Cleanup: Remove some underlying code for the BVH disk cache.
[blender-staging.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 CacheData;
33 class LeafNode;
34 class Object;
35 class Progress;
36
37 #define BVH_NODE_SIZE   4
38 #define BVH_NODE_LEAF_SIZE      1
39 #define BVH_QNODE_SIZE  7
40 #define BVH_QNODE_LEAF_SIZE     1
41 #define BVH_ALIGN               4096
42 #define TRI_NODE_SIZE   3
43
44 /* Packed BVH
45  *
46  * BVH stored as it will be used for traversal on the rendering device. */
47
48 struct PackedBVH {
49         /* BVH nodes storage, one node is 4x int4, and contains two bounding boxes,
50          * and child, triangle or object indexes depending on the node type */
51         array<int4> nodes;
52         /* BVH leaf nodes storage. */
53         array<int4> leaf_nodes;
54         /* object index to BVH node index mapping for instances */
55         array<int> object_node; 
56         /* precomputed triangle intersection data, one triangle is 4x float4 */
57         array<float4> tri_woop;
58         /* primitive type - triangle or strand */
59         array<int> prim_type;
60         /* visibility visibilitys for primitives */
61         array<uint> prim_visibility;
62         /* mapping from BVH primitive index to true primitive index, as primitives
63          * may be duplicated due to spatial splits. -1 for instances. */
64         array<int> prim_index;
65         /* mapping from BVH primitive index, to the object id of that primitive. */
66         array<int> prim_object;
67
68         /* index of the root node. */
69         int root_index;
70
71         /* surface area heuristic, for building top level BVH */
72         float SAH;
73
74         PackedBVH()
75         {
76                 root_index = 0;
77                 SAH = 0.0f;
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         /* cache */
100         bool cache_read(CacheData& key);
101         void cache_write(CacheData& key);
102
103         /* triangles and strands*/
104         void pack_primitives();
105         void pack_triangle(int idx, float4 woop[3]);
106
107         /* merge instance BVH's */
108         void pack_instances(size_t nodes_size, size_t leaf_nodes_size);
109
110         /* for subclasses to implement */
111         virtual void pack_nodes(const BVHNode *root) = 0;
112         virtual void refit_nodes() = 0;
113 };
114
115 /* Regular BVH
116  *
117  * Typical BVH with each node having two children. */
118
119 class RegularBVH : public BVH {
120 protected:
121         /* constructor */
122         friend class BVH;
123         RegularBVH(const BVHParams& params, const vector<Object*>& objects);
124
125         /* pack */
126         void pack_nodes(const BVHNode *root);
127         void pack_leaf(const BVHStackEntry& e, const LeafNode *leaf);
128         void pack_inner(const BVHStackEntry& e, const BVHStackEntry& e0, const BVHStackEntry& e1);
129         void pack_node(int idx, const BoundBox& b0, const BoundBox& b1, int c0, int c1, uint visibility0, uint visibility1);
130
131         /* refit */
132         void refit_nodes();
133         void refit_node(int idx, bool leaf, BoundBox& bbox, uint& visibility);
134 };
135
136 /* QBVH
137  *
138  * Quad BVH, with each node having four children, to use with SIMD instructions. */
139
140 class QBVH : public BVH {
141 protected:
142         /* constructor */
143         friend class BVH;
144         QBVH(const BVHParams& params, const vector<Object*>& objects);
145
146         /* pack */
147         void pack_nodes(const BVHNode *root);
148         void pack_leaf(const BVHStackEntry& e, const LeafNode *leaf);
149         void pack_inner(const BVHStackEntry& e, const BVHStackEntry *en, int num);
150
151         /* refit */
152         void refit_nodes();
153         void refit_node(int idx, bool leaf, BoundBox& bbox, uint& visibility);
154 };
155
156 CCL_NAMESPACE_END
157
158 #endif /* __BVH_H__ */
159