Update bundled version of minilzo
[blender-staging.git] / intern / cycles / bvh / bvh_params.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_PARAMS_H__
19 #define __BVH_PARAMS_H__
20
21 #include "util_boundbox.h"
22
23 CCL_NAMESPACE_BEGIN
24
25 /* BVH Parameters */
26
27 class BVHParams
28 {
29 public:
30         /* spatial split area threshold */
31         int use_spatial_split;
32         float spatial_split_alpha;
33
34         /* SAH costs */
35         float sah_node_cost;
36         float sah_triangle_cost;
37
38         /* number of triangles in leaf */
39         int min_leaf_size;
40         int max_leaf_size;
41
42         /* object or mesh level bvh */
43         int top_level;
44
45         /* disk cache */
46         int use_cache;
47
48         /* QBVH */
49         int use_qbvh;
50
51         int pad;
52
53         /* fixed parameters */
54         enum {
55                 MAX_DEPTH = 64,
56                 MAX_SPATIAL_DEPTH = 48,
57                 NUM_SPATIAL_BINS = 32
58         };
59
60         BVHParams()
61         {
62                 use_spatial_split = true;
63                 spatial_split_alpha = 1e-5f;
64
65                 sah_node_cost = 1.0f;
66                 sah_triangle_cost = 1.0f;
67
68                 min_leaf_size = 1;
69                 max_leaf_size = 0x7FFFFFF;
70
71                 top_level = false;
72                 use_cache = false;
73                 use_qbvh = false;
74                 pad = false;
75         }
76
77         /* SAH costs */
78         __forceinline float cost(int num_nodes, int num_tris) const
79         { return node_cost(num_nodes) + triangle_cost(num_tris); }
80
81         __forceinline float triangle_cost(int n) const
82         { return n*sah_triangle_cost; }
83
84         __forceinline float node_cost(int n) const
85         { return n*sah_node_cost; }
86
87         __forceinline bool small_enough_for_leaf(int size, int level)
88         { return (size <= min_leaf_size || level >= MAX_DEPTH); }
89 };
90
91 /* BVH Reference
92  *
93  * Reference to a primitive. Primitive index and object are sneakily packed
94  * into BoundBox to reduce memory usage and align nicely */
95
96 class BVHReference
97 {
98 public:
99         __forceinline BVHReference() {}
100
101         __forceinline BVHReference(const BoundBox& bounds_, int prim_index_, int prim_object_, int prim_segment)
102         : rbounds(bounds_)
103         {
104                 rbounds.min.w = __int_as_float(prim_index_);
105                 rbounds.max.w = __int_as_float(prim_object_);
106                 segment = prim_segment;
107         }
108
109         __forceinline const BoundBox& bounds() const { return rbounds; }
110         __forceinline int prim_index() const { return __float_as_int(rbounds.min.w); }
111         __forceinline int prim_object() const { return __float_as_int(rbounds.max.w); }
112         __forceinline int prim_segment() const { return segment; }
113
114 protected:
115         BoundBox rbounds;
116         uint segment;
117 };
118
119 /* BVH Range
120  *
121  * Build range used during construction, to indicate the bounds and place in
122  * the reference array of a subset of pirmitives Again uses trickery to pack
123  * integers into BoundBox for alignment purposes. */
124
125 class BVHRange
126 {
127 public:
128         __forceinline BVHRange()
129         {
130                 rbounds.min.w = __int_as_float(0);
131                 rbounds.max.w = __int_as_float(0);
132         }
133
134         __forceinline BVHRange(const BoundBox& bounds_, int start_, int size_)
135         : rbounds(bounds_)
136         {
137                 rbounds.min.w = __int_as_float(start_);
138                 rbounds.max.w = __int_as_float(size_);
139         }
140
141         __forceinline BVHRange(const BoundBox& bounds_, const BoundBox& cbounds_, int start_, int size_)
142         : rbounds(bounds_), cbounds(cbounds_)
143         {
144                 rbounds.min.w = __int_as_float(start_);
145                 rbounds.max.w = __int_as_float(size_);
146         }
147
148         __forceinline void set_start(int start_) { rbounds.min.w = __int_as_float(start_); }
149
150         __forceinline const BoundBox& bounds() const { return rbounds; }
151         __forceinline const BoundBox& cent_bounds() const { return cbounds; }
152         __forceinline int start() const { return __float_as_int(rbounds.min.w); }
153         __forceinline int size() const { return __float_as_int(rbounds.max.w); }
154         __forceinline int end() const { return start() + size(); }
155
156 protected:
157         BoundBox rbounds;
158         BoundBox cbounds;
159 };
160
161 /* BVH Spatial Bin */
162
163 struct BVHSpatialBin
164 {
165         BoundBox bounds;
166         int enter;
167         int exit;
168
169         __forceinline BVHSpatialBin()
170         {
171         }
172 };
173
174 CCL_NAMESPACE_END
175
176 #endif /* __BVH_PARAMS_H__ */
177