griefith/test
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

ClangFormat: apply to source, most of intern

Browse Source 
Apply clang format as proposed in T53211.

For details on usage and instructions for migrating branches
without conflicts, see:

https://wiki.blender.org/wiki/Tools/ClangFormat
This commit is contained in:
Campbell Barton
2019-04-17 06:17:24 +02:00
parent b3dabc200a
commit e12c08e8d1
4481 changed files with 1230080 additions and 1155401 deletions
Download Patch File Download Diff File Expand all files Collapse all files

68
intern/openvdb/CMakeLists.txt
View File

@@ -19,57 +19,57 @@
# ***** END GPL LICENSE BLOCK *****
set(INC
.
intern
.
intern
)
set(INC_SYS
)
set(SRC
openvdb_capi.h
openvdb_capi.h
)
set(LIB
)
if(WITH_OPENVDB)
add_definitions(
-DWITH_OPENVDB
${OPENVDB_DEFINITIONS}
)
add_definitions(
-DWITH_OPENVDB
${OPENVDB_DEFINITIONS}
)
if(WITH_OPENVDB_3_ABI_COMPATIBLE)
add_definitions(
-DOPENVDB_3_ABI_COMPATIBLE
)
endif()
if(WITH_OPENVDB_3_ABI_COMPATIBLE)
add_definitions(
-DOPENVDB_3_ABI_COMPATIBLE
)
endif()
list(APPEND INC_SYS
${BOOST_INCLUDE_DIR}
${TBB_INCLUDE_DIRS}
${OPENEXR_INCLUDE_DIRS}
${OPENVDB_INCLUDE_DIRS}
)
list(APPEND INC_SYS
${BOOST_INCLUDE_DIR}
${TBB_INCLUDE_DIRS}
${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
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
)
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()
if(WITH_OPENVDB_BLOSC)
add_definitions(
-DWITH_OPENVDB_BLOSC
)
endif()
endif()
blender_add_lib(bf_intern_openvdb "${SRC}" "${INC}" "${INC_SYS}" "${LIB}")

230
intern/openvdb/intern/openvdb_dense_convert.cc
View File

@@ -19,158 +19,168 @@
#include "openvdb_dense_convert.h"
#include <openvdb/tools/ValueTransformer.h> /* for tools::foreach */
#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]);
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;
typedef openvdb::FloatTree ScalarTree;
openvdb::tree::ValueAccessor<const ScalarTree> m_acc_x, m_acc_y, m_acc_z;
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)
{}
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)
{}
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;
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);
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));
}
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 float clipping,
const openvdb::FloatGrid *mask)
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 float clipping,
const openvdb::FloatGrid *mask)
{
using namespace openvdb;
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);
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];
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(), clipping);
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(), clipping);
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(), clipping);
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(), clipping);
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(), clipping);
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(), clipping);
Vec3SGrid::Ptr vecgrid = Vec3SGrid::create(Vec3s(0.0f));
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());
}
/* 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);
MergeScalarGrids op(&(grid[0]->tree()), &(grid[1]->tree()), &(grid[2]->tree()));
tools::foreach (vecgrid->beginValueOn(), op, true, false);
vecgrid->setTransform(transform);
vecgrid->setTransform(transform);
/* Avoid clipping against an empty grid. */
if (mask && !mask->tree().empty()) {
vecgrid = tools::clip(*vecgrid, *mask);
}
/* Avoid clipping against an empty grid. */
if (mask && !mask->tree().empty()) {
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);
vecgrid->setName(name);
vecgrid->setIsInWorldSpace(false);
vecgrid->setVectorType(vec_type);
vecgrid->insertMeta("is_color", BoolMetadata(is_color));
vecgrid->setGridClass(GRID_STAGGERED);
writer->insert(vecgrid);
writer->insert(vecgrid);
return vecgrid.get();
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])
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;
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;
}
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];
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();
}
}
}
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();
}
}
}
}
openvdb::Name do_name_versionning(const openvdb::Name &name)
{
openvdb::Name temp_name = name;
openvdb::Name temp_name = name;
if (temp_name.find("_low", temp_name.size() - 4, 4) == temp_name.size() - 4) {
return temp_name.replace(temp_name.size() - 4, 4, " low");
}
if (temp_name.find("_low", temp_name.size() - 4, 4) == temp_name.size() - 4) {
return temp_name.replace(temp_name.size() - 4, 4, " low");
}
if (temp_name.find("_old", temp_name.size() - 4, 4) == temp_name.size() - 4) {
return temp_name.replace(temp_name.size() - 4, 4, " old");
}
if (temp_name.find("_old", temp_name.size() - 4, 4) == temp_name.size() - 4) {
return temp_name.replace(temp_name.size() - 4, 4, " old");
}
return temp_name;
return temp_name;
}
} /* namespace internal */
} /* namespace internal */

