forked from bartvdbraak/blender
Cleanup: remove dead code in point cache and openvdb wrapper
Reviewers: brecht Differential Revision: https://developer.blender.org/D8988
This commit is contained in:
parent
f09fcda8b6
commit
4e8d3123f0
@ -42,17 +42,11 @@ if(WITH_OPENVDB)
|
||||
)
|
||||
|
||||
list(APPEND SRC
|
||||
intern/openvdb_dense_convert.cc
|
||||
intern/openvdb_reader.cc
|
||||
intern/openvdb_writer.cc
|
||||
intern/openvdb_level_set.cc
|
||||
intern/openvdb_transform.cc
|
||||
openvdb_capi.cc
|
||||
openvdb_util.cc
|
||||
|
||||
intern/openvdb_dense_convert.h
|
||||
intern/openvdb_reader.h
|
||||
intern/openvdb_writer.h
|
||||
intern/openvdb_level_set.h
|
||||
intern/openvdb_transform.h
|
||||
openvdb_util.h
|
||||
|
@ -1,186 +0,0 @@
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#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 float clipping,
|
||||
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(), 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);
|
||||
|
||||
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);
|
||||
|
||||
/* 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);
|
||||
|
||||
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();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
openvdb::Name do_name_versionning(const openvdb::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("_old", temp_name.size() - 4, 4) == temp_name.size() - 4) {
|
||||
return temp_name.replace(temp_name.size() - 4, 4, " old");
|
||||
}
|
||||
|
||||
return temp_name;
|
||||
}
|
||||
|
||||
} /* namespace internal */
|
@ -1,132 +0,0 @@
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#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>
|
||||
|
||||
namespace internal {
|
||||
|
||||
/* Verify that the name does not correspond to the old format, in which case we
|
||||
* need to replace the '_low' ending with ' low'. See T53802. */
|
||||
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)
|
||||
{
|
||||
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(), static_cast<T>(clipping));
|
||||
|
||||
grid->setTransform(transform);
|
||||
|
||||
/* 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);
|
||||
|
||||
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;
|
||||
|
||||
openvdb::Name temp_name = 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;
|
||||
}
|
||||
}
|
||||
|
||||
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];
|
||||
|
||||
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);
|
||||
|
||||
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__ */
|
@ -1,128 +0,0 @@
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#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;
|
||||
}
|
||||
}
|
@ -1,49 +0,0 @@
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#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__ */
|
@ -1,126 +0,0 @@
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#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)
|
||||
{
|
||||
#if (OPENVDB_LIBRARY_MAJOR_VERSION_NUMBER <= 3) || defined(OPENVDB_3_ABI_COMPATIBLE)
|
||||
m_grids->push_back(grid.copyGrid());
|
||||
#else
|
||||
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;
|
||||
}
|
||||
|
||||
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';
|
||||
}
|
||||
}
|
@ -1,51 +0,0 @@
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#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__ */
|
@ -18,7 +18,6 @@
|
||||
*/
|
||||
|
||||
#include "openvdb_capi.h"
|
||||
#include "openvdb_dense_convert.h"
|
||||
#include "openvdb_level_set.h"
|
||||
#include "openvdb_transform.h"
|
||||
#include "openvdb_util.h"
|
||||
@ -28,209 +27,6 @@ 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],
|
||||
const float clipping,
|
||||
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, clipping, 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],
|
||||
const float clipping,
|
||||
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, clipping, 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 float clipping,
|
||||
const bool is_color,
|
||||
OpenVDBFloatGrid *mask)
|
||||
{
|
||||
Timer(__func__);
|
||||
|
||||
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);
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
OpenVDBLevelSet *OpenVDBLevelSet_create(bool initGrid, OpenVDBTransform *xform)
|
||||
{
|
||||
OpenVDBLevelSet *level_set = new OpenVDBLevelSet();
|
||||
|
@ -58,13 +58,8 @@ typedef enum OpenVDBLevelSet_GridSampler {
|
||||
OPENVDB_LEVELSET_GRIDSAMPLER_QUADRATIC = 3,
|
||||
} OpenVDBLevelSet_Gridsampler;
|
||||
|
||||
struct OpenVDBReader;
|
||||
struct OpenVDBWriter;
|
||||
struct OpenVDBTransform;
|
||||
struct OpenVDBLevelSet;
|
||||
struct OpenVDBFloatGrid;
|
||||
struct OpenVDBIntGrid;
|
||||
struct OpenVDBVectorGrid;
|
||||
|
||||
struct OpenVDBVolumeToMeshData {
|
||||
int tottriangles;
|
||||
@ -108,78 +103,6 @@ enum {
|
||||
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 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);
|
||||
|
||||
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);
|
||||
|
||||
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]);
|
||||
|
||||
struct OpenVDBTransform *OpenVDBTransform_create(void);
|
||||
void OpenVDBTransform_free(struct OpenVDBTransform *transform);
|
||||
void OpenVDBTransform_create_linear_transform(struct OpenVDBTransform *transform,
|
||||
|
@ -92,9 +92,6 @@ struct Scene;
|
||||
struct SoftBody;
|
||||
struct ViewLayer;
|
||||
|
||||
struct OpenVDBReader;
|
||||
struct OpenVDBWriter;
|
||||
|
||||
/* temp structure for read/write */
|
||||
typedef struct PTCacheData {
|
||||
unsigned int index;
|
||||
@ -122,7 +119,6 @@ typedef struct PTCacheFile {
|
||||
|
||||
enum {
|
||||
PTCACHE_FILE_PTCACHE = 0,
|
||||
PTCACHE_FILE_OPENVDB = 1,
|
||||
};
|
||||
|
||||
typedef struct PTCacheID {
|
||||
@ -159,11 +155,6 @@ typedef struct PTCacheID {
|
||||
/* copies cache cata to point data */
|
||||
int (*read_stream)(PTCacheFile *pf, void *calldata);
|
||||
|
||||
/* copies point data to cache data */
|
||||
int (*write_openvdb_stream)(struct OpenVDBWriter *writer, void *calldata);
|
||||
/* copies cache cata to point data */
|
||||
int (*read_openvdb_stream)(struct OpenVDBReader *reader, void *calldata);
|
||||
|
||||
/* copies custom extradata to cache data */
|
||||
void (*write_extra_data)(void *calldata, struct PTCacheMem *pm, int cfra);
|
||||
/* copies custom extradata to cache data */
|
||||
|
@ -73,10 +73,6 @@
|
||||
# include "RBI_api.h"
|
||||
#endif
|
||||
|
||||
#ifdef WITH_OPENVDB
|
||||
# include "openvdb_capi.h"
|
||||
#endif
|
||||
|
||||
#ifdef WITH_LZO
|
||||
# ifdef WITH_SYSTEM_LZO
|
||||
# include <lzo/lzo1x.h>
|
||||
@ -883,9 +879,6 @@ void BKE_ptcache_id_from_softbody(PTCacheID *pid, Object *ob, SoftBody *sb)
|
||||
pid->write_stream = NULL;
|
||||
pid->read_stream = NULL;
|
||||
|
||||
pid->write_openvdb_stream = NULL;
|
||||
pid->read_openvdb_stream = NULL;
|
||||
|
||||
pid->write_extra_data = NULL;
|
||||
pid->read_extra_data = NULL;
|
||||
pid->interpolate_extra_data = NULL;
|
||||
@ -929,9 +922,6 @@ void BKE_ptcache_id_from_particles(PTCacheID *pid, Object *ob, ParticleSystem *p
|
||||
pid->write_stream = NULL;
|
||||
pid->read_stream = NULL;
|
||||
|
||||
pid->write_openvdb_stream = NULL;
|
||||
pid->read_openvdb_stream = NULL;
|
||||
|
||||
pid->write_extra_data = NULL;
|
||||
pid->read_extra_data = NULL;
|
||||
pid->interpolate_extra_data = NULL;
|
||||
@ -985,9 +975,6 @@ void BKE_ptcache_id_from_cloth(PTCacheID *pid, Object *ob, ClothModifierData *cl
|
||||
pid->read_point = ptcache_cloth_read;
|
||||
pid->interpolate_point = ptcache_cloth_interpolate;
|
||||
|
||||
pid->write_openvdb_stream = NULL;
|
||||
pid->read_openvdb_stream = NULL;
|
||||
|
||||
pid->write_stream = NULL;
|
||||
pid->read_stream = NULL;
|
||||
|
||||
@ -1047,9 +1034,6 @@ void BKE_ptcache_id_from_dynamicpaint(PTCacheID *pid, Object *ob, DynamicPaintSu
|
||||
pid->write_stream = ptcache_dynamicpaint_write;
|
||||
pid->read_stream = ptcache_dynamicpaint_read;
|
||||
|
||||
pid->write_openvdb_stream = NULL;
|
||||
pid->read_openvdb_stream = NULL;
|
||||
|
||||
pid->write_extra_data = NULL;
|
||||
pid->read_extra_data = NULL;
|
||||
pid->interpolate_extra_data = NULL;
|
||||
@ -1088,9 +1072,6 @@ void BKE_ptcache_id_from_rigidbody(PTCacheID *pid, Object *ob, RigidBodyWorld *r
|
||||
pid->write_stream = NULL;
|
||||
pid->read_stream = NULL;
|
||||
|
||||
pid->write_openvdb_stream = NULL;
|
||||
pid->read_openvdb_stream = NULL;
|
||||
|
||||
pid->write_extra_data = NULL;
|
||||
pid->read_extra_data = NULL;
|
||||
pid->interpolate_extra_data = NULL;
|
||||
@ -1299,8 +1280,6 @@ static const char *ptcache_file_extension(const PTCacheID *pid)
|
||||
default:
|
||||
case PTCACHE_FILE_PTCACHE:
|
||||
return PTCACHE_EXT;
|
||||
case PTCACHE_FILE_OPENVDB:
|
||||
return ".vdb";
|
||||
}
|
||||
}
|
||||
|
||||
@ -2150,36 +2129,6 @@ static int ptcache_read_stream(PTCacheID *pid, int cfra)
|
||||
return error == 0;
|
||||
}
|
||||
|
||||
static int ptcache_read_openvdb_stream(PTCacheID *pid, int cfra)
|
||||
{
|
||||
#ifdef WITH_OPENVDB
|
||||
char filename[FILE_MAX * 2];
|
||||
|
||||
/* save blend file before using disk pointcache */
|
||||
if (!G.relbase_valid && (pid->cache->flag & PTCACHE_EXTERNAL) == 0) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
ptcache_filename(pid, filename, cfra, 1, 1);
|
||||
|
||||
if (!BLI_exists(filename)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
struct OpenVDBReader *reader = OpenVDBReader_create();
|
||||
OpenVDBReader_open(reader, filename);
|
||||
|
||||
if (!pid->read_openvdb_stream(reader, pid->calldata)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
return 1;
|
||||
#else
|
||||
UNUSED_VARS(pid, cfra);
|
||||
return 0;
|
||||
#endif
|
||||
}
|
||||
|
||||
static int ptcache_read(PTCacheID *pid, int cfra)
|
||||
{
|
||||
PTCacheMem *pm = NULL;
|
||||
@ -2340,12 +2289,7 @@ int BKE_ptcache_read(PTCacheID *pid, float cfra, bool no_extrapolate_old)
|
||||
}
|
||||
|
||||
if (cfra1) {
|
||||
if (pid->file_type == PTCACHE_FILE_OPENVDB && pid->read_openvdb_stream) {
|
||||
if (!ptcache_read_openvdb_stream(pid, cfra1)) {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
else if (pid->read_stream) {
|
||||
if (pid->read_stream) {
|
||||
if (!ptcache_read_stream(pid, cfra1)) {
|
||||
return 0;
|
||||
}
|
||||
@ -2356,12 +2300,7 @@ int BKE_ptcache_read(PTCacheID *pid, float cfra, bool no_extrapolate_old)
|
||||
}
|
||||
|
||||
if (cfra2) {
|
||||
if (pid->file_type == PTCACHE_FILE_OPENVDB && pid->read_openvdb_stream) {
|
||||
if (!ptcache_read_openvdb_stream(pid, cfra2)) {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
else if (pid->read_stream) {
|
||||
if (pid->read_stream) {
|
||||
if (!ptcache_read_stream(pid, cfra2)) {
|
||||
return 0;
|
||||
}
|
||||
@ -2436,28 +2375,7 @@ static int ptcache_write_stream(PTCacheID *pid, int cfra, int totpoint)
|
||||
|
||||
return error == 0;
|
||||
}
|
||||
static int ptcache_write_openvdb_stream(PTCacheID *pid, int cfra)
|
||||
{
|
||||
#ifdef WITH_OPENVDB
|
||||
struct OpenVDBWriter *writer = OpenVDBWriter_create();
|
||||
char filename[FILE_MAX * 2];
|
||||
|
||||
BKE_ptcache_id_clear(pid, PTCACHE_CLEAR_FRAME, cfra);
|
||||
|
||||
ptcache_filename(pid, filename, cfra, 1, 1);
|
||||
BLI_make_existing_file(filename);
|
||||
|
||||
int error = pid->write_openvdb_stream(writer, pid->calldata);
|
||||
|
||||
OpenVDBWriter_write(writer, filename);
|
||||
OpenVDBWriter_free(writer);
|
||||
|
||||
return error == 0;
|
||||
#else
|
||||
UNUSED_VARS(pid, cfra);
|
||||
return 0;
|
||||
#endif
|
||||
}
|
||||
static int ptcache_write(PTCacheID *pid, int cfra, int overwrite)
|
||||
{
|
||||
PointCache *cache = pid->cache;
|
||||
@ -2598,10 +2516,7 @@ int BKE_ptcache_write(PTCacheID *pid, unsigned int cfra)
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (pid->file_type == PTCACHE_FILE_OPENVDB && pid->write_openvdb_stream) {
|
||||
ptcache_write_openvdb_stream(pid, cfra);
|
||||
}
|
||||
else if (pid->write_stream) {
|
||||
if (pid->write_stream) {
|
||||
ptcache_write_stream(pid, cfra, totpoint);
|
||||
}
|
||||
else if (pid->write_point) {
|
||||
|
Loading…
Reference in New Issue
Block a user