OpenVDB  7.0.0
Building OpenVDB

Contents


Introduction

CMake is a cross-platform family of tools designed to help build software. CMake doesn't actually build the project but instead generates the files required for your toolchain, for example makefiles that serve as input to GNU Make. Makefiles have historically been included in the OpenVDB distribution and until recently were the preferred means of building OpenVDB on UNIX platforms (see Building With Make below). But CMake support ensures a high level of flexibility and pre-compile verification to the build process, making it much easier to control and customize the installation process for a wider range of platforms.

CMake also makes it easier to automatically find and handle dependencies. As OpenVDB has a number of required and optional dependencies, it's recommended that new users to the software use the CMake build system over the Makefiles. If you're completely new to CMake, you may find it useful to read over the brief introduction to CMake and the CMake structure section below. However the build guide runs through the build process step by step.

CMake Structure

CMake will configure a set of build files which represent the commands and dependencies for the OpenVDB components you wish to install. Finding and handling these dependencies on different platforms comprises the majority of the complexity involved in writing CMake. In general, software which uses CMake is expected to provide their own configuration files which dependent software will locate and use. Not all of OpenVDB's dependencies provide CMake support and therefore do not deploy with CMake configurations that OpenVDB can use. OpenVDB provides a set of FindModules in the cmake folder for finding these various dependencies e.g. FindBlosc.cmake. These are designed such that they can theoretically be used by any project that needs to locate the given library and are invoked by the find_package() call. For more information on FindModules and locating packages with CMake, see the following CMake documentation:

The other type of file provided by OpenVDB are OpenVDBSetupX.cmake includes. These are primarily designed to configure the building of OpenVDB components against supported DCC's (Houdini/Maya) by locating their installations and setting various CMake variables for subsequent find_package() dependency calls. They also represent packages which already provide their own CMake modules, but additionally provide the same input variable interface as OpenVDB's other Find Modules.

Locating Dependencies

Each CMake FindModule provides a description of the possible inputs which can be provided to help drive the search for OpenVDB dependencies (as well as the resulting outputs). They have been homogenized such that these variables follow a set convention, typically followed by most CMake projects. For a given FindModule e.g. FindBlosc.cmake:

Mixing Dependency Installations

There may be a situation where you use a package manager to install some dependencies, use a DCC such as Maya to provide others and manually build and install others from source. Care must be taken when providing CMake with these locations to ensure that the correct files are used. Incorrect use of the above variables can lead to difficult to diagnose build and runtime errors.

As an example, let's assume we have a manual installation of TBB (either through a Maya installation or a manual installation from source) and we want to use this with other dependencies installed through a package manager such as homebrew. As homebrew copies all headers and libraries it installs to a <homebrew>/include <homebrew>/lib directory structure, it can be tempting to set Xxx_ROOT variables to points to the <homebrew> folder. However you may already have an existing installation of TBB through your package manager, potentially installed by as a dependency of a completely unrelated piece of software. Whilst CMake may report to you the correct include/lib path, this can end up being hidden at compile time through these types of shared installations. You should not rely on the dependency order of the CMake build system - instead, it's important that you try to use the explicit directory paths where possible. For example homebrew will install each piece of software to <homebrew>/Cellar/<dep_name>/<dep_version>, where the subsequent include and library directories can be passed to XXX_INCLUDEDIR and XXX_LIBRARYDIR respectively.

In summary try to stick to a single installation workflow and, if in doubt, provide direct include/lib paths to isolated software locations.

Blosc Support

Blosc is one of the optional dependencies of all OpenVDB components. It is the only dependency which is enabled by default. The documented build steps below treat blosc as a required dependency. There are two reasons for this:

You can disable Blosc using -D USE_BLOSC=OFF.

Building Dependencies using VCPKG

It is recommended to set the VCPKG_DEFAULT_TRIPLET=x64-windows environment variable to use 64-bit libraries by default as even on a 64-bit Windows OS, VCPKG builds and installs 32-bit libraries by default.

OpenVDB Components

The following table lists all targets (mainly library and binary components) which can be built through the CMake build system. They can be set when using CMake from the command line with -D VAR=ON/OFF or with a CMake gui:

