Implementation of OpenVDB as a possible cache format for smoke

simulations.

This commits implements OpenVDB as an extra cache format in the Point
Cache system for smoke simulations. Compilation with the library is
turned off by default for now, and shall be enabled when the library is
present.

A documentation of its doings is available here: http://
wiki.blender.org/index.php/User:Kevindietrich/OpenVDBSmokeExport.

A guide to compile OpenVDB can be found here (Linux): http://
wiki.blender.org/index.php?title=Dev:Doc/Building_Blender/Linux/
Dependencies_From_Source#OpenVDB

Reviewers: sergey, lukastoenne, brecht, campbellbarton

Reviewed By: brecht, campbellbarton

Subscribers: galenb, Blendify, robocyte, Lapineige, bliblubli,
jtheninja, lukasstockner97, dingto, brecht

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

11 files changed, 1175 insertions, 0 deletions

diff --git a/intern/openvdb/CMakeLists.txt b/intern/openvdb/CMakeLists.txt
new file mode 100644
index 00000000000..ce683e7d319
--- /dev/null
+++ b/intern/openvdb/CMakeLists.txt
@@ -0,0 +1,69 @@
+# ***** 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.
+#
+# The Original Code is Copyright (C) 2015, Blender Foundation
+# All rights reserved.
+#
+# The Original Code is: all of this file.
+#
+# Contributor(s): Kevin Dietrich.
+#
+# ***** END GPL LICENSE BLOCK *****
+
+set(INC
+	.
+	intern
+)
+
+set(INC_SYS
+)
+
+set(SRC
+	openvdb_capi.h
+)
+
+if(WITH_OPENVDB)
+	add_definitions(
+		-DWITH_OPENVDB
+	)
+
+	list(APPEND INC_SYS
+		${BOOST_INCLUDE_DIR}
+		${OPENEXR_INCLUDE_DIRS}
+		${OPENVDB_INCLUDE_DIRS}
+	)
+
+	list(APPEND SRC
+		intern/openvdb_dense_convert.cc
+		intern/openvdb_reader.cc
+		intern/openvdb_writer.cc
+		openvdb_capi.cc
+		openvdb_util.cc
+
+		intern/openvdb_dense_convert.h
+		intern/openvdb_reader.h
+		intern/openvdb_writer.h
+		openvdb_util.h
+	)
+
+	if(WITH_OPENVDB_BLOSC)
+		add_definitions(
+			-DWITH_OPENVDB_BLOSC
+		)
+	endif()
+endif()
+
+blender_add_lib(bf_intern_openvdb "${SRC}" "${INC}" "${INC_SYS}")
diff --git a/intern/openvdb/intern/openvdb_dense_convert.cc b/intern/openvdb/intern/openvdb_dense_convert.cc
new file mode 100644
index 00000000000..d4f62776988
--- /dev/null
+++ b/intern/openvdb/intern/openvdb_dense_convert.cc
@@ -0,0 +1,167 @@
+/*
+ * ***** 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.
+ *
+ * The Original Code is Copyright (C) 2015 Blender Foundation.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): Kevin Dietrich
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#include "openvdb_dense_convert.h"
+
+#include <openvdb/tools/ValueTransformer.h>  /* for tools::foreach */
+
+namespace internal {
+
+openvdb::Mat4R convertMatrix(const float mat[4][4])
+{
+	return openvdb::Mat4R(
+	        mat[0][0], mat[0][1], mat[0][2], mat[0][3],
+	        mat[1][0], mat[1][1], mat[1][2], mat[1][3],
+	        mat[2][0], mat[2][1], mat[2][2], mat[2][3],
+	        mat[3][0], mat[3][1], mat[3][2], mat[3][3]);
+}
+
+
+class MergeScalarGrids {
+	typedef openvdb::FloatTree ScalarTree;
+
+	openvdb::tree::ValueAccessor<const ScalarTree> m_acc_x, m_acc_y, m_acc_z;
+
+public:
+	MergeScalarGrids(const ScalarTree *x_tree, const ScalarTree *y_tree, const ScalarTree *z_tree)
+	    : m_acc_x(*x_tree)
+	    , m_acc_y(*y_tree)
+	    , m_acc_z(*z_tree)
+	{}
+
+	MergeScalarGrids(const MergeScalarGrids &other)
+	    : m_acc_x(other.m_acc_x)
+	    , m_acc_y(other.m_acc_y)
+	    , m_acc_z(other.m_acc_z)
+	{}
+
+	void operator()(const openvdb::Vec3STree::ValueOnIter &it) const
+	{
+		using namespace openvdb;
+
+		const math::Coord xyz = it.getCoord();
+		float x = m_acc_x.getValue(xyz);
+		float y = m_acc_y.getValue(xyz);
+		float z = m_acc_z.getValue(xyz);
+
+		it.setValue(math::Vec3s(x, y, z));
+	}
+};
+
+openvdb::GridBase *OpenVDB_export_vector_grid(
+        OpenVDBWriter *writer,
+        const openvdb::Name &name,
+        const float *data_x, const float *data_y, const float *data_z,
+        const int res[3],
+        float fluid_mat[4][4],
+        openvdb::VecType vec_type,
+        const bool is_color,
+        const openvdb::FloatGrid *mask)
+{
+	using namespace openvdb;
+
+	math::CoordBBox bbox(Coord(0), Coord(res[0] - 1, res[1] - 1, res[2] - 1));
+	Mat4R mat = convertMatrix(fluid_mat);
+	math::Transform::Ptr transform = math::Transform::createLinearTransform(mat);
+
+	FloatGrid::Ptr grid[3];
+
+	grid[0] = FloatGrid::create(0.0f);
+	tools::Dense<const float, tools::LayoutXYZ> dense_grid_x(bbox, data_x);
+	tools::copyFromDense(dense_grid_x, grid[0]->tree(), TOLERANCE);
+
+	grid[1] = FloatGrid::create(0.0f);
+	tools::Dense<const float, tools::LayoutXYZ> dense_grid_y(bbox, data_y);
+	tools::copyFromDense(dense_grid_y, grid[1]->tree(), TOLERANCE);
+
+	grid[2] = FloatGrid::create(0.0f);
+	tools::Dense<const float, tools::LayoutXYZ> dense_grid_z(bbox, data_z);
+	tools::copyFromDense(dense_grid_z, grid[2]->tree(), TOLERANCE);
+
+	Vec3SGrid::Ptr vecgrid = Vec3SGrid::create(Vec3s(0.0f));
+
+	/* Activate voxels in the vector grid based on the scalar grids to ensure
+	 * thread safety later on */
+	for (int i = 0; i < 3; ++i) {
+		vecgrid->tree().topologyUnion(grid[i]->tree());
+	}
+
+	MergeScalarGrids op(&(grid[0]->tree()), &(grid[1]->tree()), &(grid[2]->tree()));
+	tools::foreach(vecgrid->beginValueOn(), op, true, false);
+
+	vecgrid->setTransform(transform);
+
+	if (mask) {
+		vecgrid = tools::clip(*vecgrid, *mask);
+	}
+
+	vecgrid->setName(name);
+	vecgrid->setIsInWorldSpace(false);
+	vecgrid->setVectorType(vec_type);
+	vecgrid->insertMeta("is_color", BoolMetadata(is_color));
+	vecgrid->setGridClass(GRID_STAGGERED);
+
+	writer->insert(vecgrid);
+
+	return vecgrid.get();
+}
+
+void OpenVDB_import_grid_vector(
+        OpenVDBReader *reader,
+        const openvdb::Name &name,
+        float **data_x, float **data_y, float **data_z,
+        const int res[3])
+{
+	using namespace openvdb;
+
+	if (!reader->hasGrid(name)) {
+		std::fprintf(stderr, "OpenVDB grid %s not found in file!\n", name.c_str());
+		memset(*data_x, 0, sizeof(float) * res[0] * res[1] * res[2]);
+		memset(*data_y, 0, sizeof(float) * res[0] * res[1] * res[2]);
+		memset(*data_z, 0, sizeof(float) * res[0] * res[1] * res[2]);
+		return;
+	}
+
+	Vec3SGrid::Ptr vgrid = gridPtrCast<Vec3SGrid>(reader->getGrid(name));
+	Vec3SGrid::ConstAccessor acc = vgrid->getConstAccessor();
+	math::Coord xyz;
+	int &x = xyz[0], &y = xyz[1], &z = xyz[2];
+
+	size_t index = 0;
+	for (z = 0; z < res[2]; ++z) {
+		for (y = 0; y < res[1]; ++y) {
+			for (x = 0; x < res[0]; ++x, ++index) {
+				math::Vec3s value = acc.getValue(xyz);
+				(*data_x)[index] = value.x();
+				(*data_y)[index] = value.y();
+				(*data_z)[index] = value.z();
+			}
+		}
+	}
+}
+
+}  /* namespace internal */
diff --git a/intern/openvdb/intern/openvdb_dense_convert.h b/intern/openvdb/intern/openvdb_dense_convert.h
new file mode 100644
index 00000000000..fd10334c4ad
--- /dev/null
+++ b/intern/openvdb/intern/openvdb_dense_convert.h
@@ -0,0 +1,130 @@
+/*
+ * ***** 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.
+ *
+ * The Original Code is Copyright (C) 2015 Blender Foundation.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): Kevin Dietrich
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#ifndef __OPENVDB_DENSE_CONVERT_H__
+#define __OPENVDB_DENSE_CONVERT_H__
+
+#include "openvdb_reader.h"
+#include "openvdb_writer.h"
+
+#include <openvdb/tools/Clip.h>
+#include <openvdb/tools/Dense.h>
+
+#include <cstdio>
+
+#define TOLERANCE 1e-3f
+
+namespace internal {
+
+openvdb::Mat4R convertMatrix(const float mat[4][4]);
+
+template <typename GridType, typename T>
+GridType *OpenVDB_export_grid(
+        OpenVDBWriter *writer,
+        const openvdb::Name &name,
+        const T *data,
+        const int res[3],
+        float fluid_mat[4][4],
+        const openvdb::FloatGrid *mask)
+{
+	using namespace openvdb;
+
+	math::CoordBBox bbox(Coord(0), Coord(res[0] - 1, res[1] - 1, res[2] - 1));
+	Mat4R mat = convertMatrix(fluid_mat);
+	math::Transform::Ptr transform = math::Transform::createLinearTransform(mat);
+
+	typename GridType::Ptr grid = GridType::create(T(0));
+
+	tools::Dense<const T, openvdb::tools::LayoutXYZ> dense_grid(bbox, data);
+	tools::copyFromDense(dense_grid, grid->tree(), (T)TOLERANCE);
+
+	grid->setTransform(transform);
+
+	if (mask) {
+		grid = tools::clip(*grid, *mask);
+	}
+
+	grid->setName(name);
+	grid->setIsInWorldSpace(false);
+	grid->setVectorType(openvdb::VEC_INVARIANT);
+
+	writer->insert(grid);
+
+	return grid.get();
+}
+
+template <typename GridType, typename T>
+void OpenVDB_import_grid(
+        OpenVDBReader *reader,
+        const openvdb::Name &name,
+        T **data,
+        const int res[3])
+{
+	using namespace openvdb;
+
+	if (!reader->hasGrid(name)) {
+		std::fprintf(stderr, "OpenVDB grid %s not found in file!\n", name.c_str());
+		memset(*data, 0, sizeof(T) * res[0] * res[1] * res[2]);
+		return;
+	}
+
+	typename GridType::Ptr grid = gridPtrCast<GridType>(reader->getGrid(name));
+	typename GridType::ConstAccessor acc = grid->getConstAccessor();
+
+	math::Coord xyz;
+	int &x = xyz[0], &y = xyz[1], &z = xyz[2];
+
+	size_t index = 0;
+	for (z = 0; z < res[2]; ++z) {
+		for (y = 0; y < res[1]; ++y) {
+			for (x = 0; x < res[0]; ++x, ++index) {
+				(*data)[index] = acc.getValue(xyz);
+			}
+		}
+	}
+}
+
+openvdb::GridBase *OpenVDB_export_vector_grid(
+        OpenVDBWriter *writer,
+        const openvdb::Name &name,
+        const float *data_x, const float *data_y, const float *data_z,
+        const int res[3],
+        float fluid_mat[4][4],
+        openvdb::VecType vec_type,
+        const bool is_color,
+        const openvdb::FloatGrid *mask);
+
+
+void OpenVDB_import_grid_vector(
+        OpenVDBReader *reader,
+        const openvdb::Name &name,
+        float **data_x, float **data_y, float **data_z,
+        const int res[3]);
+
+}  /* namespace internal */
+
+#endif /* __OPENVDB_DENSE_CONVERT_H__ */
diff --git a/intern/openvdb/intern/openvdb_reader.cc b/intern/openvdb/intern/openvdb_reader.cc
new file mode 100644
index 00000000000..8b15b81710d
--- /dev/null
+++ b/intern/openvdb/intern/openvdb_reader.cc
@@ -0,0 +1,136 @@
+/*
+ * ***** 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.
+ *
+ * The Original Code is Copyright (C) 2015 Blender Foundation.
+ * All rights reserved.
+ *
+ * Contributor(s): Kevin Dietrich
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#include "openvdb_reader.h"
+#include "openvdb_util.h"
+
+OpenVDBReader::OpenVDBReader()
+    : m_meta_map(new openvdb::MetaMap)
+    , m_file(NULL)
+{
+	/* Although it is safe, it may not be good to have this here, could be done
+	 * once instead of everytime we read a file. */
+	openvdb::initialize();
+}
+
+OpenVDBReader::~OpenVDBReader()
+{
+	cleanupFile();
+}
+
+void OpenVDBReader::open(const openvdb::Name &filename)
+{
+	cleanupFile();
+
+	try {
+		m_file = new openvdb::io::File(filename);
+		m_file->setCopyMaxBytes(0);
+		m_file->open();
+
+		m_meta_map = m_file->getMetadata();
+	}
+	/* Mostly to catch exceptions related to Blosc not being supported. */
+	catch (const openvdb::IoError &e) {
+		std::cerr << e.what() << '\n';
+		cleanupFile();
+	}
+}
+
+void OpenVDBReader::floatMeta(const openvdb::Name &name, float &value) const
+{
+	try {
+		value = m_meta_map->metaValue<float>(name);
+	}
+	CATCH_KEYERROR;
+}
+
+void OpenVDBReader::intMeta(const openvdb::Name &name, int &value) const
+{
+	try {
+		value = m_meta_map->metaValue<int>(name);
+	}
+	CATCH_KEYERROR;
+}
+
+void OpenVDBReader::vec3sMeta(const openvdb::Name &name, float value[3]) const
+{
+	try {
+		openvdb::Vec3s meta_val = m_meta_map->metaValue<openvdb::Vec3s>(name);
+
+		value[0] = meta_val.x();
+		value[1] = meta_val.y();
+		value[2] = meta_val.z();
+	}
+	CATCH_KEYERROR;
+}
+
+void OpenVDBReader::vec3IMeta(const openvdb::Name &name, int value[3]) const
+{
+	try {
+		openvdb::Vec3i meta_val = m_meta_map->metaValue<openvdb::Vec3i>(name);
+
+		value[0] = meta_val.x();
+		value[1] = meta_val.y();
+		value[2] = meta_val.z();
+	}
+	CATCH_KEYERROR;
+}
+
+void OpenVDBReader::mat4sMeta(const openvdb::Name &name, float value[4][4]) const
+{
+	try {
+		openvdb::Mat4s meta_val = m_meta_map->metaValue<openvdb::Mat4s>(name);
+
+		for (int i =  0; i < 4; ++i) {
+			for (int j = 0; j < 4; ++j) {
+				value[i][j] = meta_val[i][j];
+			}
+		}
+	}
+	CATCH_KEYERROR;
+}
+
+bool OpenVDBReader::hasGrid(const openvdb::Name &name) const
+{
+	return m_file->hasGrid(name);
+}
+
+openvdb::GridBase::Ptr OpenVDBReader::getGrid(const openvdb::Name &name) const
+{
+	return m_file->readGrid(name);
+}
+
+size_t OpenVDBReader::numGrids() const
+{
+	return m_file->getGrids()->size();
+}
+
+void OpenVDBReader::cleanupFile()
+{
+	if (m_file) {
+		m_file->close();
+		delete m_file;
+	}
+}
diff --git a/intern/openvdb/intern/openvdb_reader.h b/intern/openvdb/intern/openvdb_reader.h
new file mode 100644
index 00000000000..07f77130ff9
--- /dev/null
+++ b/intern/openvdb/intern/openvdb_reader.h
@@ -0,0 +1,55 @@
+/*
+ * ***** 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.
+ *
+ * The Original Code is Copyright (C) 2015 Blender Foundation.
+ * All rights reserved.
+ *
+ * Contributor(s): Kevin Dietrich
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#ifndef __OPENVDB_READER_H__
+#define __OPENVDB_READER_H__
+
+#include <openvdb/openvdb.h>
+
+struct OpenVDBReader {
+private:
+	openvdb::MetaMap::Ptr m_meta_map;
+	openvdb::io::File *m_file;
+
+	void cleanupFile();
+
+public:
+	OpenVDBReader();
+	~OpenVDBReader();
+
+	void open(const openvdb::Name &filename);
+
+	void floatMeta(const openvdb::Name &name, float &value) const;
+	void intMeta(const openvdb::Name &name, int &value) const;
+	void vec3sMeta(const openvdb::Name &name, float value[3]) const;
+	void vec3IMeta(const openvdb::Name &name, int value[3]) const;
+	void mat4sMeta(const openvdb::Name &name, float value[4][4]) const;
+
+	bool hasGrid(const openvdb::Name &name) const;
+	openvdb::GridBase::Ptr getGrid(const openvdb::Name &name) const;
+	size_t numGrids() const;
+};
+
+#endif /* __OPENVDB_READER_H__ */
diff --git a/intern/openvdb/intern/openvdb_writer.cc b/intern/openvdb/intern/openvdb_writer.cc
new file mode 100644
index 00000000000..923752909d9
--- /dev/null
+++ b/intern/openvdb/intern/openvdb_writer.cc
@@ -0,0 +1,118 @@
+/*
+ * ***** 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.
+ *
+ * The Original Code is Copyright (C) 2015 Blender Foundation.
+ * All rights reserved.
+ *
+ * Contributor(s): Kevin Dietrich
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#include "openvdb_writer.h"
+#include "openvdb_util.h"
+
+OpenVDBWriter::OpenVDBWriter()
+    : m_grids(new openvdb::GridPtrVec())
+    , m_meta_map(new openvdb::MetaMap())
+    , m_save_as_half(false)
+{
+	m_meta_map->insertMeta("creator", openvdb::StringMetadata("Blender/Smoke"));
+}
+
+OpenVDBWriter::~OpenVDBWriter()
+{}
+
+void OpenVDBWriter::insert(const openvdb::GridBase::Ptr &grid)
+{
+	grid->setSaveFloatAsHalf(m_save_as_half);
+	m_grids->push_back(grid);
+}
+
+void OpenVDBWriter::insert(const openvdb::GridBase &grid)
+{
+	m_grids->push_back(grid.copyGrid());
+}
+
+void OpenVDBWriter::insertFloatMeta(const openvdb::Name &name, const float value)
+{
+	try {
+		m_meta_map->insertMeta(name, openvdb::FloatMetadata(value));
+	}
+	CATCH_KEYERROR;
+}
+
+void OpenVDBWriter::insertIntMeta(const openvdb::Name &name, const int value)
+{
+	try {
+		m_meta_map->insertMeta(name, openvdb::Int32Metadata(value));
+	}
+	CATCH_KEYERROR;
+}
+
+void OpenVDBWriter::insertVec3sMeta(const openvdb::Name &name, const openvdb::Vec3s &value)
+{
+	try {
+		m_meta_map->insertMeta(name, openvdb::Vec3SMetadata(value));
+	}
+	CATCH_KEYERROR;
+}
+
+void OpenVDBWriter::insertVec3IMeta(const openvdb::Name &name, const openvdb::Vec3I &value)
+{
+	try {
+		m_meta_map->insertMeta(name, openvdb::Vec3IMetadata(value));
+	}
+	CATCH_KEYERROR;
+}
+
+void OpenVDBWriter::insertMat4sMeta(const openvdb::Name &name, const float value[4][4])
+{
+	openvdb::Mat4s mat = openvdb::Mat4s(
+	    value[0][0], value[0][1], value[0][2], value[0][3],
+	    value[1][0], value[1][1], value[1][2], value[1][3],
+	    value[2][0], value[2][1], value[2][2], value[2][3],
+	    value[3][0], value[3][1], value[3][2], value[3][3]);
+
+	try {
+		m_meta_map->insertMeta(name, openvdb::Mat4SMetadata(mat));
+	}
+	CATCH_KEYERROR;
+}
+
+void OpenVDBWriter::setFlags(const int compression, const bool save_as_half)
+{
+	m_compression_flags = compression;
+	m_save_as_half = save_as_half;
+}
+
+void OpenVDBWriter::write(const openvdb::Name &filename) const
+{
+	try {
+		openvdb::io::File file(filename);
+		file.setCompression(m_compression_flags);
+		file.write(*m_grids, *m_meta_map);
+		file.close();
+
+		/* Should perhaps be an option at some point */
+		m_grids->clear();
+	}
+	/* Mostly to catch exceptions related to Blosc not being supported. */
+	catch (const openvdb::IoError &e) {
+		std::cerr << e.what() << '\n';
+	}
+}
diff --git a/intern/openvdb/intern/openvdb_writer.h b/intern/openvdb/intern/openvdb_writer.h
new file mode 100644
index 00000000000..69f42473975
--- /dev/null
+++ b/intern/openvdb/intern/openvdb_writer.h
@@ -0,0 +1,57 @@
+/*
+ * ***** 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.
+ *
+ * The Original Code is Copyright (C) 2015 Blender Foundation.
+ * All rights reserved.
+ *
+ * Contributor(s): Kevin Dietrich
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#ifndef __OPENVDB_WRITER_H__
+#define __OPENVDB_WRITER_H__
+
+#include <openvdb/openvdb.h>
+
+struct OpenVDBWriter {
+private:
+	openvdb::GridPtrVecPtr m_grids;
+	openvdb::MetaMap::Ptr m_meta_map;
+
+	int m_compression_flags;
+	bool m_save_as_half;
+
+public:
+	OpenVDBWriter();
+	~OpenVDBWriter();
+
+	void insert(const openvdb::GridBase::Ptr &grid);
+	void insert(const openvdb::GridBase &grid);
+
+	void insertFloatMeta(const openvdb::Name &name, const float value);
+	void insertIntMeta(const openvdb::Name &name, const int value);
+	void insertVec3sMeta(const openvdb::Name &name, const openvdb::Vec3s &value);
+	void insertVec3IMeta(const openvdb::Name &name, const openvdb::Vec3I &value);
+	void insertMat4sMeta(const openvdb::Name &name, const float value[4][4]);
+
+	void setFlags(const int compression, const bool save_as_half);
+
+	void write(const openvdb::Name &filename) const;
+};
+
+#endif /* __OPENVDB_WRITER_H__ */
diff --git a/intern/openvdb/openvdb_capi.cc b/intern/openvdb/openvdb_capi.cc
new file mode 100644
index 00000000000..ef4f8c8820f
--- /dev/null
+++ b/intern/openvdb/openvdb_capi.cc
@@ -0,0 +1,240 @@
+/*
+ * ***** 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.
+ *
+ * The Original Code is Copyright (C) 2015 Blender Foundation.
+ * All rights reserved.
+ *
+ * Contributor(s): Kevin Dietrich
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#include "openvdb_capi.h"
+#include "openvdb_dense_convert.h"
+#include "openvdb_util.h"
+
+struct OpenVDBFloatGrid { int unused; };
+struct OpenVDBIntGrid { int unused; };
+struct OpenVDBVectorGrid { int unused; };
+
+int OpenVDB_getVersionHex()
+{
+	return openvdb::OPENVDB_LIBRARY_VERSION;
+}
+
+OpenVDBFloatGrid *OpenVDB_export_grid_fl(
+        OpenVDBWriter *writer,
+        const char *name, float *data,
+        const int res[3], float matrix[4][4],
+        OpenVDBFloatGrid *mask)
+{
+	Timer(__func__);
+
+	using openvdb::FloatGrid;
+
+	FloatGrid *mask_grid = reinterpret_cast<FloatGrid *>(mask);
+	FloatGrid *grid = internal::OpenVDB_export_grid<FloatGrid>(
+	        writer,
+	        name,
+	        data,
+	        res,
+	        matrix,
+	        mask_grid);
+
+	return reinterpret_cast<OpenVDBFloatGrid *>(grid);
+}
+
+OpenVDBIntGrid *OpenVDB_export_grid_ch(
+        OpenVDBWriter *writer,
+        const char *name, unsigned char *data,
+        const int res[3], float matrix[4][4],
+        OpenVDBFloatGrid *mask)
+{
+	Timer(__func__);
+
+	using openvdb::FloatGrid;
+	using openvdb::Int32Grid;
+
+	FloatGrid *mask_grid = reinterpret_cast<FloatGrid *>(mask);
+	Int32Grid *grid = internal::OpenVDB_export_grid<Int32Grid>(
+	        writer,
+	        name,
+	        data,
+	        res,
+	        matrix,
+	        mask_grid);
+
+	return reinterpret_cast<OpenVDBIntGrid *>(grid);
+}
+
+OpenVDBVectorGrid *OpenVDB_export_grid_vec(
+        struct OpenVDBWriter *writer,
+        const char *name,
+        const float *data_x, const float *data_y, const float *data_z,
+        const int res[3], float matrix[4][4], short vec_type,
+        const bool is_color, OpenVDBFloatGrid *mask)
+{
+	Timer(__func__);
+
+	using openvdb::GridBase;
+	using openvdb::FloatGrid;
+	using openvdb::VecType;
+
+	FloatGrid *mask_grid = reinterpret_cast<FloatGrid *>(mask);
+	GridBase *grid = internal::OpenVDB_export_vector_grid(
+	        writer,
+	        name,
+	        data_x,
+	        data_y,
+	        data_z,
+	        res,
+	        matrix,
+	        static_cast<VecType>(vec_type),
+	        is_color,
+	        mask_grid);
+
+	return reinterpret_cast<OpenVDBVectorGrid *>(grid);
+}
+
+void OpenVDB_import_grid_fl(
+        OpenVDBReader *reader,
+        const char *name, float **data,
+        const int res[3])
+{
+	Timer(__func__);
+
+	internal::OpenVDB_import_grid<openvdb::FloatGrid>(reader, name, data, res);
+}
+
+void OpenVDB_import_grid_ch(
+        OpenVDBReader *reader,
+        const char *name, unsigned char **data,
+        const int res[3])
+{
+	internal::OpenVDB_import_grid<openvdb::Int32Grid>(reader, name, data, res);
+}
+
+void OpenVDB_import_grid_vec(
+        struct OpenVDBReader *reader,
+        const char *name,
+        float **data_x, float **data_y, float **data_z,
+        const int res[3])
+{
+	Timer(__func__);
+
+	internal::OpenVDB_import_grid_vector(reader, name, data_x, data_y, data_z, res);
+}
+
+OpenVDBWriter *OpenVDBWriter_create()
+{
+	return new OpenVDBWriter();
+}
+
+void OpenVDBWriter_free(OpenVDBWriter *writer)
+{
+	delete writer;
+}
+
+void OpenVDBWriter_set_flags(OpenVDBWriter *writer, const int flag, const bool half)
+{
+	int compression_flags = openvdb::io::COMPRESS_ACTIVE_MASK;
+
+#ifdef WITH_OPENVDB_BLOSC
+	if (flag == 0) {
+		compression_flags |= openvdb::io::COMPRESS_BLOSC;
+	}
+	else
+#endif
+	if (flag == 1) {
+		compression_flags |= openvdb::io::COMPRESS_ZIP;
+	}
+	else {
+		compression_flags = openvdb::io::COMPRESS_NONE;
+	}
+
+	writer->setFlags(compression_flags, half);
+}
+
+void OpenVDBWriter_add_meta_fl(OpenVDBWriter *writer, const char *name, const float value)
+{
+	writer->insertFloatMeta(name, value);
+}
+
+void OpenVDBWriter_add_meta_int(OpenVDBWriter *writer, const char *name, const int value)
+{
+	writer->insertIntMeta(name, value);
+}
+
+void OpenVDBWriter_add_meta_v3(OpenVDBWriter *writer, const char *name, const float value[3])
+{
+	writer->insertVec3sMeta(name, value);
+}
+
+void OpenVDBWriter_add_meta_v3_int(OpenVDBWriter *writer, const char *name, const int value[3])
+{
+	writer->insertVec3IMeta(name, value);
+}
+
+void OpenVDBWriter_add_meta_mat4(OpenVDBWriter *writer, const char *name, float value[4][4])
+{
+	writer->insertMat4sMeta(name, value);
+}
+
+void OpenVDBWriter_write(OpenVDBWriter *writer, const char *filename)
+{
+	writer->write(filename);
+}
+
+OpenVDBReader *OpenVDBReader_create()
+{
+	return new OpenVDBReader();
+}
+
+void OpenVDBReader_free(OpenVDBReader *reader)
+{
+	delete reader;
+}
+
+void OpenVDBReader_open(OpenVDBReader *reader, const char *filename)
+{
+	reader->open(filename);
+}
+
+void OpenVDBReader_get_meta_fl(OpenVDBReader *reader, const char *name, float *value)
+{
+	reader->floatMeta(name, *value);
+}
+
+void OpenVDBReader_get_meta_int(OpenVDBReader *reader, const char *name, int *value)
+{
+	reader->intMeta(name, *value);
+}
+
+void OpenVDBReader_get_meta_v3(OpenVDBReader *reader, const char *name, float value[3])
+{
+	reader->vec3sMeta(name, value);
+}
+
+void OpenVDBReader_get_meta_v3_int(OpenVDBReader *reader, const char *name, int value[3])
+{
+	reader->vec3IMeta(name, value);
+}
+
+void OpenVDBReader_get_meta_mat4(OpenVDBReader *reader, const char *name, float value[4][4])
+{
+	reader->mat4sMeta(name, value);
+}
diff --git a/intern/openvdb/openvdb_capi.h b/intern/openvdb/openvdb_capi.h
new file mode 100644
index 00000000000..2d2feeadcf1
--- /dev/null
+++ b/intern/openvdb/openvdb_capi.h
@@ -0,0 +1,108 @@
+/*
+ * ***** 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.
+ *
+ * The Original Code is Copyright (C) 2015 Blender Foundation.
+ * All rights reserved.
+ *
+ * Contributor(s): Kevin Dietrich
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#ifndef __OPENVDB_CAPI_H__
+#define __OPENVDB_CAPI_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct OpenVDBReader;
+struct OpenVDBWriter;
+struct OpenVDBFloatGrid;
+struct OpenVDBIntGrid;
+struct OpenVDBVectorGrid;
+
+int OpenVDB_getVersionHex(void);
+
+enum {
+	VEC_INVARIANT = 0,
+	VEC_COVARIANT = 1,
+	VEC_COVARIANT_NORMALIZE = 2,
+	VEC_CONTRAVARIANT_RELATIVE = 3,
+	VEC_CONTRAVARIANT_ABSOLUTE = 4,
+};
+
+struct OpenVDBFloatGrid *OpenVDB_export_grid_fl(
+        struct OpenVDBWriter *writer,
+        const char *name, float *data,
+        const int res[3], float matrix[4][4],
+        struct OpenVDBFloatGrid *mask);
+
+struct OpenVDBIntGrid *OpenVDB_export_grid_ch(
+        struct OpenVDBWriter *writer,
+        const char *name, unsigned char *data,
+        const int res[3], float matrix[4][4],
+        struct OpenVDBFloatGrid *mask);
+
+struct OpenVDBVectorGrid *OpenVDB_export_grid_vec(
+        struct OpenVDBWriter *writer,
+        const char *name,
+        const float *data_x, const float *data_y, const float *data_z,
+        const int res[3], float matrix[4][4], short vec_type,
+        const bool is_color,
+        struct OpenVDBFloatGrid *mask);
+
+void OpenVDB_import_grid_fl(
+        struct OpenVDBReader *reader,
+        const char *name, float **data,
+        const int res[3]);
+
+void OpenVDB_import_grid_ch(
+        struct OpenVDBReader *reader,
+        const char *name, unsigned char **data,
+        const int res[3]);
+
+void OpenVDB_import_grid_vec(
+        struct OpenVDBReader *reader,
+        const char *name,
+        float **data_x, float **data_y, float **data_z,
+        const int res[3]);
+
+struct OpenVDBWriter *OpenVDBWriter_create(void);
+void OpenVDBWriter_free(struct OpenVDBWriter *writer);
+void OpenVDBWriter_set_flags(struct OpenVDBWriter *writer, const int flag, const bool half);
+void OpenVDBWriter_add_meta_fl(struct OpenVDBWriter *writer, const char *name, const float value);
+void OpenVDBWriter_add_meta_int(struct OpenVDBWriter *writer, const char *name, const int value);
+void OpenVDBWriter_add_meta_v3(struct OpenVDBWriter *writer, const char *name, const float value[3]);
+void OpenVDBWriter_add_meta_v3_int(struct OpenVDBWriter *writer, const char *name, const int value[3]);
+void OpenVDBWriter_add_meta_mat4(struct OpenVDBWriter *writer, const char *name, float value[4][4]);
+void OpenVDBWriter_write(struct OpenVDBWriter *writer, const char *filename);
+
+struct OpenVDBReader *OpenVDBReader_create(void);
+void OpenVDBReader_free(struct OpenVDBReader *reader);
+void OpenVDBReader_open(struct OpenVDBReader *reader, const char *filename);
+void OpenVDBReader_get_meta_fl(struct OpenVDBReader *reader, const char *name, float *value);
+void OpenVDBReader_get_meta_int(struct OpenVDBReader *reader, const char *name, int *value);
+void OpenVDBReader_get_meta_v3(struct OpenVDBReader *reader, const char *name, float value[3]);
+void OpenVDBReader_get_meta_v3_int(struct OpenVDBReader *reader, const char *name, int value[3]);
+void OpenVDBReader_get_meta_mat4(struct OpenVDBReader *reader, const char *name, float value[4][4]);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __OPENVDB_CAPI_H__ */
diff --git a/intern/openvdb/openvdb_util.cc b/intern/openvdb/openvdb_util.cc
new file mode 100644
index 00000000000..d187f55970d
--- /dev/null
+++ b/intern/openvdb/openvdb_util.cc
@@ -0,0 +1,38 @@
+/*
+ * ***** 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.
+ *
+ * The Original Code is Copyright (C) 2015 Blender Foundation.
+ * All rights reserved.
+ *
+ * Contributor(s): Kevin Dietrich
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#include "openvdb_util.h"
+
+#include <cstdio>
+
+ScopeTimer::ScopeTimer(const std::string &message)
+    : m_message(message)
+    , m_timer()
+{}
+
+ScopeTimer::~ScopeTimer()
+{
+	std::printf("%s: %fms\n", m_message.c_str(), m_timer.delta());
+}
diff --git a/intern/openvdb/openvdb_util.h b/intern/openvdb/openvdb_util.h
new file mode 100644
index 00000000000..8e14ed54345
--- /dev/null
+++ b/intern/openvdb/openvdb_util.h
@@ -0,0 +1,57 @@
+/*
+ * ***** 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.
+ *
+ * The Original Code is Copyright (C) 2015 Blender Foundation.
+ * All rights reserved.
+ *
+ * Contributor(s): Kevin Dietrich
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#ifndef __OPENVDB_UTIL_H__
+#define __OPENVDB_UTIL_H__
+
+#include <openvdb/openvdb.h>
+#include <openvdb/util/CpuTimer.h>
+
+#define CATCH_KEYERROR \
+	catch (const openvdb::KeyError &e) { \
+		std::cerr << e.what() << '\n'; \
+	}
+
+//#define DEBUG_TIME
+
+/* A utility class which prints the time elapsed during its lifetime, useful for
+ * e.g. timing the overall execution time of a function */
+class ScopeTimer {
+	std::string m_message;
+	openvdb::util::CpuTimer m_timer;
+
+public:
+	ScopeTimer(const std::string &message);
+	~ScopeTimer();
+};
+
+#ifdef DEBUG_TIME
+#	define Timer(x) \
+		ScopeTimer prof(x);
+#else
+#	define Timer(x)
+#endif
+
+#endif /* __OPENVDB_UTIL_H__ */