16# include <openvdb/tools/GridTransformer.h>
17# include <openvdb/tools/LevelSetUtil.h>
18# include <openvdb/tools/Morphology.h>
23#include "util/nanovdb.h"
30#include <OpenImageIO/filesystem.h>
80#if defined(WITH_OPENVDB) && defined(WITH_NANOVDB)
81const int quads_indices[6][4] = {
96const float3 quads_normals[6] = {
113 const VertHashMap::iterator it = used_verts.find(v);
115 if (it != used_verts.end()) {
119 const int vertex_offset = vertices.size();
120 used_verts[
v] = vertex_offset;
121 vertices.push_back(v);
122 return vertex_offset;
125static void create_quad(
const int3 corners[8],
129 const int face_index)
132 quad.
v0 = add_vertex(corners[quads_indices[face_index][0]], vertices, used_verts);
133 quad.
v1 = add_vertex(corners[quads_indices[face_index][1]], vertices, used_verts);
134 quad.
v2 = add_vertex(corners[quads_indices[face_index][2]], vertices, used_verts);
135 quad.
v3 = add_vertex(corners[quads_indices[face_index][3]], vertices, used_verts);
136 quad.
normal = quads_normals[face_index];
138 quads.push_back(quad);
150class VolumeMeshBuilder {
153 openvdb::MaskGrid::Ptr topology_grid;
158 void add_grid(
const nanovdb::GridHandle<> &grid);
160 void add_padding(
const int pad_size);
162 void create_mesh(vector<float3> &vertices, vector<int> &indices,
const bool ray_marching);
164 void generate_vertices_and_quads(vector<int3> &vertices_is,
165 vector<QuadData> &quads,
166 const bool ray_marching);
168 void convert_object_space(
const vector<int3> &vertices, vector<float3> &out_vertices);
170 void convert_quads_to_tris(
const vector<QuadData> &quads, vector<int> &tris);
172 bool empty_grid()
const;
175VolumeMeshBuilder::VolumeMeshBuilder()
180void VolumeMeshBuilder::add_grid(
const nanovdb::GridHandle<> &nanogrid)
183 openvdb::MaskGrid::Ptr grid = nanovdb_to_openvdb_mask(nanogrid);
186 topology_grid = grid;
194 if (topology_grid->transform() != grid->transform()) {
195 const openvdb::MaskGrid::Ptr temp_grid = topology_grid->copyWithNewTree();
196 temp_grid->setTransform(grid->transform().copy());
197 openvdb::tools::resampleToMatch<openvdb::tools::BoxSampler>(*topology_grid, *temp_grid);
198 topology_grid = temp_grid;
199 topology_grid->setTransform(grid->transform().copy());
202 topology_grid->topologyUnion(*grid);
205void VolumeMeshBuilder::add_padding(
const int pad_size)
207 openvdb::tools::dilateActiveValues(topology_grid->tree(),
209 openvdb::tools::NN_FACE_EDGE_VERTEX,
210 openvdb::tools::PRESERVE_TILES);
215 const bool ray_marching)
222 generate_vertices_and_quads(vertices_is, quads, ray_marching);
224 convert_object_space(vertices_is, vertices);
226 convert_quads_to_tris(quads, indices);
229static bool is_non_empty_leaf(
const openvdb::MaskGrid::TreeType &tree,
const openvdb::Coord coord)
231 const auto *leaf_node = tree.probeLeaf(coord);
232 return (leaf_node && !leaf_node->isEmpty());
235void VolumeMeshBuilder::generate_vertices_and_quads(
vector<ccl::int3> &vertices_is,
237 const bool ray_marching)
241 topology_grid->tree().voxelizeActiveTiles();
243 const openvdb::MaskGrid::TreeType &tree = topology_grid->tree();
248 openvdb::CoordBBox active_bbox;
249 tree.evalActiveVoxelBoundingBox(active_bbox);
251 active_bbox.max() = active_bbox.max().offsetBy(1);
254 for (
auto iter = tree.cbeginLeaf(); iter; ++iter) {
255 if (iter->isEmpty()) {
258 openvdb::CoordBBox leaf_bbox = iter->getNodeBoundingBox();
261 static const int LEAF_DIM = openvdb::MaskGrid::TreeType::LeafNodeType::DIM;
262 const auto center = leaf_bbox.min() + openvdb::Coord(LEAF_DIM / 2);
265 leaf_bbox.max() = leaf_bbox.max().offsetBy(1);
267 leaf_bbox.min() = openvdb::Coord::maxComponent(leaf_bbox.min(), active_bbox.min());
268 leaf_bbox.max() = openvdb::Coord::minComponent(leaf_bbox.max(), active_bbox.max());
270 const int3 min =
make_int3(leaf_bbox.min().x(), leaf_bbox.min().y(), leaf_bbox.min().z());
271 const int3 max =
make_int3(leaf_bbox.max().x(), leaf_bbox.max().y(), leaf_bbox.max().z());
288 if (!is_non_empty_leaf(tree, openvdb::Coord(center.x() - LEAF_DIM, center.y(), center.z())))
290 create_quad(corners, vertices_is, quads, used_verts,
QUAD_X_MIN);
292 if (!is_non_empty_leaf(tree, openvdb::Coord(center.x() + LEAF_DIM, center.y(), center.z())))
294 create_quad(corners, vertices_is, quads, used_verts,
QUAD_X_MAX);
296 if (!is_non_empty_leaf(tree, openvdb::Coord(center.x(), center.y() - LEAF_DIM, center.z())))
298 create_quad(corners, vertices_is, quads, used_verts,
QUAD_Y_MIN);
300 if (!is_non_empty_leaf(tree, openvdb::Coord(center.x(), center.y() + LEAF_DIM, center.z())))
302 create_quad(corners, vertices_is, quads, used_verts,
QUAD_Y_MAX);
304 if (!is_non_empty_leaf(tree, openvdb::Coord(center.x(), center.y(), center.z() - LEAF_DIM)))
306 create_quad(corners, vertices_is, quads, used_verts,
QUAD_Z_MIN);
308 if (!is_non_empty_leaf(tree, openvdb::Coord(center.x(), center.y(), center.z() + LEAF_DIM)))
310 create_quad(corners, vertices_is, quads, used_verts,
QUAD_Z_MAX);
316 openvdb::CoordBBox bbox = topology_grid->evalActiveVoxelBoundingBox();
334 create_quad(corners, vertices_is, quads, used_verts,
QUAD_X_MIN);
335 create_quad(corners, vertices_is, quads, used_verts,
QUAD_X_MAX);
336 create_quad(corners, vertices_is, quads, used_verts,
QUAD_Y_MIN);
337 create_quad(corners, vertices_is, quads, used_verts,
QUAD_Y_MAX);
338 create_quad(corners, vertices_is, quads, used_verts,
QUAD_Z_MIN);
339 create_quad(corners, vertices_is, quads, used_verts,
QUAD_Z_MAX);
342void VolumeMeshBuilder::convert_object_space(
const vector<int3> &vertices,
345 out_vertices.reserve(vertices.size());
347 for (
size_t i = 0; i < vertices.size(); ++i) {
348 openvdb::math::Vec3d p = topology_grid->indexToWorld(
349 openvdb::math::Vec3d(vertices[i].
x, vertices[i].
y, vertices[i].
z));
351 out_vertices.push_back(
vertex);
360 const bool negative_scale =
361 topology_grid->transform().baseMap()->getAffineMap()->getMat4().det() < 0.0;
363 int index_offset = 0;
364 tris.resize(quads.size() * 6);
366 for (
size_t i = 0; i < quads.size(); ++i) {
367 tris[index_offset++] = quads[i].v0;
368 tris[index_offset++] = negative_scale ? quads[i].v1 : quads[i].v2;
369 tris[index_offset++] = negative_scale ? quads[i].v2 : quads[i].v1;
371 tris[index_offset++] = quads[i].v0;
372 tris[index_offset++] = negative_scale ? quads[i].v2 : quads[i].v3;
373 tris[index_offset++] = negative_scale ? quads[i].v3 : quads[i].v2;
377bool VolumeMeshBuilder::empty_grid()
const
379 return !topology_grid ||
380 (!topology_grid->tree().hasActiveTiles() && topology_grid->tree().leafCount() == 0);
391 double avg[3] = {0.0, 0.0, 0.0};
392 double var[3] = {0.0, 0.0, 0.0};
397 void add(
const double value[3])
400 for (
int i = 0; i < 3; i++) {
401 const double delta = value[i] - avg[i];
402 avg[i] += delta / double(size);
403 var[i] += delta * (value[i] - avg[i]);
407 void add(
const Vec3Stats &other)
409 if (other.size > 0) {
410 const double denom = 1.0 / (double(size + other.size));
411 for (
int i = 0; i < 3; i++) {
412 const double delta = other.avg[i] - avg[i];
413 avg[i] += denom * delta * double(other.size);
414 var[i] += other.var[i] + denom * delta * delta * double(size) * double(other.size);
423 var[0] = var[1] = var[2] = 0.0;
426 for (
int i = 0; i < 3; i++) {
427 var[i] /= double(size);
436 for (
auto value_it = leaf.cbeginValueOn(); value_it; ++value_it) {
437 const double value[3] = {(*value_it)[0], (*value_it)[1], (*value_it)[2]};
447 std::unique_ptr<const ChildT *[]> childNodes(
new const ChildT *[num_leaf]);
448 const ChildT **ptr = childNodes.get();
449 for (
auto it =
node.mChildMask.beginOn(); it; ++it) {
450 *ptr++ =
node.getChild(*it);
453 auto reduction_func = [&](
const blocked_range<uint32_t> &r, Vec3Stats
init) -> Vec3Stats {
454 for (uint32_t i = r.begin(); i < r.end(); ++i) {
455 init.add(compute_stats(*childNodes[i]));
460 auto join_func = [](Vec3Stats a, Vec3Stats
b) -> Vec3Stats {
465 const tbb::blocked_range<uint32_t> range(0, num_leaf);
472static int estimate_required_velocity_padding(
const nanovdb::GridHandle<> &grid,
473 const float velocity_scale)
475 const auto *typed_grid = grid.template grid<nanovdb::Vec3f>(0);
477 if (typed_grid ==
nullptr) {
481 const nanovdb::Vec3d voxel_size = typed_grid->voxelSize();
484 const double max_voxel_size = openvdb::math::Max(voxel_size[0], voxel_size[1], voxel_size[2]);
485 if (max_voxel_size == 0.0 || velocity_scale == 0.0f) {
490 for (
auto internal = typed_grid->tree().root().cbeginChild(); internal; ++internal) {
491 stats.add(compute_stats(*internal));
496 const double score = 2.32635;
497 double estimated_padding = 0.0f;
498 for (
int i = 0; i < 3; i++) {
499 const double max_velocity =
max(std::fabs(stats.avg[i] + score *
sqrt(stats.var[i])),
500 std::fabs(stats.avg[i] - score *
sqrt(stats.var[i])));
501 const double max_dist_in_voxel = max_velocity * double(velocity_scale) / voxel_size[i];
504 estimated_padding =
max(
505 min(max_dist_in_voxel, 0.5 *
double(typed_grid->tree().bbox().dim()[i])),
509 return static_cast<int>(std::ceil(estimated_padding));
527 const openvdb::GridBase::ConstPtr grid = vdb_loader->get_grid();
532 if (!grid->isType<openvdb::FloatGrid>()) {
536 return openvdb::gridConstPtrCast<openvdb::FloatGrid>(grid);
539class MergeScalarGrids {
542 openvdb::tree::ValueAccessor<const ScalarTree> m_acc_x, m_acc_y, m_acc_z;
545 MergeScalarGrids(
const ScalarTree *x_tree,
const ScalarTree *y_tree,
const ScalarTree *z_tree)
546 : m_acc_x(*x_tree), m_acc_y(*y_tree), m_acc_z(*z_tree)
550 MergeScalarGrids(
const MergeScalarGrids &other)
554 void operator()(
const openvdb::Vec3STree::ValueOnIter &it)
const
556 using namespace openvdb;
558 const math::Coord xyz = it.getCoord();
559 const float x = m_acc_x.getValue(xyz);
560 const float y = m_acc_y.getValue(xyz);
561 const float z = m_acc_z.getValue(xyz);
563 it.setValue(math::Vec3s(
x,
y,
z));
567static void merge_scalar_grids_for_velocity(
const Scene *scene,
Volume *volume)
574 const openvdb::FloatGrid::ConstPtr vel_x_grid = get_vdb_for_attribute(
576 const openvdb::FloatGrid::ConstPtr vel_y_grid = get_vdb_for_attribute(
578 const openvdb::FloatGrid::ConstPtr vel_z_grid = get_vdb_for_attribute(
581 if (!(vel_x_grid && vel_y_grid && vel_z_grid)) {
585 const openvdb::Vec3fGrid::Ptr vecgrid = openvdb::Vec3SGrid::create(openvdb::Vec3s(0.0f));
589 vecgrid->tree().topologyUnion(vel_x_grid->tree());
590 vecgrid->tree().topologyUnion(vel_y_grid->tree());
591 vecgrid->tree().topologyUnion(vel_z_grid->tree());
593 MergeScalarGrids op(&vel_x_grid->tree(), &vel_y_grid->tree(), &vel_z_grid->tree());
594 openvdb::tools::foreach(vecgrid->beginValueOn(), op,
true,
false);
597 const openvdb::math::Transform::Ptr
transform = openvdb::ConstPtrCast<openvdb::math::Transform>(
598 vel_x_grid->transformPtr());
613 const string msg =
string_printf(
"Computing Volume Mesh %s", volume->
name.c_str());
617 Shader *volume_shader =
nullptr;
620 for (
Node *
node : volume->get_used_shaders()) {
627 volume_shader = shader;
630 pad_size =
max(1, pad_size);
633 pad_size =
max(2, pad_size);
646 if (!volume_shader) {
650#if defined(WITH_OPENVDB) && defined(WITH_NANOVDB)
652 VolumeMeshBuilder builder;
661 if (handle.
empty()) {
667 if (
image ==
nullptr ||
image->host_pointer ==
nullptr ||
674 nanovdb::GridHandle grid(
675 nanovdb::HostBuffer::createFull(
image->memory_size(),
image->host_pointer));
679 pad_size =
max(pad_size,
680 estimate_required_velocity_padding(grid, volume->get_velocity_scale()));
683 builder.add_grid(grid);
687 if (builder.empty_grid()) {
688 LOG_DEBUG <<
"Memory usage volume mesh: 0 Mb. (empty grid)";
692 builder.add_padding(pad_size);
697 const bool ray_marching = scene->
integrator->get_volume_ray_marching();
698 builder.create_mesh(vertices, indices, ray_marching);
700 volume->
resize_mesh(vertices.size(), indices.size() / 3);
701 volume->used_shaders.
clear();
702 volume->used_shaders.push_back_slow(volume_shader);
705 std::ranges::copy(indices, volume->triangles.data());
706 std::ranges::fill(volume->get_shader(), 0);
707 std::ranges::fill(volume->get_smooth(),
false);
710 LOG_DEBUG <<
"Memory usage volume mesh: "
711 << (vertices.size() *
sizeof(
float3) + indices.size() *
sizeof(
int)) /
722 merge_scalar_grids_for_velocity(scene,
this);
730 need_rebuild_ =
true;
736 need_rebuild_ =
true;
742 if (object_octrees_.empty()) {
747 bool volume_object_updated =
false;
748 for (
const Object *
object : objects) {
749 if (!object->get_geometry()->has_volume) {
753 volume_object_updated =
true;
755 for (
const Node *
node : object->get_geometry()->get_used_shaders()) {
760 object_octrees_.erase({object, shader});
765 if (volume_object_updated) {
771 update_visualization_ =
true;
780 for (
auto it = object_octrees_.begin(); it != object_octrees_.end();) {
781 if (it->first.second == shader) {
782 it = object_octrees_.erase(it);
793 bool volume_geometry_updated =
false;
794 for (
Geometry *geometry : geometry) {
795 if (geometry->has_volume) {
796 volume_geometry_updated =
true;
800 if (!volume_geometry_updated) {
806 for (
auto it = object_octrees_.begin(); it != object_octrees_.end();) {
807 const Object *
object = it->first.first;
808 if (geometry.contains(object->get_geometry())) {
809 it = object_octrees_.erase(it);
818 for (
auto it = vdb_map_.begin(); it != vdb_map_.end();) {
819 if (geometry.contains(
const_cast<Geometry *
>(it->first.first))) {
820 it = vdb_map_.erase(it);
831 update_root_indices_ =
true;
836 need_rebuild_ =
true;
837 algorithm_modified_ =
true;
861static bool mesh_is_closed(
const std::vector<openvdb::Vec3I> &triangles)
863 const size_t num_triangles = triangles.size();
864 if (num_triangles % 2) {
869 std::multiset<std::pair<int, int>> edges;
872 for (
const auto &tri : triangles) {
873 for (
int i = 0; i < 3; i++) {
874 const std::pair<int, int>
e = {tri[i], tri[(i + 1) % 3]};
875 if (edges.contains(e)) {
881 const auto count = edges.count({
e.second,
e.first});
888 edges.insert({
e.second,
e.first});
900 return num_triangles * 3 == num_edges * 2;
903openvdb::BoolGrid::ConstPtr VolumeManager::mesh_to_sdf_grid(
const Mesh *mesh,
905 const float half_width)
908 std::vector<openvdb::Vec3f> points(num_verts);
915 std::vector<openvdb::Vec3I> triangles;
916 triangles.reserve(max_num_triangles);
917 for (
int i = 0; i < max_num_triangles; i++) {
919 const int shader_index = mesh->get_shader()[i];
920 if (
static_cast<const Shader *
>(mesh->get_used_shaders()[shader_index]) == shader) {
921 triangles.emplace_back(mesh->get_triangles()[i * 3],
922 mesh->get_triangles()[i * 3 + 1],
923 mesh->get_triangles()[i * 3 + 2]);
927 if (!mesh_is_closed(triangles)) {
930 return openvdb::BoolGrid::create();
935 const auto vdb_voxel_size = openvdb::Vec3d(mesh_size.
x, mesh_size.
y, mesh_size.
z) /
938 auto xform = openvdb::math::Transform::createLinearTransform(1.0);
939 xform->postScale(vdb_voxel_size);
941 auto sdf_grid = openvdb::tools::meshToLevelSet<openvdb::FloatGrid>(
942 *xform, points, triangles, half_width);
944 return openvdb::tools::sdfInteriorMask(*sdf_grid, 0.5 * vdb_voxel_size.length());
947openvdb::BoolGrid::ConstPtr VolumeManager::get_vdb(
const Geometry *geom,
948 const Shader *shader)
const
951 if (
auto it = vdb_map_.find({geom, shader}); it != vdb_map_.end()) {
956 return openvdb::BoolGrid::create();
960void VolumeManager::initialize_octree(
const Scene *scene,
Progress &progress)
963 std::map<std::pair<const Geometry *, const Shader *>, std::shared_ptr<Octree>> geometry_octrees;
964 for (
const auto &it : object_octrees_) {
965 const Shader *shader = it.first.second;
967 if (
const Object *
object = it.first.first) {
968 geometry_octrees[{
object->get_geometry(), shader}] = it.second;
974 for (
const Object *
object : scene->
objects) {
975 const Geometry *geom =
object->get_geometry();
981 for (
const Node *
node : geom->get_used_shaders()) {
987 if (!object_octrees_.contains({object, shader})) {
989 const Light *light =
static_cast<const Light *
>(geom);
993 object_octrees_[{object, shader}] = std::make_shared<Octree>(
BoundBox(-size, size));
997 const Mesh *mesh =
static_cast<const Mesh *
>(geom);
1003 if (
auto it = geometry_octrees.find({geom, shader}); it != geometry_octrees.end()) {
1005 object_octrees_[{object, shader}] = it->second;
1008 auto octree = std::make_shared<Octree>(mesh->
bounds);
1009 geometry_octrees[{geom, shader}] = octree;
1010 object_octrees_[{object, shader}] = octree;
1016 object_octrees_[{object, shader}] = std::make_shared<Octree>(mesh->
bounds);
1023 !vdb_map_.contains({geom, shader}))
1025 const Mesh *mesh =
static_cast<const Mesh *
>(geom);
1027 if (dim.
x > 0.0f && dim.
y > 0.0f && dim.
z > 0.0f) {
1028 const char *name =
object->get_asset_name().c_str();
1030 vdb_map_[{geom, shader}] = mesh_to_sdf_grid(mesh, shader, 1.0f);
1040void VolumeManager::update_num_octree_nodes()
1042 num_octree_nodes_ = 0;
1043 num_octree_roots_ = 0;
1045 std::set<const Octree *> unique_octrees;
1046 for (
const auto &it : object_octrees_) {
1047 const Octree *octree = it.second.get();
1048 if (unique_octrees.contains(octree)) {
1052 unique_octrees.insert(octree);
1054 num_octree_roots_++;
1059int VolumeManager::num_octree_nodes()
const
1061 return num_octree_nodes_;
1064int VolumeManager::num_octree_roots()
const
1066 return num_octree_roots_;
1069void VolumeManager::build_octree(
Device *device,
Progress &progress)
1071 const double start_time =
time_dt();
1073 for (
auto &it : object_octrees_) {
1074 if (it.second->is_built()) {
1078 const Object *
object = it.first.first;
1079 const Shader *shader = it.first.second;
1081 openvdb::BoolGrid::ConstPtr interior_mask = get_vdb(object->get_geometry(), shader);
1082 it.second->build(device, progress, interior_mask,
object, shader);
1084 it.second->build(device, progress,
object, shader);
1088 update_num_octree_nodes();
1092 LOG_DEBUG << object_octrees_.size() <<
" volume octree(s) with a total of " << num_octree_nodes()
1093 <<
" nodes are built in " <<
build_time <<
" seconds.";
1096void VolumeManager::update_root_indices(
DeviceScene *dscene,
const Scene *scene)
const
1098 if (object_octrees_.empty()) {
1103 std::map<const Octree *, int> octree_root_indices;
1108 for (
const auto &it : object_octrees_) {
1109 const Object *
object = it.first.first;
1110 const int object_id =
object->get_device_index();
1111 const Octree *octree = it.second.get();
1112 auto entry = octree_root_indices.find(octree);
1113 if (entry == octree_root_indices.end()) {
1114 roots[object_id] = root_index;
1115 octree_root_indices[octree] = root_index;
1121 roots[object_id] = entry->second;
1128void VolumeManager::flatten_octree(
DeviceScene *dscene,
const Scene *scene)
const
1130 if (object_octrees_.empty()) {
1134 update_root_indices(dscene, scene);
1136 for (
const auto &it : object_octrees_) {
1138 it.second->set_flattened(
false);
1146 for (
const auto &it : object_octrees_) {
1147 std::shared_ptr<Octree> octree = it.second;
1148 if (octree->is_flattened()) {
1154 kroots[root_index].
shader = it.first.second->id;
1155 kroots[root_index].
id = node_index;
1158 auto root = octree->get_root();
1166 const uint current_index = node_index++;
1167 knodes[current_index].
parent = -1;
1168 octree->flatten(knodes, current_index, root, node_index);
1169 octree->set_flattened();
1175 LOG_DEBUG <<
"Memory usage of volume octrees: "
1184std::string VolumeManager::visualize_octree(
const char *filename)
const
1186 const std::string filename_full =
path_join(OIIO::Filesystem::current_path(), filename);
1188 std::ofstream file(filename_full);
1189 if (file.is_open()) {
1190 std::ostringstream buffer;
1191 file <<
"# Visualize volume octree.\n\n"
1192 "import bpy\nimport mathutils\n\n"
1193 "if bpy.context.active_object:\n"
1194 " bpy.context.active_object.select_set(False)\n\n"
1195 "octree = bpy.data.collections.new(name='Octree')\n"
1196 "bpy.context.scene.collection.children.link(octree)\n\n";
1198 for (
const auto &it : object_octrees_) {
1200 const auto octree = it.second;
1201 const std::string object_name = it.first.first->get_asset_name().string();
1202 octree->visualize(file, object_name);
1205 const Object *
object = it.first.first;
1206 const Geometry *geom =
object->get_geometry();
1209 file <<
"obj.matrix_world = mathutils.Matrix((" << t.
x <<
", " << t.
y <<
", " << t.
z
1210 <<
", (" << 0 <<
"," << 0 <<
"," << 0 <<
"," << 1 <<
")))\n\n";
1217 return filename_full;
1225 !scene->
integrator->volume_step_rate_is_modified() && !algorithm_modified_)
1236 for (
const Object *
object : scene->
objects) {
1237 const Geometry *geom =
object->get_geometry();
1242 volume_step_size[
object->index] = scene->
integrator->get_volume_step_rate() *
1243 object->compute_volume_step_size(progress);
1256 if (scene->
integrator->get_volume_ray_marching()) {
1258 if (algorithm_modified_) {
1263 update_step_size(scene, dscene, progress);
1264 algorithm_modified_ =
false;
1268 if (need_rebuild_) {
1272 initialize_octree(scene, progress);
1273 build_octree(device, progress);
1274 flatten_octree(dscene, scene);
1276 update_visualization_ =
true;
1277 need_rebuild_ =
false;
1278 update_root_indices_ =
false;
1280 else if (update_root_indices_) {
1281 update_root_indices(dscene, scene);
1282 update_root_indices_ =
false;
1285 if (update_visualization_) {
1286 static const bool dump_octree = getenv(
"CYCLES_VOLUME_OCTREE_DUMP") !=
nullptr;
1288 const std::string octree_path = visualize_octree(
"octree.py");
1289 LOG_INFO <<
"Octree visualization has been written to " << octree_path;
1291 update_visualization_ =
false;
1294 if (algorithm_modified_) {
1296 algorithm_modified_ =
false;
1311 for (
auto &it : vdb_map_) {
SIMD_FORCE_INLINE btVector3 transform(const btVector3 &point) const
SIMD_FORCE_INLINE const btScalar & z() const
Return the z value.
list< Attribute > attributes
Attribute * find(ustring name) const
Attribute * add(ustring name, const TypeDesc type, AttributeElement element)
ImageHandle & data_voxel_for_write()
const ImageHandle & data_voxel() const
__forceinline BoundBox()=default
__forceinline float3 size() const
device_vector< int > volume_tree_root_ids
device_vector< KernelOctreeRoot > volume_tree_roots
device_vector< KernelOctreeNode > volume_tree_nodes
device_vector< float > volume_step_size
virtual void const_copy_to(const char *name, void *host, const size_t size)=0
void create_volume_mesh(const Scene *scene, Volume *volume, Progress &progress)
const packed_float3 * get_position() const
Geometry(const NodeType *node_type, const Type type)
packed_float3 * get_position_for_write()
device_image * vdb_image_memory() const
VDBImageLoader * vdb_loader() const
bool is_background_light() const
NODE_DECLARE size_t num_verts() const
Mesh(const NodeType *node_type_, Type geom_type_)
void clear(bool preserve_shaders=false) override
size_t num_triangles() const
void resize_mesh(const int numverts, const int numtris)
vector< ParamValue > attributes
int get_num_nodes() const
void set_substatus(const string &substatus_)
void set_status(const string &status_, const string &substatus_="")
MotionType need_motion() const
unique_ptr_vector< Object > objects
unique_ptr< ImageManager > image_manager
bool has_volume_attribute_dependency
bool has_volume_spatial_varying
void tag_update_algorithm()
void device_update(Device *, DeviceScene *, const Scene *, Progress &)
void device_free(DeviceScene *)
bool need_update_step_size
static bool is_homogeneous_volume(const Object *, const Shader *)
void tag_update_indices()
void merge_grids(const Scene *scene)
void clear(bool preserve_shaders=false) override
T * alloc(const size_t width, const size_t height=0)
#define VOLUME_OCTREE_MAX_DEPTH
#define CCL_NAMESPACE_END
uint hash_uint3(uint kx, uint ky, uint kz)
#define assert(assertion)
#define image(slot, qualifiers, format)
VecBase< float, 3 > float3
float3x3 scale(float3x3 mat, float2 scale)
@ ATTR_STD_VOLUME_VELOCITY_Y
@ ATTR_STD_VOLUME_VELOCITY_Z
@ ATTR_STD_VOLUME_VELOCITY
@ ATTR_STD_VOLUME_VELOCITY_X
std::array< VecBase< T, 3 >, 8 > corners(const Bounds< VecBase< T, 3 > > &bounds)
void add(Depsgraph &depsgraph, std::function< void()> fn)
int size(const AssetLibraryReference *library_reference)
void parallel_for(const IndexRange range, const int64_t grain_size, const Function &function, const TaskSizeHints &size_hints=detail::TaskSizeHints_Static(1))
Value parallel_reduce(IndexRange range, int64_t grain_size, const Value &identity, const Function &function, const Reduction &reduction)
ATTR_WARN_UNUSED_RESULT const BMVert * v
ATTR_WARN_UNUSED_RESULT const BMVert const BMEdge * e
void vert(const int vert_id, float4 &position)
#define SOCKET_FLOAT(name, ui_name, default_value,...)
#define NODE_DEFINE(structname)
#define SOCKET_BOOLEAN(name, ui_name, default_value,...)
string path_join(const string &dir, const string &file)
@ VOLUME_INTERPOLATION_LINEAR
@ VOLUME_INTERPOLATION_CUBIC
unordered_map< int3, int, VertHash > VertHashMap
CCL_NAMESPACE_BEGIN string string_printf(const char *format,...)
packed_float3 translation
static NodeType * add(const char *name, CreateFunc create, Type type=NONE, const NodeType *base=nullptr)
size_t operator()(const int3 &i) const
CCL_NAMESPACE_BEGIN double time_dt()
@ IMAGE_DATA_TYPE_NANOVDB_EMPTY
ccl_device_inline bool is_nanovdb_type(int type)