Merge branch 'master' into outliner-cpp-refactor

Fix T82521: Bump OpenImageIO minimum version 1.8 > 2.2.1 for install_deps.sh
Since rB6fdcca8de64cd70f, we need at least OpenImageIO 2.1.12 to build Blender.
2020-11-11 17:35:26 +01:00 · 2020-11-11 15:10:01 +01:00 · 2020-11-11 12:16:22 +01:00 · 2020-11-11 20:40:42 +11:00 · 2020-11-11 10:27:44 +01:00 · 2020-11-11 10:18:47 +01:00
1832 changed files with 45729 additions and 41999 deletions
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -15,9 +15,10 @@ Checks:  >

  -readability-misleading-indentation,

-  -readability-redundant-member-init,
  -readability-use-anyofallof,

+  -readability-function-cognitive-complexity,
+
  bugprone-*,
  -bugprone-narrowing-conversions,
  -bugprone-unhandled-self-assignment,
@@ -28,4 +29,23 @@ Checks:  >
  -bugprone-sizeof-expression,
  -bugprone-integer-division,

+  -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: '*'
--- a/.git-blame-ignore-revs
+++ b/.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
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -43,8 +43,8 @@ endif()

 cmake_minimum_required(VERSION 3.10)

-# Prever LEGACY OpenGL to eb compatible with all the existing releases and
-# platforms which don't hare GLVND yet. Only do it if preference was not set
+# Prefer LEGACY OpenGL to be compatible with all the existing releases and
+# platforms which don't have GLVND yet. Only do it if preference was not set
 # externally.
 if(NOT DEFINED OpenGL_GL_PREFERENCE)
  set(OpenGL_GL_PREFERENCE "LEGACY")
@@ -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("")

--- a/2
+++ b/2
@@ -89,7 +89,7 @@ Spell Checkers
   * check_spelling_osl:    Check for spelling errors (OSL only).
   * check_spelling_py:     Check for spelling errors (Python only).

-   Note that spell checkers can tak a 'CHECK_SPELLING_CACHE' filepath argument,
+   Note that spell checkers can take a 'CHECK_SPELLING_CACHE' filepath argument,
   so re-running does not need to re-check unchanged files.

   Example:
--- a/build_files/build_environment/CMakeLists.txt
+++ b/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)
--- a/build_files/build_environment/cmake/check_software.cmake
+++ b/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()

--- a/build_files/build_environment/cmake/gmp.cmake
+++ b/build_files/build_environment/cmake/gmp.cmake
@@ -20,7 +20,7 @@ set(GMP_EXTRA_ARGS -enable-cxx)

 if(WIN32)
  # Shared for windows because static libs will drag in a libgcc dependency.
-  set(GMP_OPTIONS --disable-static --enable-shared --host=x86_64-w64-mingw32 --build=x86_64-w64-mingw32)
+  set(GMP_OPTIONS --disable-static --enable-shared --enable-fat --host=x86_64-w64-mingw32 --build=x86_64-w64-mingw32)
 else()
  set(GMP_OPTIONS --enable-static --disable-shared )
 endif()
@@ -41,6 +41,7 @@ elseif(UNIX)
  set(GMP_OPTIONS
    ${GMP_OPTIONS}
    --with-pic
+    --enable-fat
  )
 endif()

--- a/build_files/build_environment/cmake/harvest.cmake
+++ b/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")
--- a/build_files/build_environment/cmake/nanovdb.cmake
+++ b/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()
--- a/build_files/build_environment/cmake/openvdb.cmake
+++ b/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
--- a/build_files/build_environment/cmake/options.cmake
+++ b/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()
--- a/build_files/build_environment/cmake/versions.cmake
+++ b/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)
--- a/build_files/build_environment/install_deps.sh
+++ b/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
 }

 # ----------------------------------------------------------------------------
