Cycles: don't count volume boundaries as transparent bounces.
[blender-staging.git] / intern / cycles / kernel / kernel_montecarlo.h
1 /*
2  * Parts adapted from Open Shading Language with this license:
3  *
4  * Copyright (c) 2009-2010 Sony Pictures Imageworks Inc., et al.
5  * All Rights Reserved.
6  *
7  * Modifications Copyright 2011, Blender Foundation.
8  * 
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions are
11  * met:
12  * * Redistributions of source code must retain the above copyright
13  *   notice, this list of conditions and the following disclaimer.
14  * * Redistributions in binary form must reproduce the above copyright
15  *   notice, this list of conditions and the following disclaimer in the
16  *   documentation and/or other materials provided with the distribution.
17  * * Neither the name of Sony Pictures Imageworks nor the names of its
18  *   contributors may be used to endorse or promote products derived from
19  *   this software without specific prior written permission.
20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31  */
32
33 #ifndef __KERNEL_MONTECARLO_CL__
34 #define __KERNEL_MONTECARLO_CL__
35
36 CCL_NAMESPACE_BEGIN
37
38 /* distribute uniform xy on [0,1] over unit disk [-1,1] */
39 ccl_device void to_unit_disk(float *x, float *y)
40 {
41         float phi = M_2PI_F * (*x);
42         float r = sqrtf(*y);
43
44         *x = r * cosf(phi);
45         *y = r * sinf(phi);
46 }
47
48 /* return an orthogonal tangent and bitangent given a normal and tangent that
49  * may not be exactly orthogonal */
50 ccl_device void make_orthonormals_tangent(const float3 N, const float3 T, float3 *a, float3 *b)
51 {
52         *b = normalize(cross(N, T));
53         *a = cross(*b, N);
54 }
55
56 /* sample direction with cosine weighted distributed in hemisphere */
57 ccl_device_inline void sample_cos_hemisphere(const float3 N,
58         float randu, float randv, float3 *omega_in, float *pdf)
59 {
60         to_unit_disk(&randu, &randv);
61         float costheta = sqrtf(max(1.0f - randu * randu - randv * randv, 0.0f));
62         float3 T, B;
63         make_orthonormals(N, &T, &B);
64         *omega_in = randu * T + randv * B + costheta * N;
65         *pdf = costheta *M_1_PI_F;
66 }
67
68 /* sample direction uniformly distributed in hemisphere */
69 ccl_device_inline void sample_uniform_hemisphere(const float3 N,
70                                                  float randu, float randv,
71                                                  float3 *omega_in, float *pdf)
72 {
73         float z = randu;
74         float r = sqrtf(max(0.0f, 1.0f - z*z));
75         float phi = M_2PI_F * randv;
76         float x = r * cosf(phi);
77         float y = r * sinf(phi);
78
79         float3 T, B;
80         make_orthonormals (N, &T, &B);
81         *omega_in = x * T + y * B + z * N;
82         *pdf = 0.5f * M_1_PI_F;
83 }
84
85 /* sample direction uniformly distributed in cone */
86 ccl_device_inline void sample_uniform_cone(const float3 N, float angle,
87                                            float randu, float randv,
88                                            float3 *omega_in, float *pdf)
89 {
90         float z = cosf(angle*randu);
91         float r = sqrtf(max(0.0f, 1.0f - z*z));
92         float phi = M_2PI_F * randv;
93         float x = r * cosf(phi);
94         float y = r * sinf(phi);
95
96         float3 T, B;
97         make_orthonormals (N, &T, &B);
98         *omega_in = x * T + y * B + z * N;
99         *pdf = 0.5f * M_1_PI_F / (1.0f - cosf(angle));
100 }
101
102 /* sample uniform point on the surface of a sphere */
103 ccl_device float3 sample_uniform_sphere(float u1, float u2)
104 {
105         float z = 1.0f - 2.0f*u1;
106         float r = sqrtf(fmaxf(0.0f, 1.0f - z*z));
107         float phi = M_2PI_F*u2;
108         float x = r*cosf(phi);
109         float y = r*sinf(phi);
110
111         return make_float3(x, y, z);
112 }
113
114 ccl_device float balance_heuristic(float a, float b)
115 {
116         return (a)/(a + b);
117 }
118
119 ccl_device float balance_heuristic_3(float a, float b, float c)
120 {
121         return (a)/(a + b + c);
122 }
123
124 ccl_device float power_heuristic(float a, float b)
125 {
126         return (a*a)/(a*a + b*b);
127 }
128
129 ccl_device float power_heuristic_3(float a, float b, float c)
130 {
131         return (a*a)/(a*a + b*b + c*c);
132 }
133
134 ccl_device float max_heuristic(float a, float b)
135 {
136         return (a > b)? 1.0f: 0.0f;
137 }
138
139 /* distribute uniform xy on [0,1] over unit disk [-1,1], with concentric mapping
140  * to better preserve stratification for some RNG sequences */
141 ccl_device float2 concentric_sample_disk(float u1, float u2)
142 {
143         float phi, r;
144         float a = 2.0f*u1 - 1.0f;
145         float b = 2.0f*u2 - 1.0f;
146
147         if(a == 0.0f && b == 0.0f) {
148                 return make_float2(0.0f, 0.0f);
149         }
150         else if(a*a > b*b) {
151                 r = a;
152                 phi = M_PI_4_F * (b/a);
153         }
154         else {
155                 r = b;
156                 phi = M_PI_2_F - M_PI_4_F * (a/b);
157         }
158
159         return make_float2(r*cosf(phi), r*sinf(phi));
160 }
161
162 /* sample point in unit polygon with given number of corners and rotation */
163 ccl_device float2 regular_polygon_sample(float corners, float rotation, float u, float v)
164 {
165         /* sample corner number and reuse u */
166         float corner = floorf(u*corners);
167         u = u*corners - corner;
168
169         /* uniform sampled triangle weights */
170         u = sqrtf(u);
171         v = v*u;
172         u = 1.0f - u;
173
174         /* point in triangle */
175         float angle = M_PI_F/corners;
176         float2 p = make_float2((u + v)*cosf(angle), (u - v)*sinf(angle));
177
178         /* rotate */
179         rotation += corner*2.0f*angle;
180
181         float cr = cosf(rotation);
182         float sr = sinf(rotation);
183
184         return make_float2(cr*p.x - sr*p.y, sr*p.x + cr*p.y);
185 }
186
187 CCL_NAMESPACE_END
188
189 #endif /* __KERNEL_MONTECARLO_CL__ */