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