35 :
BVH(params_, geometry_, objects_)
93 return std::move(root);
103 data[0].x = ~(leaf->
lo);
108 data[0].x = leaf->
lo;
109 data[0].y = leaf->
hi;
227 assert(num_leaf_nodes <= num_nodes);
228 const size_t num_inner_nodes = num_nodes - num_leaf_nodes;
251 int nextLeafNodeIdx = 0;
263 while (!stack.empty()) {
267 if (e.node->is_leaf()) {
275 for (
int i = 0; i < 2; ++i) {
276 if (e.node->get_child(i)->is_leaf()) {
277 idx[i] = nextLeafNodeIdx++;
280 idx[i] = nextNodeIdx;
286 stack.push_back(
BVHStackEntry(e.node->get_child(0), idx[0]));
287 stack.push_back(
BVHStackEntry(e.node->get_child(1), idx[1]));
289 pack_inner(e, stack[stack.size() - 2], stack[stack.size() - 1]);
292 assert(node_size == nextNodeIdx);
312 const int c0 = data[0].x;
313 const int c1 = data[0].y;
321 leaf_data[0].
z = visibility;
322 leaf_data[0].
w = data[0].w;
330 const int c0 = data[0].z;
331 const int c1 = data[0].w;
335 uint visibility0 = 0;
336 uint visibility1 = 0;
338 refit_node((c0 < 0) ? -c0 - 1 : c0, (c0 < 0), bbox0, visibility0);
339 refit_node((c1 < 0) ? -c1 - 1 : c1, (c1 < 0), bbox1, visibility1);
344 idx, aligned_space, aligned_space, bbox0, bbox1, c0, c1, visibility0, visibility1);
352 visibility = visibility0 | visibility1;
361 for (
int prim = start; prim < end; prim++) {
374 const Hair *hair =
static_cast<const Hair *
>(ob->get_geometry());
382 if (hair->get_use_motion_blur()) {
387 for (
int attr_step = 1; attr_step < attr_P->
num_motion_steps(); attr_step++) {
399 const float *radius = pointcloud->
get_radius();
405 if (pointcloud->get_use_motion_blur()) {
410 for (
int attr_step = 1; attr_step < attr_P->
num_motion_steps(); attr_step++) {
412 const float r = attr_R->
data<
float>(attr_step)[point.
index];
422 const Mesh *mesh =
static_cast<const Mesh *
>(ob->get_geometry());
430 if (mesh->use_motion_blur) {
434 for (
int attr_step = 1; attr_step < attr_P->
num_motion_steps(); attr_step++) {
454 for (
unsigned int i = 0; i < tidx_size; i++) {
481 size_t nodes_offset = nodes_size;
482 size_t nodes_leaf_offset = leaf_nodes_size;
490 size_t pack_prim_index_offset = prim_index_size;
491 size_t pack_nodes_offset = nodes_size;
492 size_t pack_leaf_nodes_offset = leaf_nodes_size;
493 size_t object_offset = 0;
496 BVH2 *bvh =
static_cast<BVH2 *
>(geom->bvh.get());
528 unordered_map<Geometry *, int> geometry_map;
532 Geometry *geom = ob->get_geometry();
544 const unordered_map<Geometry *, int>::iterator it = geometry_map.find(geom);
546 if (geometry_map.contains(geom)) {
547 const int noffset = it->second;
554 const int noffset = nodes_offset;
555 const int noffset_leaf = nodes_leaf_offset;
576 for (
size_t i = 0; i < bvh_prim_index_size; i++) {
577 pack_prim_index[pack_prim_index_offset] = bvh_prim_index[i] + geom_prim_offset;
578 pack_prim_type[pack_prim_index_offset] = bvh_prim_type[i];
579 pack_prim_visibility[pack_prim_index_offset] = bvh_prim_visibility[i];
580 pack_prim_object[pack_prim_index_offset] = 0;
581 if (bvh_prim_time !=
nullptr) {
582 pack_prim_time[pack_prim_index_offset] = bvh_prim_time[i];
584 pack_prim_index_offset++;
593 int4 data = leaf_nodes_offset[i];
594 data.x += prim_offset;
595 data.y += prim_offset;
596 pack_leaf_nodes[pack_leaf_nodes_offset] = data;
598 pack_leaf_nodes[pack_leaf_nodes_offset + j] = leaf_nodes_offset[i + j];
608 for (
size_t i = 0; i < bvh_nodes_size;) {
620 std::copy_n(bvh_nodes + i, nsize_bbox,
pack_nodes + pack_nodes_offset);
623 int4 data = bvh_nodes[i + nsize_bbox];
624 data.z += (data.z < 0) ? -noffset_leaf : noffset;
625 data.w += (data.w < 0) ? -noffset_leaf : noffset;
626 pack_nodes[pack_nodes_offset + nsize_bbox] = data;
631 std::copy_n(&bvh_nodes[i + nsize_bbox + 1],
632 (nsize - (nsize_bbox + 1)),
633 &
pack_nodes[pack_nodes_offset + nsize_bbox + 1]);
635 pack_nodes_offset += nsize;
#define BVH_NODE_LEAF_SIZE
#define BVH_UNALIGNED_NODE_SIZE
@ BVH_STAT_UNALIGNED_INNER_COUNT
Attribute * find(ustring name) const
const T * data(const int step=0) const
int num_motion_steps() const
void pack_aligned_inner(const BVHStackEntry &e, const BVHStackEntry &e0, const BVHStackEntry &e1)
void pack_unaligned_node(const int idx, const Transform &aligned_space0, const Transform &aligned_space1, const BoundBox &b0, const BoundBox &b1, int c0, int c1, uint visibility0, uint visibility1)
void refit_node(const int idx, bool leaf, BoundBox &bbox, uint &visibility)
virtual unique_ptr< BVHNode > widen_children_nodes(unique_ptr< BVHNode > &&root)
void pack_leaf(const BVHStackEntry &e, const LeafNode *leaf)
void pack_inner(const BVHStackEntry &e, const BVHStackEntry &e0, const BVHStackEntry &e1)
void refit_primitives(const int start, const int end, BoundBox &bbox, uint &visibility)
void pack_instances(const size_t nodes_size, const size_t leaf_nodes_size)
void pack_aligned_node(const int idx, const BoundBox &b0, const BoundBox &b1, int c0, int c1, uint visibility0, uint visibility1)
void pack_unaligned_inner(const BVHStackEntry &e, const BVHStackEntry &e0, const BVHStackEntry &e1)
void pack_nodes(const BVHNode *root)
void refit(Progress &progress)
BVH2(const BVHParams ¶ms, const vector< Geometry * > &geometry, const vector< Object * > &objects)
void build(Progress &progress, Stats *stats)
unique_ptr< BVHNode > run()
int getSubtreeSize(BVH_STAT stat=BVH_STAT_NODE_COUNT) const
virtual bool is_leaf() const =0
bool has_unaligned() const
Transform get_aligned_space() const
int num_motion_triangle_steps
int num_motion_point_steps
int num_motion_curve_steps
static Transform compute_node_transform(const BoundBox &bounds, const Transform &aligned_space)
vector< Geometry * > geometry
BVH(const BVHParams ¶ms, const vector< Geometry * > &geometry, const vector< Object * > &objects)
vector< Object * > objects
__forceinline void grow(const float3 &pt)
bool need_build_bvh(BVHLayout layout) const
const packed_float3 * get_position() const
const float * get_radius() const
Curve get_curve(const size_t i) const
int num_triangles() const override
Triangle get_triangle(const size_t i) const
NODE_DECLARE BoundBox bounds
uint visibility_for_tracing() const
Point get_point(const int i) const
void set_substatus(const string &substatus_)
T * resize(const size_t newsize)
#define PRIMITIVE_UNPACK_SEGMENT(type)
#define CCL_NAMESPACE_END
#define assert(assertion)
@ PATH_RAY_VISIBILITY_NODE_UNALIGNED
ccl_device_inline int4 __float4_as_int4(const float4 f)
BVHStackEntry(const BVHNode *n=nullptr, const int i=0)
void bounds_grow(const int k, const packed_float3 *curve_keys, const float *curve_radius, BoundBox &bounds) const
void bounds_grow(const packed_float3 *verts, BoundBox &bounds) const
array< uint > prim_visibility
array< float2 > prim_time
void bounds_grow(const packed_float3 *points, const float *radius, BoundBox &bounds) const
ccl_device_inline int4 zero_int4()