138
intern/openvdb/intern/openvdb_dense_convert.h
View File

@@ -36,97 +36,97 @@ openvdb::Name do_name_versionning(const openvdb::Name &name);
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 float clipping,
const openvdb::FloatGrid *mask)
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 float clipping,
const openvdb::FloatGrid *mask)
{
using namespace openvdb;
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);
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));
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(), static_cast<T>(clipping));
tools::Dense<const T, openvdb::tools::LayoutXYZ> dense_grid(bbox, data);
tools::copyFromDense(dense_grid, grid->tree(), static_cast<T>(clipping));
grid->setTransform(transform);
grid->setTransform(transform);
/* Avoid clipping against an empty grid. */
if (mask && !mask->tree().empty()) {
grid = tools::clip(*grid, *mask);
}
/* Avoid clipping against an empty grid. */
if (mask && !mask->tree().empty()) {
grid = tools::clip(*grid, *mask);
}
grid->setName(name);
grid->setIsInWorldSpace(false);
grid->setVectorType(openvdb::VEC_INVARIANT);
grid->setName(name);
grid->setIsInWorldSpace(false);
grid->setVectorType(openvdb::VEC_INVARIANT);
writer->insert(grid);
writer->insert(grid);
return grid.get();
return grid.get();
}
template <typename GridType, typename T>
void OpenVDB_import_grid(
OpenVDBReader *reader,
const openvdb::Name &name,
T **data,
const int res[3])
template<typename GridType, typename T>
void OpenVDB_import_grid(OpenVDBReader *reader,
const openvdb::Name &name,
T **data,
const int res[3])
{
using namespace openvdb;
using namespace openvdb;
openvdb::Name temp_name = name;
openvdb::Name temp_name = name;
if (!reader->hasGrid(temp_name)) {
temp_name = do_name_versionning(temp_name);
if (!reader->hasGrid(temp_name)) {
temp_name = do_name_versionning(temp_name);
if (!reader->hasGrid(temp_name)) {
std::fprintf(stderr, "OpenVDB grid %s not found in file!\n", temp_name.c_str());
memset(*data, 0, sizeof(T) * res[0] * res[1] * res[2]);
return;
}
}
if (!reader->hasGrid(temp_name)) {
std::fprintf(stderr, "OpenVDB grid %s not found in file!\n", temp_name.c_str());
memset(*data, 0, sizeof(T) * res[0] * res[1] * res[2]);
return;
}
}
typename GridType::Ptr grid = gridPtrCast<GridType>(reader->getGrid(temp_name));
typename GridType::ConstAccessor acc = grid->getConstAccessor();
typename GridType::Ptr grid = gridPtrCast<GridType>(reader->getGrid(temp_name));
typename GridType::ConstAccessor acc = grid->getConstAccessor();
math::Coord xyz;
int &x = xyz[0], &y = xyz[1], &z = xyz[2];
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);
}
}
}
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 float clipping,
const openvdb::FloatGrid *mask);
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 float clipping,
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]);
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 */
} /* namespace internal */
#endif /* __OPENVDB_DENSE_CONVERT_H__ */

112
intern/openvdb/intern/openvdb_reader.cc
View File

