Blender V5.3
volume_to_mesh.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include <fmt/format.h>
10#include <vector>
11
13#include "BLI_span.hh"
14
15#include "BKE_mesh.hh"
16#include "BKE_volume_grid.hh"
17#include "BKE_volume_openvdb.hh"
18
19#ifdef WITH_OPENVDB
20# include <openvdb/tools/GridTransformer.h>
21# include <openvdb/tools/VolumeToMesh.h>
22#endif
23
24#include "BKE_volume_to_mesh.hh"
25
26#include "BLT_translation.hh"
27
28namespace blender::bke {
29
30#ifdef WITH_OPENVDB
31
32struct VolumeToMeshOp {
33 const openvdb::GridBase &base_grid;
34 const VolumeToMeshResolution resolution;
35 const float threshold;
36 const float adaptivity;
37 std::vector<openvdb::Vec3s> verts;
38 std::vector<openvdb::Vec3I> tris;
39 std::vector<openvdb::Vec4I> quads;
40 std::string error;
41
42 template<typename GridType> bool operator()()
43 {
44 if constexpr (std::is_scalar_v<typename GridType::ValueType>) {
45 this->generate_mesh_data<GridType>();
46 return true;
47 }
48 return false;
49 }
50
51 template<typename GridType> void generate_mesh_data()
52 {
53 const GridType &grid = static_cast<const GridType &>(base_grid);
54
55 if (this->resolution.mode == VOLUME_TO_MESH_RESOLUTION_MODE_GRID) {
56 this->grid_to_mesh(grid);
57 return;
58 }
59
60 const std::optional<float> resolution_factor = this->compute_resolution_factor(base_grid);
61 if (resolution_factor.has_value()) {
62 typename GridType::Ptr temp_grid = this->create_grid_with_changed_resolution(
63 grid, resolution_factor.value());
64 this->grid_to_mesh(*temp_grid);
65 }
66 }
67
68 template<typename GridType>
69 typename GridType::Ptr create_grid_with_changed_resolution(const GridType &old_grid,
70 const float resolution_factor)
71 {
72 BLI_assert(resolution_factor > 0.0f);
73
74 openvdb::Mat4R xform;
75 xform.setToScale(openvdb::Vec3d(resolution_factor));
76 openvdb::tools::GridTransformer transformer{xform};
77
78 typename GridType::Ptr new_grid = GridType::create();
79 transformer.transformGrid<openvdb::tools::BoxSampler>(old_grid, *new_grid);
80 new_grid->transform() = old_grid.transform();
81 new_grid->transform().preScale(1.0f / resolution_factor);
82 return new_grid;
83 }
84
85 std::optional<float> compute_resolution_factor(const openvdb::GridBase &grid) const
86 {
87 const openvdb::Vec3s voxel_size{grid.voxelSize()};
88 const float current_voxel_size = std::max({voxel_size[0], voxel_size[1], voxel_size[2]});
89 const std::optional<float> desired_voxel_size = this->compute_desired_voxel_size(grid);
90 if (!desired_voxel_size.has_value()) {
91 return std::nullopt;
92 }
93 return current_voxel_size / desired_voxel_size.value();
94 }
95
96 std::optional<float> compute_desired_voxel_size(const openvdb::GridBase &grid) const
97 {
98 if (this->resolution.mode == VOLUME_TO_MESH_RESOLUTION_MODE_VOXEL_SIZE) {
99 return this->resolution.settings.voxel_size;
100 }
101 const openvdb::CoordBBox coord_bbox = base_grid.evalActiveVoxelBoundingBox();
102 const openvdb::BBoxd bbox = grid.transform().indexToWorld(coord_bbox);
103 const float max_extent = bbox.extents()[bbox.maxExtent()];
104 if (max_extent == 0.0f) {
105 return std::nullopt;
106 }
107 const float voxel_size = max_extent / this->resolution.settings.voxel_amount;
108 return voxel_size;
109 }
110
111 template<typename GridType> void grid_to_mesh(const GridType &grid)
112 {
113 try {
114 openvdb::tools::volumeToMesh(
115 grid, this->verts, this->tris, this->quads, this->threshold, this->adaptivity);
116 }
117 catch (const std::exception &e) {
118 this->error = fmt::format(fmt::runtime(TIP_("OpenVDB error: {}")), e.what());
119 this->verts.clear();
120 this->tris.clear();
121 this->quads.clear();
122 }
123 }
124};
125
126void fill_mesh_from_openvdb_data(const Span<openvdb::Vec3s> vdb_verts,
127 const Span<openvdb::Vec3I> vdb_tris,
128 const Span<openvdb::Vec4I> vdb_quads,
129 const int vert_offset,
130 const int face_offset,
131 const int loop_offset,
132 MutableSpan<float3> vert_positions,
133 MutableSpan<int> face_offsets,
134 MutableSpan<int> corner_verts)
135{
136 /* Write vertices. */
137 vert_positions.slice(vert_offset, vdb_verts.size()).copy_from(vdb_verts.cast<float3>());
138
139 /* Write triangles. */
140 for (const int i : vdb_tris.index_range()) {
141 face_offsets[face_offset + i] = loop_offset + 3 * i;
142 for (int j = 0; j < 3; j++) {
143 /* Reverse vertex order to get correct normals. */
144 corner_verts[loop_offset + 3 * i + j] = vert_offset + vdb_tris[i][2 - j];
145 }
146 }
147
148 /* Write quads. */
149 const int quad_offset = face_offset + vdb_tris.size();
150 const int quad_loop_offset = loop_offset + vdb_tris.size() * 3;
151 for (const int i : vdb_quads.index_range()) {
152 face_offsets[quad_offset + i] = quad_loop_offset + 4 * i;
153 for (int j = 0; j < 4; j++) {
154 /* Reverse vertex order to get correct normals. */
155 corner_verts[quad_loop_offset + 4 * i + j] = vert_offset + vdb_quads[i][3 - j];
156 }
157 }
158}
159
160bke::VolumeToMeshDataResult volume_to_mesh_data(const openvdb::GridBase &grid,
161 const VolumeToMeshResolution &resolution,
162 const float threshold,
163 const float adaptivity)
164{
165 const VolumeGridType grid_type = bke::volume_grid::get_type(grid);
166
167 VolumeToMeshOp to_mesh_op{grid, resolution, threshold, adaptivity};
168 if (!BKE_volume_grid_type_operation(grid_type, to_mesh_op)) {
169 return {};
170 }
171 return {{std::move(to_mesh_op.verts), std::move(to_mesh_op.tris), std::move(to_mesh_op.quads)},
172 to_mesh_op.error};
173}
174
175Mesh *volume_to_mesh(const openvdb::GridBase &grid,
176 const VolumeToMeshResolution &resolution,
177 const float threshold,
178 const float adaptivity)
179{
180 using namespace blender::bke;
181 const OpenVDBMeshData mesh_data =
182 volume_to_mesh_data(grid, resolution, threshold, adaptivity).data;
183
184 const int tot_loops = 3 * mesh_data.tris.size() + 4 * mesh_data.quads.size();
185 const int tot_faces = mesh_data.tris.size() + mesh_data.quads.size();
186 Mesh *mesh = BKE_mesh_new_nomain(mesh_data.verts.size(), 0, tot_faces, tot_loops);
187
188 fill_mesh_from_openvdb_data(mesh_data.verts,
189 mesh_data.tris,
190 mesh_data.quads,
191 0,
192 0,
193 0,
194 mesh->vert_positions_for_write(),
195 mesh->face_offsets_for_write(),
196 mesh->corner_verts_for_write());
197
198 mesh_calc_edges(*mesh, false, false);
199 mesh_smooth_set(*mesh, false);
200
201 mesh->tag_overlapping_none();
202
203 return mesh;
204}
205
206Mesh *volume_grid_to_mesh(const openvdb::GridBase &grid,
207 const float threshold,
208 const float adaptivity)
209{
210 return volume_to_mesh(grid, {VOLUME_TO_MESH_RESOLUTION_MODE_GRID}, threshold, adaptivity);
211}
212
213#endif /* WITH_OPENVDB */
214
215} // namespace blender::bke
#define TIP_(msgid)
#define BLI_assert(a)
SIMD_FORCE_INLINE btVector3 operator()(const btVector3 &x) const
Return the transform of the vector.
Definition btTransform.h:90
Span< NewT > constexpr cast() const
Definition BLI_span.hh:422
constexpr int64_t size() const
Definition BLI_span.hh:256
constexpr IndexRange index_range() const
Definition BLI_span.hh:405
VolumeGridType get_type(const VolumeGridData &grid)
void mesh_smooth_set(Mesh &mesh, bool use_smooth, bool keep_sharp_edges=false)
void mesh_calc_edges(Mesh &mesh, bool keep_existing_edges, bool select_new_edges)
Mesh * BKE_mesh_new_nomain(int verts_num, int edges_num, int faces_num, int corners_num)
@ VOLUME_TO_MESH_RESOLUTION_MODE_GRID
VecBase< float, 3 > float3
ATTR_WARN_UNUSED_RESULT const BMVert const BMEdge * e