Component Description CMake Variable Default
OpenVDB Core Library The Core OpenVDB shared/static library OPENVDB_BUILD_CORE ON
OpenVDB Print Command line binary for displaying information about OpenVDB files OPENVDB_BUILD_BINARIES / OPENVDB_BUILD_VDB_PRINT ON / ON
OpenVDB LOD Command line binary for generating volume mipmaps from an OpenVDB grid OPENVDB_BUILD_BINARIES / OPENVDB_BUILD_VDB_LOD ON / OFF
OpenVDB Render Command line binary for ray-tracing OpenVDB grids OPENVDB_BUILD_BINARIES / OPENVDB_BUILD_VDB_RENDER ON / OFF
OpenVDB View Command line binary for displaying OpenVDB grids in a GL viewport OPENVDB_BUILD_BINARIES / OPENVDB_BUILD_VDB_VIEW ON / OFF
OpenVDB Python Python module for OpenVDB C++ Python bindings OPENVDB_BUILD_PYTHON_MODULE OFF
OpenVDB UnitTests OpenVDB's Unit Test suite OPENVDB_BUILD_UNITTESTS OFF
OpenVDB Houdini Plugin The OpenVDB Houdini shared library and OpenVDB Nodes OPENVDB_BUILD_HOUDINI_PLUGIN OFF
OpenVDB Maya Plugin The Maya OpenVDB Nodes OPENVDB_BUILD_MAYA_PLUGIN OFF
Documentation The OpenVDB doxygen documentation OPENVDB_BUILD_DOCS OFF

Building With CMake

Build Types

The first step is to decide what type of OpenVDB build you're after. This primarily boils down to three main options:

Each option provides various benefits. Apart from the support for either the Houdini or Maya OpenVDB plugins, the latter two options can make it easier for new users to install the range of OpenVDB dependencies without having to worry about using a package manager or manually installing for source. You'll still be able to build and use all components of OpenVDB with these methods. However depending on the DCC (Digital Content Creation) software's version, you may find that some features of the Core library are restricted to ensure compatibility. For more information of building OpenVDB against a Houdini or Maya installation, see here.

Developers may wish to build a standalone version of OpenVDB to take advantage of newer dependencies and newer library features. See here for more information.

Note: Blosc is treated as a required dependency in these install instructions. See the blosc support section for more information.

Building Against Houdini/Maya

Building against a DCC reduces the list of dependencies you need to provide. You should not mix between Houdini and Maya libraries and should not attempt to build the Maya plugin using Houdini libraries and vice-versa. Additionally, it's a good idea to read the above section on mixing dependency installations.

DCC Supported Version OpenVDB ABI
Houdini 17.0 5
Houdini 17.5 5
Maya 2017 Any
Maya 2018 Any
Maya 2019 Any

Building Against Houdini

Houdini ships with a number of libraries that OpenVDB requires. When downloading Houdini, take note of the file version information. The version you install will determine the compiler version you should try and use to build OpenVDB. For example, for Linux Houdini 17.5, with a file name of houdini-17.5.219-linux_x86_64_gcc6.3.tar.gz, GCC 6.3 should be used. You will need to install some of the following dependencies depending on which OpenVDB components you wish to build.

Package Description OpenVDB Components
CMake Cross-platform family of tools designed to help build software All
C++11 Compiler Matching Houdini compiler and version All
Boost Components: system, iostreams, python, thread All
CppUnit A unit testing framework module for C++ Unit Tests
GLFW Simple API for OpenGL development OpenVDB View
Doxygen Documentation generation from C++ Documentation
Log4cplus An optional dependency for improved OpenVDB Logging Optional (All)
NumPy Scientific computing with Python Optional (Python)

At a minimum, boost, a matching C++11 compiler and CMake will be required. See the full dependency list for help with downloading and installing the above software. Note that as Blosc is provided as part of the Houdini installation USE_BLOSC should be left ON.

With the necessary dependencies installed, create and enter a directory for cmake to write to. It's generally useful to create this in the location you've extracted the OpenVDB repository. It will house CMake's generated build files.