@@ -20,111 +20,109 @@
#include "openvdb_reader.h"
#include "openvdb_util.h"
OpenVDBReader::OpenVDBReader()
: m_meta_map(new openvdb::MetaMap)
, m_file(NULL)
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();
/* 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();
cleanupFile();
}
void OpenVDBReader::open(const openvdb::Name &filename)
{
cleanupFile();
cleanupFile();
try {
m_file = new openvdb::io::File(filename);
m_file->setCopyMaxBytes(0);
m_file->open();
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();
}
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;
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;
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);
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;
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);
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;
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);
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;
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);
return m_file->hasGrid(name);
}
openvdb::GridBase::Ptr OpenVDBReader::getGrid(const openvdb::Name &name) const
{
return m_file->readGrid(name);
return m_file->readGrid(name);
}
size_t OpenVDBReader::numGrids() const
{
return m_file->getGrids()->size();
return m_file->getGrids()->size();
}
void OpenVDBReader::cleanupFile()
{
if (m_file) {
m_file->close();
delete m_file;
}
if (m_file) {
m_file->close();
delete m_file;
}
}

32
intern/openvdb/intern/openvdb_reader.h
View File

@@ -23,27 +23,27 @@
#include <openvdb/openvdb.h>
struct OpenVDBReader {
private:
openvdb::MetaMap::Ptr m_meta_map;
openvdb::io::File *m_file;
private:
openvdb::MetaMap::Ptr m_meta_map;
openvdb::io::File *m_file;
void cleanupFile();
void cleanupFile();
public:
OpenVDBReader();
~OpenVDBReader();
public:
OpenVDBReader();
~OpenVDBReader();
void open(const openvdb::Name &filename);
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;
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;
bool hasGrid(const openvdb::Name &name) const;
openvdb::GridBase::Ptr getGrid(const openvdb::Name &name) const;
size_t numGrids() const;
};
#endif /* __OPENVDB_READER_H__ */

106
intern/openvdb/intern/openvdb_writer.cc
View File

@@ -21,96 +21,106 @@
#include "openvdb_util.h"
OpenVDBWriter::OpenVDBWriter()
: m_grids(new openvdb::GridPtrVec())
, m_meta_map(new openvdb::MetaMap())
, m_save_as_half(false)
: 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"));
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);
grid->setSaveFloatAsHalf(m_save_as_half);
m_grids->push_back(grid);
}
void OpenVDBWriter::insert(const openvdb::GridBase &grid)
{
#if (OPENVDB_LIBRARY_MAJOR_VERSION_NUMBER <= 3) || defined(OPENVDB_3_ABI_COMPATIBLE)
m_grids->push_back(grid.copyGrid());
m_grids->push_back(grid.copyGrid());
#else
m_grids->push_back(grid.copyGridWithNewTree());
m_grids->push_back(grid.copyGridWithNewTree());
#endif
}
void OpenVDBWriter::insertFloatMeta(const openvdb::Name &name, const float value)
{
try {
m_meta_map->insertMeta(name, openvdb::FloatMetadata(value));
}
CATCH_KEYERROR;
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;
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;
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;
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]);
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;
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;
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();
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';
}
/* 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';
}
}

34
intern/openvdb/intern/openvdb_writer.h
View File

@@ -23,29 +23,29 @@
#include <openvdb/openvdb.h>
struct OpenVDBWriter {
private:
openvdb::GridPtrVecPtr m_grids;
openvdb::MetaMap::Ptr m_meta_map;
private:
openvdb::GridPtrVecPtr m_grids;
openvdb::MetaMap::Ptr m_meta_map;
int m_compression_flags;
bool m_save_as_half;
int m_compression_flags;
bool m_save_as_half;
public:
OpenVDBWriter();
~OpenVDBWriter();
public:
OpenVDBWriter();
~OpenVDBWriter();
void insert(const openvdb::GridBase::Ptr &grid);
void insert(const openvdb::GridBase &grid);
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 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 setFlags(const int compression, const bool save_as_half);
void write(const openvdb::Name &filename) const;
void write(const openvdb::Name &filename) const;
};
#endif /* __OPENVDB_WRITER_H__ */

218
intern/openvdb/openvdb_capi.cc
View File

