Blender V5.3
bvh2.cpp
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2009-2010 NVIDIA Corporation
2 * SPDX-FileCopyrightText: 2011-2022 Blender Foundation
3 *
4 * SPDX-License-Identifier: Apache-2.0
5 *
6 * Adapted code from NVIDIA Corporation. */
7
8#include <algorithm>
9
10#include "bvh/bvh2.h"
11
12#include "scene/hair.h"
13#include "scene/mesh.h"
14#include "scene/object.h"
15#include "scene/pointcloud.h"
16
17#include "bvh/build.h"
18#include "bvh/node.h"
19#include "bvh/unaligned.h"
20
21#include "util/progress.h"
22
24
25BVHStackEntry::BVHStackEntry(const BVHNode *n, const int i) : node(n), idx(i) {}
26
28{
29 return (node->is_leaf()) ? ~idx : idx;
30}
31
32BVH2::BVH2(const BVHParams &params_,
33 const vector<Geometry *> &geometry_,
34 const vector<Object *> &objects_)
35 : BVH(params_, geometry_, objects_)
36{
37}
38
39void BVH2::build(Progress &progress, Stats * /*unused*/)
40{
41 progress.set_substatus("Building BVH");
42
43 /* build nodes */
44 BVHBuild bvh_build(objects,
49 params,
50 progress);
51 unique_ptr<BVHNode> bvh2_root = bvh_build.run();
52
53 if (progress.get_cancel()) {
54 return;
55 }
56
57 /* BVH builder returns tree in a binary mode (with two children per inner
58 * node. Need to adopt that for a wider BVH implementations. */
59 const unique_ptr<BVHNode> root = widen_children_nodes(std::move(bvh2_root));
60
61 if (progress.get_cancel()) {
62 return;
63 }
64
65 /* pack triangles */
66 progress.set_substatus("Packing BVH triangles and strands");
68
69 if (progress.get_cancel()) {
70 return;
71 }
72
73 /* pack nodes */
74 progress.set_substatus("Packing BVH nodes");
75 pack_nodes(root.get());
76}
77
78void BVH2::refit(Progress &progress)
79{
80 progress.set_substatus("Packing BVH primitives");
82
83 if (progress.get_cancel()) {
84 return;
85 }
86
87 progress.set_substatus("Refitting BVH nodes");
89}
90
92{
93 return std::move(root);
94}
95
96void BVH2::pack_leaf(const BVHStackEntry &e, const LeafNode *leaf)
97{
100 std::fill_n(data, BVH_NODE_LEAF_SIZE, zero_int4());
101 if (leaf->num_triangles() == 1 && pack.prim_index[leaf->lo] == -1) {
102 /* object */
103 data[0].x = ~(leaf->lo);
104 data[0].y = 0;
105 }
106 else {
107 /* triangle */
108 data[0].x = leaf->lo;
109 data[0].y = leaf->hi;
110 }
111 data[0].z = leaf->visibility;
112 if (leaf->num_triangles() != 0) {
113 data[0].w = pack.prim_type[leaf->lo];
114 }
115
116 std::copy_n(data, BVH_NODE_LEAF_SIZE, &pack.leaf_nodes[e.idx]);
117}
118
119void BVH2::pack_inner(const BVHStackEntry &e, const BVHStackEntry &e0, const BVHStackEntry &e1)
120{
121 if (e0.node->is_unaligned || e1.node->is_unaligned) {
122 pack_unaligned_inner(e, e0, e1);
123 }
124 else {
125 pack_aligned_inner(e, e0, e1);
126 }
127}
128
130 const BVHStackEntry &e0,
131 const BVHStackEntry &e1)
132{
133 pack_aligned_node(e.idx,
134 e0.node->bounds,
135 e1.node->bounds,
136 e0.encodeIdx(),
137 e1.encodeIdx(),
138 e0.node->visibility,
139 e1.node->visibility);
140}
141
142void BVH2::pack_aligned_node(const int idx,
143 const BoundBox &b0,
144 const BoundBox &b1,
145 int c0,
146 int c1,
147 uint visibility0,
148 uint visibility1)
149{
150 assert(idx + BVH_NODE_SIZE <= pack.nodes.size());
151 assert(c0 < 0 || c0 < pack.nodes.size());
152 assert(c1 < 0 || c1 < pack.nodes.size());
153
154 int4 data[BVH_NODE_SIZE] = {
157 c0,
158 c1),
160 __float_as_int(b1.min.x),
161 __float_as_int(b0.max.x),
162 __float_as_int(b1.max.x)),
164 __float_as_int(b1.min.y),
165 __float_as_int(b0.max.y),
166 __float_as_int(b1.max.y)),
168 __float_as_int(b1.min.z),
169 __float_as_int(b0.max.z),
170 __float_as_int(b1.max.z)),
171 };
172
173 std::copy_n(data, BVH_NODE_SIZE, &pack.nodes[idx]);
174}
175
177 const BVHStackEntry &e0,
178 const BVHStackEntry &e1)
179{
183 e0.node->bounds,
184 e1.node->bounds,
185 e0.encodeIdx(),
186 e1.encodeIdx(),
187 e0.node->visibility,
188 e1.node->visibility);
189}
190
191void BVH2::pack_unaligned_node(const int idx,
192 const Transform &aligned_space0,
193 const Transform &aligned_space1,
194 const BoundBox &b0,
195 const BoundBox &b1,
196 int c0,
197 int c1,
198 uint visibility0,
199 uint visibility1)
200{
202 assert(c0 < 0 || c0 < pack.nodes.size());
203 assert(c1 < 0 || c1 < pack.nodes.size());
204
206 const Transform space0 = BVHUnaligned::compute_node_transform(b0, aligned_space0);
207 const Transform space1 = BVHUnaligned::compute_node_transform(b1, aligned_space1);
208 data[0] = make_int4(visibility0 | PATH_RAY_VISIBILITY_NODE_UNALIGNED,
210 c0,
211 c1);
212
213 data[1] = __float4_as_int4(space0.x);
214 data[2] = __float4_as_int4(space0.y);
215 data[3] = __float4_as_int4(space0.z);
216 data[4] = __float4_as_int4(space1.x);
217 data[5] = __float4_as_int4(space1.y);
218 data[6] = __float4_as_int4(space1.z);
219
220 std::copy_n(data, BVH_UNALIGNED_NODE_SIZE, &pack.nodes[idx]);
221}
222
223void BVH2::pack_nodes(const BVHNode *root)
224{
225 const size_t num_nodes = root->getSubtreeSize(BVH_STAT_NODE_COUNT);
226 const size_t num_leaf_nodes = root->getSubtreeSize(BVH_STAT_LEAF_COUNT);
227 assert(num_leaf_nodes <= num_nodes);
228 const size_t num_inner_nodes = num_nodes - num_leaf_nodes;
229 size_t node_size;
231 const size_t num_unaligned_nodes = root->getSubtreeSize(BVH_STAT_UNALIGNED_INNER_COUNT);
232 node_size = (num_unaligned_nodes * BVH_UNALIGNED_NODE_SIZE) +
233 (num_inner_nodes - num_unaligned_nodes) * BVH_NODE_SIZE;
234 }
235 else {
236 node_size = num_inner_nodes * BVH_NODE_SIZE;
237 }
238 /* Resize arrays */
239 pack.nodes.clear();
241 /* For top level BVH, first merge existing BVH's so we know the offsets. */
242 if (params.top_level) {
243 pack_instances(node_size, num_leaf_nodes * BVH_NODE_LEAF_SIZE);
244 }
245 else {
246 pack.nodes.resize(node_size);
247 pack.leaf_nodes.resize(num_leaf_nodes * BVH_NODE_LEAF_SIZE);
248 }
249
250 int nextNodeIdx = 0;
251 int nextLeafNodeIdx = 0;
252
254 stack.reserve(BVHParams::MAX_DEPTH * 2);
255 if (root->is_leaf()) {
256 stack.push_back(BVHStackEntry(root, nextLeafNodeIdx++));
257 }
258 else {
259 stack.push_back(BVHStackEntry(root, nextNodeIdx));
260 nextNodeIdx += root->has_unaligned() ? BVH_UNALIGNED_NODE_SIZE : BVH_NODE_SIZE;
261 }
262
263 while (!stack.empty()) {
264 const BVHStackEntry e = stack.back();
265 stack.pop_back();
266
267 if (e.node->is_leaf()) {
268 /* leaf node */
269 const LeafNode *leaf = reinterpret_cast<const LeafNode *>(e.node);
270 pack_leaf(e, leaf);
271 }
272 else {
273 /* inner node */
274 int idx[2];
275 for (int i = 0; i < 2; ++i) {
276 if (e.node->get_child(i)->is_leaf()) {
277 idx[i] = nextLeafNodeIdx++;
278 }
279 else {
280 idx[i] = nextNodeIdx;
281 nextNodeIdx += e.node->get_child(i)->has_unaligned() ? BVH_UNALIGNED_NODE_SIZE :
283 }
284 }
285
286 stack.push_back(BVHStackEntry(e.node->get_child(0), idx[0]));
287 stack.push_back(BVHStackEntry(e.node->get_child(1), idx[1]));
288
289 pack_inner(e, stack[stack.size() - 2], stack[stack.size() - 1]);
290 }
291 }
292 assert(node_size == nextNodeIdx);
293 /* root index to start traversal at, to handle case of single leaf node */
294 pack.root_index = (root->is_leaf()) ? -1 : 0;
295}
296
298{
300
302 uint visibility = 0;
303 refit_node(0, (pack.root_index == -1) ? true : false, bbox, visibility);
304}
305
306void BVH2::refit_node(const int idx, bool leaf, BoundBox &bbox, uint &visibility)
307{
308 if (leaf) {
309 /* refit leaf node */
311 const int4 *data = &pack.leaf_nodes[idx];
312 const int c0 = data[0].x;
313 const int c1 = data[0].y;
314
315 refit_primitives(c0, c1, bbox, visibility);
316
317 /* TODO(sergey): De-duplicate with pack_leaf(). */
318 int4 leaf_data[BVH_NODE_LEAF_SIZE];
319 leaf_data[0].x = c0;
320 leaf_data[0].y = c1;
321 leaf_data[0].z = visibility;
322 leaf_data[0].w = data[0].w;
323 std::copy_n(leaf_data, BVH_NODE_LEAF_SIZE, &pack.leaf_nodes[idx]);
324 }
325 else {
326 assert(idx + BVH_NODE_SIZE <= pack.nodes.size());
327
328 const int4 *data = &pack.nodes[idx];
329 const bool is_unaligned = (data[0].x & PATH_RAY_VISIBILITY_NODE_UNALIGNED) != 0;
330 const int c0 = data[0].z;
331 const int c1 = data[0].w;
332 /* refit inner node, set bbox from children */
335 uint visibility0 = 0;
336 uint visibility1 = 0;
337
338 refit_node((c0 < 0) ? -c0 - 1 : c0, (c0 < 0), bbox0, visibility0);
339 refit_node((c1 < 0) ? -c1 - 1 : c1, (c1 < 0), bbox1, visibility1);
340
341 if (is_unaligned) {
342 const Transform aligned_space = transform_identity();
344 idx, aligned_space, aligned_space, bbox0, bbox1, c0, c1, visibility0, visibility1);
345 }
346 else {
347 pack_aligned_node(idx, bbox0, bbox1, c0, c1, visibility0, visibility1);
348 }
349
350 bbox.grow(bbox0);
351 bbox.grow(bbox1);
352 visibility = visibility0 | visibility1;
353 }
354}
355
356/* Refitting */
357
358void BVH2::refit_primitives(const int start, const int end, BoundBox &bbox, uint &visibility)
359{
360 /* Refit range of primitives. */
361 for (int prim = start; prim < end; prim++) {
362 const int pidx = pack.prim_index[prim];
363 const int tob = pack.prim_object[prim];
364 Object *ob = objects[tob];
365
366 if (pidx == -1) {
367 /* Object instance. */
368 bbox.grow(ob->bounds);
369 }
370 else {
371 /* Primitives. */
372 if (pack.prim_type[prim] & PRIMITIVE_CURVE) {
373 /* Curves. */
374 const Hair *hair = static_cast<const Hair *>(ob->get_geometry());
375 const int prim_offset = (params.top_level) ? hair->prim_offset : 0;
376 const Hair::Curve curve = hair->get_curve(pidx - prim_offset);
377 const int k = PRIMITIVE_UNPACK_SEGMENT(pack.prim_type[prim]);
378
379 curve.bounds_grow(k, hair->get_position(), hair->get_radius(), bbox);
380
381 /* Motion curves. */
382 if (hair->get_use_motion_blur()) {
383 const Attribute *attr_P = hair->attributes.find(ATTR_STD_POSITION);
384 const Attribute *attr_R = hair->attributes.find(ATTR_STD_RADIUS);
385
386 if (attr_P->has_motion()) {
387 for (int attr_step = 1; attr_step < attr_P->num_motion_steps(); attr_step++) {
388 curve.bounds_grow(
389 k, attr_P->data<packed_float3>(attr_step), attr_R->data<float>(attr_step), bbox);
390 }
391 }
392 }
393 }
394 else if (pack.prim_type[prim] & PRIMITIVE_ANY_POINT) {
395 /* Points. */
396 const PointCloud *pointcloud = static_cast<const PointCloud *>(ob->get_geometry());
397 const int prim_offset = (params.top_level) ? pointcloud->prim_offset : 0;
398 const packed_float3 *points = pointcloud->get_position();
399 const float *radius = pointcloud->get_radius();
400 const PointCloud::Point point = pointcloud->get_point(pidx - prim_offset);
401
402 point.bounds_grow(points, radius, bbox);
403
404 /* Motion points. */
405 if (pointcloud->get_use_motion_blur()) {
406 const Attribute *attr_P = pointcloud->attributes.find(ATTR_STD_POSITION);
407
408 if (attr_P->has_motion()) {
409 const Attribute *attr_R = pointcloud->attributes.find(ATTR_STD_RADIUS);
410 for (int attr_step = 1; attr_step < attr_P->num_motion_steps(); attr_step++) {
411 const float3 P = attr_P->data<packed_float3>(attr_step)[point.index];
412 const float r = attr_R->data<float>(attr_step)[point.index];
413 bbox.grow(P, r);
414 }
415 }
416 }
417 }
418 else {
420
421 /* Triangles. */
422 const Mesh *mesh = static_cast<const Mesh *>(ob->get_geometry());
423 const int prim_offset = (params.top_level) ? mesh->prim_offset : 0;
424 const Mesh::Triangle triangle = mesh->get_triangle(pidx - prim_offset);
425 const packed_float3 *vpos = mesh->get_position();
426
427 triangle.bounds_grow(vpos, bbox);
428
429 /* Motion triangles. */
430 if (mesh->use_motion_blur) {
431 const Attribute *attr_P = mesh->attributes.find(ATTR_STD_POSITION);
432
433 if (attr_P->has_motion()) {
434 for (int attr_step = 1; attr_step < attr_P->num_motion_steps(); attr_step++) {
435 triangle.bounds_grow(attr_P->data<packed_float3>(attr_step), bbox);
436 }
437 }
438 }
439 }
440 }
441 visibility |= ob->visibility_for_tracing();
442 }
443}
444
445/* Triangles */
446
448{
449 const size_t tidx_size = pack.prim_index.size();
450 /* Reserve size for arrays. */
452 pack.prim_visibility.resize(tidx_size);
453 /* Fill in all the arrays. */
454 for (unsigned int i = 0; i < tidx_size; i++) {
455 if (pack.prim_index[i] != -1) {
456 const int tob = pack.prim_object[i];
457 Object *ob = objects[tob];
459 }
460 else {
461 pack.prim_visibility[i] = 0;
462 }
463 }
464}
465
466/* Pack Instances */
467
468void BVH2::pack_instances(size_t nodes_size, size_t leaf_nodes_size)
469{
470 /* Adjust primitive index to point to the triangle in the global array, for
471 * geometry with transform applied and already in the top level BVH.
472 */
473 for (size_t i = 0; i < pack.prim_index.size(); i++) {
474 if (pack.prim_index[i] != -1) {
475 pack.prim_index[i] += objects[pack.prim_object[i]]->get_geometry()->prim_offset;
476 }
477 }
478
479 /* track offsets of instanced BVH data in global array */
480 size_t prim_offset = pack.prim_index.size();
481 size_t nodes_offset = nodes_size;
482 size_t nodes_leaf_offset = leaf_nodes_size;
483
484 /* clear array that gives the node indexes for instanced objects */
486
487 /* reserve */
488 size_t prim_index_size = pack.prim_index.size();
489
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;
494
495 for (Geometry *geom : geometry) {
496 BVH2 *bvh = static_cast<BVH2 *>(geom->bvh.get());
497
498 if (geom->need_build_bvh(params.bvh_layout)) {
499 prim_index_size += bvh->pack.prim_index.size();
500 nodes_size += bvh->pack.nodes.size();
501 leaf_nodes_size += bvh->pack.leaf_nodes.size();
502 }
503 }
504
505 pack.prim_index.resize(prim_index_size);
506 pack.prim_type.resize(prim_index_size);
507 pack.prim_object.resize(prim_index_size);
508 pack.prim_visibility.resize(prim_index_size);
509 pack.nodes.resize(nodes_size);
510 pack.leaf_nodes.resize(leaf_nodes_size);
512
515 {
516 pack.prim_time.resize(prim_index_size);
517 }
518
519 int *pack_prim_index = (pack.prim_index.size()) ? pack.prim_index.data() : nullptr;
520 int *pack_prim_type = (pack.prim_type.size()) ? pack.prim_type.data() : nullptr;
521 int *pack_prim_object = (pack.prim_object.size()) ? pack.prim_object.data() : nullptr;
522 uint *pack_prim_visibility = (pack.prim_visibility.size()) ? pack.prim_visibility.data() :
523 nullptr;
524 int4 *pack_nodes = (pack.nodes.size()) ? pack.nodes.data() : nullptr;
525 int4 *pack_leaf_nodes = (pack.leaf_nodes.size()) ? pack.leaf_nodes.data() : nullptr;
526 float2 *pack_prim_time = (pack.prim_time.size()) ? pack.prim_time.data() : nullptr;
527
528 unordered_map<Geometry *, int> geometry_map;
529
530 /* merge */
531 for (Object *ob : objects) {
532 Geometry *geom = ob->get_geometry();
533
534 /* We assume that if mesh doesn't need own BVH it was already included
535 * into a top-level BVH and no packing here is needed.
536 */
537 if (!geom->need_build_bvh(params.bvh_layout)) {
538 pack.object_node[object_offset++] = 0;
539 continue;
540 }
541
542 /* if mesh already added once, don't add it again, but used set
543 * node offset for this object */
544 const unordered_map<Geometry *, int>::iterator it = geometry_map.find(geom);
545
546 if (geometry_map.contains(geom)) {
547 const int noffset = it->second;
548 pack.object_node[object_offset++] = noffset;
549 continue;
550 }
551
552 BVH2 *bvh = static_cast<BVH2 *>(geom->bvh.get());
553
554 const int noffset = nodes_offset;
555 const int noffset_leaf = nodes_leaf_offset;
556 const int geom_prim_offset = geom->prim_offset;
557
558 /* fill in node indexes for instances */
559 if (bvh->pack.root_index == -1) {
560 pack.object_node[object_offset++] = -noffset_leaf - 1;
561 }
562 else {
563 pack.object_node[object_offset++] = noffset;
564 }
565
566 geometry_map[geom] = pack.object_node[object_offset - 1];
567
568 /* merge primitive, object and triangle indexes */
569 if (bvh->pack.prim_index.size()) {
570 const size_t bvh_prim_index_size = bvh->pack.prim_index.size();
571 int *bvh_prim_index = bvh->pack.prim_index.data();
572 int *bvh_prim_type = bvh->pack.prim_type.data();
573 uint *bvh_prim_visibility = bvh->pack.prim_visibility.data();
574 float2 *bvh_prim_time = bvh->pack.prim_time.size() ? bvh->pack.prim_time.data() : nullptr;
575
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; // unused for instances
581 if (bvh_prim_time != nullptr) {
582 pack_prim_time[pack_prim_index_offset] = bvh_prim_time[i];
583 }
584 pack_prim_index_offset++;
585 }
586 }
587
588 /* merge nodes */
589 if (bvh->pack.leaf_nodes.size()) {
590 int4 *leaf_nodes_offset = bvh->pack.leaf_nodes.data();
591 const size_t leaf_nodes_offset_size = bvh->pack.leaf_nodes.size();
592 for (size_t i = 0; i < leaf_nodes_offset_size; i += BVH_NODE_LEAF_SIZE) {
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;
597 for (int j = 1; j < BVH_NODE_LEAF_SIZE; ++j) {
598 pack_leaf_nodes[pack_leaf_nodes_offset + j] = leaf_nodes_offset[i + j];
599 }
600 pack_leaf_nodes_offset += BVH_NODE_LEAF_SIZE;
601 }
602 }
603
604 if (bvh->pack.nodes.size()) {
605 int4 *bvh_nodes = bvh->pack.nodes.data();
606 const size_t bvh_nodes_size = bvh->pack.nodes.size();
607
608 for (size_t i = 0; i < bvh_nodes_size;) {
609 size_t nsize;
610 size_t nsize_bbox;
611 if (bvh_nodes[i].x & PATH_RAY_VISIBILITY_NODE_UNALIGNED) {
613 nsize_bbox = 0;
614 }
615 else {
616 nsize = BVH_NODE_SIZE;
617 nsize_bbox = 0;
618 }
619
620 std::copy_n(bvh_nodes + i, nsize_bbox, pack_nodes + pack_nodes_offset);
621
622 /* Modify offsets into arrays */
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;
627
628 /* Usually this copies nothing, but we better
629 * be prepared for possible node size extension.
630 */
631 std::copy_n(&bvh_nodes[i + nsize_bbox + 1],
632 (nsize - (nsize_bbox + 1)),
633 &pack_nodes[pack_nodes_offset + nsize_bbox + 1]);
634
635 pack_nodes_offset += nsize;
636 i += nsize;
637 }
638 }
639
640 nodes_offset += bvh->pack.nodes.size();
641 nodes_leaf_offset += bvh->pack.leaf_nodes.size();
642 prim_offset += bvh->pack.prim_index.size();
643 }
644}
645
#define BVH_NODE_SIZE
Definition bvh2.h:20
#define BVH_NODE_LEAF_SIZE
Definition bvh2.h:21
#define BVH_UNALIGNED_NODE_SIZE
Definition bvh2.h:22
@ BVH_STAT_NODE_COUNT
Definition bvh/node.h:17
@ BVH_STAT_UNALIGNED_INNER_COUNT
Definition bvh/node.h:25
@ BVH_STAT_LEAF_COUNT
Definition bvh/node.h:19
Attribute * find(ustring name) const
const T * data(const int step=0) const
bool has_motion() const
int num_motion_steps() const
void pack_aligned_inner(const BVHStackEntry &e, const BVHStackEntry &e0, const BVHStackEntry &e1)
Definition bvh2.cpp:129
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)
Definition bvh2.cpp:191
void refit_node(const int idx, bool leaf, BoundBox &bbox, uint &visibility)
Definition bvh2.cpp:306
virtual unique_ptr< BVHNode > widen_children_nodes(unique_ptr< BVHNode > &&root)
Definition bvh2.cpp:91
void pack_leaf(const BVHStackEntry &e, const LeafNode *leaf)
Definition bvh2.cpp:96
PackedBVH pack
Definition bvh2.h:47
void pack_inner(const BVHStackEntry &e, const BVHStackEntry &e0, const BVHStackEntry &e1)
Definition bvh2.cpp:119
void refit_primitives(const int start, const int end, BoundBox &bbox, uint &visibility)
Definition bvh2.cpp:358
void pack_instances(const size_t nodes_size, const size_t leaf_nodes_size)
Definition bvh2.cpp:468
void pack_aligned_node(const int idx, const BoundBox &b0, const BoundBox &b1, int c0, int c1, uint visibility0, uint visibility1)
Definition bvh2.cpp:142
void pack_unaligned_inner(const BVHStackEntry &e, const BVHStackEntry &e0, const BVHStackEntry &e1)
Definition bvh2.cpp:176
void pack_primitives()
Definition bvh2.cpp:447
void pack_nodes(const BVHNode *root)
Definition bvh2.cpp:223
void refit(Progress &progress)
Definition bvh2.cpp:78
BVH2(const BVHParams &params, const vector< Geometry * > &geometry, const vector< Object * > &objects)
Definition bvh2.cpp:32
void refit_nodes()
Definition bvh2.cpp:297
void build(Progress &progress, Stats *stats)
Definition bvh2.cpp:39
unique_ptr< BVHNode > run()
Definition build.cpp:443
int getSubtreeSize(BVH_STAT stat=BVH_STAT_NODE_COUNT) const
Definition bvh/node.cpp:17
uint visibility
Definition bvh/node.h:90
bool is_unaligned
Definition bvh/node.h:92
virtual bool is_leaf() const =0
bool has_unaligned() const
Definition bvh/node.h:65
Transform get_aligned_space() const
Definition bvh/node.h:57
BoundBox bounds
Definition bvh/node.h:89
int num_motion_triangle_steps
Definition params.h:100
BVHLayout bvh_layout
Definition params.h:83
bool use_unaligned_nodes
Definition params.h:88
@ MAX_DEPTH
Definition params.h:111
int num_motion_point_steps
Definition params.h:102
bool top_level
Definition params.h:80
int num_motion_curve_steps
Definition params.h:101
static Transform compute_node_transform(const BoundBox &bounds, const Transform &aligned_space)
vector< Geometry * > geometry
Definition bvh/bvh.h:70
BVH(const BVHParams &params, const vector< Geometry * > &geometry, const vector< Object * > &objects)
Definition bvh.cpp:90
BVHParams params
Definition bvh/bvh.h:69
vector< Object * > objects
Definition bvh/bvh.h:71
float3 max
Definition boundbox.h:20
__forceinline void grow(const float3 &pt)
Definition boundbox.h:35
float3 min
Definition boundbox.h:20
bool need_build_bvh(BVHLayout layout) const
const packed_float3 * get_position() const
size_t prim_offset
unique_ptr< BVH > bvh
const float * get_radius() const
AttributeSet attributes
Definition hair.h:13
Curve get_curve(const size_t i) const
Definition hair.h:94
int num_triangles() const override
Definition bvh/node.h:192
Triangle get_triangle(const size_t i) const
Definition scene/mesh.h:67
NODE_DECLARE BoundBox bounds
uint visibility_for_tracing() const
Point get_point(const int i) const
void set_substatus(const string &substatus_)
Definition progress.h:259
bool get_cancel() const
Definition progress.h:77
size_t size() const
T * resize(const size_t newsize)
#define PRIMITIVE_UNPACK_SEGMENT(type)
#define CCL_NAMESPACE_END
#define __float_as_int(x)
ccl_device_forceinline int4 make_int4(const int x, const int y, const int z, const int w)
#define assert(assertion)
@ PRIMITIVE_CURVE
@ PRIMITIVE_ANY_POINT
@ PRIMITIVE_TRIANGLE
@ PATH_RAY_VISIBILITY_NODE_UNALIGNED
@ ATTR_STD_POSITION
@ ATTR_STD_RADIUS
ccl_device_inline int4 __float4_as_int4(const float4 f)
const BVHNode * node
Definition bvh2.h:27
BVHStackEntry(const BVHNode *n=nullptr, const int i=0)
Definition bvh2.cpp:25
int idx
Definition bvh2.h:28
int encodeIdx() const
Definition bvh2.cpp:27
void bounds_grow(const int k, const packed_float3 *curve_keys, const float *curve_radius, BoundBox &bounds) const
Definition hair.cpp:44
void bounds_grow(const packed_float3 *verts, BoundBox &bounds) const
array< int > prim_index
Definition bvh/bvh.h:50
array< int > prim_type
Definition bvh/bvh.h:45
array< int4 > nodes
Definition bvh/bvh.h:39
array< uint > prim_visibility
Definition bvh/bvh.h:47
array< float2 > prim_time
Definition bvh/bvh.h:54
array< int4 > leaf_nodes
Definition bvh/bvh.h:41
array< int > prim_object
Definition bvh/bvh.h:52
int root_index
Definition bvh/bvh.h:57
array< int > object_node
Definition bvh/bvh.h:43
void bounds_grow(const packed_float3 *points, const float *radius, BoundBox &bounds) const
float4 y
Definition transform.h:53
float4 x
Definition transform.h:53
float4 z
Definition transform.h:53
float z
Definition sky_math.h:136
float y
Definition sky_math.h:136
float x
Definition sky_math.h:136
ccl_device_inline Transform transform_identity()
Definition transform.h:355
ccl_device_inline int4 zero_int4()
Definition types_int4.h:79