mkdir build
cd build

Now you can call CMake by providing the absolute or relative path to the root of the OpenVDB source tree along with the following options:

Required:

Optional:

For example on MacOS and where the build folder has been created inside the OpenVDB source root:

cmake -D BOOST_ROOT=/path/to/boost/install \
-D Houdini_ROOT=/Applications/Houdini/Houdini17.0.506/ \
-D USE_HOUDINI=ON \
../

After the CMake build files have been successfully generated, run make within the build directory to compile the project, where the value of the j argument is the number of CPU threads to use for a multi-threaded build.

make -j4

Finally, once a successful build has completed, you can install all files.

make install

See the troubleshooting section for help with CMake and Make errors.

Building Against Maya

Supported versions of maya only ship with TBB.

Package Description OpenVDB Components
CMake Cross-platform family of tools designed to help build software All
C++11 Compiler Matching Houdini compiler and version All
Boost Components: system, iostreams, python, thread All
IlmBase Used half precision floating points and EXR serialization support All
ZLIB Compression library for disk serialization compression All
Blosc Recommended dependency for improved disk compression All*
CppUnit A unit testing framework module for C++ Unit Tests
GLFW Simple API for OpenGL development OpenVDB View
Doxygen Documentation generation from C++ Documentation
OpenEXR EXR serialization support Optional (Core) / OpenVDB Render
Log4cplus An optional dependency for improved OpenVDB Logging Optional (All)
NumPy Scientific computing with Python Optional (Python)

See blosc support

At a minimum, boost, a matching C++11 compiler, IlmBase, ZLIB, blosc and CMake will be required. See the full dependency list for help with downloading and installing the above software.

With the necessary dependencies installed, create and enter a directory for cmake to write to. It's generally useful to create this in the location you've extracted the OpenVDB repository. It will house CMake's generated build files.

mkdir build
cd build

Now you can call CMake by providing the absolute or relative path to the root of the OpenVDB source tree along with the following options:

Required:

Optional:

For example on MacOS and where the build folder has been created inside the OpenVDB source root:

cmake -D BOOST_ROOT=/path/to/boost/install \
-D IlmBase_ROOT=/path/to/ilmbase/install \
-D Maya_ROOT=/Applications/Autodesk/maya2019/ \
-D USE_MAYA=ON \
../

As the Maya plugin is disabled by default, you may also want to add -D OPENVDB_BUILD_MAYA_PLUGIN=ON to the command. The components section shows which targets are enabled by default.

After the CMake build files have been successfully generated, run make within the build directory to compile the project, where the value of the j argument is the number of CPU threads to use for a multi-threaded build.

make -j4

Finally, once a successful build has completed, you can install all files.

make install

Note: The Maya OpenVDB Visualize Node is only compatible with Legacy OpenGL support. You can enable this in Maya by navigating to Windows->Settings/Preferences->Preferences->Display and changing Rendering Engine to OpenGL - Legacy.

See the troubleshooting section for help with CMake and Make errors.

Building Standalone

It's recommended you first visit the dependency list page before attempting to run CMake on a standalone build. With the necessary dependencies installed, create and enter a directory for cmake to write to. It's generally useful to create this in the location you've extracted the OpenVDB repository. It will house CMake's generated build files.

mkdir build
cd build

Now you can call CMake by providing the absolute or relative path to the root of the OpenVDB source tree. Below are some common options you may want to provide:

For example, a typical first attempt at generating the build files may look as follows:

cmake -D CMAKE_INSTALL_PREFIX=$HOME/openvdb ../

See the components section to find which targets are available, their corresponding CMake flags and their default values.

After the CMake build files have been successfully generated, run make within the build directory to compile the project, where the value of the j argument is the number of CPU threads to use for a multi-threaded build.

make -j4

Finally, once a successful build has completed, you can install all files.

make install

See the troubleshooting section for help with CMake and Make errors.

Building With OpenVDB

This section is for users wishing to use a build of OpenVDB in their own applications with CMake.

