Cycles: better path termination for transparency.
[blender.git] / intern / cycles / kernel / closure / bsdf_principled_diffuse.h
1 /*
2  * Copyright 2011-2017 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_PRINCIPLED_DIFFUSE_H__
18 #define __BSDF_PRINCIPLED_DIFFUSE_H__
19
20 /* DISNEY PRINCIPLED DIFFUSE BRDF
21  *
22  * Shading model by Brent Burley (Disney): "Physically Based Shading at Disney" (2012)
23  */
24
25 CCL_NAMESPACE_BEGIN
26
27 typedef ccl_addr_space struct PrincipledDiffuseBsdf {
28         SHADER_CLOSURE_BASE;
29
30         float roughness;
31 } PrincipledDiffuseBsdf;
32
33 ccl_device float3 calculate_principled_diffuse_brdf(const PrincipledDiffuseBsdf *bsdf,
34         float3 N, float3 V, float3 L, float3 H, float *pdf)
35 {
36         float NdotL = max(dot(N, L), 0.0f);
37         float NdotV = max(dot(N, V), 0.0f);
38
39         if(NdotL < 0 || NdotV < 0) {
40                 *pdf = 0.0f;
41                 return make_float3(0.0f, 0.0f, 0.0f);
42         }
43
44         float LdotH = dot(L, H);
45
46         float FL = schlick_fresnel(NdotL), FV = schlick_fresnel(NdotV);
47         const float Fd90 = 0.5f + 2.0f * LdotH*LdotH * bsdf->roughness;
48         float Fd = (1.0f * (1.0f - FL) + Fd90 * FL) * (1.0f * (1.0f - FV) + Fd90 * FV);
49
50         float value = M_1_PI_F * NdotL * Fd;
51
52         return make_float3(value, value, value);
53 }
54
55 ccl_device int bsdf_principled_diffuse_setup(PrincipledDiffuseBsdf *bsdf)
56 {
57         bsdf->type = CLOSURE_BSDF_PRINCIPLED_DIFFUSE_ID;
58         return SD_BSDF|SD_BSDF_HAS_EVAL;
59 }
60
61 ccl_device bool bsdf_principled_diffuse_merge(const ShaderClosure *a, const ShaderClosure *b)
62 {
63         const PrincipledDiffuseBsdf *bsdf_a = (const PrincipledDiffuseBsdf*)a;
64         const PrincipledDiffuseBsdf *bsdf_b = (const PrincipledDiffuseBsdf*)b;
65
66         return (isequal_float3(bsdf_a->N, bsdf_b->N) && bsdf_a->roughness == bsdf_b->roughness);
67 }
68
69 ccl_device float3 bsdf_principled_diffuse_eval_reflect(const ShaderClosure *sc, const float3 I,
70         const float3 omega_in, float *pdf)
71 {
72         const PrincipledDiffuseBsdf *bsdf = (const PrincipledDiffuseBsdf *)sc;
73
74         float3 N = bsdf->N;
75         float3 V = I; // outgoing
76         float3 L = omega_in; // incoming
77         float3 H = normalize(L + V);
78
79         if(dot(N, omega_in) > 0.0f) {
80                 *pdf = fmaxf(dot(N, omega_in), 0.0f) * M_1_PI_F;
81                 return calculate_principled_diffuse_brdf(bsdf, N, V, L, H, pdf);
82         }
83         else {
84                 *pdf = 0.0f;
85                 return make_float3(0.0f, 0.0f, 0.0f);
86         }
87 }
88
89 ccl_device float3 bsdf_principled_diffuse_eval_transmit(const ShaderClosure *sc, const float3 I,
90         const float3 omega_in, float *pdf)
91 {
92         return make_float3(0.0f, 0.0f, 0.0f);
93 }
94
95 ccl_device int bsdf_principled_diffuse_sample(const ShaderClosure *sc,
96         float3 Ng, float3 I, float3 dIdx, float3 dIdy, float randu, float randv,
97         float3 *eval, float3 *omega_in, float3 *domega_in_dx,
98         float3 *domega_in_dy, float *pdf)
99 {
100         const PrincipledDiffuseBsdf *bsdf = (const PrincipledDiffuseBsdf *)sc;
101
102         float3 N = bsdf->N;
103
104         sample_cos_hemisphere(N, randu, randv, omega_in, pdf);
105
106         if(dot(Ng, *omega_in) > 0) {
107                 float3 H = normalize(I + *omega_in);
108
109                 *eval = calculate_principled_diffuse_brdf(bsdf, N, I, *omega_in, H, pdf);
110
111 #ifdef __RAY_DIFFERENTIALS__
112                 // TODO: find a better approximation for the diffuse bounce
113                 *domega_in_dx = -((2 * dot(N, dIdx)) * N - dIdx);
114                 *domega_in_dy = -((2 * dot(N, dIdy)) * N - dIdy);
115 #endif
116         }
117         else {
118                 *pdf = 0.0f;
119         }
120         return LABEL_REFLECT|LABEL_DIFFUSE;
121 }
122
123 CCL_NAMESPACE_END
124
125 #endif /* __BSDF_PRINCIPLED_DIFFUSE_H__ */
126
127