Cycles: change __device and similar qualifiers to ccl_device in kernel code.
[blender.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 CCL_NAMESPACE_BEGIN
18
19 /* "Correlated Multi-Jittered Sampling"
20  * Andrew Kensler, Pixar Technical Memo 13-01, 2013 */
21
22 /* todo: find good value, suggested 64 gives pattern on cornell box ceiling */
23 #define CMJ_RANDOM_OFFSET_LIMIT 4096
24
25 ccl_device_inline bool cmj_is_pow2(int i)
26 {
27         return (i & (i - 1)) == 0;
28 }
29
30 ccl_device_inline int cmj_fast_mod_pow2(int a, int b)
31 {
32         return (a & (b - 1));
33 }
34
35 /* a must be > 0 and b must be > 1 */
36 ccl_device_inline int cmj_fast_div_pow2(int a, int b)
37 {
38 #if defined(__KERNEL_SSE2__) && !defined(_MSC_VER)
39         return a >> __builtin_ctz(b);
40 #else
41         return a/b;
42 #endif
43 }
44
45 ccl_device_inline uint cmj_w_mask(uint w)
46 {
47 #if defined(__KERNEL_SSE2__) && !defined(_MSC_VER)
48         return ((1 << (32 - __builtin_clz(w))) - 1);
49 #else
50         w |= w >> 1;
51         w |= w >> 2;
52         w |= w >> 4;
53         w |= w >> 8;
54         w |= w >> 16;
55
56         return w;
57 #endif
58 }
59
60 ccl_device_inline uint cmj_permute(uint i, uint l, uint p)
61 {
62         uint w = l - 1;
63
64         if((l & w) == 0) {
65                 /* l is a power of two (fast) */
66                 i ^= p;
67                 i *= 0xe170893d;
68                 i ^= p >> 16;
69                 i ^= (i & w) >> 4;
70                 i ^= p >> 8;
71                 i *= 0x0929eb3f;
72                 i ^= p >> 23;
73                 i ^= (i & w) >> 1;
74                 i *= 1 | p >> 27;
75                 i *= 0x6935fa69;
76                 i ^= (i & w) >> 11;
77                 i *= 0x74dcb303;
78                 i ^= (i & w) >> 2;
79                 i *= 0x9e501cc3;
80                 i ^= (i & w) >> 2;
81                 i *= 0xc860a3df;
82                 i &= w;
83                 i ^= i >> 5;
84
85                 return (i + p) & w;
86         }
87         else {
88                 /* l is not a power of two (slow) */
89                 w = cmj_w_mask(w);
90
91                 do {
92                         i ^= p;
93                         i *= 0xe170893d;
94                         i ^= p >> 16;
95                         i ^= (i & w) >> 4;
96                         i ^= p >> 8;
97                         i *= 0x0929eb3f;
98                         i ^= p >> 23;
99                         i ^= (i & w) >> 1;
100                         i *= 1 | p >> 27;
101                         i *= 0x6935fa69;
102                         i ^= (i & w) >> 11;
103                         i *= 0x74dcb303;
104                         i ^= (i & w) >> 2;
105                         i *= 0x9e501cc3;
106                         i ^= (i & w) >> 2;
107                         i *= 0xc860a3df;
108                         i &= w;
109                         i ^= i >> 5;
110                 } while (i >= l);
111
112                 return (i + p) % l;
113         }
114 }
115
116 ccl_device_inline uint cmj_hash(uint i, uint p)
117 {
118         i ^= p;
119         i ^= i >> 17;
120         i ^= i >> 10;
121         i *= 0xb36534e5;
122         i ^= i >> 12;
123         i ^= i >> 21;
124         i *= 0x93fc4795;
125         i ^= 0xdf6e307f;
126         i ^= i >> 17;
127         i *= 1 | p >> 18;
128
129         return i;
130 }
131
132 ccl_device_inline float cmj_randfloat(uint i, uint p)
133 {
134         return cmj_hash(i, p) * (1.0f / 4294967808.0f);
135 }
136
137 #ifdef __CMJ__
138 ccl_device float cmj_sample_1D(int s, int N, int p)
139 {
140         kernel_assert(s < N);
141
142         uint x = cmj_permute(s, N, p * 0x68bc21eb);
143         float jx = cmj_randfloat(s, p * 0x967a889b);
144
145         float invN = 1.0f/N;
146         return (x + jx)*invN;
147 }
148
149 ccl_device void cmj_sample_2D(int s, int N, int p, float *fx, float *fy)
150 {
151         kernel_assert(s < N);
152
153         int m = float_to_int(sqrtf(N));
154         int n = (N + m - 1)/m;
155         float invN = 1.0f/N;
156         float invm = 1.0f/m;
157         float invn = 1.0f/n;
158
159         s = cmj_permute(s, N, p * 0x51633e2d);
160
161         int sdivm, smodm;
162
163         if(cmj_is_pow2(m)) {
164                 sdivm = cmj_fast_div_pow2(s, m);
165                 smodm = cmj_fast_mod_pow2(s, m);
166         }
167         else {
168                 sdivm = float_to_int(s * invm);
169                 smodm = s - sdivm*m;
170         }
171
172         uint sx = cmj_permute(smodm, m, p * 0x68bc21eb);
173         uint sy = cmj_permute(sdivm, n, p * 0x02e5be93);
174
175         float jx = cmj_randfloat(s, p * 0x967a889b);
176         float jy = cmj_randfloat(s, p * 0x368cc8b7);
177
178         *fx = (sx + (sy + jx)*invn)*invm;
179         *fy = (s + jy)*invN;
180 }
181 #endif
182
183 CCL_NAMESPACE_END
184