@@ -3958,7 +4094,7 @@ install_DEB() {
    if [ $? -eq 0 ]; then
      install_packages_DEB llvm-dev clang
      have_llvm=true
-      LLVM_VERSION=`get_package_version_DEB llvm-dev`
+      LLVM_VERSION=`llvm-config --version`
      LLVM_VERSION_FOUND=$LLVM_VERSION
      clean_LLVM
    else
@@ -4607,7 +4743,7 @@ install_RPM() {
    if [ $? -eq 0 ]; then
      install_packages_RPM llvm-devel $CLANG_DEV
      have_llvm=true
-      LLVM_VERSION=`get_package_version_RPM llvm-devel`
+      LLVM_VERSION=`llvm-config --version`
      LLVM_VERSION_FOUND=$LLVM_VERSION
      clean_LLVM
    else
@@ -5129,7 +5265,7 @@ install_ARCH() {
    if [ $? -eq 0 ]; then
      install_packages_ARCH llvm clang
      have_llvm=true
-      LLVM_VERSION=`get_package_version_ARCH llvm`
+      LLVM_VERSION=`llvm-config --version`
      LLVM_VERSION_FOUND=$LLVM_VERSION
      clean_LLVM
    else
@@ -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
--- a/build_files/build_environment/patches/openvdb_nanovdb.diff
+++ b/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
- 
--- a/build_files/cmake/Modules/FindClangTidy.cmake
+++ b/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)

--- a/build_files/cmake/Modules/GTestTesting.cmake
+++ b/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)
--- a/build_files/cmake/buildinfo.cmake
+++ b/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
--- a/build_files/cmake/buildinfo_static.h.in
+++ b/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@"
--- a/build_files/cmake/macros.cmake
+++ b/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)
@@ -1243,7 +1256,7 @@ macro(without_system_libs_begin)
  set(CMAKE_IGNORE_PATH "${CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES};${CMAKE_SYSTEM_INCLUDE_PATH};${CMAKE_C_IMPLICIT_INCLUDE_DIRECTORIES};${CMAKE_CXX_IMPLICIT_INCLUDE_DIRECTORIES}")
  if(APPLE)
    # Avoid searching for headers in frameworks (like Mono), and libraries in LIBDIR.
-    set(CMAKE_FIND_FRAMEWORK LAST)
+    set(CMAKE_FIND_FRAMEWORK NEVER)
  endif()
 endmacro()

--- a/build_files/cmake/platform/platform_apple.cmake
+++ b/build_files/cmake/platform/platform_apple.cmake
@@ -53,6 +53,24 @@ find_package(ZLIB REQUIRED)
 find_package(BZip2 REQUIRED)
 list(APPEND ZLIB_LIBRARIES ${BZIP2_LIBRARIES})

+if(WITH_OPENAL)
+  find_package(OpenAL)
+  if(NOT OPENAL_FOUND)
+    set(WITH_OPENAL OFF)
+  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
@@ -72,15 +90,6 @@ if(EXISTS ${LIBDIR})
  without_system_libs_begin()
 endif()

-if(WITH_OPENAL)
-  find_package(OpenAL)
-  if(OPENAL_FOUND)
-    set(WITH_OPENAL ON)
-  else()
-    set(WITH_OPENAL OFF)
-  endif()
-endif()
-
 if(WITH_ALEMBIC)
  find_package(Alembic)
 endif()
@@ -96,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)
@@ -196,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"
 )
@@ -204,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)
@@ -224,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)
@@ -268,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 +335,10 @@ endif()

 if(WITH_CYCLES_EMBREE)
  find_package(Embree 3.8.0 REQUIRED)
-  set(PLATFORM_LINKFLAGS "${PLATFORM_LINKFLAGS} -Xlinker -stack_size -Xlinker 0x100000")
+  # Increase stack size for Embree, only works for executables.
+  if(NOT WITH_PYTHON_MODULE)
+    string(APPEND PLATFORM_LINKFLAGS " -Xlinker -stack_size -Xlinker 0x100000")
+  endif()

  # Embree static library linking can mix up SSE and AVX symbols, causing
  # crashes on macOS systems with older CPUs that don't have AVX. Using
