Cycles: don't count volume boundaries as transparent bounces.
[blender-staging.git] / intern / cycles / kernel / kernel_jitter.h
1 /*
2  * Copyright 2011-2013 Blender Foundation
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 /* TODO(sergey): Consider moving portable ctz/clz stuff to util. */
18
19 CCL_NAMESPACE_BEGIN
20
21 /* "Correlated Multi-Jittered Sampling"
22  * Andrew Kensler, Pixar Technical Memo 13-01, 2013 */
23
24 /* todo: find good value, suggested 64 gives pattern on cornell box ceiling */
25 #define CMJ_RANDOM_OFFSET_LIMIT 4096
26
27 ccl_device_inline bool cmj_is_pow2(int i)
28 {
29         return (i > 1) && ((i & (i - 1)) == 0);
30 }
31
32 ccl_device_inline int cmj_fast_mod_pow2(int a, int b)
33 {
34         return (a & (b - 1));
35 }
36
37 /* b must be > 1 */
38 ccl_device_inline int cmj_fast_div_pow2(int a, int b)
39 {
40         kernel_assert(b > 1);
41 #if defined(__KERNEL_SSE2__)
42 #  ifdef _MSC_VER
43         unsigned long ctz;
44         _BitScanForward(&ctz, b);
45         return a >> ctz;
46 #  else
47         return a >> __builtin_ctz(b);
48 #  endif
49 #elif defined(__KERNEL_CUDA__)
50         return a >> (__ffs(b) - 1);
51 #else
52         return a/b;
53 #endif
54 }
55
56 ccl_device_inline uint cmj_w_mask(uint w)
57 {
58         kernel_assert(w > 1);
59 #if defined(__KERNEL_SSE2__)
60 #  ifdef _MSC_VER
61         unsigned long leading_zero;
62         _BitScanReverse(&leading_zero, w);
63         return ((1 << (1 + leading_zero)) - 1);
64 #  else
65         return ((1 << (32 - __builtin_clz(w))) - 1);
66 #  endif
67 #elif defined(__KERNEL_CUDA__)
68         return ((1 << (32 - __clz(w))) - 1);
69 #else
70         w |= w >> 1;
71         w |= w >> 2;
72         w |= w >> 4;
73         w |= w >> 8;
74         w |= w >> 16;
75
76         return w;
77 #endif
78 }
79
80 ccl_device_inline uint cmj_permute(uint i, uint l, uint p)
81 {
82         uint w = l - 1;
83
84         if((l & w) == 0) {
85                 /* l is a power of two (fast) */
86                 i ^= p;
87                 i *= 0xe170893d;
88                 i ^= p >> 16;
89                 i ^= (i & w) >> 4;
90                 i ^= p >> 8;
91                 i *= 0x0929eb3f;
92                 i ^= p >> 23;
93                 i ^= (i & w) >> 1;
94                 i *= 1 | p >> 27;
95                 i *= 0x6935fa69;
96                 i ^= (i & w) >> 11;
97                 i *= 0x74dcb303;
98                 i ^= (i & w) >> 2;
99                 i *= 0x9e501cc3;
100                 i ^= (i & w) >> 2;
101                 i *= 0xc860a3df;
102                 i &= w;
103                 i ^= i >> 5;
104
105                 return (i + p) & w;
106         }
107         else {
108                 /* l is not a power of two (slow) */
109                 w = cmj_w_mask(w);
110
111                 do {
112                         i ^= p;
113                         i *= 0xe170893d;
114                         i ^= p >> 16;
115                         i ^= (i & w) >> 4;
116                         i ^= p >> 8;
117                         i *= 0x0929eb3f;
118                         i ^= p >> 23;
119                         i ^= (i & w) >> 1;
120                         i *= 1 | p >> 27;
121                         i *= 0x6935fa69;
122                         i ^= (i & w) >> 11;
123                         i *= 0x74dcb303;
124                         i ^= (i & w) >> 2;
125                         i *= 0x9e501cc3;
126                         i ^= (i & w) >> 2;
127                         i *= 0xc860a3df;
128                         i &= w;
129                         i ^= i >> 5;
130                 } while(i >= l);
131
132                 return (i + p) % l;
133         }
134 }
135
136 ccl_device_inline uint cmj_hash(uint i, uint p)
137 {
138         i ^= p;
139         i ^= i >> 17;
140         i ^= i >> 10;
141         i *= 0xb36534e5;
142         i ^= i >> 12;
143         i ^= i >> 21;
144         i *= 0x93fc4795;
145         i ^= 0xdf6e307f;
146         i ^= i >> 17;
147         i *= 1 | p >> 18;
148
149         return i;
150 }
151
152 ccl_device_inline uint cmj_hash_simple(uint i, uint p)
153 {
154         i = (i ^ 61) ^ p;
155         i += i << 3;
156         i ^= i >> 4;
157         i *= 0x27d4eb2d;
158         return i;
159 }
160
161 ccl_device_inline float cmj_randfloat(uint i, uint p)
162 {
163         return cmj_hash(i, p) * (1.0f / 4294967808.0f);
164 }
165
166 #ifdef __CMJ__
167 ccl_device float cmj_sample_1D(int s, int N, int p)
168 {
169         kernel_assert(s < N);
170
171         uint x = cmj_permute(s, N, p * 0x68bc21eb);
172         float jx = cmj_randfloat(s, p * 0x967a889b);
173
174         float invN = 1.0f/N;
175         return (x + jx)*invN;
176 }
177
178 /* TODO(sergey): Do some extra tests and consider moving to util_math.h. */
179 ccl_device_inline int cmj_isqrt(int value)
180 {
181 #if defined(__KERNEL_CUDA__)
182         return float_to_int(__fsqrt_ru(value));
183 #elif defined(__KERNEL_GPU__)
184         return float_to_int(sqrtf(value));
185 #else
186         /* This is a work around for fast-math on CPU which might replace sqrtf()
187          * with am approximated version.
188          */
189         return float_to_int(sqrtf(value) + 1e-6f);
190 #endif
191 }
192
193 ccl_device void cmj_sample_2D(int s, int N, int p, float *fx, float *fy)
194 {
195         kernel_assert(s < N);
196
197         int m = cmj_isqrt(N);
198         int n = (N - 1)/m + 1;
199         float invN = 1.0f/N;
200         float invm = 1.0f/m;
201         float invn = 1.0f/n;
202
203         s = cmj_permute(s, N, p * 0x51633e2d);
204
205         int sdivm, smodm;
206
207         if(cmj_is_pow2(m)) {
208                 sdivm = cmj_fast_div_pow2(s, m);
209                 smodm = cmj_fast_mod_pow2(s, m);
210         }
211         else {
212                 /* Doing s*inmv gives precision issues here. */
213                 sdivm = s / m;
214                 smodm = s - sdivm*m;
215         }
216
217         uint sx = cmj_permute(smodm, m, p * 0x68bc21eb);
218         uint sy = cmj_permute(sdivm, n, p * 0x02e5be93);
219
220         float jx = cmj_randfloat(s, p * 0x967a889b);
221         float jy = cmj_randfloat(s, p * 0x368cc8b7);
222
223         *fx = (sx + (sy + jx)*invn)*invm;
224         *fy = (s + jy)*invN;
225 }
226 #endif
227
228 CCL_NAMESPACE_END
229