Cycles: Remove odd definition from CMake file
[blender.git] / intern / cycles / bvh / bvh.h
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 #ifndef __BVH_H__
19 #define __BVH_H__
20
21 #include "bvh_params.h"
22
23 #include "util_types.h"
24 #include "util_vector.h"
25
26 CCL_NAMESPACE_BEGIN
27
28 class BVHNode;
29 struct BVHStackEntry;
30 class BVHParams;
31 class BoundBox;
32 class LeafNode;
33 class Object;
34 class Progress;
35
36 #define BVH_NODE_SIZE   4
37 #define BVH_NODE_LEAF_SIZE      1
38 #define BVH_QNODE_SIZE  8
39 #define BVH_QNODE_LEAF_SIZE     1
40 #define BVH_ALIGN               4096
41 #define TRI_NODE_SIZE   3
42
43 #define BVH_UNALIGNED_NODE_SIZE 7
44 #define BVH_UNALIGNED_QNODE_SIZE 14
45
46 /* Packed BVH
47  *
48  * BVH stored as it will be used for traversal on the rendering device. */
49
50 struct PackedBVH {
51         /* BVH nodes storage, one node is 4x int4, and contains two bounding boxes,
52          * and child, triangle or object indexes depending on the node type */
53         array<int4> nodes;
54         /* BVH leaf nodes storage. */
55         array<int4> leaf_nodes;
56         /* object index to BVH node index mapping for instances */
57         array<int> object_node; 
58         /* Mapping from primitive index to index in triangle array. */
59         array<uint> prim_tri_index;
60         /* Continuous storage of triangle vertices. */
61         array<float4> prim_tri_verts;
62         /* primitive type - triangle or strand */
63         array<int> prim_type;
64         /* visibility visibilitys for primitives */
65         array<uint> prim_visibility;
66         /* mapping from BVH primitive index to true primitive index, as primitives
67          * may be duplicated due to spatial splits. -1 for instances. */
68         array<int> prim_index;
69         /* mapping from BVH primitive index, to the object id of that primitive. */
70         array<int> prim_object;
71
72         /* index of the root node. */
73         int root_index;
74
75         PackedBVH()
76         {
77                 root_index = 0;
78         }
79 };
80
81 /* BVH */
82
83 class BVH
84 {
85 public:
86         PackedBVH pack;
87         BVHParams params;
88         vector<Object*> objects;
89
90         static BVH *create(const BVHParams& params, const vector<Object*>& objects);
91         virtual ~BVH() {}
92
93         void build(Progress& progress);
94         void refit(Progress& progress);
95
96 protected:
97         BVH(const BVHParams& params, const vector<Object*>& objects);
98
99         /* triangles and strands */
100         void pack_primitives();
101         void pack_triangle(int idx, float4 storage[3]);
102
103         /* merge instance BVH's */
104         void pack_instances(size_t nodes_size, size_t leaf_nodes_size);
105
106         /* for subclasses to implement */
107         virtual void pack_nodes(const BVHNode *root) = 0;
108         virtual void refit_nodes() = 0;
109 };
110
111 /* Regular BVH
112  *
113  * Typical BVH with each node having two children. */
114
115 class RegularBVH : public BVH {
116 protected:
117         /* constructor */
118         friend class BVH;
119         RegularBVH(const BVHParams& params, const vector<Object*>& objects);
120
121         /* pack */
122         void pack_nodes(const BVHNode *root);
123
124         void pack_leaf(const BVHStackEntry& e,
125                        const LeafNode *leaf);
126         void pack_inner(const BVHStackEntry& e,
127                         const BVHStackEntry& e0,
128                         const BVHStackEntry& e1);
129
130         void pack_aligned_inner(const BVHStackEntry& e,
131                                 const BVHStackEntry& e0,
132                                 const BVHStackEntry& e1);
133         void pack_aligned_node(int idx,
134                                const BoundBox& b0,
135                                const BoundBox& b1,
136                                int c0, int c1,
137                                uint visibility0, uint visibility1);
138
139         void pack_unaligned_inner(const BVHStackEntry& e,
140                                   const BVHStackEntry& e0,
141                                   const BVHStackEntry& e1);
142         void pack_unaligned_node(int idx,
143                                  const Transform& aligned_space0,
144                                  const Transform& aligned_space1,
145                                  const BoundBox& b0,
146                                  const BoundBox& b1,
147                                  int c0, int c1,
148                                  uint visibility0, uint visibility1);
149
150         /* refit */
151         void refit_nodes();
152         void refit_node(int idx, bool leaf, BoundBox& bbox, uint& visibility);
153 };
154
155 /* QBVH
156  *
157  * Quad BVH, with each node having four children, to use with SIMD instructions. */
158
159 class QBVH : public BVH {
160 protected:
161         /* constructor */
162         friend class BVH;
163         QBVH(const BVHParams& params, const vector<Object*>& objects);
164
165         /* pack */
166         void pack_nodes(const BVHNode *root);
167
168         void pack_leaf(const BVHStackEntry& e, const LeafNode *leaf);
169         void pack_inner(const BVHStackEntry& e, const BVHStackEntry *en, int num);
170
171         void pack_aligned_inner(const BVHStackEntry& e,
172                                 const BVHStackEntry *en,
173                                 int num);
174         void pack_unaligned_inner(const BVHStackEntry& e,
175                                   const BVHStackEntry *en,
176                                   int num);
177
178         /* refit */
179         void refit_nodes();
180         void refit_node(int idx, bool leaf, BoundBox& bbox, uint& visibility);
181 };
182
183 CCL_NAMESPACE_END
184
185 #endif /* __BVH_H__ */
186