The following assumes that OpenVDB was installed with OPENVDB_BUILD_CORE=ON and OPENVDB_INSTALL_CMAKE_MODULES=ON. Don't worry if you didn't specify these options directly, they both default to ON. This ensures that OpenVDB has installed the required CMake modules that your application will need to use.

Note: Typically, projects provide a Config-file rather than a Find-module for downstream use. OpenVDB currently provides a Find-module. This may change in the future. Further information here.

You can add the below CMake snippet to your main CMakeLists.txt to bring in OpenVDB as a dependency:

cmake_minimum_required(VERSION 3.3)
list(APPEND CMAKE_MODULE_PATH "/location/of/openvdb/install/lib/cmake/OpenVDB")
find_package(OpenVDB REQUIRED)
target_link_libraries(myapp OpenVDB::openvdb)

myapp in the above is a CMake target, usually created with add_library() or add_executable(). You can optionally provide CMAKE_MODULE_PATH as a -D argument to the cmake command line instead of specifying it in your CMakeLists.txt.

Note that the FindOpenVDB.cmake module relies on the other FindModules provided in the OpenVDB installation to find it's own dependencies. This may require you to provide additional dependency locations for OpenVDB's dependencies. See Locating Dependencies or the below troubleshooting for more information.

Building With Make

Makefiles are provided for those not wishing to use the CMake build system. However, Make support is now deprecated and will be removed in a future release, so one should not expect the Makefiles to provide the same level of functionality as the CMake build system.