@@ -380,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.
@@ -427,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
@@ -452,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>")
--- a/build_files/cmake/platform/platform_apple_xcode.cmake
+++ b/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()
--- a/build_files/cmake/platform/platform_unix.cmake
+++ b/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()
--- a/build_files/cmake/platform/platform_win32.cmake
+++ b/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)
--- a/build_files/cmake/platform/platform_win32_bundle_crt.cmake
+++ b/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})
--- a/doc/doxygen/Doxyfile
+++ b/doc/doxygen/Doxyfile
@@ -38,7 +38,7 @@ PROJECT_NAME           = Blender
 # could be handy for archiving the generated documentation or if some version
 # control system is used.

-PROJECT_NUMBER         = "V2.91"
+PROJECT_NUMBER         = "V2.92"

 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a
--- a/extern/bullet2/CMakeLists.txt
+++ b/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)
--- a/extern/draco/dracoenc/cmake/compiler_flags.cmake
+++ b/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 ()
--- a/extern/draco/dracoenc/cmake/compiler_tests.cmake
+++ b/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)
--- a/extern/mantaflow/CMakeLists.txt
+++ b/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()

--- a/extern/mantaflow/helper/pwrapper/numpyWrap.cpp
+++ b/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;
--- a/extern/mantaflow/helper/pwrapper/pclass.cpp
+++ b/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 !");
  }
 }
--- a/extern/mantaflow/helper/pwrapper/pclass.h
+++ b/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();

--- a/extern/mantaflow/helper/pwrapper/pconvert.cpp
+++ b/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());
--- a/extern/mantaflow/helper/pwrapper/pconvert.h
+++ b/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;
--- a/extern/mantaflow/helper/pwrapper/pvec3.cpp
+++ b/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
--- a/extern/mantaflow/helper/pwrapper/registry.cpp
+++ b/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;
 }
--- a/extern/mantaflow/helper/util/randomstream.h
+++ b/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)
--- a/extern/mantaflow/helper/util/rcmatrix.h
+++ b/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:
--- a/extern/mantaflow/helper/util/simpleimage.cpp
+++ b/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,
--- a/extern/mantaflow/helper/util/simpleimage.h
+++ b/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)
--- a/extern/mantaflow/preprocessed/conjugategrad.cpp
+++ b/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);
--- a/extern/mantaflow/preprocessed/fastmarch.cpp
+++ b/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);
--- a/extern/mantaflow/preprocessed/fastmarch.h
+++ b/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()
  {
  }
--- a/extern/mantaflow/preprocessed/fileio/iogrids.cpp
+++ b/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);
--- a/extern/mantaflow/preprocessed/fileio/ioutil.cpp
+++ b/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;
--- a/extern/mantaflow/preprocessed/fileio/mantaio.cpp
+++ b/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);
--- a/extern/mantaflow/preprocessed/fileio/mantaio.h
+++ b/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);
--- a/extern/mantaflow/preprocessed/fluidsolver.cpp
+++ b/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();
--- a/extern/mantaflow/preprocessed/fluidsolver.h
+++ b/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);
--- a/extern/mantaflow/preprocessed/gitinfo.h
+++ b/extern/mantaflow/preprocessed/gitinfo.h
@@ -1,3 +1,3 @@


