ClangFormat: apply to source, most of intern
[blender.git] / intern / cycles / bvh / bvh4.cpp
1 /*
2  * Adapted from code copyright 2009-2010 NVIDIA Corporation
3  * Modifications Copyright 2011, Blender Foundation.
4  *
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at
8  *
9  * http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17
18 #include "bvh/bvh4.h"
19
20 #include "render/mesh.h"
21 #include "render/object.h"
22
23 #include "bvh/bvh_node.h"
24 #include "bvh/bvh_unaligned.h"
25
26 CCL_NAMESPACE_BEGIN
27
28 /* Can we avoid this somehow or make more generic?
29  *
30  * Perhaps we can merge nodes in actual tree and make our
31  * life easier all over the place.
32  */
33
34 BVH4::BVH4(const BVHParams &params_, const vector<Object *> &objects_) : BVH(params_, objects_)
35 {
36   params.bvh_layout = BVH_LAYOUT_BVH4;
37 }
38
39 namespace {
40
41 BVHNode *bvh_node_merge_children_recursively(const BVHNode *node)
42 {
43   if (node->is_leaf()) {
44     return new LeafNode(*reinterpret_cast<const LeafNode *>(node));
45   }
46   /* Collect nodes of one layer deeper, allowing us to have more childrem in
47    * an inner layer. */
48   assert(node->num_children() <= 2);
49   const BVHNode *children[4];
50   const BVHNode *child0 = node->get_child(0);
51   const BVHNode *child1 = node->get_child(1);
52   int num_children = 0;
53   if (child0->is_leaf()) {
54     children[num_children++] = child0;
55   }
56   else {
57     children[num_children++] = child0->get_child(0);
58     children[num_children++] = child0->get_child(1);
59   }
60   if (child1->is_leaf()) {
61     children[num_children++] = child1;
62   }
63   else {
64     children[num_children++] = child1->get_child(0);
65     children[num_children++] = child1->get_child(1);
66   }
67   /* Merge children in subtrees. */
68   BVHNode *children4[4];
69   for (int i = 0; i < num_children; ++i) {
70     children4[i] = bvh_node_merge_children_recursively(children[i]);
71   }
72   /* Allocate new node. */
73   BVHNode *node4 = new InnerNode(node->bounds, children4, num_children);
74   /* TODO(sergey): Consider doing this from the InnerNode() constructor.
75    * But in order to do this nicely need to think of how to pass all the
76    * parameters there. */
77   if (node->is_unaligned) {
78     node4->is_unaligned = true;
79     node4->aligned_space = new Transform();
80     *node4->aligned_space = *node->aligned_space;
81   }
82   return node4;
83 }
84
85 }  // namespace
86
87 BVHNode *BVH4::widen_children_nodes(const BVHNode *root)
88 {
89   if (root == NULL) {
90     return NULL;
91   }
92   if (root->is_leaf()) {
93     return const_cast<BVHNode *>(root);
94   }
95   BVHNode *root4 = bvh_node_merge_children_recursively(root);
96   /* TODO(sergey): Pack children nodes to parents which has less that 4
97    * children. */
98   return root4;
99 }
100
101 void BVH4::pack_leaf(const BVHStackEntry &e, const LeafNode *leaf)
102 {
103   float4 data[BVH_QNODE_LEAF_SIZE];
104   memset(data, 0, sizeof(data));
105   if (leaf->num_triangles() == 1 && pack.prim_index[leaf->lo] == -1) {
106     /* object */
107     data[0].x = __int_as_float(~(leaf->lo));
108     data[0].y = __int_as_float(0);
109   }
110   else {
111     /* triangle */
112     data[0].x = __int_as_float(leaf->lo);
113     data[0].y = __int_as_float(leaf->hi);
114   }
115   data[0].z = __uint_as_float(leaf->visibility);
116   if (leaf->num_triangles() != 0) {
117     data[0].w = __uint_as_float(pack.prim_type[leaf->lo]);
118   }
119
120   memcpy(&pack.leaf_nodes[e.idx], data, sizeof(float4) * BVH_QNODE_LEAF_SIZE);
121 }
122
123 void BVH4::pack_inner(const BVHStackEntry &e, const BVHStackEntry *en, int num)
124 {
125   bool has_unaligned = false;
126   /* Check whether we have to create unaligned node or all nodes are aligned
127    * and we can cut some corner here.
128    */
129   if (params.use_unaligned_nodes) {
130     for (int i = 0; i < num; i++) {
131       if (en[i].node->is_unaligned) {
132         has_unaligned = true;
133         break;
134       }
135     }
136   }
137   if (has_unaligned) {
138     /* There's no unaligned children, pack into AABB node. */
139     pack_unaligned_inner(e, en, num);
140   }
141   else {
142     /* Create unaligned node with orientation transform for each of the
143      * children.
144      */
145     pack_aligned_inner(e, en, num);
146   }
147 }
148
149 void BVH4::pack_aligned_inner(const BVHStackEntry &e, const BVHStackEntry *en, int num)
150 {
151   BoundBox bounds[4];
152   int child[4];
153   for (int i = 0; i < num; ++i) {
154     bounds[i] = en[i].node->bounds;
155     child[i] = en[i].encodeIdx();
156   }
157   pack_aligned_node(
158       e.idx, bounds, child, e.node->visibility, e.node->time_from, e.node->time_to, num);
159 }
160
161 void BVH4::pack_aligned_node(int idx,
162                              const BoundBox *bounds,
163                              const int *child,
164                              const uint visibility,
165                              const float time_from,
166                              const float time_to,
167                              const int num)
168 {
169   float4 data[BVH_QNODE_SIZE];
170   memset(data, 0, sizeof(data));
171
172   data[0].x = __uint_as_float(visibility & ~PATH_RAY_NODE_UNALIGNED);
173   data[0].y = time_from;
174   data[0].z = time_to;
175
176   for (int i = 0; i < num; i++) {
177     float3 bb_min = bounds[i].min;
178     float3 bb_max = bounds[i].max;
179
180     data[1][i] = bb_min.x;
181     data[2][i] = bb_max.x;
182     data[3][i] = bb_min.y;
183     data[4][i] = bb_max.y;
184     data[5][i] = bb_min.z;
185     data[6][i] = bb_max.z;
186
187     data[7][i] = __int_as_float(child[i]);
188   }
189
190   for (int i = num; i < 4; i++) {
191     /* We store BB which would never be recorded as intersection
192      * so kernel might safely assume there are always 4 child nodes.
193      */
194     data[1][i] = FLT_MAX;
195     data[2][i] = -FLT_MAX;
196
197     data[3][i] = FLT_MAX;
198     data[4][i] = -FLT_MAX;
199
200     data[5][i] = FLT_MAX;
201     data[6][i] = -FLT_MAX;
202
203     data[7][i] = __int_as_float(0);
204   }
205
206   memcpy(&pack.nodes[idx], data, sizeof(float4) * BVH_QNODE_SIZE);
207 }
208
209 void BVH4::pack_unaligned_inner(const BVHStackEntry &e, const BVHStackEntry *en, int num)
210 {
211   Transform aligned_space[4];
212   BoundBox bounds[4];
213   int child[4];
214   for (int i = 0; i < num; ++i) {
215     aligned_space[i] = en[i].node->get_aligned_space();
216     bounds[i] = en[i].node->bounds;
217     child[i] = en[i].encodeIdx();
218   }
219   pack_unaligned_node(e.idx,
220                       aligned_space,
221                       bounds,
222                       child,
223                       e.node->visibility,
224                       e.node->time_from,
225                       e.node->time_to,
226                       num);
227 }
228
229 void BVH4::pack_unaligned_node(int idx,
230                                const Transform *aligned_space,
231                                const BoundBox *bounds,
232                                const int *child,
233                                const uint visibility,
234                                const float time_from,
235                                const float time_to,
236                                const int num)
237 {
238   float4 data[BVH_UNALIGNED_QNODE_SIZE];
239   memset(data, 0, sizeof(data));
240
241   data[0].x = __uint_as_float(visibility | PATH_RAY_NODE_UNALIGNED);
242   data[0].y = time_from;
243   data[0].z = time_to;
244
245   for (int i = 0; i < num; i++) {
246     Transform space = BVHUnaligned::compute_node_transform(bounds[i], aligned_space[i]);
247
248     data[1][i] = space.x.x;
249     data[2][i] = space.x.y;
250     data[3][i] = space.x.z;
251
252     data[4][i] = space.y.x;
253     data[5][i] = space.y.y;
254     data[6][i] = space.y.z;
255
256     data[7][i] = space.z.x;
257     data[8][i] = space.z.y;
258     data[9][i] = space.z.z;
259
260     data[10][i] = space.x.w;
261     data[11][i] = space.y.w;
262     data[12][i] = space.z.w;
263
264     data[13][i] = __int_as_float(child[i]);
265   }
266
267   for (int i = num; i < 4; i++) {
268     /* We store BB which would never be recorded as intersection
269      * so kernel might safely assume there are always 4 child nodes.
270      */
271
272     data[1][i] = NAN;
273     data[2][i] = NAN;
274     data[3][i] = NAN;
275
276     data[4][i] = NAN;
277     data[5][i] = NAN;
278     data[6][i] = NAN;
279
280     data[7][i] = NAN;
281     data[8][i] = NAN;
282     data[9][i] = NAN;
283
284     data[10][i] = NAN;
285     data[11][i] = NAN;
286     data[12][i] = NAN;
287
288     data[13][i] = __int_as_float(0);
289   }
290
291   memcpy(&pack.nodes[idx], data, sizeof(float4) * BVH_UNALIGNED_QNODE_SIZE);
292 }
293
294 /* Quad SIMD Nodes */
295
296 void BVH4::pack_nodes(const BVHNode *root)
297 {
298   /* Calculate size of the arrays required. */
299   const size_t num_nodes = root->getSubtreeSize(BVH_STAT_NODE_COUNT);
300   const size_t num_leaf_nodes = root->getSubtreeSize(BVH_STAT_LEAF_COUNT);
301   assert(num_leaf_nodes <= num_nodes);
302   const size_t num_inner_nodes = num_nodes - num_leaf_nodes;
303   size_t node_size;
304   if (params.use_unaligned_nodes) {
305     const size_t num_unaligned_nodes = root->getSubtreeSize(BVH_STAT_UNALIGNED_INNER_COUNT);
306     node_size = (num_unaligned_nodes * BVH_UNALIGNED_QNODE_SIZE) +
307                 (num_inner_nodes - num_unaligned_nodes) * BVH_QNODE_SIZE;
308   }
309   else {
310     node_size = num_inner_nodes * BVH_QNODE_SIZE;
311   }
312   /* Resize arrays. */
313   pack.nodes.clear();
314   pack.leaf_nodes.clear();
315   /* For top level BVH, first merge existing BVH's so we know the offsets. */
316   if (params.top_level) {
317     pack_instances(node_size, num_leaf_nodes * BVH_QNODE_LEAF_SIZE);
318   }
319   else {
320     pack.nodes.resize(node_size);
321     pack.leaf_nodes.resize(num_leaf_nodes * BVH_QNODE_LEAF_SIZE);
322   }
323
324   int nextNodeIdx = 0, nextLeafNodeIdx = 0;
325
326   vector<BVHStackEntry> stack;
327   stack.reserve(BVHParams::MAX_DEPTH * 2);
328   if (root->is_leaf()) {
329     stack.push_back(BVHStackEntry(root, nextLeafNodeIdx++));
330   }
331   else {
332     stack.push_back(BVHStackEntry(root, nextNodeIdx));
333     nextNodeIdx += root->has_unaligned() ? BVH_UNALIGNED_QNODE_SIZE : BVH_QNODE_SIZE;
334   }
335
336   while (stack.size()) {
337     BVHStackEntry e = stack.back();
338     stack.pop_back();
339
340     if (e.node->is_leaf()) {
341       /* leaf node */
342       const LeafNode *leaf = reinterpret_cast<const LeafNode *>(e.node);
343       pack_leaf(e, leaf);
344     }
345     else {
346       /* Inner node. */
347       /* Collect nodes. */
348       const BVHNode *children[4];
349       const int num_children = e.node->num_children();
350       /* Push entries on the stack. */
351       for (int i = 0; i < num_children; ++i) {
352         int idx;
353         children[i] = e.node->get_child(i);
354         assert(children[i] != NULL);
355         if (children[i]->is_leaf()) {
356           idx = nextLeafNodeIdx++;
357         }
358         else {
359           idx = nextNodeIdx;
360           nextNodeIdx += children[i]->has_unaligned() ? BVH_UNALIGNED_QNODE_SIZE : BVH_QNODE_SIZE;
361         }
362         stack.push_back(BVHStackEntry(children[i], idx));
363       }
364       /* Set node. */
365       pack_inner(e, &stack[stack.size() - num_children], num_children);
366     }
367   }
368
369   assert(node_size == nextNodeIdx);
370   /* Root index to start traversal at, to handle case of single leaf node. */
371   pack.root_index = (root->is_leaf()) ? -1 : 0;
372 }
373
374 void BVH4::refit_nodes()
375 {
376   assert(!params.top_level);
377
378   BoundBox bbox = BoundBox::empty;
379   uint visibility = 0;
380   refit_node(0, (pack.root_index == -1) ? true : false, bbox, visibility);
381 }
382
383 void BVH4::refit_node(int idx, bool leaf, BoundBox &bbox, uint &visibility)
384 {
385   if (leaf) {
386     /* Refit leaf node. */
387     int4 *data = &pack.leaf_nodes[idx];
388     int4 c = data[0];
389
390     BVH::refit_primitives(c.x, c.y, bbox, visibility);
391
392     /* TODO(sergey): This is actually a copy of pack_leaf(),
393      * but this chunk of code only knows actual data and has
394      * no idea about BVHNode.
395      *
396      * Would be nice to de-duplicate code, but trying to make
397      * making code more general ends up in much nastier code
398      * in my opinion so far.
399      *
400      * Same applies to the inner nodes case below.
401      */
402     float4 leaf_data[BVH_QNODE_LEAF_SIZE];
403     leaf_data[0].x = __int_as_float(c.x);
404     leaf_data[0].y = __int_as_float(c.y);
405     leaf_data[0].z = __uint_as_float(visibility);
406     leaf_data[0].w = __uint_as_float(c.w);
407     memcpy(&pack.leaf_nodes[idx], leaf_data, sizeof(float4) * BVH_QNODE_LEAF_SIZE);
408   }
409   else {
410     int4 *data = &pack.nodes[idx];
411     bool is_unaligned = (data[0].x & PATH_RAY_NODE_UNALIGNED) != 0;
412     int4 c;
413     if (is_unaligned) {
414       c = data[13];
415     }
416     else {
417       c = data[7];
418     }
419     /* Refit inner node, set bbox from children. */
420     BoundBox child_bbox[4] = {BoundBox::empty, BoundBox::empty, BoundBox::empty, BoundBox::empty};
421     uint child_visibility[4] = {0};
422     int num_nodes = 0;
423
424     for (int i = 0; i < 4; ++i) {
425       if (c[i] != 0) {
426         refit_node((c[i] < 0) ? -c[i] - 1 : c[i], (c[i] < 0), child_bbox[i], child_visibility[i]);
427         ++num_nodes;
428         bbox.grow(child_bbox[i]);
429         visibility |= child_visibility[i];
430       }
431     }
432
433     if (is_unaligned) {
434       Transform aligned_space[4] = {
435           transform_identity(), transform_identity(), transform_identity(), transform_identity()};
436       pack_unaligned_node(
437           idx, aligned_space, child_bbox, &c[0], visibility, 0.0f, 1.0f, num_nodes);
438     }
439     else {
440       pack_aligned_node(idx, child_bbox, &c[0], visibility, 0.0f, 1.0f, num_nodes);
441     }
442   }
443 }
444
445 CCL_NAMESPACE_END