Blender V5.3
mesh_to_volume.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 "BLI_math_matrix.hh"
10#include "BLI_task.hh"
11
12#include "BKE_volume.hh"
13#include "BKE_volume_grid.hh"
14#include "BKE_volume_openvdb.hh"
15
16#include "GEO_mesh_to_volume.hh"
17
18#ifdef WITH_OPENVDB
19# include <algorithm>
20# include <openvdb/openvdb.h>
21# include <openvdb/tools/GridTransformer.h>
22# include <openvdb/tools/LevelSetUtil.h>
23# include <openvdb/tools/VolumeToMesh.h>
24
25namespace blender::geometry {
26
27/* This class follows the MeshDataAdapter interface from openvdb. */
28class OpenVDBMeshAdapter {
29 private:
30 Span<float3> positions_;
31 Span<int> corner_verts_;
32 Span<int3> corner_tris_;
33 float4x4 transform_;
34
35 public:
36 OpenVDBMeshAdapter(const Span<float3> positions,
37 const Span<int> corner_verts,
38 const Span<int3> corner_tris,
39 const float4x4 &transform);
40 size_t polygonCount() const;
41 size_t pointCount() const;
42 size_t vertexCount(size_t /*polygon_index*/) const;
43 void getIndexSpacePoint(size_t polygon_index, size_t vertex_index, openvdb::Vec3d &pos) const;
44};
45
46OpenVDBMeshAdapter::OpenVDBMeshAdapter(const Span<float3> positions,
47 const Span<int> corner_verts,
48 const Span<int3> corner_tris,
49 const float4x4 &transform)
50 : positions_(positions),
51 corner_verts_(corner_verts),
52 corner_tris_(corner_tris),
53 transform_(transform)
54{
55}
56
57size_t OpenVDBMeshAdapter::polygonCount() const
58{
59 return size_t(corner_tris_.size());
60}
61
62size_t OpenVDBMeshAdapter::pointCount() const
63{
64 return size_t(positions_.size());
65}
66
67size_t OpenVDBMeshAdapter::vertexCount(size_t /*polygon_index*/) const
68{
69 /* All polygons are triangles. */
70 return 3;
71}
72
73void OpenVDBMeshAdapter::getIndexSpacePoint(size_t polygon_index,
74 size_t vertex_index,
75 openvdb::Vec3d &pos) const
76{
77 const int3 &tri = corner_tris_[polygon_index];
78 const float3 transformed_co = math::transform_point(
79 transform_, positions_[corner_verts_[tri[vertex_index]]]);
80 pos = &transformed_co.x;
81}
82
83float volume_compute_voxel_size(const Depsgraph *depsgraph,
84 const FunctionRef<Bounds<float3>()> bounds_fn,
85 const MeshToVolumeResolution res,
86 const float exterior_band_width,
87 const float4x4 &transform)
88{
89 const float volume_simplify = BKE_volume_simplify_factor(depsgraph);
90 if (volume_simplify == 0.0f) {
91 return 0.0f;
92 }
93
94 if (res.mode == MESH_TO_VOLUME_RESOLUTION_MODE_VOXEL_SIZE) {
95 return res.settings.voxel_size / volume_simplify;
96 }
97 if (res.settings.voxel_amount <= 0) {
98 return 0;
99 }
100
101 const Bounds<float3> bounds = bounds_fn();
102
103 /* Compute the diagonal of the bounding box. This is used because
104 * it will always be bigger than the widest side of the mesh. */
105 const float diagonal = math::distance(math::transform_point(transform, bounds.min),
106 math::transform_point(transform, bounds.max));
107
108 /* To get the approximate size per voxel, first subtract the exterior band from the requested
109 * voxel amount, then divide the diagonal with this value if it's bigger than 1. */
110 const float voxel_size =
111 (diagonal / std::max(1.0f, float(res.settings.voxel_amount) - 2.0f * exterior_band_width));
112
113 /* Return the simplified voxel size. */
114 return voxel_size / volume_simplify;
115}
116
117static openvdb::FloatGrid::Ptr mesh_to_density_grid_impl(
118 const Span<float3> positions,
119 const Span<int> corner_verts,
120 const Span<int3> corner_tris,
121 const float4x4 &mesh_to_volume_space_transform,
122 const float voxel_size,
123 const float interior_band_width,
124 const float density)
125{
126 if (!BKE_volume_voxel_size_valid(float3(voxel_size))) {
127 return nullptr;
128 }
129
130 float4x4 mesh_to_index_space_transform = math::from_scale<float4x4>(float3(1.0f / voxel_size));
131 mesh_to_index_space_transform *= mesh_to_volume_space_transform;
132
133 OpenVDBMeshAdapter mesh_adapter{
134 positions, corner_verts, corner_tris, mesh_to_index_space_transform};
135 const float interior = std::max(1.0f, interior_band_width / voxel_size);
136
137 openvdb::math::Transform::Ptr transform = openvdb::math::Transform::createLinearTransform(
138 voxel_size);
139 openvdb::FloatGrid::Ptr new_grid = openvdb::tools::meshToVolume<openvdb::FloatGrid>(
140 mesh_adapter, *transform, 1.0f, interior);
141
142 openvdb::tools::sdfToFogVolume(*new_grid);
143
144 if (density != 1.0f) {
145 openvdb::tools::foreach(new_grid->beginValueOn(),
146 [&](const openvdb::FloatGrid::ValueOnIter &iter) {
147 iter.modifyValue([&](float &value) { value *= density; });
148 });
149 }
150 return new_grid;
151}
152
153bke::VolumeGrid<float> mesh_to_density_grid(const Span<float3> positions,
154 const Span<int> corner_verts,
155 const Span<int3> corner_tris,
156 const float voxel_size,
157 const float interior_band_width,
158 const float density)
159{
160 openvdb::FloatGrid::Ptr grid = mesh_to_density_grid_impl(positions,
161 corner_verts,
162 corner_tris,
163 float4x4::identity(),
164 voxel_size,
165 interior_band_width,
166 density);
167 if (!grid) {
168 return {};
169 }
170 return bke::VolumeGrid<float>(std::move(grid));
171}
172
173bke::VolumeGrid<float> mesh_to_sdf_grid(const Span<float3> positions,
174 const Span<int> corner_verts,
175 const Span<int3> corner_tris,
176 const float voxel_size,
177 const float half_band_width)
178{
179 if (!BKE_volume_voxel_size_valid(float3(voxel_size)) || half_band_width <= 0.0f) {
180 return {};
181 }
182
183 std::vector<openvdb::Vec3s> points(positions.size());
184 std::vector<openvdb::Vec3I> triangles(corner_tris.size());
185
186 threading::parallel_for(positions.index_range(), 2048, [&](const IndexRange range) {
187 for (const int i : range) {
188 const float3 &co = positions[i];
189 points[i] = openvdb::Vec3s(co.x, co.y, co.z);
190 }
191 });
192
193 threading::parallel_for(corner_tris.index_range(), 2048, [&](const IndexRange range) {
194 for (const int i : range) {
195 const int3 &tri = corner_tris[i];
196 triangles[i] = openvdb::Vec3I(
197 corner_verts[tri[0]], corner_verts[tri[1]], corner_verts[tri[2]]);
198 }
199 });
200
201 openvdb::math::Transform::Ptr transform = openvdb::math::Transform::createLinearTransform(
202 voxel_size);
203 openvdb::FloatGrid::Ptr new_grid = openvdb::tools::meshToLevelSet<openvdb::FloatGrid>(
204 *transform, points, triangles, half_band_width);
205
206 return bke::VolumeGrid<float>(std::move(new_grid));
207}
208
209bke::VolumeGridData *fog_volume_grid_add_from_mesh(Volume *volume,
210 const StringRefNull name,
211 const Span<float3> positions,
212 const Span<int> corner_verts,
213 const Span<int3> corner_tris,
214 const float4x4 &mesh_to_volume_space_transform,
215 const float voxel_size,
216 const float interior_band_width,
217 const float density)
218{
219 openvdb::FloatGrid::Ptr mesh_grid = mesh_to_density_grid_impl(positions,
220 corner_verts,
221 corner_tris,
222 mesh_to_volume_space_transform,
223 voxel_size,
224 interior_band_width,
225 density);
226 return mesh_grid ? BKE_volume_grid_add_vdb(*volume, name, std::move(mesh_grid)) : nullptr;
227}
228
229} // namespace blender::geometry
230#endif
Volume data-block.
SIMD_FORCE_INLINE btVector3 transform(const btVector3 &point) const
static btDbvtVolume bounds(btDbvtNode **leaves, int count)
Definition btDbvt.cpp:299
constexpr int64_t size() const
Definition BLI_span.hh:256
constexpr IndexRange index_range() const
Definition BLI_span.hh:405
MatBase< 4, 4 > float4x4
MatBase< float, 4, 4 > float4x4
float BKE_volume_simplify_factor(const Depsgraph *depsgraph)
bool BKE_volume_voxel_size_valid(const float3 &voxel_size)
float4 transform(float4 hs_position)
float x
Definition sky_math.h:136