1ff8f363b492e43833e6b12d30dc35258380068c
[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 int min (int a, int b) BUILTIN;
138 PERCOMP2 (max)
139 int max (int a, int b) BUILTIN;
140 normal clamp (normal x, normal minval, normal maxval) { return max(min(x,maxval),minval); }
141 vector clamp (vector x, vector minval, vector maxval) { return max(min(x,maxval),minval); }
142 point  clamp (point x, point minval, point maxval) { return max(min(x,maxval),minval); }
143 color  clamp (color x, color minval, color maxval) { return max(min(x,maxval),minval); }
144 float  clamp (float x, float minval, float maxval) { return max(min(x,maxval),minval); }
145 int    clamp (int x, int minval, int maxval) { return max(min(x,maxval),minval); }
146 #if 0
147 normal mix (normal x, normal y, normal a) { return x*(1-a) + y*a; }
148 normal mix (normal x, normal y, float  a) { return x*(1-a) + y*a; }
149 vector mix (vector x, vector y, vector a) { return x*(1-a) + y*a; }
150 vector mix (vector x, vector y, float  a) { return x*(1-a) + y*a; }
151 point  mix (point  x, point  y, point  a) { return x*(1-a) + y*a; }
152 point  mix (point  x, point  y, float  a) { return x*(1-a) + y*a; }
153 color  mix (color  x, color  y, color  a) { return x*(1-a) + y*a; }
154 color  mix (color  x, color  y, float  a) { return x*(1-a) + y*a; }
155 float  mix (float  x, float  y, float  a) { return x*(1-a) + y*a; }
156 #else
157 normal mix (normal x, normal y, normal a) BUILTIN;
158 normal mix (normal x, normal y, float  a) BUILTIN;
159 vector mix (vector x, vector y, vector a) BUILTIN;
160 vector mix (vector x, vector y, float  a) BUILTIN;
161 point  mix (point  x, point  y, point  a) BUILTIN;
162 point  mix (point  x, point  y, float  a) BUILTIN;
163 color  mix (color  x, color  y, color  a) BUILTIN;
164 color  mix (color  x, color  y, float  a) BUILTIN;
165 float  mix (float  x, float  y, float  a) BUILTIN;
166 #endif
167 int isnan (float x) BUILTIN;
168 int isinf (float x) BUILTIN;
169 int isfinite (float x) BUILTIN;
170 float erf (float x) BUILTIN;
171 float erfc (float x) BUILTIN;
172
173 // Vector functions
174
175 vector cross (vector a, vector b) BUILTIN;
176 float dot (vector a, vector b) BUILTIN;
177 float length (vector v) BUILTIN;
178 float distance (point a, point b) BUILTIN;
179 float distance (point a, point b, point q)
180 {
181     vector d = b - a;
182     float dd = dot(d, d);
183     if(dd == 0.0)
184         return distance(q, a);
185     float t = dot(q - a, d)/dd;
186     return distance(q, a + clamp(t, 0.0, 1.0)*d);
187 }
188 normal normalize (normal v) BUILTIN;
189 vector normalize (vector v) BUILTIN;
190 vector faceforward (vector N, vector I, vector Nref) BUILTIN;
191 vector faceforward (vector N, vector I) BUILTIN;
192 vector reflect (vector I, vector N) { return I - 2*dot(N,I)*N; }
193 vector refract (vector I, vector N, float eta) {
194     float IdotN = dot (I, N);
195     float k = 1 - eta*eta * (1 - IdotN*IdotN);
196     return (k < 0) ? vector(0,0,0) : (eta*I - N * (eta*IdotN + sqrt(k)));
197 }
198 void fresnel (vector I, normal N, float eta,
199               output float Kr, output float Kt,
200               output vector R, output vector T)
201 {
202     float sqr(float x) { return x*x; }
203     float c = dot(I, N);
204     if (c < 0)
205         c = -c;
206     R = reflect(I, N);
207     float g = 1.0 / sqr(eta) - 1.0 + c * c;
208     if (g >= 0.0) {
209         g = sqrt (g);
210         float beta = g - c;
211         float F = (c * (g+c) - 1.0) / (c * beta + 1.0);
212         F = 0.5 * (1.0 + sqr(F));
213         F *= sqr (beta / (g+c));
214         Kr = F;
215         Kt = (1.0 - Kr) * eta*eta;
216         // OPT: the following recomputes some of the above values, but it 
217         // gives us the same result as if the shader-writer called refract()
218         T = refract(I, N, eta);
219     } else {
220         // total internal reflection
221         Kr = 1.0;
222         Kt = 0.0;
223         T = vector (0,0,0);
224     }
225 }
226
227 void fresnel (vector I, normal N, float eta,
228               output float Kr, output float Kt)
229 {
230     vector R, T;
231     fresnel(I, N, eta, Kr, Kt, R, T);
232 }
233
234
235 normal transform (matrix Mto, normal p) BUILTIN;
236 vector transform (matrix Mto, vector p) BUILTIN;
237 point  transform (matrix Mto, point p) BUILTIN;
238 normal transform (string from, string to, normal p) BUILTIN;
239 vector transform (string from, string to, vector p) BUILTIN;
240 point  transform (string from, string to, point p) BUILTIN;
241 normal transform (string to, normal p) { return transform("common",to,p); }
242 vector transform (string to, vector p) { return transform("common",to,p); }
243 point  transform (string to, point p)  { return transform("common",to,p); }
244
245 float transformu (string tounits, float x) BUILTIN;
246 float transformu (string fromunits, string tounits, float x) BUILTIN;
247
248 point rotate (point p, float angle, point a, point b)
249 {
250     vector axis = normalize (b - a);
251     float cosang, sinang;
252     sincos (angle, sinang, cosang);
253     float cosang1 = 1.0 - cosang;
254     float x = axis[0], y = axis[1], z = axis[2];
255     matrix M = matrix (x * x + (1.0 - x * x) * cosang,
256                        x * y * cosang1 + z * sinang,
257                        x * z * cosang1 - y * sinang,
258                        0.0,
259                        x * y * cosang1 - z * sinang,
260                        y * y + (1.0 - y * y) * cosang,
261                        y * z * cosang1 + x * sinang,
262                        0.0,
263                        x * z * cosang1 + y * sinang,
264                        y * z * cosang1 - x * sinang,
265                        z * z + (1.0 - z * z) * cosang,
266                        0.0,
267                        0.0, 0.0, 0.0, 1.0);
268     return transform (M, p-a) + a;
269 }
270
271
272
273 // Color functions
274
275 float luminance (color c) BUILTIN;
276 color blackbody (float temperatureK) BUILTIN;
277 color wavelength_color (float wavelength_nm) BUILTIN;
278
279
280 color transformc (string to, color x)
281 {
282     color rgb_to_hsv (color rgb) {  // See Foley & van Dam
283         float r = rgb[0], g = rgb[1], b = rgb[2];
284         float mincomp = min (r, min (g, b));
285         float maxcomp = max (r, max (g, b));
286         float delta = maxcomp - mincomp;  // chroma
287         float h, s, v;
288         v = maxcomp;
289         if (maxcomp > 0)
290             s = delta / maxcomp;
291         else s = 0;
292         if (s <= 0)
293             h = 0;
294         else {
295             if      (r >= maxcomp) h = (g-b) / delta;
296             else if (g >= maxcomp) h = 2 + (b-r) / delta;
297             else                   h = 4 + (r-g) / delta;
298             h /= 6;
299             if (h < 0)
300                 h += 1;
301         }
302         return color (h, s, v);
303     }
304
305     color rgb_to_hsl (color rgb) {  // See Foley & van Dam
306         // First convert rgb to hsv, then to hsl
307         float minval = min (rgb[0], min (rgb[1], rgb[2]));
308         color hsv = rgb_to_hsv (rgb);
309         float maxval = hsv[2];   // v == maxval
310         float h = hsv[0], s, l = (minval+maxval) / 2;
311         if (minval == maxval)
312             s = 0;  // special 'achromatic' case, hue is 0
313         else if (l <= 0.5)
314             s = (maxval - minval) / (maxval + minval);
315         else
316             s = (maxval - minval) / (2 - maxval - minval);
317         return color (h, s, l);
318     }
319
320     color r;
321     if (to == "rgb" || to == "RGB")
322         r = x;
323     else if (to == "hsv")
324         r = rgb_to_hsv (x);
325     else if (to == "hsl")
326         r = rgb_to_hsl (x);
327     else if (to == "YIQ")
328         r = color (dot (vector(0.299,  0.587,  0.114), (vector)x),
329                    dot (vector(0.596, -0.275, -0.321), (vector)x),
330                    dot (vector(0.212, -0.523,  0.311), (vector)x));
331     else if (to == "XYZ")
332         r = color (dot (vector(0.412453, 0.357580, 0.180423), (vector)x),
333                    dot (vector(0.212671, 0.715160, 0.072169), (vector)x),
334                    dot (vector(0.019334, 0.119193, 0.950227), (vector)x));
335     else {
336         error ("Unknown color space \"%s\"", to);
337         r = x;
338     }
339     return r;
340 }
341
342
343 color transformc (string from, string to, color x)
344 {
345     color hsv_to_rgb (color c) { // Reference: Foley & van Dam
346         float h = c[0], s = c[1], v = c[2];
347         color r;
348         if (s < 0.0001) {
349             r = v;
350         } else {
351             h = 6 * (h - floor(h));  // expand to [0..6)
352             int hi = (int)h;
353             float f = h - hi;
354             float p = v * (1-s);
355             float q = v * (1-s*f);
356             float t = v * (1-s*(1-f));
357             if      (hi == 0) r = color (v, t, p);
358             else if (hi == 1) r = color (q, v, p);
359             else if (hi == 2) r = color (p, v, t);
360             else if (hi == 3) r = color (p, q, v);
361             else if (hi == 4) r = color (t, p, v);
362             else              r = color (v, p, q);
363         }
364         return r;
365     }
366
367     color hsl_to_rgb (color c) {
368         float h = c[0], s = c[1], l = c[2];
369         // Easiest to convert hsl -> hsv, then hsv -> RGB (per Foley & van Dam)
370         float v = (l <= 0.5) ? (l * (1 + s)) : (l * (1 - s) + s);
371         color r;
372         if (v <= 0) {
373             r = 0;
374         } else {
375             float min = 2 * l - v;
376             s = (v - min) / v;
377             r = hsv_to_rgb (color (h, s, v));
378         }
379         return r;
380     }
381
382     color r;
383     if (from == "rgb" || from == "RGB")
384         r = x;
385     else if (from == "hsv")
386         r = hsv_to_rgb (x);
387     else if (from == "hsl")
388         r = hsl_to_rgb (x);
389     else if (from == "YIQ")
390         r = color (dot (vector(1,  0.9557,  0.6199), (vector)x),
391                    dot (vector(1, -0.2716, -0.6469), (vector)x),
392                    dot (vector(1, -1.1082,  1.7051), (vector)x));
393     else if (from == "XYZ")
394         r = color (dot (vector( 3.240479, -1.537150, -0.498535), (vector)x),
395                    dot (vector(-0.969256,  1.875991,  0.041556), (vector)x),
396                    dot (vector( 0.055648, -0.204043,  1.057311), (vector)x));
397     else {
398         error ("Unknown color space \"%s\"", to);
399         r = x;
400     }
401     return transformc (to, r);
402 }
403
404  
405
406 // Matrix functions
407
408 float determinant (matrix m) BUILTIN;
409 matrix transpose (matrix m) BUILTIN;
410
411
412
413 // Pattern generation
414
415 color step (color edge, color x) BUILTIN;
416 point step (point edge, point x) BUILTIN;
417 vector step (vector edge, vector x) BUILTIN;
418 normal step (normal edge, normal x) BUILTIN;
419 float step (float edge, float x) BUILTIN;
420 float smoothstep (float edge0, float edge1, float x) BUILTIN;
421
422 float aastep (float edge, float s, float dedge, float ds) {
423     // Box filtered AA step
424     float width = fabs(dedge) + fabs(ds);
425     float halfwidth = 0.5*width;
426     float e1 = edge-halfwidth;
427     return (s <= e1) ? 0.0 : ((s >= (edge+halfwidth)) ? 1.0 : (s-e1)/width);
428 }
429 float aastep (float edge, float s, float ds) {
430     return aastep (edge, s, filterwidth(edge), ds);
431 }
432 float aastep (float edge, float s) {
433     return aastep (edge, s, filterwidth(edge), filterwidth(s));
434 }
435
436
437 // Derivatives and area operators
438
439
440 // Displacement functions
441
442
443 // String functions
444
445 int strlen (string s) BUILTIN;
446 int startswith (string s, string prefix) BUILTIN;
447 int endswith (string s, string suffix) BUILTIN;
448 string substr (string s, int start, int len) BUILTIN;
449 string substr (string s, int start) { return substr (s, start, strlen(s)); }
450 float stof (string str) BUILTIN;
451 int stoi (string str) BUILTIN;
452
453 // Define concat in terms of shorter concat
454 string concat (string a, string b, string c) {
455     return concat(concat(a,b), c);
456 }
457 string concat (string a, string b, string c, string d) {
458     return concat(concat(a,b,c), d);
459 }
460 string concat (string a, string b, string c, string d, string e) {
461     return concat(concat(a,b,c,d), e);
462 }
463 string concat (string a, string b, string c, string d, string e, string f) {
464     return concat(concat(a,b,c,d,e), f);
465 }
466
467
468 // Texture
469
470
471 // Closures
472
473 closure color diffuse(normal N) BUILTIN;
474 closure color oren_nayar(normal N, float sigma) BUILTIN;
475 closure color diffuse_ramp(normal N, color colors[8]) BUILTIN;
476 closure color phong_ramp(normal N, float exponent, color colors[8]) BUILTIN;
477 closure color diffuse_toon(normal N, float size, float smooth) BUILTIN;
478 closure color glossy_toon(normal N, float size, float smooth) BUILTIN;
479 closure color translucent(normal N) BUILTIN;
480 closure color reflection(normal N) BUILTIN;
481 closure color refraction(normal N, float eta) BUILTIN;
482 closure color transparent() BUILTIN;
483 closure color microfacet_ggx(normal N, float ag) BUILTIN;
484 closure color microfacet_ggx_aniso(normal N, vector T, float ax, float ay) BUILTIN;
485 closure color microfacet_ggx_refraction(normal N, float ag, float eta) BUILTIN;
486 closure color microfacet_beckmann(normal N, float ab) BUILTIN;
487 closure color microfacet_beckmann_aniso(normal N, vector T, float ax, float ay) BUILTIN;
488 closure color microfacet_beckmann_refraction(normal N, float ab, float eta) BUILTIN;
489 closure color ashikhmin_shirley(normal N, vector T,float ax, float ay) BUILTIN;
490 closure color ashikhmin_velvet(normal N, float sigma) BUILTIN;
491 closure color emission() BUILTIN;
492 closure color background() BUILTIN;
493 closure color holdout() BUILTIN;
494 closure color ambient_occlusion() BUILTIN;
495
496 // BSSRDF
497 closure color bssrdf_cubic(normal N, vector radius, float texture_blur, float sharpness) BUILTIN;
498 closure color bssrdf_gaussian(normal N, vector radius, float texture_blur) BUILTIN;
499
500 // Hair
501 closure color hair_reflection(normal N, float roughnessu, float roughnessv, vector T, float offset) BUILTIN;
502 closure color hair_transmission(normal N, float roughnessu, float roughnessv, vector T, float offset) BUILTIN;
503
504 // Volume
505 closure color henyey_greenstein(float g) BUILTIN;
506 closure color absorption() BUILTIN;
507
508 // Renderer state
509 int backfacing () BUILTIN;
510 int raytype (string typename) BUILTIN;
511 // the individual 'isFOOray' functions are deprecated
512 int iscameraray () { return raytype("camera"); }
513 int isdiffuseray () { return raytype("diffuse"); }
514 int isglossyray () { return raytype("glossy"); }
515 int isshadowray () { return raytype("shadow"); }
516 int getmatrix (string fromspace, string tospace, output matrix M) BUILTIN;
517 int getmatrix (string fromspace, output matrix M) {
518     return getmatrix (fromspace, "common", M);
519 }
520
521
522 // Miscellaneous
523
524
525
526
527 #undef BUILTIN
528 #undef BUILTIN_DERIV
529 #undef PERCOMP1
530 #undef PERCOMP2
531 #undef PERCOMP2F
532
533 #endif /* CCL_STDOSL_H */