To build the core library, ensure that you have GNU Make version 4.1 or later, then proceed as follows:

  1. Set values appropriate to your environment for the following variables at the top of openvdb/Makefile:

    INSTALL_DIR

    the directory into which to install libraries, executables and header files (e.g., /usr/local)

    BOOST_INCL_DIR

    the parent directory of the boost/ header directory (e.g., /usr/include)

    BOOST_LIB_DIR

    the directory containing libboost_iostreams, etc.

    BOOST_LIB

    linker flags for libboost_iostreams and libboost_system

    BOOST_THREAD_LIB

    linker flags for libboost_thread

    ILMBASE_INCL_DIR

    the parent directory of the OpenEXR/ header directory (which contains half.h)

    ILMBASE_LIB_DIR

    the directory containing libHalf.so and/or libHalf.a

    ILMBASE_LIB

    linker flags for libIlmThread, libIex and libImath

    HALF_LIB

    linker flag(s) for the Half library (e.g., -lHalf)

    EXR_INCL_DIR

    the parent directory of the OpenEXR/ header directory

    Note: some OpenEXR headers incorrectly include other OpenEXR headers with, e.g., #include <ImfName.h> instead of #include "ImfName.h". When compiling with Clang, set EXR_INCL_DIR to the parent directory of the OpenEXR/ directory and ILMBASE_INCL_DIR to the OpenEXR/ directory itself to avoid errors.

    EXR_LIB_DIR

    the directory containing libIlmImf

    EXR_LIB

    linker flags for libIlmImf

    TBB_INCL_DIR

    the parent directory of the tbb/ header directory

    TBB_LIB_DIR

    the directory containing libtbb

    TBB_LIB

    linker flag(s) for the TBB library (e.g., -ltbb)

    BLOSC_INCL_DIR

    the parent directory of the blosc.h header

    BLOSC_LIB_DIR

    the directory containing libblosc

    BLOSC_LIB

    linker flags for libblosc

    CONCURRENT_MALLOC_LIB_DIR

    a directory containing a scalable, concurrent malloc replacement library such as jemalloc or TBB malloc
    (leave blank if no such library is available, but be aware that using standard malloc in concurrent code incurs a significant performance penalty)

    CONCURRENT_MALLOC_LIB

    linker flag(s) for the malloc replacement library
    (e.g., -ltbbmalloc_proxy -ltbbmalloc)

    CPPUNIT_INCL_DIR

    the parent directory of the cppunit/ header directory
    (leave blank if CppUnit is not available)

    CPPUNIT_LIB_DIR

    the directory containing libcppunit.so or libcppunit.a

    CPPUNIT_LIB

    linker flag(s) for the CppUnit library (e.g., -lcppunit)

    GLFW_INCL_DIR

    the directory containing glfw.h
    (leave blank if GLFW is not available; GLFW is needed only for the command-line viewer tool)

    GLFW_LIB_DIR

    the directory containing libglfw

    GLFW_LIB

    linker flags for the GLFW library (e.g., -lglfw)

    GLFW_MAJOR_VERSION

    the major version number of the GLFW library
    (header filenames changed between GLFW 2 and 3, so this must be specified explicitly)

    LOG4CPLUS_INCL_DIR

    the parent directory of the log4cplus/ header directory
    (leave blank if log4cplus is not available)

    LOG4CPLUS_LIB_DIR

    directory containing liblog4cplus.so or liblog4cplus.a

    LOG4CPLUS_LIB

    linker flags for the log4cplus library (e.g., -llog4cplus)

    PYTHON_VERSION

    the version of Python (e.g., 2.7) for which to build the OpenVDB module (leave blank if Python is unavailable)

    PYTHON_INCL_DIR

    the directory containing the Python.h header file
    (on macOS, this is usually /System/Library/Frameworks/Python.framework/Versions/$(PYTHON_VERSION)/Headers)

    PYCONFIG_INCL_DIR

    the directory containing the pyconfig.h header file (usually but not always the same as PYTHON_INCL_DIR)

    PYTHON_LIB_DIR

    the directory containing the Python library
    (on macOS, this is usually /System/Library/Frameworks/Python.framework/Versions/$(PYTHON_VERSION)/lib)

    PYTHON_LIB

    linker flags for the Python library (e.g., -lpython2.7)

    BOOST_PYTHON_LIB_DIR

    the directory containing the Boost.Python library

    BOOST_PYTHON_LIB

    linker flags for the Boost.Python library (e.g., -lboost_python-mt)

    NUMPY_INCL_DIR

    the directory containing the NumPy arrayobject.h header file (leave blank if NumPy is unavailable)
    (on macOS, this is usually /System/Library/Frameworks/Python.framework/Versions/$(PYTHON_VERSION)/Extras/lib/python/numpy/core/include/numpy)

    EPYDOC

    the path to the Epydoc executable (leave blank if Epydoc is unavailable)

    PYTHON_WRAP_ALL_GRID_TYPES

    if set to "no", expose only FloatGrid, BoolGrid and Vec3SGrid in Python, otherwise expose (most of) the standard grid types defined in openvdb.h.

    DOXYGENthe path to the Doxygen executable (leave blank if Doxygen is unavailable)

    Note that if you plan to build the Houdini OpenVDB tools, you must build the OpenVDB library and the Houdini tools against compatible versions of the Boost, OpenEXR and TBB libraries. Until Houdini 16.5, all three were included in the HDK, so by default several of the variables above reference the Houdini environment variables $HDSO, $HFS and $HT (source the houdini_setup script provided with your Houdini installation to set those environment variables). You must provide your own installation of Boost.

    Also note that certain new features in OpenVDB (see the Release Notes for details) necessitated changes to the ABI of the Grid class, rendering it incompatible with earlier versions of the library, such as the ones built into Houdini. Passing grids between native VDB nodes in a scene graph and nodes built against the new ABI will lead to crashes, so to use OpenVDB with Houdini 17.5 set abi=5 to compile with the incompatible features disabled.

    To build the OpenVDB Python module, you will need local installations of Python, Boost.Python, and optionally NumPy. Houdini ships with Python 2 but not with the libboost_python library or with NumPy or with the Boost.Python headers, so both Boost.Python and NumPy have to be built separately. Point the variables $(BOOST_PYTHON_LIB_DIR), $(BOOST_PYTHON_LIB) and $(NUMPY_INCL_DIR) to your local installations of those libraries.

  2. From the top-level openvdb/ directory, type "make" (or "make -s" for less verbose output) to locally build the library and commands. The Makefile supports parallel builds (e.g. "make -j 8").

    A default local build generates the following libraries and executables (but see the Makefile for additional targets and build options):

    openvdb/libopenvdb.so.X.Y.Zthe OpenVDB library
    openvdb/libopenvdb.sosymlink to libopenvdb.so.X.Y.Z
    openvdb/pyopenvdb.sothe OpenVDB Python module (if Python and Boost.Python are available)
    openvdb/vdb_printcommand-line tool that prints info about OpenVDB .vdb files
    openvdb/vdb_rendercommand-line tool that ray-traces OpenVDB volumes
    openvdb/vdb_testunit test runner for libopenvdb (if CppUnit is available)

    From the openvdb/ directory, type "make test" to run the unit tests and verify that the library is working correctly. (Alternatively, once the library has been installed, run the unit test executable directly with "./vdb_test", or "./vdb_test -v" for more verbose output.) Type "make pytest" to run the Python module unit tests.

  3. From the openvdb/ directory, type "make doc" (or "make -s doc") to generate HTML library documentation, then open the file openvdb/doc/html/index.html in a browser. Type "make pydoc" (or "make -s pydoc") to generate HTML Python module documentation, then open openvdb/doc/html/python/index.html in a browser.

  4. Optionally (if OpenGL and GLFW are available), from the top-level openvdb/ directory, type "make vdb_view" (or "make -s vdb_view") to locally build the OpenVDB viewer tool. Then type "./vdb_view" for usage information.

  5. From the openvdb/ directory, type "make install" (or "make -s install") to copy generated files into the directory tree rooted at $(INSTALL_DIR).