-#define MANTA_GIT_VERSION "commit dffc3481b835dfa048effcbb8a9e613294ecae14"
+#define MANTA_GIT_VERSION "commit 73990a8a5b876e2b136a646258f714c08c5828da"
--- a/extern/mantaflow/preprocessed/grid.cpp
+++ b/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);
--- a/extern/mantaflow/preprocessed/grid.h
+++ b/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();
--- a/extern/mantaflow/preprocessed/grid4d.cpp
+++ b/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);
--- a/extern/mantaflow/preprocessed/grid4d.h
+++ b/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);
--- a/extern/mantaflow/preprocessed/levelset.cpp
+++ b/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);
--- a/extern/mantaflow/preprocessed/levelset.h
+++ b/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);
--- a/extern/mantaflow/preprocessed/mesh.cpp
+++ b/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());
--- a/extern/mantaflow/preprocessed/mesh.h
+++ b/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);
--- a/extern/mantaflow/preprocessed/movingobs.h
+++ b/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);
--- a/extern/mantaflow/preprocessed/noisefield.cpp
+++ b/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] = {
--- a/extern/mantaflow/preprocessed/noisefield.h
+++ b/extern/mantaflow/preprocessed/noisefield.h
@@ -64,7 +64,7 @@ class WaveletNoiseField : public PbClass {
  {
    if (mNoiseTile && !mNoiseReferenceCount) {
      delete mNoiseTile;
-      mNoiseTile = NULL;
+      mNoiseTile = nullptr;
    }
  };

--- a/extern/mantaflow/preprocessed/particle.cpp
+++ b/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());
--- a/extern/mantaflow/preprocessed/particle.h
+++ b/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());
--- a/extern/mantaflow/preprocessed/plugin/advection.cpp
+++ b/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);
--- a/extern/mantaflow/preprocessed/plugin/apic.cpp
+++ b/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);
--- a/extern/mantaflow/preprocessed/plugin/extforces.cpp
+++ b/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();
--- a/extern/mantaflow/preprocessed/plugin/fire.cpp
+++ b/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);
--- a/extern/mantaflow/preprocessed/plugin/flip.cpp
+++ b/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);
--- a/extern/mantaflow/preprocessed/plugin/fluidguiding.cpp
+++ b/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();
--- a/extern/mantaflow/preprocessed/plugin/initplugins.cpp
+++ b/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);
--- a/extern/mantaflow/preprocessed/plugin/kepsilon.cpp
+++ b/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);
--- a/extern/mantaflow/preprocessed/plugin/meshplugins.cpp
+++ b/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);
--- a/extern/mantaflow/preprocessed/plugin/pressure.cpp
+++ b/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,
--- a/extern/mantaflow/preprocessed/plugin/ptsplugins.cpp
+++ b/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);
--- a/extern/mantaflow/preprocessed/plugin/secondaryparticles.cpp
+++ b/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);
--- a/extern/mantaflow/preprocessed/plugin/surfaceturbulence.cpp
+++ b/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);
--- a/extern/mantaflow/preprocessed/plugin/vortexplugins.cpp
+++ b/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);
--- a/extern/mantaflow/preprocessed/plugin/waveletturbulence.cpp
+++ b/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);
--- a/extern/mantaflow/preprocessed/plugin/waves.cpp
+++ b/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);
--- a/extern/mantaflow/preprocessed/shapes.h
+++ b/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);
--- a/extern/mantaflow/preprocessed/timing.h
+++ b/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);
--- a/extern/mantaflow/preprocessed/turbulencepart.h
+++ b/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);
--- a/extern/mantaflow/preprocessed/vortexpart.h
+++ b/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);
--- a/extern/mantaflow/preprocessed/vortexsheet.h
+++ b/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);
--- a/intern/atomic/atomic_ops.h
+++ b/intern/atomic/atomic_ops.h
@@ -57,7 +57,7 @@
 #if defined(__arm__)
 /* Attempt to fix compilation error on Debian armel kernel.
 * arm7 architecture does have both 32 and 64bit atomics, however
- * it's gcc doesn't have __GCC_HAVE_SYNC_COMPARE_AND_SWAP_n defined.
+ * its gcc doesn't have __GCC_HAVE_SYNC_COMPARE_AND_SWAP_n defined.
 */
 #  define JE_FORCE_SYNC_COMPARE_AND_SWAP_1
 #  define JE_FORCE_SYNC_COMPARE_AND_SWAP_4
--- a/intern/clog/CLG_log.h
+++ b/intern/clog/CLG_log.h
@@ -150,6 +150,8 @@ void CLG_level_set(int level);

 void CLG_logref_init(CLG_LogRef *clg_ref);

