diff options
Diffstat (limited to 'intern')
-rw-r--r-- | intern/openvdb/CMakeLists.txt | 5 | ||||
-rw-r--r-- | intern/openvdb/intern/openvdb_level_set.cc | 176 | ||||
-rw-r--r-- | intern/openvdb/intern/openvdb_level_set.h | 60 | ||||
-rw-r--r-- | intern/openvdb/intern/openvdb_transform.cc | 43 | ||||
-rw-r--r-- | intern/openvdb/intern/openvdb_transform.h | 37 | ||||
-rw-r--r-- | intern/openvdb/openvdb_capi.cc | 152 | ||||
-rw-r--r-- | intern/openvdb/openvdb_capi.h | 107 |
7 files changed, 570 insertions, 10 deletions
diff --git a/intern/openvdb/CMakeLists.txt b/intern/openvdb/CMakeLists.txt index bcb1d545c94..412dade0f1a 100644 --- a/intern/openvdb/CMakeLists.txt +++ b/intern/openvdb/CMakeLists.txt @@ -21,6 +21,7 @@ set(INC . intern + ../guardedalloc ) set(INC_SYS @@ -56,12 +57,16 @@ if(WITH_OPENVDB) 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 ) diff --git a/intern/openvdb/intern/openvdb_level_set.cc b/intern/openvdb/intern/openvdb_level_set.cc new file mode 100644 index 00000000000..a850aae2be5 --- /dev/null +++ b/intern/openvdb/intern/openvdb_level_set.cc @@ -0,0 +1,176 @@ +/* + * 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_level_set.h" +#include "openvdb_util.h" +#include "openvdb_capi.h" +#include "MEM_guardedalloc.h" +#include "openvdb/tools/Composite.h" + +OpenVDBLevelSet::OpenVDBLevelSet() +{ + openvdb::initialize(); +} + +OpenVDBLevelSet::~OpenVDBLevelSet() +{ +} + +void OpenVDBLevelSet::mesh_to_level_set(const float *vertices, + const unsigned int *faces, + const unsigned int totvertices, + const unsigned int totfaces, + const openvdb::math::Transform::Ptr &xform) +{ + std::vector<openvdb::Vec3s> points(totvertices); + std::vector<openvdb::Vec3I> triangles(totfaces); + std::vector<openvdb::Vec4I> quads; + + for (unsigned int i = 0; i < totvertices; i++) { + points[i] = openvdb::Vec3s(vertices[i * 3], vertices[i * 3 + 1], vertices[i * 3 + 2]); + } + + for (unsigned int i = 0; i < totfaces; i++) { + triangles[i] = openvdb::Vec3I(faces[i * 3], faces[i * 3 + 1], faces[i * 3 + 2]); + } + + this->grid = openvdb::tools::meshToLevelSet<openvdb::FloatGrid>( + *xform, points, triangles, quads, 1); +} + +void OpenVDBLevelSet::volume_to_mesh(OpenVDBVolumeToMeshData *mesh, + const double isovalue, + const double adaptivity, + const bool relax_disoriented_triangles) +{ + std::vector<openvdb::Vec3s> out_points; + std::vector<openvdb::Vec4I> out_quads; + std::vector<openvdb::Vec3I> out_tris; + openvdb::tools::volumeToMesh<openvdb::FloatGrid>(*this->grid, + out_points, + out_tris, + out_quads, + isovalue, + adaptivity, + relax_disoriented_triangles); + mesh->vertices = (float *)MEM_malloc_arrayN( + out_points.size(), 3 * sizeof(float), "openvdb remesher out verts"); + mesh->quads = (unsigned int *)MEM_malloc_arrayN( + out_quads.size(), 4 * sizeof(unsigned int), "openvdb remesh out quads"); + mesh->triangles = NULL; + if (out_tris.size() > 0) { + mesh->triangles = (unsigned int *)MEM_malloc_arrayN( + out_tris.size(), 3 * sizeof(unsigned int), "openvdb remesh out tris"); + } + + mesh->totvertices = out_points.size(); + mesh->tottriangles = out_tris.size(); + mesh->totquads = out_quads.size(); + + for (size_t i = 0; i < out_points.size(); i++) { + mesh->vertices[i * 3] = out_points[i].x(); + mesh->vertices[i * 3 + 1] = out_points[i].y(); + mesh->vertices[i * 3 + 2] = out_points[i].z(); + } + + for (size_t i = 0; i < out_quads.size(); i++) { + mesh->quads[i * 4] = out_quads[i].x(); + mesh->quads[i * 4 + 1] = out_quads[i].y(); + mesh->quads[i * 4 + 2] = out_quads[i].z(); + mesh->quads[i * 4 + 3] = out_quads[i].w(); + } + + for (size_t i = 0; i < out_tris.size(); i++) { + mesh->triangles[i * 3] = out_tris[i].x(); + mesh->triangles[i * 3 + 1] = out_tris[i].y(); + mesh->triangles[i * 3 + 2] = out_tris[i].z(); + } +} + +void OpenVDBLevelSet::filter(OpenVDBLevelSet_FilterType filter_type, + int width, + float distance, + OpenVDBLevelSet_FilterBias filter_bias) +{ + + if (!this->grid) { + return; + } + + if (this->grid->getGridClass() != openvdb::GRID_LEVEL_SET) { + return; + } + + openvdb::tools::LevelSetFilter<openvdb::FloatGrid> filter(*this->grid); + filter.setSpatialScheme((openvdb::math::BiasedGradientScheme)filter_bias); + switch (filter_type) { + case OPENVDB_LEVELSET_FILTER_GAUSSIAN: + filter.gaussian(width); + break; + case OPENVDB_LEVELSET_FILTER_MEDIAN: + filter.median(width); + break; + case OPENVDB_LEVELSET_FILTER_MEAN: + filter.mean(width); + break; + case OPENVDB_LEVELSET_FILTER_MEAN_CURVATURE: + filter.meanCurvature(); + break; + case OPENVDB_LEVELSET_FILTER_LAPLACIAN: + filter.laplacian(); + break; + case OPENVDB_LEVELSET_FILTER_DILATE: + filter.offset(distance); + break; + case OPENVDB_LEVELSET_FILTER_ERODE: + filter.offset(distance); + break; + case OPENVDB_LEVELSET_FILTER_NONE: + break; + } +} +openvdb::FloatGrid::Ptr OpenVDBLevelSet::CSG_operation_apply( + const openvdb::FloatGrid::Ptr &gridA, + const openvdb::FloatGrid::Ptr &gridB, + OpenVDBLevelSet_CSGOperation operation) +{ + switch (operation) { + case OPENVDB_LEVELSET_CSG_UNION: + openvdb::tools::csgUnion(*gridA, *gridB); + break; + case OPENVDB_LEVELSET_CSG_DIFFERENCE: + openvdb::tools::csgDifference(*gridA, *gridB); + break; + case OPENVDB_LEVELSET_CSG_INTERSECTION: + openvdb::tools::csgIntersection(*gridA, *gridB); + break; + } + + return gridA; +} + +const openvdb::FloatGrid::Ptr &OpenVDBLevelSet::get_grid() +{ + return this->grid; +} + +void OpenVDBLevelSet::set_grid(const openvdb::FloatGrid::Ptr &grid) +{ + this->grid = grid; +} diff --git a/intern/openvdb/intern/openvdb_level_set.h b/intern/openvdb/intern/openvdb_level_set.h new file mode 100644 index 00000000000..c2e1e582fff --- /dev/null +++ b/intern/openvdb/intern/openvdb_level_set.h @@ -0,0 +1,60 @@ +/* + * 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_LEVEL_SET_H__ +#define __OPENVDB_LEVEL_SET_H__ + +#include <openvdb/openvdb.h> +#include <openvdb/math/FiniteDifference.h> +#include <openvdb/tools/MeshToVolume.h> +#include <openvdb/tools/VolumeToMesh.h> +#include <openvdb/tools/LevelSetFilter.h> +#include <openvdb/tools/GridTransformer.h> +#include "openvdb_capi.h" + +struct OpenVDBLevelSet { + private: + openvdb::FloatGrid::Ptr grid; + + public: + OpenVDBLevelSet(); + ~OpenVDBLevelSet(); + const openvdb::FloatGrid::Ptr &get_grid(); + void set_grid(const openvdb::FloatGrid::Ptr &grid); + + void mesh_to_level_set(const float *vertices, + const unsigned int *faces, + const unsigned int totvertices, + const unsigned int totfaces, + const openvdb::math::Transform::Ptr &transform); + + void volume_to_mesh(struct OpenVDBVolumeToMeshData *mesh, + const double isovalue, + const double adaptivity, + const bool relax_disoriented_triangles); + void filter(OpenVDBLevelSet_FilterType filter_type, + int width, + float distance, + OpenVDBLevelSet_FilterBias filter_bias); + openvdb::FloatGrid::Ptr CSG_operation_apply(const openvdb::FloatGrid::Ptr &gridA, + const openvdb::FloatGrid::Ptr &gridB, + OpenVDBLevelSet_CSGOperation operation); +}; + +#endif /* __OPENVDB_LEVEL_SET_H__ */ diff --git a/intern/openvdb/intern/openvdb_transform.cc b/intern/openvdb/intern/openvdb_transform.cc new file mode 100644 index 00000000000..4bfcf43f81a --- /dev/null +++ b/intern/openvdb/intern/openvdb_transform.cc @@ -0,0 +1,43 @@ +/* + * 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_transform.h" + +OpenVDBTransform::OpenVDBTransform() +{ +} + +OpenVDBTransform::~OpenVDBTransform() +{ +} + +void OpenVDBTransform::create_linear_transform(double voxel_size) +{ + this->transform = openvdb::math::Transform::createLinearTransform(voxel_size); +} + +const openvdb::math::Transform::Ptr &OpenVDBTransform::get_transform() +{ + return this->transform; +} + +void OpenVDBTransform::set_transform(const openvdb::math::Transform::Ptr &transform) +{ + this->transform = transform; +} diff --git a/intern/openvdb/intern/openvdb_transform.h b/intern/openvdb/intern/openvdb_transform.h new file mode 100644 index 00000000000..e2528cd0192 --- /dev/null +++ b/intern/openvdb/intern/openvdb_transform.h @@ -0,0 +1,37 @@ +/* + * 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_TRANSFORM_H +#define OPENVDB_TRANSFORM_H + +#include <openvdb/openvdb.h> + +struct OpenVDBTransform { + private: + openvdb::math::Transform::Ptr transform; + + public: + OpenVDBTransform(); + ~OpenVDBTransform(); + void create_linear_transform(double voxel_size); + const openvdb::math::Transform::Ptr &get_transform(); + void set_transform(const openvdb::math::Transform::Ptr &transform); +}; + +#endif // OPENVDB_TRANSFORM_H diff --git a/intern/openvdb/openvdb_capi.cc b/intern/openvdb/openvdb_capi.cc index aff27ee6c62..22d0d20ea4e 100644 --- a/intern/openvdb/openvdb_capi.cc +++ b/intern/openvdb/openvdb_capi.cc @@ -20,16 +20,8 @@ #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; -}; +#include "openvdb_level_set.h" +#include "openvdb_transform.h" int OpenVDB_getVersionHex() { @@ -238,3 +230,143 @@ void OpenVDBReader_get_meta_mat4(OpenVDBReader *reader, const char *name, float { reader->mat4sMeta(name, value); } + +OpenVDBLevelSet *OpenVDBLevelSet_create(bool initGrid, OpenVDBTransform *xform) +{ + OpenVDBLevelSet *level_set = new OpenVDBLevelSet(); + if (initGrid) { + openvdb::FloatGrid::Ptr grid = openvdb::FloatGrid::create(); + grid->setGridClass(openvdb::GRID_LEVEL_SET); + if (xform) { + grid->setTransform(xform->get_transform()); + } + level_set->set_grid(grid); + } + return level_set; +} + +OpenVDBTransform *OpenVDBTransform_create() +{ + return new OpenVDBTransform(); +} + +void OpenVDBTransform_free(OpenVDBTransform *transform) +{ + delete transform; +} + +void OpenVDBTransform_create_linear_transform(OpenVDBTransform *transform, double voxel_size) +{ + transform->create_linear_transform(voxel_size); +} + +void OpenVDBLevelSet_free(OpenVDBLevelSet *level_set) +{ + delete level_set; +} + +void OpenVDBLevelSet_mesh_to_level_set(struct OpenVDBLevelSet *level_set, + const float *vertices, + const unsigned int *faces, + const unsigned int totvertices, + const unsigned int totfaces, + OpenVDBTransform *xform) +{ + level_set->mesh_to_level_set(vertices, faces, totvertices, totfaces, xform->get_transform()); +} + +void OpenVDBLevelSet_mesh_to_level_set_transform(struct OpenVDBLevelSet *level_set, + const float *vertices, + const unsigned int *faces, + const unsigned int totvertices, + const unsigned int totfaces, + OpenVDBTransform *transform) +{ + level_set->mesh_to_level_set(vertices, faces, totvertices, totfaces, transform->get_transform()); +} + +void OpenVDBLevelSet_volume_to_mesh(struct OpenVDBLevelSet *level_set, + struct OpenVDBVolumeToMeshData *mesh, + const double isovalue, + const double adaptivity, + const bool relax_disoriented_triangles) +{ + level_set->volume_to_mesh(mesh, isovalue, adaptivity, relax_disoriented_triangles); +} + +void OpenVDBLevelSet_filter(struct OpenVDBLevelSet *level_set, + OpenVDBLevelSet_FilterType filter_type, + int width, + float distance, + OpenVDBLevelSet_FilterBias bias) +{ + level_set->filter(filter_type, width, distance, bias); +} + +void OpenVDBLevelSet_CSG_operation(struct OpenVDBLevelSet *out, + struct OpenVDBLevelSet *gridA, + struct OpenVDBLevelSet *gridB, + OpenVDBLevelSet_CSGOperation operation) +{ + openvdb::FloatGrid::Ptr grid = out->CSG_operation_apply( + gridA->get_grid(), gridB->get_grid(), operation); + out->set_grid(grid); +} + +OpenVDBLevelSet *OpenVDBLevelSet_transform_and_resample(struct OpenVDBLevelSet *level_setA, + struct OpenVDBLevelSet *level_setB, + char sampler, + float isolevel) +{ + openvdb::FloatGrid::Ptr sourceGrid = level_setA->get_grid(); + openvdb::FloatGrid::Ptr targetGrid = level_setB->get_grid()->deepCopy(); + + const openvdb::math::Transform &sourceXform = sourceGrid->transform(), + &targetXform = targetGrid->transform(); + + // Compute a source grid to target grid transform. + // (For this example, we assume that both grids' transforms are linear, + // so that they can be represented as 4 x 4 matrices.) + openvdb::Mat4R xform = sourceXform.baseMap()->getAffineMap()->getMat4() * + targetXform.baseMap()->getAffineMap()->getMat4().inverse(); + + // Create the transformer. + openvdb::tools::GridTransformer transformer(xform); + + switch (sampler) { + case OPENVDB_LEVELSET_GRIDSAMPLER_POINT: + // Resample using nearest-neighbor interpolation. + transformer.transformGrid<openvdb::tools::PointSampler, openvdb::FloatGrid>(*sourceGrid, + *targetGrid); + // Prune the target tree for optimal sparsity. + targetGrid->tree().prune(); + break; + + case OPENVDB_LEVELSET_GRIDSAMPLER_BOX: + // Resample using trilinear interpolation. + transformer.transformGrid<openvdb::tools::BoxSampler, openvdb::FloatGrid>(*sourceGrid, + *targetGrid); + // Prune the target tree for optimal sparsity. + targetGrid->tree().prune(); + break; + + case OPENVDB_LEVELSET_GRIDSAMPLER_QUADRATIC: + // Resample using triquadratic interpolation. + transformer.transformGrid<openvdb::tools::QuadraticSampler, openvdb::FloatGrid>(*sourceGrid, + *targetGrid); + // Prune the target tree for optimal sparsity. + targetGrid->tree().prune(); + break; + + case OPENVDB_LEVELSET_GRIDSAMPLER_NONE: + break; + } + + targetGrid = openvdb::tools::levelSetRebuild(*targetGrid, isolevel, 1.0f); + openvdb::tools::pruneLevelSet(targetGrid->tree()); + + OpenVDBLevelSet *level_set = OpenVDBLevelSet_create(false, NULL); + level_set->set_grid(targetGrid); + + return level_set; +} diff --git a/intern/openvdb/openvdb_capi.h b/intern/openvdb/openvdb_capi.h index 236bceea3e2..826481bde34 100644 --- a/intern/openvdb/openvdb_capi.h +++ b/intern/openvdb/openvdb_capi.h @@ -24,12 +24,80 @@ extern "C" { #endif +/* Level Set Filters */ +typedef enum OpenVDBLevelSet_FilterType { + OPENVDB_LEVELSET_FILTER_NONE = 0, + OPENVDB_LEVELSET_FILTER_GAUSSIAN = 1, + OPENVDB_LEVELSET_FILTER_MEAN = 2, + OPENVDB_LEVELSET_FILTER_MEDIAN = 3, + OPENVDB_LEVELSET_FILTER_MEAN_CURVATURE = 4, + OPENVDB_LEVELSET_FILTER_LAPLACIAN = 5, + OPENVDB_LEVELSET_FILTER_DILATE = 6, + OPENVDB_LEVELSET_FILTER_ERODE = 7, +} OpenVDBLevelSet_FilterType; + +typedef enum OpenVDBLevelSet_FilterBias { + OPENVDB_LEVELSET_FIRST_BIAS = 0, + OPENVDB_LEVELSET_SECOND_BIAS, + OPENVDB_LEVELSET_THIRD_BIAS, + OPENVDB_LEVELSET_WENO5_BIAS, + OPENVDB_LEVELSET_HJWENO5_BIAS, +} OpenVDBLevelSet_FilterBias; + +/* Level Set CSG Operations */ +typedef enum OpenVDBLevelSet_CSGOperation { + OPENVDB_LEVELSET_CSG_UNION = 0, + OPENVDB_LEVELSET_CSG_DIFFERENCE = 1, + OPENVDB_LEVELSET_CSG_INTERSECTION = 2, +} OpenVDBLevelSet_CSGOperation; + +typedef enum OpenVDBLevelSet_GridSampler { + OPENVDB_LEVELSET_GRIDSAMPLER_NONE = 0, + OPENVDB_LEVELSET_GRIDSAMPLER_POINT = 1, + OPENVDB_LEVELSET_GRIDSAMPLER_BOX = 2, + 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; + int totquads; + int totvertices; + + float *vertices; + unsigned int *quads; + unsigned int *triangles; +}; + +struct OpenVDBRemeshData { + float *verts; + unsigned int *faces; + int totfaces; + int totverts; + + float *out_verts; + unsigned int *out_faces; + unsigned int *out_tris; + int out_totverts; + int out_totfaces; + int out_tottris; + int filter_type; + enum OpenVDBLevelSet_FilterType filter_bias; + enum OpenVDBLevelSet_FilterBias filter_width; /* Parameter for gaussian, median, mean*/ + + float voxel_size; + float isovalue; + float adaptivity; + int relax_disoriented_triangles; +}; + int OpenVDB_getVersionHex(void); enum { @@ -112,6 +180,45 @@ 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, + double voxel_size); + +struct OpenVDBLevelSet *OpenVDBLevelSet_create(bool initGrid, struct OpenVDBTransform *xform); +void OpenVDBLevelSet_free(struct OpenVDBLevelSet *level_set); +void OpenVDBLevelSet_mesh_to_level_set(struct OpenVDBLevelSet *level_set, + const float *vertices, + const unsigned int *faces, + const unsigned int totvertices, + const unsigned int totfaces, + struct OpenVDBTransform *xform); +void OpenVDBLevelSet_mesh_to_level_set_transform(struct OpenVDBLevelSet *level_set, + const float *vertices, + const unsigned int *faces, + const unsigned int totvertices, + const unsigned int totfaces, + struct OpenVDBTransform *transform); +void OpenVDBLevelSet_volume_to_mesh(struct OpenVDBLevelSet *level_set, + struct OpenVDBVolumeToMeshData *mesh, + const double isovalue, + const double adaptivity, + const bool relax_disoriented_triangles); +void OpenVDBLevelSet_filter(struct OpenVDBLevelSet *level_set, + OpenVDBLevelSet_FilterType filter_type, + int width, + float distance, + OpenVDBLevelSet_FilterBias bias); +void OpenVDBLevelSet_CSG_operation(struct OpenVDBLevelSet *out, + struct OpenVDBLevelSet *gridA, + struct OpenVDBLevelSet *gridB, + OpenVDBLevelSet_CSGOperation operation); + +struct OpenVDBLevelSet *OpenVDBLevelSet_transform_and_resample(struct OpenVDBLevelSet *level_setA, + struct OpenVDBLevelSet *level_setB, + char sampler, + float isolevel); + #ifdef __cplusplus } #endif |