Fix incorrect FLT_MIN use
[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 };
35
36 class BVHParams;
37
38 class BVHNode
39 {
40 public:
41         BVHNode()
42         {
43         }
44
45         virtual ~BVHNode() {}
46         virtual bool is_leaf() const = 0;
47         virtual int num_children() const = 0;
48         virtual BVHNode *get_child(int i) const = 0;
49         virtual int num_triangles() const { return 0; }
50         virtual void print(int depth = 0) const = 0;
51
52         BoundBox m_bounds;
53         uint m_visibility;
54
55         // Subtree functions
56         int getSubtreeSize(BVH_STAT stat=BVH_STAT_NODE_COUNT) const;
57         float computeSubtreeSAHCost(const BVHParams& p, float probability = 1.0f) const;
58         void deleteSubtree();
59
60         uint update_visibility();
61 };
62
63 class InnerNode : public BVHNode
64 {
65 public:
66         InnerNode(const BoundBox& bounds, BVHNode* child0, BVHNode* child1)
67         {
68                 m_bounds = bounds;
69                 children[0] = child0;
70                 children[1] = child1;
71
72                 if(child0 && child1)
73                         m_visibility = child0->m_visibility|child1->m_visibility;
74                 else
75                         m_visibility = 0; /* happens on build cancel */
76         }
77
78         InnerNode(const BoundBox& bounds)
79         {
80                 m_bounds = bounds;
81                 m_visibility = 0;
82                 children[0] = NULL;
83                 children[1] = NULL;
84         }
85
86         bool is_leaf() const { return false; }
87         int num_children() const { return 2; }
88         BVHNode *get_child(int i) const{ assert(i>=0 && i<2); return children[i]; }
89         void print(int depth) const;
90
91         BVHNode *children[2];
92 };
93
94 class LeafNode : public BVHNode
95 {
96 public:
97         LeafNode(const BoundBox& bounds, uint visibility, int lo, int hi) 
98         {
99                 m_bounds = bounds;
100                 m_visibility = visibility;
101                 m_lo = lo;
102                 m_hi = hi;
103         }
104
105         LeafNode(const LeafNode& s)
106         : BVHNode()
107         {
108                 *this = s;
109         }
110
111         bool is_leaf() const { return true; }
112         int num_children() const { return 0; }
113         BVHNode *get_child(int) const { return NULL; }
114         int num_triangles() const { return m_hi - m_lo; }
115         void print(int depth) const;
116
117         int m_lo;
118         int m_hi;
119 };
120
121 CCL_NAMESPACE_END
122
123 #endif /* __BVH_NODE_H__ */
124