+int CLG_color_support_get(CLG_LogRef *clg_ref);
+
 /** Declare outside function, declare as extern in header. */
 #define CLG_LOGREF_DECLARE_GLOBAL(var, id) \
  static CLG_LogRef _static_##var = {id}; \
--- a/intern/clog/clog.c
+++ b/intern/clog/clog.c
@@ -755,4 +755,12 @@ void CLG_logref_init(CLG_LogRef *clg_ref)
 #endif
 }

+int CLG_color_support_get(CLG_LogRef *clg_ref)
+{
+  if (clg_ref->type == NULL) {
+    CLG_logref_init(clg_ref);
+  }
+  return clg_ref->type->ctx->use_color;
+}
+
 /** \} */
--- a/intern/cycles/CMakeLists.txt
+++ b/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)
--- a/intern/cycles/blender/CMakeLists.txt
+++ b/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)
--- a/intern/cycles/blender/addon/ui.py
+++ b/intern/cycles/blender/addon/ui.py
@@ -1271,7 +1271,7 @@ class CYCLES_OBJECT_PT_visibility(CyclesButtonsPanel, Panel):

        layout.prop(ob, "hide_select", text="Selectable", invert_checkbox=True, toggle=False)

-        col = layout.column(heading="Show in")
+        col = layout.column(heading="Show In")
        col.prop(ob, "hide_viewport", text="Viewports", invert_checkbox=True, toggle=False)
        col.prop(ob, "hide_render", text="Renders", invert_checkbox=True, toggle=False)

--- a/intern/cycles/blender/blender_camera.cpp
+++ b/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);
      }
    }
  }
--- a/intern/cycles/blender/blender_curves.cpp
+++ b/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);
 }
--- a/intern/cycles/blender/blender_device.cpp
+++ b/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);
--- a/intern/cycles/blender/blender_geometry.cpp
+++ b/intern/cycles/blender/blender_geometry.cpp
@@ -25,6 +25,7 @@
 #include "blender/blender_util.h"

 #include "util/util_foreach.h"
+#include "util/util_task.h"

 CCL_NAMESPACE_BEGIN