@@ -21,216 +21,220 @@
#include "openvdb_dense_convert.h"
#include "openvdb_util.h"
struct OpenVDBFloatGrid { int unused; };
struct OpenVDBIntGrid { int unused; };
struct OpenVDBVectorGrid { int unused; };
struct OpenVDBFloatGrid {
int unused;
};
struct OpenVDBIntGrid {
int unused;
};
struct OpenVDBVectorGrid {
int unused;
};
int OpenVDB_getVersionHex()
{
return openvdb::OPENVDB_LIBRARY_VERSION;
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], const float clipping,
OpenVDBFloatGrid *mask)
OpenVDBFloatGrid *OpenVDB_export_grid_fl(OpenVDBWriter *writer,
const char *name,
float *data,
const int res[3],
float matrix[4][4],
const float clipping,
OpenVDBFloatGrid *mask)
{
Timer(__func__);
Timer(__func__);
using openvdb::FloatGrid;
using openvdb::FloatGrid;
FloatGrid *mask_grid = reinterpret_cast<FloatGrid *>(mask);
FloatGrid *grid = internal::OpenVDB_export_grid<FloatGrid>(
writer,
name,
data,
res,
matrix,
clipping,
mask_grid);
FloatGrid *mask_grid = reinterpret_cast<FloatGrid *>(mask);
FloatGrid *grid = internal::OpenVDB_export_grid<FloatGrid>(
writer, name, data, res, matrix, clipping, mask_grid);
return reinterpret_cast<OpenVDBFloatGrid *>(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], const float clipping,
OpenVDBFloatGrid *mask)
OpenVDBIntGrid *OpenVDB_export_grid_ch(OpenVDBWriter *writer,
const char *name,
unsigned char *data,
const int res[3],
float matrix[4][4],
const float clipping,
OpenVDBFloatGrid *mask)
{
Timer(__func__);
Timer(__func__);
using openvdb::FloatGrid;
using openvdb::Int32Grid;
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,
clipping,
mask_grid);
FloatGrid *mask_grid = reinterpret_cast<FloatGrid *>(mask);
Int32Grid *grid = internal::OpenVDB_export_grid<Int32Grid>(
writer, name, data, res, matrix, clipping, mask_grid);
return reinterpret_cast<OpenVDBIntGrid *>(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 float clipping,
const bool is_color, OpenVDBFloatGrid *mask)
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 float clipping,
const bool is_color,
OpenVDBFloatGrid *mask)
{
Timer(__func__);
Timer(__func__);
using openvdb::GridBase;
using openvdb::FloatGrid;
using openvdb::VecType;
using openvdb::FloatGrid;
using openvdb::GridBase;
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,
clipping,
mask_grid);
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,
clipping,
mask_grid);
return reinterpret_cast<OpenVDBVectorGrid *>(grid);
return reinterpret_cast<OpenVDBVectorGrid *>(grid);
}
void OpenVDB_import_grid_fl(
OpenVDBReader *reader,
const char *name, float **data,
const int res[3])
void OpenVDB_import_grid_fl(OpenVDBReader *reader,
const char *name,
float **data,
const int res[3])
{
Timer(__func__);
Timer(__func__);
internal::OpenVDB_import_grid<openvdb::FloatGrid>(reader, name, data, res);
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])
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);
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])
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__);
Timer(__func__);
internal::OpenVDB_import_grid_vector(reader, name, data_x, data_y, data_z, res);
internal::OpenVDB_import_grid_vector(reader, name, data_x, data_y, data_z, res);
}
OpenVDBWriter *OpenVDBWriter_create()
{
return new OpenVDBWriter();
return new OpenVDBWriter();
}
void OpenVDBWriter_free(OpenVDBWriter *writer)
{
delete writer;
delete writer;
}
void OpenVDBWriter_set_flags(OpenVDBWriter *writer, const int flag, const bool half)
{
int compression_flags = openvdb::io::COMPRESS_ACTIVE_MASK;
int compression_flags = openvdb::io::COMPRESS_ACTIVE_MASK;
#ifdef WITH_OPENVDB_BLOSC
if (flag == 0) {
compression_flags |= openvdb::io::COMPRESS_BLOSC;
}
else
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;
}
if (flag == 1) {
compression_flags |= openvdb::io::COMPRESS_ZIP;
}
else {
compression_flags = openvdb::io::COMPRESS_NONE;
}
writer->setFlags(compression_flags, half);
writer->setFlags(compression_flags, half);
}
void OpenVDBWriter_add_meta_fl(OpenVDBWriter *writer, const char *name, const float value)
{
writer->insertFloatMeta(name, value);
writer->insertFloatMeta(name, value);
}
void OpenVDBWriter_add_meta_int(OpenVDBWriter *writer, const char *name, const int value)
{
writer->insertIntMeta(name, value);
writer->insertIntMeta(name, value);
}
void OpenVDBWriter_add_meta_v3(OpenVDBWriter *writer, const char *name, const float value[3])
{
writer->insertVec3sMeta(name, value);
writer->insertVec3sMeta(name, value);
}
void OpenVDBWriter_add_meta_v3_int(OpenVDBWriter *writer, const char *name, const int value[3])
{
writer->insertVec3IMeta(name, value);
writer->insertVec3IMeta(name, value);
}
void OpenVDBWriter_add_meta_mat4(OpenVDBWriter *writer, const char *name, float value[4][4])
{
writer->insertMat4sMeta(name, value);
writer->insertMat4sMeta(name, value);
}
void OpenVDBWriter_write(OpenVDBWriter *writer, const char *filename)
{
writer->write(filename);
writer->write(filename);
}
OpenVDBReader *OpenVDBReader_create()
{
return new OpenVDBReader();
return new OpenVDBReader();
}
void OpenVDBReader_free(OpenVDBReader *reader)
{
delete reader;
delete reader;
}
void OpenVDBReader_open(OpenVDBReader *reader, const char *filename)
{
reader->open(filename);
reader->open(filename);
}
void OpenVDBReader_get_meta_fl(OpenVDBReader *reader, const char *name, float *value)
{
reader->floatMeta(name, *value);
reader->floatMeta(name, *value);
}
void OpenVDBReader_get_meta_int(OpenVDBReader *reader, const char *name, int *value)
{
reader->intMeta(name, *value);
reader->intMeta(name, *value);
}
void OpenVDBReader_get_meta_v3(OpenVDBReader *reader, const char *name, float value[3])
{
reader->vec3sMeta(name, value);
reader->vec3sMeta(name, value);
}
void OpenVDBReader_get_meta_v3_int(OpenVDBReader *reader, const char *name, int value[3])
{
reader->vec3IMeta(name, value);
reader->vec3IMeta(name, value);
}
void OpenVDBReader_get_meta_mat4(OpenVDBReader *reader, const char *name, float value[4][4])
{
reader->mat4sMeta(name, value);
reader->mat4sMeta(name, value);
}

