a7f15de7325d246b5f8634b0afb82a03ade752be
[blender-staging.git] / intern / cycles / kernel / svm / svm_math_util.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 CCL_NAMESPACE_BEGIN
18
19 ccl_device float average_fac(float3 v)
20 {
21         return (fabsf(v.x) + fabsf(v.y) + fabsf(v.z))/3.0f;
22 }
23
24 ccl_device void svm_vector_math(float *Fac, float3 *Vector, NodeVectorMath type, float3 Vector1, float3 Vector2)
25 {
26         if(type == NODE_VECTOR_MATH_ADD) {
27                 *Vector = Vector1 + Vector2;
28                 *Fac = average_fac(*Vector);
29         }
30         else if(type == NODE_VECTOR_MATH_SUBTRACT) {
31                 *Vector = Vector1 - Vector2;
32                 *Fac = average_fac(*Vector);
33         }
34         else if(type == NODE_VECTOR_MATH_AVERAGE) {
35                 *Vector = safe_normalize_len(Vector1 + Vector2, Fac);
36         }
37         else if(type == NODE_VECTOR_MATH_DOT_PRODUCT) {
38                 *Fac = dot(Vector1, Vector2);
39                 *Vector = make_float3(0.0f, 0.0f, 0.0f);
40         }
41         else if(type == NODE_VECTOR_MATH_CROSS_PRODUCT) {
42                 *Vector = safe_normalize_len(cross(Vector1, Vector2), Fac);
43         }
44         else if(type == NODE_VECTOR_MATH_NORMALIZE) {
45                 *Vector = safe_normalize_len(Vector1, Fac);
46         }
47         else {
48                 *Fac = 0.0f;
49                 *Vector = make_float3(0.0f, 0.0f, 0.0f);
50         }
51 }
52
53 ccl_device float svm_math(NodeMath type, float Fac1, float Fac2)
54 {
55         float Fac;
56
57         if(type == NODE_MATH_ADD)
58                 Fac = Fac1 + Fac2;
59         else if(type == NODE_MATH_SUBTRACT)
60                 Fac = Fac1 - Fac2;
61         else if(type == NODE_MATH_MULTIPLY)
62                 Fac = Fac1*Fac2;
63         else if(type == NODE_MATH_DIVIDE)
64                 Fac = safe_divide(Fac1, Fac2);
65         else if(type == NODE_MATH_SINE)
66                 Fac = sinf(Fac1);
67         else if(type == NODE_MATH_COSINE)
68                 Fac = cosf(Fac1);
69         else if(type == NODE_MATH_TANGENT)
70                 Fac = tanf(Fac1);
71         else if(type == NODE_MATH_ARCSINE)
72                 Fac = safe_asinf(Fac1);
73         else if(type == NODE_MATH_ARCCOSINE)
74                 Fac = safe_acosf(Fac1);
75         else if(type == NODE_MATH_ARCTANGENT)
76                 Fac = atanf(Fac1);
77         else if(type == NODE_MATH_POWER)
78                 Fac = safe_powf(Fac1, Fac2);
79         else if(type == NODE_MATH_LOGARITHM)
80                 Fac = safe_logf(Fac1, Fac2);
81         else if(type == NODE_MATH_MINIMUM)
82                 Fac = fminf(Fac1, Fac2);
83         else if(type == NODE_MATH_MAXIMUM)
84                 Fac = fmaxf(Fac1, Fac2);
85         else if(type == NODE_MATH_ROUND)
86                 Fac = floorf(Fac1 + 0.5f);
87         else if(type == NODE_MATH_LESS_THAN)
88                 Fac = Fac1 < Fac2;
89         else if(type == NODE_MATH_GREATER_THAN)
90                 Fac = Fac1 > Fac2;
91         else if(type == NODE_MATH_MODULO)
92                 Fac = safe_modulo(Fac1, Fac2);
93         else if(type == NODE_MATH_ABSOLUTE)
94                 Fac = fabsf(Fac1);
95         else if(type == NODE_MATH_CLAMP)
96                 Fac = saturate(Fac1);
97         else
98                 Fac = 0.0f;
99         
100         return Fac;
101 }
102
103 ccl_device float3 svm_math_blackbody_color(float t) {
104         /* Calculate color in range 800..12000 using an approximation
105          * a/x+bx+c for R and G and ((at + b)t + c)t + d) for B
106          * Max absolute error for RGB is (0.00095, 0.00077, 0.00057),
107          * which is enough to get the same 8 bit/channel color.
108          */
109
110         const float rc[6][3] = {
111                 {  2.52432244e+03f, -1.06185848e-03f, 3.11067539e+00f },
112                 {  3.37763626e+03f, -4.34581697e-04f, 1.64843306e+00f },
113                 {  4.10671449e+03f, -8.61949938e-05f, 6.41423749e-01f },
114                 {  4.66849800e+03f,  2.85655028e-05f, 1.29075375e-01f },
115                 {  4.60124770e+03f,  2.89727618e-05f, 1.48001316e-01f },
116                 {  3.78765709e+03f,  9.36026367e-06f, 3.98995841e-01f },
117         };
118
119         const float gc[6][3] = {
120                 { -7.50343014e+02f,  3.15679613e-04f, 4.73464526e-01f },
121                 { -1.00402363e+03f,  1.29189794e-04f, 9.08181524e-01f },
122                 { -1.22075471e+03f,  2.56245413e-05f, 1.20753416e+00f },
123                 { -1.42546105e+03f, -4.01730887e-05f, 1.44002695e+00f },
124                 { -1.18134453e+03f, -2.18913373e-05f, 1.30656109e+00f },
125                 { -5.00279505e+02f, -4.59745390e-06f, 1.09090465e+00f },
126         };
127
128         const float bc[6][4] = {
129                 { 0.0f, 0.0f, 0.0f, 0.0f }, /* zeros should be optimized by compiler */
130                 { 0.0f, 0.0f, 0.0f, 0.0f },
131                 { 0.0f, 0.0f, 0.0f, 0.0f },
132                 { -2.02524603e-11f,  1.79435860e-07f, -2.60561875e-04f, -1.41761141e-02f },
133                 { -2.22463426e-13f, -1.55078698e-08f,  3.81675160e-04f, -7.30646033e-01f },
134                 {  6.72595954e-13f, -2.73059993e-08f,  4.24068546e-04f, -7.52204323e-01f },
135         };
136
137         int i;
138         if(t >= 12000.0f) {
139                 return make_float3(0.826270103f, 0.994478524f, 1.56626022f);
140         }
141         else if(t >= 6365.0f) {
142                 i = 5;
143         }
144         else if(t >= 3315.0f) {
145                 i = 4;
146         }
147         else if(t >= 1902.0f) {
148                 i = 3;
149         }
150         else if(t >= 1449.0f) {
151                 i = 2;
152         }
153         else if(t >= 1167.0f) {
154                 i = 1;
155         }
156         else if(t >= 965.0f) {
157                 i = 0;
158         }
159         else {
160                 /* For 800 <= t < 965 color does not change in OSL implementation, so keep color the same */
161                 return make_float3(4.70366907f, 0.0f, 0.0f);
162         }
163
164         const float t_inv = 1.0f / t;
165         return make_float3(rc[i][0] * t_inv + rc[i][1] * t + rc[i][2],
166                            gc[i][0] * t_inv + gc[i][1] * t + gc[i][2],
167                            ((bc[i][0] * t + bc[i][1]) * t + bc[i][2]) * t + bc[i][3]);
168 }
169
170 ccl_device_inline float3 svm_math_gamma_color(float3 color, float gamma)
171 {
172         if(gamma == 0.0f)
173                 return make_float3(1.0f, 1.0f, 1.0f);
174
175         if(color.x > 0.0f)
176                 color.x = powf(color.x, gamma);
177         if(color.y > 0.0f)
178                 color.y = powf(color.y, gamma);
179         if(color.z > 0.0f)
180                 color.z = powf(color.z, gamma);
181
182         return color;
183 }
184
185 CCL_NAMESPACE_END
186