Merge branch 'master' into outliner-cpp-refactor

Since rB6fdcca8de64cd70f, we need at least OpenImageIO 2.1.12 to build
Blender.

.clang-tidy

@@ -15,7 +15,6 @@ Checks:  >
 
   -readability-misleading-indentation,
 
-  -readability-redundant-member-init,
   -readability-use-anyofallof,
 
   -readability-function-cognitive-complexity,
@@ -33,4 +32,20 @@ Checks:  >
   -bugprone-exception-escape,
   -bugprone-redundant-branch-condition,
 
+  modernize-*,
+  -modernize-use-auto,
+  -modernize-use-trailing-return-type,
+  -modernize-deprecated-headers,
+  -modernize-avoid-c-arrays,
+  -modernize-use-equals-default,
+  -modernize-use-nodiscard,
+  -modernize-use-using,
+  -modernize-loop-convert,
+  -modernize-pass-by-value,
+  -modernize-use-default-member-init,
+  -modernize-raw-string-literal,
+  -modernize-avoid-bind,
+  -modernize-use-override,
+  -modernize-use-transparent-functors,
+
 WarningsAsErrors: '*'

.git-blame-ignore-revs

@@ -0,0 +1,93 @@
+# git config blame.ignoreRevsFile .git-blame-ignore-revs
+#
+# After running the above, commits listed in this file will be
+# ignored by git blame. The blame will be shifted to the person
+# who edited the line(s) before the ignored commit.
+#
+# To disable this ignorance for a command, run as follows
+# git blame --ignore-revs-file="" <other options>
+#
+# Changes that belong here:
+# - Massive comment, doxy-sections, or spelling corrections.
+# - Clang-format, PEP8 or other automated changes which are *strictly* "no functional change".
+# - Several smaller commits should be added to this list at once, because adding
+#   one extra commit (to edit this file) after every small cleanup is noisy.
+#
+# Note:
+# - The comment above the SHA should be the first line of the commit.
+# - It is fine to pack together similar commits if they have the same explanatory comment.
+# - Use only 40 character git SHAs; not smaller ones, not prefixed with rB.
+#
+# https://git-scm.com/docs/git-blame/2.23.0
+
+# white space commit. (2 spaces -> tab).
+0a3694cd6ebec710da7110e9f168a72d47c71ee0
+
+# Cycles: Cleanup, spacing after preprocessor
+cb4b5e12abf1fc6cf9ffc0944e0a1bc406286c63
+
+# ClangFormat: apply to source, most of intern
+e12c08e8d170b7ca40f204a5b0423c23a9fbc2c1
+
+# Code Style: use "#pragma once" in source directory
+91694b9b58ab953f3b313be9389cc1303e472fc2
+
+# Code Style: use "#pragma once" in some newer headers
+8198dbb888856b8c11757586df02aca15f132f90
+
+# Code Style: use "#pragma once" in intern/ghost
+1b1129f82a9cf316b54fbc025f8cfcc1a74b8589
+
+# Cleanup: mostly comments, use doxy syntax & typos
+e0cb02587012b4b2f4b18363dc7d0a7da2c02093
+
+# Cleanup: use C comments for descriptive text
+2abfcebb0eb7989e3d1e7d03f37ecf5c088210af
+
+# use lowercase for cmake builtin names and macros, remove contents in else() and endif() which is no longer needed.
+afacd184982e58a9c830a3d5366e25983939a7ba
+
+# Spelling: It's Versus Its
+3a7fd309fce89213b0224b3c6807adb2d1fe7ca8
+
+# Spelling: Then Versus Than
+d1eefc421544e2ea632fb35cb6bcaade4c39ce6b
+
+# Spelling: Miscellaneous
+84ef3b80de4915a24a9fd2fd214d0fa44e59b854
+
+# Spelling: Loose Versus Lose
+c0a6bc19794c69843c38451c762e91bc10136e0f
+
+# Spelling: Apart Versus A Part
+3d26cd01b9ba6381eb165e11536345ae652dfb41
+
+# Cleanup: use 2 space indentation for CMake
+3076d95ba441cd32706a27d18922a30f8fd28b8a
+
+# Cleanup: use over-line for doxy comments
+4b188bb08cf5aaae3c68ab57bbcfa037eef1ac10
+
+# Cleanup: General comment style clean up of graph_edit.c and fcurve.c
+0105f146bb40bd609ccbda3d3f6aeb8e14ad3f9e
+
+# Cleanup: pep8 (indentation, spacing, long lines)
+41d2d6da0c96d351b47acb64d3e0decdba16cb16
+
+# Cleanup: pep8, blank lines
+bab9de2a52929fe2b45ecddb1eb09da3378e303b
+
+# Cleanup: PEP8 for python changes
+1e7e94588daa66483190f45a9de5e98228f80e05
+
+# GPencil: Cleanup pep8
+a09cc3ee1a99f2cd5040bbf30c8ab8c588bb2bb1
+
+# Cleanup: trailing space, remove tabs, pep8
+c42a6b77b52560d257279de2cb624b4ef2c0d24c
+
+# Cleanup: use C style doxygen comments
+8c1726918374e1d2d2123e17bae8db5aadde3433
+
+# Cleanup: use doxy sections for imbuf
+c207f7c22e1439e0b285fba5d2c072bdae23f981

CMakeLists.txt

@@ -203,7 +203,7 @@ option(WITH_OPENVDB       "Enable features relying on OpenVDB" ON)
 option(WITH_OPENVDB_BLOSC "Enable blosc compression for OpenVDB, only enable if OpenVDB was built with blosc support" ON)
 option(WITH_OPENVDB_3_ABI_COMPATIBLE "Assume OpenVDB library has been compiled with version 3 ABI compatibility" OFF)
 mark_as_advanced(WITH_OPENVDB_3_ABI_COMPATIBLE)
-option(WITH_NANOVDB       "Enable usage of NanoVDB data structure for accelerated rendering on the GPU" OFF)
+option(WITH_NANOVDB       "Enable usage of NanoVDB data structure for rendering on the GPU" ON)
 
 # GHOST Windowing Library Options
 option(WITH_GHOST_DEBUG   "Enable debugging output for the GHOST library" OFF)
@@ -526,10 +526,10 @@ if(CMAKE_COMPILER_IS_GNUCC OR CMAKE_C_COMPILER_ID MATCHES "Clang")
         # Silence the warning that object-size is not effective in -O0.
         set(_asan_defaults "${_asan_defaults}")
       else()
-        set(_asan_defaults "${_asan_defaults} -fsanitize=object-size")
+        string(APPEND _asan_defaults " -fsanitize=object-size")
       endif()
     else()
-      set(_asan_defaults "${_asan_defaults} -fsanitize=leak -fsanitize=object-size")
+      string(APPEND _asan_defaults " -fsanitize=leak -fsanitize=object-size")
     endif()
 
     set(COMPILER_ASAN_CFLAGS "${_asan_defaults}" CACHE STRING "C flags for address sanitizer")
@@ -570,6 +570,11 @@ if(CMAKE_COMPILER_IS_GNUCC OR CMAKE_C_COMPILER_ID MATCHES "Clang")
   endif()
 endif()
 
+if(CMAKE_COMPILER_IS_GNUCC OR CMAKE_C_COMPILER_ID MATCHES "Clang")
+  option(WITH_COMPILER_SHORT_FILE_MACRO "Make paths in macros like __FILE__ relative to top level source and build directories." ON)
+  mark_as_advanced(WITH_COMPILER_SHORT_FILE_MACRO)
+endif()
+
 if(WIN32)
   # Use hardcoded paths or find_package to find externals
   option(WITH_WINDOWS_FIND_MODULES "Use find_package to locate libraries" OFF)
@@ -858,11 +863,11 @@ if(NOT CMAKE_BUILD_TYPE MATCHES "Release")
       # Since linker flags are not set, all compiler checks and `find_package`
       # calls that rely on `try_compile` will fail.
       # See CMP0066 also.
-      set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} ${COMPILER_ASAN_CFLAGS}")
-      set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO} ${COMPILER_ASAN_CFLAGS}")
+      string(APPEND CMAKE_C_FLAGS_DEBUG " ${COMPILER_ASAN_CFLAGS}")
+      string(APPEND CMAKE_C_FLAGS_RELWITHDEBINFO " ${COMPILER_ASAN_CFLAGS}")
 
-      set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${COMPILER_ASAN_CXXFLAGS}")
-      set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} ${COMPILER_ASAN_CXXFLAGS}")
+      string(APPEND CMAKE_CXX_FLAGS_DEBUG " ${COMPILER_ASAN_CXXFLAGS}")
+      string(APPEND CMAKE_CXX_FLAGS_RELWITHDEBINFO " ${COMPILER_ASAN_CXXFLAGS}")
     endif()
     if(MSVC)
       set(COMPILER_ASAN_LINKER_FLAGS "/FUNCTIONPADMIN:6")
@@ -941,11 +946,11 @@ endif()
 # Do it globally, SSE2 is required for quite some time now.
 # Doing it now allows to use SSE/SSE2 in inline headers.
 if(SUPPORT_SSE_BUILD)
-  set(PLATFORM_CFLAGS " ${COMPILER_SSE_FLAG} ${PLATFORM_CFLAGS}")
+  string(PREPEND PLATFORM_CFLAGS "${COMPILER_SSE_FLAG} ")
   add_definitions(-D__SSE__ -D__MMX__)
 endif()
 if(SUPPORT_SSE2_BUILD)
-  set(PLATFORM_CFLAGS " ${PLATFORM_CFLAGS} ${COMPILER_SSE2_FLAG}")
+  string(APPEND PLATFORM_CFLAGS " ${COMPILER_SSE2_FLAG}")
   add_definitions(-D__SSE2__)
   if(NOT SUPPORT_SSE_BUILD) # don't double up
     add_definitions(-D__MMX__)
@@ -1157,8 +1162,8 @@ if(WITH_OPENMP)
 
   if(OPENMP_FOUND)
     if(NOT WITH_OPENMP_STATIC)
-      set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OpenMP_C_FLAGS}")
-      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
+      string(APPEND CMAKE_C_FLAGS " ${OpenMP_C_FLAGS}")
+      string(APPEND CMAKE_CXX_FLAGS " ${OpenMP_CXX_FLAGS}")
     else()
       # Typically avoid adding flags as defines but we can't
       # pass OpenMP flags to the linker for static builds, meaning
@@ -1517,6 +1522,7 @@ elseif(CMAKE_C_COMPILER_ID MATCHES "Clang")
   ADD_CHECK_C_COMPILER_FLAG(C_REMOVE_STRICT_FLAGS C_WARN_NO_UNUSED_PARAMETER -Wno-unused-parameter)
   ADD_CHECK_C_COMPILER_FLAG(C_REMOVE_STRICT_FLAGS C_WARN_NO_UNUSED_VARIABLE  -Wno-unused-variable)
   ADD_CHECK_C_COMPILER_FLAG(C_REMOVE_STRICT_FLAGS C_WARN_NO_UNUSED_MACROS    -Wno-unused-macros)
+  ADD_CHECK_C_COMPILER_FLAG(C_REMOVE_STRICT_FLAGS C_WARN_NO_MISLEADING_INDENTATION    -Wno-misleading-indentation)
 
   ADD_CHECK_C_COMPILER_FLAG(C_REMOVE_STRICT_FLAGS C_WARN_NO_MISSING_VARIABLE_DECLARATIONS -Wno-missing-variable-declarations)
   ADD_CHECK_C_COMPILER_FLAG(C_REMOVE_STRICT_FLAGS C_WARN_NO_INCOMPAT_PTR_DISCARD_QUAL -Wno-incompatible-pointer-types-discards-qualifiers)
@@ -1527,6 +1533,7 @@ elseif(CMAKE_C_COMPILER_ID MATCHES "Clang")
   ADD_CHECK_C_COMPILER_FLAG(C_REMOVE_STRICT_FLAGS C_WARN_NO_UNDEF -Wno-undef)
   ADD_CHECK_C_COMPILER_FLAG(C_REMOVE_STRICT_FLAGS C_WARN_NO_MISSING_NORETURN -Wno-missing-noreturn)
 
+  ADD_CHECK_CXX_COMPILER_FLAG(CXX_REMOVE_STRICT_FLAGS CXX_WARN_NO_UNUSED_PARAMETER -Wno-unused-parameter)
   ADD_CHECK_CXX_COMPILER_FLAG(CXX_REMOVE_STRICT_FLAGS CXX_WARN_NO_UNUSED_PRIVATE_FIELD -Wno-unused-private-field)
   ADD_CHECK_CXX_COMPILER_FLAG(CXX_REMOVE_STRICT_FLAGS CXX_WARN_NO_CXX11_NARROWING -Wno-c++11-narrowing)
   ADD_CHECK_CXX_COMPILER_FLAG(CXX_REMOVE_STRICT_FLAGS CXX_WARN_NO_NON_VIRTUAL_DTOR -Wno-non-virtual-dtor)
@@ -1536,6 +1543,7 @@ elseif(CMAKE_C_COMPILER_ID MATCHES "Clang")
   ADD_CHECK_CXX_COMPILER_FLAG(CXX_REMOVE_STRICT_FLAGS CXX_WARN_NO_UNUSED_TYPEDEFS -Wno-unused-local-typedefs)
   ADD_CHECK_CXX_COMPILER_FLAG(CXX_REMOVE_STRICT_FLAGS CXX_WARN_NO_UNDEFINED_VAR_TEMPLATE -Wno-undefined-var-template)
   ADD_CHECK_CXX_COMPILER_FLAG(CXX_REMOVE_STRICT_FLAGS CXX_WARN_NO_INSTANTIATION_AFTER_SPECIALIZATION -Wno-instantiation-after-specialization)
+  ADD_CHECK_CXX_COMPILER_FLAG(CXX_REMOVE_STRICT_FLAGS CXX_WARN_NO_MISLEADING_INDENTATION    -Wno-misleading-indentation)
 
 elseif(CMAKE_C_COMPILER_ID MATCHES "Intel")
 
@@ -1548,8 +1556,8 @@ elseif(CMAKE_C_COMPILER_ID MATCHES "Intel")
   ADD_CHECK_CXX_COMPILER_FLAG(CXX_WARNINGS CXX_WARN_NO_SIGN_COMPARE -Wno-sign-compare)
 
   # disable numbered, false positives
-  set(C_WARNINGS "${C_WARNINGS} -wd188,186,144,913,556,858,597,177,1292,167,279,592,94,2722,3199")
-  set(CXX_WARNINGS "${CXX_WARNINGS} -wd188,186,144,913,556,858,597,177,1292,167,279,592,94,2722,3199")
+  string(APPEND C_WARNINGS " -wd188,186,144,913,556,858,597,177,1292,167,279,592,94,2722,3199")
+  string(APPEND CXX_WARNINGS " -wd188,186,144,913,556,858,597,177,1292,167,279,592,94,2722,3199")
 elseif(CMAKE_C_COMPILER_ID MATCHES "MSVC")
   # most msvc warnings are C & C++
   set(_WARNINGS
@@ -1580,7 +1588,7 @@ elseif(CMAKE_C_COMPILER_ID MATCHES "MSVC")
 
   if(MSVC_VERSION GREATER_EQUAL 1911)
     # see https://docs.microsoft.com/en-us/cpp/error-messages/compiler-warnings/c5038?view=vs-2017
-    set(_WARNINGS "${_WARNINGS} /w35038") # order of initialization in c++ constructors
+    string(APPEND _WARNINGS " /w35038") # order of initialization in c++ constructors
   endif()
 
   string(REPLACE ";" " " _WARNINGS "${_WARNINGS}")
@@ -1621,19 +1629,19 @@ if(WITH_PYTHON)
 endif()
 
 if(MSVC)
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /std:c++17")
+  string(APPEND CMAKE_CXX_FLAGS " /std:c++17")
   # Make MSVC properly report the value of the __cplusplus preprocessor macro
   # Available MSVC 15.7 (1914) and up, without this it reports 199711L regardless
   # of the C++ standard chosen above
   if(MSVC_VERSION GREATER 1913)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Zc:__cplusplus")
+    string(APPEND CMAKE_CXX_FLAGS " /Zc:__cplusplus")
   endif()
 elseif(
   CMAKE_COMPILER_IS_GNUCC OR
   CMAKE_C_COMPILER_ID MATCHES "Clang" OR
   CMAKE_C_COMPILER_ID MATCHES "Intel"
 )
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17")
+  string(APPEND CMAKE_CXX_FLAGS " -std=c++17")
 else()
   message(FATAL_ERROR "Unknown compiler ${CMAKE_C_COMPILER_ID}, can't enable C++17 build")
 endif()
@@ -1646,12 +1654,47 @@ if(
   (CMAKE_C_COMPILER_ID MATCHES "Intel")
 )
   # Use C11 + GNU extensions, works with GCC, Clang, ICC
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=gnu11")
+  string(APPEND CMAKE_C_FLAGS " -std=gnu11")
 endif()
 
 if(UNIX AND NOT APPLE)
   if(NOT WITH_CXX11_ABI)
-    set(PLATFORM_CFLAGS "${PLATFORM_CFLAGS} -D_GLIBCXX_USE_CXX11_ABI=0")
+    string(APPEND PLATFORM_CFLAGS " -D_GLIBCXX_USE_CXX11_ABI=0")
+  endif()
+endif()
+
+if(WITH_COMPILER_SHORT_FILE_MACRO)
+  # Use '-fmacro-prefix-map' for Clang and GCC (MSVC doesn't support this).
+  ADD_CHECK_C_COMPILER_FLAG(C_PREFIX_MAP_FLAGS C_MACRO_PREFIX_MAP -fmacro-prefix-map=foo=bar)
+  ADD_CHECK_CXX_COMPILER_FLAG(CXX_PREFIX_MAP_FLAGS CXX_MACRO_PREFIX_MAP -fmacro-prefix-map=foo=bar)
+  if(C_MACRO_PREFIX_MAP AND CXX_MACRO_PREFIX_MAP)
+    if(APPLE)
+      if(XCODE AND ${XCODE_VERSION} VERSION_LESS 12.0)
+      # Developers may have say LLVM Clang-10.0.1 toolchain (which supports the flag)
+      # with Xcode-11 (the Clang of which doesn't support the flag).
+        message(WARNING
+          "-fmacro-prefix-map flag is NOT supported by Clang shipped with Xcode-${XCODE_VERSION}."
+          " Some Xcode functionality in Product menu may not work. Disabling WITH_COMPILER_SHORT_FILE_MACRO."
+        )
+        set(WITH_COMPILER_SHORT_FILE_MACRO OFF)
+      endif()
+    endif()
+    if(WITH_COMPILER_SHORT_FILE_MACRO)
+      path_ensure_trailing_slash(_src_dir "${CMAKE_SOURCE_DIR}")
+      path_ensure_trailing_slash(_bin_dir "${CMAKE_BINARY_DIR}")
+      # Keep this variable so it can be stripped from build-info.
+      set(PLATFORM_CFLAGS_FMACRO_PREFIX_MAP
+        "-fmacro-prefix-map=\"${_src_dir}\"=\"\" -fmacro-prefix-map=\"${_bin_dir}\"=\"\"")
+      string(APPEND PLATFORM_CFLAGS " ${PLATFORM_CFLAGS_FMACRO_PREFIX_MAP}")
+      unset(_src_dir)
+      unset(_bin_dir)
+    endif()
+  else()
+    message(WARNING
+      "-fmacro-prefix-map flag is NOT supported by C/C++ compiler."
+      " Disabling WITH_COMPILER_SHORT_FILE_MACRO."
+    )
+    set(WITH_COMPILER_SHORT_FILE_MACRO OFF)
   endif()
 endif()
 
@@ -1755,7 +1798,7 @@ if(FIRST_RUN)
     set(_msg "  - ${_setting}")
     string(LENGTH "${_msg}" _len)
     while("32" GREATER "${_len}")
-      set(_msg "${_msg} ")
+      string(APPEND _msg " ")
       math(EXPR _len "${_len} + 1")
     endwhile()
 
@@ -1773,24 +1816,24 @@ if(FIRST_RUN)
   message(STATUS "C++ Compiler: \"${CMAKE_CXX_COMPILER_ID}\"")
 
   info_cfg_text("Build Options:")
+  info_cfg_option(WITH_ALEMBIC)
   info_cfg_option(WITH_BULLET)
-  info_cfg_option(WITH_IK_SOLVER)
-  info_cfg_option(WITH_IK_ITASC)
-  info_cfg_option(WITH_OPENCOLLADA)
-  info_cfg_option(WITH_FFTW3)
-  info_cfg_option(WITH_INTERNATIONAL)
-  info_cfg_option(WITH_INPUT_NDOF)
   info_cfg_option(WITH_CYCLES)
+  info_cfg_option(WITH_FFTW3)
   info_cfg_option(WITH_FREESTYLE)
+  info_cfg_option(WITH_GMP)
+  info_cfg_option(WITH_IK_ITASC)
+  info_cfg_option(WITH_IK_SOLVER)
+  info_cfg_option(WITH_INPUT_NDOF)
+  info_cfg_option(WITH_INTERNATIONAL)
+  info_cfg_option(WITH_OPENCOLLADA)
   info_cfg_option(WITH_OPENCOLORIO)
-  info_cfg_option(WITH_XR_OPENXR)
   info_cfg_option(WITH_OPENIMAGEDENOISE)
   info_cfg_option(WITH_OPENVDB)
-  info_cfg_option(WITH_ALEMBIC)
   info_cfg_option(WITH_QUADRIFLOW)
-  info_cfg_option(WITH_USD)
   info_cfg_option(WITH_TBB)
-  info_cfg_option(WITH_GMP)
+  info_cfg_option(WITH_USD)
+  info_cfg_option(WITH_XR_OPENXR)
 
   info_cfg_text("Compiler Options:")
   info_cfg_option(WITH_BUILDINFO)
@@ -1798,58 +1841,58 @@ if(FIRST_RUN)
 
   info_cfg_text("System Options:")
   info_cfg_option(WITH_INSTALL_PORTABLE)
+  info_cfg_option(WITH_MEM_JEMALLOC)
+  info_cfg_option(WITH_MEM_VALGRIND)
+  info_cfg_option(WITH_SYSTEM_GLEW)
   info_cfg_option(WITH_X11_ALPHA)
   info_cfg_option(WITH_X11_XF86VMODE)
   info_cfg_option(WITH_X11_XFIXES)
   info_cfg_option(WITH_X11_XINPUT)
-  info_cfg_option(WITH_MEM_JEMALLOC)
-  info_cfg_option(WITH_MEM_VALGRIND)
-  info_cfg_option(WITH_SYSTEM_GLEW)
 
   info_cfg_text("Image Formats:")
-  info_cfg_option(WITH_OPENIMAGEIO)
   info_cfg_option(WITH_IMAGE_CINEON)
   info_cfg_option(WITH_IMAGE_DDS)
   info_cfg_option(WITH_IMAGE_HDR)
   info_cfg_option(WITH_IMAGE_OPENEXR)
   info_cfg_option(WITH_IMAGE_OPENJPEG)
   info_cfg_option(WITH_IMAGE_TIFF)
+  info_cfg_option(WITH_OPENIMAGEIO)
 
   info_cfg_text("Audio:")
-  info_cfg_option(WITH_OPENAL)
-  info_cfg_option(WITH_SDL)
-  info_cfg_option(WITH_SDL_DYNLOAD)
-  info_cfg_option(WITH_JACK)
-  info_cfg_option(WITH_JACK_DYNLOAD)
   info_cfg_option(WITH_CODEC_AVI)
   info_cfg_option(WITH_CODEC_FFMPEG)
   info_cfg_option(WITH_CODEC_SNDFILE)
+  info_cfg_option(WITH_JACK)
+  info_cfg_option(WITH_JACK_DYNLOAD)
+  info_cfg_option(WITH_OPENAL)
+  info_cfg_option(WITH_SDL)
+  info_cfg_option(WITH_SDL_DYNLOAD)
 
   info_cfg_text("Compression:")
   info_cfg_option(WITH_LZMA)
   info_cfg_option(WITH_LZO)
 
   info_cfg_text("Python:")
+  if(APPLE)
+    info_cfg_option(WITH_PYTHON_FRAMEWORK)
+  endif()
   info_cfg_option(WITH_PYTHON_INSTALL)
   info_cfg_option(WITH_PYTHON_INSTALL_NUMPY)
   info_cfg_option(WITH_PYTHON_MODULE)
   info_cfg_option(WITH_PYTHON_SAFETY)
-  if(APPLE)
-    info_cfg_option(WITH_PYTHON_FRAMEWORK)
-  endif()
 
   info_cfg_text("Modifiers:")
-  info_cfg_option(WITH_MOD_REMESH)
   info_cfg_option(WITH_MOD_FLUID)
   info_cfg_option(WITH_MOD_OCEANSIM)
+  info_cfg_option(WITH_MOD_REMESH)
 
   info_cfg_text("OpenGL:")
-  info_cfg_option(WITH_GLEW_ES)
-  info_cfg_option(WITH_GL_EGL)
-  info_cfg_option(WITH_GL_PROFILE_ES20)
   if(WIN32)
     info_cfg_option(WITH_GL_ANGLE)
   endif()
+  info_cfg_option(WITH_GL_EGL)
+  info_cfg_option(WITH_GL_PROFILE_ES20)
+  info_cfg_option(WITH_GLEW_ES)
 
   info_cfg_text("")
 

build_files/build_environment/CMakeLists.txt

@@ -85,6 +85,7 @@ include(cmake/flexbison.cmake)
 include(cmake/osl.cmake)
 include(cmake/tbb.cmake)
 include(cmake/openvdb.cmake)
+include(cmake/nanovdb.cmake)
 include(cmake/python.cmake)
 include(cmake/python_site_packages.cmake)
 include(cmake/package_python.cmake)

build_files/build_environment/cmake/check_software.cmake

@@ -43,7 +43,7 @@ if(UNIX)
 
   if(APPLE)
     if(NOT EXISTS "/usr/local/opt/bison/bin/bison")
-      set(_software_missing "${_software_missing} bison")
+      string(APPEND _software_missing " bison")
     endif()
   endif()
 

build_files/build_environment/cmake/harvest.cmake

@@ -146,10 +146,8 @@ harvest(openjpeg/lib openjpeg/lib "*.a")
 harvest(opensubdiv/include opensubdiv/include "*.h")
 harvest(opensubdiv/lib opensubdiv/lib "*.a")
 harvest(openvdb/include/openvdb openvdb/include/openvdb "*.h")
-if(WITH_NANOVDB)
-  harvest(openvdb/nanovdb nanovdb/include/nanovdb "*.h")
-endif()
 harvest(openvdb/lib openvdb/lib "*.a")
+harvest(nanovdb/nanovdb nanovdb/include/nanovdb "*.h")
 harvest(xr_openxr_sdk/include/openxr xr_openxr_sdk/include/openxr "*.h")
 harvest(xr_openxr_sdk/lib xr_openxr_sdk/lib "*.a")
 harvest(osl/bin osl/bin "oslc")

build_files/build_environment/cmake/nanovdb.cmake

@@ -0,0 +1,54 @@
+# ***** BEGIN GPL LICENSE BLOCK *****
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ***** END GPL LICENSE BLOCK *****
+
+set(NANOVDB_EXTRA_ARGS
+   # NanoVDB is header-only, so only need the install target
+  -DNANOVDB_BUILD_UNITTESTS=OFF
+  -DNANOVDB_BUILD_EXAMPLES=OFF
+  -DNANOVDB_BUILD_BENCHMARK=OFF
+  -DNANOVDB_BUILD_DOCS=OFF
+  -DNANOVDB_BUILD_TOOLS=OFF
+  -DNANOVDB_CUDA_KEEP_PTX=OFF
+   # Do not need to include any of the dependencies because of this
+  -DNANOVDB_USE_OPENVDB=OFF
+  -DNANOVDB_USE_OPENGL=OFF
+  -DNANOVDB_USE_OPENCL=OFF
+  -DNANOVDB_USE_CUDA=OFF
+  -DNANOVDB_USE_TBB=OFF
+  -DNANOVDB_USE_BLOSC=OFF
+  -DNANOVDB_USE_ZLIB=OFF
+  -DNANOVDB_USE_OPTIX=OFF
+  -DNANOVDB_ALLOW_FETCHCONTENT=OFF
+)
+
+ExternalProject_Add(nanovdb
+  URL ${NANOVDB_URI}
+  DOWNLOAD_DIR ${DOWNLOAD_DIR}
+  URL_HASH MD5=${NANOVDB_HASH}
+  PREFIX ${BUILD_DIR}/nanovdb
+  SOURCE_SUBDIR nanovdb
+  CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${LIBDIR}/nanovdb ${DEFAULT_CMAKE_FLAGS} ${NANOVDB_EXTRA_ARGS}
+  INSTALL_DIR ${LIBDIR}/nanovdb
+)
+
+if(WIN32)
+  ExternalProject_Add_Step(nanovdb after_install
+    COMMAND ${CMAKE_COMMAND} -E copy_directory ${LIBDIR}/nanovdb/nanovdb ${HARVEST_TARGET}/nanovdb/include/nanovdb
+    DEPENDEES install
+  )
+endif()

build_files/build_environment/cmake/openvdb.cmake

@@ -54,20 +54,6 @@ set(OPENVDB_EXTRA_ARGS
   -DOPENVDB_CORE_STATIC=${OPENVDB_STATIC}
   -DOPENVDB_BUILD_BINARIES=Off
   -DCMAKE_DEBUG_POSTFIX=_d
-   # NanoVDB is header-only, so only need the install target
-  -DNANOVDB_BUILD_UNITTESTS=OFF
-  -DNANOVDB_BUILD_EXAMPLES=OFF
-  -DNANOVDB_BUILD_BENCHMARK=OFF
-  -DNANOVDB_BUILD_DOCS=OFF
-  -DNANOVDB_BUILD_TOOLS=OFF
-  -DNANOVDB_CUDA_KEEP_PTX=OFF
-  -DNANOVDB_USE_OPENGL=OFF
-  -DNANOVDB_USE_OPENGL=OFF
-  -DNANOVDB_USE_CUDA=OFF
-  -DNANOVDB_USE_TBB=OFF
-  -DNANOVDB_USE_OPTIX=OFF
-  -DNANOVDB_USE_OPENVDB=OFF
-  -DNANOVDB_ALLOW_FETCHCONTENT=OFF
 )
 
 if(WIN32)
@@ -88,18 +74,12 @@ else()
   )
 endif()
 
-if(WITH_NANOVDB)
-  set(OPENVDB_PATCH_FILE openvdb_nanovdb.diff)
-else()
-  set(OPENVDB_PATCH_FILE openvdb.diff)
-endif()
-
 ExternalProject_Add(openvdb
   URL ${OPENVDB_URI}
   DOWNLOAD_DIR ${DOWNLOAD_DIR}
   URL_HASH MD5=${OPENVDB_HASH}
   PREFIX ${BUILD_DIR}/openvdb
-  PATCH_COMMAND ${PATCH_CMD} -p 1 -d ${BUILD_DIR}/openvdb/src/openvdb < ${PATCH_DIR}/${OPENVDB_PATCH_FILE}
+  PATCH_COMMAND ${PATCH_CMD} -p 1 -d ${BUILD_DIR}/openvdb/src/openvdb < ${PATCH_DIR}/openvdb.diff
   CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${LIBDIR}/openvdb ${DEFAULT_CMAKE_FLAGS} ${OPENVDB_EXTRA_ARGS}
   INSTALL_DIR ${LIBDIR}/openvdb
 )
@@ -121,12 +101,6 @@ if(WIN32)
       COMMAND ${CMAKE_COMMAND} -E copy ${LIBDIR}/openvdb/bin/openvdb.dll ${HARVEST_TARGET}/openvdb/bin/openvdb.dll
       DEPENDEES install
     )
-    if(WITH_NANOVDB)
-      ExternalProject_Add_Step(openvdb nanovdb_install
-        COMMAND ${CMAKE_COMMAND} -E copy_directory ${LIBDIR}/openvdb/nanovdb ${HARVEST_TARGET}/nanovdb/include/nanovdb
-        DEPENDEES after_install
-      )
-    endif()
   endif()
   if(BUILD_MODE STREQUAL Debug)
     ExternalProject_Add_Step(openvdb after_install

build_files/build_environment/cmake/options.cmake

@@ -21,7 +21,6 @@ if(WIN32)
 endif()
 option(WITH_WEBP "Enable building of oiio with webp support" OFF)
 option(WITH_BOOST_PYTHON "Enable building of boost with python support" OFF)
-option(WITH_NANOVDB "Enable building of OpenVDB with NanoVDB included" OFF)
 set(MAKE_THREADS 1 CACHE STRING "Number of threads to run make with")
 
 if(NOT BUILD_MODE)
@@ -57,7 +56,7 @@ if(WIN32)
   if(MSVC_VERSION GREATER 1909)
     set(COMMON_MSVC_FLAGS "/Wv:18") #some deps with warnings as error aren't quite ready for dealing with the new 2017 warnings.
   endif()
-  set(COMMON_MSVC_FLAGS "${COMMON_MSVC_FLAGS} /bigobj")
+  string(APPEND COMMON_MSVC_FLAGS " /bigobj")
   if(WITH_OPTIMIZED_DEBUG)
     set(BLENDER_CMAKE_C_FLAGS_DEBUG "/MDd ${COMMON_MSVC_FLAGS} /O2 /Ob2 /DNDEBUG /DPSAPI_VERSION=1 /DOIIO_STATIC_BUILD /DTINYFORMAT_ALLOW_WCHAR_STRINGS")
   else()

build_files/build_environment/cmake/versions.cmake

@@ -145,15 +145,13 @@ set(TBB_VERSION 2019_U9)
 set(TBB_URI https://github.com/oneapi-src/oneTBB/archive/${TBB_VERSION}.tar.gz)
 set(TBB_HASH 26263622e9187212ec240dcf01b66207)
 
-if(WITH_NANOVDB)
-  set(OPENVDB_GIT_UID e62f7a0bf1e27397223c61ddeaaf57edf111b77f)
-  set(OPENVDB_URI https://github.com/AcademySoftwareFoundation/openvdb/archive/${OPENVDB_GIT_UID}.tar.gz)
-  set(OPENVDB_HASH 90919510bc6ccd630fedc56f748cb199)
-else()
-  set(OPENVDB_VERSION 7.0.0)
-  set(OPENVDB_URI https://github.com/AcademySoftwareFoundation/openvdb/archive/v${OPENVDB_VERSION}.tar.gz)
-  set(OPENVDB_HASH fd6c4f168282f7e0e494d290cd531fa8)
-endif()
+set(OPENVDB_VERSION 7.0.0)
+set(OPENVDB_URI https://github.com/AcademySoftwareFoundation/openvdb/archive/v${OPENVDB_VERSION}.tar.gz)
+set(OPENVDB_HASH fd6c4f168282f7e0e494d290cd531fa8)
+
+set(NANOVDB_GIT_UID e62f7a0bf1e27397223c61ddeaaf57edf111b77f)
+set(NANOVDB_URI https://github.com/AcademySoftwareFoundation/openvdb/archive/${NANOVDB_GIT_UID}.tar.gz)
+set(NANOVDB_HASH 90919510bc6ccd630fedc56f748cb199)
 
 set(IDNA_VERSION 2.9)
 set(CHARDET_VERSION 3.0.4)

build_files/build_environment/install_deps.sh

@@ -51,7 +51,7 @@ ARGS=$( \
 getopt \
 -o s:i:t:h \
 --long source:,install:,tmp:,info:,threads:,help,show-deps,no-sudo,no-build,no-confirm,\
-with-all,with-opencollada,with-jack,with-embree,with-oidn,\
+with-all,with-opencollada,with-jack,with-embree,with-oidn,with-nanovdb,\
 ver-ocio:,ver-oiio:,ver-llvm:,ver-osl:,ver-osd:,ver-openvdb:,ver-xr-openxr:,\
 force-all,force-python,force-numpy,force-boost,force-tbb,\
 force-ocio,force-openexr,force-oiio,force-llvm,force-osl,force-osd,force-openvdb,\
@@ -151,6 +151,9 @@ ARGUMENTS_INFO="\"COMMAND LINE ARGUMENTS:
     --with-oidn
         Build and install the OpenImageDenoise libraries.
 
+    --with-nanovdb
+        Build and install the NanoVDB branch of OpenVDB (instead of official release of OpenVDB).
+
     --with-jack
         Install the jack libraries.
 
@@ -435,7 +438,7 @@ _with_built_openexr=false
 
 OIIO_VERSION="2.1.15.0"
 OIIO_VERSION_SHORT="2.1"
-OIIO_VERSION_MIN="1.8"
+OIIO_VERSION_MIN="2.1.12"
 OIIO_VERSION_MAX="3.0"
 OIIO_FORCE_BUILD=false
 OIIO_FORCE_REBUILD=false
@@ -676,6 +679,10 @@ while true; do
     --with-oidn)
       WITH_OIDN=true; shift; continue
     ;;
+    --with-nanovdb)
+      WITH_NANOVDB=true;
+      shift; continue
+    ;;
     --with-jack)
       WITH_JACK=true; shift; continue;
     ;;
@@ -957,6 +964,11 @@ if [ "$WITH_ALL" = true -a "$OIDN_SKIP" = false ]; then
 fi
 if [ "$WITH_ALL" = true ]; then
   WITH_JACK=true
+  WITH_NANOVDB=true
+fi
+
+if [ "$WITH_NANOVDB" = true ]; then
+  OPENVDB_FORCE_BUILD=true
 fi
 
 
@@ -1029,11 +1041,15 @@ OSD_SOURCE=( "https://github.com/PixarAnimationStudios/OpenSubdiv/archive/v${OSD
 
 OPENVDB_USE_REPO=false
 OPENVDB_BLOSC_SOURCE=( "https://github.com/Blosc/c-blosc/archive/v${OPENVDB_BLOSC_VERSION}.tar.gz" )
-OPENVDB_SOURCE=( "https://github.com/dreamworksanimation/openvdb/archive/v${OPENVDB_VERSION}.tar.gz" )
-#~ OPENVDB_SOURCE_REPO=( "https:///dreamworksanimation/openvdb.git" )
+OPENVDB_SOURCE=( "https://github.com/AcademySoftwareFoundation/openvdb/archive/v${OPENVDB_VERSION}.tar.gz" )
+#~ OPENVDB_SOURCE_REPO=( "https://github.com/AcademySoftwareFoundation/openvdb.git" )
 #~ OPENVDB_SOURCE_REPO_UID="404659fffa659da075d1c9416e4fc939139a84ee"
 #~ OPENVDB_SOURCE_REPO_BRANCH="dev"
 
+NANOVDB_USE_REPO=false
+NANOVDB_SOURCE_REPO_UID="e62f7a0bf1e27397223c61ddeaaf57edf111b77f"
+NANOVDB_SOURCE=( "https://github.com/AcademySoftwareFoundation/openvdb/archive/${NANOVDB_SOURCE_REPO_UID}.tar.gz" )
+
 ALEMBIC_USE_REPO=false
 ALEMBIC_SOURCE=( "https://github.com/alembic/alembic/archive/${ALEMBIC_VERSION}.tar.gz" )
 # ALEMBIC_SOURCE_REPO=( "https://github.com/alembic/alembic.git" )
@@ -2594,11 +2610,115 @@ compile_BLOSC() {
 # ----------------------------------------------------------------------------
 # Build OpenVDB
 
+_init_nanovdb() {
+  _src=$SRC/openvdb-$OPENVDB_VERSION/nanovdb
+  _inst=$INST/nanovdb-$OPENVDB_VERSION_SHORT
+  _inst_shortcut=$INST/nanovdb
+}
+
+_update_deps_nanovdb() {
+  :
+}
+
+clean_nanovdb() {
+  _init_nanovdb
+  if [ -d $_inst ]; then
+    _update_deps_nanovdb
+  fi
+  _git=true  # Mere trick to prevent clean from removing $_src...
+  _clean
+}
+
+install_NanoVDB() {
+  # To be changed each time we make edits that would modify the compiled results!
+  nanovdb_magic=1
+  _init_nanovdb
+
+  # Clean install if needed!
+  magic_compile_check nanovdb-$OPENVDB_VERSION $nanovdb_magic
+  if [ $? -eq 1 ]; then
+    clean_nanovdb
+  fi
+
+  if [ ! -d $_inst ]; then
+    INFO "Installing NanoVDB v$OPENVDB_VERSION"
+    _is_building=true
+
+    # Rebuild dependencies as well!
+    _update_deps_nanovdb
+
+    prepare_inst
+
+    if [ ! -d $_src ]; then
+      ERROR "NanoVDB not found in openvdb-$OPENVDB_VERSION ($_src), exiting"
+      exit 1
+    fi
+
+    # Always refresh the whole build!
+    if [ -d build ]; then
+      rm -rf build
+    fi
+    mkdir build
+    cd build
+
+    cmake_d="-D CMAKE_BUILD_TYPE=Release"
+    cmake_d="$cmake_d -D CMAKE_INSTALL_PREFIX=$_inst"
+
+    # NanoVDB is header-only, so only need the install target
+    cmake_d="$cmake_d -D NANOVDB_BUILD_UNITTESTS=OFF"
+    cmake_d="$cmake_d -D NANOVDB_BUILD_EXAMPLES=OFF"
+    cmake_d="$cmake_d -D NANOVDB_BUILD_BENCHMARK=OFF"
+    cmake_d="$cmake_d -D NANOVDB_BUILD_DOCS=OFF"
+    cmake_d="$cmake_d -D NANOVDB_BUILD_TOOLS=OFF"
+    cmake_d="$cmake_d -D NANOVDB_CUDA_KEEP_PTX=OFF"
+
+    # Do not need to include any of the dependencies because of this
+    cmake_d="$cmake_d -D NANOVDB_USE_OPENVDB=OFF"
+    cmake_d="$cmake_d -D NANOVDB_USE_OPENGL=OFF"
+    cmake_d="$cmake_d -D NANOVDB_USE_OPENCL=OFF"
+    cmake_d="$cmake_d -D NANOVDB_USE_CUDA=OFF"
+    cmake_d="$cmake_d -D NANOVDB_USE_TBB=OFF"
+    cmake_d="$cmake_d -D NANOVDB_USE_BLOSC=OFF"
+    cmake_d="$cmake_d -D NANOVDB_USE_ZLIB=OFF"
+    cmake_d="$cmake_d -D NANOVDB_USE_OPTIX=OFF"
+    cmake_d="$cmake_d -D NANOVDB_ALLOW_FETCHCONTENT=OFF"
+
+    cmake $cmake_d $_src
+
+    make -j$THREADS install
+    make clean
+
+    #~ mkdir -p $_inst
+    #~ cp -r $_src/include $_inst/include
+
+    if [ -d $_inst ]; then
+      _create_inst_shortcut
+    else
+      ERROR "NanoVDB-v$OPENVDB_VERSION failed to install, exiting"
+      exit 1
+    fi
+
+    magic_compile_set nanovdb-$OPENVDB_VERSION $nanovdb_magic
+
+    cd $CWD
+    INFO "Done compiling NanoVDB-v$OPENVDB_VERSION!"
+    _is_building=false
+  else
+    INFO "Own NanoVDB-v$OPENVDB_VERSION is up to date, nothing to do!"
+  fi
+}
+
+
 _init_openvdb() {
   _src=$SRC/openvdb-$OPENVDB_VERSION
   _git=false
   _inst=$INST/openvdb-$OPENVDB_VERSION_SHORT
   _inst_shortcut=$INST/openvdb
+  
+  _openvdb_source=$OPENVDB_SOURCE
+  if [ "$WITH_NANOVDB" = true ]; then
+    _openvdb_source=$NANOVDB_SOURCE
+  fi
 }
 
 _update_deps_openvdb() {
@@ -2623,7 +2743,7 @@ compile_OPENVDB() {
   PRINT ""
 
   # To be changed each time we make edits that would modify the compiled result!
-  openvdb_magic=1
+  openvdb_magic=2
   _init_openvdb
 
   # Clean install if needed!
@@ -2633,7 +2753,7 @@ compile_OPENVDB() {
   fi
 
   if [ ! -d $_inst ]; then
-    INFO "Building OpenVDB-$OPENVDB_VERSION"
+    INFO "Building OpenVDB-$OPENVDB_VERSION (with NanoVDB: $WITH_NANOVDB)"
     _is_building=true
 
     # Rebuild dependencies as well!
@@ -2641,12 +2761,17 @@ compile_OPENVDB() {
 
     prepare_inst
 
-    if [ ! -d $_src -o true ]; then
+    if [ ! -d $_src ]; then
       mkdir -p $SRC
-      download OPENVDB_SOURCE[@] "$_src.tar.gz"
+      download _openvdb_source[@] "$_src.tar.gz"
 
       INFO "Unpacking OpenVDB-$OPENVDB_VERSION"
-      tar -C $SRC -xf $_src.tar.gz
+      if [ "$WITH_NANOVDB" = true ]; then
+        tar -C $SRC --transform "s,(.*/?)openvdb-$NANOVDB_SOURCE_REPO_UID[^/]*(.*),\1openvdb-$OPENVDB_VERSION\2,x" \
+            -xf $_src.tar.gz
+      else
+        tar -C $SRC -xf $_src.tar.gz
+      fi
     fi
 
     cd $_src
@@ -2660,33 +2785,40 @@ compile_OPENVDB() {
       #~ git reset --hard
     #~ fi
 
-    # Source builds here
-    cd openvdb
+    # Always refresh the whole build!
+    if [ -d build ]; then
+      rm -rf build
+    fi
+    mkdir build
+    cd build
 
-    make_d="DESTDIR=$_inst"
-    make_d="$make_d HDSO=/usr"
+    cmake_d="-D CMAKE_BUILD_TYPE=Release"
+    cmake_d="$cmake_d -D CMAKE_INSTALL_PREFIX=$_inst"
+    cmake_d="$cmake_d -D USE_STATIC_DEPENDENCIES=OFF"
+    cmake_d="$cmake_d -D OPENVDB_BUILD_BINARIES=OFF"
 
     if [ -d $INST/boost ]; then
-      make_d="$make_d BOOST_INCL_DIR=$INST/boost/include BOOST_LIB_DIR=$INST/boost/lib"
+      cmake_d="$cmake_d -D BOOST_ROOT=$INST/boost"
+      cmake_d="$cmake_d -D Boost_USE_MULTITHREADED=ON"
+      cmake_d="$cmake_d -D Boost_NO_SYSTEM_PATHS=ON"
+      cmake_d="$cmake_d -D Boost_NO_BOOST_CMAKE=ON"
     fi
     if [ -d $INST/tbb ]; then
-      make_d="$make_d TBB_ROOT=$INST/tbb TBB_USE_STATIC_LIBS=OFF"
+      cmake_d="$cmake_d -D TBB_ROOT=$INST/tbb"
     fi
 
     if [ "$_with_built_openexr" = true ]; then
-      make_d="$make_d ILMBASE_INCL_DIR=$INST/openexr/include ILMBASE_LIB_DIR=$INST/openexr/lib"
-      make_d="$make_d EXR_INCL_DIR=$INST/openexr/include EXR_LIB_DIR=$INST/openexr/lib"
-      INFO "ILMBASE_HOME=$INST/openexr"
+      cmake_d="$cmake_d -D IlmBase_ROOT=$INST/openexr"
+      cmake_d="$cmake_d -D OpenEXR_ROOT=$INST/openexr"
     fi
 
     if [ -d $INST/blosc ]; then
-      make_d="$make_d BLOSC_INCL_DIR=$INST/blosc/include BLOSC_LIB_DIR=$INST/blosc/lib"
+      cmake_d="$cmake_d -D Blosc_ROOT=$INST/blosc"
     fi
+  
+    cmake $cmake_d ..
 
-    # Build without log4cplus, glfw, python module & docs
-    make_d="$make_d LOG4CPLUS_INCL_DIR= GLFW_INCL_DIR= PYTHON_VERSION= DOXYGEN="
-
-    make -j$THREADS lib $make_d install
+    make -j$THREADS install
     make clean
 
     if [ -d $_inst ]; then
@@ -2707,6 +2839,10 @@ compile_OPENVDB() {
   fi
 
   run_ldconfig "openvdb"
+
+  if [ "$WITH_NANOVDB" = true ]; then
+    install_NanoVDB
+  fi
 }
 
 # ----------------------------------------------------------------------------
@@ -5691,6 +5827,13 @@ print_info() {
       PRINT "  $_1"
       _buildargs="$_buildargs $_1"
     fi
+    if [ -d $INST/nanovdb ]; then
+      _1="-D WITH_NANOVDB=ON"
+      _2="-D NANOVDB_ROOT_DIR=$INST/nanovdb"
+      PRINT "  $_1"
+      PRINT "  $_2"
+      _buildargs="$_buildargs $_1 $_2"
+    fi
   fi
 
   if [ "$WITH_OPENCOLLADA" = true ]; then

build_files/build_environment/patches/openvdb_nanovdb.diff

@@ -1,135 +0,0 @@
-diff -Naur orig/cmake/FindIlmBase.cmake openvdb/cmake/FindIlmBase.cmake
---- orig/cmake/FindIlmBase.cmake	2019-12-06 12:11:33 -0700
-+++ openvdb/cmake/FindIlmBase.cmake	2020-08-12 12:48:44 -0600
-@@ -217,6 +217,8 @@
-     set(CMAKE_FIND_LIBRARY_SUFFIXES ".lib")
-   endif()
-   list(APPEND CMAKE_FIND_LIBRARY_SUFFIXES "${_IlmBase_Version_Suffix}.lib")
-+  list(APPEND CMAKE_FIND_LIBRARY_SUFFIXES "_s.lib")
-+  list(APPEND CMAKE_FIND_LIBRARY_SUFFIXES "_s_d.lib")
- else()
-   if(ILMBASE_USE_STATIC_LIBS)
-     set(CMAKE_FIND_LIBRARY_SUFFIXES ".a")
-diff -Naur orig/cmake/FindOpenEXR.cmake openvdb/cmake/FindOpenEXR.cmake
---- orig/cmake/FindOpenEXR.cmake	2019-12-06 12:11:33 -0700
-+++ openvdb/cmake/FindOpenEXR.cmake	2020-08-12 12:48:44 -0600
-@@ -210,6 +210,8 @@
-     set(CMAKE_FIND_LIBRARY_SUFFIXES ".lib")
-   endif()
-   list(APPEND CMAKE_FIND_LIBRARY_SUFFIXES "${_OpenEXR_Version_Suffix}.lib")
-+  list(APPEND CMAKE_FIND_LIBRARY_SUFFIXES "_s.lib")
-+  list(APPEND CMAKE_FIND_LIBRARY_SUFFIXES "_s_d.lib")
- else()
-   if(OPENEXR_USE_STATIC_LIBS)
-     set(CMAKE_FIND_LIBRARY_SUFFIXES ".a")
-diff -Naur orig/openvdb/openvdb/CMakeLists.txt openvdb/openvdb/openvdb/CMakeLists.txt
---- orig/openvdb/openvdb/CMakeLists.txt	2019-12-06 12:11:33 -0700
-+++ openvdb/openvdb/openvdb/CMakeLists.txt	2020-08-12 14:12:26 -0600
-@@ -105,7 +105,9 @@
-   #        http://boost.2283326.n4.nabble.com/CMake-config-scripts-broken-in-1-70-td4708957.html
-   #        https://github.com/boostorg/boost_install/commit/160c7cb2b2c720e74463865ef0454d4c4cd9ae7c
-   set(BUILD_SHARED_LIBS ON)
--  set(Boost_USE_STATIC_LIBS OFF)
-+  if(NOT WIN32) # blender links boost statically on windows
-+    set(Boost_USE_STATIC_LIBS OFF)
-+  endif()
- endif()
- 
- find_package(Boost ${MINIMUM_BOOST_VERSION} REQUIRED COMPONENTS iostreams system)
-@@ -193,6 +195,7 @@
-   if(OPENVDB_DISABLE_BOOST_IMPLICIT_LINKING)
-     add_definitions(-DBOOST_ALL_NO_LIB)
-   endif()
-+  add_definitions(-D__TBB_NO_IMPLICIT_LINKAGE -DOPENVDB_OPENEXR_STATICLIB)
- endif()
- 
- # @todo Should be target definitions
-@@ -383,7 +386,12 @@
- # imported targets.
- 
- if(OPENVDB_CORE_SHARED)
--  add_library(openvdb_shared SHARED ${OPENVDB_LIBRARY_SOURCE_FILES})
-+  if(WIN32)
-+    configure_file(version.rc.in ${CMAKE_CURRENT_BINARY_DIR}/version.rc @ONLY)
-+    add_library(openvdb_shared SHARED ${OPENVDB_LIBRARY_SOURCE_FILES} ${CMAKE_CURRENT_BINARY_DIR}/version.rc)
-+  else()
-+    add_library(openvdb_shared SHARED ${OPENVDB_LIBRARY_SOURCE_FILES})
-+  endif()
- endif()
- 
- if(OPENVDB_CORE_STATIC)
-diff -Naur orig/openvdb/openvdb/version.rc.in openvdb/openvdb/openvdb/version.rc.in
---- orig/openvdb/openvdb/version.rc.in	1969-12-31 17:00:00 -0700
-+++ openvdb/openvdb/openvdb/version.rc.in	2020-08-12 14:15:01 -0600
-@@ -0,0 +1,48 @@
-+#include <winver.h>
-+
-+#define VER_FILEVERSION             @OpenVDB_MAJOR_VERSION@,@OpenVDB_MINOR_VERSION@,@OpenVDB_PATCH_VERSION@,0
-+#define VER_FILEVERSION_STR         "@OpenVDB_MAJOR_VERSION@.@OpenVDB_MINOR_VERSION@.@OpenVDB_PATCH_VERSION@.0\0"
-+
-+#define VER_PRODUCTVERSION          @OpenVDB_MAJOR_VERSION@,@OpenVDB_MINOR_VERSION@,@OpenVDB_PATCH_VERSION@,0
-+#define VER_PRODUCTVERSION_STR      "@OpenVDB_MAJOR_VERSION@.@OpenVDB_MINOR_VERSION@\0"
-+
-+#ifndef DEBUG
-+#define VER_DEBUG                   0
-+#else
-+#define VER_DEBUG                   VS_FF_DEBUG
-+#endif
-+
-+VS_VERSION_INFO VERSIONINFO
-+FILEVERSION     VER_FILEVERSION
-+PRODUCTVERSION  VER_PRODUCTVERSION
-+FILEFLAGSMASK   VS_FFI_FILEFLAGSMASK
-+FILEFLAGS       (VER_DEBUG)
-+FILEOS          VOS__WINDOWS32
-+FILETYPE        VFT_DLL
-+FILESUBTYPE     VFT2_UNKNOWN
-+BEGIN
-+    BLOCK "StringFileInfo"
-+    BEGIN
-+        BLOCK "040904E4"
-+        BEGIN
-+            VALUE "FileDescription",  "OpenVDB"
-+            VALUE "FileVersion",      VER_FILEVERSION_STR
-+            VALUE "InternalName",     "OpenVDB"
-+            VALUE "ProductName",      "OpenVDB"
-+            VALUE "ProductVersion",   VER_PRODUCTVERSION_STR
-+        END
-+    END
-+
-+    BLOCK "VarFileInfo"
-+    BEGIN
-+        /* The following line should only be modified for localized versions.     */
-+        /* It consists of any number of WORD,WORD pairs, with each pair           */
-+        /* describing a language,codepage combination supported by the file.      */
-+        /*                                                                        */
-+        /* For example, a file might have values "0x409,1252" indicating that it  */
-+        /* supports English language (0x409) in the Windows ANSI codepage (1252). */
-+
-+        VALUE "Translation", 0x409, 1252
-+
-+    END
-+END
-diff -Naur openvdb-original/CMakeLists.txt openvdb/CMakeLists.txt
---- openvdb-original/CMakeLists.txt	2020-08-27 03:34:02.000000000 +0200
-+++ openvdb/CMakeLists.txt	2020-09-02 10:56:21.665735244 +0200
-@@ -68,6 +68,7 @@
- option(OPENVDB_INSTALL_HOUDINI_PYTHONRC [=[Install a Houdini startup script that sets
- the visibilty of OpenVDB nodes and their native equivalents.]=] OFF)
- option(OPENVDB_BUILD_MAYA_PLUGIN "Build the Maya plugin" OFF)
-+option(OPENVDB_BUILD_NANOVDB "Build nanovdb" ON)
- option(OPENVDB_ENABLE_RPATH "Build with RPATH information" ON)
- option(OPENVDB_CXX_STRICT "Enable or disable pre-defined compiler warnings" OFF)
- option(OPENVDB_CODE_COVERAGE "Enable code coverage. This also overrides CMAKE_BUILD_TYPE to Debug" OFF)
-@@ -740,6 +741,10 @@
-   add_subdirectory(openvdb_maya)
- endif()
- 
-+if(OPENVDB_BUILD_NANOVDB)
-+  add_subdirectory(nanovdb)
-+endif()
-+
- ##########################################################################
- 
- add_custom_target(uninstall
- 

build_files/cmake/Modules/FindClangTidy.cmake

@@ -43,7 +43,10 @@ find_program(CLANG_TIDY_EXECUTABLE
     ${_clang_tidy_SEARCH_DIRS}
 )
 
-if(CLANG_TIDY_EXECUTABLE)
+if(CLANG_TIDY_EXECUTABLE AND NOT EXISTS ${CLANG_TIDY_EXECUTABLE})
+  message(WARNING "Cached or directly specified Clang-Tidy executable does not exist.")
+  set(CLANG_TIDY_FOUND FALSE)
+elseif(CLANG_TIDY_EXECUTABLE)
   # Mark clang-tidy as found.
   set(CLANG_TIDY_FOUND TRUE)
 

build_files/cmake/Modules/GTestTesting.cmake

@@ -97,6 +97,7 @@ macro(BLENDER_SRC_GTEST_EX)
       set_tests_properties(${TARGET_NAME} PROPERTIES ENVIRONMENT LSAN_OPTIONS=exitcode=0)
     endif()
     if(WIN32)
+      set_target_properties(${TARGET_NAME} PROPERTIES VS_GLOBAL_VcpkgEnabled "false")
       unset(MANIFEST)
     endif()
     unset(TEST_INC)

build_files/cmake/buildinfo.cmake

@@ -128,7 +128,7 @@ if(EXISTS ${SOURCE_DIR}/.git)
                   OUTPUT_STRIP_TRAILING_WHITESPACE)
 
   if(NOT _git_changed_files STREQUAL "")
-    set(MY_WC_BRANCH "${MY_WC_BRANCH} (modified)")
+    string(APPEND MY_WC_BRANCH " (modified)")
   else()
     # Unpushed commits are also considered local modifications
     execute_process(COMMAND git log @{u}..
@@ -137,7 +137,7 @@ if(EXISTS ${SOURCE_DIR}/.git)
                     OUTPUT_STRIP_TRAILING_WHITESPACE
                     ERROR_QUIET)
     if(NOT _git_unpushed_log STREQUAL "")
-      set(MY_WC_BRANCH "${MY_WC_BRANCH} (modified)")
+      string(APPEND MY_WC_BRANCH " (modified)")
     endif()
     unset(_git_unpushed_log)
   endif()
@@ -161,6 +161,7 @@ file(WRITE buildinfo.h.txt
   "#define BUILD_BRANCH \"${MY_WC_BRANCH}\"\n"
   "#define BUILD_DATE \"${BUILD_DATE}\"\n"
   "#define BUILD_TIME \"${BUILD_TIME}\"\n"
+  "#include \"buildinfo_static.h\"\n"
 )
 
 # cleanup

build_files/cmake/buildinfo_static.h.in

@@ -0,0 +1,8 @@
+/* CMake expanded values that won't change between CMake execution (unlike date/time).
+ * This is included by `buildinfo.h` generated by `buildinfo.cmake`. */
+#define BUILD_PLATFORM "@BUILD_PLATFORM@"
+#define BUILD_TYPE "@BUILD_TYPE@"
+#define BUILD_CFLAGS "@BUILD_CFLAGS@"
+#define BUILD_CXXFLAGS "@BUILD_CXXFLAGS@"
+#define BUILD_LINKFLAGS "@BUILD_LINKFLAGS@"
+#define BUILD_SYSTEM "@BUILD_SYSTEM@"

build_files/cmake/macros.cmake

@@ -60,6 +60,19 @@ function(list_assert_duplicates
   unset(_len_after)
 endfunction()
 
+# Adds a native path separator to the end of the path:
+#
+# - 'example' -> 'example/'
+# - '/example///' -> '/example/'
+#
+macro(path_ensure_trailing_slash
+  path_new path_input
+  )
+  file(TO_NATIVE_PATH "/" _path_sep)
+  string(REGEX REPLACE "[${_path_sep}]+$" "" ${path_new} ${path_input})
+  set(${path_new} "${${path_new}}${_path_sep}")
+  unset(_path_sep)
+endmacro()
 
 # foo_bar.spam --> foo_barMySuffix.spam
 macro(file_suffix
@@ -183,7 +196,7 @@ function(blender_user_header_search_paths
     foreach(_INC ${includes})
       get_filename_component(_ABS_INC ${_INC} ABSOLUTE)
       # _ALL_INCS is a space-separated string of file paths in quotes.
-      set(_ALL_INCS "${_ALL_INCS} \"${_ABS_INC}\"")
+      string(APPEND _ALL_INCS " \"${_ABS_INC}\"")
     endforeach()
     set_target_properties(${name} PROPERTIES XCODE_ATTRIBUTE_USER_HEADER_SEARCH_PATHS "${_ALL_INCS}")
   endif()
@@ -250,11 +263,11 @@ macro(add_cc_flags_custom_test
   string(TOUPPER ${name} _name_upper)
   if(DEFINED CMAKE_C_FLAGS_${_name_upper})
     message(STATUS "Using custom CFLAGS: CMAKE_C_FLAGS_${_name_upper} in \"${CMAKE_CURRENT_SOURCE_DIR}\"")
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${CMAKE_C_FLAGS_${_name_upper}}" ${ARGV1})
+    string(APPEND CMAKE_C_FLAGS " ${CMAKE_C_FLAGS_${_name_upper}}" ${ARGV1})
   endif()
   if(DEFINED CMAKE_CXX_FLAGS_${_name_upper})
     message(STATUS "Using custom CXXFLAGS: CMAKE_CXX_FLAGS_${_name_upper} in \"${CMAKE_CURRENT_SOURCE_DIR}\"")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_${_name_upper}}" ${ARGV1})
+    string(APPEND CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS_${_name_upper}}" ${ARGV1})
   endif()
   unset(_name_upper)
 
@@ -675,14 +688,14 @@ endmacro()
 macro(add_c_flag
   flag)
 
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${flag}")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${flag}")
+  string(APPEND CMAKE_C_FLAGS " ${flag}")
+  string(APPEND CMAKE_CXX_FLAGS " ${flag}")
 endmacro()
 
 macro(add_cxx_flag
   flag)
 
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${flag}")
+  string(APPEND CMAKE_CXX_FLAGS " ${flag}")
 endmacro()
 
 macro(remove_strict_flags)

build_files/cmake/platform/platform_apple.cmake

@@ -60,6 +60,17 @@ if(WITH_OPENAL)
   endif()
 endif()
 
+if(WITH_JACK)
+  find_library(JACK_FRAMEWORK
+    NAMES jackmp
+  )
+  if(NOT JACK_FRAMEWORK)
+    set(WITH_JACK OFF)
+  else()
+    set(JACK_INCLUDE_DIRS ${JACK_FRAMEWORK}/headers)
+  endif()
+endif()
+
 if(NOT DEFINED LIBDIR)
   set(LIBDIR ${CMAKE_SOURCE_DIR}/../lib/darwin)
   # Prefer lib directory paths
@@ -94,17 +105,6 @@ if(WITH_OPENSUBDIV)
   find_package(OpenSubdiv)
 endif()
 
-if(WITH_JACK)
-  find_library(JACK_FRAMEWORK
-    NAMES jackmp
-  )
-  if(NOT JACK_FRAMEWORK)
-    set(WITH_JACK OFF)
-  else()
-    set(JACK_INCLUDE_DIRS ${JACK_FRAMEWORK}/headers)
-  endif()
-endif()
-
 if(WITH_CODEC_SNDFILE)
   find_package(SndFile)
   find_library(_sndfile_FLAC_LIBRARY NAMES flac HINTS ${LIBDIR}/sndfile/lib)
@@ -194,7 +194,7 @@ if(SYSTEMSTUBS_LIBRARY)
   list(APPEND PLATFORM_LINKLIBS SystemStubs)
 endif()
 
-set(PLATFORM_CFLAGS "${PLATFORM_CFLAGS} -pipe -funsigned-char")
+string(APPEND PLATFORM_CFLAGS " -pipe -funsigned-char -fno-strict-aliasing")
 set(PLATFORM_LINKFLAGS
   "-fexceptions -framework CoreServices -framework Foundation -framework IOKit -framework AppKit -framework Cocoa -framework Carbon -framework AudioUnit -framework AudioToolbox -framework CoreAudio -framework Metal -framework QuartzCore"
 )
@@ -202,12 +202,12 @@ set(PLATFORM_LINKFLAGS
 list(APPEND PLATFORM_LINKLIBS c++)
 
 if(WITH_JACK)
-  set(PLATFORM_LINKFLAGS "${PLATFORM_LINKFLAGS} -F/Library/Frameworks -weak_framework jackmp")
+  string(APPEND PLATFORM_LINKFLAGS " -F/Library/Frameworks -weak_framework jackmp")
 endif()
 
 if(WITH_PYTHON_MODULE OR WITH_PYTHON_FRAMEWORK)
   # force cmake to link right framework
-  set(PLATFORM_LINKFLAGS "${PLATFORM_LINKFLAGS} /Library/Frameworks/Python.framework/Versions/${PYTHON_VERSION}/Python")
+  string(APPEND PLATFORM_LINKFLAGS " /Library/Frameworks/Python.framework/Versions/${PYTHON_VERSION}/Python")
 endif()
 
 if(WITH_OPENCOLLADA)
@@ -222,7 +222,7 @@ if(WITH_SDL)
   find_package(SDL2)
   set(SDL_INCLUDE_DIR ${SDL2_INCLUDE_DIRS})
   set(SDL_LIBRARY ${SDL2_LIBRARIES})
-  set(PLATFORM_LINKFLAGS "${PLATFORM_LINKFLAGS} -framework ForceFeedback")
+  string(APPEND PLATFORM_LINKFLAGS " -framework ForceFeedback")
 endif()
 
 set(PNG_ROOT ${LIBDIR}/png)
@@ -266,7 +266,7 @@ if(WITH_BOOST)
 endif()
 
 if(WITH_INTERNATIONAL OR WITH_CODEC_FFMPEG)
-  set(PLATFORM_LINKFLAGS "${PLATFORM_LINKFLAGS} -liconv") # boost_locale and ffmpeg needs it !
+  string(APPEND PLATFORM_LINKFLAGS " -liconv") # boost_locale and ffmpeg needs it !
 endif()
 
 if(WITH_OPENIMAGEIO)
@@ -337,7 +337,7 @@ if(WITH_CYCLES_EMBREE)
   find_package(Embree 3.8.0 REQUIRED)
   # Increase stack size for Embree, only works for executables.
   if(NOT WITH_PYTHON_MODULE)
-    set(PLATFORM_LINKFLAGS "${PLATFORM_LINKFLAGS} -Xlinker -stack_size -Xlinker 0x100000")
+    string(APPEND PLATFORM_LINKFLAGS " -Xlinker -stack_size -Xlinker 0x100000")
   endif()
 
   # Embree static library linking can mix up SSE and AVX symbols, causing
@@ -381,7 +381,7 @@ if(WITH_OPENMP)
     set(OPENMP_FOUND ON)
     set(OpenMP_C_FLAGS "-Xclang -fopenmp -I'${LIBDIR}/openmp/include'")
     set(OpenMP_CXX_FLAGS "-Xclang -fopenmp -I'${LIBDIR}/openmp/include'")
-    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -L'${LIBDIR}/openmp/lib' -lomp")
+    string(APPEND CMAKE_EXE_LINKER_FLAGS " -L'${LIBDIR}/openmp/lib' -lomp")
 
     # Copy libomp.dylib to allow executables like datatoc and tests to work.
     # `@executable_path/../Resources/lib/` is a default dylib search path.
@@ -428,23 +428,23 @@ endif()
 
 set(EXETYPE MACOSX_BUNDLE)
 
-set(CMAKE_C_FLAGS_DEBUG "-fno-strict-aliasing -g")
-set(CMAKE_CXX_FLAGS_DEBUG "-fno-strict-aliasing -g")
+set(CMAKE_C_FLAGS_DEBUG "-g")
+set(CMAKE_CXX_FLAGS_DEBUG "-g")
 if(CMAKE_OSX_ARCHITECTURES MATCHES "x86_64" OR CMAKE_OSX_ARCHITECTURES MATCHES "i386")
   set(CMAKE_CXX_FLAGS_RELEASE "-O2 -mdynamic-no-pic -msse -msse2 -msse3 -mssse3")
   set(CMAKE_C_FLAGS_RELEASE "-O2 -mdynamic-no-pic  -msse -msse2 -msse3 -mssse3")
   if(NOT CMAKE_C_COMPILER_ID MATCHES "Clang")
-    set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -ftree-vectorize  -fvariable-expansion-in-unroller")
-    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -ftree-vectorize  -fvariable-expansion-in-unroller")
+    string(APPEND CMAKE_C_FLAGS_RELEASE " -ftree-vectorize  -fvariable-expansion-in-unroller")
+    string(APPEND CMAKE_CXX_FLAGS_RELEASE " -ftree-vectorize  -fvariable-expansion-in-unroller")
   endif()
 else()
-  set(CMAKE_C_FLAGS_RELEASE "-O2 -mdynamic-no-pic -fno-strict-aliasing")
-  set(CMAKE_CXX_FLAGS_RELEASE "-O2 -mdynamic-no-pic -fno-strict-aliasing")
+  set(CMAKE_C_FLAGS_RELEASE "-O2 -mdynamic-no-pic")
+  set(CMAKE_CXX_FLAGS_RELEASE "-O2 -mdynamic-no-pic")
 endif()
 
 if(${XCODE_VERSION} VERSION_EQUAL 5 OR ${XCODE_VERSION} VERSION_GREATER 5)
   # Xcode 5 is always using CLANG, which has too low template depth of 128 for libmv
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ftemplate-depth=1024")
+  string(APPEND CMAKE_CXX_FLAGS " -ftemplate-depth=1024")
 endif()
 
 # Avoid conflicts with Luxrender, and other plug-ins that may use the same
@@ -453,8 +453,8 @@ set(PLATFORM_LINKFLAGS
   "${PLATFORM_LINKFLAGS} -Xlinker -unexported_symbols_list -Xlinker '${CMAKE_SOURCE_DIR}/source/creator/osx_locals.map'"
 )
 
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++")
-set(PLATFORM_LINKFLAGS "${PLATFORM_LINKFLAGS} -stdlib=libc++")
+string(APPEND CMAKE_CXX_FLAGS " -stdlib=libc++")
+string(APPEND PLATFORM_LINKFLAGS " -stdlib=libc++")
 
 # Suppress ranlib "has no symbols" warnings (workaround for T48250)
 set(CMAKE_C_ARCHIVE_CREATE   "<CMAKE_AR> Scr <TARGET> <LINK_FLAGS> <OBJECTS>")

build_files/cmake/platform/platform_apple_xcode.cmake

@@ -150,7 +150,7 @@ endif()
 
 if(NOT ${CMAKE_GENERATOR} MATCHES "Xcode")
   # Force CMAKE_OSX_DEPLOYMENT_TARGET for makefiles, will not work else (CMake bug?)
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mmacosx-version-min=${CMAKE_OSX_DEPLOYMENT_TARGET}")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mmacosx-version-min=${CMAKE_OSX_DEPLOYMENT_TARGET}")
+  string(APPEND CMAKE_C_FLAGS " -mmacosx-version-min=${CMAKE_OSX_DEPLOYMENT_TARGET}")
+  string(APPEND CMAKE_CXX_FLAGS " -mmacosx-version-min=${CMAKE_OSX_DEPLOYMENT_TARGET}")
   add_definitions("-DMACOSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET}")
 endif()

build_files/cmake/platform/platform_unix.cmake

@@ -73,7 +73,7 @@ if(EXISTS ${LIBDIR})
 endif()
 
 if(WITH_STATIC_LIBS)
-  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static-libstdc++")
+  string(APPEND CMAKE_EXE_LINKER_FLAGS " -static-libstdc++")
 endif()
 
 # Wrapper to prefer static libraries
@@ -620,7 +620,7 @@ if(CMAKE_COMPILER_IS_GNUCC)
   set(CMAKE_C_FLAGS_RELEASE          "${GCC_EXTRA_FLAGS_RELEASE} ${CMAKE_C_FLAGS_RELEASE}")
   set(CMAKE_C_FLAGS_RELWITHDEBINFO   "${GCC_EXTRA_FLAGS_RELEASE} ${CMAKE_C_FLAGS_RELWITHDEBINFO}")
   set(CMAKE_CXX_FLAGS_RELEASE        "${GCC_EXTRA_FLAGS_RELEASE} ${CMAKE_CXX_FLAGS_RELEASE}")
-  set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${GCC_EXTRA_FLAGS_RELEASE} ${CMAKE_CXX_FLAGS_RELWITHDEBINFO}")
+  string(PREPEND CMAKE_CXX_FLAGS_RELWITHDEBINFO "${GCC_EXTRA_FLAGS_RELEASE} ")
   unset(GCC_EXTRA_FLAGS_RELEASE)
 
   if(WITH_LINKER_GOLD)
@@ -628,8 +628,8 @@ if(CMAKE_COMPILER_IS_GNUCC)
       COMMAND ${CMAKE_C_COMPILER} -fuse-ld=gold -Wl,--version
       ERROR_QUIET OUTPUT_VARIABLE LD_VERSION)
     if("${LD_VERSION}" MATCHES "GNU gold")
-      set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fuse-ld=gold")
-      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fuse-ld=gold")
+      string(APPEND CMAKE_C_FLAGS " -fuse-ld=gold")
+      string(APPEND CMAKE_CXX_FLAGS " -fuse-ld=gold")
     else()
       message(STATUS "GNU gold linker isn't available, using the default system linker.")
     endif()
@@ -641,8 +641,8 @@ if(CMAKE_COMPILER_IS_GNUCC)
       COMMAND ${CMAKE_C_COMPILER} -fuse-ld=lld -Wl,--version
       ERROR_QUIET OUTPUT_VARIABLE LD_VERSION)
     if("${LD_VERSION}" MATCHES "LLD")
-      set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fuse-ld=lld")
-      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fuse-ld=lld")
+      string(APPEND CMAKE_C_FLAGS " -fuse-ld=lld")
+      string(APPEND CMAKE_CXX_FLAGS " -fuse-ld=lld")
     else()
       message(STATUS "LLD linker isn't available, using the default system linker.")
     endif()
@@ -667,12 +667,12 @@ elseif(CMAKE_C_COMPILER_ID MATCHES "Intel")
   endif()
   mark_as_advanced(XILD)
 
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fp-model precise -prec_div -parallel")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fp-model precise -prec_div -parallel")
+  string(APPEND CMAKE_C_FLAGS " -fp-model precise -prec_div -parallel")
+  string(APPEND CMAKE_CXX_FLAGS " -fp-model precise -prec_div -parallel")
 
-  # set(PLATFORM_CFLAGS "${PLATFORM_CFLAGS} -diag-enable sc3")
+  # string(APPEND PLATFORM_CFLAGS " -diag-enable sc3")
   set(PLATFORM_CFLAGS "-pipe -fPIC -funsigned-char -fno-strict-aliasing")
-  set(PLATFORM_LINKFLAGS "${PLATFORM_LINKFLAGS} -static-intel")
+  string(APPEND PLATFORM_LINKFLAGS " -static-intel")
 endif()
 
 # Avoid conflicts with Mesa llvmpipe, Luxrender, and other plug-ins that may
@@ -685,5 +685,5 @@ set(PLATFORM_LINKFLAGS
 # browsers can't properly detect blender as an executable then. Still enabled
 # for non-portable installs as typically used by Linux distributions.
 if(WITH_INSTALL_PORTABLE)
-  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -no-pie")
+  string(APPEND CMAKE_EXE_LINKER_FLAGS " -no-pie")
 endif()

build_files/cmake/platform/platform_win32.cmake

@@ -49,7 +49,7 @@ if(CMAKE_C_COMPILER_ID MATCHES "Clang")
     if(NOT EXISTS "${CLANG_OPENMP_DLL}")
       message(FATAL_ERROR "Clang OpenMP library (${CLANG_OPENMP_DLL}) not found.")
     endif()
-    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} \"${CLANG_OPENMP_LIB}\"")
+    string(APPEND CMAKE_EXE_LINKER_FLAGS " \"${CLANG_OPENMP_LIB}\"")
   endif()
   if(WITH_WINDOWS_STRIPPED_PDB)
     message(WARNING "stripped pdb not supported with clang, disabling..")
@@ -112,9 +112,9 @@ unset(_min_ver)
 
 # needed for some MSVC installations
 # 4099 : PDB 'filename' was not found with 'object/library'
-set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /SAFESEH:NO /ignore:4099")
-set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /SAFESEH:NO /ignore:4099")
-set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} /SAFESEH:NO /ignore:4099")
+string(APPEND CMAKE_EXE_LINKER_FLAGS " /SAFESEH:NO /ignore:4099")
+string(APPEND CMAKE_SHARED_LINKER_FLAGS " /SAFESEH:NO /ignore:4099")
+string(APPEND CMAKE_MODULE_LINKER_FLAGS " /SAFESEH:NO /ignore:4099")
 
 list(APPEND PLATFORM_LINKLIBS
   ws2_32 vfw32 winmm kernel32 user32 gdi32 comdlg32 Comctl32 version
@@ -154,18 +154,18 @@ if(WITH_WINDOWS_PDB)
 endif()
 
 if(MSVC_CLANG) # Clangs version of cl doesn't support all flags
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_WARN_FLAGS} /nologo /J /Gd /EHsc -Wno-unused-command-line-argument -Wno-microsoft-enum-forward-reference ")
+  string(APPEND CMAKE_CXX_FLAGS " ${CXX_WARN_FLAGS} /nologo /J /Gd /EHsc -Wno-unused-command-line-argument -Wno-microsoft-enum-forward-reference ")
   set(CMAKE_C_FLAGS     "${CMAKE_C_FLAGS} /nologo /J /Gd -Wno-unused-command-line-argument -Wno-microsoft-enum-forward-reference")
 else()
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /nologo /J /Gd /MP /EHsc /bigobj")
+  string(APPEND CMAKE_CXX_FLAGS " /nologo /J /Gd /MP /EHsc /bigobj")
   set(CMAKE_C_FLAGS     "${CMAKE_C_FLAGS} /nologo /J /Gd /MP /bigobj")
 endif()
 
 # C++ standards conformace (/permissive-) is available on msvc 15.5 (1912) and up
 if(MSVC_VERSION GREATER 1911 AND NOT MSVC_CLANG)
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /permissive-")
+  string(APPEND CMAKE_CXX_FLAGS " /permissive-")
   # Two-phase name lookup does not place nicely with OpenMP yet, so disable for now
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Zc:twoPhase-")
+  string(APPEND CMAKE_CXX_FLAGS " /Zc:twoPhase-")
 endif()
 
 if(WITH_WINDOWS_SCCACHE AND CMAKE_VS_MSBUILD_COMMAND)
@@ -183,33 +183,33 @@ else()
     set(SYMBOL_FORMAT /ZI)
 endif()
 
-set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /MDd ${SYMBOL_FORMAT}")
-set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /MDd ${SYMBOL_FORMAT}")
-set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /MD ${PDB_INFO_OVERRIDE_FLAGS}")
-set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /MD ${PDB_INFO_OVERRIDE_FLAGS}")
-set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} /MD ${PDB_INFO_OVERRIDE_FLAGS}")
-set(CMAKE_C_FLAGS_MINSIZEREL "${CMAKE_C_FLAGS_MINSIZEREL} /MD ${PDB_INFO_OVERRIDE_FLAGS}")
-set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} /MD ${SYMBOL_FORMAT}")
-set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO} /MD ${SYMBOL_FORMAT}")
+string(APPEND CMAKE_CXX_FLAGS_DEBUG " /MDd ${SYMBOL_FORMAT}")
+string(APPEND CMAKE_C_FLAGS_DEBUG " /MDd ${SYMBOL_FORMAT}")
+string(APPEND CMAKE_CXX_FLAGS_RELEASE " /MD ${PDB_INFO_OVERRIDE_FLAGS}")
+string(APPEND CMAKE_C_FLAGS_RELEASE " /MD ${PDB_INFO_OVERRIDE_FLAGS}")
+string(APPEND CMAKE_CXX_FLAGS_MINSIZEREL " /MD ${PDB_INFO_OVERRIDE_FLAGS}")
+string(APPEND CMAKE_C_FLAGS_MINSIZEREL " /MD ${PDB_INFO_OVERRIDE_FLAGS}")
+string(APPEND CMAKE_CXX_FLAGS_RELWITHDEBINFO " /MD ${SYMBOL_FORMAT}")
+string(APPEND CMAKE_C_FLAGS_RELWITHDEBINFO " /MD ${SYMBOL_FORMAT}")
 unset(SYMBOL_FORMAT)
 # JMC is available on msvc 15.8 (1915) and up
 if(MSVC_VERSION GREATER 1914 AND NOT MSVC_CLANG)
-  set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /JMC")
+  string(APPEND CMAKE_CXX_FLAGS_DEBUG " /JMC")
 endif()
 
-set(PLATFORM_LINKFLAGS "${PLATFORM_LINKFLAGS} /SUBSYSTEM:CONSOLE /STACK:2097152")
+string(APPEND PLATFORM_LINKFLAGS " /SUBSYSTEM:CONSOLE /STACK:2097152")
 set(PLATFORM_LINKFLAGS_RELEASE "/NODEFAULTLIB:libcmt.lib /NODEFAULTLIB:libcmtd.lib /NODEFAULTLIB:msvcrtd.lib")
-set(PLATFORM_LINKFLAGS_DEBUG "${PLATFORM_LINKFLAGS_DEBUG} /IGNORE:4099 /NODEFAULTLIB:libcmt.lib /NODEFAULTLIB:msvcrt.lib /NODEFAULTLIB:libcmtd.lib")
+string(APPEND PLATFORM_LINKFLAGS_DEBUG " /IGNORE:4099 /NODEFAULTLIB:libcmt.lib /NODEFAULTLIB:msvcrt.lib /NODEFAULTLIB:libcmtd.lib")
 
 # Ignore meaningless for us linker warnings.
-set(PLATFORM_LINKFLAGS "${PLATFORM_LINKFLAGS} /ignore:4049 /ignore:4217 /ignore:4221")
+string(APPEND PLATFORM_LINKFLAGS " /ignore:4049 /ignore:4217 /ignore:4221")
 set(PLATFORM_LINKFLAGS_RELEASE "${PLATFORM_LINKFLAGS} ${PDB_INFO_OVERRIDE_LINKER_FLAGS}")
-set(CMAKE_STATIC_LINKER_FLAGS "${CMAKE_STATIC_LINKER_FLAGS} /ignore:4221")
+string(APPEND CMAKE_STATIC_LINKER_FLAGS " /ignore:4221")
 
 if(CMAKE_CL_64)
-  set(PLATFORM_LINKFLAGS "/MACHINE:X64 ${PLATFORM_LINKFLAGS}")
+  string(PREPEND PLATFORM_LINKFLAGS "/MACHINE:X64 ")
 else()
-  set(PLATFORM_LINKFLAGS "/MACHINE:IX86 /LARGEADDRESSAWARE ${PLATFORM_LINKFLAGS}")
+  string(PREPEND PLATFORM_LINKFLAGS "/MACHINE:IX86 /LARGEADDRESSAWARE ")
 endif()
 
 if(NOT DEFINED LIBDIR)

build_files/cmake/platform/platform_win32_bundle_crt.cmake

@@ -31,7 +31,7 @@ if(WITH_WINDOWS_BUNDLE_CRT)
     foreach(lib ${CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS})
       get_filename_component(filename ${lib} NAME)
       file(SHA1 "${lib}" sha1_file)
-      set(CRTLIBS "${CRTLIBS}    <file name=\"${filename}\" hash=\"${sha1_file}\"  hashalg=\"SHA1\" />\n")
+      string(APPEND CRTLIBS "    <file name=\"${filename}\" hash=\"${sha1_file}\"  hashalg=\"SHA1\" />\n")
     endforeach()
     configure_file(${CMAKE_SOURCE_DIR}/release/windows/manifest/blender.crt.manifest.in ${CMAKE_CURRENT_BINARY_DIR}/blender.crt.manifest @ONLY)
     file(TOUCH ${manifest_trigger_file})

extern/bullet2/CMakeLists.txt

@@ -423,7 +423,7 @@ set(LIB
 
 if(CMAKE_COMPILER_IS_GNUCXX)
   # needed for gcc 4.6+
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fpermissive")
+  string(APPEND CMAKE_CXX_FLAGS " -fpermissive")
 endif()
 
 if(MSVC)

extern/draco/dracoenc/cmake/compiler_flags.cmake

@@ -23,9 +23,9 @@ macro (add_c_flag_if_supported c_flag)
     message("Checking C compiler flag support for: " ${c_flag})
     check_c_compiler_flag("${c_flag}" C_FLAG_SUPPORTED)
     if (${C_FLAG_SUPPORTED})
-      set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${c_flag}" CACHE STRING "")
+      string(APPEND CMAKE_C_FLAGS " ${c_flag}" CACHE STRING "")
     else ()
-      set(DRACO_FAILED_C_FLAGS "${DRACO_FAILED_C_FLAGS} ${c_flag}" CACHE STRING
+      string(APPEND DRACO_FAILED_C_FLAGS " ${c_flag}" CACHE STRING
           "" FORCE)
     endif ()
   endif ()
@@ -45,9 +45,9 @@ macro (add_cxx_flag_if_supported cxx_flag)
     message("Checking CXX compiler flag support for: " ${cxx_flag})
     check_cxx_compiler_flag("${cxx_flag}" CXX_FLAG_SUPPORTED)
     if (${CXX_FLAG_SUPPORTED})
-      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${cxx_flag}" CACHE STRING "")
+      string(APPEND CMAKE_CXX_FLAGS " ${cxx_flag}" CACHE STRING "")
     else()
-      set(DRACO_FAILED_CXX_FLAGS "${DRACO_FAILED_CXX_FLAGS} ${cxx_flag}" CACHE
+      string(APPEND DRACO_FAILED_CXX_FLAGS " ${cxx_flag}" CACHE
           STRING "" FORCE)
     endif ()
   endif ()
@@ -138,7 +138,7 @@ macro (append_as_flag flag)
   string(FIND "${DRACO_AS_FLAGS}" "${flag}" AS_FLAG_FOUND)
 
   if (${AS_FLAG_FOUND} EQUAL -1)
-    set(DRACO_AS_FLAGS "${DRACO_AS_FLAGS} ${flag}")
+    string(APPEND DRACO_AS_FLAGS " ${flag}")
   endif ()
 endmacro ()
 
@@ -148,7 +148,7 @@ macro (append_c_flag flag)
   string(FIND "${CMAKE_C_FLAGS}" "${flag}" C_FLAG_FOUND)
 
   if (${C_FLAG_FOUND} EQUAL -1)
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${flag}")
+    string(APPEND CMAKE_C_FLAGS " ${flag}")
   endif ()
 endmacro ()
 
@@ -158,7 +158,7 @@ macro (append_cxx_flag flag)
   string(FIND "${CMAKE_CXX_FLAGS}" "${flag}" CXX_FLAG_FOUND)
 
   if (${CXX_FLAG_FOUND} EQUAL -1)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${flag}")
+    string(APPEND CMAKE_CXX_FLAGS " ${flag}")
   endif ()
 endmacro ()
 
@@ -174,7 +174,7 @@ macro (append_exe_linker_flag flag)
   string(FIND "${CMAKE_EXE_LINKER_FLAGS}" "${flag}" LINKER_FLAG_FOUND)
 
   if (${LINKER_FLAG_FOUND} EQUAL -1)
-    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${flag}")
+    string(APPEND CMAKE_EXE_LINKER_FLAGS " ${flag}")
   endif ()
 endmacro ()
 
@@ -191,7 +191,7 @@ function (append_link_flag_to_target target flags)
       return()
     endif ()
 
-    set(target_link_flags "${target_link_flags} ${flags}")
+    string(APPEND target_link_flags " ${flags}")
   else ()
     set(target_link_flags "${flags}")
   endif ()

extern/draco/dracoenc/cmake/compiler_tests.cmake

@@ -41,9 +41,9 @@ macro(draco_check_c_compiles test_name test_source result_var)
     set(${result_var} ${C_TEST_COMPILED})
 
     if (${C_TEST_COMPILED})
-      set(DRACO_C_PASSED_TESTS "${DRACO_C_PASSED_TESTS} ${test_name}")
+      string(APPEND DRACO_C_PASSED_TESTS " ${test_name}")
     else ()
-      set(DRACO_C_FAILED_TESTS "${DRACO_C_FAILED_TESTS} ${test_name}")
+      string(APPEND DRACO_C_FAILED_TESTS " ${test_name}")
       message("C Compiler test ${test_name} failed.")
     endif ()
   elseif (NOT ${C_TEST_PASSED} EQUAL -1)
@@ -71,9 +71,9 @@ macro(draco_check_cxx_compiles test_name test_source result_var)
     set(${result_var} ${CXX_TEST_COMPILED})
 
     if (${CXX_TEST_COMPILED})
-      set(DRACO_CXX_PASSED_TESTS "${DRACO_CXX_PASSED_TESTS} ${test_name}")
+      string(APPEND DRACO_CXX_PASSED_TESTS " ${test_name}")
     else ()
-      set(DRACO_CXX_FAILED_TESTS "${DRACO_CXX_FAILED_TESTS} ${test_name}")
+      string(APPEND DRACO_CXX_FAILED_TESTS " ${test_name}")
       message("CXX Compiler test ${test_name} failed.")
     endif ()
   elseif (NOT ${CXX_TEST_PASSED} EQUAL -1)

extern/mantaflow/CMakeLists.txt

@@ -37,8 +37,8 @@ endif()
 
 if(APPLE AND ("${CMAKE_OSX_ARCHITECTURES}" STREQUAL "arm64"))
   if(CMAKE_COMPILER_IS_GNUCXX OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fvisibility=hidden")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden")
+    string(APPEND CMAKE_C_FLAGS " -fvisibility=hidden")
+    string(APPEND CMAKE_CXX_FLAGS " -fvisibility=hidden")
   endif()
 endif()
 

extern/mantaflow/helper/pwrapper/numpyWrap.cpp

@@ -94,7 +94,7 @@ void PyArrayContainer::ExtractData(void *_pParentPyArray)
 
 template<> PyArrayContainer fromPy<PyArrayContainer>(PyObject *obj)
 {
-  if (PyArray_API == NULL) {
+  if (PyArray_API == nullptr) {
     // python 3 uses the return value
 #if PY_VERSION_HEX >= 0x03000000
     import_array();
@@ -109,12 +109,12 @@ template<> PyArrayContainer fromPy<PyArrayContainer>(PyObject *obj)
 
   PyArrayObject *obj_p = reinterpret_cast<PyArrayObject *>(
       PyArray_CheckFromAny(obj,
-                           NULL,
+                           nullptr,
                            0,
                            0,
                            /*NPY_ARRAY_ENSURECOPY*/ NPY_ARRAY_C_CONTIGUOUS |
                                NPY_ARRAY_ENSUREARRAY | NPY_ARRAY_NOTSWAPPED,
-                           NULL));
+                           nullptr));
   PyArrayContainer container = PyArrayContainer(obj_p);
 
   return container;

extern/mantaflow/helper/pwrapper/pclass.cpp

@@ -98,13 +98,13 @@ string PbType::str() const
 vector<PbClass *> PbClass::mInstances;
 
 PbClass::PbClass(FluidSolver *parent, const string &name, PyObject *obj)
-    : mMutex(NULL), mParent(parent), mPyObject(obj), mName(name), mHidden(false)
+    : mMutex(nullptr), mParent(parent), mPyObject(obj), mName(name), mHidden(false)
 {
   mMutex = new QMutex();
 }
 
 PbClass::PbClass(const PbClass &a)
-    : mMutex(NULL), mParent(a.mParent), mPyObject(0), mName("_unnamed"), mHidden(false)
+    : mMutex(nullptr), mParent(a.mParent), mPyObject(0), mName("_unnamed"), mHidden(false)
 {
   mMutex = new QMutex();
 }
@@ -180,7 +180,7 @@ PbClass *PbClass::createPyObject(const string &classname,
 
 void PbClass::checkParent()
 {
-  if (getParent() == NULL) {
+  if (getParent() == nullptr) {
     errMsg("New class " + mName + ": no parent given -- specify using parent=xxx !");
   }
 }

extern/mantaflow/helper/pwrapper/pclass.h

@@ -43,7 +43,7 @@ struct PbTypeVec {
 //! Base class for all classes exposed to Python
 class PbClass {
  public:
-  PbClass(FluidSolver *parent, const std::string &name = "", PyObject *obj = NULL);
+  PbClass(FluidSolver *parent, const std::string &name = "", PyObject *obj = nullptr);
   PbClass(const PbClass &a);
   virtual ~PbClass();
 

extern/mantaflow/helper/pwrapper/pconvert.cpp

@@ -491,7 +491,7 @@ template<> bool isPy<std::vector<float>>(PyObject *obj)
 //******************************************************************************
 // PbArgs class defs
 
-PbArgs PbArgs::EMPTY(NULL, NULL);
+PbArgs PbArgs::EMPTY(nullptr, nullptr);
 
 PbArgs::PbArgs(PyObject *linarg, PyObject *dict) : mLinArgs(0), mKwds(0)
 {
@@ -577,7 +577,7 @@ void PbArgs::check()
 
 FluidSolver *PbArgs::obtainParent()
 {
-  FluidSolver *solver = getPtrOpt<FluidSolver>("solver", -1, NULL);
+  FluidSolver *solver = getPtrOpt<FluidSolver>("solver", -1, nullptr);
   if (solver != 0)
     return solver;
 
@@ -585,7 +585,7 @@ FluidSolver *PbArgs::obtainParent()
     PbClass *obj = Pb::objFromPy(it->second.obj);
 
     if (obj) {
-      if (solver == NULL)
+      if (solver == nullptr)
         solver = obj->getParent();
     }
   }
@@ -593,7 +593,7 @@ FluidSolver *PbArgs::obtainParent()
     PbClass *obj = Pb::objFromPy(it->obj);
 
     if (obj) {
-      if (solver == NULL)
+      if (solver == nullptr)
         solver = obj->getParent();
     }
   }
@@ -616,7 +616,7 @@ PyObject *PbArgs::getItem(const std::string &key, bool strict, ArgLocker *lk)
   if (lu == mData.end()) {
     if (strict)
       errMsg("Argument '" + key + "' is not defined.");
-    return NULL;
+    return nullptr;
   }
   PbClass *pbo = Pb::objFromPy(lu->second.obj);
   // try to lock
@@ -629,7 +629,7 @@ PyObject *PbArgs::getItem(size_t number, bool strict, ArgLocker *lk)
 {
   if (number >= mLinData.size()) {
     if (!strict)
-      return NULL;
+      return nullptr;
     stringstream s;
     s << "Argument number #" << number << " not specified.";
     errMsg(s.str());

extern/mantaflow/helper/pwrapper/pconvert.h

@@ -139,9 +139,9 @@ template<> bool isPy<std::vector<float>>(PyObject *obj);
 //! Encapsulation of python arguments
 class PbArgs {
  public:
-  PbArgs(PyObject *linargs = NULL, PyObject *dict = NULL);
+  PbArgs(PyObject *linargs = nullptr, PyObject *dict = nullptr);
   ~PbArgs();
-  void setup(PyObject *linargs = NULL, PyObject *dict = NULL);
+  void setup(PyObject *linargs = nullptr, PyObject *dict = nullptr);
 
   void check();
   FluidSolver *obtainParent();
@@ -153,7 +153,7 @@ class PbArgs {
 
   inline bool has(const std::string &key)
   {
-    return getItem(key, false) != NULL;
+    return getItem(key, false) != nullptr;
   }
   inline void deleteItem(const std::string &key)
   {
@@ -177,7 +177,7 @@ class PbArgs {
     DataElement el = {toPy(arg), false};
     mData[key] = el;
   }
-  template<class T> inline T get(const std::string &key, int number = -1, ArgLocker *lk = NULL)
+  template<class T> inline T get(const std::string &key, int number = -1, ArgLocker *lk = nullptr)
   {
     visit(number, key);
     PyObject *o = getItem(key, false, lk);
@@ -189,7 +189,7 @@ class PbArgs {
     errMsg("Argument '" + key + "' is not defined.");
   }
   template<class T>
-  inline T getOpt(const std::string &key, int number, T defarg, ArgLocker *lk = NULL)
+  inline T getOpt(const std::string &key, int number, T defarg, ArgLocker *lk = nullptr)
   {
     visit(number, key);
     PyObject *o = getItem(key, false, lk);
@@ -200,7 +200,7 @@ class PbArgs {
     return (o) ? fromPy<T>(o) : defarg;
   }
   template<class T>
-  inline T *getPtrOpt(const std::string &key, int number, T *defarg, ArgLocker *lk = NULL)
+  inline T *getPtrOpt(const std::string &key, int number, T *defarg, ArgLocker *lk = nullptr)
   {
     visit(number, key);
     PyObject *o = getItem(key, false, lk);
@@ -210,7 +210,8 @@ class PbArgs {
       o = getItem(number, false, lk);
     return o ? fromPyPtr<T>(o, &mTmpStorage) : defarg;
   }
-  template<class T> inline T *getPtr(const std::string &key, int number = -1, ArgLocker *lk = NULL)
+  template<class T>
+  inline T *getPtr(const std::string &key, int number = -1, ArgLocker *lk = nullptr)
   {
     visit(number, key);
     PyObject *o = getItem(key, false, lk);
@@ -239,8 +240,8 @@ class PbArgs {
   static PbArgs EMPTY;
 
  protected:
-  PyObject *getItem(const std::string &key, bool strict, ArgLocker *lk = NULL);
-  PyObject *getItem(size_t number, bool strict, ArgLocker *lk = NULL);
+  PyObject *getItem(const std::string &key, bool strict, ArgLocker *lk = nullptr);
+  PyObject *getItem(size_t number, bool strict, ArgLocker *lk = nullptr);
 
   struct DataElement {
     PyObject *obj;

extern/mantaflow/helper/pwrapper/pvec3.cpp

@@ -77,13 +77,13 @@ static PyMemberDef PbVec3Members[] = {
     {(char *)"x", T_FLOAT, offsetof(PbVec3, data), 0, (char *)"X"},
     {(char *)"y", T_FLOAT, offsetof(PbVec3, data) + sizeof(float), 0, (char *)"Y"},
     {(char *)"z", T_FLOAT, offsetof(PbVec3, data) + sizeof(float) * 2, 0, (char *)"Z"},
-    {NULL}  // Sentinel
+    {nullptr}  // Sentinel
 };
 
 static PyMethodDef PbVec3Methods[] = {
     //{"name", (PyCFunction)Noddy_name, METH_NOARGS, "Return the name, combining the first and last
     //name" },
-    {NULL}  // Sentinel
+    {nullptr}  // Sentinel
 };
 
 // operator overloads
@@ -240,24 +240,24 @@ static PyNumberMethods PbVec3NumberMethods = {
 #endif
 
 PyTypeObject PbVec3Type = {
-    PyVarObject_HEAD_INIT(NULL, 0) "manta.vec3", /* tp_name */
-    sizeof(PbVec3),                              /* tp_basicsize */
-    0,                                           /* tp_itemsize */
-    (destructor)PbVec3Dealloc,                   /* tp_dealloc */
-    0,                                           /* tp_print */
-    0,                                           /* tp_getattr */
-    0,                                           /* tp_setattr */
-    0,                                           /* tp_reserved */
-    (reprfunc)PbVec3Repr,                        /* tp_repr */
-    &PbVec3NumberMethods,                        /* tp_as_number */
-    0,                                           /* tp_as_sequence */
-    0,                                           /* tp_as_mapping */
-    0,                                           /* tp_hash  */
-    0,                                           /* tp_call */
-    0,                                           /* tp_str */
-    0,                                           /* tp_getattro */
-    0,                                           /* tp_setattro */
-    0,                                           /* tp_as_buffer */
+    PyVarObject_HEAD_INIT(nullptr, 0) "manta.vec3", /* tp_name */
+    sizeof(PbVec3),                                 /* tp_basicsize */
+    0,                                              /* tp_itemsize */
+    (destructor)PbVec3Dealloc,                      /* tp_dealloc */
+    0,                                              /* tp_print */
+    0,                                              /* tp_getattr */
+    0,                                              /* tp_setattr */
+    0,                                              /* tp_reserved */
+    (reprfunc)PbVec3Repr,                           /* tp_repr */
+    &PbVec3NumberMethods,                           /* tp_as_number */
+    0,                                              /* tp_as_sequence */
+    0,                                              /* tp_as_mapping */
+    0,                                              /* tp_hash  */
+    0,                                              /* tp_call */
+    0,                                              /* tp_str */
+    0,                                              /* tp_getattro */
+    0,                                              /* tp_setattro */
+    0,                                              /* tp_as_buffer */
 #if PY_MAJOR_VERSION >= 3
     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
 #else
@@ -297,7 +297,7 @@ struct PbVec4 {
 };
 
 static PyMethodDef PbVec4Methods[] = {
-    {NULL}  // Sentinel
+    {nullptr}  // Sentinel
 };
 
 static PyMemberDef PbVec4Members[] = {
@@ -305,7 +305,7 @@ static PyMemberDef PbVec4Members[] = {
     {(char *)"y", T_FLOAT, offsetof(PbVec4, data) + sizeof(float) * 1, 0, (char *)"Y"},
     {(char *)"z", T_FLOAT, offsetof(PbVec4, data) + sizeof(float) * 2, 0, (char *)"Z"},
     {(char *)"t", T_FLOAT, offsetof(PbVec4, data) + sizeof(float) * 3, 0, (char *)"T"},
-    {NULL}  // Sentinel
+    {nullptr}  // Sentinel
 };
 
 static void PbVec4Dealloc(PbVec4 *self)
@@ -352,24 +352,24 @@ static PyObject *PbVec4Repr(PbVec4 *self)
 }
 
 PyTypeObject PbVec4Type = {
-    PyVarObject_HEAD_INIT(NULL, 0) "manta.vec4", /* tp_name */
-    sizeof(PbVec4),                              /* tp_basicsize */
-    0,                                           /* tp_itemsize */
-    (destructor)PbVec4Dealloc,                   /* tp_dealloc */
-    0,                                           /* tp_print */
-    0,                                           /* tp_getattr */
-    0,                                           /* tp_setattr */
-    0,                                           /* tp_reserved */
-    (reprfunc)PbVec4Repr,                        /* tp_repr */
-    NULL,                                        // &PbVec4NumberMethods,      /* tp_as_number */
-    0,                                           /* tp_as_sequence */
-    0,                                           /* tp_as_mapping */
-    0,                                           /* tp_hash  */
-    0,                                           /* tp_call */
-    0,                                           /* tp_str */
-    0,                                           /* tp_getattro */
-    0,                                           /* tp_setattro */
-    0,                                           /* tp_as_buffer */
+    PyVarObject_HEAD_INIT(nullptr, 0) "manta.vec4", /* tp_name */
+    sizeof(PbVec4),                                 /* tp_basicsize */
+    0,                                              /* tp_itemsize */
+    (destructor)PbVec4Dealloc,                      /* tp_dealloc */
+    0,                                              /* tp_print */
+    0,                                              /* tp_getattr */
+    0,                                              /* tp_setattr */
+    0,                                              /* tp_reserved */
+    (reprfunc)PbVec4Repr,                           /* tp_repr */
+    nullptr,  // &PbVec4NumberMethods,      /* tp_as_number */
+    0,        /* tp_as_sequence */
+    0,        /* tp_as_mapping */
+    0,        /* tp_hash  */
+    0,        /* tp_call */
+    0,        /* tp_str */
+    0,        /* tp_getattro */
+    0,        /* tp_setattro */
+    0,        /* tp_as_buffer */
 #if PY_MAJOR_VERSION >= 3
     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
 #else

extern/mantaflow/helper/pwrapper/registry.cpp

@@ -52,7 +52,7 @@ struct GetSet {
 
   PyGetSetDef def()
   {
-    PyGetSetDef def = {&name[0], getter, setter, &doc[0], NULL};
+    PyGetSetDef def = {&name[0], getter, setter, &doc[0], nullptr};
     return def;
   }
 };
@@ -175,10 +175,10 @@ void cbDealloc(PbObject *self)
 PyObject *cbNew(PyTypeObject *type, PyObject *args, PyObject *kwds)
 {
   PbObject *self = (PbObject *)type->tp_alloc(type, 0);
-  if (self != NULL) {
+  if (self != nullptr) {
     // lookup and link classdef
     self->classdef = WrapperRegistry::instance().lookup(type->tp_name);
-    self->instance = NULL;
+    self->instance = nullptr;
     // cout << "creating " << self->classdef->cName << endl;
   }
   else
@@ -233,7 +233,7 @@ ClassData *WrapperRegistry::getOrConstructClass(const string &classname)
     data->cPureName = classname.substr(0, tplIdx);
     data->cTemplate = classname.substr(tplIdx + 1, classname.find('>') - tplIdx - 1);
   }
-  data->baseclass = NULL;
+  data->baseclass = nullptr;
   data->constructor = cbDisableConstructor;
   mClasses[classname] = data;
   mClassList.push_back(data);
@@ -435,7 +435,7 @@ ClassData *WrapperRegistry::lookup(const string &name)
     if (it->first == name || it->second->cName == name)
       return it->second;
   }
-  return NULL;
+  return nullptr;
 }
 
 void WrapperRegistry::cleanup()
@@ -510,7 +510,7 @@ void WrapperRegistry::runPreInit()
   PyObject *sys_path = PySys_GetObject((char *)"path");
   for (size_t i = 0; i < mPaths.size(); i++) {
     PyObject *path = Manta::toPy(mPaths[i]);
-    if (sys_path == NULL || path == NULL || PyList_Append(sys_path, path) < 0) {
+    if (sys_path == nullptr || path == nullptr || PyList_Append(sys_path, path) < 0) {
       errMsg("unable to set python path");
     }
     Py_DECREF(path);
@@ -531,7 +531,7 @@ PyObject *WrapperRegistry::createPyObject(const string &classname,
     errMsg("Class " + classname + " doesn't exist.");
 
   // create object
-  PyObject *obj = cbNew(&classdef->typeInfo, NULL, NULL);
+  PyObject *obj = cbNew(&classdef->typeInfo, nullptr, nullptr);
   PbObject *self = (PbObject *)obj;
   PyObject *nkw = 0;
 
@@ -578,8 +578,8 @@ inline PyObject *castPy(PyTypeObject *p)
 PyObject *WrapperRegistry::initModule()
 {
   // generate and terminate all method lists
-  PyMethodDef sentinelFunc = {NULL, NULL, 0, NULL};
-  PyGetSetDef sentinelGetSet = {NULL, NULL, NULL, NULL, NULL};
+  PyMethodDef sentinelFunc = {nullptr, nullptr, 0, nullptr};
+  PyGetSetDef sentinelGetSet = {nullptr, nullptr, nullptr, nullptr, nullptr};
   for (int i = 0; i < (int)mClassList.size(); i++) {
     ClassData *cls = mClassList[i];
     cls->genMethods.clear();
@@ -599,11 +599,11 @@ PyObject *WrapperRegistry::initModule()
                                    gDefaultModuleName.c_str(),
                                    "Bridge module to the C++ solver",
                                    -1,
-                                   NULL,
-                                   NULL,
-                                   NULL,
-                                   NULL,
-                                   NULL};
+                                   nullptr,
+                                   nullptr,
+                                   nullptr,
+                                   nullptr,
+                                   nullptr};
   // get generic methods (plugin functions)
   MainModule.m_methods = &mClasses["__modclass__"]->genMethods[0];
 
@@ -613,8 +613,8 @@ PyObject *WrapperRegistry::initModule()
   PyObject *module = Py_InitModule(gDefaultModuleName.c_str(),
                                    &mClasses["__modclass__"]->genMethods[0]);
 #endif
-  if (module == NULL)
-    return NULL;
+  if (module == nullptr)
+    return nullptr;
 
   // load classes
   for (vector<ClassData *>::iterator it = mClassList.begin(); it != mClassList.end(); ++it) {
@@ -631,43 +631,43 @@ PyObject *WrapperRegistry::initModule()
 
     // define python classinfo
     PyTypeObject t = {
-        PyVarObject_HEAD_INIT(NULL, 0)(char *) data.pyName.c_str(),  // tp_name
-        sizeof(PbObject),                                            // tp_basicsize
-        0,                                                           // tp_itemsize
-        (destructor)cbDealloc,                                       // tp_dealloc
-        0,                                                           // tp_print
-        0,                                                           // tp_getattr
-        0,                                                           // tp_setattr
-        0,                                                           // tp_reserved
-        0,                                                           // tp_repr
-        num,                                                         // tp_as_number
-        0,                                                           // tp_as_sequence
-        0,                                                           // tp_as_mapping
-        0,                                                           // tp_hash
-        0,                                                           // tp_call
-        0,                                                           // tp_str
-        0,                                                           // tp_getattro
-        0,                                                           // tp_setattro
-        0,                                                           // tp_as_buffer
-        Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                    // tp_flags
-        nameptr,                                                     // tp_doc
-        0,                                                           // tp_traverse
-        0,                                                           // tp_clear
-        0,                                                           // tp_richcompare
-        0,                                                           // tp_weaklistoffset
-        0,                                                           // tp_iter
-        0,                                                           // tp_iternext
-        &data.genMethods[0],                                         // tp_methods
-        0,                                                           // tp_members
-        &data.genGetSet[0],                                          // tp_getset
-        0,                                                           // tp_base
-        0,                                                           // tp_dict
-        0,                                                           // tp_descr_get
-        0,                                                           // tp_descr_set
-        0,                                                           // tp_dictoffset
-        (initproc)(data.constructor),                                // tp_init
-        0,                                                           // tp_alloc
-        cbNew                                                        // tp_new
+        PyVarObject_HEAD_INIT(nullptr, 0)(char *) data.pyName.c_str(),  // tp_name
+        sizeof(PbObject),                                               // tp_basicsize
+        0,                                                              // tp_itemsize
+        (destructor)cbDealloc,                                          // tp_dealloc
+        0,                                                              // tp_print
+        0,                                                              // tp_getattr
+        0,                                                              // tp_setattr
+        0,                                                              // tp_reserved
+        0,                                                              // tp_repr
+        num,                                                            // tp_as_number
+        0,                                                              // tp_as_sequence
+        0,                                                              // tp_as_mapping
+        0,                                                              // tp_hash
+        0,                                                              // tp_call
+        0,                                                              // tp_str
+        0,                                                              // tp_getattro
+        0,                                                              // tp_setattro
+        0,                                                              // tp_as_buffer
+        Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                       // tp_flags
+        nameptr,                                                        // tp_doc
+        0,                                                              // tp_traverse
+        0,                                                              // tp_clear
+        0,                                                              // tp_richcompare
+        0,                                                              // tp_weaklistoffset
+        0,                                                              // tp_iter
+        0,                                                              // tp_iternext
+        &data.genMethods[0],                                            // tp_methods
+        0,                                                              // tp_members
+        &data.genGetSet[0],                                             // tp_getset
+        0,                                                              // tp_base
+        0,                                                              // tp_dict
+        0,                                                              // tp_descr_get
+        0,                                                              // tp_descr_set
+        0,                                                              // tp_dictoffset
+        (initproc)(data.constructor),                                   // tp_init
+        0,                                                              // tp_alloc
+        cbNew                                                           // tp_new
     };
     data.typeInfo = t;
 
@@ -722,7 +722,7 @@ bool canConvert(PyObject *obj, const string &classname)
 Manta::PbClass *objFromPy(PyObject *obj)
 {
   if (Py_TYPE(obj)->tp_dealloc != (destructor)cbDealloc)  // not a manta object
-    return NULL;
+    return nullptr;
 
   return ((PbObject *)obj)->instance;
 }

extern/mantaflow/helper/util/randomstream.h

@@ -270,7 +270,7 @@ inline void MTRand::seed()
   }
 
   // Was not successful, so use time() and clock() instead
-  seed(hash(time(NULL), clock()));
+  seed(hash(time(nullptr), clock()));
 }
 
 inline void MTRand::initialize(const uint32 intseed)

extern/mantaflow/helper/util/rcmatrix.h

@@ -157,18 +157,18 @@ template<class N, class T> struct RCMatrix {
   {
     for (N i = 0; i < n; i++) {
       dealloc_row(i);
-      matrix[i] = NULL;
+      matrix[i] = nullptr;
       if (offsets.size())
         offsets[i] = 0;
     }
   };
   bool empty(N i) const
   {
-    return matrix[i] == NULL;
+    return matrix[i] == nullptr;
   }
   N row_nonzero_size(N i) const
   {
-    return matrix[i] == NULL ? 0 : matrix[i]->index.size();
+    return matrix[i] == nullptr ? 0 : matrix[i]->index.size();
   }
   void resize(N size, N expected_none_zeros = 0)
   {
@@ -185,7 +185,7 @@ template<class N, class T> struct RCMatrix {
       // Expanding
       matrix.resize(size);
       for (N i = n; i < size; i++) {
-        matrix[i] = NULL;
+        matrix[i] = nullptr;
         if (offsets.size())
           offsets[i] = 0;
       }
@@ -209,7 +209,7 @@ template<class N, class T> struct RCMatrix {
     if (matrix[i]) {
       if (offsets.empty() || !offsets[i])
         delete matrix[i];
-      matrix[i] = NULL;
+      matrix[i] = nullptr;
       if (offsets.size())
         offsets[i] = 0;
     }
@@ -426,7 +426,7 @@ template<class N, class T> struct RCMatrix {
     }
     operator bool() const
     {
-      return rowEntry != NULL && k < (N)rowEntry->index.size();
+      return rowEntry != nullptr && k < (N)rowEntry->index.size();
     }
     Iterator &operator++()
     {
@@ -447,7 +447,7 @@ template<class N, class T> struct RCMatrix {
     }
     N size() const
     {
-      return rowEntry == NULL ? 0 : rowEntry->index.size();
+      return rowEntry == nullptr ? 0 : rowEntry->index.size();
     }
 
    protected:

extern/mantaflow/helper/util/simpleimage.cpp

@@ -35,7 +35,7 @@ bool SimpleImage::writePpm(
   }
 
   FILE *fp = fopen(filename.c_str(), "wb");
-  if (fp == NULL) {
+  if (fp == nullptr) {
     errMsg("SimpleImage::WritePPM Unable to open '" << filename << "' for writing");
     return false;
   }
@@ -96,7 +96,7 @@ bool SimpleImage::initFromPpm(std::string filename)
   }
 
   // 1st line: PPM or PGM
-  if (fgets(line, MAXLINE, fp) == NULL) {
+  if (fgets(line, MAXLINE, fp) == nullptr) {
     if (mAbortOnError)
       debMsg("SimpleImage::initFromPpm fgets failed", 1);
     return 0;
@@ -114,7 +114,7 @@ bool SimpleImage::initFromPpm(std::string filename)
 
   // Read in width and height, & allocate space
   // 2nd line: width height
-  if (fgets(line, MAXLINE, fp) == NULL) {
+  if (fgets(line, MAXLINE, fp) == nullptr) {
     if (mAbortOnError)
       errMsg("SimpleImage::initFromPpm fgets failed");
     return 0;
@@ -156,14 +156,14 @@ bool SimpleImage::initFromPpm(std::string filename)
 
   // Read in maximum value (ignore) , could be scanned with sscanf as well, but this should be
   // 255... 3rd line
-  if (fgets(line, MAXLINE, fp) == NULL) {
+  if (fgets(line, MAXLINE, fp) == nullptr) {
     if (mAbortOnError)
       errMsg("SimpleImage::initFromPpm fgets failed");
     return 0;
   }
 
   // Read in the pixel array row-by-row: 1st row = top scanline */
-  unsigned char *ptr = NULL;
+  unsigned char *ptr = nullptr;
   ptr = &pic[(windH - 1) * rowsize];
   for (int i = windH; i > 0; i--) {
     assertMsg(fread((void *)ptr, 1, rowsize, fp) == rowsize,

extern/mantaflow/helper/util/simpleimage.h

@@ -29,7 +29,7 @@ namespace Manta {
 class SimpleImage {
  public:
   // cons/des
-  SimpleImage() : mSize(-1), mpData(NULL), mAbortOnError(true){};
+  SimpleImage() : mSize(-1), mpData(nullptr), mAbortOnError(true){};
   virtual ~SimpleImage()
   {
     if (mpData)

extern/mantaflow/preprocessed/conjugategrad.cpp

@@ -688,7 +688,7 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "cgSolveDiffusion", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);

extern/mantaflow/preprocessed/fastmarch.cpp

@@ -617,7 +617,7 @@ struct knUnprojectNormalComp : public KernelBase {
 void extrapolateMACSimple(FlagGrid &flags,
                           MACGrid &vel,
                           int distance = 4,
-                          LevelsetGrid *phiObs = NULL,
+                          LevelsetGrid *phiObs = nullptr,
                           bool intoObs = false)
 {
   Grid<int> tmp(flags.getParent());
@@ -669,13 +669,13 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "extrapolateMACSimple", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
       MACGrid &vel = *_args.getPtr<MACGrid>("vel", 1, &_lock);
       int distance = _args.getOpt<int>("distance", 2, 4, &_lock);
-      LevelsetGrid *phiObs = _args.getPtrOpt<LevelsetGrid>("phiObs", 3, NULL, &_lock);
+      LevelsetGrid *phiObs = _args.getPtrOpt<LevelsetGrid>("phiObs", 3, nullptr, &_lock);
       bool intoObs = _args.getOpt<bool>("intoObs", 4, false, &_lock);
       _retval = getPyNone();
       extrapolateMACSimple(flags, vel, distance, phiObs, intoObs);
@@ -839,7 +839,7 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "extrapolateMACFromWeight", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       MACGrid &vel = *_args.getPtr<MACGrid>("vel", 0, &_lock);
@@ -1092,7 +1092,7 @@ static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "extrapolateLsSimple", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Grid<Real> &phi = *_args.getPtr<Grid<Real>>("phi", 0, &_lock);
@@ -1170,7 +1170,7 @@ static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "extrapolateVec3Simple", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Grid<Vec3> &vel = *_args.getPtr<Grid<Vec3>>("vel", 0, &_lock);

extern/mantaflow/preprocessed/fastmarch.h

@@ -181,7 +181,7 @@ template<class T, int TDIR> class FastMarch {
             Grid<int> &fmFlags,
             Grid<Real> &levelset,
             Real maxTime,
-            MACGrid *velTransport = NULL);
+            MACGrid *velTransport = nullptr);
   ~FastMarch()
   {
   }

extern/mantaflow/preprocessed/fileio/iogrids.cpp

@@ -440,7 +440,7 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "getUniFileSize", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const string &name = _args.get<string>("name", 0, &_lock);
@@ -479,7 +479,7 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "printUniFileInfoString", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const string &name = _args.get<string>("name", 0, &_lock);
@@ -715,7 +715,7 @@ template<> int writeGridVol<Real>(const string &name, Grid<Real> *grid)
   header.bboxMax = Vec3(0.5);
 
   FILE *fp = fopen(name.c_str(), "wb");
-  if (fp == NULL) {
+  if (fp == nullptr) {
     errMsg("writeGridVol: Cannot open '" << name << "'");
     return 0;
   }
@@ -749,7 +749,7 @@ template<> int readGridVol<Real>(const string &name, Grid<Real> *grid)
 
   volHeader header;
   FILE *fp = fopen(name.c_str(), "rb");
-  if (fp == NULL) {
+  if (fp == nullptr) {
     errMsg("readGridVol: Cannot open '" << name << "'");
     return 0;
   }
@@ -844,11 +844,11 @@ int readGrid4dUni(
            1);
 
 #if NO_ZLIB != 1
-  gzFile gzf = NULL;
+  gzFile gzf = nullptr;
   char ID[5] = {0, 0, 0, 0, 0};
 
   // optionally - reuse file handle, if valid one is passed in fileHandle pointer...
-  if ((!fileHandle) || (fileHandle && (*fileHandle == NULL))) {
+  if ((!fileHandle) || (fileHandle && (*fileHandle == nullptr))) {
     gzf = (gzFile)safeGzopen(name.c_str(), "rb");
     if (!gzf) {
       errMsg("readGrid4dUni: can't open file " << name);
@@ -969,11 +969,11 @@ int readGrid4dUni(
 void readGrid4dUniCleanup(void **fileHandle)
 {
 #if NO_ZLIB != 1
-  gzFile gzf = NULL;
+  gzFile gzf = nullptr;
   if (fileHandle) {
     gzf = (gzFile)(*fileHandle);
     gzclose(gzf);
-    *fileHandle = NULL;
+    *fileHandle = nullptr;
   }
 #else
   debMsg("file format not supported without zlib", 1);
@@ -1171,7 +1171,7 @@ int readGridsNumpy(const string &name, std::vector<PbClass *> *grids)
 
 // adopted from getUniFileSize
 void getNpzFileSize(
-    const string &name, int &x, int &y, int &z, int *t = NULL, std::string *info = NULL)
+    const string &name, int &x, int &y, int &z, int *t = nullptr, std::string *info = nullptr)
 {
   x = y = z = 0;
 
@@ -1207,7 +1207,7 @@ static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "getNpzFileSize", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const string &name = _args.get<string>("name", 0, &_lock);
@@ -1289,7 +1289,7 @@ static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "quantizeGrid", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Grid<Real> &grid = *_args.getPtr<Grid<Real>>("grid", 0, &_lock);
@@ -1365,7 +1365,7 @@ static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "quantizeGridVec3", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Grid<Vec3> &grid = *_args.getPtr<Grid<Vec3>>("grid", 0, &_lock);

extern/mantaflow/preprocessed/fileio/ioutil.cpp

@@ -40,7 +40,7 @@ namespace Manta {
 #if defined(WIN32) || defined(_WIN32)
 static wstring stringToWstring(const char *str)
 {
-  const int length_wc = MultiByteToWideChar(CP_UTF8, 0, str, strlen(str), NULL, 0);
+  const int length_wc = MultiByteToWideChar(CP_UTF8, 0, str, strlen(str), nullptr, 0);
   wstring strWide(length_wc, 0);
   MultiByteToWideChar(CP_UTF8, 0, str, strlen(str), &strWide[0], length_wc);
   return strWide;

extern/mantaflow/preprocessed/fileio/mantaio.cpp

@@ -51,7 +51,7 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "load", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const string &name = _args.get<string>("name", 0, &_lock);
@@ -118,7 +118,7 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "save", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const string &name = _args.get<string>("name", 0, &_lock);

extern/mantaflow/preprocessed/fileio/mantaio.h

@@ -93,8 +93,8 @@ template<class T>
 int readGrid4dUni(const std::string &name,
                   Grid4d<T> *grid,
                   int readTslice = -1,
-                  Grid4d<T> *slice = NULL,
-                  void **fileHandle = NULL);
+                  Grid4d<T> *slice = nullptr,
+                  void **fileHandle = nullptr);
 void readGrid4dUniCleanup(void **fileHandle);
 template<class T> int writeGrid4dRaw(const std::string &name, Grid4d<T> *grid);
 template<class T> int readGrid4dRaw(const std::string &name, Grid4d<T> *grid);
@@ -111,8 +111,12 @@ template<class T> int writeMdataUni(const std::string &name, MeshDataImpl<T> *md
 template<class T> int readMdataUni(const std::string &name, MeshDataImpl<T> *mdata);
 
 // Helpers
-void getUniFileSize(
-    const std::string &name, int &x, int &y, int &z, int *t = NULL, std::string *info = NULL);
+void getUniFileSize(const std::string &name,
+                    int &x,
+                    int &y,
+                    int &z,
+                    int *t = nullptr,
+                    std::string *info = nullptr);
 void *safeGzopen(const char *filename, const char *mode);
 #if OPENVDB == 1
 template<class S, class T> void convertFrom(S &in, T *out);

extern/mantaflow/preprocessed/fluidsolver.cpp

@@ -172,7 +172,7 @@ PbClass *FluidSolver::create(PbType t, PbTypeVec T, const string &name)
 
   PbClass *ret = PbClass::createPyObject(t.str() + T.str(), name, _args, this);
 #else
-  PbClass *ret = NULL;
+  PbClass *ret = nullptr;
 #endif
   return ret;
 }
@@ -259,7 +259,7 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "mantaMsg", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const std::string &out = _args.get<std::string>("out", 0, &_lock);
@@ -297,7 +297,7 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "printBuildInfo", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       _retval = toPy(printBuildInfo());
@@ -331,7 +331,7 @@ static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "setDebugLevel", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       int level = _args.getOpt<int>("level", 0, 1, &_lock);
@@ -371,7 +371,7 @@ static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "assertNumpy", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       _retval = getPyNone();

extern/mantaflow/preprocessed/fluidsolver.h

@@ -73,7 +73,7 @@ class FluidSolver : public PbClass {
       FluidSolver *pbo = dynamic_cast<FluidSolver *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "FluidSolver::getGridSize", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -121,7 +121,7 @@ class FluidSolver : public PbClass {
       FluidSolver *pbo = dynamic_cast<FluidSolver *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "FluidSolver::printMemInfo", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -147,7 +147,7 @@ class FluidSolver : public PbClass {
       FluidSolver *pbo = dynamic_cast<FluidSolver *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "FluidSolver::step", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -173,7 +173,7 @@ class FluidSolver : public PbClass {
       FluidSolver *pbo = dynamic_cast<FluidSolver *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "FluidSolver::adaptTimestep", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         Real maxVel = _args.get<Real>("maxVel", 0, &_lock);
@@ -200,7 +200,7 @@ class FluidSolver : public PbClass {
       FluidSolver *pbo = dynamic_cast<FluidSolver *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "FluidSolver::create", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         PbType type = _args.get<PbType>("type", 0, &_lock);

extern/mantaflow/preprocessed/gitinfo.h

@@ -1,3 +1,3 @@
 
 
-#define MANTA_GIT_VERSION "commit dffc3481b835dfa048effcbb8a9e613294ecae14"
+#define MANTA_GIT_VERSION "commit 73990a8a5b876e2b136a646258f714c08c5828da"

extern/mantaflow/preprocessed/grid.cpp

@@ -1290,7 +1290,7 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "gridMaxDiff", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Grid<Real> &g1 = *_args.getPtr<Grid<Real>>("g1", 0, &_lock);
@@ -1330,7 +1330,7 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "gridMaxDiffInt", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Grid<int> &g1 = *_args.getPtr<Grid<int>>("g1", 0, &_lock);
@@ -1377,7 +1377,7 @@ static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "gridMaxDiffVec3", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Grid<Vec3> &g1 = *_args.getPtr<Grid<Vec3>>("g1", 0, &_lock);
@@ -1470,7 +1470,7 @@ static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "copyMacToVec3", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       MACGrid &source = *_args.getPtr<MACGrid>("source", 0, &_lock);
@@ -1507,7 +1507,7 @@ static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "convertMacToVec3", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       MACGrid &source = *_args.getPtr<MACGrid>("source", 0, &_lock);
@@ -1604,7 +1604,7 @@ static PyObject *_W_5(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "resampleVec3ToMac", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Grid<Vec3> &source = *_args.getPtr<Grid<Vec3>>("source", 0, &_lock);
@@ -1697,7 +1697,7 @@ static PyObject *_W_6(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "resampleMacToVec3", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       MACGrid &source = *_args.getPtr<MACGrid>("source", 0, &_lock);
@@ -1789,7 +1789,7 @@ static PyObject *_W_7(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "copyLevelsetToReal", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       LevelsetGrid &source = *_args.getPtr<LevelsetGrid>("source", 0, &_lock);
@@ -1911,7 +1911,7 @@ static PyObject *_W_8(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "copyVec3ToReal", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Grid<Vec3> &source = *_args.getPtr<Grid<Vec3>>("source", 0, &_lock);
@@ -2035,7 +2035,7 @@ static PyObject *_W_9(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "copyRealToVec3", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Grid<Real> &sourceX = *_args.getPtr<Grid<Real>>("sourceX", 0, &_lock);
@@ -2074,7 +2074,7 @@ static PyObject *_W_10(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "convertLevelsetToReal", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       LevelsetGrid &source = *_args.getPtr<LevelsetGrid>("source", 0, &_lock);
@@ -2139,7 +2139,7 @@ static PyObject *_W_11(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "swapComponents", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Grid<Vec3> &vel = *_args.getPtr<Grid<Vec3>>("vel", 0, &_lock);
@@ -2181,7 +2181,7 @@ static PyObject *_W_12(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "getUvWeight", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Grid<Vec3> &uv = *_args.getPtr<Grid<Vec3>>("uv", 0, &_lock);
@@ -2280,7 +2280,7 @@ struct knResetUvGrid : public KernelBase {
   const Vec3 *offset;
 };
 
-void resetUvGrid(Grid<Vec3> &target, const Vec3 *offset = NULL)
+void resetUvGrid(Grid<Vec3> &target, const Vec3 *offset = nullptr)
 {
   knResetUvGrid reset(target,
                       offset);  // note, llvm complains about anonymous declaration here... ?
@@ -2292,11 +2292,11 @@ static PyObject *_W_13(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "resetUvGrid", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Grid<Vec3> &target = *_args.getPtr<Grid<Vec3>>("target", 0, &_lock);
-      const Vec3 *offset = _args.getPtrOpt<Vec3>("offset", 1, NULL, &_lock);
+      const Vec3 *offset = _args.getPtrOpt<Vec3>("offset", 1, nullptr, &_lock);
       _retval = getPyNone();
       resetUvGrid(target, offset);
       _args.check();
@@ -2318,7 +2318,7 @@ void PbRegister_resetUvGrid()
 }
 
 void updateUvWeight(
-    Real resetTime, int index, int numUvs, Grid<Vec3> &uv, const Vec3 *offset = NULL)
+    Real resetTime, int index, int numUvs, Grid<Vec3> &uv, const Vec3 *offset = nullptr)
 {
   const Real t = uv.getParent()->getTime();
   Real timeOff = resetTime / (Real)numUvs;
@@ -2357,14 +2357,14 @@ static PyObject *_W_14(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "updateUvWeight", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Real resetTime = _args.get<Real>("resetTime", 0, &_lock);
       int index = _args.get<int>("index", 1, &_lock);
       int numUvs = _args.get<int>("numUvs", 2, &_lock);
       Grid<Vec3> &uv = *_args.getPtr<Grid<Vec3>>("uv", 3, &_lock);
-      const Vec3 *offset = _args.getPtrOpt<Vec3>("offset", 4, NULL, &_lock);
+      const Vec3 *offset = _args.getPtrOpt<Vec3>("offset", 4, nullptr, &_lock);
       _retval = getPyNone();
       updateUvWeight(resetTime, index, numUvs, uv, offset);
       _args.check();
@@ -2812,7 +2812,7 @@ struct knCountFluidCells : public KernelBase {
 
 //! averaged value for all cells (if flags are given, only for fluid cells)
 
-Real getGridAvg(Grid<Real> &source, FlagGrid *flags = NULL)
+Real getGridAvg(Grid<Real> &source, FlagGrid *flags = nullptr)
 {
   double sum = knGridTotalSum(source, flags);
 
@@ -2837,11 +2837,11 @@ static PyObject *_W_15(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "getGridAvg", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Grid<Real> &source = *_args.getPtr<Grid<Real>>("source", 0, &_lock);
-      FlagGrid *flags = _args.getPtrOpt<FlagGrid>("flags", 1, NULL, &_lock);
+      FlagGrid *flags = _args.getPtrOpt<FlagGrid>("flags", 1, nullptr, &_lock);
       _retval = toPy(getGridAvg(source, flags));
       _args.check();
     }
@@ -2920,7 +2920,7 @@ static PyObject *_W_16(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "getComponent", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const Grid<Vec3> &source = *_args.getPtr<Grid<Vec3>>("source", 0, &_lock);
@@ -3003,7 +3003,7 @@ static PyObject *_W_17(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "setComponent", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const Grid<Real> &source = *_args.getPtr<Grid<Real>>("source", 0, &_lock);
@@ -3373,7 +3373,7 @@ static PyObject *_W_18(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "markIsolatedFluidCell", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
@@ -3427,7 +3427,7 @@ static PyObject *_W_19(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "copyMACData", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const MACGrid &source = *_args.getPtr<MACGrid>("source", 0, &_lock);

extern/mantaflow/preprocessed/grid.h

@@ -79,7 +79,7 @@ class GridBase : public PbClass {
       GridBase *pbo = dynamic_cast<GridBase *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "GridBase::getSizeX", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -107,7 +107,7 @@ class GridBase : public PbClass {
       GridBase *pbo = dynamic_cast<GridBase *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "GridBase::getSizeY", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -135,7 +135,7 @@ class GridBase : public PbClass {
       GridBase *pbo = dynamic_cast<GridBase *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "GridBase::getSizeZ", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -163,7 +163,7 @@ class GridBase : public PbClass {
       GridBase *pbo = dynamic_cast<GridBase *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "GridBase::getSize", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -233,7 +233,7 @@ class GridBase : public PbClass {
       GridBase *pbo = dynamic_cast<GridBase *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "GridBase::is3D", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -274,7 +274,7 @@ class GridBase : public PbClass {
       GridBase *pbo = dynamic_cast<GridBase *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "GridBase::is4D", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -301,7 +301,7 @@ class GridBase : public PbClass {
       GridBase *pbo = dynamic_cast<GridBase *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "GridBase::getSizeT", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -328,7 +328,7 @@ class GridBase : public PbClass {
       GridBase *pbo = dynamic_cast<GridBase *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "GridBase::getStrideT", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -367,7 +367,7 @@ class GridBase : public PbClass {
       GridBase *pbo = dynamic_cast<GridBase *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "GridBase::setName", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const std::string &name = _args.get<std::string>("name", 0, &_lock);
@@ -447,7 +447,7 @@ template<class T> class Grid : public GridBase {
       Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid::save", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         std::string name = _args.get<std::string>("name", 0, &_lock);
@@ -472,7 +472,7 @@ template<class T> class Grid : public GridBase {
       Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid::load", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         std::string name = _args.get<std::string>("name", 0, &_lock);
@@ -498,7 +498,7 @@ template<class T> class Grid : public GridBase {
       Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid::clear", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -625,7 +625,7 @@ template<class T> class Grid : public GridBase {
       Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid::copyFrom", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const Grid<T> &a = *_args.getPtr<Grid<T>>("a", 0, &_lock);
@@ -655,7 +655,7 @@ template<class T> class Grid : public GridBase {
       Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid::getGridType", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -680,7 +680,7 @@ template<class T> class Grid : public GridBase {
       Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid::add", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const Grid<T> &a = *_args.getPtr<Grid<T>>("a", 0, &_lock);
@@ -706,7 +706,7 @@ template<class T> class Grid : public GridBase {
       Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid::sub", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const Grid<T> &a = *_args.getPtr<Grid<T>>("a", 0, &_lock);
@@ -733,7 +733,7 @@ template<class T> class Grid : public GridBase {
       Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid::setConst", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         T s = _args.get<T>("s", 0, &_lock);
@@ -760,7 +760,7 @@ template<class T> class Grid : public GridBase {
       Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid::addConst", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         T s = _args.get<T>("s", 0, &_lock);
@@ -787,7 +787,7 @@ template<class T> class Grid : public GridBase {
       Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid::addScaled", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const Grid<T> &a = *_args.getPtr<Grid<T>>("a", 0, &_lock);
@@ -815,7 +815,7 @@ template<class T> class Grid : public GridBase {
       Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid::mult", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const Grid<T> &a = *_args.getPtr<Grid<T>>("a", 0, &_lock);
@@ -842,7 +842,7 @@ template<class T> class Grid : public GridBase {
       Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid::multConst", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         T s = _args.get<T>("s", 0, &_lock);
@@ -869,7 +869,7 @@ template<class T> class Grid : public GridBase {
       Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid::safeDivide", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const Grid<T> &a = *_args.getPtr<Grid<T>>("a", 0, &_lock);
@@ -895,7 +895,7 @@ template<class T> class Grid : public GridBase {
       Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid::clamp", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         Real min = _args.get<Real>("min", 0, &_lock);
@@ -923,7 +923,7 @@ template<class T> class Grid : public GridBase {
       Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid::stomp", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const T &threshold = *_args.getPtr<T>("threshold", 0, &_lock);
@@ -950,7 +950,7 @@ template<class T> class Grid : public GridBase {
       Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid::permuteAxes", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         int axis0 = _args.get<int>("axis0", 0, &_lock);
@@ -979,7 +979,7 @@ template<class T> class Grid : public GridBase {
       Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid::permuteAxesCopyToGrid", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         int axis0 = _args.get<int>("axis0", 0, &_lock);
@@ -1009,7 +1009,7 @@ template<class T> class Grid : public GridBase {
       Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid::join", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const Grid<T> &a = *_args.getPtr<Grid<T>>("a", 0, &_lock);
@@ -1038,7 +1038,7 @@ template<class T> class Grid : public GridBase {
       Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid::getMaxAbs", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -1063,7 +1063,7 @@ template<class T> class Grid : public GridBase {
       Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid::getMax", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -1088,7 +1088,7 @@ template<class T> class Grid : public GridBase {
       Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid::getMin", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -1113,7 +1113,7 @@ template<class T> class Grid : public GridBase {
       Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid::getL1", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         int bnd = _args.getOpt<int>("bnd", 0, 0, &_lock);
@@ -1139,7 +1139,7 @@ template<class T> class Grid : public GridBase {
       Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid::getL2", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         int bnd = _args.getOpt<int>("bnd", 0, 0, &_lock);
@@ -1165,7 +1165,7 @@ template<class T> class Grid : public GridBase {
       Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid::setBound", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         T value = _args.get<T>("value", 0, &_lock);
@@ -1193,7 +1193,7 @@ template<class T> class Grid : public GridBase {
       Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid::setBoundNeumann", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         int boundaryWidth = _args.getOpt<int>("boundaryWidth", 0, 1, &_lock);
@@ -1220,7 +1220,7 @@ template<class T> class Grid : public GridBase {
       Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid::getDataPointer", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -1245,7 +1245,7 @@ template<class T> class Grid : public GridBase {
       Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid::printGrid", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         int zSlice = _args.getOpt<int>("zSlice", 0, -1, &_lock);
@@ -1395,7 +1395,7 @@ class MACGrid : public Grid<Vec3> {
       MACGrid *pbo = dynamic_cast<MACGrid *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "MACGrid::setBoundMAC", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         Vec3 value = _args.get<Vec3>("value", 0, &_lock);
@@ -1616,7 +1616,7 @@ class FlagGrid : public Grid<int> {
       FlagGrid *pbo = dynamic_cast<FlagGrid *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "FlagGrid::initDomain", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const int &boundaryWidth = _args.getOpt<int>("boundaryWidth", 0, 0, &_lock);
@@ -1650,7 +1650,7 @@ class FlagGrid : public Grid<int> {
       FlagGrid *pbo = dynamic_cast<FlagGrid *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "FlagGrid::updateFromLevelset", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         LevelsetGrid &levelset = *_args.getPtr<LevelsetGrid>("levelset", 0, &_lock);
@@ -1677,7 +1677,7 @@ class FlagGrid : public Grid<int> {
       FlagGrid *pbo = dynamic_cast<FlagGrid *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "FlagGrid::fillGrid", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         int type = _args.getOpt<int>("type", 0, TypeFluid, &_lock);
@@ -1698,7 +1698,7 @@ class FlagGrid : public Grid<int> {
   //! count no. of cells matching flags via "AND"
   //! warning for large grids! only regular int returned (due to python interface)
   //! optionally creates mask in RealGrid (1 where flag matches, 0 otherwise)
-  int countCells(int flag, int bnd = 0, Grid<Real> *mask = NULL);
+  int countCells(int flag, int bnd = 0, Grid<Real> *mask = nullptr);
   static PyObject *_W_44(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
   {
     try {
@@ -1706,12 +1706,12 @@ class FlagGrid : public Grid<int> {
       FlagGrid *pbo = dynamic_cast<FlagGrid *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "FlagGrid::countCells", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         int flag = _args.get<int>("flag", 0, &_lock);
         int bnd = _args.getOpt<int>("bnd", 1, 0, &_lock);
-        Grid<Real> *mask = _args.getPtrOpt<Grid<Real>>("mask", 2, NULL, &_lock);
+        Grid<Real> *mask = _args.getPtrOpt<Grid<Real>>("mask", 2, nullptr, &_lock);
         pbo->_args.copy(_args);
         _retval = toPy(pbo->countCells(flag, bnd, mask));
         pbo->_args.check();

extern/mantaflow/preprocessed/grid4d.cpp

@@ -888,7 +888,7 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "getComp4d", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const Grid4d<Vec4> &src = *_args.getPtr<Grid4d<Vec4>>("src", 0, &_lock);
@@ -926,7 +926,7 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "setComp4d", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const Grid4d<Real> &src = *_args.getPtr<Grid4d<Real>>("src", 0, &_lock);
@@ -1170,7 +1170,7 @@ static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "grid4dMaxDiff", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Grid4d<Real> &g1 = *_args.getPtr<Grid4d<Real>>("g1", 0, &_lock);
@@ -1210,7 +1210,7 @@ static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "grid4dMaxDiffInt", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Grid4d<int> &g1 = *_args.getPtr<Grid4d<int>>("g1", 0, &_lock);
@@ -1254,7 +1254,7 @@ static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "grid4dMaxDiffVec3", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Grid4d<Vec3> &g1 = *_args.getPtr<Grid4d<Vec3>>("g1", 0, &_lock);
@@ -1298,7 +1298,7 @@ static PyObject *_W_5(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "grid4dMaxDiffVec4", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Grid4d<Vec4> &g1 = *_args.getPtr<Grid4d<Vec4>>("g1", 0, &_lock);
@@ -1422,7 +1422,7 @@ static PyObject *_W_6(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "setRegion4d", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Grid4d<Real> &dst = *_args.getPtr<Grid4d<Real>>("dst", 0, &_lock);
@@ -1461,7 +1461,7 @@ static PyObject *_W_7(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "setRegion4dVec4", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Grid4d<Vec4> &dst = *_args.getPtr<Grid4d<Vec4>>("dst", 0, &_lock);
@@ -1510,7 +1510,7 @@ static PyObject *_W_8(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "getSliceFrom4d", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Grid4d<Real> &src = *_args.getPtr<Grid4d<Real>>("src", 0, &_lock);
@@ -1537,7 +1537,7 @@ void PbRegister_getSliceFrom4d()
 }
 
 //! slow helper to visualize tests, get a 3d slice of a 4d vec4 grid
-void getSliceFrom4dVec(Grid4d<Vec4> &src, int srct, Grid<Vec3> &dst, Grid<Real> *dstt = NULL)
+void getSliceFrom4dVec(Grid4d<Vec4> &src, int srct, Grid<Vec3> &dst, Grid<Real> *dstt = nullptr)
 {
   const int bnd = 0;
   if (!src.isInBounds(Vec4i(bnd, bnd, bnd, srct)))
@@ -1561,13 +1561,13 @@ static PyObject *_W_9(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "getSliceFrom4dVec", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Grid4d<Vec4> &src = *_args.getPtr<Grid4d<Vec4>>("src", 0, &_lock);
       int srct = _args.get<int>("srct", 1, &_lock);
       Grid<Vec3> &dst = *_args.getPtr<Grid<Vec3>>("dst", 2, &_lock);
-      Grid<Real> *dstt = _args.getPtrOpt<Grid<Real>>("dstt", 3, NULL, &_lock);
+      Grid<Real> *dstt = _args.getPtrOpt<Grid<Real>>("dstt", 3, nullptr, &_lock);
       _retval = getPyNone();
       getSliceFrom4dVec(src, srct, dst, dstt);
       _args.check();
@@ -1716,7 +1716,7 @@ static PyObject *_W_10(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "interpolateGrid4d", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Grid4d<Real> &target = *_args.getPtr<Grid4d<Real>>("target", 0, &_lock);
@@ -1763,7 +1763,7 @@ static PyObject *_W_11(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "interpolateGrid4dVec", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Grid4d<Vec4> &target = *_args.getPtr<Grid4d<Vec4>>("target", 0, &_lock);

extern/mantaflow/preprocessed/grid4d.h

@@ -69,7 +69,7 @@ class Grid4dBase : public PbClass {
       Grid4dBase *pbo = dynamic_cast<Grid4dBase *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid4dBase::getSizeX", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -97,7 +97,7 @@ class Grid4dBase : public PbClass {
       Grid4dBase *pbo = dynamic_cast<Grid4dBase *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid4dBase::getSizeY", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -125,7 +125,7 @@ class Grid4dBase : public PbClass {
       Grid4dBase *pbo = dynamic_cast<Grid4dBase *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid4dBase::getSizeZ", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -153,7 +153,7 @@ class Grid4dBase : public PbClass {
       Grid4dBase *pbo = dynamic_cast<Grid4dBase *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid4dBase::getSizeT", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -181,7 +181,7 @@ class Grid4dBase : public PbClass {
       Grid4dBase *pbo = dynamic_cast<Grid4dBase *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid4dBase::getSize", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -256,7 +256,7 @@ class Grid4dBase : public PbClass {
       Grid4dBase *pbo = dynamic_cast<Grid4dBase *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid4dBase::is3D", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -283,7 +283,7 @@ class Grid4dBase : public PbClass {
       Grid4dBase *pbo = dynamic_cast<Grid4dBase *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid4dBase::is4D", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -380,7 +380,7 @@ template<class T> class Grid4d : public Grid4dBase {
       Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid4d::save", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         std::string name = _args.get<std::string>("name", 0, &_lock);
@@ -405,7 +405,7 @@ template<class T> class Grid4d : public Grid4dBase {
       Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid4d::load", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         std::string name = _args.get<std::string>("name", 0, &_lock);
@@ -431,7 +431,7 @@ template<class T> class Grid4d : public Grid4dBase {
       Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid4d::clear", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -535,7 +535,7 @@ template<class T> class Grid4d : public Grid4dBase {
       Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid4d::copyFrom", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const Grid4d<T> &a = *_args.getPtr<Grid4d<T>>("a", 0, &_lock);
@@ -565,7 +565,7 @@ template<class T> class Grid4d : public Grid4dBase {
       Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid4d::add", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const Grid4d<T> &a = *_args.getPtr<Grid4d<T>>("a", 0, &_lock);
@@ -591,7 +591,7 @@ template<class T> class Grid4d : public Grid4dBase {
       Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid4d::sub", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const Grid4d<T> &a = *_args.getPtr<Grid4d<T>>("a", 0, &_lock);
@@ -618,7 +618,7 @@ template<class T> class Grid4d : public Grid4dBase {
       Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid4d::setConst", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         T s = _args.get<T>("s", 0, &_lock);
@@ -645,7 +645,7 @@ template<class T> class Grid4d : public Grid4dBase {
       Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid4d::addConst", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         T s = _args.get<T>("s", 0, &_lock);
@@ -672,7 +672,7 @@ template<class T> class Grid4d : public Grid4dBase {
       Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid4d::addScaled", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const Grid4d<T> &a = *_args.getPtr<Grid4d<T>>("a", 0, &_lock);
@@ -700,7 +700,7 @@ template<class T> class Grid4d : public Grid4dBase {
       Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid4d::mult", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const Grid4d<T> &a = *_args.getPtr<Grid4d<T>>("a", 0, &_lock);
@@ -727,7 +727,7 @@ template<class T> class Grid4d : public Grid4dBase {
       Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid4d::multConst", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         T s = _args.get<T>("s", 0, &_lock);
@@ -754,7 +754,7 @@ template<class T> class Grid4d : public Grid4dBase {
       Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid4d::clamp", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         Real min = _args.get<Real>("min", 0, &_lock);
@@ -783,7 +783,7 @@ template<class T> class Grid4d : public Grid4dBase {
       Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid4d::getMaxAbs", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -808,7 +808,7 @@ template<class T> class Grid4d : public Grid4dBase {
       Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid4d::getMax", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -833,7 +833,7 @@ template<class T> class Grid4d : public Grid4dBase {
       Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid4d::getMin", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -858,7 +858,7 @@ template<class T> class Grid4d : public Grid4dBase {
       Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid4d::setBound", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         T value = _args.get<T>("value", 0, &_lock);
@@ -886,7 +886,7 @@ template<class T> class Grid4d : public Grid4dBase {
       Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid4d::setBoundNeumann", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         int boundaryWidth = _args.getOpt<int>("boundaryWidth", 0, 1, &_lock);
@@ -913,7 +913,7 @@ template<class T> class Grid4d : public Grid4dBase {
       Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Grid4d::printGrid", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         int zSlice = _args.getOpt<int>("zSlice", 0, -1, &_lock);

extern/mantaflow/preprocessed/levelset.cpp

@@ -510,7 +510,7 @@ static void doReinitMarch(Grid<Real> &phi,
   const int dim = (phi.is3D() ? 3 : 2);
   Grid<int> fmFlags(phi.getParent());
 
-  FastMarch<FmHeapEntryIn, -1> marchIn(flags, fmFlags, phi, maxTime, NULL);
+  FastMarch<FmHeapEntryIn, -1> marchIn(flags, fmFlags, phi, maxTime, nullptr);
 
   // march inside
   InitFmIn(flags, fmFlags, phi, ignoreWalls, obstacleType);

extern/mantaflow/preprocessed/levelset.h

@@ -60,7 +60,7 @@ class LevelsetGrid : public Grid<Real> {
 
   void reinitMarching(const FlagGrid &flags,
                       Real maxTime = 4.0,
-                      MACGrid *velTransport = NULL,
+                      MACGrid *velTransport = nullptr,
                       bool ignoreWalls = false,
                       bool correctOuterLayer = true,
                       int obstacleType = FlagGrid::TypeObstacle);
@@ -71,12 +71,12 @@ class LevelsetGrid : public Grid<Real> {
       LevelsetGrid *pbo = dynamic_cast<LevelsetGrid *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "LevelsetGrid::reinitMarching", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
         Real maxTime = _args.getOpt<Real>("maxTime", 1, 4.0, &_lock);
-        MACGrid *velTransport = _args.getPtrOpt<MACGrid>("velTransport", 2, NULL, &_lock);
+        MACGrid *velTransport = _args.getPtrOpt<MACGrid>("velTransport", 2, nullptr, &_lock);
         bool ignoreWalls = _args.getOpt<bool>("ignoreWalls", 3, false, &_lock);
         bool correctOuterLayer = _args.getOpt<bool>("correctOuterLayer", 4, true, &_lock);
         int obstacleType = _args.getOpt<int>("obstacleType", 5, FlagGrid::TypeObstacle, &_lock);
@@ -104,7 +104,7 @@ class LevelsetGrid : public Grid<Real> {
       LevelsetGrid *pbo = dynamic_cast<LevelsetGrid *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "LevelsetGrid::createMesh", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         Mesh &mesh = *_args.getPtr<Mesh>("mesh", 0, &_lock);
@@ -131,7 +131,7 @@ class LevelsetGrid : public Grid<Real> {
       LevelsetGrid *pbo = dynamic_cast<LevelsetGrid *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "LevelsetGrid::join", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const LevelsetGrid &o = *_args.getPtr<LevelsetGrid>("o", 0, &_lock);
@@ -149,7 +149,9 @@ class LevelsetGrid : public Grid<Real> {
     }
   }
 
-  void subtract(const LevelsetGrid &o, const FlagGrid *flags = NULL, const int subtractType = 0);
+  void subtract(const LevelsetGrid &o,
+                const FlagGrid *flags = nullptr,
+                const int subtractType = 0);
   static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
   {
     try {
@@ -157,11 +159,11 @@ class LevelsetGrid : public Grid<Real> {
       LevelsetGrid *pbo = dynamic_cast<LevelsetGrid *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "LevelsetGrid::subtract", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const LevelsetGrid &o = *_args.getPtr<LevelsetGrid>("o", 0, &_lock);
-        const FlagGrid *flags = _args.getPtrOpt<FlagGrid>("flags", 1, NULL, &_lock);
+        const FlagGrid *flags = _args.getPtrOpt<FlagGrid>("flags", 1, nullptr, &_lock);
         const int subtractType = _args.getOpt<int>("subtractType", 2, 0, &_lock);
         pbo->_args.copy(_args);
         _retval = getPyNone();
@@ -186,7 +188,7 @@ class LevelsetGrid : public Grid<Real> {
       LevelsetGrid *pbo = dynamic_cast<LevelsetGrid *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "LevelsetGrid::initFromFlags", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
@@ -215,7 +217,7 @@ class LevelsetGrid : public Grid<Real> {
       LevelsetGrid *pbo = dynamic_cast<LevelsetGrid *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "LevelsetGrid::fillHoles", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         int maxDepth = _args.getOpt<int>("maxDepth", 0, 10, &_lock);
@@ -243,7 +245,7 @@ class LevelsetGrid : public Grid<Real> {
       LevelsetGrid *pbo = dynamic_cast<LevelsetGrid *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "LevelsetGrid::floodFill", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const Real value = _args.getOpt<Real>("value", 0, -0.5, &_lock);

extern/mantaflow/preprocessed/mesh.cpp

@@ -39,7 +39,7 @@ Mesh::Mesh(FluidSolver *parent) : PbClass(parent)
 Mesh::~Mesh()
 {
   for (IndexInt i = 0; i < (IndexInt)mMeshData.size(); ++i)
-    mMeshData[i]->setMesh(NULL);
+    mMeshData[i]->setMesh(nullptr);
 
   if (mFreeMdata) {
     for (IndexInt i = 0; i < (IndexInt)mMeshData.size(); ++i)
@@ -88,7 +88,7 @@ PbClass *Mesh::create(PbType t, PbTypeVec T, const string &name)
         "Unable to get mesh data pointer from newly created object. Only create MeshData type "
         "with a Mesh.creat() call, eg, MdataReal, MdataVec3 etc.");
     delete pyObj;
-    return NULL;
+    return nullptr;
   }
   else {
     this->registerMdata(mdata);
@@ -97,7 +97,7 @@ PbClass *Mesh::create(PbType t, PbTypeVec T, const string &name)
   // directly init size of new mdata field:
   mdata->resize(this->getSizeSlow());
 #else
-  PbClass *pyObj = NULL;
+  PbClass *pyObj = nullptr;
 #endif
   return pyObj;
 }
@@ -1279,7 +1279,7 @@ std::string Mesh::getTrisDataPointer()
 
 // mesh data
 
-MeshDataBase::MeshDataBase(FluidSolver *parent) : PbClass(parent), mMesh(NULL)
+MeshDataBase::MeshDataBase(FluidSolver *parent) : PbClass(parent), mMesh(nullptr)
 {
 }
 
@@ -1294,13 +1294,13 @@ MeshDataBase::~MeshDataBase()
 
 template<class T>
 MeshDataImpl<T>::MeshDataImpl(FluidSolver *parent)
-    : MeshDataBase(parent), mpGridSource(NULL), mGridSourceMAC(false)
+    : MeshDataBase(parent), mpGridSource(nullptr), mGridSourceMAC(false)
 {
 }
 
 template<class T>
 MeshDataImpl<T>::MeshDataImpl(FluidSolver *parent, MeshDataImpl<T> *other)
-    : MeshDataBase(parent), mpGridSource(NULL), mGridSourceMAC(false)
+    : MeshDataBase(parent), mpGridSource(nullptr), mGridSourceMAC(false)
 {
   this->mData = other->mData;
   setName(other->getName());

extern/mantaflow/preprocessed/mesh.h

@@ -223,7 +223,7 @@ class Mesh : public PbClass {
       Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Mesh::clear", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -248,7 +248,7 @@ class Mesh : public PbClass {
       Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Mesh::fromShape", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         Shape &shape = *_args.getPtr<Shape>("shape", 0, &_lock);
@@ -275,7 +275,7 @@ class Mesh : public PbClass {
       Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Mesh::advectInGrid", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
@@ -303,7 +303,7 @@ class Mesh : public PbClass {
       Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Mesh::scale", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         Vec3 s = _args.get<Vec3>("s", 0, &_lock);
@@ -329,7 +329,7 @@ class Mesh : public PbClass {
       Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Mesh::offset", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         Vec3 o = _args.get<Vec3>("o", 0, &_lock);
@@ -355,7 +355,7 @@ class Mesh : public PbClass {
       Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Mesh::rotate", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         Vec3 thetas = _args.get<Vec3>("thetas", 0, &_lock);
@@ -381,7 +381,7 @@ class Mesh : public PbClass {
       Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Mesh::computeVelocity", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         Mesh &oldMesh = *_args.getPtr<Mesh>("oldMesh", 0, &_lock);
@@ -409,7 +409,7 @@ class Mesh : public PbClass {
       Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Mesh::load", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         std::string name = _args.get<std::string>("name", 0, &_lock);
@@ -435,7 +435,7 @@ class Mesh : public PbClass {
       Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Mesh::save", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         std::string name = _args.get<std::string>("name", 0, &_lock);
@@ -460,7 +460,7 @@ class Mesh : public PbClass {
       Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Mesh::computeLevelset", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         LevelsetGrid &levelset = *_args.getPtr<LevelsetGrid>("levelset", 0, &_lock);
@@ -488,7 +488,7 @@ class Mesh : public PbClass {
       Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Mesh::getLevelset", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         Real sigma = _args.get<Real>("sigma", 0, &_lock);
@@ -518,7 +518,7 @@ class Mesh : public PbClass {
       Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Mesh::applyMeshToGrid", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         GridBase *grid = _args.getPtr<GridBase>("grid", 0, &_lock);
@@ -548,7 +548,7 @@ class Mesh : public PbClass {
       Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Mesh::getNodesDataPointer", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -573,7 +573,7 @@ class Mesh : public PbClass {
       Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Mesh::getTrisDataPointer", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -734,7 +734,7 @@ class Mesh : public PbClass {
       Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Mesh::create", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         PbType type = _args.get<PbType>("type", 0, &_lock);
@@ -852,7 +852,7 @@ class MeshDataBase : public PbClass {
   virtual MeshDataBase *clone()
   {
     assertMsg(false, "Dont use, override...");
-    return NULL;
+    return nullptr;
   }
   virtual MdataType getType() const
   {
@@ -952,7 +952,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
       MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "MeshDataImpl::clear", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -978,7 +978,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
       MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "MeshDataImpl::setSource", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         Grid<T> *grid = _args.getPtr<Grid<T>>("grid", 0, &_lock);
@@ -1026,7 +1026,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
       MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "MeshDataImpl::setConst", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         T s = _args.get<T>("s", 0, &_lock);
@@ -1052,7 +1052,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
       MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "MeshDataImpl::setConstRange", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         T s = _args.get<T>("s", 0, &_lock);
@@ -1080,7 +1080,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
       MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "MeshDataImpl::copyFrom", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const MeshDataImpl<T> &a = *_args.getPtr<MeshDataImpl<T>>("a", 0, &_lock);
@@ -1105,7 +1105,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
       MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "MeshDataImpl::add", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const MeshDataImpl<T> &a = *_args.getPtr<MeshDataImpl<T>>("a", 0, &_lock);
@@ -1131,7 +1131,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
       MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "MeshDataImpl::sub", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const MeshDataImpl<T> &a = *_args.getPtr<MeshDataImpl<T>>("a", 0, &_lock);
@@ -1157,7 +1157,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
       MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "MeshDataImpl::addConst", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         T s = _args.get<T>("s", 0, &_lock);
@@ -1183,7 +1183,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
       MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "MeshDataImpl::addScaled", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const MeshDataImpl<T> &a = *_args.getPtr<MeshDataImpl<T>>("a", 0, &_lock);
@@ -1210,7 +1210,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
       MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "MeshDataImpl::mult", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const MeshDataImpl<T> &a = *_args.getPtr<MeshDataImpl<T>>("a", 0, &_lock);
@@ -1236,7 +1236,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
       MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "MeshDataImpl::multConst", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         T s = _args.get<T>("s", 0, &_lock);
@@ -1262,7 +1262,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
       MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "MeshDataImpl::safeDiv", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const MeshDataImpl<T> &a = *_args.getPtr<MeshDataImpl<T>>("a", 0, &_lock);
@@ -1288,7 +1288,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
       MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "MeshDataImpl::clamp", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         Real min = _args.get<Real>("min", 0, &_lock);
@@ -1315,7 +1315,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
       MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "MeshDataImpl::clampMin", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         Real vmin = _args.get<Real>("vmin", 0, &_lock);
@@ -1341,7 +1341,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
       MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "MeshDataImpl::clampMax", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         Real vmax = _args.get<Real>("vmax", 0, &_lock);
@@ -1367,7 +1367,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
       MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "MeshDataImpl::getMaxAbs", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -1391,7 +1391,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
       MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "MeshDataImpl::getMax", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -1415,7 +1415,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
       MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "MeshDataImpl::getMin", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -1431,7 +1431,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
     }
   }
 
-  T sum(const MeshDataImpl<int> *t = NULL, const int itype = 0) const;
+  T sum(const MeshDataImpl<int> *t = nullptr, const int itype = 0) const;
   static PyObject *_W_36(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
   {
     try {
@@ -1439,10 +1439,10 @@ template<class T> class MeshDataImpl : public MeshDataBase {
       MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "MeshDataImpl::sum", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
-        const MeshDataImpl<int> *t = _args.getPtrOpt<MeshDataImpl<int>>("t", 0, NULL, &_lock);
+        const MeshDataImpl<int> *t = _args.getPtrOpt<MeshDataImpl<int>>("t", 0, nullptr, &_lock);
         const int itype = _args.getOpt<int>("itype", 1, 0, &_lock);
         pbo->_args.copy(_args);
         _retval = toPy(pbo->sum(t, itype));
@@ -1465,7 +1465,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
       MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "MeshDataImpl::sumSquare", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -1489,7 +1489,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
       MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "MeshDataImpl::sumMagnitude", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -1514,7 +1514,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
       MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "MeshDataImpl::setConstIntFlag", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         T s = _args.get<T>("s", 0, &_lock);
@@ -1542,7 +1542,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
       MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "MeshDataImpl::printMdata", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         IndexInt start = _args.getOpt<IndexInt>("start", 0, -1, &_lock);
@@ -1571,7 +1571,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
       MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "MeshDataImpl::save", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const std::string name = _args.get<std::string>("name", 0, &_lock);
@@ -1596,7 +1596,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
       MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "MeshDataImpl::load", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const std::string name = _args.get<std::string>("name", 0, &_lock);
@@ -1622,7 +1622,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
       MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "MeshDataImpl::getDataPointer", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);

extern/mantaflow/preprocessed/movingobs.h

@@ -62,7 +62,7 @@ class MovingObstacle : public PbClass {
       MovingObstacle *pbo = dynamic_cast<MovingObstacle *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "MovingObstacle::add", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         Shape *shape = _args.getPtr<Shape>("shape", 0, &_lock);
@@ -96,7 +96,7 @@ class MovingObstacle : public PbClass {
       MovingObstacle *pbo = dynamic_cast<MovingObstacle *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "MovingObstacle::moveLinear", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         Real t = _args.get<Real>("t", 0, &_lock);
@@ -130,7 +130,7 @@ class MovingObstacle : public PbClass {
       MovingObstacle *pbo = dynamic_cast<MovingObstacle *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "MovingObstacle::projectOutside", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);

extern/mantaflow/preprocessed/noisefield.cpp

@@ -34,7 +34,7 @@ using namespace std;
 namespace Manta {
 
 int WaveletNoiseField::randomSeed = 13322223;
-Real *WaveletNoiseField::mNoiseTile = NULL;
+Real *WaveletNoiseField::mNoiseTile = nullptr;
 std::atomic<int> WaveletNoiseField::mNoiseReferenceCount(0);
 
 static Real _aCoeffs[32] = {

extern/mantaflow/preprocessed/noisefield.h

@@ -64,7 +64,7 @@ class WaveletNoiseField : public PbClass {
   {
     if (mNoiseTile && !mNoiseReferenceCount) {
       delete mNoiseTile;
-      mNoiseTile = NULL;
+      mNoiseTile = nullptr;
     }
   };
 

extern/mantaflow/preprocessed/particle.cpp

@@ -37,7 +37,7 @@ ParticleBase::~ParticleBase()
 {
   // make sure data fields now parent system is deleted
   for (IndexInt i = 0; i < (IndexInt)mPartData.size(); ++i)
-    mPartData[i]->setParticleSys(NULL);
+    mPartData[i]->setParticleSys(nullptr);
 
   if (mFreePdata) {
     for (IndexInt i = 0; i < (IndexInt)mPartData.size(); ++i)
@@ -93,7 +93,7 @@ PbClass *ParticleBase::create(PbType t, PbTypeVec T, const string &name)
         "Unable to get particle data pointer from newly created object. Only create ParticleData "
         "type with a ParticleSys.creat() call, eg, PdataReal, PdataVec3 etc.");
     delete pyObj;
-    return NULL;
+    return nullptr;
   }
   else {
     this->registerPdata(pdata);
@@ -102,7 +102,7 @@ PbClass *ParticleBase::create(PbType t, PbTypeVec T, const string &name)
   // directly init size of new pdata field:
   pdata->resize(this->getSizeSlow());
 #else
-  PbClass *pyObj = NULL;
+  PbClass *pyObj = nullptr;
 #endif
   return pyObj;
 }
@@ -297,7 +297,7 @@ void BasicParticleSystem::readParticles(BasicParticleSystem *from)
 
 // particle data
 
-ParticleDataBase::ParticleDataBase(FluidSolver *parent) : PbClass(parent), mpParticleSys(NULL)
+ParticleDataBase::ParticleDataBase(FluidSolver *parent) : PbClass(parent), mpParticleSys(nullptr)
 {
 }
 
@@ -312,13 +312,13 @@ ParticleDataBase::~ParticleDataBase()
 
 template<class T>
 ParticleDataImpl<T>::ParticleDataImpl(FluidSolver *parent)
-    : ParticleDataBase(parent), mpGridSource(NULL), mGridSourceMAC(false)
+    : ParticleDataBase(parent), mpGridSource(nullptr), mGridSourceMAC(false)
 {
 }
 
 template<class T>
 ParticleDataImpl<T>::ParticleDataImpl(FluidSolver *parent, ParticleDataImpl<T> *other)
-    : ParticleDataBase(parent), mpGridSource(NULL), mGridSourceMAC(false)
+    : ParticleDataBase(parent), mpGridSource(nullptr), mGridSourceMAC(false)
 {
   this->mData = other->mData;
   setName(other->getName());

extern/mantaflow/preprocessed/particle.h

@@ -86,7 +86,7 @@ class ParticleBase : public PbClass {
   virtual ParticleBase *clone()
   {
     assertMsg(false, "Dont use, override...");
-    return NULL;
+    return nullptr;
   }
 
   //! slow virtual function to query size, do not use in kernels! use size() instead
@@ -122,7 +122,7 @@ class ParticleBase : public PbClass {
       ParticleBase *pbo = dynamic_cast<ParticleBase *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "ParticleBase::create", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         PbType type = _args.get<PbType>("type", 0, &_lock);
@@ -274,7 +274,7 @@ template<class S> class ParticleSystem : public ParticleBase {
       ParticleSystem *pbo = dynamic_cast<ParticleSystem *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "ParticleSystem::pySize", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -342,7 +342,7 @@ template<class S> class ParticleSystem : public ParticleBase {
       ParticleSystem *pbo = dynamic_cast<ParticleSystem *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "ParticleSystem::setPos", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const IndexInt idx = _args.get<IndexInt>("idx", 0, &_lock);
@@ -373,7 +373,7 @@ template<class S> class ParticleSystem : public ParticleBase {
       ParticleSystem *pbo = dynamic_cast<ParticleSystem *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "ParticleSystem::getPos", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const IndexInt idx = _args.get<IndexInt>("idx", 0, &_lock);
@@ -399,7 +399,7 @@ template<class S> class ParticleSystem : public ParticleBase {
       ParticleSystem *pbo = dynamic_cast<ParticleSystem *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "ParticleSystem::getPosPdata", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         ParticleDataImpl<Vec3> &target = *_args.getPtr<ParticleDataImpl<Vec3>>(
@@ -426,7 +426,7 @@ template<class S> class ParticleSystem : public ParticleBase {
       ParticleSystem *pbo = dynamic_cast<ParticleSystem *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "ParticleSystem::setPosPdata", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const ParticleDataImpl<Vec3> &source = *_args.getPtr<ParticleDataImpl<Vec3>>(
@@ -477,7 +477,7 @@ template<class S> class ParticleSystem : public ParticleBase {
       ParticleSystem *pbo = dynamic_cast<ParticleSystem *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "ParticleSystem::clear", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -501,7 +501,7 @@ template<class S> class ParticleSystem : public ParticleBase {
                     const bool deleteInObstacle = true,
                     const bool stopInObstacle = true,
                     const bool skipNew = false,
-                    const ParticleDataImpl<int> *ptype = NULL,
+                    const ParticleDataImpl<int> *ptype = nullptr,
                     const int exclude = 0);
   static PyObject *_W_9(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
   {
@@ -510,7 +510,7 @@ template<class S> class ParticleSystem : public ParticleBase {
       ParticleSystem *pbo = dynamic_cast<ParticleSystem *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "ParticleSystem::advectInGrid", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
@@ -520,7 +520,7 @@ template<class S> class ParticleSystem : public ParticleBase {
         const bool stopInObstacle = _args.getOpt<bool>("stopInObstacle", 4, true, &_lock);
         const bool skipNew = _args.getOpt<bool>("skipNew", 5, false, &_lock);
         const ParticleDataImpl<int> *ptype = _args.getPtrOpt<ParticleDataImpl<int>>(
-            "ptype", 6, NULL, &_lock);
+            "ptype", 6, nullptr, &_lock);
         const int exclude = _args.getOpt<int>("exclude", 7, 0, &_lock);
         pbo->_args.copy(_args);
         _retval = getPyNone();
@@ -552,7 +552,7 @@ template<class S> class ParticleSystem : public ParticleBase {
       ParticleSystem *pbo = dynamic_cast<ParticleSystem *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "ParticleSystem::projectOutside", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         Grid<Vec3> &gradient = *_args.getPtr<Grid<Vec3>>("gradient", 0, &_lock);
@@ -573,7 +573,7 @@ template<class S> class ParticleSystem : public ParticleBase {
   void projectOutOfBnd(const FlagGrid &flags,
                        const Real bnd,
                        const std::string &plane = "xXyYzZ",
-                       const ParticleDataImpl<int> *ptype = NULL,
+                       const ParticleDataImpl<int> *ptype = nullptr,
                        const int exclude = 0);
   static PyObject *_W_11(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
   {
@@ -582,14 +582,14 @@ template<class S> class ParticleSystem : public ParticleBase {
       ParticleSystem *pbo = dynamic_cast<ParticleSystem *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "ParticleSystem::projectOutOfBnd", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
         const Real bnd = _args.get<Real>("bnd", 1, &_lock);
         const std::string &plane = _args.getOpt<std::string>("plane", 2, "xXyYzZ", &_lock);
         const ParticleDataImpl<int> *ptype = _args.getPtrOpt<ParticleDataImpl<int>>(
-            "ptype", 3, NULL, &_lock);
+            "ptype", 3, nullptr, &_lock);
         const int exclude = _args.getOpt<int>("exclude", 4, 0, &_lock);
         pbo->_args.copy(_args);
         _retval = getPyNone();
@@ -685,7 +685,7 @@ class BasicParticleSystem : public ParticleSystem<BasicParticleData> {
       BasicParticleSystem *pbo = dynamic_cast<BasicParticleSystem *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "BasicParticleSystem::save", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const std::string name = _args.get<std::string>("name", 0, &_lock);
@@ -710,7 +710,7 @@ class BasicParticleSystem : public ParticleSystem<BasicParticleData> {
       BasicParticleSystem *pbo = dynamic_cast<BasicParticleSystem *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "BasicParticleSystem::load", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const std::string name = _args.get<std::string>("name", 0, &_lock);
@@ -742,7 +742,7 @@ class BasicParticleSystem : public ParticleSystem<BasicParticleData> {
       BasicParticleSystem *pbo = dynamic_cast<BasicParticleSystem *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "BasicParticleSystem::readParticles", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         BasicParticleSystem *from = _args.getPtr<BasicParticleSystem>("from", 0, &_lock);
@@ -772,7 +772,7 @@ class BasicParticleSystem : public ParticleSystem<BasicParticleData> {
       BasicParticleSystem *pbo = dynamic_cast<BasicParticleSystem *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "BasicParticleSystem::addParticle", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         Vec3 pos = _args.get<Vec3>("pos", 0, &_lock);
@@ -804,7 +804,7 @@ class BasicParticleSystem : public ParticleSystem<BasicParticleData> {
       BasicParticleSystem *pbo = dynamic_cast<BasicParticleSystem *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "BasicParticleSystem::printParts", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         IndexInt start = _args.getOpt<IndexInt>("start", 0, -1, &_lock);
@@ -833,7 +833,7 @@ class BasicParticleSystem : public ParticleSystem<BasicParticleData> {
       BasicParticleSystem *pbo = dynamic_cast<BasicParticleSystem *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "BasicParticleSystem::getDataPointer", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -1028,7 +1028,7 @@ class ParticleDataBase : public PbClass {
   virtual ParticleDataBase *clone()
   {
     assertMsg(false, "Dont use, override...");
-    return NULL;
+    return nullptr;
   }
   virtual PdataType getType() const
   {
@@ -1139,7 +1139,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
       ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::clear", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -1165,7 +1165,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
       ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::setSource", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         Grid<T> *grid = _args.getPtr<Grid<T>>("grid", 0, &_lock);
@@ -1213,7 +1213,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
       ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::copyFrom", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const ParticleDataImpl<T> &a = *_args.getPtr<ParticleDataImpl<T>>("a", 0, &_lock);
@@ -1238,7 +1238,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
       ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::setConst", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const T &s = *_args.getPtr<T>("s", 0, &_lock);
@@ -1264,7 +1264,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
       ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::setConstRange", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const T &s = *_args.getPtr<T>("s", 0, &_lock);
@@ -1292,7 +1292,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
       ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::add", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const ParticleDataImpl<T> &a = *_args.getPtr<ParticleDataImpl<T>>("a", 0, &_lock);
@@ -1318,7 +1318,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
       ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::sub", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const ParticleDataImpl<T> &a = *_args.getPtr<ParticleDataImpl<T>>("a", 0, &_lock);
@@ -1344,7 +1344,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
       ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::addConst", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const T &s = *_args.getPtr<T>("s", 0, &_lock);
@@ -1370,7 +1370,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
       ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::addScaled", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const ParticleDataImpl<T> &a = *_args.getPtr<ParticleDataImpl<T>>("a", 0, &_lock);
@@ -1397,7 +1397,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
       ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::mult", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const ParticleDataImpl<T> &a = *_args.getPtr<ParticleDataImpl<T>>("a", 0, &_lock);
@@ -1423,7 +1423,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
       ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::multConst", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const T &s = *_args.getPtr<T>("s", 0, &_lock);
@@ -1449,7 +1449,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
       ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::safeDiv", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const ParticleDataImpl<T> &a = *_args.getPtr<ParticleDataImpl<T>>("a", 0, &_lock);
@@ -1475,7 +1475,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
       ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::clamp", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const Real vmin = _args.get<Real>("vmin", 0, &_lock);
@@ -1502,7 +1502,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
       ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::clampMin", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const Real vmin = _args.get<Real>("vmin", 0, &_lock);
@@ -1528,7 +1528,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
       ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::clampMax", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const Real vmax = _args.get<Real>("vmax", 0, &_lock);
@@ -1554,7 +1554,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
       ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::getMaxAbs", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -1578,7 +1578,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
       ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::getMax", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -1602,7 +1602,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
       ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::getMin", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -1618,7 +1618,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
     }
   }
 
-  T sum(const ParticleDataImpl<int> *t = NULL, const int itype = 0) const;
+  T sum(const ParticleDataImpl<int> *t = nullptr, const int itype = 0) const;
   static PyObject *_W_41(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
   {
     try {
@@ -1626,11 +1626,11 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
       ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::sum", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const ParticleDataImpl<int> *t = _args.getPtrOpt<ParticleDataImpl<int>>(
-            "t", 0, NULL, &_lock);
+            "t", 0, nullptr, &_lock);
         const int itype = _args.getOpt<int>("itype", 1, 0, &_lock);
         pbo->_args.copy(_args);
         _retval = toPy(pbo->sum(t, itype));
@@ -1653,7 +1653,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
       ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::sumSquare", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -1677,7 +1677,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
       ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::sumMagnitude", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -1702,7 +1702,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
       ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::setConstIntFlag", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const T &s = *_args.getPtr<T>("s", 0, &_lock);
@@ -1730,7 +1730,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
       ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::printPdata", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         IndexInt start = _args.getOpt<IndexInt>("start", 0, -1, &_lock);
@@ -1759,7 +1759,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
       ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::save", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const std::string name = _args.get<std::string>("name", 0, &_lock);
@@ -1784,7 +1784,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
       ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::load", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const std::string name = _args.get<std::string>("name", 0, &_lock);
@@ -1810,7 +1810,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
       ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::getDataPointer", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -2152,9 +2152,9 @@ static inline Vec3 bisectBacktracePos(const FlagGrid &flags, const Vec3 &oldp, c
 template<class S> struct KnClampPositions : public KernelBase {
   KnClampPositions(std::vector<S> &p,
                    const FlagGrid &flags,
-                   ParticleDataImpl<Vec3> *posOld = NULL,
+                   ParticleDataImpl<Vec3> *posOld = nullptr,
                    bool stopInObstacle = true,
-                   const ParticleDataImpl<int> *ptype = NULL,
+                   const ParticleDataImpl<int> *ptype = nullptr,
                    const int exclude = 0)
       : KernelBase(p.size()),
         p(p),
@@ -2170,9 +2170,9 @@ template<class S> struct KnClampPositions : public KernelBase {
   inline void op(IndexInt idx,
                  std::vector<S> &p,
                  const FlagGrid &flags,
-                 ParticleDataImpl<Vec3> *posOld = NULL,
+                 ParticleDataImpl<Vec3> *posOld = nullptr,
                  bool stopInObstacle = true,
-                 const ParticleDataImpl<int> *ptype = NULL,
+                 const ParticleDataImpl<int> *ptype = nullptr,
                  const int exclude = 0) const
   {
     if (p[idx].flag & ParticleBase::PDELETE)
@@ -2255,7 +2255,7 @@ void ParticleSystem<S>::advectInGrid(const FlagGrid &flags,
                                      const int exclude)
 {
   // position clamp requires old positions, backup
-  ParticleDataImpl<Vec3> *posOld = NULL;
+  ParticleDataImpl<Vec3> *posOld = nullptr;
   if (!deleteInObstacle) {
     posOld = new ParticleDataImpl<Vec3>(this->getParent());
     posOld->resize(mData.size());

extern/mantaflow/preprocessed/plugin/advection.cpp

@@ -1336,7 +1336,7 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "resetPhiInObs", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
@@ -1476,7 +1476,7 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "advectSemiLagrange", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const FlagGrid *flags = _args.getPtr<FlagGrid>("flags", 0, &_lock);

extern/mantaflow/preprocessed/plugin/apic.cpp

@@ -6,7 +6,7 @@
 // ----------------------------------------------------------------------------
 //
 // MantaFlow fluid solver framework
-// Copyright 2016-2017 Kiwon Um, Nils Thuerey
+// Copyright 2016-2020 Kiwon Um, Nils Thuerey
 //
 // This program is free software, distributed under the terms of the
 // Apache License, Version 2.0
@@ -21,6 +21,52 @@
 
 namespace Manta {
 
+#define FOR_INT_IJK(num) \
+  for (int i = 0; i < num; ++i) \
+    for (int j = 0; j < num; ++j) \
+      for (int k = 0; k < num; ++k)
+
+static inline IndexInt indexUFace(const Vec3 &pos, const MACGrid &ref)
+{
+  const Vec3i f = toVec3i(pos), c = toVec3i(pos - 0.5);
+  const IndexInt index = f.x * ref.getStrideX() + c.y * ref.getStrideY() + c.z * ref.getStrideZ();
+  assertDeb(ref.isInBounds(index),
+            "U face index out of bounds for particle position [" << pos.x << ", " << pos.y << ", "
+                                                                 << pos.z << "]");
+  return (ref.isInBounds(index)) ? index : -1;
+}
+
+static inline IndexInt indexVFace(const Vec3 &pos, const MACGrid &ref)
+{
+  const Vec3i f = toVec3i(pos), c = toVec3i(pos - 0.5);
+  const IndexInt index = c.x * ref.getStrideX() + f.y * ref.getStrideY() + c.z * ref.getStrideZ();
+  assertDeb(ref.isInBounds(index),
+            "V face index out of bounds for particle position [" << pos.x << ", " << pos.y << ", "
+                                                                 << pos.z << "]");
+  return (ref.isInBounds(index)) ? index : -1;
+}
+
+static inline IndexInt indexWFace(const Vec3 &pos, const MACGrid &ref)
+{
+  const Vec3i f = toVec3i(pos), c = toVec3i(pos - 0.5);
+  const IndexInt index = c.x * ref.getStrideX() + c.y * ref.getStrideY() + f.z * ref.getStrideZ();
+  assertDeb(ref.isInBounds(index),
+            "W face index out of bounds for particle position [" << pos.x << ", " << pos.y << ", "
+                                                                 << pos.z << "]");
+  return (ref.isInBounds(index)) ? index : -1;
+}
+
+static inline IndexInt indexOffset(
+    const IndexInt gidx, const int i, const int j, const int k, const MACGrid &ref)
+{
+  const IndexInt dX[2] = {0, ref.getStrideX()};
+  const IndexInt dY[2] = {0, ref.getStrideY()};
+  const IndexInt dZ[2] = {0, ref.getStrideZ()};
+  const IndexInt index = gidx + dX[i] + dY[j] + dZ[k];
+  assertDeb(ref.isInBounds(index), "Offset index " << index << " is out of bounds");
+  return (ref.isInBounds(index)) ? index : -1;
+}
+
 struct knApicMapLinearVec3ToMACGrid : public KernelBase {
   knApicMapLinearVec3ToMACGrid(const BasicParticleSystem &p,
                                MACGrid &mg,
@@ -30,7 +76,8 @@ struct knApicMapLinearVec3ToMACGrid : public KernelBase {
                                const ParticleDataImpl<Vec3> &cpy,
                                const ParticleDataImpl<Vec3> &cpz,
                                const ParticleDataImpl<int> *ptype,
-                               const int exclude)
+                               const int exclude,
+                               const int boundaryWidth)
       : KernelBase(p.size()),
         p(p),
         mg(mg),
@@ -40,7 +87,8 @@ struct knApicMapLinearVec3ToMACGrid : public KernelBase {
         cpy(cpy),
         cpz(cpz),
         ptype(ptype),
-        exclude(exclude)
+        exclude(exclude),
+        boundaryWidth(boundaryWidth)
   {
     runMessage();
     run();
@@ -54,73 +102,91 @@ struct knApicMapLinearVec3ToMACGrid : public KernelBase {
                  const ParticleDataImpl<Vec3> &cpy,
                  const ParticleDataImpl<Vec3> &cpz,
                  const ParticleDataImpl<int> *ptype,
-                 const int exclude)
+                 const int exclude,
+                 const int boundaryWidth)
   {
     if (!p.isActive(idx) || (ptype && ((*ptype)[idx] & exclude)))
       return;
-    const IndexInt dX[2] = {0, vg.getStrideX()};
-    const IndexInt dY[2] = {0, vg.getStrideY()};
-    const IndexInt dZ[2] = {0, vg.getStrideZ()};
+    if (!vg.isInBounds(p.getPos(idx), boundaryWidth)) {
+      debMsg("Skipping particle at index " << idx
+                                           << ". Is out of bounds and cannot be applied to grid.",
+             1);
+      return;
+    }
+
+    const Vec3 &pos = p.getPos(idx), &vel = vp[idx];
+    const Vec3i f = toVec3i(pos);
+    const Vec3i c = toVec3i(pos - 0.5);
+    const Vec3 wf = clamp(pos - toVec3(f), Vec3(0.), Vec3(1.));
+    const Vec3 wc = clamp(pos - toVec3(c) - 0.5, Vec3(0.), Vec3(1.));
 
-    const Vec3 &pos = p[idx].pos, &vel = vp[idx];
-    const IndexInt fi = static_cast<IndexInt>(pos.x), fj = static_cast<IndexInt>(pos.y),
-                   fk = static_cast<IndexInt>(pos.z);
-    const IndexInt ci = static_cast<IndexInt>(pos.x - 0.5),
-                   cj = static_cast<IndexInt>(pos.y - 0.5),
-                   ck = static_cast<IndexInt>(pos.z - 0.5);
-    const Real wfi = clamp(pos.x - fi, Real(0), Real(1)),
-               wfj = clamp(pos.y - fj, Real(0), Real(1)),
-               wfk = clamp(pos.z - fk, Real(0), Real(1));
-    const Real wci = clamp(Real(pos.x - ci - 0.5), Real(0), Real(1)),
-               wcj = clamp(Real(pos.y - cj - 0.5), Real(0), Real(1)),
-               wck = clamp(Real(pos.z - ck - 0.5), Real(0), Real(1));
-    // TODO: check index for safety
     {  // u-face
-      const IndexInt gidx = fi * dX[1] + cj * dY[1] + ck * dZ[1];
-      const Vec3 gpos(fi, cj + 0.5, ck + 0.5);
-      const Real wi[2] = {Real(1) - wfi, wfi};
-      const Real wj[2] = {Real(1) - wcj, wcj};
-      const Real wk[2] = {Real(1) - wck, wck};
-      for (int i = 0; i < 2; ++i)
-        for (int j = 0; j < 2; ++j)
-          for (int k = 0; k < 2; ++k) {
-            const Real w = wi[i] * wj[j] * wk[k];
-            mg[gidx + dX[i] + dY[j] + dZ[k]].x += w;
-            vg[gidx + dX[i] + dY[j] + dZ[k]].x += w * vel.x;
-            vg[gidx + dX[i] + dY[j] + dZ[k]].x += w * dot(cpx[idx], gpos + Vec3(i, j, k) - pos);
-          }
+      const IndexInt gidx = indexUFace(pos, vg);
+      if (gidx < 0)
+        return;  // debug will fail before
+
+      const Vec3 gpos(f.x, c.y + 0.5, c.z + 0.5);
+      const Real wi[2] = {Real(1) - wf.x, wf.x};
+      const Real wj[2] = {Real(1) - wc.y, wc.y};
+      const Real wk[2] = {Real(1) - wc.z, wc.z};
+
+      FOR_INT_IJK(2)
+      {
+        const Real w = wi[i] * wj[j] * wk[k];
+        const IndexInt vidx = indexOffset(gidx, i, j, k, vg);
+        if (vidx < 0)
+          continue;  // debug will fail before
+
+        mg[vidx].x += w;
+        vg[vidx].x += w * vel.x;
+        vg[vidx].x += w * dot(cpx[idx], gpos + Vec3(i, j, k) - pos);
+      }
     }
     {  // v-face
-      const IndexInt gidx = ci * dX[1] + fj * dY[1] + ck * dZ[1];
-      const Vec3 gpos(ci + 0.5, fj, ck + 0.5);
-      const Real wi[2] = {Real(1) - wci, wci};
-      const Real wj[2] = {Real(1) - wfj, wfj};
-      const Real wk[2] = {Real(1) - wck, wck};
-      for (int i = 0; i < 2; ++i)
-        for (int j = 0; j < 2; ++j)
-          for (int k = 0; k < 2; ++k) {
-            const Real w = wi[i] * wj[j] * wk[k];
-            mg[gidx + dX[i] + dY[j] + dZ[k]].y += w;
-            vg[gidx + dX[i] + dY[j] + dZ[k]].y += w * vel.y;
-            vg[gidx + dX[i] + dY[j] + dZ[k]].y += w * dot(cpy[idx], gpos + Vec3(i, j, k) - pos);
-          }
+      const IndexInt gidx = indexVFace(pos, vg);
+      if (gidx < 0)
+        return;
+
+      const Vec3 gpos(c.x + 0.5, f.y, c.z + 0.5);
+      const Real wi[2] = {Real(1) - wc.x, wc.x};
+      const Real wj[2] = {Real(1) - wf.y, wf.y};
+      const Real wk[2] = {Real(1) - wc.z, wc.z};
+
+      FOR_INT_IJK(2)
+      {
+        const Real w = wi[i] * wj[j] * wk[k];
+        const IndexInt vidx = indexOffset(gidx, i, j, k, vg);
+        if (vidx < 0)
+          continue;
+
+        mg[vidx].y += w;
+        vg[vidx].y += w * vel.y;
+        vg[vidx].y += w * dot(cpy[idx], gpos + Vec3(i, j, k) - pos);
+      }
     }
     if (!vg.is3D())
       return;
     {  // w-face
-      const IndexInt gidx = ci * dX[1] + cj * dY[1] + fk * dZ[1];
-      const Vec3 gpos(ci + 0.5, cj + 0.5, fk);
-      const Real wi[2] = {Real(1) - wci, wci};
-      const Real wj[2] = {Real(1) - wcj, wcj};
-      const Real wk[2] = {Real(1) - wfk, wfk};
-      for (int i = 0; i < 2; ++i)
-        for (int j = 0; j < 2; ++j)
-          for (int k = 0; k < 2; ++k) {
-            const Real w = wi[i] * wj[j] * wk[k];
-            mg[gidx + dX[i] + dY[j] + dZ[k]].z += w;
-            vg[gidx + dX[i] + dY[j] + dZ[k]].z += w * vel.z;
-            vg[gidx + dX[i] + dY[j] + dZ[k]].z += w * dot(cpz[idx], gpos + Vec3(i, j, k) - pos);
-          }
+      const IndexInt gidx = indexWFace(pos, vg);
+      if (gidx < 0)
+        return;
+
+      const Vec3 gpos(c.x + 0.5, c.y + 0.5, f.z);
+      const Real wi[2] = {Real(1) - wc.x, wc.x};
+      const Real wj[2] = {Real(1) - wc.y, wc.y};
+      const Real wk[2] = {Real(1) - wf.z, wf.z};
+
+      FOR_INT_IJK(2)
+      {
+        const Real w = wi[i] * wj[j] * wk[k];
+        const IndexInt vidx = indexOffset(gidx, i, j, k, vg);
+        if (vidx < 0)
+          continue;
+
+        mg[vidx].z += w;
+        vg[vidx].z += w * vel.z;
+        vg[vidx].z += w * dot(cpz[idx], gpos + Vec3(i, j, k) - pos);
+      }
     }
   }
   inline const BasicParticleSystem &getArg0()
@@ -168,6 +234,11 @@ struct knApicMapLinearVec3ToMACGrid : public KernelBase {
     return exclude;
   }
   typedef int type8;
+  inline const int &getArg9()
+  {
+    return boundaryWidth;
+  }
+  typedef int type9;
   void runMessage()
   {
     debMsg("Executing kernel knApicMapLinearVec3ToMACGrid ", 3);
@@ -179,7 +250,7 @@ struct knApicMapLinearVec3ToMACGrid : public KernelBase {
   {
     const IndexInt _sz = size;
     for (IndexInt i = 0; i < _sz; i++)
-      op(i, p, mg, vg, vp, cpx, cpy, cpz, ptype, exclude);
+      op(i, p, mg, vg, vp, cpx, cpy, cpz, ptype, exclude, boundaryWidth);
   }
   const BasicParticleSystem &p;
   MACGrid &mg;
@@ -190,6 +261,7 @@ struct knApicMapLinearVec3ToMACGrid : public KernelBase {
   const ParticleDataImpl<Vec3> &cpz;
   const ParticleDataImpl<int> *ptype;
   const int exclude;
+  const int boundaryWidth;
 };
 
 void apicMapPartsToMAC(const FlagGrid &flags,
@@ -199,25 +271,24 @@ void apicMapPartsToMAC(const FlagGrid &flags,
                        const ParticleDataImpl<Vec3> &cpx,
                        const ParticleDataImpl<Vec3> &cpy,
                        const ParticleDataImpl<Vec3> &cpz,
-                       MACGrid *mass = NULL,
-                       const ParticleDataImpl<int> *ptype = NULL,
-                       const int exclude = 0)
+                       MACGrid *mass = nullptr,
+                       const ParticleDataImpl<int> *ptype = nullptr,
+                       const int exclude = 0,
+                       const int boundaryWidth = 0)
 {
-  // affine map
-  // let's assume that the particle mass is constant, 1.0
-  const bool freeMass = !mass;
-  if (!mass)
-    mass = new MACGrid(flags.getParent());
-  else
-    mass->clear();
+  // affine map: let's assume that the particle mass is constant, 1.0
+  MACGrid tmpmass(vel.getParent());
 
+  tmpmass.clear();
   vel.clear();
-  knApicMapLinearVec3ToMACGrid(parts, *mass, vel, partVel, cpx, cpy, cpz, ptype, exclude);
-  mass->stomp(VECTOR_EPSILON);
-  vel.safeDivide(*mass);
 
-  if (freeMass)
-    delete mass;
+  knApicMapLinearVec3ToMACGrid(
+      parts, tmpmass, vel, partVel, cpx, cpy, cpz, ptype, exclude, boundaryWidth);
+  tmpmass.stomp(VECTOR_EPSILON);
+  vel.safeDivide(tmpmass);
+
+  if (mass)
+    (*mass).swap(tmpmass);
 }
 static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
 {
@@ -226,7 +297,7 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "apicMapPartsToMAC", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
@@ -237,12 +308,14 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
       const ParticleDataImpl<Vec3> &cpx = *_args.getPtr<ParticleDataImpl<Vec3>>("cpx", 4, &_lock);
       const ParticleDataImpl<Vec3> &cpy = *_args.getPtr<ParticleDataImpl<Vec3>>("cpy", 5, &_lock);
       const ParticleDataImpl<Vec3> &cpz = *_args.getPtr<ParticleDataImpl<Vec3>>("cpz", 6, &_lock);
-      MACGrid *mass = _args.getPtrOpt<MACGrid>("mass", 7, NULL, &_lock);
+      MACGrid *mass = _args.getPtrOpt<MACGrid>("mass", 7, nullptr, &_lock);
       const ParticleDataImpl<int> *ptype = _args.getPtrOpt<ParticleDataImpl<int>>(
-          "ptype", 8, NULL, &_lock);
+          "ptype", 8, nullptr, &_lock);
       const int exclude = _args.getOpt<int>("exclude", 9, 0, &_lock);
+      const int boundaryWidth = _args.getOpt<int>("boundaryWidth", 10, 0, &_lock);
       _retval = getPyNone();
-      apicMapPartsToMAC(flags, vel, parts, partVel, cpx, cpy, cpz, mass, ptype, exclude);
+      apicMapPartsToMAC(
+          flags, vel, parts, partVel, cpx, cpy, cpz, mass, ptype, exclude, boundaryWidth);
       _args.check();
     }
     pbFinalizePlugin(parent, "apicMapPartsToMAC", !noTiming);
@@ -270,7 +343,8 @@ struct knApicMapLinearMACGridToVec3 : public KernelBase {
                                const MACGrid &vg,
                                const FlagGrid &flags,
                                const ParticleDataImpl<int> *ptype,
-                               const int exclude)
+                               const int exclude,
+                               const int boundaryWidth)
       : KernelBase(vp.size()),
         vp(vp),
         cpx(cpx),
@@ -280,7 +354,8 @@ struct knApicMapLinearMACGridToVec3 : public KernelBase {
         vg(vg),
         flags(flags),
         ptype(ptype),
-        exclude(exclude)
+        exclude(exclude),
+        boundaryWidth(boundaryWidth)
   {
     runMessage();
     run();
@@ -294,78 +369,94 @@ struct knApicMapLinearMACGridToVec3 : public KernelBase {
                  const MACGrid &vg,
                  const FlagGrid &flags,
                  const ParticleDataImpl<int> *ptype,
-                 const int exclude) const
+                 const int exclude,
+                 const int boundaryWidth) const
   {
     if (!p.isActive(idx) || (ptype && ((*ptype)[idx] & exclude)))
       return;
+    if (!vg.isInBounds(p.getPos(idx), boundaryWidth)) {
+      debMsg("Skipping particle at index " << idx
+                                           << ". Is out of bounds and cannot get value from grid.",
+             1);
+      return;
+    }
 
     vp[idx] = cpx[idx] = cpy[idx] = cpz[idx] = Vec3(Real(0));
-    const IndexInt dX[2] = {0, vg.getStrideX()}, dY[2] = {0, vg.getStrideY()},
-                   dZ[2] = {0, vg.getStrideZ()};
     const Real gw[2] = {-Real(1), Real(1)};
 
-    const Vec3 &pos = p[idx].pos;
-    const IndexInt fi = static_cast<IndexInt>(pos.x), fj = static_cast<IndexInt>(pos.y),
-                   fk = static_cast<IndexInt>(pos.z);
-    const IndexInt ci = static_cast<IndexInt>(pos.x - 0.5),
-                   cj = static_cast<IndexInt>(pos.y - 0.5),
-                   ck = static_cast<IndexInt>(pos.z - 0.5);
-    const Real wfi = clamp(pos.x - fi, Real(0), Real(1)),
-               wfj = clamp(pos.y - fj, Real(0), Real(1)),
-               wfk = clamp(pos.z - fk, Real(0), Real(1));
-    const Real wci = clamp(Real(pos.x - ci - 0.5), Real(0), Real(1)),
-               wcj = clamp(Real(pos.y - cj - 0.5), Real(0), Real(1)),
-               wck = clamp(Real(pos.z - ck - 0.5), Real(0), Real(1));
-    // TODO: check index for safety
-    {  // u
-      const IndexInt gidx = fi * dX[1] + cj * dY[1] + ck * dZ[1];
-      const Real wx[2] = {Real(1) - wfi, wfi};
-      const Real wy[2] = {Real(1) - wcj, wcj};
-      const Real wz[2] = {Real(1) - wck, wck};
-      for (int i = 0; i < 2; ++i)
-        for (int j = 0; j < 2; ++j)
-          for (int k = 0; k < 2; ++k) {
-            const IndexInt vidx = gidx + dX[i] + dY[j] + dZ[k];
-            Real vgx = vg[vidx].x;
-            vp[idx].x += wx[i] * wy[j] * wz[k] * vgx;
-            cpx[idx].x += gw[i] * wy[j] * wz[k] * vgx;
-            cpx[idx].y += wx[i] * gw[j] * wz[k] * vgx;
-            cpx[idx].z += wx[i] * wy[j] * gw[k] * vgx;
-          }
+    const Vec3 &pos = p.getPos(idx);
+    const Vec3i f = toVec3i(pos);
+    const Vec3i c = toVec3i(pos - 0.5);
+    const Vec3 wf = clamp(pos - toVec3(f), Vec3(0.), Vec3(1.));
+    const Vec3 wc = clamp(pos - toVec3(c) - 0.5, Vec3(0.), Vec3(1.));
+
+    {  // u-face
+      const IndexInt gidx = indexUFace(pos, vg);
+      if (gidx < 0)
+        return;  // debug will fail before
+
+      const Real wx[2] = {Real(1) - wf.x, wf.x};
+      const Real wy[2] = {Real(1) - wc.y, wc.y};
+      const Real wz[2] = {Real(1) - wc.z, wc.z};
+
+      FOR_INT_IJK(2)
+      {
+        const IndexInt vidx = indexOffset(gidx, i, j, k, vg);
+        if (vidx < 0)
+          continue;  // debug will fail before
+
+        const Real vgx = vg[vidx].x;
+        vp[idx].x += wx[i] * wy[j] * wz[k] * vgx;
+        cpx[idx].x += gw[i] * wy[j] * wz[k] * vgx;
+        cpx[idx].y += wx[i] * gw[j] * wz[k] * vgx;
+        cpx[idx].z += wx[i] * wy[j] * gw[k] * vgx;
+      }
     }
-    {  // v
-      const IndexInt gidx = ci * dX[1] + fj * dY[1] + ck * dZ[1];
-      const Real wx[2] = {Real(1) - wci, wci};
-      const Real wy[2] = {Real(1) - wfj, wfj};
-      const Real wz[2] = {Real(1) - wck, wck};
-      for (int i = 0; i < 2; ++i)
-        for (int j = 0; j < 2; ++j)
-          for (int k = 0; k < 2; ++k) {
-            const IndexInt vidx = gidx + dX[i] + dY[j] + dZ[k];
-            Real vgy = vg[vidx].y;
-            vp[idx].y += wx[i] * wy[j] * wz[k] * vgy;
-            cpy[idx].x += gw[i] * wy[j] * wz[k] * vgy;
-            cpy[idx].y += wx[i] * gw[j] * wz[k] * vgy;
-            cpy[idx].z += wx[i] * wy[j] * gw[k] * vgy;
-          }
+    {  // v-face
+      const IndexInt gidx = indexVFace(pos, vg);
+      if (gidx < 0)
+        return;
+
+      const Real wx[2] = {Real(1) - wc.x, wc.x};
+      const Real wy[2] = {Real(1) - wf.y, wf.y};
+      const Real wz[2] = {Real(1) - wc.z, wc.z};
+
+      FOR_INT_IJK(2)
+      {
+        const IndexInt vidx = indexOffset(gidx, i, j, k, vg);
+        if (vidx < 0)
+          continue;
+
+        const Real vgy = vg[vidx].y;
+        vp[idx].y += wx[i] * wy[j] * wz[k] * vgy;
+        cpy[idx].x += gw[i] * wy[j] * wz[k] * vgy;
+        cpy[idx].y += wx[i] * gw[j] * wz[k] * vgy;
+        cpy[idx].z += wx[i] * wy[j] * gw[k] * vgy;
+      }
     }
     if (!vg.is3D())
       return;
-    {  // w
-      const IndexInt gidx = ci * dX[1] + cj * dY[1] + fk * dZ[1];
-      const Real wx[2] = {Real(1) - wci, wci};
-      const Real wy[2] = {Real(1) - wcj, wcj};
-      const Real wz[2] = {Real(1) - wfk, wfk};
-      for (int i = 0; i < 2; ++i)
-        for (int j = 0; j < 2; ++j)
-          for (int k = 0; k < 2; ++k) {
-            const IndexInt vidx = gidx + dX[i] + dY[j] + dZ[k];
-            Real vgz = vg[vidx].z;
-            vp[idx].z += wx[i] * wy[j] * wz[k] * vgz;
-            cpz[idx].x += gw[i] * wy[j] * wz[k] * vgz;
-            cpz[idx].y += wx[i] * gw[j] * wz[k] * vgz;
-            cpz[idx].z += wx[i] * wy[j] * gw[k] * vgz;
-          }
+    {  // w-face
+      const IndexInt gidx = indexWFace(pos, vg);
+      if (gidx < 0)
+        return;
+
+      const Real wx[2] = {Real(1) - wc.x, wc.x};
+      const Real wy[2] = {Real(1) - wc.y, wc.y};
+      const Real wz[2] = {Real(1) - wf.z, wf.z};
+
+      FOR_INT_IJK(2)
+      {
+        const IndexInt vidx = indexOffset(gidx, i, j, k, vg);
+        if (vidx < 0)
+          continue;
+
+        const Real vgz = vg[vidx].z;
+        vp[idx].z += wx[i] * wy[j] * wz[k] * vgz;
+        cpz[idx].x += gw[i] * wy[j] * wz[k] * vgz;
+        cpz[idx].y += wx[i] * gw[j] * wz[k] * vgz;
+        cpz[idx].z += wx[i] * wy[j] * gw[k] * vgz;
+      }
     }
   }
   inline ParticleDataImpl<Vec3> &getArg0()
@@ -413,6 +504,11 @@ struct knApicMapLinearMACGridToVec3 : public KernelBase {
     return exclude;
   }
   typedef int type8;
+  inline const int &getArg9()
+  {
+    return boundaryWidth;
+  }
+  typedef int type9;
   void runMessage()
   {
     debMsg("Executing kernel knApicMapLinearMACGridToVec3 ", 3);
@@ -423,7 +519,7 @@ struct knApicMapLinearMACGridToVec3 : public KernelBase {
   void operator()(const tbb::blocked_range<IndexInt> &__r) const
   {
     for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
-      op(idx, vp, cpx, cpy, cpz, p, vg, flags, ptype, exclude);
+      op(idx, vp, cpx, cpy, cpz, p, vg, flags, ptype, exclude, boundaryWidth);
   }
   void run()
   {
@@ -438,6 +534,7 @@ struct knApicMapLinearMACGridToVec3 : public KernelBase {
   const FlagGrid &flags;
   const ParticleDataImpl<int> *ptype;
   const int exclude;
+  const int boundaryWidth;
 };
 
 void apicMapMACGridToParts(ParticleDataImpl<Vec3> &partVel,
@@ -447,10 +544,12 @@ void apicMapMACGridToParts(ParticleDataImpl<Vec3> &partVel,
                            const BasicParticleSystem &parts,
                            const MACGrid &vel,
                            const FlagGrid &flags,
-                           const ParticleDataImpl<int> *ptype = NULL,
-                           const int exclude = 0)
+                           const ParticleDataImpl<int> *ptype = nullptr,
+                           const int exclude = 0,
+                           const int boundaryWidth = 0)
 {
-  knApicMapLinearMACGridToVec3(partVel, cpx, cpy, cpz, parts, vel, flags, ptype, exclude);
+  knApicMapLinearMACGridToVec3(
+      partVel, cpx, cpy, cpz, parts, vel, flags, ptype, exclude, boundaryWidth);
 }
 static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
 {
@@ -459,7 +558,7 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "apicMapMACGridToParts", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       ParticleDataImpl<Vec3> &partVel = *_args.getPtr<ParticleDataImpl<Vec3>>(
@@ -471,10 +570,12 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
       const MACGrid &vel = *_args.getPtr<MACGrid>("vel", 5, &_lock);
       const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 6, &_lock);
       const ParticleDataImpl<int> *ptype = _args.getPtrOpt<ParticleDataImpl<int>>(
-          "ptype", 7, NULL, &_lock);
+          "ptype", 7, nullptr, &_lock);
       const int exclude = _args.getOpt<int>("exclude", 8, 0, &_lock);
+      const int boundaryWidth = _args.getOpt<int>("boundaryWidth", 9, 0, &_lock);
       _retval = getPyNone();
-      apicMapMACGridToParts(partVel, cpx, cpy, cpz, parts, vel, flags, ptype, exclude);
+      apicMapMACGridToParts(
+          partVel, cpx, cpy, cpz, parts, vel, flags, ptype, exclude, boundaryWidth);
       _args.check();
     }
     pbFinalizePlugin(parent, "apicMapMACGridToParts", !noTiming);

extern/mantaflow/preprocessed/plugin/extforces.cpp

@@ -248,7 +248,7 @@ struct KnApplyForce : public KernelBase {
 void addGravity(const FlagGrid &flags,
                 MACGrid &vel,
                 Vec3 gravity,
-                const Grid<Real> *exclude = NULL,
+                const Grid<Real> *exclude = nullptr,
                 bool scale = true)
 {
   float gridScale = (scale) ? flags.getDx() : 1;
@@ -262,13 +262,13 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "addGravity", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
       MACGrid &vel = *_args.getPtr<MACGrid>("vel", 1, &_lock);
       Vec3 gravity = _args.get<Vec3>("gravity", 2, &_lock);
-      const Grid<Real> *exclude = _args.getPtrOpt<Grid<Real>>("exclude", 3, NULL, &_lock);
+      const Grid<Real> *exclude = _args.getPtrOpt<Grid<Real>>("exclude", 3, nullptr, &_lock);
       bool scale = _args.getOpt<bool>("scale", 4, true, &_lock);
       _retval = getPyNone();
       addGravity(flags, vel, gravity, exclude, scale);
@@ -294,7 +294,7 @@ void PbRegister_addGravity()
 void addGravityNoScale(const FlagGrid &flags,
                        MACGrid &vel,
                        const Vec3 &gravity,
-                       const Grid<Real> *exclude = NULL)
+                       const Grid<Real> *exclude = nullptr)
 {
   addGravity(flags, vel, gravity, exclude, false);
 }
@@ -305,13 +305,13 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "addGravityNoScale", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
       MACGrid &vel = *_args.getPtr<MACGrid>("vel", 1, &_lock);
       const Vec3 &gravity = _args.get<Vec3>("gravity", 2, &_lock);
-      const Grid<Real> *exclude = _args.getPtrOpt<Grid<Real>>("exclude", 3, NULL, &_lock);
+      const Grid<Real> *exclude = _args.getPtrOpt<Grid<Real>>("exclude", 3, nullptr, &_lock);
       _retval = getPyNone();
       addGravityNoScale(flags, vel, gravity, exclude);
       _args.check();
@@ -434,7 +434,7 @@ static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "addBuoyancy", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
@@ -537,7 +537,7 @@ static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "setOpenBound", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
@@ -567,11 +567,11 @@ void PbRegister_setOpenBound()
 //! delete fluid and ensure empty flag in outflow cells, delete particles and density and set phi
 //! to 0.5
 void resetOutflow(FlagGrid &flags,
-                  Grid<Real> *phi = 0,
-                  BasicParticleSystem *parts = 0,
-                  Grid<Real> *real = 0,
-                  Grid<int> *index = 0,
-                  ParticleIndexSystem *indexSys = 0)
+                  Grid<Real> *phi = nullptr,
+                  BasicParticleSystem *parts = nullptr,
+                  Grid<Real> *real = nullptr,
+                  Grid<int> *index = nullptr,
+                  ParticleIndexSystem *indexSys = nullptr)
 {
   // check if phi and parts -> pindex and gpi already created -> access particles from cell index,
   // avoid extra looping over particles
@@ -623,16 +623,17 @@ static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "resetOutflow", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
-      Grid<Real> *phi = _args.getPtrOpt<Grid<Real>>("phi", 1, 0, &_lock);
-      BasicParticleSystem *parts = _args.getPtrOpt<BasicParticleSystem>("parts", 2, 0, &_lock);
-      Grid<Real> *real = _args.getPtrOpt<Grid<Real>>("real", 3, 0, &_lock);
-      Grid<int> *index = _args.getPtrOpt<Grid<int>>("index", 4, 0, &_lock);
+      Grid<Real> *phi = _args.getPtrOpt<Grid<Real>>("phi", 1, nullptr, &_lock);
+      BasicParticleSystem *parts = _args.getPtrOpt<BasicParticleSystem>(
+          "parts", 2, nullptr, &_lock);
+      Grid<Real> *real = _args.getPtrOpt<Grid<Real>>("real", 3, nullptr, &_lock);
+      Grid<int> *index = _args.getPtrOpt<Grid<int>>("index", 4, nullptr, &_lock);
       ParticleIndexSystem *indexSys = _args.getPtrOpt<ParticleIndexSystem>(
-          "indexSys", 5, 0, &_lock);
+          "indexSys", 5, nullptr, &_lock);
       _retval = getPyNone();
       resetOutflow(flags, phi, parts, real, index, indexSys);
       _args.check();
@@ -747,7 +748,7 @@ static PyObject *_W_5(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "setInflowBcs", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       MACGrid &vel = *_args.getPtr<MACGrid>("vel", 0, &_lock);
@@ -1064,13 +1065,13 @@ struct KnSetWallBcsFrac : public KernelBase {
 };
 
 //! set zero normal velocity boundary condition on walls
-// (optionally with second order accuracy using the obstacle SDF , fractions grid currentlyl not
+// (optionally with second order accuracy using the obstacle SDF , fractions grid currently not
 // needed)
 void setWallBcs(const FlagGrid &flags,
                 MACGrid &vel,
-                const MACGrid *obvel = 0,
-                const MACGrid *fractions = 0,
-                const Grid<Real> *phiObs = 0,
+                const MACGrid *obvel = nullptr,
+                const MACGrid *fractions = nullptr,
+                const Grid<Real> *phiObs = nullptr,
                 int boundaryWidth = 0)
 {
   if (!phiObs || !fractions) {
@@ -1089,14 +1090,14 @@ static PyObject *_W_6(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "setWallBcs", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
       MACGrid &vel = *_args.getPtr<MACGrid>("vel", 1, &_lock);
-      const MACGrid *obvel = _args.getPtrOpt<MACGrid>("obvel", 2, 0, &_lock);
-      const MACGrid *fractions = _args.getPtrOpt<MACGrid>("fractions", 3, 0, &_lock);
-      const Grid<Real> *phiObs = _args.getPtrOpt<Grid<Real>>("phiObs", 4, 0, &_lock);
+      const MACGrid *obvel = _args.getPtrOpt<MACGrid>("obvel", 2, nullptr, &_lock);
+      const MACGrid *fractions = _args.getPtrOpt<MACGrid>("fractions", 3, nullptr, &_lock);
+      const Grid<Real> *phiObs = _args.getPtrOpt<Grid<Real>>("phiObs", 4, nullptr, &_lock);
       int boundaryWidth = _args.getOpt<int>("boundaryWidth", 5, 0, &_lock);
       _retval = getPyNone();
       setWallBcs(flags, vel, obvel, fractions, phiObs, boundaryWidth);
@@ -1219,7 +1220,7 @@ static PyObject *_W_7(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "setInitialVelocity", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
@@ -1342,7 +1343,7 @@ struct KnConfForce : public KernelBase {
 void vorticityConfinement(MACGrid &vel,
                           const FlagGrid &flags,
                           Real strength = 0,
-                          const Grid<Real> *strengthCell = NULL)
+                          const Grid<Real> *strengthCell = nullptr)
 {
   Grid<Vec3> velCenter(flags.getParent()), curl(flags.getParent()), force(flags.getParent());
   Grid<Real> norm(flags.getParent());
@@ -1351,7 +1352,7 @@ void vorticityConfinement(MACGrid &vel,
   CurlOp(velCenter, curl);
   GridNorm(norm, curl);
   KnConfForce(force, norm, curl, strength, strengthCell);
-  KnApplyForceField(flags, vel, force, NULL, true, false);
+  KnApplyForceField(flags, vel, force, nullptr, true, false);
 }
 static PyObject *_W_8(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
 {
@@ -1360,14 +1361,14 @@ static PyObject *_W_8(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "vorticityConfinement", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       MACGrid &vel = *_args.getPtr<MACGrid>("vel", 0, &_lock);
       const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 1, &_lock);
       Real strength = _args.getOpt<Real>("strength", 2, 0, &_lock);
       const Grid<Real> *strengthCell = _args.getPtrOpt<Grid<Real>>(
-          "strengthCell", 3, NULL, &_lock);
+          "strengthCell", 3, nullptr, &_lock);
       _retval = getPyNone();
       vorticityConfinement(vel, flags, strength, strengthCell);
       _args.check();
@@ -1391,7 +1392,7 @@ void PbRegister_vorticityConfinement()
 void addForceField(const FlagGrid &flags,
                    MACGrid &vel,
                    const Grid<Vec3> &force,
-                   const Grid<Real> *region = NULL,
+                   const Grid<Real> *region = nullptr,
                    bool isMAC = false)
 {
   KnApplyForceField(flags, vel, force, region, true, isMAC);
@@ -1403,13 +1404,13 @@ static PyObject *_W_9(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "addForceField", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
       MACGrid &vel = *_args.getPtr<MACGrid>("vel", 1, &_lock);
       const Grid<Vec3> &force = *_args.getPtr<Grid<Vec3>>("force", 2, &_lock);
-      const Grid<Real> *region = _args.getPtrOpt<Grid<Real>>("region", 3, NULL, &_lock);
+      const Grid<Real> *region = _args.getPtrOpt<Grid<Real>>("region", 3, nullptr, &_lock);
       bool isMAC = _args.getOpt<bool>("isMAC", 4, false, &_lock);
       _retval = getPyNone();
       addForceField(flags, vel, force, region, isMAC);
@@ -1434,7 +1435,7 @@ void PbRegister_addForceField()
 void setForceField(const FlagGrid &flags,
                    MACGrid &vel,
                    const Grid<Vec3> &force,
-                   const Grid<Real> *region = NULL,
+                   const Grid<Real> *region = nullptr,
                    bool isMAC = false)
 {
   KnApplyForceField(flags, vel, force, region, false, isMAC);
@@ -1446,13 +1447,13 @@ static PyObject *_W_10(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "setForceField", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
       MACGrid &vel = *_args.getPtr<MACGrid>("vel", 1, &_lock);
       const Grid<Vec3> &force = *_args.getPtr<Grid<Vec3>>("force", 2, &_lock);
-      const Grid<Real> *region = _args.getPtrOpt<Grid<Real>>("region", 3, NULL, &_lock);
+      const Grid<Real> *region = _args.getPtrOpt<Grid<Real>>("region", 3, nullptr, &_lock);
       bool isMAC = _args.getOpt<bool>("isMAC", 4, false, &_lock);
       _retval = getPyNone();
       setForceField(flags, vel, force, region, isMAC);
@@ -1645,10 +1646,10 @@ struct KnDissolveSmoke : public KernelBase {
 
 void dissolveSmoke(const FlagGrid &flags,
                    Grid<Real> &density,
-                   Grid<Real> *heat = NULL,
-                   Grid<Real> *red = NULL,
-                   Grid<Real> *green = NULL,
-                   Grid<Real> *blue = NULL,
+                   Grid<Real> *heat = nullptr,
+                   Grid<Real> *red = nullptr,
+                   Grid<Real> *green = nullptr,
+                   Grid<Real> *blue = nullptr,
                    int speed = 5,
                    bool logFalloff = true)
 {
@@ -1663,15 +1664,15 @@ static PyObject *_W_11(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "dissolveSmoke", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
       Grid<Real> &density = *_args.getPtr<Grid<Real>>("density", 1, &_lock);
-      Grid<Real> *heat = _args.getPtrOpt<Grid<Real>>("heat", 2, NULL, &_lock);
-      Grid<Real> *red = _args.getPtrOpt<Grid<Real>>("red", 3, NULL, &_lock);
-      Grid<Real> *green = _args.getPtrOpt<Grid<Real>>("green", 4, NULL, &_lock);
-      Grid<Real> *blue = _args.getPtrOpt<Grid<Real>>("blue", 5, NULL, &_lock);
+      Grid<Real> *heat = _args.getPtrOpt<Grid<Real>>("heat", 2, nullptr, &_lock);
+      Grid<Real> *red = _args.getPtrOpt<Grid<Real>>("red", 3, nullptr, &_lock);
+      Grid<Real> *green = _args.getPtrOpt<Grid<Real>>("green", 4, nullptr, &_lock);
+      Grid<Real> *blue = _args.getPtrOpt<Grid<Real>>("blue", 5, nullptr, &_lock);
       int speed = _args.getOpt<int>("speed", 6, 5, &_lock);
       bool logFalloff = _args.getOpt<bool>("logFalloff", 7, true, &_lock);
       _retval = getPyNone();

extern/mantaflow/preprocessed/plugin/fire.cpp

@@ -258,10 +258,10 @@ struct KnProcessBurn : public KernelBase {
 void processBurn(Grid<Real> &fuel,
                  Grid<Real> &density,
                  Grid<Real> &react,
-                 Grid<Real> *red = NULL,
-                 Grid<Real> *green = NULL,
-                 Grid<Real> *blue = NULL,
-                 Grid<Real> *heat = NULL,
+                 Grid<Real> *red = nullptr,
+                 Grid<Real> *green = nullptr,
+                 Grid<Real> *blue = nullptr,
+                 Grid<Real> *heat = nullptr,
                  Real burningRate = 0.75f,
                  Real flameSmoke = 1.0f,
                  Real ignitionTemp = 1.25f,
@@ -290,16 +290,16 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "processBurn", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Grid<Real> &fuel = *_args.getPtr<Grid<Real>>("fuel", 0, &_lock);
       Grid<Real> &density = *_args.getPtr<Grid<Real>>("density", 1, &_lock);
       Grid<Real> &react = *_args.getPtr<Grid<Real>>("react", 2, &_lock);
-      Grid<Real> *red = _args.getPtrOpt<Grid<Real>>("red", 3, NULL, &_lock);
-      Grid<Real> *green = _args.getPtrOpt<Grid<Real>>("green", 4, NULL, &_lock);
-      Grid<Real> *blue = _args.getPtrOpt<Grid<Real>>("blue", 5, NULL, &_lock);
-      Grid<Real> *heat = _args.getPtrOpt<Grid<Real>>("heat", 6, NULL, &_lock);
+      Grid<Real> *red = _args.getPtrOpt<Grid<Real>>("red", 3, nullptr, &_lock);
+      Grid<Real> *green = _args.getPtrOpt<Grid<Real>>("green", 4, nullptr, &_lock);
+      Grid<Real> *blue = _args.getPtrOpt<Grid<Real>>("blue", 5, nullptr, &_lock);
+      Grid<Real> *heat = _args.getPtrOpt<Grid<Real>>("heat", 6, nullptr, &_lock);
       Real burningRate = _args.getOpt<Real>("burningRate", 7, 0.75f, &_lock);
       Real flameSmoke = _args.getOpt<Real>("flameSmoke", 8, 1.0f, &_lock);
       Real ignitionTemp = _args.getOpt<Real>("ignitionTemp", 9, 1.25f, &_lock);
@@ -407,7 +407,7 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "updateFlame", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const Grid<Real> &react = *_args.getPtr<Grid<Real>>("react", 0, &_lock);

extern/mantaflow/preprocessed/plugin/flip.cpp

@@ -69,7 +69,7 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "sampleFlagsWithParticles", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
@@ -156,7 +156,7 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "sampleLevelsetWithParticles", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const LevelsetGrid &phi = *_args.getPtr<LevelsetGrid>("phi", 0, &_lock);
@@ -200,7 +200,7 @@ void sampleShapeWithParticles(const Shape &shape,
                               const Real randomness,
                               const bool reset = false,
                               const bool refillEmpty = false,
-                              const LevelsetGrid *exclude = NULL)
+                              const LevelsetGrid *exclude = nullptr)
 {
   const bool is3D = flags.is3D();
   const Real jlen = randomness / discretization;
@@ -243,7 +243,7 @@ static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "sampleShapeWithParticles", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const Shape &shape = *_args.getPtr<Shape>("shape", 0, &_lock);
@@ -253,7 +253,7 @@ static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
       const Real randomness = _args.get<Real>("randomness", 4, &_lock);
       const bool reset = _args.getOpt<bool>("reset", 5, false, &_lock);
       const bool refillEmpty = _args.getOpt<bool>("refillEmpty", 6, false, &_lock);
-      const LevelsetGrid *exclude = _args.getPtrOpt<LevelsetGrid>("exclude", 7, NULL, &_lock);
+      const LevelsetGrid *exclude = _args.getPtrOpt<LevelsetGrid>("exclude", 7, nullptr, &_lock);
       _retval = getPyNone();
       sampleShapeWithParticles(
           shape, flags, parts, discretization, randomness, reset, refillEmpty, exclude);
@@ -418,8 +418,8 @@ struct knSetNbObstacle : public KernelBase {
 };
 void markFluidCells(const BasicParticleSystem &parts,
                     FlagGrid &flags,
-                    const Grid<Real> *phiObs = NULL,
-                    const ParticleDataImpl<int> *ptype = NULL,
+                    const Grid<Real> *phiObs = nullptr,
+                    const ParticleDataImpl<int> *ptype = nullptr,
                     const int exclude = 0)
 {
   // remove all fluid cells
@@ -448,14 +448,14 @@ static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "markFluidCells", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock);
       FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 1, &_lock);
-      const Grid<Real> *phiObs = _args.getPtrOpt<Grid<Real>>("phiObs", 2, NULL, &_lock);
+      const Grid<Real> *phiObs = _args.getPtrOpt<Grid<Real>>("phiObs", 2, nullptr, &_lock);
       const ParticleDataImpl<int> *ptype = _args.getPtrOpt<ParticleDataImpl<int>>(
-          "ptype", 3, NULL, &_lock);
+          "ptype", 3, nullptr, &_lock);
       const int exclude = _args.getOpt<int>("exclude", 4, 0, &_lock);
       _retval = getPyNone();
       markFluidCells(parts, flags, phiObs, ptype, exclude);
@@ -492,7 +492,7 @@ static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "testInitGridWithPos", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Grid<Real> &grid = *_args.getPtr<Grid<Real>>("grid", 0, &_lock);
@@ -534,7 +534,7 @@ void adjustNumber(BasicParticleSystem &parts,
                   const LevelsetGrid &phi,
                   Real radiusFactor = 1.,
                   Real narrowBand = -1.,
-                  const Grid<Real> *exclude = NULL)
+                  const Grid<Real> *exclude = nullptr)
 {
   // which levelset to use as threshold
   const Real SURFACE_LS = -1.0 * calculateRadiusFactor(phi, radiusFactor);
@@ -610,7 +610,7 @@ static PyObject *_W_5(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "adjustNumber", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock);
@@ -621,7 +621,7 @@ static PyObject *_W_5(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
       const LevelsetGrid &phi = *_args.getPtr<LevelsetGrid>("phi", 5, &_lock);
       Real radiusFactor = _args.getOpt<Real>("radiusFactor", 6, 1., &_lock);
       Real narrowBand = _args.getOpt<Real>("narrowBand", 7, -1., &_lock);
-      const Grid<Real> *exclude = _args.getPtrOpt<Grid<Real>>("exclude", 8, NULL, &_lock);
+      const Grid<Real> *exclude = _args.getPtrOpt<Grid<Real>>("exclude", 8, nullptr, &_lock);
       _retval = getPyNone();
       adjustNumber(
           parts, vel, flags, minParticles, maxParticles, phi, radiusFactor, narrowBand, exclude);
@@ -660,7 +660,7 @@ static PyObject *_W_6(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "debugIntToReal", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const Grid<int> &source = *_args.getPtr<Grid<int>>("source", 0, &_lock);
@@ -694,7 +694,7 @@ void gridParticleIndex(const BasicParticleSystem &parts,
                        ParticleIndexSystem &indexSys,
                        const FlagGrid &flags,
                        Grid<int> &index,
-                       Grid<int> *counter = NULL)
+                       Grid<int> *counter = nullptr)
 {
   bool delCounter = false;
   if (!counter) {
@@ -761,14 +761,14 @@ static PyObject *_W_7(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "gridParticleIndex", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock);
       ParticleIndexSystem &indexSys = *_args.getPtr<ParticleIndexSystem>("indexSys", 1, &_lock);
       const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 2, &_lock);
       Grid<int> &index = *_args.getPtr<Grid<int>>("index", 3, &_lock);
-      Grid<int> *counter = _args.getPtrOpt<Grid<int>>("counter", 4, NULL, &_lock);
+      Grid<int> *counter = _args.getPtrOpt<Grid<int>>("counter", 4, nullptr, &_lock);
       _retval = getPyNone();
       gridParticleIndex(parts, indexSys, flags, index, counter);
       _args.check();
@@ -932,7 +932,7 @@ void unionParticleLevelset(const BasicParticleSystem &parts,
                            const Grid<int> &index,
                            LevelsetGrid &phi,
                            const Real radiusFactor = 1.,
-                           const ParticleDataImpl<int> *ptype = NULL,
+                           const ParticleDataImpl<int> *ptype = nullptr,
                            const int exclude = 0)
 {
   // use half a cell diagonal as base radius
@@ -949,7 +949,7 @@ static PyObject *_W_8(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "unionParticleLevelset", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock);
@@ -960,7 +960,7 @@ static PyObject *_W_8(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
       LevelsetGrid &phi = *_args.getPtr<LevelsetGrid>("phi", 4, &_lock);
       const Real radiusFactor = _args.getOpt<Real>("radiusFactor", 5, 1., &_lock);
       const ParticleDataImpl<int> *ptype = _args.getPtrOpt<ParticleDataImpl<int>>(
-          "ptype", 6, NULL, &_lock);
+          "ptype", 6, nullptr, &_lock);
       const int exclude = _args.getOpt<int>("exclude", 7, 0, &_lock);
       _retval = getPyNone();
       unionParticleLevelset(parts, indexSys, flags, index, phi, radiusFactor, ptype, exclude);
@@ -992,8 +992,8 @@ struct ComputeAveragedLevelsetWeight : public KernelBase {
                                 const Real radius,
                                 const ParticleDataImpl<int> *ptype,
                                 const int exclude,
-                                Grid<Vec3> *save_pAcc = NULL,
-                                Grid<Real> *save_rAcc = NULL)
+                                Grid<Vec3> *save_pAcc = nullptr,
+                                Grid<Real> *save_rAcc = nullptr)
       : KernelBase(&index, 0),
         parts(parts),
         index(index),
@@ -1018,8 +1018,8 @@ struct ComputeAveragedLevelsetWeight : public KernelBase {
                  const Real radius,
                  const ParticleDataImpl<int> *ptype,
                  const int exclude,
-                 Grid<Vec3> *save_pAcc = NULL,
-                 Grid<Real> *save_rAcc = NULL) const
+                 Grid<Vec3> *save_pAcc = nullptr,
+                 Grid<Real> *save_rAcc = nullptr) const
   {
     const Vec3 gridPos = Vec3(i, j, k) + Vec3(0.5);  // shifted by half cell
     Real phiv = radius * 1.0;                        // outside
@@ -1312,7 +1312,7 @@ void averagedParticleLevelset(const BasicParticleSystem &parts,
                               const Real radiusFactor = 1.,
                               const int smoothen = 1,
                               const int smoothenNeg = 1,
-                              const ParticleDataImpl<int> *ptype = NULL,
+                              const ParticleDataImpl<int> *ptype = nullptr,
                               const int exclude = 0)
 {
   // use half a cell diagonal as base radius
@@ -1340,7 +1340,7 @@ static PyObject *_W_9(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "averagedParticleLevelset", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock);
@@ -1353,7 +1353,7 @@ static PyObject *_W_9(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
       const int smoothen = _args.getOpt<int>("smoothen", 6, 1, &_lock);
       const int smoothenNeg = _args.getOpt<int>("smoothenNeg", 7, 1, &_lock);
       const ParticleDataImpl<int> *ptype = _args.getPtrOpt<ParticleDataImpl<int>>(
-          "ptype", 8, NULL, &_lock);
+          "ptype", 8, nullptr, &_lock);
       const int exclude = _args.getOpt<int>("exclude", 9, 0, &_lock);
       _retval = getPyNone();
       averagedParticleLevelset(
@@ -1523,7 +1523,7 @@ void improvedParticleLevelset(const BasicParticleSystem &parts,
                               const int smoothenNeg = 1,
                               const Real t_low = 0.4,
                               const Real t_high = 3.5,
-                              const ParticleDataImpl<int> *ptype = NULL,
+                              const ParticleDataImpl<int> *ptype = nullptr,
                               const int exclude = 0)
 {
   // create temporary grids to store values from levelset weight computation
@@ -1557,7 +1557,7 @@ static PyObject *_W_10(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "improvedParticleLevelset", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock);
@@ -1572,7 +1572,7 @@ static PyObject *_W_10(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
       const Real t_low = _args.getOpt<Real>("t_low", 8, 0.4, &_lock);
       const Real t_high = _args.getOpt<Real>("t_high", 9, 3.5, &_lock);
       const ParticleDataImpl<int> *ptype = _args.getPtrOpt<ParticleDataImpl<int>>(
-          "ptype", 10, NULL, &_lock);
+          "ptype", 10, nullptr, &_lock);
       const int exclude = _args.getOpt<int>("exclude", 11, 0, &_lock);
       _retval = getPyNone();
       improvedParticleLevelset(parts,
@@ -1714,7 +1714,7 @@ void pushOutofObs(BasicParticleSystem &parts,
                   const Grid<Real> &phiObs,
                   const Real shift = 0,
                   const Real thresh = 0,
-                  const ParticleDataImpl<int> *ptype = NULL,
+                  const ParticleDataImpl<int> *ptype = nullptr,
                   const int exclude = 0)
 {
   knPushOutofObs(parts, flags, phiObs, shift, thresh, ptype, exclude);
@@ -1726,7 +1726,7 @@ static PyObject *_W_11(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "pushOutofObs", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock);
@@ -1735,7 +1735,7 @@ static PyObject *_W_11(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
       const Real shift = _args.getOpt<Real>("shift", 3, 0, &_lock);
       const Real thresh = _args.getOpt<Real>("thresh", 4, 0, &_lock);
       const ParticleDataImpl<int> *ptype = _args.getPtrOpt<ParticleDataImpl<int>>(
-          "ptype", 5, NULL, &_lock);
+          "ptype", 5, nullptr, &_lock);
       const int exclude = _args.getOpt<int>("exclude", 6, 0, &_lock);
       _retval = getPyNone();
       pushOutofObs(parts, flags, phiObs, shift, thresh, ptype, exclude);
@@ -1917,8 +1917,8 @@ void mapPartsToMAC(const FlagGrid &flags,
                    MACGrid &velOld,
                    const BasicParticleSystem &parts,
                    const ParticleDataImpl<Vec3> &partVel,
-                   Grid<Vec3> *weight = NULL,
-                   const ParticleDataImpl<int> *ptype = NULL,
+                   Grid<Vec3> *weight = nullptr,
+                   const ParticleDataImpl<int> *ptype = nullptr,
                    const int exclude = 0)
 {
   // interpol -> grid. tmpgrid for particle contribution weights
@@ -1949,7 +1949,7 @@ static PyObject *_W_12(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "mapPartsToMAC", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
@@ -1958,9 +1958,9 @@ static PyObject *_W_12(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
       const BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 3, &_lock);
       const ParticleDataImpl<Vec3> &partVel = *_args.getPtr<ParticleDataImpl<Vec3>>(
           "partVel", 4, &_lock);
-      Grid<Vec3> *weight = _args.getPtrOpt<Grid<Vec3>>("weight", 5, NULL, &_lock);
+      Grid<Vec3> *weight = _args.getPtrOpt<Grid<Vec3>>("weight", 5, nullptr, &_lock);
       const ParticleDataImpl<int> *ptype = _args.getPtrOpt<ParticleDataImpl<int>>(
-          "ptype", 6, NULL, &_lock);
+          "ptype", 6, nullptr, &_lock);
       const int exclude = _args.getOpt<int>("exclude", 7, 0, &_lock);
       _retval = getPyNone();
       mapPartsToMAC(flags, vel, velOld, parts, partVel, weight, ptype, exclude);
@@ -2076,7 +2076,7 @@ static PyObject *_W_13(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "mapPartsToGrid", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
@@ -2118,7 +2118,7 @@ static PyObject *_W_14(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "mapPartsToGridVec3", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
@@ -2215,7 +2215,7 @@ static PyObject *_W_15(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "mapGridToParts", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const Grid<Real> &source = *_args.getPtr<Grid<Real>>("source", 0, &_lock);
@@ -2254,7 +2254,7 @@ static PyObject *_W_16(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "mapGridToPartsVec3", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const Grid<Vec3> &source = *_args.getPtr<Grid<Vec3>>("source", 0, &_lock);
@@ -2371,7 +2371,7 @@ void mapMACToParts(const FlagGrid &flags,
                    const MACGrid &vel,
                    const BasicParticleSystem &parts,
                    ParticleDataImpl<Vec3> &partVel,
-                   const ParticleDataImpl<int> *ptype = NULL,
+                   const ParticleDataImpl<int> *ptype = nullptr,
                    const int exclude = 0)
 {
   knMapLinearMACGridToVec3_PIC(parts, flags, vel, partVel, ptype, exclude);
@@ -2383,7 +2383,7 @@ static PyObject *_W_17(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "mapMACToParts", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
@@ -2392,7 +2392,7 @@ static PyObject *_W_17(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
       ParticleDataImpl<Vec3> &partVel = *_args.getPtr<ParticleDataImpl<Vec3>>(
           "partVel", 3, &_lock);
       const ParticleDataImpl<int> *ptype = _args.getPtrOpt<ParticleDataImpl<int>>(
-          "ptype", 4, NULL, &_lock);
+          "ptype", 4, nullptr, &_lock);
       const int exclude = _args.getOpt<int>("exclude", 5, 0, &_lock);
       _retval = getPyNone();
       mapMACToParts(flags, vel, parts, partVel, ptype, exclude);
@@ -2526,7 +2526,7 @@ void flipVelocityUpdate(const FlagGrid &flags,
                         const BasicParticleSystem &parts,
                         ParticleDataImpl<Vec3> &partVel,
                         const Real flipRatio,
-                        const ParticleDataImpl<int> *ptype = NULL,
+                        const ParticleDataImpl<int> *ptype = nullptr,
                         const int exclude = 0)
 {
   knMapLinearMACGridToVec3_FLIP(parts, flags, vel, velOld, partVel, flipRatio, ptype, exclude);
@@ -2538,7 +2538,7 @@ static PyObject *_W_18(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "flipVelocityUpdate", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
@@ -2549,7 +2549,7 @@ static PyObject *_W_18(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
           "partVel", 4, &_lock);
       const Real flipRatio = _args.get<Real>("flipRatio", 5, &_lock);
       const ParticleDataImpl<int> *ptype = _args.getPtrOpt<ParticleDataImpl<int>>(
-          "ptype", 6, NULL, &_lock);
+          "ptype", 6, nullptr, &_lock);
       const int exclude = _args.getOpt<int>("exclude", 7, 0, &_lock);
       _retval = getPyNone();
       flipVelocityUpdate(flags, vel, velOld, parts, partVel, flipRatio, ptype, exclude);
@@ -2700,7 +2700,7 @@ struct knCombineVels : public KernelBase {
 void combineGridVel(MACGrid &vel,
                     const Grid<Vec3> &weight,
                     MACGrid &combineVel,
-                    const LevelsetGrid *phi = NULL,
+                    const LevelsetGrid *phi = nullptr,
                     Real narrowBand = 0.0,
                     Real thresh = 0.0)
 {
@@ -2713,13 +2713,13 @@ static PyObject *_W_19(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "combineGridVel", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       MACGrid &vel = *_args.getPtr<MACGrid>("vel", 0, &_lock);
       const Grid<Vec3> &weight = *_args.getPtr<Grid<Vec3>>("weight", 1, &_lock);
       MACGrid &combineVel = *_args.getPtr<MACGrid>("combineVel", 2, &_lock);
-      const LevelsetGrid *phi = _args.getPtrOpt<LevelsetGrid>("phi", 3, NULL, &_lock);
+      const LevelsetGrid *phi = _args.getPtrOpt<LevelsetGrid>("phi", 3, nullptr, &_lock);
       Real narrowBand = _args.getOpt<Real>("narrowBand", 4, 0.0, &_lock);
       Real thresh = _args.getOpt<Real>("thresh", 5, 0.0, &_lock);
       _retval = getPyNone();
@@ -2754,7 +2754,7 @@ static PyObject *_W_20(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "getLaplacian", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Grid<Real> &laplacian = *_args.getPtr<Grid<Real>>("laplacian", 0, &_lock);
@@ -2790,7 +2790,7 @@ static PyObject *_W_21(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "getCurvature", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Grid<Real> &curv = *_args.getPtr<Grid<Real>>("curv", 0, &_lock);

extern/mantaflow/preprocessed/plugin/fluidguiding.cpp

@@ -404,7 +404,7 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "getSpiralVelocity", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
@@ -454,7 +454,7 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "setGradientYWeight", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Grid<Real> &W = *_args.getPtr<Grid<Real>>("W", 0, &_lock);
@@ -574,10 +574,10 @@ void solvePressure(MACGrid &vel,
                    Grid<Real> &pressure,
                    const FlagGrid &flags,
                    Real cgAccuracy = 1e-3,
-                   const Grid<Real> *phi = 0,
-                   const Grid<Real> *perCellCorr = 0,
-                   const MACGrid *fractions = 0,
-                   const MACGrid *obvel = 0,
+                   const Grid<Real> *phi = nullptr,
+                   const Grid<Real> *perCellCorr = nullptr,
+                   const MACGrid *fractions = nullptr,
+                   const MACGrid *obvel = nullptr,
                    Real gfClamp = 1e-04,
                    Real cgMaxIterFac = 1.5,
                    bool precondition = true,
@@ -585,9 +585,9 @@ void solvePressure(MACGrid &vel,
                    bool enforceCompatibility = false,
                    bool useL2Norm = false,
                    bool zeroPressureFixing = false,
-                   const Grid<Real> *curv = NULL,
+                   const Grid<Real> *curv = nullptr,
                    const Real surfTens = 0.0,
-                   Grid<Real> *retRhs = NULL);
+                   Grid<Real> *retRhs = nullptr);
 
 //! Main function for fluid guiding , includes "regular" pressure solve
 
@@ -603,16 +603,16 @@ void PD_fluid_guiding(MACGrid &vel,
                       Real epsRel = 1e-3,
                       Real epsAbs = 1e-3,
                       int maxIters = 200,
-                      Grid<Real> *phi = 0,
-                      Grid<Real> *perCellCorr = 0,
-                      MACGrid *fractions = 0,
-                      MACGrid *obvel = 0,
+                      Grid<Real> *phi = nullptr,
+                      Grid<Real> *perCellCorr = nullptr,
+                      MACGrid *fractions = nullptr,
+                      MACGrid *obvel = nullptr,
                       Real gfClamp = 1e-04,
                       Real cgMaxIterFac = 1.5,
                       Real cgAccuracy = 1e-3,
                       int preconditioner = 1,
                       bool zeroPressureFixing = false,
-                      const Grid<Real> *curv = NULL,
+                      const Grid<Real> *curv = nullptr,
                       const Real surfTens = 0.)
 {
   FluidSolver *parent = vel.getParent();
@@ -693,7 +693,7 @@ static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "PD_fluid_guiding", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       MACGrid &vel = *_args.getPtr<MACGrid>("vel", 0, &_lock);
@@ -708,16 +708,16 @@ static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
       Real epsRel = _args.getOpt<Real>("epsRel", 9, 1e-3, &_lock);
       Real epsAbs = _args.getOpt<Real>("epsAbs", 10, 1e-3, &_lock);
       int maxIters = _args.getOpt<int>("maxIters", 11, 200, &_lock);
-      Grid<Real> *phi = _args.getPtrOpt<Grid<Real>>("phi", 12, 0, &_lock);
-      Grid<Real> *perCellCorr = _args.getPtrOpt<Grid<Real>>("perCellCorr", 13, 0, &_lock);
-      MACGrid *fractions = _args.getPtrOpt<MACGrid>("fractions", 14, 0, &_lock);
-      MACGrid *obvel = _args.getPtrOpt<MACGrid>("obvel", 15, 0, &_lock);
+      Grid<Real> *phi = _args.getPtrOpt<Grid<Real>>("phi", 12, nullptr, &_lock);
+      Grid<Real> *perCellCorr = _args.getPtrOpt<Grid<Real>>("perCellCorr", 13, nullptr, &_lock);
+      MACGrid *fractions = _args.getPtrOpt<MACGrid>("fractions", 14, nullptr, &_lock);
+      MACGrid *obvel = _args.getPtrOpt<MACGrid>("obvel", 15, nullptr, &_lock);
       Real gfClamp = _args.getOpt<Real>("gfClamp", 16, 1e-04, &_lock);
       Real cgMaxIterFac = _args.getOpt<Real>("cgMaxIterFac", 17, 1.5, &_lock);
       Real cgAccuracy = _args.getOpt<Real>("cgAccuracy", 18, 1e-3, &_lock);
       int preconditioner = _args.getOpt<int>("preconditioner", 19, 1, &_lock);
       bool zeroPressureFixing = _args.getOpt<bool>("zeroPressureFixing", 20, false, &_lock);
-      const Grid<Real> *curv = _args.getPtrOpt<Grid<Real>>("curv", 21, NULL, &_lock);
+      const Grid<Real> *curv = _args.getPtrOpt<Grid<Real>>("curv", 21, nullptr, &_lock);
       const Real surfTens = _args.getOpt<Real>("surfTens", 22, 0., &_lock);
       _retval = getPyNone();
       PD_fluid_guiding(vel,
@@ -775,7 +775,7 @@ static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "releaseBlurPrecomp", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       _retval = getPyNone();

extern/mantaflow/preprocessed/plugin/initplugins.cpp

@@ -154,7 +154,7 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "densityInflow", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
@@ -273,7 +273,7 @@ struct KnAddNoise : public KernelBase {
 void addNoise(const FlagGrid &flags,
               Grid<Real> &density,
               const WaveletNoiseField &noise,
-              const Grid<Real> *sdf = NULL,
+              const Grid<Real> *sdf = nullptr,
               Real scale = 1.0)
 {
   KnAddNoise(flags, density, noise, sdf, scale);
@@ -285,13 +285,13 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "addNoise", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
       Grid<Real> &density = *_args.getPtr<Grid<Real>>("density", 1, &_lock);
       const WaveletNoiseField &noise = *_args.getPtr<WaveletNoiseField>("noise", 2, &_lock);
-      const Grid<Real> *sdf = _args.getPtrOpt<Grid<Real>>("sdf", 3, NULL, &_lock);
+      const Grid<Real> *sdf = _args.getPtrOpt<Grid<Real>>("sdf", 3, nullptr, &_lock);
       Real scale = _args.getOpt<Real>("scale", 4, 1.0, &_lock);
       _retval = getPyNone();
       addNoise(flags, density, noise, sdf, scale);
@@ -448,7 +448,7 @@ static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "setNoisePdata", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock);
@@ -489,7 +489,7 @@ static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "setNoisePdataVec3", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock);
@@ -530,7 +530,7 @@ static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "setNoisePdataInt", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock);
@@ -592,7 +592,7 @@ static PyObject *_W_5(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "obstacleGradient", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
@@ -636,7 +636,7 @@ static PyObject *_W_6(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "obstacleLevelset", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
@@ -777,7 +777,7 @@ struct KnApplyEmission : public KernelBase {
 void applyEmission(FlagGrid &flags,
                    Grid<Real> &target,
                    Grid<Real> &source,
-                   Grid<Real> *emissionTexture = NULL,
+                   Grid<Real> *emissionTexture = nullptr,
                    bool isAbsolute = true,
                    int type = 0)
 {
@@ -790,14 +790,14 @@ static PyObject *_W_7(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "applyEmission", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
       Grid<Real> &target = *_args.getPtr<Grid<Real>>("target", 1, &_lock);
       Grid<Real> &source = *_args.getPtr<Grid<Real>>("source", 2, &_lock);
       Grid<Real> *emissionTexture = _args.getPtrOpt<Grid<Real>>(
-          "emissionTexture", 3, NULL, &_lock);
+          "emissionTexture", 3, nullptr, &_lock);
       bool isAbsolute = _args.getOpt<bool>("isAbsolute", 4, true, &_lock);
       int type = _args.getOpt<int>("type", 5, 0, &_lock);
       _retval = getPyNone();
@@ -925,7 +925,7 @@ static PyObject *_W_8(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "densityInflowMeshNoise", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
@@ -974,7 +974,7 @@ static PyObject *_W_9(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "densityInflowMesh", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
@@ -1161,12 +1161,12 @@ struct KnResetInObstacle : public KernelBase {
 void resetInObstacle(FlagGrid &flags,
                      MACGrid &vel,
                      Grid<Real> *density,
-                     Grid<Real> *heat = NULL,
-                     Grid<Real> *fuel = NULL,
-                     Grid<Real> *flame = NULL,
-                     Grid<Real> *red = NULL,
-                     Grid<Real> *green = NULL,
-                     Grid<Real> *blue = NULL,
+                     Grid<Real> *heat = nullptr,
+                     Grid<Real> *fuel = nullptr,
+                     Grid<Real> *flame = nullptr,
+                     Grid<Real> *red = nullptr,
+                     Grid<Real> *green = nullptr,
+                     Grid<Real> *blue = nullptr,
                      Real resetValue = 0)
 {
   KnResetInObstacle(flags, vel, density, heat, fuel, flame, red, green, blue, resetValue);
@@ -1178,18 +1178,18 @@ static PyObject *_W_10(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "resetInObstacle", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
       MACGrid &vel = *_args.getPtr<MACGrid>("vel", 1, &_lock);
       Grid<Real> *density = _args.getPtr<Grid<Real>>("density", 2, &_lock);
-      Grid<Real> *heat = _args.getPtrOpt<Grid<Real>>("heat", 3, NULL, &_lock);
-      Grid<Real> *fuel = _args.getPtrOpt<Grid<Real>>("fuel", 4, NULL, &_lock);
-      Grid<Real> *flame = _args.getPtrOpt<Grid<Real>>("flame", 5, NULL, &_lock);
-      Grid<Real> *red = _args.getPtrOpt<Grid<Real>>("red", 6, NULL, &_lock);
-      Grid<Real> *green = _args.getPtrOpt<Grid<Real>>("green", 7, NULL, &_lock);
-      Grid<Real> *blue = _args.getPtrOpt<Grid<Real>>("blue", 8, NULL, &_lock);
+      Grid<Real> *heat = _args.getPtrOpt<Grid<Real>>("heat", 3, nullptr, &_lock);
+      Grid<Real> *fuel = _args.getPtrOpt<Grid<Real>>("fuel", 4, nullptr, &_lock);
+      Grid<Real> *flame = _args.getPtrOpt<Grid<Real>>("flame", 5, nullptr, &_lock);
+      Grid<Real> *red = _args.getPtrOpt<Grid<Real>>("red", 6, nullptr, &_lock);
+      Grid<Real> *green = _args.getPtrOpt<Grid<Real>>("green", 7, nullptr, &_lock);
+      Grid<Real> *blue = _args.getPtrOpt<Grid<Real>>("blue", 8, nullptr, &_lock);
       Real resetValue = _args.getOpt<Real>("resetValue", 9, 0, &_lock);
       _retval = getPyNone();
       resetInObstacle(flags, vel, density, heat, fuel, flame, red, green, blue, resetValue);
@@ -1216,7 +1216,7 @@ void PbRegister_resetInObstacle()
 //! check for symmetry , optionally enfore by copying
 
 void checkSymmetry(
-    Grid<Real> &a, Grid<Real> *err = NULL, bool symmetrize = false, int axis = 0, int bound = 0)
+    Grid<Real> &a, Grid<Real> *err = nullptr, bool symmetrize = false, int axis = 0, int bound = 0)
 {
   const int c = axis;
   const int s = a.getSize()[c];
@@ -1241,11 +1241,11 @@ static PyObject *_W_11(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "checkSymmetry", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Grid<Real> &a = *_args.getPtr<Grid<Real>>("a", 0, &_lock);
-      Grid<Real> *err = _args.getPtrOpt<Grid<Real>>("err", 1, NULL, &_lock);
+      Grid<Real> *err = _args.getPtrOpt<Grid<Real>>("err", 1, nullptr, &_lock);
       bool symmetrize = _args.getOpt<bool>("symmetrize", 2, false, &_lock);
       int axis = _args.getOpt<int>("axis", 3, 0, &_lock);
       int bound = _args.getOpt<int>("bound", 4, 0, &_lock);
@@ -1272,7 +1272,7 @@ void PbRegister_checkSymmetry()
 //! check for symmetry , mac grid version
 
 void checkSymmetryVec3(Grid<Vec3> &a,
-                       Grid<Real> *err = NULL,
+                       Grid<Real> *err = nullptr,
                        bool symmetrize = false,
                        int axis = 0,
                        int bound = 0,
@@ -1359,11 +1359,11 @@ static PyObject *_W_12(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "checkSymmetryVec3", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Grid<Vec3> &a = *_args.getPtr<Grid<Vec3>>("a", 0, &_lock);
-      Grid<Real> *err = _args.getPtrOpt<Grid<Real>>("err", 1, NULL, &_lock);
+      Grid<Real> *err = _args.getPtrOpt<Grid<Real>>("err", 1, nullptr, &_lock);
       bool symmetrize = _args.getOpt<bool>("symmetrize", 2, false, &_lock);
       int axis = _args.getOpt<int>("axis", 3, 0, &_lock);
       int bound = _args.getOpt<int>("bound", 4, 0, &_lock);
@@ -1407,7 +1407,7 @@ static PyObject *_W_13(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "projectPpmFull", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const Grid<Real> &val = *_args.getPtr<Grid<Real>>("val", 0, &_lock);
@@ -1453,7 +1453,7 @@ static PyObject *_W_14(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "addTestParts", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock);
@@ -1504,7 +1504,7 @@ static PyObject *_W_15(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "pdataMaxDiff", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const ParticleDataImpl<Real> *a = _args.getPtr<ParticleDataImpl<Real>>("a", 0, &_lock);
@@ -1539,7 +1539,7 @@ static PyObject *_W_16(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "pdataMaxDiffInt", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const ParticleDataImpl<int> *a = _args.getPtr<ParticleDataImpl<int>>("a", 0, &_lock);
@@ -1574,7 +1574,7 @@ static PyObject *_W_17(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "pdataMaxDiffVec3", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const ParticleDataImpl<Vec3> *a = _args.getPtr<ParticleDataImpl<Vec3>>("a", 0, &_lock);
@@ -1620,7 +1620,7 @@ static PyObject *_W_18(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "calcCenterOfMass", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const Grid<Real> &density = *_args.getPtr<Grid<Real>>("density", 0, &_lock);
@@ -1842,7 +1842,7 @@ static PyObject *_W_19(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "updateFractions", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
@@ -2007,9 +2007,9 @@ struct KnUpdateFlagsObs : public KernelBase {
 //! optionally uses fill fractions for obstacle
 void setObstacleFlags(FlagGrid &flags,
                       const Grid<Real> &phiObs,
-                      const MACGrid *fractions = NULL,
-                      const Grid<Real> *phiOut = NULL,
-                      const Grid<Real> *phiIn = NULL,
+                      const MACGrid *fractions = nullptr,
+                      const Grid<Real> *phiOut = nullptr,
+                      const Grid<Real> *phiIn = nullptr,
                       int boundaryWidth = 1)
 {
   KnUpdateFlagsObs(flags, fractions, phiObs, phiOut, phiIn, boundaryWidth);
@@ -2021,14 +2021,14 @@ static PyObject *_W_20(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "setObstacleFlags", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
       const Grid<Real> &phiObs = *_args.getPtr<Grid<Real>>("phiObs", 1, &_lock);
-      const MACGrid *fractions = _args.getPtrOpt<MACGrid>("fractions", 2, NULL, &_lock);
-      const Grid<Real> *phiOut = _args.getPtrOpt<Grid<Real>>("phiOut", 3, NULL, &_lock);
-      const Grid<Real> *phiIn = _args.getPtrOpt<Grid<Real>>("phiIn", 4, NULL, &_lock);
+      const MACGrid *fractions = _args.getPtrOpt<MACGrid>("fractions", 2, nullptr, &_lock);
+      const Grid<Real> *phiOut = _args.getPtrOpt<Grid<Real>>("phiOut", 3, nullptr, &_lock);
+      const Grid<Real> *phiIn = _args.getPtrOpt<Grid<Real>>("phiIn", 4, nullptr, &_lock);
       int boundaryWidth = _args.getOpt<int>("boundaryWidth", 5, 1, &_lock);
       _retval = getPyNone();
       setObstacleFlags(flags, phiObs, fractions, phiOut, phiIn, boundaryWidth);
@@ -2166,7 +2166,7 @@ static PyObject *_W_21(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "initVortexVelocity", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const Grid<Real> &phiObs = *_args.getPtr<Grid<Real>>("phiObs", 0, &_lock);
@@ -2203,10 +2203,10 @@ struct GaussianKernelCreator {
   int mDim;
   float *mMat1D;
 
-  GaussianKernelCreator() : mSigma(0.0f), mDim(0), mMat1D(NULL)
+  GaussianKernelCreator() : mSigma(0.0f), mDim(0), mMat1D(nullptr)
   {
   }
-  GaussianKernelCreator(float sigma, int dim = 0) : mSigma(0.0f), mDim(0), mMat1D(NULL)
+  GaussianKernelCreator(float sigma, int dim = 0) : mSigma(0.0f), mDim(0), mMat1D(nullptr)
   {
     setGaussianSigma(sigma, dim);
   }
@@ -2518,7 +2518,7 @@ static PyObject *_W_22(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "blurMacGrid", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       MACGrid &oG = *_args.getPtr<MACGrid>("oG", 0, &_lock);
@@ -2554,7 +2554,7 @@ static PyObject *_W_23(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "blurRealGrid", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Grid<Real> &oG = *_args.getPtr<Grid<Real>>("oG", 0, &_lock);

extern/mantaflow/preprocessed/plugin/kepsilon.cpp

@@ -305,7 +305,7 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "KEpsilonComputeProduction", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const MACGrid &vel = *_args.getPtr<MACGrid>("vel", 0, &_lock);
@@ -420,7 +420,7 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "KEpsilonSources", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Grid<Real> &k = *_args.getPtr<Grid<Real>>("k", 0, &_lock);
@@ -469,7 +469,7 @@ static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "KEpsilonBcs", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
@@ -547,7 +547,7 @@ static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "KEpsilonGradientDiffusion", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Grid<Real> &k = *_args.getPtr<Grid<Real>>("k", 0, &_lock);

extern/mantaflow/preprocessed/plugin/meshplugins.cpp

@@ -118,7 +118,7 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "smoothMesh", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Mesh &mesh = *_args.getPtr<Mesh>("mesh", 0, &_lock);
@@ -657,7 +657,7 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "subdivideMesh", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Mesh &mesh = *_args.getPtr<Mesh>("mesh", 0, &_lock);
@@ -752,7 +752,7 @@ static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "killSmallComponents", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Mesh &mesh = *_args.getPtr<Mesh>("mesh", 0, &_lock);

extern/mantaflow/preprocessed/plugin/pressure.cpp

@@ -912,7 +912,7 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "releaseMG", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       FluidSolver *solver = _args.getPtrOpt<FluidSolver>("solver", 0, nullptr, &_lock);
@@ -949,10 +949,10 @@ void computePressureRhs(Grid<Real> &rhs,
                         const Grid<Real> &pressure,
                         const FlagGrid &flags,
                         Real cgAccuracy = 1e-3,
-                        const Grid<Real> *phi = 0,
-                        const Grid<Real> *perCellCorr = 0,
-                        const MACGrid *fractions = 0,
-                        const MACGrid *obvel = 0,
+                        const Grid<Real> *phi = nullptr,
+                        const Grid<Real> *perCellCorr = nullptr,
+                        const MACGrid *fractions = nullptr,
+                        const MACGrid *obvel = nullptr,
                         Real gfClamp = 1e-04,
                         Real cgMaxIterFac = 1.5,
                         bool precondition = true,
@@ -960,7 +960,7 @@ void computePressureRhs(Grid<Real> &rhs,
                         bool enforceCompatibility = false,
                         bool useL2Norm = false,
                         bool zeroPressureFixing = false,
-                        const Grid<Real> *curv = NULL,
+                        const Grid<Real> *curv = nullptr,
                         const Real surfTens = 0.)
 {
   // compute divergence and init right hand side
@@ -977,7 +977,7 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "computePressureRhs", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Grid<Real> &rhs = *_args.getPtr<Grid<Real>>("rhs", 0, &_lock);
@@ -985,10 +985,11 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
       const Grid<Real> &pressure = *_args.getPtr<Grid<Real>>("pressure", 2, &_lock);
       const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 3, &_lock);
       Real cgAccuracy = _args.getOpt<Real>("cgAccuracy", 4, 1e-3, &_lock);
-      const Grid<Real> *phi = _args.getPtrOpt<Grid<Real>>("phi", 5, 0, &_lock);
-      const Grid<Real> *perCellCorr = _args.getPtrOpt<Grid<Real>>("perCellCorr", 6, 0, &_lock);
-      const MACGrid *fractions = _args.getPtrOpt<MACGrid>("fractions", 7, 0, &_lock);
-      const MACGrid *obvel = _args.getPtrOpt<MACGrid>("obvel", 8, 0, &_lock);
+      const Grid<Real> *phi = _args.getPtrOpt<Grid<Real>>("phi", 5, nullptr, &_lock);
+      const Grid<Real> *perCellCorr = _args.getPtrOpt<Grid<Real>>(
+          "perCellCorr", 6, nullptr, &_lock);
+      const MACGrid *fractions = _args.getPtrOpt<MACGrid>("fractions", 7, nullptr, &_lock);
+      const MACGrid *obvel = _args.getPtrOpt<MACGrid>("obvel", 8, nullptr, &_lock);
       Real gfClamp = _args.getOpt<Real>("gfClamp", 9, 1e-04, &_lock);
       Real cgMaxIterFac = _args.getOpt<Real>("cgMaxIterFac", 10, 1.5, &_lock);
       bool precondition = _args.getOpt<bool>("precondition", 11, true, &_lock);
@@ -996,7 +997,7 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
       bool enforceCompatibility = _args.getOpt<bool>("enforceCompatibility", 13, false, &_lock);
       bool useL2Norm = _args.getOpt<bool>("useL2Norm", 14, false, &_lock);
       bool zeroPressureFixing = _args.getOpt<bool>("zeroPressureFixing", 15, false, &_lock);
-      const Grid<Real> *curv = _args.getPtrOpt<Grid<Real>>("curv", 16, NULL, &_lock);
+      const Grid<Real> *curv = _args.getPtrOpt<Grid<Real>>("curv", 16, nullptr, &_lock);
       const Real surfTens = _args.getOpt<Real>("surfTens", 17, 0., &_lock);
       _retval = getPyNone();
       computePressureRhs(rhs,
@@ -1050,9 +1051,9 @@ void solvePressureSystem(Grid<Real> &rhs,
                          Grid<Real> &pressure,
                          const FlagGrid &flags,
                          Real cgAccuracy = 1e-3,
-                         const Grid<Real> *phi = 0,
-                         const Grid<Real> *perCellCorr = 0,
-                         const MACGrid *fractions = 0,
+                         const Grid<Real> *phi = nullptr,
+                         const Grid<Real> *perCellCorr = nullptr,
+                         const MACGrid *fractions = nullptr,
                          Real gfClamp = 1e-04,
                          Real cgMaxIterFac = 1.5,
                          bool precondition = true,
@@ -1060,7 +1061,7 @@ void solvePressureSystem(Grid<Real> &rhs,
                          const bool enforceCompatibility = false,
                          const bool useL2Norm = false,
                          const bool zeroPressureFixing = false,
-                         const Grid<Real> *curv = NULL,
+                         const Grid<Real> *curv = nullptr,
                          const Real surfTens = 0.)
 {
   if (precondition == false)
@@ -1221,7 +1222,7 @@ static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "solvePressureSystem", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Grid<Real> &rhs = *_args.getPtr<Grid<Real>>("rhs", 0, &_lock);
@@ -1229,9 +1230,10 @@ static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
       Grid<Real> &pressure = *_args.getPtr<Grid<Real>>("pressure", 2, &_lock);
       const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 3, &_lock);
       Real cgAccuracy = _args.getOpt<Real>("cgAccuracy", 4, 1e-3, &_lock);
-      const Grid<Real> *phi = _args.getPtrOpt<Grid<Real>>("phi", 5, 0, &_lock);
-      const Grid<Real> *perCellCorr = _args.getPtrOpt<Grid<Real>>("perCellCorr", 6, 0, &_lock);
-      const MACGrid *fractions = _args.getPtrOpt<MACGrid>("fractions", 7, 0, &_lock);
+      const Grid<Real> *phi = _args.getPtrOpt<Grid<Real>>("phi", 5, nullptr, &_lock);
+      const Grid<Real> *perCellCorr = _args.getPtrOpt<Grid<Real>>(
+          "perCellCorr", 6, nullptr, &_lock);
+      const MACGrid *fractions = _args.getPtrOpt<MACGrid>("fractions", 7, nullptr, &_lock);
       Real gfClamp = _args.getOpt<Real>("gfClamp", 8, 1e-04, &_lock);
       Real cgMaxIterFac = _args.getOpt<Real>("cgMaxIterFac", 9, 1.5, &_lock);
       bool precondition = _args.getOpt<bool>("precondition", 10, true, &_lock);
@@ -1240,7 +1242,7 @@ static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
           "enforceCompatibility", 12, false, &_lock);
       const bool useL2Norm = _args.getOpt<bool>("useL2Norm", 13, false, &_lock);
       const bool zeroPressureFixing = _args.getOpt<bool>("zeroPressureFixing", 14, false, &_lock);
-      const Grid<Real> *curv = _args.getPtrOpt<Grid<Real>>("curv", 15, NULL, &_lock);
+      const Grid<Real> *curv = _args.getPtrOpt<Grid<Real>>("curv", 15, nullptr, &_lock);
       const Real surfTens = _args.getOpt<Real>("surfTens", 16, 0., &_lock);
       _retval = getPyNone();
       solvePressureSystem(rhs,
@@ -1284,9 +1286,9 @@ void correctVelocity(MACGrid &vel,
                      Grid<Real> &pressure,
                      const FlagGrid &flags,
                      Real cgAccuracy = 1e-3,
-                     const Grid<Real> *phi = 0,
-                     const Grid<Real> *perCellCorr = 0,
-                     const MACGrid *fractions = 0,
+                     const Grid<Real> *phi = nullptr,
+                     const Grid<Real> *perCellCorr = nullptr,
+                     const MACGrid *fractions = nullptr,
                      Real gfClamp = 1e-04,
                      Real cgMaxIterFac = 1.5,
                      bool precondition = true,
@@ -1294,7 +1296,7 @@ void correctVelocity(MACGrid &vel,
                      bool enforceCompatibility = false,
                      bool useL2Norm = false,
                      bool zeroPressureFixing = false,
-                     const Grid<Real> *curv = NULL,
+                     const Grid<Real> *curv = nullptr,
                      const Real surfTens = 0.)
 {
   knCorrectVelocity(flags, vel, pressure);
@@ -1311,16 +1313,17 @@ static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "correctVelocity", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       MACGrid &vel = *_args.getPtr<MACGrid>("vel", 0, &_lock);
       Grid<Real> &pressure = *_args.getPtr<Grid<Real>>("pressure", 1, &_lock);
       const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 2, &_lock);
       Real cgAccuracy = _args.getOpt<Real>("cgAccuracy", 3, 1e-3, &_lock);
-      const Grid<Real> *phi = _args.getPtrOpt<Grid<Real>>("phi", 4, 0, &_lock);
-      const Grid<Real> *perCellCorr = _args.getPtrOpt<Grid<Real>>("perCellCorr", 5, 0, &_lock);
-      const MACGrid *fractions = _args.getPtrOpt<MACGrid>("fractions", 6, 0, &_lock);
+      const Grid<Real> *phi = _args.getPtrOpt<Grid<Real>>("phi", 4, nullptr, &_lock);
+      const Grid<Real> *perCellCorr = _args.getPtrOpt<Grid<Real>>(
+          "perCellCorr", 5, nullptr, &_lock);
+      const MACGrid *fractions = _args.getPtrOpt<MACGrid>("fractions", 6, nullptr, &_lock);
       Real gfClamp = _args.getOpt<Real>("gfClamp", 7, 1e-04, &_lock);
       Real cgMaxIterFac = _args.getOpt<Real>("cgMaxIterFac", 8, 1.5, &_lock);
       bool precondition = _args.getOpt<bool>("precondition", 9, true, &_lock);
@@ -1328,7 +1331,7 @@ static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
       bool enforceCompatibility = _args.getOpt<bool>("enforceCompatibility", 11, false, &_lock);
       bool useL2Norm = _args.getOpt<bool>("useL2Norm", 12, false, &_lock);
       bool zeroPressureFixing = _args.getOpt<bool>("zeroPressureFixing", 13, false, &_lock);
-      const Grid<Real> *curv = _args.getPtrOpt<Grid<Real>>("curv", 14, NULL, &_lock);
+      const Grid<Real> *curv = _args.getPtrOpt<Grid<Real>>("curv", 14, nullptr, &_lock);
       const Real surfTens = _args.getOpt<Real>("surfTens", 15, 0., &_lock);
       _retval = getPyNone();
       correctVelocity(vel,
@@ -1372,10 +1375,10 @@ void solvePressure(MACGrid &vel,
                    Grid<Real> &pressure,
                    const FlagGrid &flags,
                    Real cgAccuracy = 1e-3,
-                   const Grid<Real> *phi = 0,
-                   const Grid<Real> *perCellCorr = 0,
-                   const MACGrid *fractions = 0,
-                   const MACGrid *obvel = 0,
+                   const Grid<Real> *phi = nullptr,
+                   const Grid<Real> *perCellCorr = nullptr,
+                   const MACGrid *fractions = nullptr,
+                   const MACGrid *obvel = nullptr,
                    Real gfClamp = 1e-04,
                    Real cgMaxIterFac = 1.5,
                    bool precondition = true,
@@ -1383,9 +1386,9 @@ void solvePressure(MACGrid &vel,
                    bool enforceCompatibility = false,
                    bool useL2Norm = false,
                    bool zeroPressureFixing = false,
-                   const Grid<Real> *curv = NULL,
+                   const Grid<Real> *curv = nullptr,
                    const Real surfTens = 0.,
-                   Grid<Real> *retRhs = NULL)
+                   Grid<Real> *retRhs = nullptr)
 {
   Grid<Real> rhs(vel.getParent());
 
@@ -1455,17 +1458,18 @@ static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "solvePressure", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       MACGrid &vel = *_args.getPtr<MACGrid>("vel", 0, &_lock);
       Grid<Real> &pressure = *_args.getPtr<Grid<Real>>("pressure", 1, &_lock);
       const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 2, &_lock);
       Real cgAccuracy = _args.getOpt<Real>("cgAccuracy", 3, 1e-3, &_lock);
-      const Grid<Real> *phi = _args.getPtrOpt<Grid<Real>>("phi", 4, 0, &_lock);
-      const Grid<Real> *perCellCorr = _args.getPtrOpt<Grid<Real>>("perCellCorr", 5, 0, &_lock);
-      const MACGrid *fractions = _args.getPtrOpt<MACGrid>("fractions", 6, 0, &_lock);
-      const MACGrid *obvel = _args.getPtrOpt<MACGrid>("obvel", 7, 0, &_lock);
+      const Grid<Real> *phi = _args.getPtrOpt<Grid<Real>>("phi", 4, nullptr, &_lock);
+      const Grid<Real> *perCellCorr = _args.getPtrOpt<Grid<Real>>(
+          "perCellCorr", 5, nullptr, &_lock);
+      const MACGrid *fractions = _args.getPtrOpt<MACGrid>("fractions", 6, nullptr, &_lock);
+      const MACGrid *obvel = _args.getPtrOpt<MACGrid>("obvel", 7, nullptr, &_lock);
       Real gfClamp = _args.getOpt<Real>("gfClamp", 8, 1e-04, &_lock);
       Real cgMaxIterFac = _args.getOpt<Real>("cgMaxIterFac", 9, 1.5, &_lock);
       bool precondition = _args.getOpt<bool>("precondition", 10, true, &_lock);
@@ -1473,9 +1477,9 @@ static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
       bool enforceCompatibility = _args.getOpt<bool>("enforceCompatibility", 12, false, &_lock);
       bool useL2Norm = _args.getOpt<bool>("useL2Norm", 13, false, &_lock);
       bool zeroPressureFixing = _args.getOpt<bool>("zeroPressureFixing", 14, false, &_lock);
-      const Grid<Real> *curv = _args.getPtrOpt<Grid<Real>>("curv", 15, NULL, &_lock);
+      const Grid<Real> *curv = _args.getPtrOpt<Grid<Real>>("curv", 15, nullptr, &_lock);
       const Real surfTens = _args.getOpt<Real>("surfTens", 16, 0., &_lock);
-      Grid<Real> *retRhs = _args.getPtrOpt<Grid<Real>>("retRhs", 17, NULL, &_lock);
+      Grid<Real> *retRhs = _args.getPtrOpt<Grid<Real>>("retRhs", 17, nullptr, &_lock);
       _retval = getPyNone();
       solvePressure(vel,
                     pressure,

extern/mantaflow/preprocessed/plugin/ptsplugins.cpp

@@ -98,7 +98,7 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "addForcePvel", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       ParticleDataImpl<Vec3> &vel = *_args.getPtr<ParticleDataImpl<Vec3>>("vel", 0, &_lock);
@@ -227,7 +227,7 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "updateVelocityFromDeltaPos", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock);
@@ -342,7 +342,7 @@ static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "eulerStep", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock);
@@ -470,7 +470,7 @@ static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "setPartType", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock);

extern/mantaflow/preprocessed/plugin/secondaryparticles.cpp

@@ -392,7 +392,7 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "flipComputeSecondaryParticlePotentials", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Grid<Real> &potTA = *_args.getPtr<Grid<Real>>("potTA", 0, &_lock);
@@ -1041,7 +1041,7 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "flipSampleSecondaryParticles", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const std::string mode = _args.get<std::string>("mode", 0, &_lock);
@@ -1760,7 +1760,7 @@ static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "flipUpdateSecondaryParticles", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const std::string mode = _args.get<std::string>("mode", 0, &_lock);
@@ -1895,7 +1895,7 @@ static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "flipDeleteParticlesInObstacle", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       BasicParticleSystem &pts = *_args.getPtr<BasicParticleSystem>("pts", 0, &_lock);
@@ -1963,7 +1963,7 @@ static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "debugGridInfo", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
@@ -2069,7 +2069,7 @@ static PyObject *_W_5(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "setFlagsFromLevelset", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
@@ -2170,7 +2170,7 @@ static PyObject *_W_6(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "setMACFromLevelset", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       MACGrid &v = *_args.getPtr<MACGrid>("v", 0, &_lock);
@@ -2382,7 +2382,7 @@ static PyObject *_W_7(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "flipComputePotentialTrappedAir", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Grid<Real> &pot = *_args.getPtr<Grid<Real>>("pot", 0, &_lock);
@@ -2555,7 +2555,7 @@ static PyObject *_W_8(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "flipComputePotentialKineticEnergy", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Grid<Real> &pot = *_args.getPtr<Grid<Real>>("pot", 0, &_lock);
@@ -2791,7 +2791,7 @@ static PyObject *_W_9(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "flipComputePotentialWaveCrest", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Grid<Real> &pot = *_args.getPtr<Grid<Real>>("pot", 0, &_lock);
@@ -2883,7 +2883,7 @@ static PyObject *_W_10(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "flipComputeSurfaceNormals", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Grid<Vec3> &normal = *_args.getPtr<Grid<Vec3>>("normal", 0, &_lock);
@@ -3040,7 +3040,7 @@ static PyObject *_W_11(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "flipUpdateNeighborRatio", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);

extern/mantaflow/preprocessed/plugin/surfaceturbulence.cpp

@@ -2055,7 +2055,7 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "particleSurfaceTurbulence", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
@@ -2159,7 +2159,7 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "debugCheckParts", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock);

extern/mantaflow/preprocessed/plugin/vortexplugins.cpp

@@ -48,7 +48,7 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "markAsFixed", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Mesh &mesh = *_args.getPtr<Mesh>("mesh", 0, &_lock);
@@ -111,7 +111,7 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "texcoordInflow", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       VortexSheetMesh &mesh = *_args.getPtr<VortexSheetMesh>("mesh", 0, &_lock);
@@ -155,7 +155,7 @@ static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "meshSmokeInflow", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       VortexSheetMesh &mesh = *_args.getPtr<VortexSheetMesh>("mesh", 0, &_lock);
@@ -239,8 +239,8 @@ struct KnAcceleration : public KernelBase {
 
 void vorticitySource(VortexSheetMesh &mesh,
                      Vec3 gravity,
-                     const MACGrid *vel = NULL,
-                     const MACGrid *velOld = NULL,
+                     const MACGrid *vel = nullptr,
+                     const MACGrid *velOld = nullptr,
                      Real scale = 0.1,
                      Real maxAmount = 0,
                      Real mult = 1.0)
@@ -289,13 +289,13 @@ static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "vorticitySource", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       VortexSheetMesh &mesh = *_args.getPtr<VortexSheetMesh>("mesh", 0, &_lock);
       Vec3 gravity = _args.get<Vec3>("gravity", 1, &_lock);
-      const MACGrid *vel = _args.getPtrOpt<MACGrid>("vel", 2, NULL, &_lock);
-      const MACGrid *velOld = _args.getPtrOpt<MACGrid>("velOld", 3, NULL, &_lock);
+      const MACGrid *vel = _args.getPtrOpt<MACGrid>("vel", 2, nullptr, &_lock);
+      const MACGrid *velOld = _args.getPtrOpt<MACGrid>("velOld", 3, nullptr, &_lock);
       Real scale = _args.getOpt<Real>("scale", 4, 0.1, &_lock);
       Real maxAmount = _args.getOpt<Real>("maxAmount", 5, 0, &_lock);
       Real mult = _args.getOpt<Real>("mult", 6, 1.0, &_lock);
@@ -373,7 +373,7 @@ static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "smoothVorticity", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       VortexSheetMesh &mesh = *_args.getPtr<VortexSheetMesh>("mesh", 0, &_lock);
@@ -437,7 +437,7 @@ static PyObject *_W_5(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "VPseedK41", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       VortexParticleSystem &system = *_args.getPtr<VortexParticleSystem>("system", 0, &_lock);
@@ -473,7 +473,7 @@ void VICintegration(VortexSheetMesh &mesh,
                     Real sigma,
                     Grid<Vec3> &vel,
                     const FlagGrid &flags,
-                    Grid<Vec3> *vorticity = NULL,
+                    Grid<Vec3> *vorticity = nullptr,
                     Real cgMaxIterFac = 1.5,
                     Real cgAccuracy = 1e-3,
                     Real scale = 0.01,
@@ -604,14 +604,14 @@ static PyObject *_W_6(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "VICintegration", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       VortexSheetMesh &mesh = *_args.getPtr<VortexSheetMesh>("mesh", 0, &_lock);
       Real sigma = _args.get<Real>("sigma", 1, &_lock);
       Grid<Vec3> &vel = *_args.getPtr<Grid<Vec3>>("vel", 2, &_lock);
       const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 3, &_lock);
-      Grid<Vec3> *vorticity = _args.getPtrOpt<Grid<Vec3>>("vorticity", 4, NULL, &_lock);
+      Grid<Vec3> *vorticity = _args.getPtrOpt<Grid<Vec3>>("vorticity", 4, nullptr, &_lock);
       Real cgMaxIterFac = _args.getOpt<Real>("cgMaxIterFac", 5, 1.5, &_lock);
       Real cgAccuracy = _args.getOpt<Real>("cgAccuracy", 6, 1e-3, &_lock);
       Real scale = _args.getOpt<Real>("scale", 7, 0.01, &_lock);
@@ -665,7 +665,7 @@ static PyObject *_W_7(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "densityFromLevelset", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const LevelsetGrid &phi = *_args.getPtr<LevelsetGrid>("phi", 0, &_lock);

extern/mantaflow/preprocessed/plugin/waveletturbulence.cpp

@@ -69,7 +69,7 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "interpolateGrid", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Grid<Real> &target = *_args.getPtr<Grid<Real>>("target", 0, &_lock);
@@ -116,7 +116,7 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "interpolateGridVec3", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Grid<Vec3> &target = *_args.getPtr<Grid<Vec3>>("target", 0, &_lock);
@@ -263,7 +263,7 @@ static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "interpolateMACGrid", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       MACGrid &target = *_args.getPtr<MACGrid>("target", 0, &_lock);
@@ -395,7 +395,7 @@ void applySimpleNoiseVec3(const FlagGrid &flags,
                           Grid<Vec3> &target,
                           const WaveletNoiseField &noise,
                           Real scale = 1.0,
-                          const Grid<Real> *weight = NULL)
+                          const Grid<Real> *weight = nullptr)
 {
   // note - passing a MAC grid here is slightly inaccurate, we should evaluate each component
   // separately
@@ -408,14 +408,14 @@ static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "applySimpleNoiseVec3", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
       Grid<Vec3> &target = *_args.getPtr<Grid<Vec3>>("target", 1, &_lock);
       const WaveletNoiseField &noise = *_args.getPtr<WaveletNoiseField>("noise", 2, &_lock);
       Real scale = _args.getOpt<Real>("scale", 3, 1.0, &_lock);
-      const Grid<Real> *weight = _args.getPtrOpt<Grid<Real>>("weight", 4, NULL, &_lock);
+      const Grid<Real> *weight = _args.getPtrOpt<Grid<Real>>("weight", 4, nullptr, &_lock);
       _retval = getPyNone();
       applySimpleNoiseVec3(flags, target, noise, scale, weight);
       _args.check();
@@ -537,7 +537,7 @@ void applySimpleNoiseReal(const FlagGrid &flags,
                           Grid<Real> &target,
                           const WaveletNoiseField &noise,
                           Real scale = 1.0,
-                          const Grid<Real> *weight = NULL)
+                          const Grid<Real> *weight = nullptr)
 {
   knApplySimpleNoiseReal(flags, target, noise, scale, weight);
 }
@@ -548,14 +548,14 @@ static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "applySimpleNoiseReal", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
       Grid<Real> &target = *_args.getPtr<Grid<Real>>("target", 1, &_lock);
       const WaveletNoiseField &noise = *_args.getPtr<WaveletNoiseField>("noise", 2, &_lock);
       Real scale = _args.getOpt<Real>("scale", 3, 1.0, &_lock);
-      const Grid<Real> *weight = _args.getPtrOpt<Grid<Real>>("weight", 4, NULL, &_lock);
+      const Grid<Real> *weight = _args.getPtrOpt<Grid<Real>>("weight", 4, nullptr, &_lock);
       _retval = getPyNone();
       applySimpleNoiseReal(flags, target, noise, scale, weight);
       _args.check();
@@ -763,8 +763,8 @@ void applyNoiseVec3(const FlagGrid &flags,
                     const WaveletNoiseField &noise,
                     Real scale = 1.0,
                     Real scaleSpatial = 1.0,
-                    const Grid<Real> *weight = NULL,
-                    const Grid<Vec3> *uv = NULL)
+                    const Grid<Real> *weight = nullptr,
+                    const Grid<Vec3> *uv = nullptr)
 {
   // check whether the uv grid has a different resolution
   bool uvInterpol = false;
@@ -794,7 +794,7 @@ static PyObject *_W_5(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "applyNoiseVec3", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
@@ -802,8 +802,8 @@ static PyObject *_W_5(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
       const WaveletNoiseField &noise = *_args.getPtr<WaveletNoiseField>("noise", 2, &_lock);
       Real scale = _args.getOpt<Real>("scale", 3, 1.0, &_lock);
       Real scaleSpatial = _args.getOpt<Real>("scaleSpatial", 4, 1.0, &_lock);
-      const Grid<Real> *weight = _args.getPtrOpt<Grid<Real>>("weight", 5, NULL, &_lock);
-      const Grid<Vec3> *uv = _args.getPtrOpt<Grid<Vec3>>("uv", 6, NULL, &_lock);
+      const Grid<Real> *weight = _args.getPtrOpt<Grid<Real>>("weight", 5, nullptr, &_lock);
+      const Grid<Vec3> *uv = _args.getPtrOpt<Grid<Vec3>>("uv", 6, nullptr, &_lock);
       _retval = getPyNone();
       applyNoiseVec3(flags, target, noise, scale, scaleSpatial, weight, uv);
       _args.check();
@@ -905,7 +905,7 @@ static PyObject *_W_6(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "computeEnergy", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
@@ -943,7 +943,7 @@ static PyObject *_W_7(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "computeWaveletCoeffs", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Grid<Real> &input = *_args.getPtr<Grid<Real>>("input", 0, &_lock);
@@ -968,7 +968,7 @@ void PbRegister_computeWaveletCoeffs()
 }
 
 // note - alomst the same as for vorticity confinement
-void computeVorticity(const MACGrid &vel, Grid<Vec3> &vorticity, Grid<Real> *norm = NULL)
+void computeVorticity(const MACGrid &vel, Grid<Vec3> &vorticity, Grid<Real> *norm = nullptr)
 {
   Grid<Vec3> velCenter(vel.getParent());
   GetCentered(velCenter, vel);
@@ -983,12 +983,12 @@ static PyObject *_W_8(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "computeVorticity", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const MACGrid &vel = *_args.getPtr<MACGrid>("vel", 0, &_lock);
       Grid<Vec3> &vorticity = *_args.getPtr<Grid<Vec3>>("vorticity", 1, &_lock);
-      Grid<Real> *norm = _args.getPtrOpt<Grid<Real>>("norm", 2, NULL, &_lock);
+      Grid<Real> *norm = _args.getPtrOpt<Grid<Real>>("norm", 2, nullptr, &_lock);
       _retval = getPyNone();
       computeVorticity(vel, vorticity, norm);
       _args.check();
@@ -1104,7 +1104,7 @@ static PyObject *_W_9(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "computeStrainRateMag", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const MACGrid &vel = *_args.getPtr<MACGrid>("vel", 0, &_lock);
@@ -1219,7 +1219,7 @@ static PyObject *_W_10(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "extrapolateSimpleFlags", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
@@ -1263,7 +1263,7 @@ static PyObject *_W_11(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "getCurl", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const MACGrid &vel = *_args.getPtr<MACGrid>("vel", 0, &_lock);

extern/mantaflow/preprocessed/plugin/waves.cpp

@@ -101,7 +101,7 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "calcSecDeriv2d", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const Grid<Real> &v = *_args.getPtr<Grid<Real>>("v", 0, &_lock);
@@ -206,7 +206,7 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "totalSum", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Grid<Real> &height = *_args.getPtr<Grid<Real>>("height", 0, &_lock);
@@ -243,7 +243,7 @@ static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "normalizeSumTo", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       Grid<Real> &height = *_args.getPtr<Grid<Real>>("height", 0, &_lock);
@@ -449,7 +449,7 @@ static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
     FluidSolver *parent = _args.obtainParent();
     bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
     pbPreparePlugin(parent, "cgSolveWE", !noTiming);
-    PyObject *_retval = 0;
+    PyObject *_retval = nullptr;
     {
       ArgLocker _lock;
       const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);

extern/mantaflow/preprocessed/shapes.h

@@ -74,7 +74,7 @@ class Shape : public PbClass {
       Shape *pbo = dynamic_cast<Shape *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Shape::applyToGrid", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         GridBase *grid = _args.getPtr<GridBase>("grid", 0, &_lock);
@@ -104,7 +104,7 @@ class Shape : public PbClass {
       Shape *pbo = dynamic_cast<Shape *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Shape::applyToGridSmooth", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         GridBase *grid = _args.getPtr<GridBase>("grid", 0, &_lock);
@@ -133,7 +133,7 @@ class Shape : public PbClass {
       Shape *pbo = dynamic_cast<Shape *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Shape::computeLevelset", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -157,7 +157,7 @@ class Shape : public PbClass {
       Shape *pbo = dynamic_cast<Shape *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Shape::collideMesh", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         Mesh &mesh = *_args.getPtr<Mesh>("mesh", 0, &_lock);
@@ -186,7 +186,7 @@ class Shape : public PbClass {
       Shape *pbo = dynamic_cast<Shape *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Shape::getCenter", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -212,7 +212,7 @@ class Shape : public PbClass {
       Shape *pbo = dynamic_cast<Shape *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Shape::setCenter", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         const Vec3 &center = _args.get<Vec3>("center", 0, &_lock);
@@ -241,7 +241,7 @@ class Shape : public PbClass {
       Shape *pbo = dynamic_cast<Shape *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Shape::getExtent", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -504,7 +504,7 @@ class Cylinder : public Shape {
       Cylinder *pbo = dynamic_cast<Cylinder *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Cylinder::setRadius", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         Real r = _args.get<Real>("r", 0, &_lock);
@@ -534,7 +534,7 @@ class Cylinder : public Shape {
       Cylinder *pbo = dynamic_cast<Cylinder *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Cylinder::setZ", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         Vec3 z = _args.get<Vec3>("z", 0, &_lock);

extern/mantaflow/preprocessed/timing.h

@@ -101,7 +101,7 @@ class Timings : public PbClass {
       Timings *pbo = dynamic_cast<Timings *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Timings::display", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -128,7 +128,7 @@ class Timings : public PbClass {
       Timings *pbo = dynamic_cast<Timings *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "Timings::saveMean", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         std::string file = _args.get<std::string>("file", 0, &_lock);

extern/mantaflow/preprocessed/turbulencepart.h

@@ -82,7 +82,7 @@ class TurbulenceParticleSystem : public ParticleSystem<TurbulenceParticleData> {
           Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "TurbulenceParticleSystem::resetTexCoords", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         int num = _args.get<int>("num", 0, &_lock);
@@ -110,7 +110,7 @@ class TurbulenceParticleSystem : public ParticleSystem<TurbulenceParticleData> {
           Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "TurbulenceParticleSystem::seed", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         Shape *source = _args.getPtr<Shape>("source", 0, &_lock);
@@ -144,7 +144,7 @@ class TurbulenceParticleSystem : public ParticleSystem<TurbulenceParticleData> {
           Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "TurbulenceParticleSystem::synthesize", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
@@ -177,7 +177,7 @@ class TurbulenceParticleSystem : public ParticleSystem<TurbulenceParticleData> {
           Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "TurbulenceParticleSystem::deleteInObstacle", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);

extern/mantaflow/preprocessed/vortexpart.h

@@ -79,7 +79,7 @@ class VortexParticleSystem : public ParticleSystem<VortexParticleData> {
       VortexParticleSystem *pbo = dynamic_cast<VortexParticleSystem *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "VortexParticleSystem::advectSelf", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         Real scale = _args.getOpt<Real>("scale", 0, 1.0, &_lock);
@@ -106,7 +106,7 @@ class VortexParticleSystem : public ParticleSystem<VortexParticleData> {
       VortexParticleSystem *pbo = dynamic_cast<VortexParticleSystem *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "VortexParticleSystem::applyToMesh", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         Mesh &mesh = *_args.getPtr<Mesh>("mesh", 0, &_lock);

extern/mantaflow/preprocessed/vortexsheet.h

@@ -168,7 +168,7 @@ class VortexSheetMesh : public Mesh {
       VortexSheetMesh *pbo = dynamic_cast<VortexSheetMesh *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "VortexSheetMesh::calcCirculation", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -193,7 +193,7 @@ class VortexSheetMesh : public Mesh {
       VortexSheetMesh *pbo = dynamic_cast<VortexSheetMesh *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "VortexSheetMesh::calcVorticity", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);
@@ -218,7 +218,7 @@ class VortexSheetMesh : public Mesh {
       VortexSheetMesh *pbo = dynamic_cast<VortexSheetMesh *>(Pb::objFromPy(_self));
       bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
       pbPreparePlugin(pbo->getParent(), "VortexSheetMesh::reinitTexCoords", !noTiming);
-      PyObject *_retval = 0;
+      PyObject *_retval = nullptr;
       {
         ArgLocker _lock;
         pbo->_args.copy(_args);

intern/cycles/CMakeLists.txt

@@ -45,7 +45,7 @@ if(WITH_CYCLES_NATIVE_ONLY)
   )
 
   if(NOT MSVC)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=native")
+    string(APPEND CMAKE_CXX_FLAGS " -march=native")
     set(CYCLES_KERNEL_FLAGS "-march=native")
   else()
     if(NOT MSVC_NATIVE_ARCH_FLAGS)
@@ -101,10 +101,10 @@ elseif(WIN32 AND MSVC AND NOT CMAKE_CXX_COMPILER_ID MATCHES "Clang")
     set(CYCLES_AVX2_KERNEL_FLAGS "${CYCLES_AVX2_ARCH_FLAGS} ${CYCLES_KERNEL_FLAGS}")
   endif()
 
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CYCLES_KERNEL_FLAGS}")
-  set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /Ox")
-  set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} /Ox")
-  set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} /Ox")
+  string(APPEND CMAKE_CXX_FLAGS " ${CYCLES_KERNEL_FLAGS}")
+  string(APPEND CMAKE_CXX_FLAGS_RELEASE " /Ox")
+  string(APPEND CMAKE_CXX_FLAGS_RELWITHDEBINFO " /Ox")
+  string(APPEND CMAKE_CXX_FLAGS_MINSIZEREL " /Ox")
 elseif(CMAKE_COMPILER_IS_GNUCC OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
   check_cxx_compiler_flag(-msse CXX_HAS_SSE)
   check_cxx_compiler_flag(-mavx CXX_HAS_AVX)
@@ -113,20 +113,20 @@ elseif(CMAKE_COMPILER_IS_GNUCC OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
   # Assume no signal trapping for better code generation.
   set(CYCLES_KERNEL_FLAGS "-fno-trapping-math")
   # Avoid overhead of setting errno for NaNs.
-  set(CYCLES_KERNEL_FLAGS "${CYCLES_KERNEL_FLAGS} -fno-math-errno")
+  string(APPEND CYCLES_KERNEL_FLAGS " -fno-math-errno")
   # Let compiler optimize 0.0 - x without worrying about signed zeros.
-  set(CYCLES_KERNEL_FLAGS "${CYCLES_KERNEL_FLAGS} -fno-signed-zeros")
+  string(APPEND CYCLES_KERNEL_FLAGS " -fno-signed-zeros")
 
   if(CMAKE_COMPILER_IS_GNUCC)
     # Assume no signal trapping for better code generation.
-    set(CYCLES_KERNEL_FLAGS "${CYCLES_KERNEL_FLAGS} -fno-signaling-nans")
+    string(APPEND CYCLES_KERNEL_FLAGS " -fno-signaling-nans")
     # Assume a fixed rounding mode for better constant folding.
-    set(CYCLES_KERNEL_FLAGS "${CYCLES_KERNEL_FLAGS} -fno-rounding-math")
+    string(APPEND CYCLES_KERNEL_FLAGS " -fno-rounding-math")
   endif()
 
   if(CXX_HAS_SSE)
     if(CMAKE_COMPILER_IS_GNUCC)
-      set(CYCLES_KERNEL_FLAGS "${CYCLES_KERNEL_FLAGS} -mfpmath=sse")
+      string(APPEND CYCLES_KERNEL_FLAGS " -mfpmath=sse")
     endif()
 
     set(CYCLES_SSE2_KERNEL_FLAGS "${CYCLES_KERNEL_FLAGS} -msse -msse2")
@@ -140,7 +140,7 @@ elseif(CMAKE_COMPILER_IS_GNUCC OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
     endif()
   endif()
 
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CYCLES_KERNEL_FLAGS}")
+  string(APPEND CMAKE_CXX_FLAGS " ${CYCLES_KERNEL_FLAGS}")
 elseif(WIN32 AND CMAKE_CXX_COMPILER_ID MATCHES "Intel")
   check_cxx_compiler_flag(/QxSSE2 CXX_HAS_SSE)
   check_cxx_compiler_flag(/arch:AVX CXX_HAS_AVX)

intern/cycles/blender/CMakeLists.txt

@@ -130,7 +130,7 @@ blender_add_lib(bf_intern_cycles "${SRC}" "${INC}" "${INC_SYS}" "${LIB}")
 
 # avoid link failure with clang 3.4 debug
 if(CMAKE_C_COMPILER_ID MATCHES "Clang" AND NOT ${CMAKE_C_COMPILER_VERSION} VERSION_LESS '3.4')
-  set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -gline-tables-only")
+  string(APPEND CMAKE_CXX_FLAGS_DEBUG " -gline-tables-only")
 endif()
 
 add_dependencies(bf_intern_cycles bf_rna)

intern/cycles/blender/blender_camera.cpp

@@ -388,18 +388,19 @@ static void blender_camera_sync(Camera *cam,
                                 const char *viewname,
                                 PointerRNA *cscene)
 {
-  /* copy camera to compare later */
-  Camera prevcam = *cam;
   float aspectratio, sensor_size;
 
   /* viewplane */
-  blender_camera_viewplane(bcam, width, height, &cam->viewplane, &aspectratio, &sensor_size);
+  BoundBox2D viewplane;
+  blender_camera_viewplane(bcam, width, height, &viewplane, &aspectratio, &sensor_size);
 
-  cam->width = bcam->full_width;
-  cam->height = bcam->full_height;
+  cam->set_viewplane_left(viewplane.left);
+  cam->set_viewplane_right(viewplane.right);
+  cam->set_viewplane_top(viewplane.top);
+  cam->set_viewplane_bottom(viewplane.bottom);
 
-  cam->full_width = width;
-  cam->full_height = height;
+  cam->set_full_width(width);
+  cam->set_full_height(height);
 
   /* panorama sensor */
   if (bcam->type == CAMERA_PANORAMA && bcam->panorama_type == PANORAMA_FISHEYE_EQUISOLID) {
@@ -422,85 +423,91 @@ static void blender_camera_sync(Camera *cam,
     }
 
     if (horizontal_fit) {
-      cam->sensorwidth = sensor_size;
-      cam->sensorheight = sensor_size * fit_yratio / fit_xratio;
+      cam->set_sensorwidth(sensor_size);
+      cam->set_sensorheight(sensor_size * fit_yratio / fit_xratio);
     }
     else {
-      cam->sensorwidth = sensor_size * fit_xratio / fit_yratio;
-      cam->sensorheight = sensor_size;
+      cam->set_sensorwidth(sensor_size * fit_xratio / fit_yratio);
+      cam->set_sensorheight(sensor_size);
     }
   }
 
   /* clipping distances */
-  cam->nearclip = bcam->nearclip;
-  cam->farclip = bcam->farclip;
+  cam->set_nearclip(bcam->nearclip);
+  cam->set_farclip(bcam->farclip);
 
   /* type */
-  cam->type = bcam->type;
+  cam->set_camera_type(bcam->type);
 
   /* panorama */
-  cam->panorama_type = bcam->panorama_type;
-  cam->fisheye_fov = bcam->fisheye_fov;
-  cam->fisheye_lens = bcam->fisheye_lens;
-  cam->latitude_min = bcam->latitude_min;
-  cam->latitude_max = bcam->latitude_max;
+  cam->set_panorama_type(bcam->panorama_type);
+  cam->set_fisheye_fov(bcam->fisheye_fov);
+  cam->set_fisheye_lens(bcam->fisheye_lens);
+  cam->set_latitude_min(bcam->latitude_min);
+  cam->set_latitude_max(bcam->latitude_max);
 
-  cam->longitude_min = bcam->longitude_min;
-  cam->longitude_max = bcam->longitude_max;
+  cam->set_longitude_min(bcam->longitude_min);
+  cam->set_longitude_max(bcam->longitude_max);
 
   /* panorama stereo */
-  cam->interocular_distance = bcam->interocular_distance;
-  cam->convergence_distance = bcam->convergence_distance;
-  cam->use_spherical_stereo = bcam->use_spherical_stereo;
+  cam->set_interocular_distance(bcam->interocular_distance);
+  cam->set_convergence_distance(bcam->convergence_distance);
+  cam->set_use_spherical_stereo(bcam->use_spherical_stereo);
 
-  if (cam->use_spherical_stereo) {
+  if (cam->get_use_spherical_stereo()) {
     if (strcmp(viewname, "left") == 0)
-      cam->stereo_eye = Camera::STEREO_LEFT;
+      cam->set_stereo_eye(Camera::STEREO_LEFT);
     else if (strcmp(viewname, "right") == 0)
-      cam->stereo_eye = Camera::STEREO_RIGHT;
+      cam->set_stereo_eye(Camera::STEREO_RIGHT);
     else
-      cam->stereo_eye = Camera::STEREO_NONE;
+      cam->set_stereo_eye(Camera::STEREO_NONE);
   }
 
-  cam->use_pole_merge = bcam->use_pole_merge;
-  cam->pole_merge_angle_from = bcam->pole_merge_angle_from;
-  cam->pole_merge_angle_to = bcam->pole_merge_angle_to;
+  cam->set_use_pole_merge(bcam->use_pole_merge);
+  cam->set_pole_merge_angle_from(bcam->pole_merge_angle_from);
+  cam->set_pole_merge_angle_to(bcam->pole_merge_angle_to);
 
   /* anamorphic lens bokeh */
-  cam->aperture_ratio = bcam->aperture_ratio;
+  cam->set_aperture_ratio(bcam->aperture_ratio);
 
   /* perspective */
-  cam->fov = 2.0f * atanf((0.5f * sensor_size) / bcam->lens / aspectratio);
-  cam->focaldistance = bcam->focaldistance;
-  cam->aperturesize = bcam->aperturesize;
-  cam->blades = bcam->apertureblades;
-  cam->bladesrotation = bcam->aperturerotation;
+  cam->set_fov(2.0f * atanf((0.5f * sensor_size) / bcam->lens / aspectratio));
+  cam->set_focaldistance(bcam->focaldistance);
+  cam->set_aperturesize(bcam->aperturesize);
+  cam->set_blades(bcam->apertureblades);
+  cam->set_bladesrotation(bcam->aperturerotation);
 
   /* transform */
-  cam->matrix = blender_camera_matrix(bcam->matrix, bcam->type, bcam->panorama_type);
-  cam->motion.clear();
-  cam->motion.resize(bcam->motion_steps, cam->matrix);
-  cam->use_perspective_motion = false;
-  cam->shuttertime = bcam->shuttertime;
-  cam->fov_pre = cam->fov;
-  cam->fov_post = cam->fov;
-  cam->motion_position = bcam->motion_position;
+  cam->set_matrix(blender_camera_matrix(bcam->matrix, bcam->type, bcam->panorama_type));
 
-  cam->rolling_shutter_type = bcam->rolling_shutter_type;
-  cam->rolling_shutter_duration = bcam->rolling_shutter_duration;
+  array<Transform> motion;
+  motion.resize(bcam->motion_steps, cam->get_matrix());
+  cam->set_motion(motion);
+  cam->set_use_perspective_motion(false);
 
-  cam->shutter_curve = bcam->shutter_curve;
+  cam->set_shuttertime(bcam->shuttertime);
+  cam->set_fov_pre(cam->get_fov());
+  cam->set_fov_post(cam->get_fov());
+  cam->set_motion_position(bcam->motion_position);
+
+  cam->set_rolling_shutter_type(bcam->rolling_shutter_type);
+  cam->set_rolling_shutter_duration(bcam->rolling_shutter_duration);
+
+  cam->set_shutter_curve(bcam->shutter_curve);
 
   /* border */
-  cam->border = bcam->border;
-  cam->viewport_camera_border = bcam->viewport_camera_border;
+  cam->set_border_left(bcam->border.left);
+  cam->set_border_right(bcam->border.right);
+  cam->set_border_top(bcam->border.top);
+  cam->set_border_bottom(bcam->border.bottom);
+
+  cam->set_viewport_camera_border_left(bcam->viewport_camera_border.left);
+  cam->set_viewport_camera_border_right(bcam->viewport_camera_border.right);
+  cam->set_viewport_camera_border_top(bcam->viewport_camera_border.top);
+  cam->set_viewport_camera_border_bottom(bcam->viewport_camera_border.bottom);
 
   bcam->offscreen_dicing_scale = RNA_float_get(cscene, "offscreen_dicing_scale");
-  cam->offscreen_dicing_scale = bcam->offscreen_dicing_scale;
-
-  /* set update flag */
-  if (cam->modified(prevcam))
-    cam->tag_update();
+  cam->set_offscreen_dicing_scale(bcam->offscreen_dicing_scale);
 }
 
 /* Sync Render Camera */
@@ -582,22 +589,24 @@ void BlenderSync::sync_camera_motion(
 
   Camera *cam = scene->camera;
   BL::Array<float, 16> b_ob_matrix;
-  b_engine.camera_model_matrix(b_ob, cam->use_spherical_stereo, b_ob_matrix);
+  b_engine.camera_model_matrix(b_ob, cam->get_use_spherical_stereo(), b_ob_matrix);
   Transform tfm = get_transform(b_ob_matrix);
-  tfm = blender_camera_matrix(tfm, cam->type, cam->panorama_type);
+  tfm = blender_camera_matrix(tfm, cam->get_camera_type(), cam->get_panorama_type());
 
   if (motion_time == 0.0f) {
     /* When motion blur is not centered in frame, cam->matrix gets reset. */
-    cam->matrix = tfm;
+    cam->set_matrix(tfm);
   }
 
   /* Set transform in motion array. */
   int motion_step = cam->motion_step(motion_time);
   if (motion_step >= 0) {
-    cam->motion[motion_step] = tfm;
+    array<Transform> motion = cam->get_motion();
+    motion[motion_step] = tfm;
+    cam->set_motion(motion);
   }
 
-  if (cam->type == CAMERA_PERSPECTIVE) {
+  if (cam->get_camera_type() == CAMERA_PERSPECTIVE) {
     BlenderCamera bcam;
     float aspectratio, sensor_size;
     blender_camera_init(&bcam, b_render);
@@ -610,18 +619,18 @@ void BlenderSync::sync_camera_motion(
     blender_camera_viewplane(&bcam, width, height, NULL, &aspectratio, &sensor_size);
     /* TODO(sergey): De-duplicate calculation with camera sync. */
     float fov = 2.0f * atanf((0.5f * sensor_size) / bcam.lens / aspectratio);
-    if (fov != cam->fov) {
+    if (fov != cam->get_fov()) {
       VLOG(1) << "Camera " << b_ob.name() << " FOV change detected.";
       if (motion_time == 0.0f) {
-        cam->fov = fov;
+        cam->set_fov(fov);
       }
       else if (motion_time == -1.0f) {
-        cam->fov_pre = fov;
-        cam->use_perspective_motion = true;
+        cam->set_fov_pre(fov);
+        cam->set_use_perspective_motion(true);
       }
       else if (motion_time == 1.0f) {
-        cam->fov_post = fov;
-        cam->use_perspective_motion = true;
+        cam->set_fov_post(fov);
+        cam->set_use_perspective_motion(true);
       }
     }
   }

intern/cycles/blender/blender_curves.cpp

@@ -77,7 +77,7 @@ static bool ObtainCacheParticleData(
 
       if ((b_part.render_type() == BL::ParticleSettings::render_type_PATH) &&
           (b_part.type() == BL::ParticleSettings::type_HAIR)) {
-        int shader = clamp(b_part.material() - 1, 0, hair->used_shaders.size() - 1);
+        int shader = clamp(b_part.material() - 1, 0, hair->get_used_shaders().size() - 1);
         int display_step = background ? b_part.render_step() : b_part.display_step();
         int totparts = b_psys.particles.length();
         int totchild = background ? b_psys.child_particles.length() :
@@ -307,7 +307,7 @@ static void ExportCurveSegments(Scene *scene, Hair *hair, ParticleCurveData *CDa
     VLOG(1) << "Exporting curve segments for mesh " << hair->name;
   }
 
-  hair->reserve_curves(hair->num_curves() + num_curves, hair->curve_keys.size() + num_keys);
+  hair->reserve_curves(hair->num_curves() + num_curves, hair->get_curve_keys().size() + num_keys);
 
   num_keys = 0;
   num_curves = 0;
@@ -350,9 +350,9 @@ static void ExportCurveSegments(Scene *scene, Hair *hair, ParticleCurveData *CDa
   }
 
   /* check allocation */
-  if ((hair->curve_keys.size() != num_keys) || (hair->num_curves() != num_curves)) {
+  if ((hair->get_curve_keys().size() != num_keys) || (hair->num_curves() != num_curves)) {
     VLOG(1) << "Allocation failed, clearing data";
-    hair->clear();
+    hair->clear(true);
   }
 }
 
@@ -402,7 +402,7 @@ static void export_hair_motion_validate_attribute(Hair *hair,
                                                   bool have_motion)
 {
   Attribute *attr_mP = hair->attributes.find(ATTR_STD_MOTION_VERTEX_POSITION);
-  const int num_keys = hair->curve_keys.size();
+  const int num_keys = hair->get_curve_keys().size();
 
   if (num_motion_keys != num_keys || !have_motion) {
     /* No motion or hair "topology" changed, remove attributes again. */
@@ -423,8 +423,8 @@ static void export_hair_motion_validate_attribute(Hair *hair,
       float4 *mP = attr_mP->data_float4() + step * num_keys;
 
       for (int key = 0; key < num_keys; key++) {
-        mP[key] = float3_to_float4(hair->curve_keys[key]);
-        mP[key].w = hair->curve_radius[key];
+        mP[key] = float3_to_float4(hair->get_curve_keys()[key]);
+        mP[key].w = hair->get_curve_radius()[key];
       }
     }
   }
@@ -447,7 +447,7 @@ static void ExportCurveSegmentsMotion(Hair *hair, ParticleCurveData *CData, int
   }
 
   /* export motion vectors for curve keys */
-  size_t numkeys = hair->curve_keys.size();
+  size_t numkeys = hair->get_curve_keys().size();
   float4 *mP = attr_mP->data_float4() + motion_step * numkeys;
   bool have_motion = false;
   int i = 0;
@@ -458,24 +458,24 @@ static void ExportCurveSegmentsMotion(Hair *hair, ParticleCurveData *CData, int
          curve < CData->psys_firstcurve[sys] + CData->psys_curvenum[sys];
          curve++) {
       /* Curve lengths may not match! Curves can be clipped. */
-      int curve_key_end = (num_curves + 1 < (int)hair->curve_first_key.size() ?
-                               hair->curve_first_key[num_curves + 1] :
-                               (int)hair->curve_keys.size());
-      const int num_center_curve_keys = curve_key_end - hair->curve_first_key[num_curves];
+      int curve_key_end = (num_curves + 1 < (int)hair->get_curve_first_key().size() ?
+                               hair->get_curve_first_key()[num_curves + 1] :
+                               (int)hair->get_curve_keys().size());
+      const int num_center_curve_keys = curve_key_end - hair->get_curve_first_key()[num_curves];
       const int is_num_keys_different = CData->curve_keynum[curve] - num_center_curve_keys;
 
       if (!is_num_keys_different) {
         for (int curvekey = CData->curve_firstkey[curve];
              curvekey < CData->curve_firstkey[curve] + CData->curve_keynum[curve];
              curvekey++) {
-          if (i < hair->curve_keys.size()) {
+          if (i < hair->get_curve_keys().size()) {
             mP[i] = CurveSegmentMotionCV(CData, sys, curve, curvekey);
             if (!have_motion) {
               /* unlike mesh coordinates, these tend to be slightly different
                * between frames due to particle transforms into/out of object
                * space, so we use an epsilon to detect actual changes */
-              float4 curve_key = float3_to_float4(hair->curve_keys[i]);
-              curve_key.w = hair->curve_radius[i];
+              float4 curve_key = float3_to_float4(hair->get_curve_keys()[i]);
+              curve_key.w = hair->get_curve_radius()[i];
               if (len_squared(mP[i] - curve_key) > 1e-5f * 1e-5f)
                 have_motion = true;
             }
@@ -560,7 +560,7 @@ void BlenderSync::sync_particle_hair(
       float3 *generated = attr_generated->data_float3();
 
       for (size_t i = 0; i < hair->num_curves(); i++) {
-        float3 co = hair->curve_keys[hair->get_curve(i).first_key];
+        float3 co = hair->get_curve_keys()[hair->get_curve(i).first_key];
         generated[i] = co * size - loc;
       }
     }
@@ -742,7 +742,7 @@ static void export_hair_curves_motion(Hair *hair, BL::Hair b_hair, int motion_st
   }
 
   /* Export motion keys. */
-  const int num_keys = hair->curve_keys.size();
+  const int num_keys = hair->get_curve_keys().size();
   float4 *mP = attr_mP->data_float4() + motion_step * num_keys;
   bool have_motion = false;
   int num_motion_keys = 0;
@@ -769,8 +769,8 @@ static void export_hair_curves_motion(Hair *hair, BL::Hair b_hair, int motion_st
           if (!have_motion) {
             /* TODO: use epsilon for comparison? Was needed for particles due to
              * transform, but ideally should not happen anymore. */
-            float4 curve_key = float3_to_float4(hair->curve_keys[i]);
-            curve_key.w = hair->curve_radius[i];
+            float4 curve_key = float3_to_float4(hair->get_curve_keys()[i]);
+            curve_key.w = hair->get_curve_radius()[i];
             have_motion = !(mP[i] == curve_key);
           }
         }
@@ -817,42 +817,53 @@ void BlenderSync::sync_hair(Hair *hair, BL::Object &b_ob, bool motion, int motio
 }
 #endif
 
-void BlenderSync::sync_hair(BL::Depsgraph b_depsgraph,
-                            BL::Object b_ob,
-                            Hair *hair,
-                            const vector<Shader *> &used_shaders)
+void BlenderSync::sync_hair(BL::Depsgraph b_depsgraph, BL::Object b_ob, Hair *hair)
 {
-  /* Compares curve_keys rather than strands in order to handle quick hair
-   * adjustments in dynamic BVH - other methods could probably do this better. */
-  array<float3> oldcurve_keys;
-  array<float> oldcurve_radius;
-  oldcurve_keys.steal_data(hair->curve_keys);
-  oldcurve_radius.steal_data(hair->curve_radius);
+  /* make a copy of the shaders as the caller in the main thread still need them for syncing the
+   * attributes */
+  array<Node *> used_shaders = hair->get_used_shaders();
 
-  hair->clear();
-  hair->used_shaders = used_shaders;
+  Hair new_hair;
+  new_hair.set_used_shaders(used_shaders);
 
   if (view_layer.use_hair) {
     if (b_ob.type() == BL::Object::type_HAIR) {
       /* Hair object. */
-      sync_hair(hair, b_ob, false);
+      sync_hair(&new_hair, b_ob, false);
     }
     else {
       /* Particle hair. */
-      bool need_undeformed = hair->need_attribute(scene, ATTR_STD_GENERATED);
+      bool need_undeformed = new_hair.need_attribute(scene, ATTR_STD_GENERATED);
       BL::Mesh b_mesh = object_to_mesh(
           b_data, b_ob, b_depsgraph, need_undeformed, Mesh::SUBDIVISION_NONE);
 
       if (b_mesh) {
-        sync_particle_hair(hair, b_mesh, b_ob, false);
+        sync_particle_hair(&new_hair, b_mesh, b_ob, false);
         free_object_to_mesh(b_data, b_ob, b_mesh);
       }
     }
   }
 
+  /* update original sockets */
+
+  for (const SocketType &socket : new_hair.type->inputs) {
+    /* Those sockets are updated in sync_object, so do not modify them. */
+    if (socket.name == "use_motion_blur" || socket.name == "motion_steps" ||
+        socket.name == "used_shaders") {
+      continue;
+    }
+    hair->set_value(socket, new_hair, socket);
+  }
+
+  foreach (Attribute &attr, new_hair.attributes.attributes) {
+    hair->attributes.attributes.push_back(std::move(attr));
+  }
+
   /* tag update */
-  const bool rebuild = ((oldcurve_keys != hair->curve_keys) ||
-                        (oldcurve_radius != hair->curve_radius));
+
+  /* Compares curve_keys rather than strands in order to handle quick hair
+   * adjustments in dynamic BVH - other methods could probably do this better. */
+  const bool rebuild = (hair->curve_keys_is_modified() || hair->curve_radius_is_modified());
 
   hair->tag_update(scene, rebuild);
 }

intern/cycles/blender/blender_device.cpp

@@ -47,8 +47,7 @@ DeviceInfo blender_device_info(BL::Preferences &b_preferences, BL::Scene &b_scen
     vector<DeviceInfo> devices = Device::available_devices(BlenderSession::device_override);
 
     if (devices.empty()) {
-      printf("Found no Cycles device of the specified type, falling back to CPU...\n");
-      return Device::available_devices(DEVICE_MASK_CPU).front();
+      return Device::dummy_device("Found no Cycles device of the specified type");
     }
 
     int threads = blender_device_threads(b_scene);

intern/cycles/blender/blender_geometry.cpp

@@ -52,14 +52,14 @@ Geometry *BlenderSync::sync_geometry(BL::Depsgraph &b_depsgraph,
   /* Test if we can instance or if the object is modified. */
   BL::ID b_ob_data = b_ob.data();
   BL::ID b_key_id = (BKE_object_is_modified(b_ob)) ? b_ob_instance : b_ob_data;
-  GeometryKey key(b_key_id.ptr.data, use_particle_hair);
   BL::Material material_override = view_layer.material_override;
   Shader *default_shader = (b_ob.type() == BL::Object::type_VOLUME) ? scene->default_volume :
                                                                       scene->default_surface;
   Geometry::Type geom_type = determine_geom_type(b_ob, use_particle_hair);
+  GeometryKey key(b_key_id.ptr.data, geom_type);
 
   /* Find shader indices. */
-  vector<Shader *> used_shaders;
+  array<Node *> used_shaders;
 
   BL::Object::material_slots_iterator slot;
   for (b_ob.material_slots.begin(slot); slot != b_ob.material_slots.end(); ++slot) {
@@ -76,7 +76,7 @@ Geometry *BlenderSync::sync_geometry(BL::Depsgraph &b_depsgraph,
     if (material_override)
       find_shader(material_override, used_shaders, default_shader);
     else
-      used_shaders.push_back(default_shader);
+      used_shaders.push_back_slow(default_shader);
   }
 
   /* Ensure we only sync instanced geometry once. */
@@ -114,7 +114,7 @@ Geometry *BlenderSync::sync_geometry(BL::Depsgraph &b_depsgraph,
     }
     /* Test if shaders changed, these can be object level so geometry
      * does not get tagged for recalc. */
-    else if (geom->used_shaders != used_shaders) {
+    else if (geom->get_used_shaders() != used_shaders) {
       ;
     }
     else {
@@ -122,7 +122,8 @@ Geometry *BlenderSync::sync_geometry(BL::Depsgraph &b_depsgraph,
        * because the shader needs different geometry attributes. */
       bool attribute_recalc = false;
 
-      foreach (Shader *shader, geom->used_shaders) {
+      foreach (Node *node, geom->get_used_shaders()) {
+        Shader *shader = static_cast<Shader *>(node);
         if (shader->need_update_geometry) {
           attribute_recalc = true;
         }
@@ -138,6 +139,9 @@ Geometry *BlenderSync::sync_geometry(BL::Depsgraph &b_depsgraph,
 
   geom->name = ustring(b_ob_data.name().c_str());
 
+  /* Store the shaders immediately for the object attribute code. */
+  geom->set_used_shaders(used_shaders);
+
   auto sync_func = [=]() mutable {
     if (progress.get_cancel())
       return;
@@ -146,15 +150,15 @@ Geometry *BlenderSync::sync_geometry(BL::Depsgraph &b_depsgraph,
 
     if (geom_type == Geometry::HAIR) {
       Hair *hair = static_cast<Hair *>(geom);
-      sync_hair(b_depsgraph, b_ob, hair, used_shaders);
+      sync_hair(b_depsgraph, b_ob, hair);
     }
     else if (geom_type == Geometry::VOLUME) {
       Volume *volume = static_cast<Volume *>(geom);
-      sync_volume(b_ob, volume, used_shaders);
+      sync_volume(b_ob, volume);
     }
     else {
       Mesh *mesh = static_cast<Mesh *>(geom);
-      sync_mesh(b_depsgraph, b_ob, mesh, used_shaders);
+      sync_mesh(b_depsgraph, b_ob, mesh);
     }
   };
 
@@ -177,7 +181,7 @@ void BlenderSync::sync_geometry_motion(BL::Depsgraph &b_depsgraph,
                                        TaskPool *task_pool)
 {
   /* Ensure we only sync instanced geometry once. */
-  Geometry *geom = object->geometry;
+  Geometry *geom = object->get_geometry();
 
   if (geometry_motion_synced.find(geom) != geometry_motion_synced.end())
     return;

intern/cycles/blender/blender_id_map.h

@@ -19,6 +19,7 @@
 
 #include <string.h>
 
+#include "render/geometry.h"
 #include "render/scene.h"
 
 #include "util/util_map.h"
@@ -34,10 +35,22 @@ CCL_NAMESPACE_BEGIN
 
 template<typename K, typename T> class id_map {
  public:
-  id_map()
+  id_map(Scene *scene_) : scene(scene_)
   {
   }
 
+  ~id_map()
+  {
+    set<T *> nodes;
+
+    typename map<K, T *>::iterator jt;
+    for (jt = b_map.begin(); jt != b_map.end(); jt++) {
+      nodes.insert(jt->second);
+    }
+
+    scene->delete_nodes(nodes);
+  }
+
   T *find(const BL::ID &id)
   {
     return find(id.ptr.owner_id);
@@ -97,16 +110,15 @@ template<typename K, typename T> class id_map {
   }
 
   /* Combined add and update as needed. */
-  bool add_or_update(Scene *scene, T **r_data, const BL::ID &id)
+  bool add_or_update(T **r_data, const BL::ID &id)
   {
-    return add_or_update(scene, r_data, id, id, id.ptr.owner_id);
+    return add_or_update(r_data, id, id, id.ptr.owner_id);
   }
-  bool add_or_update(Scene *scene, T **r_data, const BL::ID &id, const K &key)
+  bool add_or_update(T **r_data, const BL::ID &id, const K &key)
   {
-    return add_or_update(scene, r_data, id, id, key);
+    return add_or_update(r_data, id, id, key);
   }
-  bool add_or_update(
-      Scene *scene, T **r_data, const BL::ID &id, const BL::ID &parent, const K &key)
+  bool add_or_update(T **r_data, const BL::ID &id, const BL::ID &parent, const K &key)
   {
     T *data = find(key);
     bool recalc;
@@ -145,7 +157,7 @@ template<typename K, typename T> class id_map {
     b_map[NULL] = data;
   }
 
-  void post_sync(Scene *scene, bool do_delete = true)
+  void post_sync(bool do_delete = true)
   {
     map<K, T *> new_map;
     typedef pair<const K, T *> TMapPair;
@@ -176,6 +188,7 @@ template<typename K, typename T> class id_map {
   map<K, T *> b_map;
   set<T *> used_set;
   set<void *> b_recalc;
+  Scene *scene;
 };
 
 /* Object Key
@@ -230,9 +243,9 @@ struct ObjectKey {
 
 struct GeometryKey {
   void *id;
-  bool use_particle_hair;
+  Geometry::Type geometry_type;
 
-  GeometryKey(void *id, bool use_particle_hair) : id(id), use_particle_hair(use_particle_hair)
+  GeometryKey(void *id, Geometry::Type geometry_type) : id(id), geometry_type(geometry_type)
   {
   }
 
@@ -242,7 +255,7 @@ struct GeometryKey {
       return true;
     }
     else if (id == k.id) {
-      if (use_particle_hair < k.use_particle_hair) {
+      if (geometry_type < k.geometry_type) {
         return true;
       }
     }

intern/cycles/blender/blender_light.cpp

@@ -39,10 +39,10 @@ void BlenderSync::sync_light(BL::Object &b_parent,
   BL::Light b_light(b_ob.data());
 
   /* Update if either object or light data changed. */
-  if (!light_map.add_or_update(scene, &light, b_ob, b_parent, key)) {
+  if (!light_map.add_or_update(&light, b_ob, b_parent, key)) {
     Shader *shader;
-    if (!shader_map.add_or_update(scene, &shader, b_light)) {
-      if (light->is_portal)
+    if (!shader_map.add_or_update(&shader, b_light)) {
+      if (light->get_is_portal())
         *use_portal = true;
       return;
     }
@@ -52,16 +52,16 @@ void BlenderSync::sync_light(BL::Object &b_parent,
   switch (b_light.type()) {
     case BL::Light::type_POINT: {
       BL::PointLight b_point_light(b_light);
-      light->size = b_point_light.shadow_soft_size();
-      light->type = LIGHT_POINT;
+      light->set_size(b_point_light.shadow_soft_size());
+      light->set_light_type(LIGHT_POINT);
       break;
     }
     case BL::Light::type_SPOT: {
       BL::SpotLight b_spot_light(b_light);
-      light->size = b_spot_light.shadow_soft_size();
-      light->type = LIGHT_SPOT;
-      light->spot_angle = b_spot_light.spot_size();
-      light->spot_smooth = b_spot_light.spot_blend();
+      light->set_size(b_spot_light.shadow_soft_size());
+      light->set_light_type(LIGHT_SPOT);
+      light->set_spot_angle(b_spot_light.spot_size());
+      light->set_spot_smooth(b_spot_light.spot_blend());
       break;
     }
     /* Hemi were removed from 2.8 */
@@ -72,88 +72,88 @@ void BlenderSync::sync_light(BL::Object &b_parent,
     // }
     case BL::Light::type_SUN: {
       BL::SunLight b_sun_light(b_light);
-      light->angle = b_sun_light.angle();
-      light->type = LIGHT_DISTANT;
+      light->set_angle(b_sun_light.angle());
+      light->set_light_type(LIGHT_DISTANT);
       break;
     }
     case BL::Light::type_AREA: {
       BL::AreaLight b_area_light(b_light);
-      light->size = 1.0f;
-      light->axisu = transform_get_column(&tfm, 0);
-      light->axisv = transform_get_column(&tfm, 1);
-      light->sizeu = b_area_light.size();
+      light->set_size(1.0f);
+      light->set_axisu(transform_get_column(&tfm, 0));
+      light->set_axisv(transform_get_column(&tfm, 1));
+      light->set_sizeu(b_area_light.size());
       switch (b_area_light.shape()) {
         case BL::AreaLight::shape_SQUARE:
-          light->sizev = light->sizeu;
-          light->round = false;
+          light->set_sizev(light->get_sizeu());
+          light->set_round(false);
           break;
         case BL::AreaLight::shape_RECTANGLE:
-          light->sizev = b_area_light.size_y();
-          light->round = false;
+          light->set_sizev(b_area_light.size_y());
+          light->set_round(false);
           break;
         case BL::AreaLight::shape_DISK:
-          light->sizev = light->sizeu;
-          light->round = true;
+          light->set_sizev(light->get_sizeu());
+          light->set_round(true);
           break;
         case BL::AreaLight::shape_ELLIPSE:
-          light->sizev = b_area_light.size_y();
-          light->round = true;
+          light->set_sizev(b_area_light.size_y());
+          light->set_round(true);
           break;
       }
-      light->type = LIGHT_AREA;
+      light->set_light_type(LIGHT_AREA);
       break;
     }
   }
 
   /* strength */
-  light->strength = get_float3(b_light.color());
-  light->strength *= BL::PointLight(b_light).energy();
+  float3 strength = get_float3(b_light.color()) * BL::PointLight(b_light).energy();
+  light->set_strength(strength);
 
   /* location and (inverted!) direction */
-  light->co = transform_get_column(&tfm, 3);
-  light->dir = -transform_get_column(&tfm, 2);
-  light->tfm = tfm;
+  light->set_co(transform_get_column(&tfm, 3));
+  light->set_dir(-transform_get_column(&tfm, 2));
+  light->set_tfm(tfm);
 
   /* shader */
-  vector<Shader *> used_shaders;
+  array<Node *> used_shaders;
   find_shader(b_light, used_shaders, scene->default_light);
-  light->shader = used_shaders[0];
+  light->set_shader(static_cast<Shader *>(used_shaders[0]));
 
   /* shadow */
   PointerRNA cscene = RNA_pointer_get(&b_scene.ptr, "cycles");
   PointerRNA clight = RNA_pointer_get(&b_light.ptr, "cycles");
-  light->cast_shadow = get_boolean(clight, "cast_shadow");
-  light->use_mis = get_boolean(clight, "use_multiple_importance_sampling");
+  light->set_cast_shadow(get_boolean(clight, "cast_shadow"));
+  light->set_use_mis(get_boolean(clight, "use_multiple_importance_sampling"));
 
   int samples = get_int(clight, "samples");
   if (get_boolean(cscene, "use_square_samples"))
-    light->samples = samples * samples;
+    light->set_samples(samples * samples);
   else
-    light->samples = samples;
+    light->set_samples(samples);
 
-  light->max_bounces = get_int(clight, "max_bounces");
+  light->set_max_bounces(get_int(clight, "max_bounces"));
 
   if (b_ob != b_ob_instance) {
-    light->random_id = random_id;
+    light->set_random_id(random_id);
   }
   else {
-    light->random_id = hash_uint2(hash_string(b_ob.name().c_str()), 0);
+    light->set_random_id(hash_uint2(hash_string(b_ob.name().c_str()), 0));
   }
 
-  if (light->type == LIGHT_AREA)
-    light->is_portal = get_boolean(clight, "is_portal");
+  if (light->get_light_type() == LIGHT_AREA)
+    light->set_is_portal(get_boolean(clight, "is_portal"));
   else
-    light->is_portal = false;
+    light->set_is_portal(false);
 
-  if (light->is_portal)
+  if (light->get_is_portal())
     *use_portal = true;
 
   /* visibility */
   uint visibility = object_ray_visibility(b_ob);
-  light->use_diffuse = (visibility & PATH_RAY_DIFFUSE) != 0;
-  light->use_glossy = (visibility & PATH_RAY_GLOSSY) != 0;
-  light->use_transmission = (visibility & PATH_RAY_TRANSMIT) != 0;
-  light->use_scatter = (visibility & PATH_RAY_VOLUME_SCATTER) != 0;
+  light->set_use_diffuse((visibility & PATH_RAY_DIFFUSE) != 0);
+  light->set_use_glossy((visibility & PATH_RAY_GLOSSY) != 0);
+  light->set_use_transmission((visibility & PATH_RAY_TRANSMIT) != 0);
+  light->set_use_scatter((visibility & PATH_RAY_VOLUME_SCATTER) != 0);
 
   /* tag */
   light->tag_update(scene);
@@ -176,27 +176,27 @@ void BlenderSync::sync_background_light(BL::SpaceView3D &b_v3d, bool use_portal)
       Light *light;
       ObjectKey key(b_world, 0, b_world, false);
 
-      if (light_map.add_or_update(scene, &light, b_world, b_world, key) || world_recalc ||
+      if (light_map.add_or_update(&light, b_world, b_world, key) || world_recalc ||
           b_world.ptr.data != world_map) {
-        light->type = LIGHT_BACKGROUND;
+        light->set_light_type(LIGHT_BACKGROUND);
         if (sampling_method == SAMPLING_MANUAL) {
-          light->map_resolution = get_int(cworld, "sample_map_resolution");
+          light->set_map_resolution(get_int(cworld, "sample_map_resolution"));
         }
         else {
-          light->map_resolution = 0;
+          light->set_map_resolution(0);
         }
-        light->shader = scene->default_background;
-        light->use_mis = sample_as_light;
-        light->max_bounces = get_int(cworld, "max_bounces");
+        light->set_shader(scene->default_background);
+        light->set_use_mis(sample_as_light);
+        light->set_max_bounces(get_int(cworld, "max_bounces"));
 
         /* force enable light again when world is resynced */
-        light->is_enabled = true;
+        light->set_is_enabled(true);
 
         int samples = get_int(cworld, "samples");
         if (get_boolean(cscene, "use_square_samples"))
-          light->samples = samples * samples;
+          light->set_samples(samples * samples);
         else
-          light->samples = samples;
+          light->set_samples(samples);
 
         light->tag_update(scene);
         light_map.set_recalc(b_world);

intern/cycles/blender/blender_mesh.cpp

@@ -48,8 +48,8 @@ struct MikkUserData {
                float *tangent_sign)
       : mesh(mesh), texface(NULL), orco(NULL), tangent(tangent), tangent_sign(tangent_sign)
   {
-    const AttributeSet &attributes = (mesh->subd_faces.size()) ? mesh->subd_attributes :
-                                                                 mesh->attributes;
+    const AttributeSet &attributes = (mesh->get_num_subd_faces()) ? mesh->subd_attributes :
+                                                                    mesh->attributes;
 
     Attribute *attr_vN = attributes.find(ATTR_STD_VERTEX_NORMAL);
     vertex_normal = attr_vN->data_float3();
@@ -85,8 +85,8 @@ struct MikkUserData {
 static int mikk_get_num_faces(const SMikkTSpaceContext *context)
 {
   const MikkUserData *userdata = (const MikkUserData *)context->m_pUserData;
-  if (userdata->mesh->subd_faces.size()) {
-    return userdata->mesh->subd_faces.size();
+  if (userdata->mesh->get_num_subd_faces()) {
+    return userdata->mesh->get_num_subd_faces();
   }
   else {
     return userdata->mesh->num_triangles();
@@ -96,9 +96,9 @@ static int mikk_get_num_faces(const SMikkTSpaceContext *context)
 static int mikk_get_num_verts_of_face(const SMikkTSpaceContext *context, const int face_num)
 {
   const MikkUserData *userdata = (const MikkUserData *)context->m_pUserData;
-  if (userdata->mesh->subd_faces.size()) {
+  if (userdata->mesh->get_num_subd_faces()) {
     const Mesh *mesh = userdata->mesh;
-    return mesh->subd_faces[face_num].num_corners;
+    return mesh->get_subd_num_corners()[face_num];
   }
   else {
     return 3;
@@ -107,19 +107,19 @@ static int mikk_get_num_verts_of_face(const SMikkTSpaceContext *context, const i
 
 static int mikk_vertex_index(const Mesh *mesh, const int face_num, const int vert_num)
 {
-  if (mesh->subd_faces.size()) {
-    const Mesh::SubdFace &face = mesh->subd_faces[face_num];
-    return mesh->subd_face_corners[face.start_corner + vert_num];
+  if (mesh->get_num_subd_faces()) {
+    const Mesh::SubdFace &face = mesh->get_subd_face(face_num);
+    return mesh->get_subd_face_corners()[face.start_corner + vert_num];
   }
   else {
-    return mesh->triangles[face_num * 3 + vert_num];
+    return mesh->get_triangles()[face_num * 3 + vert_num];
   }
 }
 
 static int mikk_corner_index(const Mesh *mesh, const int face_num, const int vert_num)
 {
-  if (mesh->subd_faces.size()) {
-    const Mesh::SubdFace &face = mesh->subd_faces[face_num];
+  if (mesh->get_num_subd_faces()) {
+    const Mesh::SubdFace &face = mesh->get_subd_face(face_num);
     return face.start_corner + vert_num;
   }
   else {
@@ -135,7 +135,7 @@ static void mikk_get_position(const SMikkTSpaceContext *context,
   const MikkUserData *userdata = (const MikkUserData *)context->m_pUserData;
   const Mesh *mesh = userdata->mesh;
   const int vertex_index = mikk_vertex_index(mesh, face_num, vert_num);
-  const float3 vP = mesh->verts[vertex_index];
+  const float3 vP = mesh->get_verts()[vertex_index];
   P[0] = vP.x;
   P[1] = vP.y;
   P[2] = vP.z;
@@ -178,8 +178,8 @@ static void mikk_get_normal(const SMikkTSpaceContext *context,
   const MikkUserData *userdata = (const MikkUserData *)context->m_pUserData;
   const Mesh *mesh = userdata->mesh;
   float3 vN;
-  if (mesh->subd_faces.size()) {
-    const Mesh::SubdFace &face = mesh->subd_faces[face_num];
+  if (mesh->get_num_subd_faces()) {
+    const Mesh::SubdFace &face = mesh->get_subd_face(face_num);
     if (face.smooth) {
       const int vertex_index = mikk_vertex_index(mesh, face_num, vert_num);
       vN = userdata->vertex_normal[vertex_index];
@@ -189,13 +189,13 @@ static void mikk_get_normal(const SMikkTSpaceContext *context,
     }
   }
   else {
-    if (mesh->smooth[face_num]) {
+    if (mesh->get_smooth()[face_num]) {
       const int vertex_index = mikk_vertex_index(mesh, face_num, vert_num);
       vN = userdata->vertex_normal[vertex_index];
     }
     else {
       const Mesh::Triangle tri = mesh->get_triangle(face_num);
-      vN = tri.compute_normal(&mesh->verts[0]);
+      vN = tri.compute_normal(&mesh->get_verts()[0]);
     }
   }
   N[0] = vN.x;
@@ -222,7 +222,8 @@ static void mikk_compute_tangents(
     const BL::Mesh &b_mesh, const char *layer_name, Mesh *mesh, bool need_sign, bool active_render)
 {
   /* Create tangent attributes. */
-  AttributeSet &attributes = (mesh->subd_faces.size()) ? mesh->subd_attributes : mesh->attributes;
+  AttributeSet &attributes = (mesh->get_num_subd_faces()) ? mesh->subd_attributes :
+                                                            mesh->attributes;
   Attribute *attr;
   ustring name;
   if (layer_name != NULL) {
@@ -346,7 +347,7 @@ static void attr_create_vertex_color(Scene *scene, Mesh *mesh, BL::Mesh &b_mesh,
         for (int i = 0; i < n; i++) {
           float4 color = get_float4(l->data[p->loop_start() + i].color());
           /* Compress/encode vertex color using the sRGB curve. */
-          *(cdata++) = color_float4_to_uchar4(color_srgb_to_linear_v4(color));
+          *(cdata++) = color_float4_to_uchar4(color);
         }
       }
     }
@@ -368,9 +369,10 @@ static void attr_create_vertex_color(Scene *scene, Mesh *mesh, BL::Mesh &b_mesh,
         float4 c3 = get_float4(l->data[li[2]].color());
 
         /* Compress/encode vertex color using the sRGB curve. */
-        cdata[0] = color_float4_to_uchar4(color_srgb_to_linear_v4(c1));
-        cdata[1] = color_float4_to_uchar4(color_srgb_to_linear_v4(c2));
-        cdata[2] = color_float4_to_uchar4(color_srgb_to_linear_v4(c3));
+        cdata[0] = color_float4_to_uchar4(c1);
+        cdata[1] = color_float4_to_uchar4(c2);
+        cdata[2] = color_float4_to_uchar4(c3);
+
         cdata += 3;
       }
     }
@@ -554,7 +556,7 @@ static void attr_create_pointiness(Scene *scene, Mesh *mesh, BL::Mesh &b_mesh, b
   for (int vert_index = 0; vert_index < num_verts; ++vert_index) {
     sorted_vert_indeices[vert_index] = vert_index;
   }
-  VertexAverageComparator compare(mesh->verts);
+  VertexAverageComparator compare(mesh->get_verts());
   sort(sorted_vert_indeices.begin(), sorted_vert_indeices.end(), compare);
   /* This array stores index of the original vertex for the given vertex
    * index.
@@ -562,12 +564,12 @@ static void attr_create_pointiness(Scene *scene, Mesh *mesh, BL::Mesh &b_mesh, b
   vector<int> vert_orig_index(num_verts);
   for (int sorted_vert_index = 0; sorted_vert_index < num_verts; ++sorted_vert_index) {
     const int vert_index = sorted_vert_indeices[sorted_vert_index];
-    const float3 &vert_co = mesh->verts[vert_index];
+    const float3 &vert_co = mesh->get_verts()[vert_index];
     bool found = false;
     for (int other_sorted_vert_index = sorted_vert_index + 1; other_sorted_vert_index < num_verts;
          ++other_sorted_vert_index) {
       const int other_vert_index = sorted_vert_indeices[other_sorted_vert_index];
-      const float3 &other_vert_co = mesh->verts[other_vert_index];
+      const float3 &other_vert_co = mesh->get_verts()[other_vert_index];
       /* We are too far away now, we wouldn't have duplicate. */
       if ((other_vert_co.x + other_vert_co.y + other_vert_co.z) -
               (vert_co.x + vert_co.y + vert_co.z) >
@@ -732,7 +734,7 @@ static void attr_create_random_per_island(Scene *scene,
 static void create_mesh(Scene *scene,
                         Mesh *mesh,
                         BL::Mesh &b_mesh,
-                        const vector<Shader *> &used_shaders,
+                        const array<Node *> &used_shaders,
                         bool subdivision = false,
                         bool subdivide_uvs = true)
 {
@@ -743,7 +745,7 @@ static void create_mesh(Scene *scene,
   int numcorners = 0;
   int numngons = 0;
   bool use_loop_normals = b_mesh.use_auto_smooth() &&
-                          (mesh->subdivision_type != Mesh::SUBDIVISION_CATMULL_CLARK);
+                          (mesh->get_subdivision_type() != Mesh::SUBDIVISION_CATMULL_CLARK);
 
   /* If no faces, create empty mesh. */
   if (numfaces == 0) {
@@ -762,8 +764,11 @@ static void create_mesh(Scene *scene,
   }
 
   /* allocate memory */
+  if (subdivision) {
+    mesh->reserve_subd_faces(numfaces, numngons, numcorners);
+  }
+
   mesh->reserve_mesh(numverts, numtris);
-  mesh->reserve_subd_faces(numfaces, numngons, numcorners);
 
   /* create vertex coordinates and normals */
   BL::Mesh::vertices_iterator v;
@@ -875,7 +880,7 @@ static void create_subd_mesh(Scene *scene,
                              Mesh *mesh,
                              BL::Object &b_ob,
                              BL::Mesh &b_mesh,
-                             const vector<Shader *> &used_shaders,
+                             const array<Node *> &used_shaders,
                              float dicing_rate,
                              int max_subdivisions)
 {
@@ -894,31 +899,21 @@ static void create_subd_mesh(Scene *scene,
     }
   }
 
-  mesh->subd_creases.resize(num_creases);
+  mesh->reserve_subd_creases(num_creases);
 
-  Mesh::SubdEdgeCrease *crease = mesh->subd_creases.data();
   for (b_mesh.edges.begin(e); e != b_mesh.edges.end(); ++e) {
     if (e->crease() != 0.0f) {
-      crease->v[0] = e->vertices()[0];
-      crease->v[1] = e->vertices()[1];
-      crease->crease = e->crease();
-
-      crease++;
+      mesh->add_crease(e->vertices()[0], e->vertices()[1], e->crease());
     }
   }
 
   /* set subd params */
-  if (!mesh->subd_params) {
-    mesh->subd_params = new SubdParams(mesh);
-  }
-  SubdParams &sdparams = *mesh->subd_params;
-
   PointerRNA cobj = RNA_pointer_get(&b_ob.ptr, "cycles");
+  float subd_dicing_rate = max(0.1f, RNA_float_get(&cobj, "dicing_rate") * dicing_rate);
 
-  sdparams.dicing_rate = max(0.1f, RNA_float_get(&cobj, "dicing_rate") * dicing_rate);
-  sdparams.max_level = max_subdivisions;
-
-  sdparams.objecttoworld = get_transform(b_ob.matrix_world());
+  mesh->set_subd_dicing_rate(subd_dicing_rate);
+  mesh->set_subd_max_level(max_subdivisions);
+  mesh->set_subd_objecttoworld(get_transform(b_ob.matrix_world()));
 }
 
 /* Sync */
@@ -955,14 +950,14 @@ static void sync_mesh_cached_velocities(BL::Object &b_ob, Scene *scene, Mesh *me
     return;
   }
 
-  const size_t numverts = mesh->verts.size();
+  const size_t numverts = mesh->get_verts().size();
 
   if (b_mesh_cache.vertex_velocities.length() != numverts) {
     return;
   }
 
   /* Find or add attribute */
-  float3 *P = &mesh->verts[0];
+  float3 *P = &mesh->get_verts()[0];
   Attribute *attr_mP = mesh->attributes.find(ATTR_STD_MOTION_VERTEX_POSITION);
 
   if (!attr_mP) {
@@ -996,11 +991,11 @@ static void sync_mesh_fluid_motion(BL::Object &b_ob, Scene *scene, Mesh *mesh)
     return;
 
   /* If the mesh has modifiers following the fluid domain we can't export motion. */
-  if (b_fluid_domain.mesh_vertices.length() != mesh->verts.size())
+  if (b_fluid_domain.mesh_vertices.length() != mesh->get_verts().size())
     return;
 
   /* Find or add attribute */
-  float3 *P = &mesh->verts[0];
+  float3 *P = &mesh->get_verts()[0];
   Attribute *attr_mP = mesh->attributes.find(ATTR_STD_MOTION_VERTEX_POSITION);
 
   if (!attr_mP) {
@@ -1011,7 +1006,7 @@ static void sync_mesh_fluid_motion(BL::Object &b_ob, Scene *scene, Mesh *mesh)
   float motion_times[2] = {-1.0f, 1.0f};
   for (int step = 0; step < 2; step++) {
     float relative_time = motion_times[step] * scene->motion_shutter_time() * 0.5f;
-    float3 *mP = attr_mP->data_float3() + step * mesh->verts.size();
+    float3 *mP = attr_mP->data_float3() + step * mesh->get_verts().size();
 
     BL::FluidDomainSettings::mesh_vertices_iterator svi;
     int i = 0;
@@ -1023,56 +1018,77 @@ static void sync_mesh_fluid_motion(BL::Object &b_ob, Scene *scene, Mesh *mesh)
   }
 }
 
-void BlenderSync::sync_mesh(BL::Depsgraph b_depsgraph,
-                            BL::Object b_ob,
-                            Mesh *mesh,
-                            const vector<Shader *> &used_shaders)
+void BlenderSync::sync_mesh(BL::Depsgraph b_depsgraph, BL::Object b_ob, Mesh *mesh)
 {
-  array<int> oldtriangles;
-  array<Mesh::SubdFace> oldsubd_faces;
-  array<int> oldsubd_face_corners;
-  oldtriangles.steal_data(mesh->triangles);
-  oldsubd_faces.steal_data(mesh->subd_faces);
-  oldsubd_face_corners.steal_data(mesh->subd_face_corners);
+  /* make a copy of the shaders as the caller in the main thread still need them for syncing the
+   * attributes */
+  array<Node *> used_shaders = mesh->get_used_shaders();
 
-  mesh->clear();
-  mesh->used_shaders = used_shaders;
-
-  mesh->subdivision_type = Mesh::SUBDIVISION_NONE;
+  Mesh new_mesh;
+  new_mesh.set_used_shaders(used_shaders);
 
   if (view_layer.use_surfaces) {
     /* Adaptive subdivision setup. Not for baking since that requires
      * exact mapping to the Blender mesh. */
     if (!scene->bake_manager->get_baking()) {
-      mesh->subdivision_type = object_subdivision_type(b_ob, preview, experimental);
+      new_mesh.set_subdivision_type(object_subdivision_type(b_ob, preview, experimental));
     }
 
     /* For some reason, meshes do not need this... */
-    bool need_undeformed = mesh->need_attribute(scene, ATTR_STD_GENERATED);
+    bool need_undeformed = new_mesh.need_attribute(scene, ATTR_STD_GENERATED);
     BL::Mesh b_mesh = object_to_mesh(
-        b_data, b_ob, b_depsgraph, need_undeformed, mesh->subdivision_type);
+        b_data, b_ob, b_depsgraph, need_undeformed, new_mesh.get_subdivision_type());
 
     if (b_mesh) {
       /* Sync mesh itself. */
-      if (mesh->subdivision_type != Mesh::SUBDIVISION_NONE)
-        create_subd_mesh(
-            scene, mesh, b_ob, b_mesh, mesh->used_shaders, dicing_rate, max_subdivisions);
+      if (new_mesh.get_subdivision_type() != Mesh::SUBDIVISION_NONE)
+        create_subd_mesh(scene,
+                         &new_mesh,
+                         b_ob,
+                         b_mesh,
+                         new_mesh.get_used_shaders(),
+                         dicing_rate,
+                         max_subdivisions);
       else
-        create_mesh(scene, mesh, b_mesh, mesh->used_shaders, false);
+        create_mesh(scene, &new_mesh, b_mesh, new_mesh.get_used_shaders(), false);
 
       free_object_to_mesh(b_data, b_ob, b_mesh);
     }
   }
 
   /* cached velocities (e.g. from alembic archive) */
-  sync_mesh_cached_velocities(b_ob, scene, mesh);
+  sync_mesh_cached_velocities(b_ob, scene, &new_mesh);
 
   /* mesh fluid motion mantaflow */
-  sync_mesh_fluid_motion(b_ob, scene, mesh);
+  sync_mesh_fluid_motion(b_ob, scene, &new_mesh);
+
+  /* update original sockets */
+
+  for (const SocketType &socket : new_mesh.type->inputs) {
+    /* Those sockets are updated in sync_object, so do not modify them. */
+    if (socket.name == "use_motion_blur" || socket.name == "motion_steps" ||
+        socket.name == "used_shaders") {
+      continue;
+    }
+    mesh->set_value(socket, new_mesh, socket);
+  }
+
+  foreach (Attribute &attr, new_mesh.attributes.attributes) {
+    mesh->attributes.attributes.push_back(std::move(attr));
+  }
+
+  foreach (Attribute &attr, new_mesh.subd_attributes.attributes) {
+    mesh->subd_attributes.attributes.push_back(std::move(attr));
+  }
+
+  mesh->set_num_subd_faces(new_mesh.get_num_subd_faces());
 
   /* tag update */
-  bool rebuild = (oldtriangles != mesh->triangles) || (oldsubd_faces != mesh->subd_faces) ||
-                 (oldsubd_face_corners != mesh->subd_face_corners);
+  bool rebuild = (mesh->triangles_is_modified()) || (mesh->subd_num_corners_is_modified()) ||
+                 (mesh->subd_shader_is_modified()) || (mesh->subd_smooth_is_modified()) ||
+                 (mesh->subd_ptex_offset_is_modified()) ||
+                 (mesh->subd_start_corner_is_modified()) ||
+                 (mesh->subd_face_corners_is_modified());
 
   mesh->tag_update(scene, rebuild);
 }
@@ -1095,7 +1111,7 @@ void BlenderSync::sync_mesh_motion(BL::Depsgraph b_depsgraph,
   }
 
   /* Skip if no vertices were exported. */
-  size_t numverts = mesh->verts.size();
+  size_t numverts = mesh->get_verts().size();
   if (numverts == 0) {
     return;
   }
@@ -1140,7 +1156,7 @@ void BlenderSync::sync_mesh_motion(BL::Depsgraph b_depsgraph,
     if (new_attribute) {
       /* In case of new attribute, we verify if there really was any motion. */
       if (b_mesh.vertices.length() != numverts ||
-          memcmp(mP, &mesh->verts[0], sizeof(float3) * numverts) == 0) {
+          memcmp(mP, &mesh->get_verts()[0], sizeof(float3) * numverts) == 0) {
         /* no motion, remove attributes again */
         if (b_mesh.vertices.length() != numverts) {
           VLOG(1) << "Topology differs, disabling motion blur for object " << b_ob.name();
@@ -1156,7 +1172,7 @@ void BlenderSync::sync_mesh_motion(BL::Depsgraph b_depsgraph,
         VLOG(1) << "Filling deformation motion for object " << b_ob.name();
         /* motion, fill up previous steps that we might have skipped because
          * they had no motion, but we need them anyway now */
-        float3 *P = &mesh->verts[0];
+        float3 *P = &mesh->get_verts()[0];
         float3 *N = (attr_N) ? attr_N->data_float3() : NULL;
         for (int step = 0; step < motion_step; step++) {
           memcpy(attr_mP->data_float3() + step * numverts, P, sizeof(float3) * numverts);
@@ -1169,7 +1185,7 @@ void BlenderSync::sync_mesh_motion(BL::Depsgraph b_depsgraph,
       if (b_mesh.vertices.length() != numverts) {
         VLOG(1) << "Topology differs, discarding motion blur for object " << b_ob.name()
                 << " at time " << motion_step;
-        memcpy(mP, &mesh->verts[0], sizeof(float3) * numverts);
+        memcpy(mP, &mesh->get_verts()[0], sizeof(float3) * numverts);
         if (mN != NULL) {
           memcpy(mN, attr_N->data_float3(), sizeof(float3) * numverts);
         }

intern/cycles/blender/blender_object.cpp

@@ -199,11 +199,13 @@ Object *BlenderSync::sync_object(BL::Depsgraph &b_depsgraph,
       /* Set transform at matching motion time step. */
       int time_index = object->motion_step(motion_time);
       if (time_index >= 0) {
-        object->motion[time_index] = tfm;
+        array<Transform> motion = object->get_motion();
+        motion[time_index] = tfm;
+        object->set_motion(motion);
       }
 
       /* mesh deformation */
-      if (object->geometry)
+      if (object->get_geometry())
         sync_geometry_motion(b_depsgraph,
                              b_ob_instance,
                              object,
@@ -218,45 +220,40 @@ Object *BlenderSync::sync_object(BL::Depsgraph &b_depsgraph,
   /* test if we need to sync */
   bool object_updated = false;
 
-  if (object_map.add_or_update(scene, &object, b_ob, b_parent, key))
+  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.
    * b_ob_instance is the original object and will remain valid for deferred geometry
    * sync. */
-  object->geometry = sync_geometry(b_depsgraph,
-                                   b_ob_instance,
-                                   b_ob_instance,
-                                   object_updated,
-                                   use_particle_hair,
-                                   object_geom_task_pool);
+  Geometry *geometry = sync_geometry(b_depsgraph,
+                                     b_ob_instance,
+                                     b_ob_instance,
+                                     object_updated,
+                                     use_particle_hair,
+                                     object_geom_task_pool);
+  object->set_geometry(geometry);
 
   /* special case not tracked by object update flags */
 
-  /* holdout */
-  if (use_holdout != object->use_holdout) {
-    object->use_holdout = use_holdout;
-    scene->object_manager->tag_update(scene);
+  if (sync_object_attributes(b_instance, object)) {
     object_updated = true;
   }
 
-  if (visibility != object->visibility) {
-    object->visibility = visibility;
-    object_updated = true;
+  /* holdout */
+  object->set_use_holdout(use_holdout);
+  if (object->use_holdout_is_modified()) {
+    scene->object_manager->tag_update(scene);
   }
 
+  object->set_visibility(visibility);
+
   bool is_shadow_catcher = get_boolean(cobject, "is_shadow_catcher");
-  if (is_shadow_catcher != object->is_shadow_catcher) {
-    object->is_shadow_catcher = is_shadow_catcher;
-    object_updated = true;
-  }
+  object->set_is_shadow_catcher(is_shadow_catcher);
 
   float shadow_terminator_offset = get_float(cobject, "shadow_terminator_offset");
-  if (shadow_terminator_offset != object->shadow_terminator_offset) {
-    object->shadow_terminator_offset = shadow_terminator_offset;
-    object_updated = true;
-  }
+  object->set_shadow_terminator_offset(shadow_terminator_offset);
 
   /* sync the asset name for Cryptomatte */
   BL::Object parent = b_ob.parent();
@@ -270,48 +267,49 @@ Object *BlenderSync::sync_object(BL::Depsgraph &b_depsgraph,
   else {
     parent_name = b_ob.name();
   }
-  if (object->asset_name != parent_name) {
-    object->asset_name = parent_name;
-    object_updated = true;
-  }
+  object->set_asset_name(parent_name);
 
   /* object sync
    * 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_updated || (object->geometry && object->geometry->need_update) ||
-      tfm != object->tfm) {
+  if (object->is_modified() || object_updated ||
+      (object->get_geometry() && object->get_geometry()->is_modified()) ||
+      tfm != object->get_tfm()) {
     object->name = b_ob.name().c_str();
-    object->pass_id = b_ob.pass_index();
-    object->color = get_float3(b_ob.color());
-    object->tfm = tfm;
-    object->motion.clear();
+    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->geometry) {
-      Geometry *geom = object->geometry;
-      geom->use_motion_blur = false;
-      geom->motion_steps = 0;
+    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->motion_steps = motion_steps;
+        geom->set_motion_steps(motion_steps);
         if (motion_steps && object_use_deform_motion(b_parent, b_ob)) {
-          geom->use_motion_blur = true;
+          geom->set_use_motion_blur(true);
         }
       }
       else {
         motion_steps = 3;
-        geom->motion_steps = motion_steps;
+        geom->set_motion_steps(motion_steps);
       }
 
-      object->motion.clear();
-      object->motion.resize(motion_steps, transform_empty());
+      motion.resize(motion_steps, transform_empty());
 
       if (motion_steps) {
-        object->motion[motion_steps / 2] = tfm;
+        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));
@@ -321,15 +319,15 @@ Object *BlenderSync::sync_object(BL::Depsgraph &b_depsgraph,
 
     /* dupli texture coordinates and random_id */
     if (is_instance) {
-      object->dupli_generated = 0.5f * get_float3(b_instance.orco()) -
-                                make_float3(0.5f, 0.5f, 0.5f);
-      object->dupli_uv = get_float2(b_instance.uv());
-      object->random_id = b_instance.random_id();
+      object->set_dupli_generated(0.5f * get_float3(b_instance.orco()) -
+                                  make_float3(0.5f, 0.5f, 0.5f));
+      object->set_dupli_uv(get_float2(b_instance.uv()));
+      object->set_random_id(b_instance.random_id());
     }
     else {
-      object->dupli_generated = make_float3(0.0f, 0.0f, 0.0f);
-      object->dupli_uv = make_float2(0.0f, 0.0f);
-      object->random_id = hash_uint2(hash_string(object->name.c_str()), 0);
+      object->set_dupli_generated(make_float3(0.0f, 0.0f, 0.0f));
+      object->set_dupli_uv(make_float2(0.0f, 0.0f));
+      object->set_random_id(hash_uint2(hash_string(object->name.c_str()), 0));
     }
 
     object->tag_update(scene);
@@ -343,6 +341,132 @@ Object *BlenderSync::sync_object(BL::Depsgraph &b_depsgraph,
   return object;
 }
 
+/* This function mirrors drw_uniform_property_lookup in draw_instance_data.cpp */
+static bool lookup_property(BL::ID b_id, const string &name, float4 *r_value)
+{
+  PointerRNA ptr;
+  PropertyRNA *prop;
+
+  if (!RNA_path_resolve(&b_id.ptr, name.c_str(), &ptr, &prop)) {
+    return false;
+  }
+
+  PropertyType type = RNA_property_type(prop);
+  int arraylen = RNA_property_array_length(&ptr, prop);
+
+  if (arraylen == 0) {
+    float value;
+
+    if (type == PROP_FLOAT)
+      value = RNA_property_float_get(&ptr, prop);
+    else if (type == PROP_INT)
+      value = RNA_property_int_get(&ptr, prop);
+    else
+      return false;
+
+    *r_value = make_float4(value, value, value, 1.0f);
+    return true;
+  }
+  else if (type == PROP_FLOAT && arraylen <= 4) {
+    *r_value = make_float4(0.0f, 0.0f, 0.0f, 1.0f);
+    RNA_property_float_get_array(&ptr, prop, &r_value->x);
+    return true;
+  }
+
+  return false;
+}
+
+/* This function mirrors drw_uniform_attribute_lookup in draw_instance_data.cpp */
+static float4 lookup_instance_property(BL::DepsgraphObjectInstance &b_instance,
+                                       const string &name,
+                                       bool use_instancer)
+{
+  string idprop_name = string_printf("[\"%s\"]", name.c_str());
+  float4 value;
+
+  /* If requesting instance data, check the parent particle system and object. */
+  if (use_instancer && b_instance.is_instance()) {
+    BL::ParticleSystem b_psys = b_instance.particle_system();
+
+    if (b_psys) {
+      if (lookup_property(b_psys.settings(), idprop_name, &value) ||
+          lookup_property(b_psys.settings(), name, &value)) {
+        return value;
+      }
+    }
+    if (lookup_property(b_instance.parent(), idprop_name, &value) ||
+        lookup_property(b_instance.parent(), name, &value)) {
+      return value;
+    }
+  }
+
+  /* Check the object and mesh. */
+  BL::Object b_ob = b_instance.object();
+  BL::ID b_data = b_ob.data();
+
+  if (lookup_property(b_ob, idprop_name, &value) || lookup_property(b_ob, name, &value) ||
+      lookup_property(b_data, idprop_name, &value) || lookup_property(b_data, name, &value)) {
+    return value;
+  }
+
+  return make_float4(0.0f);
+}
+
+bool BlenderSync::sync_object_attributes(BL::DepsgraphObjectInstance &b_instance, Object *object)
+{
+  /* Find which attributes are needed. */
+  AttributeRequestSet requests = object->get_geometry()->needed_attributes();
+
+  /* Delete attributes that became unnecessary. */
+  vector<ParamValue> &attributes = object->attributes;
+  bool changed = false;
+
+  for (int i = attributes.size() - 1; i >= 0; i--) {
+    if (!requests.find(attributes[i].name())) {
+      attributes.erase(attributes.begin() + i);
+      changed = true;
+    }
+  }
+
+  /* Update attribute values. */
+  foreach (AttributeRequest &req, requests.requests) {
+    ustring name = req.name;
+
+    std::string real_name;
+    BlenderAttributeType type = blender_attribute_name_split_type(name, &real_name);
+
+    if (type != BL::ShaderNodeAttribute::attribute_type_GEOMETRY) {
+      bool use_instancer = (type == BL::ShaderNodeAttribute::attribute_type_INSTANCER);
+      float4 value = lookup_instance_property(b_instance, real_name, use_instancer);
+
+      /* Try finding the existing attribute value. */
+      ParamValue *param = NULL;
+
+      for (size_t i = 0; i < attributes.size(); i++) {
+        if (attributes[i].name() == name) {
+          param = &attributes[i];
+          break;
+        }
+      }
+
+      /* Replace or add the value. */
+      ParamValue new_param(name, TypeDesc::TypeFloat4, 1, &value);
+      assert(new_param.datasize() == sizeof(value));
+
+      if (!param) {
+        changed = true;
+        attributes.push_back(new_param);
+      }
+      else if (memcmp(param->data(), &value, sizeof(value)) != 0) {
+        changed = true;
+        *param = new_param;
+      }
+    }
+  }
+
+  return changed;
+}
+
 /* Object Loop */
 
 void BlenderSync::sync_objects(BL::Depsgraph &b_depsgraph,
@@ -435,10 +559,10 @@ void BlenderSync::sync_objects(BL::Depsgraph &b_depsgraph,
     sync_background_light(b_v3d, use_portal);
 
     /* handle removed data and modified pointers */
-    light_map.post_sync(scene);
-    geometry_map.post_sync(scene);
-    object_map.post_sync(scene);
-    particle_system_map.post_sync(scene);
+    light_map.post_sync();
+    geometry_map.post_sync();
+    object_map.post_sync();
+    particle_system_map.post_sync();
   }
 
   if (motion)
@@ -461,20 +585,18 @@ void BlenderSync::sync_motion(BL::RenderSettings &b_render,
   if (b_override)
     b_cam = b_override;
 
-  Camera prevcam = *(scene->camera);
-
   int frame_center = b_scene.frame_current();
   float subframe_center = b_scene.frame_subframe();
   float frame_center_delta = 0.0f;
 
   if (scene->need_motion() != Scene::MOTION_PASS &&
-      scene->camera->motion_position != Camera::MOTION_POSITION_CENTER) {
-    float shuttertime = scene->camera->shuttertime;
-    if (scene->camera->motion_position == Camera::MOTION_POSITION_END) {
+      scene->camera->get_motion_position() != Camera::MOTION_POSITION_CENTER) {
+    float shuttertime = scene->camera->get_shuttertime();
+    if (scene->camera->get_motion_position() == Camera::MOTION_POSITION_END) {
       frame_center_delta = -shuttertime * 0.5f;
     }
     else {
-      assert(scene->camera->motion_position == Camera::MOTION_POSITION_START);
+      assert(scene->camera->get_motion_position() == Camera::MOTION_POSITION_START);
       frame_center_delta = shuttertime * 0.5f;
     }
 
@@ -535,10 +657,6 @@ void BlenderSync::sync_motion(BL::RenderSettings &b_render,
   python_thread_state_restore(python_thread_state);
   b_engine.frame_set(frame_center, subframe_center);
   python_thread_state_save(python_thread_state);
-
-  /* tag camera for motion update */
-  if (scene->camera->motion_modified(prevcam))
-    scene->camera->tag_update();
 }
 
 CCL_NAMESPACE_END

intern/cycles/blender/blender_object_cull.cpp

@@ -34,10 +34,10 @@ BlenderObjectCulling::BlenderObjectCulling(Scene *scene, BL::Scene &b_scene)
   if (b_scene.render().use_simplify()) {
     PointerRNA cscene = RNA_pointer_get(&b_scene.ptr, "cycles");
 
-    use_scene_camera_cull_ = scene->camera->type != CAMERA_PANORAMA &&
+    use_scene_camera_cull_ = scene->camera->get_camera_type() != CAMERA_PANORAMA &&
                              !b_scene.render().use_multiview() &&
                              get_boolean(cscene, "use_camera_cull");
-    use_scene_distance_cull_ = scene->camera->type != CAMERA_PANORAMA &&
+    use_scene_distance_cull_ = scene->camera->get_camera_type() != CAMERA_PANORAMA &&
                                !b_scene.render().use_multiview() &&
                                get_boolean(cscene, "use_distance_cull");
 
@@ -123,7 +123,7 @@ bool BlenderObjectCulling::test_camera(Scene *scene, float3 bb[8])
 
 bool BlenderObjectCulling::test_distance(Scene *scene, float3 bb[8])
 {
-  float3 camera_position = transform_get_column(&scene->camera->matrix, 3);
+  float3 camera_position = transform_get_column(&scene->camera->get_matrix(), 3);
   float3 bb_min = make_float3(FLT_MAX, FLT_MAX, FLT_MAX),
          bb_max = make_float3(-FLT_MAX, -FLT_MAX, -FLT_MAX);
 

intern/cycles/blender/blender_particles.cpp

@@ -36,10 +36,10 @@ bool BlenderSync::sync_dupli_particle(BL::Object &b_ob,
   if (!b_psys)
     return false;
 
-  object->hide_on_missing_motion = true;
+  object->set_hide_on_missing_motion(true);
 
   /* test if we need particle data */
-  if (!object->geometry->need_attribute(scene, ATTR_STD_PARTICLE))
+  if (!object->get_geometry()->need_attribute(scene, ATTR_STD_PARTICLE))
     return false;
 
   /* don't handle child particles yet */
@@ -53,11 +53,11 @@ bool BlenderSync::sync_dupli_particle(BL::Object &b_ob,
   ParticleSystem *psys;
 
   bool first_use = !particle_system_map.is_used(key);
-  bool need_update = particle_system_map.add_or_update(
-      scene, &psys, b_ob, b_instance.object(), key);
+  bool need_update = particle_system_map.add_or_update(&psys, b_ob, b_instance.object(), key);
 
   /* no update needed? */
-  if (!need_update && !object->geometry->need_update && !scene->object_manager->need_update)
+  if (!need_update && !object->get_geometry()->is_modified() &&
+      !scene->object_manager->need_update)
     return true;
 
   /* first time used in this sync loop? clear and tag update */
@@ -81,10 +81,11 @@ bool BlenderSync::sync_dupli_particle(BL::Object &b_ob,
 
   psys->particles.push_back_slow(pa);
 
-  if (object->particle_index != psys->particles.size() - 1)
+  object->set_particle_system(psys);
+  object->set_particle_index(psys->particles.size() - 1);
+
+  if (object->particle_index_is_modified())
     scene->object_manager->tag_update(scene);
-  object->particle_system = psys;
-  object->particle_index = psys->particles.size() - 1;
 
   /* return that this object has particle data */
   return true;

intern/cycles/blender/blender_session.cpp

@@ -238,6 +238,7 @@ void BlenderSession::reset_session(BL::BlendData &b_data, BL::Depsgraph &b_depsg
    * See note on create_session().
    */
   /* sync object should be re-created */
+  delete sync;
   sync = new BlenderSync(b_engine, b_data, b_scene, scene, !background, session->progress);
 
   BL::SpaceView3D b_null_space_view3d(PointerRNA_NULL);
@@ -441,17 +442,17 @@ void BlenderSession::stamp_view_layer_metadata(Scene *scene, const string &view_
   }
 
   /* Write cryptomatte metadata. */
-  if (scene->film->cryptomatte_passes & CRYPT_OBJECT) {
+  if (scene->film->get_cryptomatte_passes() & CRYPT_OBJECT) {
     add_cryptomatte_layer(b_rr,
                           view_layer_name + ".CryptoObject",
                           scene->object_manager->get_cryptomatte_objects(scene));
   }
-  if (scene->film->cryptomatte_passes & CRYPT_MATERIAL) {
+  if (scene->film->get_cryptomatte_passes() & CRYPT_MATERIAL) {
     add_cryptomatte_layer(b_rr,
                           view_layer_name + ".CryptoMaterial",
                           scene->shader_manager->get_cryptomatte_materials(scene));
   }
-  if (scene->film->cryptomatte_passes & CRYPT_ASSET) {
+  if (scene->film->get_cryptomatte_passes() & CRYPT_ASSET) {
     add_cryptomatte_layer(b_rr,
                           view_layer_name + ".CryptoAsset",
                           scene->object_manager->get_cryptomatte_assets(scene));
@@ -472,6 +473,11 @@ void BlenderSession::render(BL::Depsgraph &b_depsgraph_)
 {
   b_depsgraph = b_depsgraph_;
 
+  if (session->progress.get_cancel()) {
+    update_status_progress();
+    return;
+  }
+
   /* set callback to write out render results */
   session->write_render_tile_cb = function_bind(&BlenderSession::write_render_tile, this, _1);
   session->update_render_tile_cb = function_bind(
@@ -502,9 +508,9 @@ void BlenderSession::render(BL::Depsgraph &b_depsgraph_)
 
   /* Set buffer params, using film settings from sync_render_passes. */
   buffer_params.passes = passes;
-  buffer_params.denoising_data_pass = scene->film->denoising_data_pass;
-  buffer_params.denoising_clean_pass = scene->film->denoising_clean_pass;
-  buffer_params.denoising_prefiltered_pass = scene->film->denoising_prefiltered_pass;
+  buffer_params.denoising_data_pass = scene->film->get_denoising_data_pass();
+  buffer_params.denoising_clean_pass = scene->film->get_denoising_clean_pass();
+  buffer_params.denoising_prefiltered_pass = scene->film->get_denoising_prefiltered_pass();
 
   BL::RenderResult::views_iterator b_view_iter;
 
@@ -541,8 +547,9 @@ void BlenderSession::render(BL::Depsgraph &b_depsgraph_)
     /* Make sure all views have different noise patterns. - hardcoded value just to make it random
      */
     if (view_index != 0) {
-      scene->integrator->seed += hash_uint2(scene->integrator->seed,
-                                            hash_uint2(view_index * 0xdeadbeef, 0));
+      int seed = scene->integrator->get_seed();
+      seed += hash_uint2(seed, hash_uint2(view_index * 0xdeadbeef, 0));
+      scene->integrator->set_seed(seed);
       scene->integrator->tag_update(scene);
     }
 
@@ -714,7 +721,7 @@ void BlenderSession::do_write_update_render_result(BL::RenderLayer &b_rlay,
   if (!buffers->copy_from_device())
     return;
 
-  float exposure = scene->film->exposure;
+  float exposure = scene->film->get_exposure();
 
   vector<float> pixels(rtile.w * rtile.h * 4);
 
@@ -831,10 +838,7 @@ void BlenderSession::synchronize(BL::Depsgraph &b_depsgraph_)
   session->set_denoising(session_params.denoising);
 
   /* Update film if denoising data was enabled or disabled. */
-  if (scene->film->denoising_data_pass != buffer_params.denoising_data_pass) {
-    scene->film->denoising_data_pass = buffer_params.denoising_data_pass;
-    scene->film->tag_update(scene);
-  }
+  scene->film->set_denoising_data_pass(buffer_params.denoising_data_pass);
 
   /* reset if needed */
   if (scene->need_reset()) {
@@ -893,7 +897,7 @@ bool BlenderSession::draw(int w, int h)
 
       sync->sync_view(b_v3d, b_rv3d, width, height);
 
-      if (scene->camera->need_update)
+      if (scene->camera->is_modified())
         reset = true;
 
       session->scene->mutex.unlock();
@@ -1108,8 +1112,11 @@ void BlenderSession::update_resumable_tile_manager(int num_samples)
   VLOG(1) << "Samples range start is " << range_start_sample << ", "
           << "number of samples to render is " << range_num_samples;
 
-  scene->integrator->start_sample = rounded_range_start_sample;
-  scene->integrator->tag_update(scene);
+  scene->integrator->set_start_sample(rounded_range_start_sample);
+
+  if (scene->integrator->is_modified()) {
+    scene->integrator->tag_update(scene);
+  }
 
   session->tile_manager.range_start_sample = rounded_range_start_sample;
   session->tile_manager.range_num_samples = rounded_range_num_samples;

intern/cycles/blender/blender_shader.cpp

@@ -42,11 +42,11 @@ typedef map<string, ConvertNode *> ProxyMap;
 
 /* Find */
 
-void BlenderSync::find_shader(BL::ID &id, vector<Shader *> &used_shaders, Shader *default_shader)
+void BlenderSync::find_shader(BL::ID &id, array<Node *> &used_shaders, Shader *default_shader)
 {
   Shader *shader = (id) ? shader_map.find(id) : default_shader;
 
-  used_shaders.push_back(shader);
+  used_shaders.push_back_slow(shader);
   shader->tag_used(scene);
 }
 
@@ -97,6 +97,53 @@ static ImageAlphaType get_image_alpha_type(BL::Image &b_image)
   return (ImageAlphaType)validate_enum_value(value, IMAGE_ALPHA_NUM_TYPES, IMAGE_ALPHA_AUTO);
 }
 
+/* Attribute name translation utilities */
+
+/* Since Eevee needs to know whether the attribute is uniform or varying
+ * at the time it compiles the shader for the material, Blender had to
+ * introduce different namespaces (types) in its attribute node. However,
+ * Cycles already has object attributes that form a uniform namespace with
+ * the more common varying attributes. Without completely reworking the
+ * attribute handling in Cycles to introduce separate namespaces (this could
+ * be especially hard for OSL which directly uses the name string), the
+ * space identifier has to be added to the attribute name as a prefix.
+ *
+ * The prefixes include a control character to ensure the user specified
+ * name can't accidentally include a special prefix.
+ */
+
+static const string_view object_attr_prefix("\x01object:");
+static const string_view instancer_attr_prefix("\x01instancer:");
+
+static ustring blender_attribute_name_add_type(const string &name, BlenderAttributeType type)
+{
+  switch (type) {
+    case BL::ShaderNodeAttribute::attribute_type_OBJECT:
+      return ustring::concat(object_attr_prefix, name);
+    case BL::ShaderNodeAttribute::attribute_type_INSTANCER:
+      return ustring::concat(instancer_attr_prefix, name);
+    default:
+      return ustring(name);
+  }
+}
+
+BlenderAttributeType blender_attribute_name_split_type(ustring name, string *r_real_name)
+{
+  string_view sname(name);
+
+  if (sname.substr(0, object_attr_prefix.size()) == object_attr_prefix) {
+    *r_real_name = sname.substr(object_attr_prefix.size());
+    return BL::ShaderNodeAttribute::attribute_type_OBJECT;
+  }
+
+  if (sname.substr(0, instancer_attr_prefix.size()) == instancer_attr_prefix) {
+    *r_real_name = sname.substr(instancer_attr_prefix.size());
+    return BL::ShaderNodeAttribute::attribute_type_INSTANCER;
+  }
+
+  return BL::ShaderNodeAttribute::attribute_type_GEOMETRY;
+}
+
 /* Graph */
 
 static BL::NodeSocket get_node_output(BL::Node &b_node, const string &name)
@@ -194,19 +241,19 @@ static void set_default_value(ShaderInput *input,
   }
 }
 
-static void get_tex_mapping(TextureMapping *mapping, BL::TexMapping &b_mapping)
+static void get_tex_mapping(TextureNode *mapping, BL::TexMapping &b_mapping)
 {
   if (!b_mapping)
     return;
 
-  mapping->translation = get_float3(b_mapping.translation());
-  mapping->rotation = get_float3(b_mapping.rotation());
-  mapping->scale = get_float3(b_mapping.scale());
-  mapping->type = (TextureMapping::Type)b_mapping.vector_type();
+  mapping->set_tex_mapping_translation(get_float3(b_mapping.translation()));
+  mapping->set_tex_mapping_rotation(get_float3(b_mapping.rotation()));
+  mapping->set_tex_mapping_scale(get_float3(b_mapping.scale()));
+  mapping->set_tex_mapping_type((TextureMapping::Type)b_mapping.vector_type());
 
-  mapping->x_mapping = (TextureMapping::Mapping)b_mapping.mapping_x();
-  mapping->y_mapping = (TextureMapping::Mapping)b_mapping.mapping_y();
-  mapping->z_mapping = (TextureMapping::Mapping)b_mapping.mapping_z();
+  mapping->set_tex_mapping_x_mapping((TextureMapping::Mapping)b_mapping.mapping_x());
+  mapping->set_tex_mapping_y_mapping((TextureMapping::Mapping)b_mapping.mapping_y());
+  mapping->set_tex_mapping_z_mapping((TextureMapping::Mapping)b_mapping.mapping_z());
 }
 
 static ShaderNode *add_node(Scene *scene,
@@ -225,34 +272,48 @@ static ShaderNode *add_node(Scene *scene,
     BL::ShaderNodeRGBCurve b_curve_node(b_node);
     BL::CurveMapping mapping(b_curve_node.mapping());
     RGBCurvesNode *curves = graph->create_node<RGBCurvesNode>();
-    curvemapping_color_to_array(mapping, curves->curves, RAMP_TABLE_SIZE, true);
-    curvemapping_minmax(mapping, true, &curves->min_x, &curves->max_x);
+    array<float3> curve_mapping_curves;
+    float min_x, max_x;
+    curvemapping_color_to_array(mapping, curve_mapping_curves, RAMP_TABLE_SIZE, true);
+    curvemapping_minmax(mapping, true, &min_x, &max_x);
+    curves->set_min_x(min_x);
+    curves->set_max_x(max_x);
+    curves->set_curves(curve_mapping_curves);
     node = curves;
   }
   if (b_node.is_a(&RNA_ShaderNodeVectorCurve)) {
     BL::ShaderNodeVectorCurve b_curve_node(b_node);
     BL::CurveMapping mapping(b_curve_node.mapping());
     VectorCurvesNode *curves = graph->create_node<VectorCurvesNode>();
-    curvemapping_color_to_array(mapping, curves->curves, RAMP_TABLE_SIZE, false);
-    curvemapping_minmax(mapping, false, &curves->min_x, &curves->max_x);
+    array<float3> curve_mapping_curves;
+    float min_x, max_x;
+    curvemapping_color_to_array(mapping, curve_mapping_curves, RAMP_TABLE_SIZE, false);
+    curvemapping_minmax(mapping, false, &min_x, &max_x);
+    curves->set_min_x(min_x);
+    curves->set_max_x(max_x);
+    curves->set_curves(curve_mapping_curves);
     node = curves;
   }
   else if (b_node.is_a(&RNA_ShaderNodeValToRGB)) {
     RGBRampNode *ramp = graph->create_node<RGBRampNode>();
     BL::ShaderNodeValToRGB b_ramp_node(b_node);
     BL::ColorRamp b_color_ramp(b_ramp_node.color_ramp());
-    colorramp_to_array(b_color_ramp, ramp->ramp, ramp->ramp_alpha, RAMP_TABLE_SIZE);
-    ramp->interpolate = b_color_ramp.interpolation() != BL::ColorRamp::interpolation_CONSTANT;
+    array<float3> ramp_values;
+    array<float> ramp_alpha;
+    colorramp_to_array(b_color_ramp, ramp_values, ramp_alpha, RAMP_TABLE_SIZE);
+    ramp->set_ramp(ramp_values);
+    ramp->set_ramp_alpha(ramp_alpha);
+    ramp->set_interpolate(b_color_ramp.interpolation() != BL::ColorRamp::interpolation_CONSTANT);
     node = ramp;
   }
   else if (b_node.is_a(&RNA_ShaderNodeRGB)) {
     ColorNode *color = graph->create_node<ColorNode>();
-    color->value = get_node_output_rgba(b_node, "Color");
+    color->set_value(get_node_output_rgba(b_node, "Color"));
     node = color;
   }
   else if (b_node.is_a(&RNA_ShaderNodeValue)) {
     ValueNode *value = graph->create_node<ValueNode>();
-    value->value = get_node_output_value(b_node, "Value");
+    value->set_value(get_node_output_value(b_node, "Value"));
     node = value;
   }
   else if (b_node.is_a(&RNA_ShaderNodeCameraData)) {
@@ -270,8 +331,8 @@ static ShaderNode *add_node(Scene *scene,
   else if (b_node.is_a(&RNA_ShaderNodeMixRGB)) {
     BL::ShaderNodeMixRGB b_mix_node(b_node);
     MixNode *mix = graph->create_node<MixNode>();
-    mix->type = (NodeMix)b_mix_node.blend_type();
-    mix->use_clamp = b_mix_node.use_clamp();
+    mix->set_mix_type((NodeMix)b_mix_node.blend_type());
+    mix->set_use_clamp(b_mix_node.use_clamp());
     node = mix;
   }
   else if (b_node.is_a(&RNA_ShaderNodeSeparateRGB)) {
@@ -301,43 +362,45 @@ static ShaderNode *add_node(Scene *scene,
   else if (b_node.is_a(&RNA_ShaderNodeMapRange)) {
     BL::ShaderNodeMapRange b_map_range_node(b_node);
     MapRangeNode *map_range_node = graph->create_node<MapRangeNode>();
-    map_range_node->clamp = b_map_range_node.clamp();
-    map_range_node->type = (NodeMapRangeType)b_map_range_node.interpolation_type();
+    map_range_node->set_clamp(b_map_range_node.clamp());
+    map_range_node->set_range_type((NodeMapRangeType)b_map_range_node.interpolation_type());
     node = map_range_node;
   }
   else if (b_node.is_a(&RNA_ShaderNodeClamp)) {
     BL::ShaderNodeClamp b_clamp_node(b_node);
     ClampNode *clamp_node = graph->create_node<ClampNode>();
-    clamp_node->type = (NodeClampType)b_clamp_node.clamp_type();
+    clamp_node->set_clamp_type((NodeClampType)b_clamp_node.clamp_type());
     node = clamp_node;
   }
   else if (b_node.is_a(&RNA_ShaderNodeMath)) {
     BL::ShaderNodeMath b_math_node(b_node);
     MathNode *math_node = graph->create_node<MathNode>();
-    math_node->type = (NodeMathType)b_math_node.operation();
-    math_node->use_clamp = b_math_node.use_clamp();
+    math_node->set_math_type((NodeMathType)b_math_node.operation());
+    math_node->set_use_clamp(b_math_node.use_clamp());
     node = math_node;
   }
   else if (b_node.is_a(&RNA_ShaderNodeVectorMath)) {
     BL::ShaderNodeVectorMath b_vector_math_node(b_node);
     VectorMathNode *vector_math_node = graph->create_node<VectorMathNode>();
-    vector_math_node->type = (NodeVectorMathType)b_vector_math_node.operation();
+    vector_math_node->set_math_type((NodeVectorMathType)b_vector_math_node.operation());
     node = vector_math_node;
   }
   else if (b_node.is_a(&RNA_ShaderNodeVectorRotate)) {
     BL::ShaderNodeVectorRotate b_vector_rotate_node(b_node);
     VectorRotateNode *vector_rotate_node = graph->create_node<VectorRotateNode>();
-    vector_rotate_node->type = (NodeVectorRotateType)b_vector_rotate_node.rotation_type();
-    vector_rotate_node->invert = b_vector_rotate_node.invert();
+    vector_rotate_node->set_rotate_type(
+        (NodeVectorRotateType)b_vector_rotate_node.rotation_type());
+    vector_rotate_node->set_invert(b_vector_rotate_node.invert());
     node = vector_rotate_node;
   }
   else if (b_node.is_a(&RNA_ShaderNodeVectorTransform)) {
     BL::ShaderNodeVectorTransform b_vector_transform_node(b_node);
     VectorTransformNode *vtransform = graph->create_node<VectorTransformNode>();
-    vtransform->type = (NodeVectorTransformType)b_vector_transform_node.vector_type();
-    vtransform->convert_from = (NodeVectorTransformConvertSpace)
-                                   b_vector_transform_node.convert_from();
-    vtransform->convert_to = (NodeVectorTransformConvertSpace)b_vector_transform_node.convert_to();
+    vtransform->set_transform_type((NodeVectorTransformType)b_vector_transform_node.vector_type());
+    vtransform->set_convert_from(
+        (NodeVectorTransformConvertSpace)b_vector_transform_node.convert_from());
+    vtransform->set_convert_to(
+        (NodeVectorTransformConvertSpace)b_vector_transform_node.convert_to());
     node = vtransform;
   }
   else if (b_node.is_a(&RNA_ShaderNodeNormal)) {
@@ -345,13 +408,13 @@ static ShaderNode *add_node(Scene *scene,
     b_node.outputs.begin(out_it);
 
     NormalNode *norm = graph->create_node<NormalNode>();
-    norm->direction = get_node_output_vector(b_node, "Normal");
+    norm->set_direction(get_node_output_vector(b_node, "Normal"));
     node = norm;
   }
   else if (b_node.is_a(&RNA_ShaderNodeMapping)) {
     BL::ShaderNodeMapping b_mapping_node(b_node);
     MappingNode *mapping = graph->create_node<MappingNode>();
-    mapping->type = (NodeMappingType)b_mapping_node.vector_type();
+    mapping->set_mapping_type((NodeMappingType)b_mapping_node.vector_type());
     node = mapping;
   }
   else if (b_node.is_a(&RNA_ShaderNodeFresnel)) {
@@ -369,7 +432,8 @@ static ShaderNode *add_node(Scene *scene,
   else if (b_node.is_a(&RNA_ShaderNodeAttribute)) {
     BL::ShaderNodeAttribute b_attr_node(b_node);
     AttributeNode *attr = graph->create_node<AttributeNode>();
-    attr->attribute = b_attr_node.attribute_name();
+    attr->set_attribute(blender_attribute_name_add_type(b_attr_node.attribute_name(),
+                                                        b_attr_node.attribute_type()));
     node = attr;
   }
   else if (b_node.is_a(&RNA_ShaderNodeBackground)) {
@@ -384,16 +448,16 @@ static ShaderNode *add_node(Scene *scene,
 
     switch (b_aniso_node.distribution()) {
       case BL::ShaderNodeBsdfAnisotropic::distribution_BECKMANN:
-        aniso->distribution = CLOSURE_BSDF_MICROFACET_BECKMANN_ID;
+        aniso->set_distribution(CLOSURE_BSDF_MICROFACET_BECKMANN_ID);
         break;
       case BL::ShaderNodeBsdfAnisotropic::distribution_GGX:
-        aniso->distribution = CLOSURE_BSDF_MICROFACET_GGX_ID;
+        aniso->set_distribution(CLOSURE_BSDF_MICROFACET_GGX_ID);
         break;
       case BL::ShaderNodeBsdfAnisotropic::distribution_MULTI_GGX:
-        aniso->distribution = CLOSURE_BSDF_MICROFACET_MULTI_GGX_ID;
+        aniso->set_distribution(CLOSURE_BSDF_MICROFACET_MULTI_GGX_ID);
         break;
       case BL::ShaderNodeBsdfAnisotropic::distribution_ASHIKHMIN_SHIRLEY:
-        aniso->distribution = CLOSURE_BSDF_ASHIKHMIN_SHIRLEY_ID;
+        aniso->set_distribution(CLOSURE_BSDF_ASHIKHMIN_SHIRLEY_ID);
         break;
     }
 
@@ -409,16 +473,16 @@ static ShaderNode *add_node(Scene *scene,
 
     switch (b_subsurface_node.falloff()) {
       case BL::ShaderNodeSubsurfaceScattering::falloff_CUBIC:
-        subsurface->falloff = CLOSURE_BSSRDF_CUBIC_ID;
+        subsurface->set_falloff(CLOSURE_BSSRDF_CUBIC_ID);
         break;
       case BL::ShaderNodeSubsurfaceScattering::falloff_GAUSSIAN:
-        subsurface->falloff = CLOSURE_BSSRDF_GAUSSIAN_ID;
+        subsurface->set_falloff(CLOSURE_BSSRDF_GAUSSIAN_ID);
         break;
       case BL::ShaderNodeSubsurfaceScattering::falloff_BURLEY:
-        subsurface->falloff = CLOSURE_BSSRDF_BURLEY_ID;
+        subsurface->set_falloff(CLOSURE_BSSRDF_BURLEY_ID);
         break;
       case BL::ShaderNodeSubsurfaceScattering::falloff_RANDOM_WALK:
-        subsurface->falloff = CLOSURE_BSSRDF_RANDOM_WALK_ID;
+        subsurface->set_falloff(CLOSURE_BSSRDF_RANDOM_WALK_ID);
         break;
     }
 
@@ -430,19 +494,19 @@ static ShaderNode *add_node(Scene *scene,
 
     switch (b_glossy_node.distribution()) {
       case BL::ShaderNodeBsdfGlossy::distribution_SHARP:
-        glossy->distribution = CLOSURE_BSDF_REFLECTION_ID;
+        glossy->set_distribution(CLOSURE_BSDF_REFLECTION_ID);
         break;
       case BL::ShaderNodeBsdfGlossy::distribution_BECKMANN:
-        glossy->distribution = CLOSURE_BSDF_MICROFACET_BECKMANN_ID;
+        glossy->set_distribution(CLOSURE_BSDF_MICROFACET_BECKMANN_ID);
         break;
       case BL::ShaderNodeBsdfGlossy::distribution_GGX:
-        glossy->distribution = CLOSURE_BSDF_MICROFACET_GGX_ID;
+        glossy->set_distribution(CLOSURE_BSDF_MICROFACET_GGX_ID);
         break;
       case BL::ShaderNodeBsdfGlossy::distribution_ASHIKHMIN_SHIRLEY:
-        glossy->distribution = CLOSURE_BSDF_ASHIKHMIN_SHIRLEY_ID;
+        glossy->set_distribution(CLOSURE_BSDF_ASHIKHMIN_SHIRLEY_ID);
         break;
       case BL::ShaderNodeBsdfGlossy::distribution_MULTI_GGX:
-        glossy->distribution = CLOSURE_BSDF_MICROFACET_MULTI_GGX_ID;
+        glossy->set_distribution(CLOSURE_BSDF_MICROFACET_MULTI_GGX_ID);
         break;
     }
     node = glossy;
@@ -452,16 +516,16 @@ static ShaderNode *add_node(Scene *scene,
     GlassBsdfNode *glass = graph->create_node<GlassBsdfNode>();
     switch (b_glass_node.distribution()) {
       case BL::ShaderNodeBsdfGlass::distribution_SHARP:
-        glass->distribution = CLOSURE_BSDF_SHARP_GLASS_ID;
+        glass->set_distribution(CLOSURE_BSDF_SHARP_GLASS_ID);
         break;
       case BL::ShaderNodeBsdfGlass::distribution_BECKMANN:
-        glass->distribution = CLOSURE_BSDF_MICROFACET_BECKMANN_GLASS_ID;
+        glass->set_distribution(CLOSURE_BSDF_MICROFACET_BECKMANN_GLASS_ID);
         break;
       case BL::ShaderNodeBsdfGlass::distribution_GGX:
-        glass->distribution = CLOSURE_BSDF_MICROFACET_GGX_GLASS_ID;
+        glass->set_distribution(CLOSURE_BSDF_MICROFACET_GGX_GLASS_ID);
         break;
       case BL::ShaderNodeBsdfGlass::distribution_MULTI_GGX:
-        glass->distribution = CLOSURE_BSDF_MICROFACET_MULTI_GGX_GLASS_ID;
+        glass->set_distribution(CLOSURE_BSDF_MICROFACET_MULTI_GGX_GLASS_ID);
         break;
     }
     node = glass;
@@ -471,13 +535,13 @@ static ShaderNode *add_node(Scene *scene,
     RefractionBsdfNode *refraction = graph->create_node<RefractionBsdfNode>();
     switch (b_refraction_node.distribution()) {
       case BL::ShaderNodeBsdfRefraction::distribution_SHARP:
-        refraction->distribution = CLOSURE_BSDF_REFRACTION_ID;
+        refraction->set_distribution(CLOSURE_BSDF_REFRACTION_ID);
         break;
       case BL::ShaderNodeBsdfRefraction::distribution_BECKMANN:
-        refraction->distribution = CLOSURE_BSDF_MICROFACET_BECKMANN_REFRACTION_ID;
+        refraction->set_distribution(CLOSURE_BSDF_MICROFACET_BECKMANN_REFRACTION_ID);
         break;
       case BL::ShaderNodeBsdfRefraction::distribution_GGX:
-        refraction->distribution = CLOSURE_BSDF_MICROFACET_GGX_REFRACTION_ID;
+        refraction->set_distribution(CLOSURE_BSDF_MICROFACET_GGX_REFRACTION_ID);
         break;
     }
     node = refraction;
@@ -487,10 +551,10 @@ static ShaderNode *add_node(Scene *scene,
     ToonBsdfNode *toon = graph->create_node<ToonBsdfNode>();
     switch (b_toon_node.component()) {
       case BL::ShaderNodeBsdfToon::component_DIFFUSE:
-        toon->component = CLOSURE_BSDF_DIFFUSE_TOON_ID;
+        toon->set_component(CLOSURE_BSDF_DIFFUSE_TOON_ID);
         break;
       case BL::ShaderNodeBsdfToon::component_GLOSSY:
-        toon->component = CLOSURE_BSDF_GLOSSY_TOON_ID;
+        toon->set_component(CLOSURE_BSDF_GLOSSY_TOON_ID);
         break;
     }
     node = toon;
@@ -500,10 +564,10 @@ static ShaderNode *add_node(Scene *scene,
     HairBsdfNode *hair = graph->create_node<HairBsdfNode>();
     switch (b_hair_node.component()) {
       case BL::ShaderNodeBsdfHair::component_Reflection:
-        hair->component = CLOSURE_BSDF_HAIR_REFLECTION_ID;
+        hair->set_component(CLOSURE_BSDF_HAIR_REFLECTION_ID);
         break;
       case BL::ShaderNodeBsdfHair::component_Transmission:
-        hair->component = CLOSURE_BSDF_HAIR_TRANSMISSION_ID;
+        hair->set_component(CLOSURE_BSDF_HAIR_TRANSMISSION_ID);
         break;
     }
     node = hair;
@@ -511,11 +575,11 @@ static ShaderNode *add_node(Scene *scene,
   else if (b_node.is_a(&RNA_ShaderNodeBsdfHairPrincipled)) {
     BL::ShaderNodeBsdfHairPrincipled b_principled_hair_node(b_node);
     PrincipledHairBsdfNode *principled_hair = graph->create_node<PrincipledHairBsdfNode>();
-    principled_hair->parametrization = (NodePrincipledHairParametrization)get_enum(
-        b_principled_hair_node.ptr,
-        "parametrization",
-        NODE_PRINCIPLED_HAIR_NUM,
-        NODE_PRINCIPLED_HAIR_REFLECTANCE);
+    principled_hair->set_parametrization(
+        (NodePrincipledHairParametrization)get_enum(b_principled_hair_node.ptr,
+                                                    "parametrization",
+                                                    NODE_PRINCIPLED_HAIR_NUM,
+                                                    NODE_PRINCIPLED_HAIR_REFLECTANCE));
     node = principled_hair;
   }
   else if (b_node.is_a(&RNA_ShaderNodeBsdfPrincipled)) {
@@ -523,18 +587,18 @@ static ShaderNode *add_node(Scene *scene,
     PrincipledBsdfNode *principled = graph->create_node<PrincipledBsdfNode>();
     switch (b_principled_node.distribution()) {
       case BL::ShaderNodeBsdfPrincipled::distribution_GGX:
-        principled->distribution = CLOSURE_BSDF_MICROFACET_GGX_GLASS_ID;
+        principled->set_distribution(CLOSURE_BSDF_MICROFACET_GGX_GLASS_ID);
         break;
       case BL::ShaderNodeBsdfPrincipled::distribution_MULTI_GGX:
-        principled->distribution = CLOSURE_BSDF_MICROFACET_MULTI_GGX_GLASS_ID;
+        principled->set_distribution(CLOSURE_BSDF_MICROFACET_MULTI_GGX_GLASS_ID);
         break;
     }
     switch (b_principled_node.subsurface_method()) {
       case BL::ShaderNodeBsdfPrincipled::subsurface_method_BURLEY:
-        principled->subsurface_method = CLOSURE_BSSRDF_PRINCIPLED_ID;
+        principled->set_subsurface_method(CLOSURE_BSSRDF_PRINCIPLED_ID);
         break;
       case BL::ShaderNodeBsdfPrincipled::subsurface_method_RANDOM_WALK:
-        principled->subsurface_method = CLOSURE_BSSRDF_PRINCIPLED_RANDOM_WALK_ID;
+        principled->set_subsurface_method(CLOSURE_BSSRDF_PRINCIPLED_RANDOM_WALK_ID);
         break;
     }
     node = principled;
@@ -554,9 +618,9 @@ static ShaderNode *add_node(Scene *scene,
   else if (b_node.is_a(&RNA_ShaderNodeAmbientOcclusion)) {
     BL::ShaderNodeAmbientOcclusion b_ao_node(b_node);
     AmbientOcclusionNode *ao = graph->create_node<AmbientOcclusionNode>();
-    ao->samples = b_ao_node.samples();
-    ao->inside = b_ao_node.inside();
-    ao->only_local = b_ao_node.only_local();
+    ao->set_samples(b_ao_node.samples());
+    ao->set_inside(b_ao_node.inside());
+    ao->set_only_local(b_ao_node.only_local());
     node = ao;
   }
   else if (b_node.is_a(&RNA_ShaderNodeVolumeScatter)) {
@@ -575,7 +639,7 @@ static ShaderNode *add_node(Scene *scene,
   else if (b_node.is_a(&RNA_ShaderNodeWireframe)) {
     BL::ShaderNodeWireframe b_wireframe_node(b_node);
     WireframeNode *wire = graph->create_node<WireframeNode>();
-    wire->use_pixel_size = b_wireframe_node.use_pixel_size();
+    wire->set_use_pixel_size(b_wireframe_node.use_pixel_size());
     node = wire;
   }
   else if (b_node.is_a(&RNA_ShaderNodeWavelength)) {
@@ -605,13 +669,13 @@ static ShaderNode *add_node(Scene *scene,
   else if (b_node.is_a(&RNA_ShaderNodeVertexColor)) {
     BL::ShaderNodeVertexColor b_vertex_color_node(b_node);
     VertexColorNode *vertex_color_node = graph->create_node<VertexColorNode>();
-    vertex_color_node->layer_name = b_vertex_color_node.layer_name();
+    vertex_color_node->set_layer_name(ustring(b_vertex_color_node.layer_name()));
     node = vertex_color_node;
   }
   else if (b_node.is_a(&RNA_ShaderNodeBump)) {
     BL::ShaderNodeBump b_bump_node(b_node);
     BumpNode *bump = graph->create_node<BumpNode>();
-    bump->invert = b_bump_node.invert();
+    bump->set_invert(b_bump_node.invert());
     node = bump;
   }
   else if (b_node.is_a(&RNA_ShaderNodeScript)) {
@@ -644,25 +708,26 @@ static ShaderNode *add_node(Scene *scene,
     BL::ImageUser b_image_user(b_image_node.image_user());
     ImageTextureNode *image = graph->create_node<ImageTextureNode>();
 
-    image->interpolation = get_image_interpolation(b_image_node);
-    image->extension = get_image_extension(b_image_node);
-    image->projection = (NodeImageProjection)b_image_node.projection();
-    image->projection_blend = b_image_node.projection_blend();
+    image->set_interpolation(get_image_interpolation(b_image_node));
+    image->set_extension(get_image_extension(b_image_node));
+    image->set_projection((NodeImageProjection)b_image_node.projection());
+    image->set_projection_blend(b_image_node.projection_blend());
     BL::TexMapping b_texture_mapping(b_image_node.texture_mapping());
-    get_tex_mapping(&image->tex_mapping, b_texture_mapping);
+    get_tex_mapping(image, b_texture_mapping);
 
     if (b_image) {
       PointerRNA colorspace_ptr = b_image.colorspace_settings().ptr;
-      image->colorspace = get_enum_identifier(colorspace_ptr, "name");
+      image->set_colorspace(ustring(get_enum_identifier(colorspace_ptr, "name")));
 
-      image->animated = b_image_node.image_user().use_auto_refresh();
-      image->alpha_type = get_image_alpha_type(b_image);
+      image->set_animated(b_image_node.image_user().use_auto_refresh());
+      image->set_alpha_type(get_image_alpha_type(b_image));
 
-      image->tiles.clear();
+      array<int> tiles;
       BL::Image::tiles_iterator b_iter;
       for (b_image.tiles.begin(b_iter); b_iter != b_image.tiles.end(); ++b_iter) {
-        image->tiles.push_back(b_iter->number());
+        tiles.push_back_slow(b_iter->number());
       }
+      image->set_tiles(tiles);
 
       /* builtin images will use callback-based reading because
        * they could only be loaded correct from blender side
@@ -684,8 +749,9 @@ static ShaderNode *add_node(Scene *scene,
             new BlenderImageLoader(b_image, image_frame), image->image_params());
       }
       else {
-        image->filename = image_user_file_path(
-            b_image_user, b_image, b_scene.frame_current(), true);
+        ustring filename = ustring(
+            image_user_file_path(b_image_user, b_image, b_scene.frame_current(), true));
+        image->set_filename(filename);
       }
     }
     node = image;
@@ -696,17 +762,17 @@ static ShaderNode *add_node(Scene *scene,
     BL::ImageUser b_image_user(b_env_node.image_user());
     EnvironmentTextureNode *env = graph->create_node<EnvironmentTextureNode>();
 
-    env->interpolation = get_image_interpolation(b_env_node);
-    env->projection = (NodeEnvironmentProjection)b_env_node.projection();
+    env->set_interpolation(get_image_interpolation(b_env_node));
+    env->set_projection((NodeEnvironmentProjection)b_env_node.projection());
     BL::TexMapping b_texture_mapping(b_env_node.texture_mapping());
-    get_tex_mapping(&env->tex_mapping, b_texture_mapping);
+    get_tex_mapping(env, b_texture_mapping);
 
     if (b_image) {
       PointerRNA colorspace_ptr = b_image.colorspace_settings().ptr;
-      env->colorspace = get_enum_identifier(colorspace_ptr, "name");
+      env->set_colorspace(ustring(get_enum_identifier(colorspace_ptr, "name")));
 
-      env->animated = b_env_node.image_user().use_auto_refresh();
-      env->alpha_type = get_image_alpha_type(b_image);
+      env->set_animated(b_env_node.image_user().use_auto_refresh());
+      env->set_alpha_type(get_image_alpha_type(b_image));
 
       bool is_builtin = b_image.packed_file() || b_image.source() == BL::Image::source_GENERATED ||
                         b_image.source() == BL::Image::source_MOVIE ||
@@ -719,8 +785,8 @@ static ShaderNode *add_node(Scene *scene,
                                                       env->image_params());
       }
       else {
-        env->filename = image_user_file_path(
-            b_image_user, b_image, b_scene.frame_current(), false);
+        env->set_filename(
+            ustring(image_user_file_path(b_image_user, b_image, b_scene.frame_current(), false)));
       }
     }
     node = env;
@@ -728,103 +794,103 @@ static ShaderNode *add_node(Scene *scene,
   else if (b_node.is_a(&RNA_ShaderNodeTexGradient)) {
     BL::ShaderNodeTexGradient b_gradient_node(b_node);
     GradientTextureNode *gradient = graph->create_node<GradientTextureNode>();
-    gradient->type = (NodeGradientType)b_gradient_node.gradient_type();
+    gradient->set_gradient_type((NodeGradientType)b_gradient_node.gradient_type());
     BL::TexMapping b_texture_mapping(b_gradient_node.texture_mapping());
-    get_tex_mapping(&gradient->tex_mapping, b_texture_mapping);
+    get_tex_mapping(gradient, b_texture_mapping);
     node = gradient;
   }
   else if (b_node.is_a(&RNA_ShaderNodeTexVoronoi)) {
     BL::ShaderNodeTexVoronoi b_voronoi_node(b_node);
     VoronoiTextureNode *voronoi = graph->create_node<VoronoiTextureNode>();
-    voronoi->dimensions = b_voronoi_node.voronoi_dimensions();
-    voronoi->feature = (NodeVoronoiFeature)b_voronoi_node.feature();
-    voronoi->metric = (NodeVoronoiDistanceMetric)b_voronoi_node.distance();
+    voronoi->set_dimensions(b_voronoi_node.voronoi_dimensions());
+    voronoi->set_feature((NodeVoronoiFeature)b_voronoi_node.feature());
+    voronoi->set_metric((NodeVoronoiDistanceMetric)b_voronoi_node.distance());
     BL::TexMapping b_texture_mapping(b_voronoi_node.texture_mapping());
-    get_tex_mapping(&voronoi->tex_mapping, b_texture_mapping);
+    get_tex_mapping(voronoi, b_texture_mapping);
     node = voronoi;
   }
   else if (b_node.is_a(&RNA_ShaderNodeTexMagic)) {
     BL::ShaderNodeTexMagic b_magic_node(b_node);
     MagicTextureNode *magic = graph->create_node<MagicTextureNode>();
-    magic->depth = b_magic_node.turbulence_depth();
+    magic->set_depth(b_magic_node.turbulence_depth());
     BL::TexMapping b_texture_mapping(b_magic_node.texture_mapping());
-    get_tex_mapping(&magic->tex_mapping, b_texture_mapping);
+    get_tex_mapping(magic, b_texture_mapping);
     node = magic;
   }
   else if (b_node.is_a(&RNA_ShaderNodeTexWave)) {
     BL::ShaderNodeTexWave b_wave_node(b_node);
     WaveTextureNode *wave = graph->create_node<WaveTextureNode>();
-    wave->type = (NodeWaveType)b_wave_node.wave_type();
-    wave->bands_direction = (NodeWaveBandsDirection)b_wave_node.bands_direction();
-    wave->rings_direction = (NodeWaveRingsDirection)b_wave_node.rings_direction();
-    wave->profile = (NodeWaveProfile)b_wave_node.wave_profile();
+    wave->set_wave_type((NodeWaveType)b_wave_node.wave_type());
+    wave->set_bands_direction((NodeWaveBandsDirection)b_wave_node.bands_direction());
+    wave->set_rings_direction((NodeWaveRingsDirection)b_wave_node.rings_direction());
+    wave->set_profile((NodeWaveProfile)b_wave_node.wave_profile());
     BL::TexMapping b_texture_mapping(b_wave_node.texture_mapping());
-    get_tex_mapping(&wave->tex_mapping, b_texture_mapping);
+    get_tex_mapping(wave, b_texture_mapping);
     node = wave;
   }
   else if (b_node.is_a(&RNA_ShaderNodeTexChecker)) {
     BL::ShaderNodeTexChecker b_checker_node(b_node);
     CheckerTextureNode *checker = graph->create_node<CheckerTextureNode>();
     BL::TexMapping b_texture_mapping(b_checker_node.texture_mapping());
-    get_tex_mapping(&checker->tex_mapping, b_texture_mapping);
+    get_tex_mapping(checker, b_texture_mapping);
     node = checker;
   }
   else if (b_node.is_a(&RNA_ShaderNodeTexBrick)) {
     BL::ShaderNodeTexBrick b_brick_node(b_node);
     BrickTextureNode *brick = graph->create_node<BrickTextureNode>();
-    brick->offset = b_brick_node.offset();
-    brick->offset_frequency = b_brick_node.offset_frequency();
-    brick->squash = b_brick_node.squash();
-    brick->squash_frequency = b_brick_node.squash_frequency();
+    brick->set_offset(b_brick_node.offset());
+    brick->set_offset_frequency(b_brick_node.offset_frequency());
+    brick->set_squash(b_brick_node.squash());
+    brick->set_squash_frequency(b_brick_node.squash_frequency());
     BL::TexMapping b_texture_mapping(b_brick_node.texture_mapping());
-    get_tex_mapping(&brick->tex_mapping, b_texture_mapping);
+    get_tex_mapping(brick, b_texture_mapping);
     node = brick;
   }
   else if (b_node.is_a(&RNA_ShaderNodeTexNoise)) {
     BL::ShaderNodeTexNoise b_noise_node(b_node);
     NoiseTextureNode *noise = graph->create_node<NoiseTextureNode>();
-    noise->dimensions = b_noise_node.noise_dimensions();
+    noise->set_dimensions(b_noise_node.noise_dimensions());
     BL::TexMapping b_texture_mapping(b_noise_node.texture_mapping());
-    get_tex_mapping(&noise->tex_mapping, b_texture_mapping);
+    get_tex_mapping(noise, b_texture_mapping);
     node = noise;
   }
   else if (b_node.is_a(&RNA_ShaderNodeTexMusgrave)) {
     BL::ShaderNodeTexMusgrave b_musgrave_node(b_node);
     MusgraveTextureNode *musgrave_node = graph->create_node<MusgraveTextureNode>();
-    musgrave_node->type = (NodeMusgraveType)b_musgrave_node.musgrave_type();
-    musgrave_node->dimensions = b_musgrave_node.musgrave_dimensions();
+    musgrave_node->set_musgrave_type((NodeMusgraveType)b_musgrave_node.musgrave_type());
+    musgrave_node->set_dimensions(b_musgrave_node.musgrave_dimensions());
     BL::TexMapping b_texture_mapping(b_musgrave_node.texture_mapping());
-    get_tex_mapping(&musgrave_node->tex_mapping, b_texture_mapping);
+    get_tex_mapping(musgrave_node, b_texture_mapping);
     node = musgrave_node;
   }
   else if (b_node.is_a(&RNA_ShaderNodeTexCoord)) {
     BL::ShaderNodeTexCoord b_tex_coord_node(b_node);
     TextureCoordinateNode *tex_coord = graph->create_node<TextureCoordinateNode>();
-    tex_coord->from_dupli = b_tex_coord_node.from_instancer();
+    tex_coord->set_from_dupli(b_tex_coord_node.from_instancer());
     if (b_tex_coord_node.object()) {
-      tex_coord->use_transform = true;
-      tex_coord->ob_tfm = get_transform(b_tex_coord_node.object().matrix_world());
+      tex_coord->set_use_transform(true);
+      tex_coord->set_ob_tfm(get_transform(b_tex_coord_node.object().matrix_world()));
     }
     node = tex_coord;
   }
   else if (b_node.is_a(&RNA_ShaderNodeTexSky)) {
     BL::ShaderNodeTexSky b_sky_node(b_node);
     SkyTextureNode *sky = graph->create_node<SkyTextureNode>();
-    sky->type = (NodeSkyType)b_sky_node.sky_type();
-    sky->sun_direction = normalize(get_float3(b_sky_node.sun_direction()));
-    sky->turbidity = b_sky_node.turbidity();
-    sky->ground_albedo = b_sky_node.ground_albedo();
-    sky->sun_disc = b_sky_node.sun_disc();
-    sky->sun_size = b_sky_node.sun_size();
-    sky->sun_intensity = b_sky_node.sun_intensity();
-    sky->sun_elevation = b_sky_node.sun_elevation();
-    sky->sun_rotation = b_sky_node.sun_rotation();
-    sky->altitude = 1000.0f * b_sky_node.altitude();
-    sky->air_density = b_sky_node.air_density();
-    sky->dust_density = b_sky_node.dust_density();
-    sky->ozone_density = b_sky_node.ozone_density();
+    sky->set_sky_type((NodeSkyType)b_sky_node.sky_type());
+    sky->set_sun_direction(normalize(get_float3(b_sky_node.sun_direction())));
+    sky->set_turbidity(b_sky_node.turbidity());
+    sky->set_ground_albedo(b_sky_node.ground_albedo());
+    sky->set_sun_disc(b_sky_node.sun_disc());
+    sky->set_sun_size(b_sky_node.sun_size());
+    sky->set_sun_intensity(b_sky_node.sun_intensity());
+    sky->set_sun_elevation(b_sky_node.sun_elevation());
+    sky->set_sun_rotation(b_sky_node.sun_rotation());
+    sky->set_altitude(1000.0f * b_sky_node.altitude());
+    sky->set_air_density(b_sky_node.air_density());
+    sky->set_dust_density(b_sky_node.dust_density());
+    sky->set_ozone_density(b_sky_node.ozone_density());
     BL::TexMapping b_texture_mapping(b_sky_node.texture_mapping());
-    get_tex_mapping(&sky->tex_mapping, b_texture_mapping);
+    get_tex_mapping(sky, b_texture_mapping);
     node = sky;
   }
   else if (b_node.is_a(&RNA_ShaderNodeTexIES)) {
@@ -832,13 +898,14 @@ static ShaderNode *add_node(Scene *scene,
     IESLightNode *ies = graph->create_node<IESLightNode>();
     switch (b_ies_node.mode()) {
       case BL::ShaderNodeTexIES::mode_EXTERNAL:
-        ies->filename = blender_absolute_path(b_data, b_ntree, b_ies_node.filepath());
+        ies->set_filename(ustring(blender_absolute_path(b_data, b_ntree, b_ies_node.filepath())));
         break;
       case BL::ShaderNodeTexIES::mode_INTERNAL:
-        ies->ies = get_text_datablock_content(b_ies_node.ies().ptr);
-        if (ies->ies.empty()) {
-          ies->ies = "\n";
+        ustring ies_content = ustring(get_text_datablock_content(b_ies_node.ies().ptr));
+        if (ies_content.empty()) {
+          ies_content = "\n";
         }
+        ies->set_ies(ies_content);
         break;
     }
     node = ies;
@@ -846,36 +913,36 @@ static ShaderNode *add_node(Scene *scene,
   else if (b_node.is_a(&RNA_ShaderNodeTexWhiteNoise)) {
     BL::ShaderNodeTexWhiteNoise b_tex_white_noise_node(b_node);
     WhiteNoiseTextureNode *white_noise_node = graph->create_node<WhiteNoiseTextureNode>();
-    white_noise_node->dimensions = b_tex_white_noise_node.noise_dimensions();
+    white_noise_node->set_dimensions(b_tex_white_noise_node.noise_dimensions());
     node = white_noise_node;
   }
   else if (b_node.is_a(&RNA_ShaderNodeNormalMap)) {
     BL::ShaderNodeNormalMap b_normal_map_node(b_node);
     NormalMapNode *nmap = graph->create_node<NormalMapNode>();
-    nmap->space = (NodeNormalMapSpace)b_normal_map_node.space();
-    nmap->attribute = b_normal_map_node.uv_map();
+    nmap->set_space((NodeNormalMapSpace)b_normal_map_node.space());
+    nmap->set_attribute(ustring(b_normal_map_node.uv_map()));
     node = nmap;
   }
   else if (b_node.is_a(&RNA_ShaderNodeTangent)) {
     BL::ShaderNodeTangent b_tangent_node(b_node);
     TangentNode *tangent = graph->create_node<TangentNode>();
-    tangent->direction_type = (NodeTangentDirectionType)b_tangent_node.direction_type();
-    tangent->axis = (NodeTangentAxis)b_tangent_node.axis();
-    tangent->attribute = b_tangent_node.uv_map();
+    tangent->set_direction_type((NodeTangentDirectionType)b_tangent_node.direction_type());
+    tangent->set_axis((NodeTangentAxis)b_tangent_node.axis());
+    tangent->set_attribute(ustring(b_tangent_node.uv_map()));
     node = tangent;
   }
   else if (b_node.is_a(&RNA_ShaderNodeUVMap)) {
     BL::ShaderNodeUVMap b_uvmap_node(b_node);
     UVMapNode *uvm = graph->create_node<UVMapNode>();
-    uvm->attribute = b_uvmap_node.uv_map();
-    uvm->from_dupli = b_uvmap_node.from_instancer();
+    uvm->set_attribute(ustring(b_uvmap_node.uv_map()));
+    uvm->set_from_dupli(b_uvmap_node.from_instancer());
     node = uvm;
   }
   else if (b_node.is_a(&RNA_ShaderNodeTexPointDensity)) {
     BL::ShaderNodeTexPointDensity b_point_density_node(b_node);
     PointDensityTextureNode *point_density = graph->create_node<PointDensityTextureNode>();
-    point_density->space = (NodeTexVoxelSpace)b_point_density_node.space();
-    point_density->interpolation = get_image_interpolation(b_point_density_node);
+    point_density->set_space((NodeTexVoxelSpace)b_point_density_node.space());
+    point_density->set_interpolation(get_image_interpolation(b_point_density_node));
     point_density->handle = scene->image_manager->add_image(
         new BlenderPointDensityLoader(b_depsgraph, b_point_density_node),
         point_density->image_params());
@@ -892,33 +959,33 @@ static ShaderNode *add_node(Scene *scene,
     if (b_ob) {
       float3 loc, size;
       point_density_texture_space(b_depsgraph, b_point_density_node, loc, size);
-      point_density->tfm = transform_translate(-loc) * transform_scale(size) *
-                           transform_inverse(get_transform(b_ob.matrix_world()));
+      point_density->set_tfm(transform_translate(-loc) * transform_scale(size) *
+                             transform_inverse(get_transform(b_ob.matrix_world())));
     }
   }
   else if (b_node.is_a(&RNA_ShaderNodeBevel)) {
     BL::ShaderNodeBevel b_bevel_node(b_node);
     BevelNode *bevel = graph->create_node<BevelNode>();
-    bevel->samples = b_bevel_node.samples();
+    bevel->set_samples(b_bevel_node.samples());
     node = bevel;
   }
   else if (b_node.is_a(&RNA_ShaderNodeDisplacement)) {
     BL::ShaderNodeDisplacement b_disp_node(b_node);
     DisplacementNode *disp = graph->create_node<DisplacementNode>();
-    disp->space = (NodeNormalMapSpace)b_disp_node.space();
+    disp->set_space((NodeNormalMapSpace)b_disp_node.space());
     node = disp;
   }
   else if (b_node.is_a(&RNA_ShaderNodeVectorDisplacement)) {
     BL::ShaderNodeVectorDisplacement b_disp_node(b_node);
     VectorDisplacementNode *disp = graph->create_node<VectorDisplacementNode>();
-    disp->space = (NodeNormalMapSpace)b_disp_node.space();
-    disp->attribute = "";
+    disp->set_space((NodeNormalMapSpace)b_disp_node.space());
+    disp->set_attribute(ustring(""));
     node = disp;
   }
   else if (b_node.is_a(&RNA_ShaderNodeOutputAOV)) {
     BL::ShaderNodeOutputAOV b_aov_node(b_node);
     OutputAOVNode *aov = graph->create_node<OutputAOVNode>();
-    aov->name = b_aov_node.name();
+    aov->set_name(ustring(b_aov_node.name()));
     node = aov;
   }
 
@@ -1241,11 +1308,11 @@ void BlenderSync::sync_materials(BL::Depsgraph &b_depsgraph, bool update_all)
     Shader *shader;
 
     /* test if we need to sync */
-    if (shader_map.add_or_update(scene, &shader, b_mat) || update_all) {
+    if (shader_map.add_or_update(&shader, b_mat) || update_all) {
       ShaderGraph *graph = new ShaderGraph();
 
       shader->name = b_mat.name().c_str();
-      shader->pass_id = b_mat.pass_index();
+      shader->set_pass_id(b_mat.pass_index());
 
       /* create nodes */
       if (b_mat.use_nodes() && b_mat.node_tree()) {
@@ -1255,7 +1322,7 @@ void BlenderSync::sync_materials(BL::Depsgraph &b_depsgraph, bool update_all)
       }
       else {
         DiffuseBsdfNode *diffuse = graph->create_node<DiffuseBsdfNode>();
-        diffuse->color = get_float3(b_mat.diffuse_color());
+        diffuse->set_color(get_float3(b_mat.diffuse_color()));
         graph->add(diffuse);
 
         ShaderNode *out = graph->output();
@@ -1264,13 +1331,13 @@ void BlenderSync::sync_materials(BL::Depsgraph &b_depsgraph, bool update_all)
 
       /* settings */
       PointerRNA cmat = RNA_pointer_get(&b_mat.ptr, "cycles");
-      shader->use_mis = get_boolean(cmat, "sample_as_light");
-      shader->use_transparent_shadow = get_boolean(cmat, "use_transparent_shadow");
-      shader->heterogeneous_volume = !get_boolean(cmat, "homogeneous_volume");
-      shader->volume_sampling_method = get_volume_sampling(cmat);
-      shader->volume_interpolation_method = get_volume_interpolation(cmat);
-      shader->volume_step_rate = get_float(cmat, "volume_step_rate");
-      shader->displacement_method = get_displacement_method(cmat);
+      shader->set_use_mis(get_boolean(cmat, "sample_as_light"));
+      shader->set_use_transparent_shadow(get_boolean(cmat, "use_transparent_shadow"));
+      shader->set_heterogeneous_volume(!get_boolean(cmat, "homogeneous_volume"));
+      shader->set_volume_sampling_method(get_volume_sampling(cmat));
+      shader->set_volume_interpolation_method(get_volume_interpolation(cmat));
+      shader->set_volume_step_rate(get_float(cmat, "volume_step_rate"));
+      shader->set_displacement_method(get_displacement_method(cmat));
 
       shader->set_graph(graph);
 
@@ -1311,7 +1378,6 @@ void BlenderSync::sync_materials(BL::Depsgraph &b_depsgraph, bool update_all)
 void BlenderSync::sync_world(BL::Depsgraph &b_depsgraph, BL::SpaceView3D &b_v3d, bool update_all)
 {
   Background *background = scene->background;
-  Background prevbackground = *background;
 
   BL::World b_world = b_scene.world();
 
@@ -1331,14 +1397,14 @@ void BlenderSync::sync_world(BL::Depsgraph &b_depsgraph, BL::SpaceView3D &b_v3d,
 
       /* volume */
       PointerRNA cworld = RNA_pointer_get(&b_world.ptr, "cycles");
-      shader->heterogeneous_volume = !get_boolean(cworld, "homogeneous_volume");
-      shader->volume_sampling_method = get_volume_sampling(cworld);
-      shader->volume_interpolation_method = get_volume_interpolation(cworld);
-      shader->volume_step_rate = get_float(cworld, "volume_step_size");
+      shader->set_heterogeneous_volume(!get_boolean(cworld, "homogeneous_volume"));
+      shader->set_volume_sampling_method(get_volume_sampling(cworld));
+      shader->set_volume_interpolation_method(get_volume_interpolation(cworld));
+      shader->set_volume_step_rate(get_float(cworld, "volume_step_size"));
     }
     else if (new_viewport_parameters.use_scene_world && b_world) {
       BackgroundNode *background = graph->create_node<BackgroundNode>();
-      background->color = get_float3(b_world.color());
+      background->set_color(get_float3(b_world.color()));
       graph->add(background);
 
       ShaderNode *out = graph->output();
@@ -1360,29 +1426,32 @@ void BlenderSync::sync_world(BL::Depsgraph &b_depsgraph, BL::SpaceView3D &b_v3d,
       graph->add(light_path);
 
       MixNode *mix_scene_with_background = graph->create_node<MixNode>();
-      mix_scene_with_background->color2 = world_color;
+      mix_scene_with_background->set_color2(world_color);
       graph->add(mix_scene_with_background);
 
       EnvironmentTextureNode *texture_environment = graph->create_node<EnvironmentTextureNode>();
-      texture_environment->tex_mapping.type = TextureMapping::VECTOR;
-      texture_environment->tex_mapping.rotation[2] = new_viewport_parameters.studiolight_rotate_z;
-      texture_environment->filename = new_viewport_parameters.studiolight_path;
+      texture_environment->set_tex_mapping_type(TextureMapping::VECTOR);
+      float3 rotation_z = texture_environment->get_tex_mapping_rotation();
+      rotation_z[2] = new_viewport_parameters.studiolight_rotate_z;
+      texture_environment->set_tex_mapping_rotation(rotation_z);
+      texture_environment->set_filename(new_viewport_parameters.studiolight_path);
       graph->add(texture_environment);
 
       MixNode *mix_intensity = graph->create_node<MixNode>();
-      mix_intensity->type = NODE_MIX_MUL;
-      mix_intensity->fac = 1.0f;
-      mix_intensity->color2 = make_float3(new_viewport_parameters.studiolight_intensity,
-                                          new_viewport_parameters.studiolight_intensity,
-                                          new_viewport_parameters.studiolight_intensity);
+      mix_intensity->set_mix_type(NODE_MIX_MUL);
+      mix_intensity->set_fac(1.0f);
+      mix_intensity->set_color2(make_float3(new_viewport_parameters.studiolight_intensity,
+                                            new_viewport_parameters.studiolight_intensity,
+                                            new_viewport_parameters.studiolight_intensity));
       graph->add(mix_intensity);
 
       TextureCoordinateNode *texture_coordinate = graph->create_node<TextureCoordinateNode>();
       graph->add(texture_coordinate);
 
       MixNode *mix_background_with_environment = graph->create_node<MixNode>();
-      mix_background_with_environment->fac = new_viewport_parameters.studiolight_background_alpha;
-      mix_background_with_environment->color1 = world_color;
+      mix_background_with_environment->set_fac(
+          new_viewport_parameters.studiolight_background_alpha);
+      mix_background_with_environment->set_color1(world_color);
       graph->add(mix_background_with_environment);
 
       ShaderNode *out = graph->output();
@@ -1404,9 +1473,9 @@ void BlenderSync::sync_world(BL::Depsgraph &b_depsgraph, BL::SpaceView3D &b_v3d,
       /* AO */
       BL::WorldLighting b_light = b_world.light_settings();
 
-      background->use_ao = b_light.use_ambient_occlusion();
-      background->ao_factor = b_light.ao_factor();
-      background->ao_distance = b_light.distance();
+      background->set_use_ao(b_light.use_ambient_occlusion());
+      background->set_ao_factor(b_light.ao_factor());
+      background->set_ao_distance(b_light.distance());
 
       /* visibility */
       PointerRNA cvisibility = RNA_pointer_get(&b_world.ptr, "cycles_visibility");
@@ -1418,12 +1487,12 @@ void BlenderSync::sync_world(BL::Depsgraph &b_depsgraph, BL::SpaceView3D &b_v3d,
       visibility |= get_boolean(cvisibility, "transmission") ? PATH_RAY_TRANSMIT : 0;
       visibility |= get_boolean(cvisibility, "scatter") ? PATH_RAY_VOLUME_SCATTER : 0;
 
-      background->visibility = visibility;
+      background->set_visibility(visibility);
     }
     else {
-      background->use_ao = false;
-      background->ao_factor = 0.0f;
-      background->ao_distance = FLT_MAX;
+      background->set_use_ao(false);
+      background->set_ao_factor(0.0f);
+      background->set_ao_distance(FLT_MAX);
     }
 
     shader->set_graph(graph);
@@ -1432,22 +1501,23 @@ void BlenderSync::sync_world(BL::Depsgraph &b_depsgraph, BL::SpaceView3D &b_v3d,
   }
 
   PointerRNA cscene = RNA_pointer_get(&b_scene.ptr, "cycles");
-  background->transparent = b_scene.render().film_transparent();
+  background->set_transparent(b_scene.render().film_transparent());
 
-  if (background->transparent) {
-    background->transparent_glass = get_boolean(cscene, "film_transparent_glass");
-    background->transparent_roughness_threshold = get_float(cscene, "film_transparent_roughness");
+  if (background->get_transparent()) {
+    background->set_transparent_glass(get_boolean(cscene, "film_transparent_glass"));
+    background->set_transparent_roughness_threshold(
+        get_float(cscene, "film_transparent_roughness"));
   }
   else {
-    background->transparent_glass = false;
-    background->transparent_roughness_threshold = 0.0f;
+    background->set_transparent_glass(false);
+    background->set_transparent_roughness_threshold(0.0f);
   }
 
-  background->use_shader = view_layer.use_background_shader |
-                           viewport_parameters.custom_viewport_parameters();
-  background->use_ao = background->use_ao && view_layer.use_background_ao;
+  background->set_use_shader(view_layer.use_background_shader |
+                             viewport_parameters.custom_viewport_parameters());
+  background->set_use_ao(background->get_use_ao() && view_layer.use_background_ao);
 
-  if (background->modified(prevbackground))
+  if (background->is_modified())
     background->tag_update(scene);
 }
 
@@ -1467,7 +1537,7 @@ void BlenderSync::sync_lights(BL::Depsgraph &b_depsgraph, bool update_all)
     Shader *shader;
 
     /* test if we need to sync */
-    if (shader_map.add_or_update(scene, &shader, b_light) || update_all) {
+    if (shader_map.add_or_update(&shader, b_light) || update_all) {
       ShaderGraph *graph = new ShaderGraph();
 
       /* create nodes */
@@ -1480,8 +1550,8 @@ void BlenderSync::sync_lights(BL::Depsgraph &b_depsgraph, bool update_all)
       }
       else {
         EmissionNode *emission = graph->create_node<EmissionNode>();
-        emission->color = make_float3(1.0f, 1.0f, 1.0f);
-        emission->strength = 1.0f;
+        emission->set_color(make_float3(1.0f, 1.0f, 1.0f));
+        emission->set_strength(1.0f);
         graph->add(emission);
 
         ShaderNode *out = graph->output();

intern/cycles/blender/blender_sync.cpp

@@ -56,11 +56,11 @@ BlenderSync::BlenderSync(BL::RenderEngine &b_engine,
     : b_engine(b_engine),
       b_data(b_data),
       b_scene(b_scene),
-      shader_map(),
-      object_map(),
-      geometry_map(),
-      light_map(),
-      particle_system_map(),
+      shader_map(scene),
+      object_map(scene),
+      geometry_map(scene),
+      light_map(scene),
+      particle_system_map(scene),
       world_map(NULL),
       world_recalc(false),
       scene(scene),
@@ -118,9 +118,9 @@ void BlenderSync::sync_recalc(BL::Depsgraph &b_depsgraph, BL::SpaceView3D &b_v3d
     if (dicing_prop_changed) {
       for (const pair<const GeometryKey, Geometry *> &iter : geometry_map.key_to_scene_data()) {
         Geometry *geom = iter.second;
-        if (geom->type == Geometry::MESH) {
+        if (geom->is_mesh()) {
           Mesh *mesh = static_cast<Mesh *>(geom);
-          if (mesh->subdivision_type != Mesh::SUBDIVISION_NONE) {
+          if (mesh->get_subdivision_type() != Mesh::SUBDIVISION_NONE) {
             PointerRNA id_ptr;
             RNA_id_pointer_create((::ID *)iter.first.id, &id_ptr);
             geometry_map.set_recalc(BL::ID(id_ptr));
@@ -238,7 +238,7 @@ void BlenderSync::sync_data(BL::RenderSettings &b_render,
   geometry_synced.clear(); /* use for objects and motion sync */
 
   if (scene->need_motion() == Scene::MOTION_PASS || scene->need_motion() == Scene::MOTION_NONE ||
-      scene->camera->motion_position == Camera::MOTION_POSITION_CENTER) {
+      scene->camera->get_motion_position() == Camera::MOTION_POSITION_CENTER) {
     sync_objects(b_depsgraph, b_v3d);
   }
   sync_motion(b_render, b_depsgraph, b_v3d, b_override, width, height, python_thread_state);
@@ -247,7 +247,7 @@ void BlenderSync::sync_data(BL::RenderSettings &b_render,
 
   /* Shader sync done at the end, since object sync uses it.
    * false = don't delete unused shaders, not supported. */
-  shader_map.post_sync(scene, false);
+  shader_map.post_sync(false);
 
   free_data_after_sync(b_depsgraph);
 
@@ -264,70 +264,75 @@ void BlenderSync::sync_integrator()
   experimental = (get_enum(cscene, "feature_set") != 0);
 
   Integrator *integrator = scene->integrator;
-  Integrator previntegrator = *integrator;
 
-  integrator->min_bounce = get_int(cscene, "min_light_bounces");
-  integrator->max_bounce = get_int(cscene, "max_bounces");
+  integrator->set_min_bounce(get_int(cscene, "min_light_bounces"));
+  integrator->set_max_bounce(get_int(cscene, "max_bounces"));
 
-  integrator->max_diffuse_bounce = get_int(cscene, "diffuse_bounces");
-  integrator->max_glossy_bounce = get_int(cscene, "glossy_bounces");
-  integrator->max_transmission_bounce = get_int(cscene, "transmission_bounces");
-  integrator->max_volume_bounce = get_int(cscene, "volume_bounces");
+  integrator->set_max_diffuse_bounce(get_int(cscene, "diffuse_bounces"));
+  integrator->set_max_glossy_bounce(get_int(cscene, "glossy_bounces"));
+  integrator->set_max_transmission_bounce(get_int(cscene, "transmission_bounces"));
+  integrator->set_max_volume_bounce(get_int(cscene, "volume_bounces"));
 
-  integrator->transparent_min_bounce = get_int(cscene, "min_transparent_bounces");
-  integrator->transparent_max_bounce = get_int(cscene, "transparent_max_bounces");
+  integrator->set_transparent_min_bounce(get_int(cscene, "min_transparent_bounces"));
+  integrator->set_transparent_max_bounce(get_int(cscene, "transparent_max_bounces"));
 
-  integrator->volume_max_steps = get_int(cscene, "volume_max_steps");
-  integrator->volume_step_rate = (preview) ? get_float(cscene, "volume_preview_step_rate") :
-                                             get_float(cscene, "volume_step_rate");
+  integrator->set_volume_max_steps(get_int(cscene, "volume_max_steps"));
+  float volume_step_rate = (preview) ? get_float(cscene, "volume_preview_step_rate") :
+                                       get_float(cscene, "volume_step_rate");
+  integrator->set_volume_step_rate(volume_step_rate);
 
-  integrator->caustics_reflective = get_boolean(cscene, "caustics_reflective");
-  integrator->caustics_refractive = get_boolean(cscene, "caustics_refractive");
-  integrator->filter_glossy = get_float(cscene, "blur_glossy");
+  integrator->set_caustics_reflective(get_boolean(cscene, "caustics_reflective"));
+  integrator->set_caustics_refractive(get_boolean(cscene, "caustics_refractive"));
+  integrator->set_filter_glossy(get_float(cscene, "blur_glossy"));
 
-  integrator->seed = get_int(cscene, "seed");
+  int seed = get_int(cscene, "seed");
   if (get_boolean(cscene, "use_animated_seed")) {
-    integrator->seed = hash_uint2(b_scene.frame_current(), get_int(cscene, "seed"));
+    seed = hash_uint2(b_scene.frame_current(), get_int(cscene, "seed"));
     if (b_scene.frame_subframe() != 0.0f) {
       /* TODO(sergey): Ideally should be some sort of hash_merge,
        * but this is good enough for now.
        */
-      integrator->seed += hash_uint2((int)(b_scene.frame_subframe() * (float)INT_MAX),
-                                     get_int(cscene, "seed"));
+      seed += hash_uint2((int)(b_scene.frame_subframe() * (float)INT_MAX),
+                         get_int(cscene, "seed"));
     }
   }
 
-  integrator->sampling_pattern = (SamplingPattern)get_enum(
+  integrator->set_seed(seed);
+
+  integrator->set_sample_clamp_direct(get_float(cscene, "sample_clamp_direct"));
+  integrator->set_sample_clamp_indirect(get_float(cscene, "sample_clamp_indirect"));
+  if (!preview) {
+    if (integrator->get_motion_blur() != r.use_motion_blur()) {
+      scene->object_manager->tag_update(scene);
+      scene->camera->tag_modified();
+    }
+
+    integrator->set_motion_blur(r.use_motion_blur());
+  }
+
+  integrator->set_method((Integrator::Method)get_enum(
+      cscene, "progressive", Integrator::NUM_METHODS, Integrator::PATH));
+
+  integrator->set_sample_all_lights_direct(get_boolean(cscene, "sample_all_lights_direct"));
+  integrator->set_sample_all_lights_indirect(get_boolean(cscene, "sample_all_lights_indirect"));
+  integrator->set_light_sampling_threshold(get_float(cscene, "light_sampling_threshold"));
+
+  SamplingPattern sampling_pattern = (SamplingPattern)get_enum(
       cscene, "sampling_pattern", SAMPLING_NUM_PATTERNS, SAMPLING_PATTERN_SOBOL);
 
-  integrator->sample_clamp_direct = get_float(cscene, "sample_clamp_direct");
-  integrator->sample_clamp_indirect = get_float(cscene, "sample_clamp_indirect");
-  if (!preview) {
-    if (integrator->motion_blur != r.use_motion_blur()) {
-      scene->object_manager->tag_update(scene);
-      scene->camera->tag_update();
-    }
-
-    integrator->motion_blur = r.use_motion_blur();
-  }
-
-  integrator->method = (Integrator::Method)get_enum(
-      cscene, "progressive", Integrator::NUM_METHODS, Integrator::PATH);
-
-  integrator->sample_all_lights_direct = get_boolean(cscene, "sample_all_lights_direct");
-  integrator->sample_all_lights_indirect = get_boolean(cscene, "sample_all_lights_indirect");
-  integrator->light_sampling_threshold = get_float(cscene, "light_sampling_threshold");
+  int adaptive_min_samples = INT_MAX;
 
   if (RNA_boolean_get(&cscene, "use_adaptive_sampling")) {
-    integrator->sampling_pattern = SAMPLING_PATTERN_PMJ;
-    integrator->adaptive_min_samples = get_int(cscene, "adaptive_min_samples");
-    integrator->adaptive_threshold = get_float(cscene, "adaptive_threshold");
+    sampling_pattern = SAMPLING_PATTERN_PMJ;
+    adaptive_min_samples = get_int(cscene, "adaptive_min_samples");
+    integrator->set_adaptive_threshold(get_float(cscene, "adaptive_threshold"));
   }
   else {
-    integrator->adaptive_min_samples = INT_MAX;
-    integrator->adaptive_threshold = 0.0f;
+    integrator->set_adaptive_threshold(0.0f);
   }
 
+  integrator->set_sampling_pattern(sampling_pattern);
+
   int diffuse_samples = get_int(cscene, "diffuse_samples");
   int glossy_samples = get_int(cscene, "glossy_samples");
   int transmission_samples = get_int(cscene, "transmission_samples");
@@ -337,39 +342,40 @@ void BlenderSync::sync_integrator()
   int volume_samples = get_int(cscene, "volume_samples");
 
   if (get_boolean(cscene, "use_square_samples")) {
-    integrator->diffuse_samples = diffuse_samples * diffuse_samples;
-    integrator->glossy_samples = glossy_samples * glossy_samples;
-    integrator->transmission_samples = transmission_samples * transmission_samples;
-    integrator->ao_samples = ao_samples * ao_samples;
-    integrator->mesh_light_samples = mesh_light_samples * mesh_light_samples;
-    integrator->subsurface_samples = subsurface_samples * subsurface_samples;
-    integrator->volume_samples = volume_samples * volume_samples;
-    integrator->adaptive_min_samples = min(
-        integrator->adaptive_min_samples * integrator->adaptive_min_samples, INT_MAX);
+    integrator->set_diffuse_samples(diffuse_samples * diffuse_samples);
+    integrator->set_glossy_samples(glossy_samples * glossy_samples);
+    integrator->set_transmission_samples(transmission_samples * transmission_samples);
+    integrator->set_ao_samples(ao_samples * ao_samples);
+    integrator->set_mesh_light_samples(mesh_light_samples * mesh_light_samples);
+    integrator->set_subsurface_samples(subsurface_samples * subsurface_samples);
+    integrator->set_volume_samples(volume_samples * volume_samples);
+    adaptive_min_samples = min(adaptive_min_samples * adaptive_min_samples, INT_MAX);
   }
   else {
-    integrator->diffuse_samples = diffuse_samples;
-    integrator->glossy_samples = glossy_samples;
-    integrator->transmission_samples = transmission_samples;
-    integrator->ao_samples = ao_samples;
-    integrator->mesh_light_samples = mesh_light_samples;
-    integrator->subsurface_samples = subsurface_samples;
-    integrator->volume_samples = volume_samples;
+    integrator->set_diffuse_samples(diffuse_samples);
+    integrator->set_glossy_samples(glossy_samples);
+    integrator->set_transmission_samples(transmission_samples);
+    integrator->set_ao_samples(ao_samples);
+    integrator->set_mesh_light_samples(mesh_light_samples);
+    integrator->set_subsurface_samples(subsurface_samples);
+    integrator->set_volume_samples(volume_samples);
   }
 
+  integrator->set_adaptive_min_samples(adaptive_min_samples);
+
   if (b_scene.render().use_simplify()) {
     if (preview) {
-      integrator->ao_bounces = get_int(cscene, "ao_bounces");
+      integrator->set_ao_bounces(get_int(cscene, "ao_bounces"));
     }
     else {
-      integrator->ao_bounces = get_int(cscene, "ao_bounces_render");
+      integrator->set_ao_bounces(get_int(cscene, "ao_bounces_render"));
     }
   }
   else {
-    integrator->ao_bounces = 0;
+    integrator->set_ao_bounces(0);
   }
 
-  if (integrator->modified(previntegrator))
+  if (integrator->is_modified())
     integrator->tag_update(scene);
 }
 
@@ -380,46 +386,42 @@ void BlenderSync::sync_film(BL::SpaceView3D &b_v3d)
   PointerRNA cscene = RNA_pointer_get(&b_scene.ptr, "cycles");
 
   Film *film = scene->film;
-  Film prevfilm = *film;
 
   vector<Pass> prevpasses = scene->passes;
 
   if (b_v3d) {
-    film->display_pass = update_viewport_display_passes(b_v3d, scene->passes);
+    film->set_display_pass(update_viewport_display_passes(b_v3d, scene->passes));
   }
 
-  film->exposure = get_float(cscene, "film_exposure");
-  film->filter_type = (FilterType)get_enum(
-      cscene, "pixel_filter_type", FILTER_NUM_TYPES, FILTER_BLACKMAN_HARRIS);
-  film->filter_width = (film->filter_type == FILTER_BOX) ? 1.0f :
-                                                           get_float(cscene, "filter_width");
+  film->set_exposure(get_float(cscene, "film_exposure"));
+  film->set_filter_type(
+      (FilterType)get_enum(cscene, "pixel_filter_type", FILTER_NUM_TYPES, FILTER_BLACKMAN_HARRIS));
+  float filter_width = (film->get_filter_type() == FILTER_BOX) ? 1.0f :
+                                                                 get_float(cscene, "filter_width");
+  film->set_filter_width(filter_width);
 
   if (b_scene.world()) {
     BL::WorldMistSettings b_mist = b_scene.world().mist_settings();
 
-    film->mist_start = b_mist.start();
-    film->mist_depth = b_mist.depth();
+    film->set_mist_start(b_mist.start());
+    film->set_mist_depth(b_mist.depth());
 
     switch (b_mist.falloff()) {
       case BL::WorldMistSettings::falloff_QUADRATIC:
-        film->mist_falloff = 2.0f;
+        film->set_mist_falloff(2.0f);
         break;
       case BL::WorldMistSettings::falloff_LINEAR:
-        film->mist_falloff = 1.0f;
+        film->set_mist_falloff(1.0f);
         break;
       case BL::WorldMistSettings::falloff_INVERSE_QUADRATIC:
-        film->mist_falloff = 0.5f;
+        film->set_mist_falloff(0.5f);
         break;
     }
   }
 
-  if (film->modified(prevfilm)) {
-    film->tag_update(scene);
-  }
-
   if (!Pass::equals(prevpasses, scene->passes)) {
     film->tag_passes_update(scene, prevpasses, false);
-    film->tag_update(scene);
+    film->tag_modified();
   }
 }
 
@@ -585,7 +587,7 @@ vector<Pass> BlenderSync::sync_render_passes(BL::RenderLayer &b_rlay,
     BL::RenderPass b_pass(*b_pass_iter);
     PassType pass_type = get_pass_type(b_pass);
 
-    if (pass_type == PASS_MOTION && scene->integrator->motion_blur)
+    if (pass_type == PASS_MOTION && scene->integrator->get_motion_blur())
       continue;
     if (pass_type != PASS_NONE)
       Pass::add(pass_type, passes, b_pass.name().c_str());
@@ -593,12 +595,12 @@ vector<Pass> BlenderSync::sync_render_passes(BL::RenderLayer &b_rlay,
 
   PointerRNA crl = RNA_pointer_get(&b_view_layer.ptr, "cycles");
 
-  scene->film->denoising_flags = 0;
+  int denoising_flags = 0;
   if (denoising.use || denoising.store_passes) {
     if (denoising.type == DENOISER_NLM) {
 #define MAP_OPTION(name, flag) \
   if (!get_boolean(crl, name)) { \
-    scene->film->denoising_flags |= flag; \
+    denoising_flags |= flag; \
   } \
   ((void)0)
       MAP_OPTION("denoising_diffuse_direct", DENOISING_CLEAN_DIFFUSE_DIR);
@@ -611,6 +613,7 @@ vector<Pass> BlenderSync::sync_render_passes(BL::RenderLayer &b_rlay,
     }
     b_engine.add_pass("Noisy Image", 4, "RGBA", b_view_layer.name().c_str());
   }
+  scene->film->set_denoising_flags(denoising_flags);
 
   if (denoising.store_passes) {
     b_engine.add_pass("Denoising Normal", 3, "XYZ", b_view_layer.name().c_str());
@@ -622,7 +625,7 @@ vector<Pass> BlenderSync::sync_render_passes(BL::RenderLayer &b_rlay,
       b_engine.add_pass("Denoising Intensity", 1, "X", b_view_layer.name().c_str());
     }
 
-    if (scene->film->denoising_flags & DENOISING_CLEAN_ALL_PASSES) {
+    if (scene->film->get_denoising_flags() & DENOISING_CLEAN_ALL_PASSES) {
       b_engine.add_pass("Denoising Clean", 3, "RGB", b_view_layer.name().c_str());
     }
   }
@@ -665,16 +668,15 @@ vector<Pass> BlenderSync::sync_render_passes(BL::RenderLayer &b_rlay,
   /* Cryptomatte stores two ID/weight pairs per RGBA layer.
    * User facing parameter is the number of pairs. */
   int crypto_depth = divide_up(min(16, get_int(crl, "pass_crypto_depth")), 2);
-  scene->film->cryptomatte_depth = crypto_depth;
-  scene->film->cryptomatte_passes = CRYPT_NONE;
+  scene->film->set_cryptomatte_depth(crypto_depth);
+  CryptomatteType cryptomatte_passes = CRYPT_NONE;
   if (get_boolean(crl, "use_pass_crypto_object")) {
     for (int i = 0; i < crypto_depth; i++) {
       string passname = cryptomatte_prefix + string_printf("Object%02d", i);
       b_engine.add_pass(passname.c_str(), 4, "RGBA", b_view_layer.name().c_str());
       Pass::add(PASS_CRYPTOMATTE, passes, passname.c_str());
     }
-    scene->film->cryptomatte_passes = (CryptomatteType)(scene->film->cryptomatte_passes |
-                                                        CRYPT_OBJECT);
+    cryptomatte_passes = (CryptomatteType)(cryptomatte_passes | CRYPT_OBJECT);
   }
   if (get_boolean(crl, "use_pass_crypto_material")) {
     for (int i = 0; i < crypto_depth; i++) {
@@ -682,8 +684,7 @@ vector<Pass> BlenderSync::sync_render_passes(BL::RenderLayer &b_rlay,
       b_engine.add_pass(passname.c_str(), 4, "RGBA", b_view_layer.name().c_str());
       Pass::add(PASS_CRYPTOMATTE, passes, passname.c_str());
     }
-    scene->film->cryptomatte_passes = (CryptomatteType)(scene->film->cryptomatte_passes |
-                                                        CRYPT_MATERIAL);
+    cryptomatte_passes = (CryptomatteType)(cryptomatte_passes | CRYPT_MATERIAL);
   }
   if (get_boolean(crl, "use_pass_crypto_asset")) {
     for (int i = 0; i < crypto_depth; i++) {
@@ -691,13 +692,12 @@ vector<Pass> BlenderSync::sync_render_passes(BL::RenderLayer &b_rlay,
       b_engine.add_pass(passname.c_str(), 4, "RGBA", b_view_layer.name().c_str());
       Pass::add(PASS_CRYPTOMATTE, passes, passname.c_str());
     }
-    scene->film->cryptomatte_passes = (CryptomatteType)(scene->film->cryptomatte_passes |
-                                                        CRYPT_ASSET);
+    cryptomatte_passes = (CryptomatteType)(cryptomatte_passes | CRYPT_ASSET);
   }
-  if (get_boolean(crl, "pass_crypto_accurate") && scene->film->cryptomatte_passes != CRYPT_NONE) {
-    scene->film->cryptomatte_passes = (CryptomatteType)(scene->film->cryptomatte_passes |
-                                                        CRYPT_ACCURATE);
+  if (get_boolean(crl, "pass_crypto_accurate") && cryptomatte_passes != CRYPT_NONE) {
+    cryptomatte_passes = (CryptomatteType)(cryptomatte_passes | CRYPT_ACCURATE);
   }
+  scene->film->set_cryptomatte_passes(cryptomatte_passes);
 
   if (adaptive_sampling) {
     Pass::add(PASS_ADAPTIVE_AUX_BUFFER, passes);
@@ -721,14 +721,14 @@ vector<Pass> BlenderSync::sync_render_passes(BL::RenderLayer &b_rlay,
   }
   RNA_END;
 
-  scene->film->denoising_data_pass = denoising.use || denoising.store_passes;
-  scene->film->denoising_clean_pass = (scene->film->denoising_flags & DENOISING_CLEAN_ALL_PASSES);
-  scene->film->denoising_prefiltered_pass = denoising.store_passes &&
-                                            denoising.type == DENOISER_NLM;
+  scene->film->set_denoising_data_pass(denoising.use || denoising.store_passes);
+  scene->film->set_denoising_clean_pass(scene->film->get_denoising_flags() &
+                                        DENOISING_CLEAN_ALL_PASSES);
+  scene->film->set_denoising_prefiltered_pass(denoising.store_passes &&
+                                              denoising.type == DENOISER_NLM);
 
-  scene->film->pass_alpha_threshold = b_view_layer.pass_alpha_threshold();
+  scene->film->set_pass_alpha_threshold(b_view_layer.pass_alpha_threshold());
   scene->film->tag_passes_update(scene, passes);
-  scene->film->tag_update(scene);
   scene->integrator->tag_update(scene);
 
   return passes;

intern/cycles/blender/blender_sync.h

@@ -149,21 +149,17 @@ class BlenderSync {
                       bool *use_portal,
                       TaskPool *geom_task_pool);
 
+  bool sync_object_attributes(BL::DepsgraphObjectInstance &b_instance, Object *object);
+
   /* Volume */
-  void sync_volume(BL::Object &b_ob, Volume *volume, const vector<Shader *> &used_shaders);
+  void sync_volume(BL::Object &b_ob, Volume *volume);
 
   /* Mesh */
-  void sync_mesh(BL::Depsgraph b_depsgraph,
-                 BL::Object b_ob,
-                 Mesh *mesh,
-                 const vector<Shader *> &used_shaders);
+  void sync_mesh(BL::Depsgraph b_depsgraph, BL::Object b_ob, Mesh *mesh);
   void sync_mesh_motion(BL::Depsgraph b_depsgraph, BL::Object b_ob, Mesh *mesh, int motion_step);
 
   /* Hair */
-  void sync_hair(BL::Depsgraph b_depsgraph,
-                 BL::Object b_ob,
-                 Hair *hair,
-                 const vector<Shader *> &used_shaders);
+  void sync_hair(BL::Depsgraph b_depsgraph, BL::Object b_ob, Hair *hair);
   void sync_hair_motion(BL::Depsgraph b_depsgraph, BL::Object b_ob, Hair *hair, int motion_step);
   void sync_hair(Hair *hair, BL::Object &b_ob, bool motion, int motion_step = 0);
   void sync_particle_hair(
@@ -211,7 +207,7 @@ class BlenderSync {
   void free_data_after_sync(BL::Depsgraph &b_depsgraph);
 
   /* util */
-  void find_shader(BL::ID &id, vector<Shader *> &used_shaders, Shader *default_shader);
+  void find_shader(BL::ID &id, array<Node *> &used_shaders, Shader *default_shader);
   bool BKE_object_is_modified(BL::Object &b_ob);
   bool object_is_geometry(BL::Object &b_ob);
   bool object_is_light(BL::Object &b_ob);

intern/cycles/blender/blender_util.h

@@ -40,6 +40,9 @@ float *BKE_image_get_float_pixels_for_frame(void *image, int frame, int tile);
 
 CCL_NAMESPACE_BEGIN
 
+typedef BL::ShaderNodeAttribute::attribute_type_enum BlenderAttributeType;
+BlenderAttributeType blender_attribute_name_split_type(ustring name, string *r_real_name);
+
 void python_thread_state_save(void **python_thread_state);
 void python_thread_state_restore(void **python_thread_state);
 

intern/cycles/blender/blender_volume.cpp

@@ -202,7 +202,7 @@ static void sync_smoke_volume(Scene *scene, BL::Object &b_ob, Volume *volume, fl
       continue;
     }
 
-    volume->clipping = b_domain.clipping();
+    volume->set_clipping(b_domain.clipping());
 
     Attribute *attr = volume->attributes.add(std);
 
@@ -262,9 +262,9 @@ static void sync_volume_object(BL::BlendData &b_data,
 
   BL::VolumeRender b_render(b_volume.render());
 
-  volume->clipping = b_render.clipping();
-  volume->step_size = b_render.step_size();
-  volume->object_space = (b_render.space() == BL::VolumeRender::space_OBJECT);
+  volume->set_clipping(b_render.clipping());
+  volume->set_step_size(b_render.step_size());
+  volume->set_object_space((b_render.space() == BL::VolumeRender::space_OBJECT));
 
   /* Find grid with matching name. */
   BL::Volume::grids_iterator b_grid_iter;
@@ -320,14 +320,11 @@ static vector<int> get_voxel_image_slots(Mesh *mesh)
   return slots;
 }
 
-void BlenderSync::sync_volume(BL::Object &b_ob,
-                              Volume *volume,
-                              const vector<Shader *> &used_shaders)
+void BlenderSync::sync_volume(BL::Object &b_ob, Volume *volume)
 {
   vector<int> old_voxel_slots = get_voxel_image_slots(volume);
 
-  volume->clear();
-  volume->used_shaders = used_shaders;
+  volume->clear(true);
 
   if (view_layer.use_volumes) {
     if (b_ob.type() == BL::Object::type_VOLUME) {

intern/cycles/bvh/bvh.cpp

@@ -108,6 +108,7 @@ BVH *BVH::create(const BVHParams &params,
 #ifdef WITH_EMBREE
       return new BVHEmbree(params, geometry, objects, device);
 #else
+      (void)device;
       break;
 #endif
     case BVH_LAYOUT_OPTIX:
@@ -208,30 +209,30 @@ void BVH::refit_primitives(int start, int end, BoundBox &bbox, uint &visibility)
       /* Primitives. */
       if (pack.prim_type[prim] & PRIMITIVE_ALL_CURVE) {
         /* Curves. */
-        const Hair *hair = static_cast<const Hair *>(ob->geometry);
+        const Hair *hair = static_cast<const Hair *>(ob->get_geometry());
         int prim_offset = (params.top_level) ? hair->prim_offset : 0;
         Hair::Curve curve = hair->get_curve(pidx - prim_offset);
         int k = PRIMITIVE_UNPACK_SEGMENT(pack.prim_type[prim]);
 
-        curve.bounds_grow(k, &hair->curve_keys[0], &hair->curve_radius[0], bbox);
+        curve.bounds_grow(k, &hair->get_curve_keys()[0], &hair->get_curve_radius()[0], bbox);
 
         /* Motion curves. */
-        if (hair->use_motion_blur) {
+        if (hair->get_use_motion_blur()) {
           Attribute *attr = hair->attributes.find(ATTR_STD_MOTION_VERTEX_POSITION);
 
           if (attr) {
-            size_t hair_size = hair->curve_keys.size();
-            size_t steps = hair->motion_steps - 1;
+            size_t hair_size = hair->get_curve_keys().size();
+            size_t steps = hair->get_motion_steps() - 1;
             float3 *key_steps = attr->data_float3();
 
             for (size_t i = 0; i < steps; i++)
-              curve.bounds_grow(k, key_steps + i * hair_size, &hair->curve_radius[0], bbox);
+              curve.bounds_grow(k, key_steps + i * hair_size, &hair->get_curve_radius()[0], bbox);
           }
         }
       }
       else {
         /* Triangles. */
-        const Mesh *mesh = static_cast<const Mesh *>(ob->geometry);
+        const Mesh *mesh = static_cast<const Mesh *>(ob->get_geometry());
         int prim_offset = (params.top_level) ? mesh->prim_offset : 0;
         Mesh::Triangle triangle = mesh->get_triangle(pidx - prim_offset);
         const float3 *vpos = &mesh->verts[0];
@@ -263,7 +264,7 @@ void BVH::pack_triangle(int idx, float4 tri_verts[3])
 {
   int tob = pack.prim_object[idx];
   assert(tob >= 0 && tob < objects.size());
-  const Mesh *mesh = static_cast<const Mesh *>(objects[tob]->geometry);
+  const Mesh *mesh = static_cast<const Mesh *>(objects[tob]->get_geometry());
 
   int tidx = pack.prim_index[idx];
   Mesh::Triangle t = mesh->get_triangle(tidx);
@@ -328,7 +329,7 @@ void BVH::pack_instances(size_t nodes_size, size_t leaf_nodes_size)
    */
   for (size_t i = 0; i < pack.prim_index.size(); i++) {
     if (pack.prim_index[i] != -1) {
-      pack.prim_index[i] += objects[pack.prim_object[i]]->geometry->prim_offset;
+      pack.prim_index[i] += objects[pack.prim_object[i]]->get_geometry()->prim_offset;
     }
   }
 
@@ -389,7 +390,7 @@ void BVH::pack_instances(size_t nodes_size, size_t leaf_nodes_size)
 
   /* merge */
   foreach (Object *ob, objects) {
-    Geometry *geom = ob->geometry;
+    Geometry *geom = ob->get_geometry();
 
     /* We assume that if mesh doesn't need own BVH it was already included
      * into a top-level BVH and no packing here is needed.