89
intern/openvdb/openvdb_capi.h
View File

@@ -33,55 +33,72 @@ 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,
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], const float clipping,
struct OpenVDBFloatGrid *mask);
struct OpenVDBFloatGrid *OpenVDB_export_grid_fl(struct OpenVDBWriter *writer,
const char *name,
float *data,
const int res[3],
float matrix[4][4],
const float clipping,
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], const float clipping,
struct OpenVDBFloatGrid *mask);
const char *name,
unsigned char *data,
const int res[3],
float matrix[4][4],
const float clipping,
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 float clipping,
const bool is_color,
struct OpenVDBFloatGrid *mask);
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 float clipping,
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_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_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]);
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_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);
@@ -91,7 +108,9 @@ void OpenVDBReader_get_meta_fl(struct OpenVDBReader *reader, const char *name, f
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]);
void OpenVDBReader_get_meta_mat4(struct OpenVDBReader *reader,
const char *name,
float value[4][4]);
#ifdef __cplusplus
}

9
intern/openvdb/openvdb_util.cc
View File

@@ -21,12 +21,11 @@
#include <cstdio>
ScopeTimer::ScopeTimer(const std::string &message)
: m_message(message)
, m_timer()
{}
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());
std::printf("%s: %fms\n", m_message.c_str(), m_timer.delta());
}

22
intern/openvdb/openvdb_util.h
View File

@@ -24,28 +24,28 @@
#include <openvdb/util/CpuTimer.h>
#define CATCH_KEYERROR \
catch (const openvdb::KeyError &e) { \
std::cerr << e.what() << '\n'; \
}
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;
std::string m_message;
openvdb::util::CpuTimer m_timer;
public:
ScopeTimer(const std::string &message);
~ScopeTimer();
public:
ScopeTimer(const std::string &message);
~ScopeTimer();
};
#ifdef DEBUG_TIME
# define Timer(x) \
ScopeTimer prof(x);
# define Timer(x) ScopeTimer prof(x);
#else
# define Timer(x)
# define Timer(x)
#endif
#endif /* __OPENVDB_UTIL_H__ */