17 # include <openvdb/tools/GridTransformer.h>
18 # include <openvdb/tools/VolumeToMesh.h>
27 struct VolumeToMeshOp {
28 const openvdb::GridBase &base_grid;
29 const VolumeToMeshResolution resolution;
31 const float adaptivity;
32 std::vector<openvdb::Vec3s>
verts;
33 std::vector<openvdb::Vec3I> tris;
34 std::vector<openvdb::Vec4I> quads;
38 if constexpr (std::is_scalar_v<typename GridType::ValueType>) {
39 this->generate_mesh_data<GridType>();
45 template<
typename Gr
idType>
void generate_mesh_data()
47 const GridType &grid =
static_cast<const GridType &
>(base_grid);
50 this->grid_to_mesh(grid);
54 const float resolution_factor = this->compute_resolution_factor(base_grid);
55 typename GridType::Ptr temp_grid = this->create_grid_with_changed_resolution(
56 grid, resolution_factor);
57 this->grid_to_mesh(*temp_grid);
60 template<
typename Gr
idType>
61 typename GridType::Ptr create_grid_with_changed_resolution(
const GridType &old_grid,
62 const float resolution_factor)
68 openvdb::tools::GridTransformer transformer{xform};
71 transformer.transformGrid<openvdb::tools::BoxSampler>(old_grid, *new_grid);
72 new_grid->transform() = old_grid.transform();
73 new_grid->transform().preScale(1.0f / resolution_factor);
77 float compute_resolution_factor(
const openvdb::GridBase &grid)
const
79 const openvdb::Vec3s voxel_size{grid.voxelSize()};
80 const float current_voxel_size =
std::max({voxel_size[0], voxel_size[1], voxel_size[2]});
81 const float desired_voxel_size = this->compute_desired_voxel_size(grid);
82 return current_voxel_size / desired_voxel_size;
85 float compute_desired_voxel_size(
const openvdb::GridBase &grid)
const
88 return this->resolution.settings.voxel_size;
90 const openvdb::CoordBBox coord_bbox = base_grid.evalActiveVoxelBoundingBox();
91 const openvdb::BBoxd bbox = grid.transform().indexToWorld(coord_bbox);
92 const float max_extent = bbox.extents()[bbox.maxExtent()];
93 const float voxel_size = max_extent / this->resolution.settings.voxel_amount;
97 template<
typename Gr
idType>
void grid_to_mesh(
const GridType &grid)
99 openvdb::tools::volumeToMesh(
100 grid, this->verts, this->tris, this->quads, this->threshold, this->adaptivity);
103 openvdb::Vec3s
offset = grid.voxelSize() / 2.0f;
104 for (openvdb::Vec3s &position : this->verts) {
110 void fill_mesh_from_openvdb_data(
const Span<openvdb::Vec3s> vdb_verts,
111 const Span<openvdb::Vec3I> vdb_tris,
112 const Span<openvdb::Vec4I> vdb_quads,
113 const int vert_offset,
114 const int poly_offset,
115 const int loop_offset,
116 MutableSpan<MVert>
verts,
117 MutableSpan<MPoly> polys,
118 MutableSpan<MLoop> loops)
121 for (
const int i : vdb_verts.index_range()) {
127 for (
const int i : vdb_tris.index_range()) {
128 polys[poly_offset + i].loopstart = loop_offset + 3 * i;
129 polys[poly_offset + i].totloop = 3;
130 for (
int j = 0; j < 3; j++) {
132 loops[loop_offset + 3 * i + j].v = vert_offset + vdb_tris[i][2 - j];
137 const int quad_offset = poly_offset + vdb_tris.size();
138 const int quad_loop_offset = loop_offset + vdb_tris.size() * 3;
139 for (
const int i : vdb_quads.index_range()) {
140 polys[quad_offset + i].loopstart = quad_loop_offset + 4 * i;
141 polys[quad_offset + i].totloop = 4;
142 for (
int j = 0; j < 4; j++) {
144 loops[quad_loop_offset + 4 * i + j].v = vert_offset + vdb_quads[i][3 - j];
149 bke::OpenVDBMeshData volume_to_mesh_data(
const openvdb::GridBase &grid,
150 const VolumeToMeshResolution &resolution,
152 const float adaptivity)
154 const VolumeGridType grid_type = BKE_volume_grid_type_openvdb(grid);
156 VolumeToMeshOp to_mesh_op{grid, resolution,
threshold, adaptivity};
157 if (!BKE_volume_grid_type_operation(grid_type, to_mesh_op)) {
160 return {std::move(to_mesh_op.verts), std::move(to_mesh_op.tris), std::move(to_mesh_op.quads)};
163 Mesh *volume_to_mesh(
const openvdb::GridBase &grid,
164 const VolumeToMeshResolution &resolution,
166 const float adaptivity)
168 const bke::OpenVDBMeshData mesh_data = volume_to_mesh_data(
169 grid, resolution,
threshold, adaptivity);
171 const int tot_loops = 3 * mesh_data.tris.size() + 4 * mesh_data.quads.size();
172 const int tot_polys = mesh_data.tris.size() + mesh_data.quads.size();
175 fill_mesh_from_openvdb_data(mesh_data.verts,
181 {mesh->mvert, mesh->totvert},
182 {mesh->mpoly, mesh->totpoly},
183 {mesh->mloop, mesh->totloop});
struct Mesh * BKE_mesh_new_nomain(int verts_len, int edges_len, int tessface_len, int loops_len, int polys_len)
void BKE_mesh_calc_edges(struct Mesh *mesh, bool keep_existing_edges, bool select_new_edges)
MINLINE void copy_v3_v3(float r[3], const float a[3])
@ VOLUME_TO_MESH_RESOLUTION_MODE_VOXEL_SIZE
@ VOLUME_TO_MESH_RESOLUTION_MODE_GRID
ccl_gpu_kernel_postfix ccl_global float int int int int float threshold
ccl_gpu_kernel_postfix ccl_global float int int int int float bool int offset
VecMat::Vec3< double > Vec3d
std::unique_ptr< IDProperty, IDPropertyDeleter > create(StringRefNull prop_name, int32_t value)
Allocate a new IDProperty of type IDP_INT, set its name and value.
vec_base< float, 3 > float3