ClangFormat: apply to source, most of intern
[blender.git] / intern / cycles / kernel / kernel_differential.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 CCL_NAMESPACE_BEGIN
18
19 /* See "Tracing Ray Differentials", Homan Igehy, 1999. */
20
21 ccl_device void differential_transfer(ccl_addr_space differential3 *dP_,
22                                       const differential3 dP,
23                                       float3 D,
24                                       const differential3 dD,
25                                       float3 Ng,
26                                       float t)
27 {
28   /* ray differential transfer through homogeneous medium, to
29    * compute dPdx/dy at a shading point from the incoming ray */
30
31   float3 tmp = D / dot(D, Ng);
32   float3 tmpx = dP.dx + t * dD.dx;
33   float3 tmpy = dP.dy + t * dD.dy;
34
35   dP_->dx = tmpx - dot(tmpx, Ng) * tmp;
36   dP_->dy = tmpy - dot(tmpy, Ng) * tmp;
37 }
38
39 ccl_device void differential_incoming(ccl_addr_space differential3 *dI, const differential3 dD)
40 {
41   /* compute dIdx/dy at a shading point, we just need to negate the
42    * differential of the ray direction */
43
44   dI->dx = -dD.dx;
45   dI->dy = -dD.dy;
46 }
47
48 ccl_device void differential_dudv(ccl_addr_space differential *du,
49                                   ccl_addr_space differential *dv,
50                                   float3 dPdu,
51                                   float3 dPdv,
52                                   differential3 dP,
53                                   float3 Ng)
54 {
55   /* now we have dPdx/dy from the ray differential transfer, and dPdu/dv
56    * from the primitive, we can compute dudx/dy and dvdx/dy. these are
57    * mainly used for differentials of arbitrary mesh attributes. */
58
59   /* find most stable axis to project to 2D */
60   float xn = fabsf(Ng.x);
61   float yn = fabsf(Ng.y);
62   float zn = fabsf(Ng.z);
63
64   if (zn < xn || zn < yn) {
65     if (yn < xn || yn < zn) {
66       dPdu.x = dPdu.y;
67       dPdv.x = dPdv.y;
68       dP.dx.x = dP.dx.y;
69       dP.dy.x = dP.dy.y;
70     }
71
72     dPdu.y = dPdu.z;
73     dPdv.y = dPdv.z;
74     dP.dx.y = dP.dx.z;
75     dP.dy.y = dP.dy.z;
76   }
77
78   /* using Cramer's rule, we solve for dudx and dvdx in a 2x2 linear system,
79    * and the same for dudy and dvdy. the denominator is the same for both
80    * solutions, so we compute it only once.
81    *
82    * dP.dx = dPdu * dudx + dPdv * dvdx;
83    * dP.dy = dPdu * dudy + dPdv * dvdy; */
84
85   float det = (dPdu.x * dPdv.y - dPdv.x * dPdu.y);
86
87   if (det != 0.0f)
88     det = 1.0f / det;
89
90   du->dx = (dP.dx.x * dPdv.y - dP.dx.y * dPdv.x) * det;
91   dv->dx = (dP.dx.y * dPdu.x - dP.dx.x * dPdu.y) * det;
92
93   du->dy = (dP.dy.x * dPdv.y - dP.dy.y * dPdv.x) * det;
94   dv->dy = (dP.dy.y * dPdu.x - dP.dy.x * dPdu.y) * det;
95 }
96
97 ccl_device differential differential_zero()
98 {
99   differential d;
100   d.dx = 0.0f;
101   d.dy = 0.0f;
102
103   return d;
104 }
105
106 ccl_device differential3 differential3_zero()
107 {
108   differential3 d;
109   d.dx = make_float3(0.0f, 0.0f, 0.0f);
110   d.dy = make_float3(0.0f, 0.0f, 0.0f);
111
112   return d;
113 }
114
115 CCL_NAMESPACE_END