Fix cycles backwards compatibility for specular_toon shader this actually needs
[blender.git] / intern / cycles / kernel / shaders / stdosl.h
1 /////////////////////////////////////////////////////////////////////////////
2 // Copyright (c) 2009-2010 Sony Pictures Imageworks Inc., et al.  All Rights Reserved.
3 //
4 // Redistribution and use in source and binary forms, with or without
5 // modification, are permitted provided that the following conditions are
6 // met:
7 // * Redistributions of source code must retain the above copyright
8 //   notice, this list of conditions and the following disclaimer.
9 // * Redistributions in binary form must reproduce the above copyright
10 //   notice, this list of conditions and the following disclaimer in the
11 //   documentation and/or other materials provided with the distribution.
12 // * Neither the name of Sony Pictures Imageworks nor the names of its
13 //   contributors may be used to endorse or promote products derived from
14 //   this software without specific prior written permission.
15 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
18 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
19 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
20 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
21 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
25 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 /////////////////////////////////////////////////////////////////////////////
27
28
29 #ifndef CCL_STDOSL_H
30 #define CCL_STDOSL_H
31
32
33 #ifndef M_PI
34 #define M_PI       3.1415926535897932        /* pi */
35 #define M_PI_2     1.5707963267948966        /* pi/2 */
36 #define M_PI_4     0.7853981633974483        /* pi/4 */
37 #define M_2_PI     0.6366197723675813        /* 2/pi */
38 #define M_2PI      6.2831853071795865        /* 2*pi */
39 #define M_4PI     12.566370614359173         /* 4*pi */
40 #define M_2_SQRTPI 1.1283791670955126        /* 2/sqrt(pi) */
41 #define M_E        2.7182818284590452        /* e (Euler's number) */
42 #define M_LN2      0.6931471805599453        /* ln(2) */
43 #define M_LN10     2.3025850929940457        /* ln(10) */
44 #define M_LOG2E    1.4426950408889634        /* log_2(e) */
45 #define M_LOG10E   0.4342944819032518        /* log_10(e) */
46 #define M_SQRT2    1.4142135623730950        /* sqrt(2) */
47 #define M_SQRT1_2  0.7071067811865475        /* 1/sqrt(2) */
48 #endif
49
50
51
52 // Declaration of built-in functions and closures
53 #define BUILTIN [[ int builtin = 1 ]]
54 #define BUILTIN_DERIV [[ int builtin = 1, int deriv = 1 ]]
55
56 #define PERCOMP1(name)                          \
57     normal name (normal x) BUILTIN;             \
58     vector name (vector x) BUILTIN;             \
59     point  name (point x) BUILTIN;              \
60     color  name (color x) BUILTIN;              \
61     float  name (float x) BUILTIN;
62
63 #define PERCOMP2(name)                          \
64     normal name (normal x, normal y) BUILTIN;   \
65     vector name (vector x, vector y) BUILTIN;   \
66     point  name (point x, point y) BUILTIN;     \
67     color  name (color x, color y) BUILTIN;     \
68     float  name (float x, float y) BUILTIN;
69
70 #define PERCOMP2F(name)                         \
71     normal name (normal x, float y) BUILTIN;    \
72     vector name (vector x, float y) BUILTIN;    \
73     point  name (point x, float y) BUILTIN;     \
74     color  name (color x, float y) BUILTIN;     \
75     float  name (float x, float y) BUILTIN;
76
77
78 // Basic math
79 normal degrees (normal x) { return x*(180.0/M_PI); }
80 vector degrees (vector x) { return x*(180.0/M_PI); }
81 point  degrees (point x)  { return x*(180.0/M_PI); }
82 color  degrees (color x)  { return x*(180.0/M_PI); }
83 float  degrees (float x)  { return x*(180.0/M_PI); }
84 normal radians (normal x) { return x*(M_PI/180.0); }
85 vector radians (vector x) { return x*(M_PI/180.0); }
86 point  radians (point x)  { return x*(M_PI/180.0); }
87 color  radians (color x)  { return x*(M_PI/180.0); }
88 float  radians (float x)  { return x*(M_PI/180.0); }
89 PERCOMP1 (cos)
90 PERCOMP1 (sin)
91 PERCOMP1 (tan)
92 PERCOMP1 (acos)
93 PERCOMP1 (asin)
94 PERCOMP1 (atan)
95 PERCOMP2 (atan2)
96 PERCOMP1 (cosh)
97 PERCOMP1 (sinh)
98 PERCOMP1 (tanh)
99 PERCOMP2F (pow)
100 PERCOMP1 (exp)
101 PERCOMP1 (exp2)
102 PERCOMP1 (expm1)
103 PERCOMP1 (log)
104 point  log (point a,  float b) { return log(a)/log(b); }
105 vector log (vector a, float b) { return log(a)/log(b); }
106 color  log (color a,  float b) { return log(a)/log(b); }
107 float  log (float a,  float b) { return log(a)/log(b); }
108 PERCOMP1 (log2)
109 PERCOMP1 (log10)
110 PERCOMP1 (logb)
111 PERCOMP1 (sqrt)
112 PERCOMP1 (inversesqrt)
113 float hypot (float a, float b) { return sqrt (a*a + b*b); }
114 float hypot (float a, float b, float c) { return sqrt (a*a + b*b + c*c); }
115 PERCOMP1 (abs)
116 int abs (int x) BUILTIN;
117 PERCOMP1 (fabs)
118 int fabs (int x) BUILTIN;
119 PERCOMP1 (sign)
120 PERCOMP1 (floor)
121 PERCOMP1 (ceil)
122 PERCOMP1 (round)
123 PERCOMP1 (trunc)
124 PERCOMP2 (fmod)
125 PERCOMP2F (fmod)
126 int    mod (int    a, int    b) { return a - b*(int)floor(a/b); }
127 point  mod (point  a, point  b) { return a - b*floor(a/b); }
128 vector mod (vector a, vector b) { return a - b*floor(a/b); }
129 normal mod (normal a, normal b) { return a - b*floor(a/b); }
130 color  mod (color  a, color  b) { return a - b*floor(a/b); }
131 point  mod (point  a, float  b) { return a - b*floor(a/b); }
132 vector mod (vector a, float  b) { return a - b*floor(a/b); }
133 normal mod (normal a, float  b) { return a - b*floor(a/b); }
134 color  mod (color  a, float  b) { return a - b*floor(a/b); }
135 float  mod (float  a, float  b) { return a - b*floor(a/b); }
136 PERCOMP2 (min)
137 PERCOMP2 (max)
138 normal clamp (normal x, normal minval, normal maxval) { return max(min(x,maxval),minval); }
139 vector clamp (vector x, vector minval, vector maxval) { return max(min(x,maxval),minval); }
140 point  clamp (point x, point minval, point maxval) { return max(min(x,maxval),minval); }
141 color  clamp (color x, color minval, color maxval) { return max(min(x,maxval),minval); }
142 float  clamp (float x, float minval, float maxval) { return max(min(x,maxval),minval); }
143 normal mix (normal x, normal y, normal a) { return x*(1-a) + y*a; }
144 normal mix (normal x, normal y, float  a) { return x*(1-a) + y*a; }
145 vector mix (vector x, vector y, vector a) { return x*(1-a) + y*a; }
146 vector mix (vector x, vector y, float  a) { return x*(1-a) + y*a; }
147 point  mix (point  x, point  y, point  a) { return x*(1-a) + y*a; }
148 point  mix (point  x, point  y, float  a) { return x*(1-a) + y*a; }
149 color  mix (color  x, color  y, color  a) { return x*(1-a) + y*a; }
150 color  mix (color  x, color  y, float  a) { return x*(1-a) + y*a; }
151 float  mix (float  x, float  y, float  a) { return x*(1-a) + y*a; }
152 int isnan (float x) BUILTIN;
153 int isinf (float x) BUILTIN;
154 int isfinite (float x) BUILTIN;
155 float erf (float x) BUILTIN;
156 float erfc (float x) BUILTIN;
157
158 // Vector functions
159
160 vector cross (vector a, vector b) BUILTIN;
161 float dot (vector a, vector b) BUILTIN;
162 float length (vector v) BUILTIN;
163 float distance (point a, point b) BUILTIN;
164 float distance (point a, point b, point q)
165 {
166     vector d = b - a;
167     float dd = dot(d, d);
168     if(dd == 0.0)
169         return distance(q, a);
170     float t = dot(q - a, d)/dd;
171     return distance(q, a + clamp(t, 0.0, 1.0)*d);
172 }
173 normal normalize (normal v) BUILTIN;
174 vector normalize (vector v) BUILTIN;
175 vector faceforward (vector N, vector I, vector Nref) BUILTIN;
176 vector faceforward (vector N, vector I) BUILTIN;
177 vector reflect (vector I, vector N) { return I - 2*dot(N,I)*N; }
178 vector refract (vector I, vector N, float eta) {
179     float IdotN = dot (I, N);
180     float k = 1 - eta*eta * (1 - IdotN*IdotN);
181     return (k < 0) ? vector(0,0,0) : (eta*I - N * (eta*IdotN + sqrt(k)));
182 }
183 void fresnel (vector I, normal N, float eta,
184               output float Kr, output float Kt,
185               output vector R, output vector T)
186 {
187     float sqr(float x) { return x*x; }
188     float c = dot(I, N);
189     if (c < 0)
190         c = -c;
191     R = reflect(I, N);
192     float g = 1.0 / sqr(eta) - 1.0 + c * c;
193     if (g >= 0.0) {
194         g = sqrt (g);
195         float beta = g - c;
196         float F = (c * (g+c) - 1.0) / (c * beta + 1.0);
197         F = 0.5 * (1.0 + sqr(F));
198         F *= sqr (beta / (g+c));
199         Kr = F;
200         Kt = (1.0 - Kr) * eta*eta;
201         // OPT: the following recomputes some of the above values, but it 
202         // gives us the same result as if the shader-writer called refract()
203         T = refract(I, N, eta);
204     } else {
205         // total internal reflection
206         Kr = 1.0;
207         Kt = 0.0;
208         T = vector (0,0,0);
209     }
210 }
211
212 void fresnel (vector I, normal N, float eta,
213               output float Kr, output float Kt)
214 {
215     vector R, T;
216     fresnel(I, N, eta, Kr, Kt, R, T);
217 }
218
219
220 normal transform (matrix Mto, normal p) BUILTIN;
221 vector transform (matrix Mto, vector p) BUILTIN;
222 point  transform (matrix Mto, point p) BUILTIN;
223 normal transform (string from, string to, normal p) BUILTIN;
224 vector transform (string from, string to, vector p) BUILTIN;
225 point  transform (string from, string to, point p) BUILTIN;
226 normal transform (string to, normal p) { return transform("common",to,p); }
227 vector transform (string to, vector p) { return transform("common",to,p); }
228 point  transform (string to, point p)  { return transform("common",to,p); }
229
230 float transformu (string tounits, float x) BUILTIN;
231 float transformu (string fromunits, string tounits, float x) BUILTIN;
232
233 point rotate (point p, float angle, point a, point b)
234 {
235     vector axis = normalize (b - a);
236     float cosang, sinang;
237     sincos (angle, sinang, cosang);
238     float cosang1 = 1.0 - cosang;
239     float x = axis[0], y = axis[1], z = axis[2];
240     matrix M = matrix (x * x + (1.0 - x * x) * cosang,
241                        x * y * cosang1 + z * sinang,
242                        x * z * cosang1 - y * sinang,
243                        0.0,
244                        x * y * cosang1 - z * sinang,
245                        y * y + (1.0 - y * y) * cosang,
246                        y * z * cosang1 + x * sinang,
247                        0.0,
248                        x * z * cosang1 + y * sinang,
249                        y * z * cosang1 - x * sinang,
250                        z * z + (1.0 - z * z) * cosang,
251                        0.0,
252                        0.0, 0.0, 0.0, 1.0);
253     return transform (M, p-a) + a;
254 }
255
256
257
258 // Color functions
259
260 float luminance (color c) BUILTIN;
261 color blackbody (float temperatureK) BUILTIN;
262 color wavelength_color (float wavelength_nm) BUILTIN;
263
264
265 color transformc (string to, color x)
266 {
267     color rgb_to_hsv (color rgb) {  // See Foley & van Dam
268         float r = rgb[0], g = rgb[1], b = rgb[2];
269         float mincomp = min (r, min (g, b));
270         float maxcomp = max (r, max (g, b));
271         float delta = maxcomp - mincomp;  // chroma
272         float h, s, v;
273         v = maxcomp;
274         if (maxcomp > 0)
275             s = delta / maxcomp;
276         else s = 0;
277         if (s <= 0)
278             h = 0;
279         else {
280             if      (r >= maxcomp) h = (g-b) / delta;
281             else if (g >= maxcomp) h = 2 + (b-r) / delta;
282             else                   h = 4 + (r-g) / delta;
283             h /= 6;
284             if (h < 0)
285                 h += 1;
286         }
287         return color (h, s, v);
288     }
289
290     color rgb_to_hsl (color rgb) {  // See Foley & van Dam
291         // First convert rgb to hsv, then to hsl
292         float minval = min (rgb[0], min (rgb[1], rgb[2]));
293         color hsv = rgb_to_hsv (rgb);
294         float maxval = hsv[2];   // v == maxval
295         float h = hsv[0], s, l = (minval+maxval) / 2;
296         if (minval == maxval)
297             s = 0;  // special 'achromatic' case, hue is 0
298         else if (l <= 0.5)
299             s = (maxval - minval) / (maxval + minval);
300         else
301             s = (maxval - minval) / (2 - maxval - minval);
302         return color (h, s, l);
303     }
304
305     color r;
306     if (to == "rgb" || to == "RGB")
307         r = x;
308     else if (to == "hsv")
309         r = rgb_to_hsv (x);
310     else if (to == "hsl")
311         r = rgb_to_hsl (x);
312     else if (to == "YIQ")
313         r = color (dot (vector(0.299,  0.587,  0.114), (vector)x),
314                    dot (vector(0.596, -0.275, -0.321), (vector)x),
315                    dot (vector(0.212, -0.523,  0.311), (vector)x));
316     else if (to == "XYZ")
317         r = color (dot (vector(0.412453, 0.357580, 0.180423), (vector)x),
318                    dot (vector(0.212671, 0.715160, 0.072169), (vector)x),
319                    dot (vector(0.019334, 0.119193, 0.950227), (vector)x));
320     else {
321         error ("Unknown color space \"%s\"", to);
322         r = x;
323     }
324     return r;
325 }
326
327
328 color transformc (string from, string to, color x)
329 {
330     color hsv_to_rgb (color c) { // Reference: Foley & van Dam
331         float h = c[0], s = c[1], v = c[2];
332         color r;
333         if (s < 0.0001) {
334             r = v;
335         } else {
336             h = 6 * (h - floor(h));  // expand to [0..6)
337             int hi = (int)h;
338             float f = h - hi;
339             float p = v * (1-s);
340             float q = v * (1-s*f);
341             float t = v * (1-s*(1-f));
342             if      (hi == 0) r = color (v, t, p);
343             else if (hi == 1) r = color (q, v, p);
344             else if (hi == 2) r = color (p, v, t);
345             else if (hi == 3) r = color (p, q, v);
346             else if (hi == 4) r = color (t, p, v);
347             else              r = color (v, p, q);
348         }
349         return r;
350     }
351
352     color hsl_to_rgb (color c) {
353         float h = c[0], s = c[1], l = c[2];
354         // Easiest to convert hsl -> hsv, then hsv -> RGB (per Foley & van Dam)
355         float v = (l <= 0.5) ? (l * (1 + s)) : (l * (1 - s) + s);
356         color r;
357         if (v <= 0) {
358             r = 0;
359         } else {
360             float min = 2 * l - v;
361             s = (v - min) / v;
362             r = hsv_to_rgb (color (h, s, v));
363         }
364         return r;
365     }
366
367     color r;
368     if (from == "rgb" || from == "RGB")
369         r = x;
370     else if (from == "hsv")
371         r = hsv_to_rgb (x);
372     else if (from == "hsl")
373         r = hsl_to_rgb (x);
374     else if (from == "YIQ")
375         r = color (dot (vector(1,  0.9557,  0.6199), (vector)x),
376                    dot (vector(1, -0.2716, -0.6469), (vector)x),
377                    dot (vector(1, -1.1082,  1.7051), (vector)x));
378     else if (from == "XYZ")
379         r = color (dot (vector( 3.240479, -1.537150, -0.498535), (vector)x),
380                    dot (vector(-0.969256,  1.875991,  0.041556), (vector)x),
381                    dot (vector( 0.055648, -0.204043,  1.057311), (vector)x));
382     else {
383         error ("Unknown color space \"%s\"", to);
384         r = x;
385     }
386     return transformc (to, r);
387 }
388
389  
390
391 // Matrix functions
392
393 float determinant (matrix m) BUILTIN;
394 matrix transpose (matrix m) BUILTIN;
395
396
397
398 // Pattern generation
399
400 float step (float edge, float x) BUILTIN;
401 color step (color edge, color x) BUILTIN;
402 point step (point edge, point x) BUILTIN;
403 vector step (vector edge, vector x) BUILTIN;
404 normal step (normal edge, normal x) BUILTIN;
405 float smoothstep (float edge0, float edge1, float x) BUILTIN;
406
407
408 // Derivatives and area operators
409
410
411 // Displacement functions
412
413
414 // String functions
415
416 int strlen (string s) BUILTIN;
417 int startswith (string s, string prefix) BUILTIN;
418 int endswith (string s, string suffix) BUILTIN;
419 string substr (string s, int start, int len) BUILTIN;
420 string substr (string s, int start) { return substr (s, start, strlen(s)); }
421 float strtof (string str) BUILTIN;
422 int strtoi (string str) BUILTIN;
423
424 // Define concat in terms of shorter concat
425 string concat (string a, string b, string c) {
426     return concat(concat(a,b), c);
427 }
428 string concat (string a, string b, string c, string d) {
429     return concat(concat(a,b,c), d);
430 }
431 string concat (string a, string b, string c, string d, string e) {
432     return concat(concat(a,b,c,d), e);
433 }
434 string concat (string a, string b, string c, string d, string e, string f) {
435     return concat(concat(a,b,c,d,e), f);
436 }
437
438
439 // Texture
440
441
442 // Closures
443
444 closure color diffuse(normal N) BUILTIN;
445 closure color oren_nayar(normal N, float sigma) BUILTIN;
446 closure color diffuse_ramp(normal N, color colors[8]) BUILTIN;
447 closure color phong_ramp(normal N, float exponent, color colors[8]) BUILTIN;
448 closure color diffuse_toon(normal N, float size, float smooth) BUILTIN;
449 closure color glossy_toon(normal N, float size, float smooth) BUILTIN;
450 closure color westin_backscatter(normal N, float roughness) BUILTIN;
451 closure color westin_sheen(normal N, float edginess) BUILTIN;
452 closure color translucent(normal N) BUILTIN;
453 closure color reflection(normal N) BUILTIN;
454 closure color refraction(normal N, float eta) BUILTIN;
455 closure color transparent() BUILTIN;
456 closure color microfacet_ggx(normal N, float ag) BUILTIN;
457 closure color microfacet_ggx_refraction(normal N, float ag, float eta) BUILTIN;
458 closure color microfacet_beckmann(normal N, float ab) BUILTIN;
459 closure color microfacet_beckmann_refraction(normal N, float ab, float eta) BUILTIN;
460 closure color ward(normal N, vector T,float ax, float ay) BUILTIN;
461 closure color ashikhmin_velvet(normal N, float sigma) BUILTIN;
462 closure color emission() BUILTIN;
463 closure color background() BUILTIN;
464 closure color holdout() BUILTIN;
465 closure color ambient_occlusion() BUILTIN;
466 closure color bssrdf_cubic(normal N, vector radius) BUILTIN;
467
468 // Backwards compatibility
469
470 closure color specular_toon(normal N, float size, float smooth) BUILTIN;
471
472 // Renderer state
473 int raytype (string typename) BUILTIN;
474 // the individual 'isFOOray' functions are deprecated
475 int iscameraray () { return raytype("camera"); }
476 int isdiffuseray () { return raytype("diffuse"); }
477 int isglossyray () { return raytype("glossy"); }
478 int isshadowray () { return raytype("shadow"); }
479 int getmatrix (string fromspace, string tospace, output matrix M) BUILTIN;
480 int getmatrix (string fromspace, output matrix M) {
481     return getmatrix (fromspace, "common", M);
482 }
483
484
485 // Miscellaneous
486
487
488
489
490 #undef BUILTIN
491 #undef BUILTIN_DERIV
492 #undef PERCOMP1
493 #undef PERCOMP2
494 #undef PERCOMP2F
495
496 #endif /* CCL_STDOSL_H */