Cycles: Remove odd definition from CMake file
[blender.git] / intern / cycles / bvh / bvh_binning.h
1 /*
2  * Adapted from code copyright 2009-2011 Intel Corporation
3  * Modifications Copyright 2012, 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_BINNING_H__
19 #define __BVH_BINNING_H__
20
21 #include "bvh_params.h"
22 #include "bvh_unaligned.h"
23
24 #include "util_types.h"
25
26 CCL_NAMESPACE_BEGIN
27
28 class BVHBuild;
29
30 /* Single threaded object binner. Finds the split with the best SAH heuristic
31  * by testing for each dimension multiple partitionings for regular spaced
32  * partition locations. A partitioning for a partition location is computed,
33  * by putting primitives whose centroid is on the left and right of the split
34  * location to different sets. The SAH is evaluated by computing the number of
35  * blocks occupied by the primitives in the partitions. */
36
37 class BVHObjectBinning : public BVHRange
38 {
39 public:
40         __forceinline BVHObjectBinning() : leafSAH(FLT_MAX) {}
41
42         BVHObjectBinning(const BVHRange& job,
43                          BVHReference *prims,
44                          const BVHUnaligned *unaligned_heuristic = NULL,
45                          const Transform *aligned_space = NULL);
46
47         void split(BVHReference *prims,
48                    BVHObjectBinning& left_o,
49                    BVHObjectBinning& right_o) const;
50
51         __forceinline const BoundBox& unaligned_bounds() { return bounds_; }
52
53         float splitSAH; /* SAH cost of the best split */
54         float leafSAH;  /* SAH cost of creating a leaf */
55
56 protected:
57         int dim;                        /* best split dimension */
58         int pos;                        /* best split position */
59         size_t num_bins;        /* actual number of bins to use */
60         float3 scale;           /* scaling factor to compute bin */
61
62         /* Effective bounds and centroid bounds. */
63         BoundBox bounds_;
64         BoundBox cent_bounds_;
65
66         const BVHUnaligned *unaligned_heuristic_;
67         const Transform *aligned_space_;
68
69         enum { MAX_BINS = 32 };
70         enum { LOG_BLOCK_SIZE = 2 };
71
72         /* computes the bin numbers for each dimension for a box. */
73         __forceinline int4 get_bin(const BoundBox& box) const
74         {
75                 int4 a = make_int4((box.center2() - cent_bounds_.min)*scale - make_float3(0.5f));
76                 int4 mn = make_int4(0);
77                 int4 mx = make_int4((int)num_bins-1);
78
79                 return clamp(a, mn, mx);
80         }
81
82         /* computes the bin numbers for each dimension for a point. */
83         __forceinline int4 get_bin(const float3& c) const
84         {
85                 return make_int4((c - cent_bounds_.min)*scale - make_float3(0.5f));
86         }
87
88         /* compute the number of blocks occupied for each dimension. */
89         __forceinline float4 blocks(const int4& a) const
90         {
91                 return make_float4((a + make_int4((1 << LOG_BLOCK_SIZE)-1)) >> LOG_BLOCK_SIZE);
92         }
93
94         /* compute the number of blocks occupied in one dimension. */
95         __forceinline int blocks(size_t a) const
96         {
97                 return (int)((a+((1LL << LOG_BLOCK_SIZE)-1)) >> LOG_BLOCK_SIZE);
98         }
99
100         __forceinline BoundBox get_prim_bounds(const BVHReference& prim) const
101         {
102                 if(aligned_space_ == NULL) {
103                         return prim.bounds();
104                 }
105                 else {
106                         return unaligned_heuristic_->compute_aligned_prim_boundbox(
107                                 prim, *aligned_space_);
108                 }
109         }
110 };
111
112 CCL_NAMESPACE_END
113
114 #endif
115