Cycles: Remove odd definition from CMake file
[blender.git] / intern / cycles / bvh / bvh_node.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_NODE_H__
19 #define __BVH_NODE_H__
20
21 #include "util_boundbox.h"
22 #include "util_debug.h"
23 #include "util_types.h"
24
25 CCL_NAMESPACE_BEGIN
26
27 enum BVH_STAT {
28         BVH_STAT_NODE_COUNT,
29         BVH_STAT_INNER_COUNT,
30         BVH_STAT_LEAF_COUNT,
31         BVH_STAT_TRIANGLE_COUNT,
32         BVH_STAT_CHILDNODE_COUNT,
33         BVH_STAT_QNODE_COUNT,
34         BVH_STAT_ALIGNED_COUNT,
35         BVH_STAT_UNALIGNED_COUNT,
36         BVH_STAT_ALIGNED_INNER_COUNT,
37         BVH_STAT_UNALIGNED_INNER_COUNT,
38         BVH_STAT_ALIGNED_INNER_QNODE_COUNT,
39         BVH_STAT_UNALIGNED_INNER_QNODE_COUNT,
40         BVH_STAT_ALIGNED_LEAF_COUNT,
41         BVH_STAT_UNALIGNED_LEAF_COUNT,
42 };
43
44 class BVHParams;
45
46 class BVHNode
47 {
48 public:
49         BVHNode() : m_is_unaligned(false),
50                     m_aligned_space(NULL)
51         {
52         }
53
54         virtual ~BVHNode()
55         {
56                 delete m_aligned_space;
57         }
58
59         virtual bool is_leaf() const = 0;
60         virtual int num_children() const = 0;
61         virtual BVHNode *get_child(int i) const = 0;
62         virtual int num_triangles() const { return 0; }
63         virtual void print(int depth = 0) const = 0;
64         bool is_unaligned() const { return m_is_unaligned; }
65
66         inline void set_aligned_space(const Transform& aligned_space)
67         {
68                 m_is_unaligned = true;
69                 if (m_aligned_space == NULL) {
70                         m_aligned_space = new Transform(aligned_space);
71                 }
72                 else {
73                         *m_aligned_space = aligned_space;
74                 }
75         }
76
77         inline Transform get_aligned_space() const
78         {
79                 if(m_aligned_space == NULL) {
80                         return transform_identity();
81                 }
82                 return *m_aligned_space;
83         }
84
85         BoundBox m_bounds;
86         uint m_visibility;
87
88         // Subtree functions
89         int getSubtreeSize(BVH_STAT stat=BVH_STAT_NODE_COUNT) const;
90         float computeSubtreeSAHCost(const BVHParams& p, float probability = 1.0f) const;
91         void deleteSubtree();
92
93         uint update_visibility();
94
95         bool m_is_unaligned;
96
97         // TODO(sergey): Can be stored as 3x3 matrix, but better to have some
98         // utilities and type defines in util_transform first.
99         Transform *m_aligned_space;
100 };
101
102 class InnerNode : public BVHNode
103 {
104 public:
105         InnerNode(const BoundBox& bounds,
106                   BVHNode* child0,
107                   BVHNode* child1)
108         {
109                 m_bounds = bounds;
110                 children[0] = child0;
111                 children[1] = child1;
112
113                 if(child0 && child1)
114                         m_visibility = child0->m_visibility|child1->m_visibility;
115                 else
116                         m_visibility = 0; /* happens on build cancel */
117         }
118
119         explicit InnerNode(const BoundBox& bounds)
120         {
121                 m_bounds = bounds;
122                 m_visibility = 0;
123                 children[0] = NULL;
124                 children[1] = NULL;
125         }
126
127         bool is_leaf() const { return false; }
128         int num_children() const { return 2; }
129         BVHNode *get_child(int i) const{ assert(i>=0 && i<2); return children[i]; }
130         void print(int depth) const;
131
132         BVHNode *children[2];
133 };
134
135 class LeafNode : public BVHNode
136 {
137 public:
138         LeafNode(const BoundBox& bounds, uint visibility, int lo, int hi) 
139         {
140                 m_bounds = bounds;
141                 m_visibility = visibility;
142                 m_lo = lo;
143                 m_hi = hi;
144         }
145
146         LeafNode(const LeafNode& s)
147         : BVHNode()
148         {
149                 *this = s;
150         }
151
152         bool is_leaf() const { return true; }
153         int num_children() const { return 0; }
154         BVHNode *get_child(int) const { return NULL; }
155         int num_triangles() const { return m_hi - m_lo; }
156         void print(int depth) const;
157
158         int m_lo;
159         int m_hi;
160 };
161
162 CCL_NAMESPACE_END
163
164 #endif /* __BVH_NODE_H__ */
165