@@ -45,19 +46,20 @@ Geometry *BlenderSync::sync_geometry(BL::Depsgraph &b_depsgraph,
                                     BL::Object &b_ob,
                                     BL::Object &b_ob_instance,
                                     bool object_updated,
-                                     bool use_particle_hair)
+                                     bool use_particle_hair,
+                                     TaskPool *task_pool)
 {
  /* 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) {
@@ -74,11 +76,18 @@ 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. */
+  Geometry *geom = geometry_map.find(key);
+  if (geom) {
+    if (geometry_synced.find(geom) != geometry_synced.end()) {
+      return geom;
+    }
  }

  /* Test if we need to sync. */
-  Geometry *geom = geometry_map.find(key);
  bool sync = true;
  if (geom == NULL) {
    /* Add new geometry if it did not exist yet. */
@@ -105,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 {
@@ -113,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;
        }
@@ -125,28 +135,39 @@ Geometry *BlenderSync::sync_geometry(BL::Depsgraph &b_depsgraph,
    }
  }

-  /* Ensure we only sync instanced geometry once. */
-  if (geometry_synced.find(geom) != geometry_synced.end()) {
-    return geom;
-  }
-
-  progress.set_sync_status("Synchronizing object", b_ob.name());
-
  geometry_synced.insert(geom);

  geom->name = ustring(b_ob_data.name().c_str());

-  if (geom_type == Geometry::HAIR) {
-    Hair *hair = static_cast<Hair *>(geom);
-    sync_hair(b_depsgraph, b_ob, hair, used_shaders);
-  }
-  else if (geom_type == Geometry::VOLUME) {
-    Volume *volume = static_cast<Volume *>(geom);
-    sync_volume(b_ob, volume, used_shaders);
+  /* Store the shaders immediately for the object attribute code. */
+  geom->set_used_shaders(used_shaders);
+
+  auto sync_func = [=]() mutable {
+    if (progress.get_cancel())
+      return;
+
+    progress.set_sync_status("Synchronizing object", b_ob.name());
+
+    if (geom_type == Geometry::HAIR) {
+      Hair *hair = static_cast<Hair *>(geom);
+      sync_hair(b_depsgraph, b_ob, hair);
+    }
+    else if (geom_type == Geometry::VOLUME) {
+      Volume *volume = static_cast<Volume *>(geom);
+      sync_volume(b_ob, volume);
+    }
+    else {
+      Mesh *mesh = static_cast<Mesh *>(geom);
+      sync_mesh(b_depsgraph, b_ob, mesh);
+    }
+  };
+
+  /* Defer the actual geometry sync to the task_pool for multithreading */
+  if (task_pool) {
+    task_pool->push(sync_func);
  }
  else {
-    Mesh *mesh = static_cast<Mesh *>(geom);
-    sync_mesh(b_depsgraph, b_ob, mesh, used_shaders);
+    sync_func();
  }

  return geom;
@@ -156,10 +177,11 @@ void BlenderSync::sync_geometry_motion(BL::Depsgraph &b_depsgraph,
                                       BL::Object &b_ob,
                                       Object *object,
                                       float motion_time,
-                                       bool use_particle_hair)
+                                       bool use_particle_hair,
+                                       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;
@@ -177,16 +199,29 @@ void BlenderSync::sync_geometry_motion(BL::Depsgraph &b_depsgraph,
    return;
  }

-  if (b_ob.type() == BL::Object::type_HAIR || use_particle_hair) {
-    Hair *hair = static_cast<Hair *>(geom);
-    sync_hair_motion(b_depsgraph, b_ob, hair, motion_step);
-  }
-  else if (b_ob.type() == BL::Object::type_VOLUME || object_fluid_gas_domain_find(b_ob)) {
-    /* No volume motion blur support yet. */
+  auto sync_func = [=]() mutable {
+    if (progress.get_cancel())
+      return;
+
+    if (b_ob.type() == BL::Object::type_HAIR || use_particle_hair) {
+      Hair *hair = static_cast<Hair *>(geom);
+      sync_hair_motion(b_depsgraph, b_ob, hair, motion_step);
+    }
+    else if (b_ob.type() == BL::Object::type_VOLUME || object_fluid_gas_domain_find(b_ob)) {
+      /* No volume motion blur support yet. */
+    }
+    else {
+      Mesh *mesh = static_cast<Mesh *>(geom);
+      sync_mesh_motion(b_depsgraph, b_ob, mesh, motion_step);
+    }
+  };
+
+  /* Defer the actual geometry sync to the task_pool for multithreading */
+  if (task_pool) {
+    task_pool->push(sync_func);
  }
  else {
-    Mesh *mesh = static_cast<Mesh *>(geom);
-    sync_mesh_motion(b_depsgraph, b_ob, mesh, motion_step);
+    sync_func();
  }
 }

--- a/intern/cycles/blender/blender_id_map.h
+++ b/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;
      }
    }
--- a/intern/cycles/blender/blender_light.cpp
+++ b/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);
--- a/intern/cycles/blender/blender_mesh.cpp
+++ b/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);
        }
--- a/intern/cycles/blender/blender_object.cpp
+++ b/intern/cycles/blender/blender_object.cpp
@@ -32,6 +32,7 @@
 #include "util/util_foreach.h"
 #include "util/util_hash.h"
 #include "util/util_logging.h"
+#include "util/util_task.h"

 CCL_NAMESPACE_BEGIN

