Blender V5.3
volume_render.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 "MEM_guardedalloc.h"
10
11#include "BLI_array.hh"
12#include "BLI_math_matrix_c.hh"
13#include "BLI_math_vector_c.hh"
15#include "BLI_task.hh"
16#include "BLI_vector.hh"
17
18#include "DNA_volume_types.h"
19
20#include "BKE_volume_grid.hh"
21#include "BKE_volume_openvdb.hh"
22#include "BKE_volume_render.hh"
23
24#ifdef WITH_OPENVDB
25# include <openvdb/openvdb.h>
26# include <openvdb/tools/Dense.h>
27#endif
28
29namespace blender {
30
31/* Dense Voxels */
32
33#ifdef WITH_OPENVDB
34
35template<typename GridType, typename VoxelType>
36static void extract_dense_voxels(const openvdb::GridBase &grid,
37 const openvdb::CoordBBox bbox,
38 VoxelType *r_voxels)
39{
40 BLI_assert(grid.isType<GridType>());
41 threading::memory_bandwidth_bound_task(bbox.volume() * sizeof(VoxelType), [&]() {
42 openvdb::tools::Dense<VoxelType, openvdb::tools::LayoutXYZ> dense(bbox, r_voxels);
43 openvdb::tools::copyToDense(static_cast<const GridType &>(grid), dense);
44 });
45}
46
47static void extract_dense_float_voxels(const VolumeGridType grid_type,
48 const openvdb::GridBase &grid,
49 const openvdb::CoordBBox &bbox,
50 float *r_voxels)
51{
52 switch (grid_type) {
54 extract_dense_voxels<openvdb::BoolGrid, float>(grid, bbox, r_voxels);
55 return;
56 }
57 case VOLUME_GRID_FLOAT: {
58 extract_dense_voxels<openvdb::FloatGrid, float>(grid, bbox, r_voxels);
59 return;
60 }
61 case VOLUME_GRID_DOUBLE: {
62 extract_dense_voxels<openvdb::DoubleGrid, float>(grid, bbox, r_voxels);
63 return;
64 }
65 case VOLUME_GRID_INT: {
66 extract_dense_voxels<openvdb::Int32Grid, float>(grid, bbox, r_voxels);
67 return;
68 }
69 case VOLUME_GRID_INT64: {
70 extract_dense_voxels<openvdb::Int64Grid, float>(grid, bbox, r_voxels);
71 return;
72 }
73 case VOLUME_GRID_MASK: {
74 extract_dense_voxels<openvdb::MaskGrid, float>(grid, bbox, r_voxels);
75 return;
76 }
78 extract_dense_voxels<openvdb::Vec3fGrid, openvdb::Vec3f>(
79 grid, bbox, reinterpret_cast<openvdb::Vec3f *>(r_voxels));
80 return;
81 }
83 extract_dense_voxels<openvdb::Vec3dGrid, openvdb::Vec3f>(
84 grid, bbox, reinterpret_cast<openvdb::Vec3f *>(r_voxels));
85 return;
86 }
88 extract_dense_voxels<openvdb::Vec3IGrid, openvdb::Vec3f>(
89 grid, bbox, reinterpret_cast<openvdb::Vec3f *>(r_voxels));
90 return;
91 }
94 /* Zero channels to copy. */
95 break;
96 }
97}
98
99static void create_texture_to_object_matrix(const openvdb::Mat4d &grid_transform,
100 const openvdb::CoordBBox &bbox,
101 float r_texture_to_object[4][4])
102{
103 float index_to_object[4][4];
104 memcpy(index_to_object, openvdb::Mat4s(grid_transform).asPointer(), sizeof(index_to_object));
105
106 float texture_to_index[4][4];
107 const openvdb::Vec3f loc = bbox.min().asVec3s() - openvdb::Vec3s(0.5f);
108 const openvdb::Vec3f size = bbox.dim().asVec3s();
109 size_to_mat4(texture_to_index, size.asV());
110 copy_v3_v3(texture_to_index[3], loc.asV());
111
112 mul_m4_m4m4(r_texture_to_object, index_to_object, texture_to_index);
113}
114
115#endif
116
118 const bke::VolumeGridData *volume_grid,
119 DenseFloatVolumeGrid *r_dense_grid)
120{
121#ifdef WITH_OPENVDB
122 const VolumeGridType grid_type = volume_grid->grid_type();
123 bke::VolumeTreeAccessToken tree_token;
124 const openvdb::GridBase &grid = volume_grid->grid(tree_token);
125
126 const openvdb::CoordBBox bbox = grid.evalActiveVoxelBoundingBox();
127 if (bbox.empty()) {
128 return false;
129 }
130 const std::array<int64_t, 6> bbox_indices = {UNPACK3(openvdb::math::Abs(bbox.min())),
131 UNPACK3(openvdb::math::Abs(bbox.max()))};
132 const int64_t max_bbox_index = *std::max_element(bbox_indices.begin(), bbox_indices.end());
133 if (max_bbox_index > (1 << 30)) {
134 /* There is an integer overflow when trying to extract dense voxels when the indices are very
135 * large. */
136 return false;
137 }
138
139 const openvdb::Vec3i resolution = bbox.dim().asVec3i();
140 const int64_t num_voxels = int64_t(resolution[0]) * int64_t(resolution[1]) *
141 int64_t(resolution[2]);
142 const int channels = bke::volume_grid::get_channels_num(grid_type);
143 float *voxels = MEM_new_array_uninitialized<float>(size_t(channels) * size_t(num_voxels),
144 __func__);
145 if (voxels == nullptr) {
146 return false;
147 }
148
149 extract_dense_float_voxels(grid_type, grid, bbox, voxels);
150 create_texture_to_object_matrix(grid.transform().baseMap()->getAffineMap()->getMat4(),
151 bbox,
152 r_dense_grid->texture_to_object);
153
154 r_dense_grid->voxels = voxels;
155 r_dense_grid->channels = channels;
156 copy_v3_v3_int(r_dense_grid->resolution, resolution.asV());
157 return true;
158#endif
159 UNUSED_VARS(volume, volume_grid, r_dense_grid);
160 return false;
161}
162
164{
165 if (dense_grid->voxels != nullptr) {
166 MEM_delete(dense_grid->voxels);
167 }
168}
169
170/* Wireframe */
171
172#ifdef WITH_OPENVDB
173
175template<typename GridType>
176static Vector<openvdb::CoordBBox> get_bounding_boxes(const GridType &grid, const bool coarse)
177{
178 using TreeType = typename GridType::TreeType;
179 using Depth2Type = typename TreeType::RootNodeType::ChildNodeType::ChildNodeType;
180 using NodeCIter = typename TreeType::NodeCIter;
181
182 Vector<openvdb::CoordBBox> boxes;
183 const int depth = coarse ? 2 : 3;
184
185 NodeCIter iter = grid.tree().cbeginNode();
186 iter.setMaxDepth(depth);
187
188 for (; iter; ++iter) {
189 if (iter.getDepth() != depth) {
190 continue;
191 }
192
193 openvdb::CoordBBox box;
194 if (depth == 2) {
195 /* Internal node at depth 2. */
196 const Depth2Type *node = nullptr;
197 iter.getNode(node);
198 if (node) {
199 node->evalActiveBoundingBox(box, false);
200 }
201 else {
202 continue;
203 }
204 }
205 else {
206 /* Leaf node. */
207 if (!iter.getBoundingBox(box)) {
208 continue;
209 }
210 }
211
212 /* +1 to convert from exclusive to inclusive bounds. */
213 box.max() = box.max().offsetBy(1);
214
215 boxes.append(box);
216 }
217
218 return boxes;
219}
220
221struct GetBoundingBoxesOp {
222 const openvdb::GridBase &grid;
223 const bool coarse;
224
225 template<typename GridType> Vector<openvdb::CoordBBox> operator()()
226 {
227 return get_bounding_boxes(static_cast<const GridType &>(grid), coarse);
228 }
229};
230
231static Vector<openvdb::CoordBBox> get_bounding_boxes(VolumeGridType grid_type,
232 const openvdb::GridBase &grid,
233 const bool coarse)
234{
235 GetBoundingBoxesOp op{grid, coarse};
236 return BKE_volume_grid_type_operation(grid_type, op);
237}
238
239static void boxes_to_center_points(Span<openvdb::CoordBBox> boxes,
240 const openvdb::math::Transform &transform,
241 MutableSpan<float3> r_verts)
242{
243 BLI_assert(boxes.size() == r_verts.size());
244 for (const int i : boxes.index_range()) {
245 openvdb::Vec3d center = transform.indexToWorld(boxes[i].getCenter());
246 r_verts[i] = float3(center[0], center[1], center[2]);
247 }
248}
249
250static void boxes_to_corner_points(Span<openvdb::CoordBBox> boxes,
251 const openvdb::math::Transform &transform,
252 MutableSpan<float3> r_verts)
253{
254 BLI_assert(boxes.size() * 8 == r_verts.size());
255 for (const int i : boxes.index_range()) {
256 const openvdb::CoordBBox &box = boxes[i];
257
258 /* The ordering of the corner points is lexicographic. */
259 std::array<openvdb::Coord, 8> corners;
260 box.getCornerPoints(corners.data());
261
262 for (int j = 0; j < 8; j++) {
263 openvdb::Coord corner_i = corners[j];
264 openvdb::Vec3d corner_d = transform.indexToWorld(corner_i);
265 r_verts[8 * i + j] = float3(corner_d[0], corner_d[1], corner_d[2]);
266 }
267 }
268}
269
270static void boxes_to_edge_mesh(Span<openvdb::CoordBBox> boxes,
271 const openvdb::math::Transform &transform,
272 Vector<float3> &r_verts,
273 Vector<std::array<int, 2>> &r_edges)
274{
275 /* TODO: Deduplicate edges, hide flat edges? */
276
277 const int box_edges[12][2] = {
278 {0, 1},
279 {0, 2},
280 {0, 4},
281 {1, 3},
282 {1, 5},
283 {2, 3},
284 {2, 6},
285 {3, 7},
286 {4, 5},
287 {4, 6},
288 {5, 7},
289 {6, 7},
290 };
291
292 int vert_offset = r_verts.size();
293 int edge_offset = r_edges.size();
294
295 const int vert_amount = 8 * boxes.size();
296 const int edge_amount = 12 * boxes.size();
297
298 r_verts.resize(r_verts.size() + vert_amount);
299 r_edges.resize(r_edges.size() + edge_amount);
300 boxes_to_corner_points(boxes, transform, r_verts.as_mutable_span().take_back(vert_amount));
301
302 for (int i = 0; i < boxes.size(); i++) {
303 for (int j = 0; j < 12; j++) {
304 r_edges[edge_offset + j] = {vert_offset + box_edges[j][0], vert_offset + box_edges[j][1]};
305 }
306 vert_offset += 8;
307 edge_offset += 12;
308 }
309}
310
311static void boxes_to_cube_mesh(Span<openvdb::CoordBBox> boxes,
312 const openvdb::math::Transform &transform,
313 Vector<float3> &r_verts,
314 Vector<std::array<int, 3>> &r_tris)
315{
316 const int box_tris[12][3] = {
317 {0, 1, 4},
318 {4, 1, 5},
319 {0, 2, 1},
320 {1, 2, 3},
321 {1, 3, 5},
322 {5, 3, 7},
323 {6, 4, 5},
324 {7, 5, 6},
325 {2, 0, 4},
326 {2, 4, 6},
327 {3, 7, 2},
328 {6, 2, 7},
329 };
330
331 int vert_offset = r_verts.size();
332 int tri_offset = r_tris.size();
333
334 const int vert_amount = 8 * boxes.size();
335 const int tri_amount = 12 * boxes.size();
336
337 r_verts.resize(r_verts.size() + vert_amount);
338 r_tris.resize(r_tris.size() + tri_amount);
339 boxes_to_corner_points(boxes, transform, r_verts.as_mutable_span().take_back(vert_amount));
340
341 for (int i = 0; i < boxes.size(); i++) {
342 for (int j = 0; j < 12; j++) {
343 r_tris[tri_offset + j] = {vert_offset + box_tris[j][0],
344 vert_offset + box_tris[j][1],
345 vert_offset + box_tris[j][2]};
346 }
347 vert_offset += 8;
348 tri_offset += 12;
349 }
350}
351
352#endif
353
355 const bke::VolumeGridData *volume_grid,
357 void *cb_userdata)
358{
360 cb(cb_userdata, nullptr, nullptr, 0, 0);
361 return;
362 }
363
364#ifdef WITH_OPENVDB
365 bke::VolumeTreeAccessToken tree_token;
366 const openvdb::GridBase &grid = volume_grid->grid(tree_token);
367
369 /* Bounding box. */
370 openvdb::CoordBBox box;
371 Vector<float3> verts;
373 if (grid.baseTree().evalLeafBoundingBox(box)) {
374 boxes_to_edge_mesh({box}, grid.transform(), verts, edges);
375 }
376 cb(cb_userdata,
377 (float (*)[3])verts.data(),
378 (int (*)[2])edges.data(),
379 verts.size(),
380 edges.size());
381 }
382 else {
383 Vector<openvdb::CoordBBox> boxes = get_bounding_boxes(volume_grid->grid_type(),
384 grid,
385 volume->display.wireframe_detail ==
387
388 Vector<float3> verts;
390
392 verts.resize(boxes.size());
393 boxes_to_center_points(boxes, grid.transform(), verts);
394 }
395 else {
396 boxes_to_edge_mesh(boxes, grid.transform(), verts, edges);
397 }
398
399 cb(cb_userdata,
400 (float (*)[3])verts.data(),
401 (int (*)[2])edges.data(),
402 verts.size(),
403 edges.size());
404 }
405
406#else
407 UNUSED_VARS(volume, volume_grid);
408 cb(cb_userdata, nullptr, nullptr, 0, 0);
409#endif
410}
411
412#ifdef WITH_OPENVDB
413static void grow_triangles(MutableSpan<float3> verts,
414 Span<std::array<int, 3>> tris,
415 const float factor)
416{
417 /* Compute the offset for every vertex based on the connected edges.
418 * This formula simply tries increases the length of all edges. */
419 Array<float3> offsets(verts.size(), {0, 0, 0});
420 Array<float> weights(verts.size(), 0.0f);
421 for (const std::array<int, 3> &tri : tris) {
422 offsets[tri[0]] += factor * (2 * verts[tri[0]] - verts[tri[1]] - verts[tri[2]]);
423 offsets[tri[1]] += factor * (2 * verts[tri[1]] - verts[tri[0]] - verts[tri[2]]);
424 offsets[tri[2]] += factor * (2 * verts[tri[2]] - verts[tri[0]] - verts[tri[1]]);
425 weights[tri[0]] += 1.0;
426 weights[tri[1]] += 1.0;
427 weights[tri[2]] += 1.0;
428 }
429 /* Apply the computed offsets. */
430 for (const int i : verts.index_range()) {
431 if (weights[i] > 0.0f) {
432 verts[i] += offsets[i] / weights[i];
433 }
434 }
435}
436#endif /* WITH_OPENVDB */
437
439 const bke::VolumeGridData *volume_grid,
441 void *cb_userdata)
442{
443#ifdef WITH_OPENVDB
444 bke::VolumeTreeAccessToken tree_token;
445 const openvdb::GridBase &grid = volume_grid->grid(tree_token);
446 Vector<openvdb::CoordBBox> boxes = get_bounding_boxes(volume_grid->grid_type(), grid, true);
447
448 Vector<float3> verts;
450 boxes_to_cube_mesh(boxes, grid.transform(), verts, tris);
451
452 /* By slightly scaling the individual boxes up, we can avoid some artifacts when drawing the
453 * selection outline. */
454 const float offset_factor = 0.01f;
455 grow_triangles(verts, tris, offset_factor);
456
457 cb(cb_userdata, (float (*)[3])verts.data(), (int (*)[3])tris.data(), verts.size(), tris.size());
458#else
460 cb(cb_userdata, nullptr, nullptr, 0, 0);
461#endif
462}
463
464/* Render */
465
466float BKE_volume_density_scale(const Volume *volume, const float matrix[4][4])
467{
468 if (volume->render.space == VOLUME_SPACE_OBJECT) {
469 float unit[3] = {1.0f, 1.0f, 1.0f};
470 normalize_v3(unit);
471 mul_mat3_m4_v3(matrix, unit);
472 return 1.0f / len_v3(unit);
473 }
474
475 return 1.0f;
476}
477
478} // namespace blender
Volume data-block rendering and viewport drawing utilities.
Read Blender memory allocation and freeing.
#define UNUSED_VARS(...)
#define UNPACK3(a)
SIMD_FORCE_INLINE btVector3 operator()(const btVector3 &x) const
Return the transform of the vector.
Definition btTransform.h:90
constexpr int64_t size() const
Definition BLI_span.hh:256
constexpr IndexRange index_range() const
Definition BLI_span.hh:405
int64_t size() const
void resize(const int64_t new_size)
int get_channels_num(VolumeGridType type)
std::array< VecBase< T, 3 >, 8 > corners(const Bounds< VecBase< T, 3 > > &bounds)
int size(const AssetLibraryReference *library_reference)
void memory_bandwidth_bound_task(const int64_t approximate_bytes_touched, const Function &function)
Definition BLI_task.hh:251
BMesh Iterators.
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
__int64 int64_t
Definition BKE_text.h:90
MINLINE void copy_v3_v3(float r[3], const float a[3])
void * MEM_new_array_uninitialized(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
void(*)(void *userdata, float(*verts)[3], int(*tris)[3], int totvert, int tottris) BKE_volume_selection_surface_cb
MINLINE void copy_v3_v3_int(int r[3], const int a[3])
void mul_m4_m4m4(float R[4][4], const float A[4][4], const float B[4][4])
bool BKE_volume_grid_dense_floats(const Volume *volume, const bke::VolumeGridData *volume_grid, DenseFloatVolumeGrid *r_dense_grid)
void(*)( void *userdata, const float(*verts)[3], const int(*edges)[2], int totvert, int totedge) BKE_volume_wireframe_cb
void size_to_mat4(float R[4][4], const float size[3])
@ VOLUME_GRID_VECTOR_FLOAT
@ VOLUME_GRID_VECTOR_DOUBLE
MINLINE float len_v3(const float a[3]) ATTR_WARN_UNUSED_RESULT
void mul_mat3_m4_v3(const float mat[4][4], float r[3])
float BKE_volume_density_scale(const Volume *volume, const float matrix[4][4])
MINLINE float normalize_v3(float n[3])
@ VOLUME_WIREFRAME_POINTS
@ VOLUME_WIREFRAME_BOUNDS
@ VOLUME_WIREFRAME_NONE
void BKE_volume_grid_wireframe(const Volume *volume, const bke::VolumeGridData *volume_grid, BKE_volume_wireframe_cb cb, void *cb_userdata)
VecBase< float, 3 > float3
@ VOLUME_WIREFRAME_COARSE
void BKE_volume_dense_float_grid_clear(DenseFloatVolumeGrid *dense_grid)
void BKE_volume_grid_selection_surface(const Volume *volume, const bke::VolumeGridData *volume_grid, BKE_volume_selection_surface_cb cb, void *cb_userdata)
VolumeWireframeDetail wireframe_detail
VolumeWireframeType wireframe_type
VolumeRenderSpace space
VolumeRender render
VolumeDisplay display