Cycles: better path termination for transparency.
[blender.git] / intern / cycles / kernel / closure / bsdf_oren_nayar.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 #ifndef __BSDF_OREN_NAYAR_H__
18 #define __BSDF_OREN_NAYAR_H__
19
20 CCL_NAMESPACE_BEGIN
21
22 typedef ccl_addr_space struct OrenNayarBsdf {
23         SHADER_CLOSURE_BASE;
24
25         float roughness;
26         float a;
27         float b;
28 } OrenNayarBsdf;
29
30 ccl_device float3 bsdf_oren_nayar_get_intensity(const ShaderClosure *sc, float3 n, float3 v, float3 l)
31 {
32         const OrenNayarBsdf *bsdf = (const OrenNayarBsdf*)sc;
33         float nl = max(dot(n, l), 0.0f);
34         float nv = max(dot(n, v), 0.0f);
35         float t = dot(l, v) - nl * nv;
36
37         if(t > 0.0f)
38                 t /= max(nl, nv) + FLT_MIN;
39         float is = nl * (bsdf->a + bsdf->b * t);
40         return make_float3(is, is, is);
41 }
42
43 ccl_device int bsdf_oren_nayar_setup(OrenNayarBsdf *bsdf)
44 {
45         float sigma = bsdf->roughness;
46
47         bsdf->type = CLOSURE_BSDF_OREN_NAYAR_ID;
48
49         sigma = saturate(sigma);
50
51         float div = 1.0f / (M_PI_F + ((3.0f * M_PI_F - 4.0f) / 6.0f) * sigma);
52
53         bsdf->a = 1.0f * div;
54         bsdf->b = sigma * div;
55
56         return SD_BSDF|SD_BSDF_HAS_EVAL;
57 }
58
59 ccl_device bool bsdf_oren_nayar_merge(const ShaderClosure *a, const ShaderClosure *b)
60 {
61         const OrenNayarBsdf *bsdf_a = (const OrenNayarBsdf*)a;
62         const OrenNayarBsdf *bsdf_b = (const OrenNayarBsdf*)b;
63
64         return (isequal_float3(bsdf_a->N, bsdf_b->N)) &&
65                (bsdf_a->roughness == bsdf_b->roughness);
66 }
67
68 ccl_device float3 bsdf_oren_nayar_eval_reflect(const ShaderClosure *sc, const float3 I, const float3 omega_in, float *pdf)
69 {
70         const OrenNayarBsdf *bsdf = (const OrenNayarBsdf*)sc;
71         if(dot(bsdf->N, omega_in) > 0.0f) {
72                 *pdf = 0.5f * M_1_PI_F;
73                 return bsdf_oren_nayar_get_intensity(sc, bsdf->N, I, omega_in);
74         }
75         else {
76                 *pdf = 0.0f;
77                 return make_float3(0.0f, 0.0f, 0.0f);
78         }
79 }
80
81 ccl_device float3 bsdf_oren_nayar_eval_transmit(const ShaderClosure *sc, const float3 I, const float3 omega_in, float *pdf)
82 {
83         return make_float3(0.0f, 0.0f, 0.0f);
84 }
85
86 ccl_device int bsdf_oren_nayar_sample(const ShaderClosure *sc, float3 Ng, float3 I, float3 dIdx, float3 dIdy, float randu, float randv, float3 *eval, float3 *omega_in, float3 *domega_in_dx, float3 *domega_in_dy, float *pdf)
87 {
88         const OrenNayarBsdf *bsdf = (const OrenNayarBsdf*)sc;
89         sample_uniform_hemisphere(bsdf->N, randu, randv, omega_in, pdf);
90
91         if(dot(Ng, *omega_in) > 0.0f) {
92                 *eval = bsdf_oren_nayar_get_intensity(sc, bsdf->N, I, *omega_in);
93
94 #ifdef __RAY_DIFFERENTIALS__
95                 // TODO: find a better approximation for the bounce
96                 *domega_in_dx = (2.0f * dot(bsdf->N, dIdx)) * bsdf->N - dIdx;
97                 *domega_in_dy = (2.0f * dot(bsdf->N, dIdy)) * bsdf->N - dIdy;
98 #endif
99         }
100         else {
101                 *pdf = 0.0f;
102                 *eval = make_float3(0.0f, 0.0f, 0.0f);
103         }
104
105         return LABEL_REFLECT|LABEL_DIFFUSE;
106 }
107
108
109 CCL_NAMESPACE_END
110
111 #endif /* __BSDF_OREN_NAYAR_H__ */