← Back to branch summary

~ubuntu-branches/ubuntu/trusty/blender/trusty

« back to all changes in this revision

Viewing changes to intern/cycles/kernel/kernel_montecarlo.h

  • Committer: Package Import Robot
  • Author(s): Jeremy Bicha
  • Date: 2013-03-06 12:08:47 UTC
  • mfrom: (1.5.1) (14.1.8 experimental)
  • Revision ID: package-import@ubuntu.com-20130306120847-frjfaryb2zrotwcg
Tags: 2.66a-1ubuntu1
https://launchpad.net/bugs/1076930
https://launchpad.net/bugs/1089256
https://launchpad.net/bugs/1052743
https://launchpad.net/bugs/999024
* Resynchronize with Debian (LP: #1076930, #1089256, #1052743, #999024,
  #1122888, #1147084)
* debian/control:
  - Lower build-depends on libavcodec-dev since we're not
    doing the libav9 transition in Ubuntu yet

Show diffs side-by-side

added added

removed removed

Lines of Context:
intern/cycles/kernel/kernel_montecarlo.h
28
28
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29
29
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30
30
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31
 
*/
 
31
 */
32
32
 
33
33
#ifndef __KERNEL_MONTECARLO_CL__
34
34
#define __KERNEL_MONTECARLO_CL__
46
46
        if(a > -b) {
47
47
                if(a > b) {
48
48
                        r = a;
49
 
                         phi = M_PI_4_F *(b/a);
50
 
                 } else {
51
 
                         r = b;
52
 
                         phi = M_PI_4_F *(2.0f - a/b);
53
 
                 }
54
 
        } else {
 
49
                        phi = M_PI_4_F *(b/a);
 
50
                }
 
51
                else {
 
52
                        r = b;
 
53
                        phi = M_PI_4_F *(2.0f - a/b);
 
54
                }
 
55
        }
 
56
        else {
55
57
                if(a < b) {
56
58
                        r = -a;
57
59
                        phi = M_PI_4_F *(4.0f + b/a);
58
 
                } else {
 
60
                }
 
61
                else {
59
62
                        r = -b;
60
63
                        if(b != 0.0f)
61
64
                                phi = M_PI_4_F *(6.0f - a/b);
69
72
 
70
73
__device void make_orthonormals_tangent(const float3 N, const float3 T, float3 *a, float3 *b)
71
74
{
72
 
        *b = cross(N, T);
 
75
        *b = normalize(cross(N, T));
73
76
        *a = cross(*b, N);
74
77
}
75
78
 
87
90
}
88
91
 
89
92
__device_inline void sample_uniform_hemisphere(const float3 N,
90
 
                                                                                         float randu, float randv,
91
 
                                                                                         float3 *omega_in, float *pdf)
 
93
                                               float randu, float randv,
 
94
                                               float3 *omega_in, float *pdf)
92
95
{
93
96
        float z = randu;
94
 
        float r = sqrtf(max(0.f, 1.f - z*z));
95
 
        float phi = 2.f * M_PI_F * randv;
 
97
        float r = sqrtf(max(0.0f, 1.0f - z*z));
 
98
        float phi = 2.0f * M_PI_F * randv;
96
99
        float x = r * cosf(phi);
97
100
        float y = r * sinf(phi);
98
101
 
102
105
        *pdf = 0.5f * M_1_PI_F;
103
106
}
104
107
 
 
108
__device_inline void sample_uniform_cone(const float3 N, float angle,
 
109
                                         float randu, float randv,
 
110
                                         float3 *omega_in, float *pdf)
 
111
{
 
112
        float z = cosf(angle*randu);
 
113
        float r = sqrtf(max(0.0f, 1.0f - z*z));
 
114
        float phi = 2.0f * M_PI_F * randv;
 
115
        float x = r * cosf(phi);
 
116
        float y = r * sinf(phi);
 
117
 
 
118
        float3 T, B;
 
119
        make_orthonormals (N, &T, &B);
 
120
        *omega_in = x * T + y * B + z * N;
 
121
        *pdf = 0.5f * M_1_PI_F / (1.0f - cosf(angle));
 
122
}
 
123
 
105
124
__device float3 sample_uniform_sphere(float u1, float u2)
106
125
{
107
126
        float z = 1.0f - 2.0f*u1;
185
204
        return make_float2(cr*p.x - sr*p.y, sr*p.x + cr*p.y);
186
205
}
187
206
 
188
 
/* Spherical coordinates <-> Cartesian direction  */
189
 
 
190
 
__device float2 direction_to_spherical(float3 dir)
191
 
{
192
 
        float theta = acosf(dir.z);
193
 
        float phi = atan2f(dir.x, dir.y);
194
 
 
195
 
        return make_float2(theta, phi);
196
 
}
197
 
 
198
 
__device float3 spherical_to_direction(float theta, float phi)
199
 
{
200
 
        return make_float3(
201
 
                sinf(theta)*cosf(phi),
202
 
                sinf(theta)*sinf(phi),
203
 
                cosf(theta));
204
 
}
205
 
 
206
 
/* Equirectangular coordinates <-> Cartesian direction */
207
 
 
208
 
__device float2 direction_to_equirectangular(float3 dir)
209
 
{
210
 
        float u = -atan2f(dir.y, dir.x)/(2.0f*M_PI_F) + 0.5f;
211
 
        float v = atan2f(dir.z, hypotf(dir.x, dir.y))/M_PI_F + 0.5f;
212
 
 
213
 
        return make_float2(u, v);
214
 
}
215
 
 
216
 
__device float3 equirectangular_to_direction(float u, float v)
217
 
{
218
 
        float phi = M_PI_F*(1.0f - 2.0f*u);
219
 
        float theta = M_PI_F*(1.0f - v);
220
 
 
221
 
        return make_float3(
222
 
                sin(theta)*cos(phi),
223
 
                sin(theta)*sin(phi),
224
 
                cos(theta));
225
 
}
226
 
 
227
 
/* Mirror Ball <-> Cartesion direction */
228
 
 
229
 
__device float3 mirrorball_to_direction(float u, float v)
230
 
{
231
 
        /* point on sphere */
232
 
        float3 dir;
233
 
 
234
 
        dir.x = 2.0f*u - 1.0f;
235
 
        dir.z = 2.0f*v - 1.0f;
236
 
        dir.y = -sqrt(max(1.0f - dir.x*dir.x - dir.z*dir.z, 0.0f));
237
 
 
238
 
        /* reflection */
239
 
        float3 I = make_float3(0.0f, -1.0f, 0.0f);
240
 
 
241
 
        return 2.0f*dot(dir, I)*dir - I;
242
 
}
243
 
 
244
 
__device float2 direction_to_mirrorball(float3 dir)
245
 
{
246
 
        /* inverse of mirrorball_to_direction */
247
 
        dir.y -= 1.0f;
248
 
 
249
 
        float div = 2.0f*sqrt(max(-0.5f*dir.y, 0.0f));
250
 
        if(div > 0.0f)
251
 
                dir /= div;
252
 
 
253
 
        float u = 0.5f*(dir.x + 1.0f);
254
 
        float v = 0.5f*(dir.z + 1.0f);
255
 
 
256
 
        return make_float2(u, v);
257
 
}
258
 
 
259
207
CCL_NAMESPACE_END
260
208
 
261
209
#endif /* __KERNEL_MONTECARLO_CL__ */