@@ -103,7 +104,8 @@ Object *BlenderSync::sync_object(BL::Depsgraph &b_depsgraph,
                                 bool use_particle_hair,
                                 bool show_lights,
                                 BlenderObjectCulling &culling,
-                                 bool *use_portal)
+                                 bool *use_portal,
+                                 TaskPool *geom_task_pool)
 {
  const bool is_instance = b_instance.is_instance();
  BL::Object b_ob = b_instance.object();
@@ -181,6 +183,10 @@ Object *BlenderSync::sync_object(BL::Depsgraph &b_depsgraph,
    return NULL;
  }

+  /* Use task pool only for non-instances, since sync_dupli_particle accesses
+   * geometry. This restriction should be removed for better performance. */
+  TaskPool *object_geom_task_pool = (is_instance) ? NULL : geom_task_pool;
+
  /* key to lookup object */
  ObjectKey key(b_parent, persistent_id, b_ob_instance, use_particle_hair);
  Object *object;
@@ -193,12 +199,19 @@ 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)
-        sync_geometry_motion(b_depsgraph, b_ob, object, motion_time, use_particle_hair);
+      if (object->get_geometry())
+        sync_geometry_motion(b_depsgraph,
+                             b_ob_instance,
+                             object,
+                             motion_time,
+                             use_particle_hair,
+                             object_geom_task_pool);
    }

    return object;
@@ -207,38 +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 */
-  object->geometry = sync_geometry(
-      b_depsgraph, b_ob, b_ob_instance, object_updated, use_particle_hair);
+  /* 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. */
+  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();
@@ -252,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));
@@ -303,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);
@@ -325,12 +341,141 @@ 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,
                               BL::SpaceView3D &b_v3d,
                               float motion_time)
 {
+  /* Task pool for multithreaded geometry sync. */
+  TaskPool geom_task_pool;
+
  /* layer data */
  bool motion = motion_time != 0.0f;

@@ -355,8 +500,8 @@ void BlenderSync::sync_objects(BL::Depsgraph &b_depsgraph,
  const bool show_lights = BlenderViewportParameters(b_v3d).use_scene_lights;

  BL::ViewLayer b_view_layer = b_depsgraph.view_layer_eval();
-
  BL::Depsgraph::object_instances_iterator b_instance_iter;
+
  for (b_depsgraph.object_instances.begin(b_instance_iter);
       b_instance_iter != b_depsgraph.object_instances.end() && !cancel;
       ++b_instance_iter) {
@@ -372,6 +517,11 @@ void BlenderSync::sync_objects(BL::Depsgraph &b_depsgraph,
    /* Load per-object culling data. */
    culling.init_object(scene, b_ob);

+    /* Ensure the object geom supporting the hair is processed before adding
+     * the hair processing task to the task pool, calling .to_mesh() on the
+     * same object in parallel does not work. */
+    const bool sync_hair = b_instance.show_particles() && object_has_particle_hair(b_ob);
+
    /* Object itself. */
    if (b_instance.show_self()) {
      sync_object(b_depsgraph,
@@ -381,11 +531,12 @@ void BlenderSync::sync_objects(BL::Depsgraph &b_depsgraph,
                  false,
                  show_lights,
                  culling,
-                  &use_portal);
+                  &use_portal,
+                  sync_hair ? NULL : &geom_task_pool);
    }

    /* Particle hair as separate object. */
-    if (b_instance.show_particles() && object_has_particle_hair(b_ob)) {
+    if (sync_hair) {
      sync_object(b_depsgraph,
                  b_view_layer,
                  b_instance,
@@ -393,22 +544,25 @@ void BlenderSync::sync_objects(BL::Depsgraph &b_depsgraph,
                  true,
                  show_lights,
                  culling,
-                  &use_portal);
+                  &use_portal,
+                  &geom_task_pool);
    }

    cancel = progress.get_cancel();
  }

+  geom_task_pool.wait_work();
+
  progress.set_sync_status("");

  if (!cancel && !motion) {
    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)
@@ -431,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;
    }

@@ -505,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
--- a/intern/cycles/blender/blender_object_cull.cpp
+++ b/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);

--- a/intern/cycles/blender/blender_particles.cpp
+++ b/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;
--- a/Show More
+++ b/Show More