ClangFormat: apply to source, most of intern
[blender.git] / intern / cycles / kernel / closure / bsdf_ashikhmin_shirley.h
1 /*
2  * Copyright 2011-2014 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_ASHIKHMIN_SHIRLEY_H__
18 #define __BSDF_ASHIKHMIN_SHIRLEY_H__
19
20 /*
21 ASHIKHMIN SHIRLEY BSDF
22
23 Implementation of
24 Michael Ashikhmin and Peter Shirley: "An Anisotropic Phong BRDF Model" (2000)
25
26 The Fresnel factor is missing to get a separable bsdf (intensity*color), as is
27 the case with all other microfacet-based BSDF implementations in Cycles.
28
29 Other than that, the implementation directly follows the paper.
30 */
31
32 CCL_NAMESPACE_BEGIN
33
34 ccl_device int bsdf_ashikhmin_shirley_setup(MicrofacetBsdf *bsdf)
35 {
36   bsdf->alpha_x = clamp(bsdf->alpha_x, 1e-4f, 1.0f);
37   bsdf->alpha_y = bsdf->alpha_x;
38
39   bsdf->type = CLOSURE_BSDF_ASHIKHMIN_SHIRLEY_ID;
40   return SD_BSDF | SD_BSDF_HAS_EVAL;
41 }
42
43 ccl_device int bsdf_ashikhmin_shirley_aniso_setup(MicrofacetBsdf *bsdf)
44 {
45   bsdf->alpha_x = clamp(bsdf->alpha_x, 1e-4f, 1.0f);
46   bsdf->alpha_y = clamp(bsdf->alpha_y, 1e-4f, 1.0f);
47
48   bsdf->type = CLOSURE_BSDF_ASHIKHMIN_SHIRLEY_ANISO_ID;
49   return SD_BSDF | SD_BSDF_HAS_EVAL;
50 }
51
52 ccl_device void bsdf_ashikhmin_shirley_blur(ShaderClosure *sc, float roughness)
53 {
54   MicrofacetBsdf *bsdf = (MicrofacetBsdf *)sc;
55
56   bsdf->alpha_x = fmaxf(roughness, bsdf->alpha_x);
57   bsdf->alpha_y = fmaxf(roughness, bsdf->alpha_y);
58 }
59
60 ccl_device_inline float bsdf_ashikhmin_shirley_roughness_to_exponent(float roughness)
61 {
62   return 2.0f / (roughness * roughness) - 2.0f;
63 }
64
65 ccl_device_forceinline float3 bsdf_ashikhmin_shirley_eval_reflect(const ShaderClosure *sc,
66                                                                   const float3 I,
67                                                                   const float3 omega_in,
68                                                                   float *pdf)
69 {
70   const MicrofacetBsdf *bsdf = (const MicrofacetBsdf *)sc;
71   float3 N = bsdf->N;
72
73   float NdotI = dot(N, I);        /* in Cycles/OSL convention I is omega_out    */
74   float NdotO = dot(N, omega_in); /* and consequently we use for O omaga_in ;)  */
75
76   float out = 0.0f;
77
78   if (fmaxf(bsdf->alpha_x, bsdf->alpha_y) <= 1e-4f)
79     return make_float3(0.0f, 0.0f, 0.0f);
80
81   if (NdotI > 0.0f && NdotO > 0.0f) {
82     NdotI = fmaxf(NdotI, 1e-6f);
83     NdotO = fmaxf(NdotO, 1e-6f);
84     float3 H = normalize(omega_in + I);
85     float HdotI = fmaxf(fabsf(dot(H, I)), 1e-6f);
86     float HdotN = fmaxf(dot(H, N), 1e-6f);
87
88     float pump =
89         1.0f /
90         fmaxf(
91             1e-6f,
92             (HdotI *
93              fmaxf(
94                  NdotO,
95                  NdotI))); /* pump from original paper (first derivative disc., but cancels the HdotI in the pdf nicely) */
96     /*float pump = 1.0f / fmaxf(1e-4f, ((NdotO + NdotI) * (NdotO*NdotI))); */ /* pump from d-brdf paper */
97
98     float n_x = bsdf_ashikhmin_shirley_roughness_to_exponent(bsdf->alpha_x);
99     float n_y = bsdf_ashikhmin_shirley_roughness_to_exponent(bsdf->alpha_y);
100
101     if (n_x == n_y) {
102       /* isotropic */
103       float e = n_x;
104       float lobe = powf(HdotN, e);
105       float norm = (n_x + 1.0f) / (8.0f * M_PI_F);
106
107       out = NdotO * norm * lobe * pump;
108       *pdf =
109           norm * lobe /
110           HdotI; /* this is p_h / 4(H.I)  (conversion from 'wh measure' to 'wi measure', eq. 8 in paper) */
111     }
112     else {
113       /* anisotropic */
114       float3 X, Y;
115       make_orthonormals_tangent(N, bsdf->T, &X, &Y);
116
117       float HdotX = dot(H, X);
118       float HdotY = dot(H, Y);
119       float lobe;
120       if (HdotN < 1.0f) {
121         float e = (n_x * HdotX * HdotX + n_y * HdotY * HdotY) / (1.0f - HdotN * HdotN);
122         lobe = powf(HdotN, e);
123       }
124       else {
125         lobe = 1.0f;
126       }
127       float norm = sqrtf((n_x + 1.0f) * (n_y + 1.0f)) / (8.0f * M_PI_F);
128
129       out = NdotO * norm * lobe * pump;
130       *pdf = norm * lobe / HdotI;
131     }
132   }
133
134   return make_float3(out, out, out);
135 }
136
137 ccl_device float3 bsdf_ashikhmin_shirley_eval_transmit(const ShaderClosure *sc,
138                                                        const float3 I,
139                                                        const float3 omega_in,
140                                                        float *pdf)
141 {
142   return make_float3(0.0f, 0.0f, 0.0f);
143 }
144
145 ccl_device_inline void bsdf_ashikhmin_shirley_sample_first_quadrant(
146     float n_x, float n_y, float randu, float randv, float *phi, float *cos_theta)
147 {
148   *phi = atanf(sqrtf((n_x + 1.0f) / (n_y + 1.0f)) * tanf(M_PI_2_F * randu));
149   float cos_phi = cosf(*phi);
150   float sin_phi = sinf(*phi);
151   *cos_theta = powf(randv, 1.0f / (n_x * cos_phi * cos_phi + n_y * sin_phi * sin_phi + 1.0f));
152 }
153
154 ccl_device int bsdf_ashikhmin_shirley_sample(const ShaderClosure *sc,
155                                              float3 Ng,
156                                              float3 I,
157                                              float3 dIdx,
158                                              float3 dIdy,
159                                              float randu,
160                                              float randv,
161                                              float3 *eval,
162                                              float3 *omega_in,
163                                              float3 *domega_in_dx,
164                                              float3 *domega_in_dy,
165                                              float *pdf)
166 {
167   const MicrofacetBsdf *bsdf = (const MicrofacetBsdf *)sc;
168   float3 N = bsdf->N;
169   int label = LABEL_REFLECT | LABEL_GLOSSY;
170
171   float NdotI = dot(N, I);
172   if (NdotI > 0.0f) {
173
174     float n_x = bsdf_ashikhmin_shirley_roughness_to_exponent(bsdf->alpha_x);
175     float n_y = bsdf_ashikhmin_shirley_roughness_to_exponent(bsdf->alpha_y);
176
177     /* get x,y basis on the surface for anisotropy */
178     float3 X, Y;
179
180     if (n_x == n_y)
181       make_orthonormals(N, &X, &Y);
182     else
183       make_orthonormals_tangent(N, bsdf->T, &X, &Y);
184
185     /* sample spherical coords for h in tangent space */
186     float phi;
187     float cos_theta;
188     if (n_x == n_y) {
189       /* isotropic sampling */
190       phi = M_2PI_F * randu;
191       cos_theta = powf(randv, 1.0f / (n_x + 1.0f));
192     }
193     else {
194       /* anisotropic sampling */
195       if (randu < 0.25f) { /* first quadrant */
196         float remapped_randu = 4.0f * randu;
197         bsdf_ashikhmin_shirley_sample_first_quadrant(
198             n_x, n_y, remapped_randu, randv, &phi, &cos_theta);
199       }
200       else if (randu < 0.5f) { /* second quadrant */
201         float remapped_randu = 4.0f * (.5f - randu);
202         bsdf_ashikhmin_shirley_sample_first_quadrant(
203             n_x, n_y, remapped_randu, randv, &phi, &cos_theta);
204         phi = M_PI_F - phi;
205       }
206       else if (randu < 0.75f) { /* third quadrant */
207         float remapped_randu = 4.0f * (randu - 0.5f);
208         bsdf_ashikhmin_shirley_sample_first_quadrant(
209             n_x, n_y, remapped_randu, randv, &phi, &cos_theta);
210         phi = M_PI_F + phi;
211       }
212       else { /* fourth quadrant */
213         float remapped_randu = 4.0f * (1.0f - randu);
214         bsdf_ashikhmin_shirley_sample_first_quadrant(
215             n_x, n_y, remapped_randu, randv, &phi, &cos_theta);
216         phi = 2.0f * M_PI_F - phi;
217       }
218     }
219
220     /* get half vector in tangent space */
221     float sin_theta = sqrtf(fmaxf(0.0f, 1.0f - cos_theta * cos_theta));
222     float cos_phi = cosf(phi);
223     float sin_phi = sinf(phi); /* no sqrt(1-cos^2) here b/c it causes artifacts */
224     float3 h = make_float3(sin_theta * cos_phi, sin_theta * sin_phi, cos_theta);
225
226     /* half vector to world space */
227     float3 H = h.x * X + h.y * Y + h.z * N;
228     float HdotI = dot(H, I);
229     if (HdotI < 0.0f)
230       H = -H;
231
232     /* reflect I on H to get omega_in */
233     *omega_in = -I + (2.0f * HdotI) * H;
234
235     if (fmaxf(bsdf->alpha_x, bsdf->alpha_y) <= 1e-4f) {
236       /* Some high number for MIS. */
237       *pdf = 1e6f;
238       *eval = make_float3(1e6f, 1e6f, 1e6f);
239       label = LABEL_REFLECT | LABEL_SINGULAR;
240     }
241     else {
242       /* leave the rest to eval_reflect */
243       *eval = bsdf_ashikhmin_shirley_eval_reflect(sc, I, *omega_in, pdf);
244     }
245
246 #ifdef __RAY_DIFFERENTIALS__
247     /* just do the reflection thing for now */
248     *domega_in_dx = (2.0f * dot(N, dIdx)) * N - dIdx;
249     *domega_in_dy = (2.0f * dot(N, dIdy)) * N - dIdy;
250 #endif
251   }
252
253   return label;
254 }
255
256 CCL_NAMESPACE_END
257
258 #endif /* __BSDF_ASHIKHMIN_SHIRLEY_H__ */