To build the Houdini and Maya plugins the process is similar, but see the Makefiles in the openvdb_houdini/ and openvdb_maya/ directories for additional requirements


Troubleshooting

If after reading this guide you're unable to find your specific issue below, please get in touch with the OpenVDB TSC.

Note: If running into issues when changing CMake settings/dependency paths, try clearing the designated CMake build directory and running your cmake command again.

CMake Error ... Could NOT find XXX (missing: ... )

It's fairly typical that CMake may fail to find some dependencies on first runs, especially if you've manually compiled from source your own dependencies. Analyzing any dependency errors will help with running further invocations of cmake. The Locating Dependencies section details the variable format required to point CMake to the correct locations. Alternatively, with interactive cmake systems such as ccmake or CMake GUI, variables which are not found will be shown, allowing you to provide them directly.

As an example, earlier versions of Threading Building Blocks (TBB) do not come with CMake modules or pkg-config modules. For OpenVDB to locate TBB, you typically need to provide this location manually:

cmake -D CMAKE_INSTALL_PREFIX=$HOME/openvdb -D TBB_ROOT=/path/to/tbb/install ../

Note that this is also equivalent to:

cmake -D CMAKE_INSTALL_PREFIX=$HOME/openvdb \
-D TBB_INCLUDEDIR=/path/to/tbb/install/include \
-D TBB_LIBRARYDIR=/path/to/tbb/install/lib \
../

CMake Error ... Could NOT find XXX (Found unsuitable version: ... )

By default, OpenVDB sets a number of minimum version requires for its dependencies. These can be found in the root CMakeList.txt or in the dependency table. These minimum versions either track the oldest supported VFX Reference Platform or are otherwise required for compatibility. Although not recommended, you can bypass these checks with -D DISABLE_DEPENDENCY_VERSION_CHECKS=ON if necessary. Note that using older or untested dependencies may produce undesired behavior. Older versions in particular are not supported by OpenVDB.

Note: Boost will produce a version error in the format Detected version of Boost is too old.

CMake warnings/errors in FindBoost.cmake

There are a variety of potential warnings and errors that may arise from the version compatibility of Boost and CMake. These are related to how both Boost and CMake have historically been kept in sync. A common warning and error combination is:

CMake Warning at ... Imported targets not available for Boost version XXXXXX
...
Target "..." links to target "Boost::XXX" but the target
was not found. Perhaps a find_package() call is missing for an IMPORTED
target, or an ALIAS target is missing?

OpenVDB uses imported targets for all its dependencies. For imported Boost compatibility, the following versions of CMake are required:

Use the above list to identify the version of CMake you require for your version of Boost. Note that this may be implemented into the OpenVDB CMake in the future.