Remove redundant check for armature mode
[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     /* Older OSX has major issues with sincos() function,
253      * it's likely a big in OSL or LLVM. For until we've
254      * updated to new versions of this libraries we'll
255      * use a workaround to prevent possible crashes on all
256      * the platforms.
257      *
258      * Shouldn't be that bad because it's mainly used for
259      * anisotropic shader where angle is usually constant.
260      */
261 #if 0
262     sincos (angle, sinang, cosang);
263 #else
264     sinang = sin (angle);
265     cosang = cos (angle);
266 #endif
267     float cosang1 = 1.0 - cosang;
268     float x = axis[0], y = axis[1], z = axis[2];
269     matrix M = matrix (x * x + (1.0 - x * x) * cosang,
270                        x * y * cosang1 + z * sinang,
271                        x * z * cosang1 - y * sinang,
272                        0.0,
273                        x * y * cosang1 - z * sinang,
274                        y * y + (1.0 - y * y) * cosang,
275                        y * z * cosang1 + x * sinang,
276                        0.0,
277                        x * z * cosang1 + y * sinang,
278                        y * z * cosang1 - x * sinang,
279                        z * z + (1.0 - z * z) * cosang,
280                        0.0,
281                        0.0, 0.0, 0.0, 1.0);
282     return transform (M, p-a) + a;
283 }
284
285
286
287 // Color functions
288
289 float luminance (color c) BUILTIN;
290 color blackbody (float temperatureK) BUILTIN;
291 color wavelength_color (float wavelength_nm) BUILTIN;
292
293
294 color transformc (string to, color x)
295 {
296     color rgb_to_hsv (color rgb) {  // See Foley & van Dam
297         float r = rgb[0], g = rgb[1], b = rgb[2];
298         float mincomp = min (r, min (g, b));
299         float maxcomp = max (r, max (g, b));
300         float delta = maxcomp - mincomp;  // chroma
301         float h, s, v;
302         v = maxcomp;
303         if (maxcomp > 0)
304             s = delta / maxcomp;
305         else s = 0;
306         if (s <= 0)
307             h = 0;
308         else {
309             if      (r >= maxcomp) h = (g-b) / delta;
310             else if (g >= maxcomp) h = 2 + (b-r) / delta;
311             else                   h = 4 + (r-g) / delta;
312             h /= 6;
313             if (h < 0)
314                 h += 1;
315         }
316         return color (h, s, v);
317     }
318
319     color rgb_to_hsl (color rgb) {  // See Foley & van Dam
320         // First convert rgb to hsv, then to hsl
321         float minval = min (rgb[0], min (rgb[1], rgb[2]));
322         color hsv = rgb_to_hsv (rgb);
323         float maxval = hsv[2];   // v == maxval
324         float h = hsv[0], s, l = (minval+maxval) / 2;
325         if (minval == maxval)
326             s = 0;  // special 'achromatic' case, hue is 0
327         else if (l <= 0.5)
328             s = (maxval - minval) / (maxval + minval);
329         else
330             s = (maxval - minval) / (2 - maxval - minval);
331         return color (h, s, l);
332     }
333
334     color r;
335     if (to == "rgb" || to == "RGB")
336         r = x;
337     else if (to == "hsv")
338         r = rgb_to_hsv (x);
339     else if (to == "hsl")
340         r = rgb_to_hsl (x);
341     else if (to == "YIQ")
342         r = color (dot (vector(0.299,  0.587,  0.114), (vector)x),
343                    dot (vector(0.596, -0.275, -0.321), (vector)x),
344                    dot (vector(0.212, -0.523,  0.311), (vector)x));
345     else if (to == "XYZ")
346         r = color (dot (vector(0.412453, 0.357580, 0.180423), (vector)x),
347                    dot (vector(0.212671, 0.715160, 0.072169), (vector)x),
348                    dot (vector(0.019334, 0.119193, 0.950227), (vector)x));
349     else {
350         error ("Unknown color space \"%s\"", to);
351         r = x;
352     }
353     return r;
354 }
355
356
357 color transformc (string from, string to, color x)
358 {
359     color hsv_to_rgb (color c) { // Reference: Foley & van Dam
360         float h = c[0], s = c[1], v = c[2];
361         color r;
362         if (s < 0.0001) {
363             r = v;
364         } else {
365             h = 6 * (h - floor(h));  // expand to [0..6)
366             int hi = (int)h;
367             float f = h - hi;
368             float p = v * (1-s);
369             float q = v * (1-s*f);
370             float t = v * (1-s*(1-f));
371             if      (hi == 0) r = color (v, t, p);
372             else if (hi == 1) r = color (q, v, p);
373             else if (hi == 2) r = color (p, v, t);
374             else if (hi == 3) r = color (p, q, v);
375             else if (hi == 4) r = color (t, p, v);
376             else              r = color (v, p, q);
377         }
378         return r;
379     }
380
381     color hsl_to_rgb (color c) {
382         float h = c[0], s = c[1], l = c[2];
383         // Easiest to convert hsl -> hsv, then hsv -> RGB (per Foley & van Dam)
384         float v = (l <= 0.5) ? (l * (1 + s)) : (l * (1 - s) + s);
385         color r;
386         if (v <= 0) {
387             r = 0;
388         } else {
389             float min = 2 * l - v;
390             s = (v - min) / v;
391             r = hsv_to_rgb (color (h, s, v));
392         }
393         return r;
394     }
395
396     color r;
397     if (from == "rgb" || from == "RGB")
398         r = x;
399     else if (from == "hsv")
400         r = hsv_to_rgb (x);
401     else if (from == "hsl")
402         r = hsl_to_rgb (x);
403     else if (from == "YIQ")
404         r = color (dot (vector(1,  0.9557,  0.6199), (vector)x),
405                    dot (vector(1, -0.2716, -0.6469), (vector)x),
406                    dot (vector(1, -1.1082,  1.7051), (vector)x));
407     else if (from == "XYZ")
408         r = color (dot (vector( 3.240479, -1.537150, -0.498535), (vector)x),
409                    dot (vector(-0.969256,  1.875991,  0.041556), (vector)x),
410                    dot (vector( 0.055648, -0.204043,  1.057311), (vector)x));
411     else {
412         error ("Unknown color space \"%s\"", to);
413         r = x;
414     }
415     return transformc (to, r);
416 }
417
418  
419
420 // Matrix functions
421
422 float determinant (matrix m) BUILTIN;
423 matrix transpose (matrix m) BUILTIN;
424
425
426
427 // Pattern generation
428
429 color step (color edge, color x) BUILTIN;
430 point step (point edge, point x) BUILTIN;
431 vector step (vector edge, vector x) BUILTIN;
432 normal step (normal edge, normal x) BUILTIN;
433 float step (float edge, float x) BUILTIN;
434 float smoothstep (float edge0, float edge1, float x) BUILTIN;
435
436 float linearstep (float edge0, float edge1, float x) {
437     float result;
438     if (edge0 != edge1) {
439         float xclamped = clamp (x, edge0, edge1);
440         result = (xclamped - edge0) / (edge1 - edge0);
441     } else {  // special case: edges coincide
442         result = step (edge0, x);
443     }
444     return result;
445 }
446
447 float smooth_linearstep (float edge0, float edge1, float x_, float eps_) {
448     float result;
449     if (edge0 != edge1) {
450         float rampup (float x, float r) { return 0.5/r * x*x; }
451         float width_inv = 1.0 / (edge1 - edge0);
452         float eps = eps_ * width_inv;
453         float x = (x_ - edge0) * width_inv;
454         if      (x <= -eps)                result = 0;
455         else if (x >= eps && x <= 1.0-eps) result = x;
456         else if (x >= 1.0+eps)             result = 1;
457         else if (x < eps)                  result = rampup (x+eps, 2.0*eps);
458         else /* if (x < 1.0+eps) */        result = 1.0 - rampup (1.0+eps - x, 2.0*eps);
459     } else {
460         result = step (edge0, x_);
461     }
462     return result;
463 }
464
465 float aastep (float edge, float s, float dedge, float ds) {
466     // Box filtered AA step
467     float width = fabs(dedge) + fabs(ds);
468     float halfwidth = 0.5*width;
469     float e1 = edge-halfwidth;
470     return (s <= e1) ? 0.0 : ((s >= (edge+halfwidth)) ? 1.0 : (s-e1)/width);
471 }
472 float aastep (float edge, float s, float ds) {
473     return aastep (edge, s, filterwidth(edge), ds);
474 }
475 float aastep (float edge, float s) {
476     return aastep (edge, s, filterwidth(edge), filterwidth(s));
477 }
478
479
480 // Derivatives and area operators
481
482
483 // Displacement functions
484
485
486 // String functions
487 int strlen (string s) BUILTIN;
488 int hash (string s) BUILTIN;
489 int getchar (string s, int index) BUILTIN;
490 int startswith (string s, string prefix) BUILTIN;
491 int endswith (string s, string suffix) BUILTIN;
492 string substr (string s, int start, int len) BUILTIN;
493 string substr (string s, int start) { return substr (s, start, strlen(s)); }
494 float stof (string str) BUILTIN;
495 int stoi (string str) BUILTIN;
496
497 // Define concat in terms of shorter concat
498 string concat (string a, string b, string c) {
499     return concat(concat(a,b), c);
500 }
501 string concat (string a, string b, string c, string d) {
502     return concat(concat(a,b,c), d);
503 }
504 string concat (string a, string b, string c, string d, string e) {
505     return concat(concat(a,b,c,d), e);
506 }
507 string concat (string a, string b, string c, string d, string e, string f) {
508     return concat(concat(a,b,c,d,e), f);
509 }
510
511
512 // Texture
513
514
515 // Closures
516
517 closure color diffuse(normal N) BUILTIN;
518 closure color oren_nayar(normal N, float sigma) BUILTIN;
519 closure color diffuse_ramp(normal N, color colors[8]) BUILTIN;
520 closure color phong_ramp(normal N, float exponent, color colors[8]) BUILTIN;
521 closure color diffuse_toon(normal N, float size, float smooth) BUILTIN;
522 closure color glossy_toon(normal N, float size, float smooth) BUILTIN;
523 closure color translucent(normal N) BUILTIN;
524 closure color reflection(normal N) BUILTIN;
525 closure color refraction(normal N, float eta) BUILTIN;
526 closure color transparent() BUILTIN;
527 closure color microfacet_ggx(normal N, float ag) BUILTIN;
528 closure color microfacet_ggx_aniso(normal N, vector T, float ax, float ay) BUILTIN;
529 closure color microfacet_ggx_refraction(normal N, float ag, float eta) BUILTIN;
530 closure color microfacet_multi_ggx(normal N, float ag, color C) BUILTIN;
531 closure color microfacet_multi_ggx_aniso(normal N, vector T, float ax, float ay, color C) BUILTIN;
532 closure color microfacet_multi_ggx_glass(normal N, float ag, float eta, color C) BUILTIN;
533 closure color microfacet_ggx_fresnel(normal N, float ag, float eta, color C, color Cspec0) BUILTIN;
534 closure color microfacet_ggx_aniso_fresnel(normal N, vector T, float ax, float ay, float eta, color C, color Cspec0) BUILTIN;
535 closure color microfacet_multi_ggx_fresnel(normal N, float ag, float eta, color C, color Cspec0) BUILTIN;
536 closure color microfacet_multi_ggx_aniso_fresnel(normal N, vector T, float ax, float ay, float eta, color C, color Cspec0) BUILTIN;
537 closure color microfacet_multi_ggx_glass_fresnel(normal N, float ag, float eta, color C, color Cspec0) BUILTIN;
538 closure color microfacet_beckmann(normal N, float ab) BUILTIN;
539 closure color microfacet_beckmann_aniso(normal N, vector T, float ax, float ay) BUILTIN;
540 closure color microfacet_beckmann_refraction(normal N, float ab, float eta) BUILTIN;
541 closure color ashikhmin_shirley(normal N, vector T,float ax, float ay) BUILTIN;
542 closure color ashikhmin_velvet(normal N, float sigma) BUILTIN;
543 closure color emission() BUILTIN;
544 closure color background() BUILTIN;
545 closure color holdout() BUILTIN;
546 closure color ambient_occlusion() BUILTIN;
547 closure color principled_diffuse(normal N, float roughness) BUILTIN;
548 closure color principled_sheen(normal N) BUILTIN;
549 closure color principled_clearcoat(normal N, float clearcoat, float clearcoat_roughness) BUILTIN;
550
551 // BSSRDF
552 closure color bssrdf_cubic(normal N, vector radius, float texture_blur, float sharpness) BUILTIN;
553 closure color bssrdf_gaussian(normal N, vector radius, float texture_blur) BUILTIN;
554 closure color bssrdf_burley(normal N, vector radius, float texture_blur, color albedo) BUILTIN;
555 closure color bssrdf_principled(normal N, vector radius, float texture_blur, color subsurface_color, float roughness) BUILTIN;
556
557 // Hair
558 closure color hair_reflection(normal N, float roughnessu, float roughnessv, vector T, float offset) BUILTIN;
559 closure color hair_transmission(normal N, float roughnessu, float roughnessv, vector T, float offset) BUILTIN;
560
561 // Volume
562 closure color henyey_greenstein(float g) BUILTIN;
563 closure color absorption() BUILTIN;
564
565 // OSL 1.5 Microfacet functions
566 closure color microfacet(string distribution, normal N, vector U, float xalpha, float yalpha, float eta, int refract) {
567         /* GGX */
568         if (distribution == "ggx" || distribution == "default") {
569                 if (!refract) {
570                         if (xalpha == yalpha) {
571                                 /* Isotropic */
572                                 return microfacet_ggx(N, xalpha);
573                         }
574                         else {
575                                 /* Anisotropic */
576                                 return microfacet_ggx_aniso(N, U, xalpha, yalpha);
577                         }
578                 }
579                 else {
580                         return microfacet_ggx_refraction(N, xalpha, eta);
581                 }
582         }
583         /* Beckmann */
584         else {
585                 if (!refract) {
586                         if (xalpha == yalpha) {
587                                 /* Isotropic */
588                                 return microfacet_beckmann(N, xalpha);
589                         }
590                         else {
591                                 /* Anisotropic */
592                                 return microfacet_beckmann_aniso(N, U, xalpha, yalpha);
593                         }
594                 }
595                 else {
596                         return microfacet_beckmann_refraction(N, xalpha, eta);
597                 }
598         }
599 }
600
601 closure color microfacet (string distribution, normal N, float alpha, float eta, int refract) {
602         return microfacet(distribution, N, vector(0), alpha, alpha, eta, refract);
603 }
604
605
606 // Renderer state
607 int backfacing () BUILTIN;
608 int raytype (string typename) BUILTIN;
609 // the individual 'isFOOray' functions are deprecated
610 int iscameraray () { return raytype("camera"); }
611 int isdiffuseray () { return raytype("diffuse"); }
612 int isglossyray () { return raytype("glossy"); }
613 int isshadowray () { return raytype("shadow"); }
614 int getmatrix (string fromspace, string tospace, output matrix M) BUILTIN;
615 int getmatrix (string fromspace, output matrix M) {
616     return getmatrix (fromspace, "common", M);
617 }
618
619
620 // Miscellaneous
621
622
623
624
625 #undef BUILTIN
626 #undef BUILTIN_DERIV
627 #undef PERCOMP1
628 #undef PERCOMP2
629 #undef PERCOMP2F
630
631 #endif /* CCL_STDOSL_H */