OSL / Cycles:
authorThomas Dinges <blender@dingto.org>
Sun, 2 Sep 2012 13:23:44 +0000 (13:23 +0000)
committerThomas Dinges <blender@dingto.org>
Sun, 2 Sep 2012 13:23:44 +0000 (13:23 +0000)
* Update the stdosl header file, from official osl 1.2.

intern/cycles/kernel/osl/nodes/stdosl.h

index 0c07c501d690c44347c7e6665a4bc0b0c7a01aa1..2368c2368b7658e113514dc28a58a3fef85ac903 100644 (file)
@@ -35,6 +35,8 @@
 #define M_PI_2     1.5707963267948966        /* pi/2 */
 #define M_PI_4     0.7853981633974483        /* pi/4 */
 #define M_2_PI     0.6366197723675813        /* 2/pi */
+#define M_2PI      6.2831853071795865        /* 2*pi */
+#define M_4PI     12.566370614359173         /* 4*pi */
 #define M_2_SQRTPI 1.1283791670955126        /* 2/sqrt(pi) */
 #define M_E        2.7182818284590452        /* e (Euler's number) */
 #define M_LN2      0.6931471805599453        /* ln(2) */
@@ -121,9 +123,16 @@ PERCOMP1 (round)
 PERCOMP1 (trunc)
 PERCOMP2 (fmod)
 PERCOMP2F (fmod)
-PERCOMP2 (mod)
-PERCOMP2F (mod)
-int    mod (int x, int y) BUILTIN;
+int    mod (int    a, int    b) { return a - b*(int)floor(a/b); }
+point  mod (point  a, point  b) { return a - b*floor(a/b); }
+vector mod (vector a, vector b) { return a - b*floor(a/b); }
+normal mod (normal a, normal b) { return a - b*floor(a/b); }
+color  mod (color  a, color  b) { return a - b*floor(a/b); }
+point  mod (point  a, float  b) { return a - b*floor(a/b); }
+vector mod (vector a, float  b) { return a - b*floor(a/b); }
+normal mod (normal a, float  b) { return a - b*floor(a/b); }
+color  mod (color  a, float  b) { return a - b*floor(a/b); }
+float  mod (float  a, float  b) { return a - b*floor(a/b); }
 PERCOMP2 (min)
 PERCOMP2 (max)
 normal clamp (normal x, normal minval, normal maxval) { return max(min(x,maxval),minval); }
@@ -131,11 +140,6 @@ vector clamp (vector x, vector minval, vector maxval) { return max(min(x,maxval)
 point  clamp (point x, point minval, point maxval) { return max(min(x,maxval),minval); }
 color  clamp (color x, color minval, color maxval) { return max(min(x,maxval),minval); }
 float  clamp (float x, float minval, float maxval) { return max(min(x,maxval),minval); }
-//normal clamp (normal x, normal minval, normal maxval) BUILTIN;
-//vector clamp (vector x, vector minval, vector maxval) BUILTIN;
-//point  clamp (point x, point minval, point maxval) BUILTIN;
-//color  clamp (color x, color minval, color maxval) BUILTIN;
-//float  clamp (float x, float minval, float maxval) BUILTIN;
 normal mix (normal x, normal y, normal a) { return x*(1-a) + y*a; }
 normal mix (normal x, normal y, float  a) { return x*(1-a) + y*a; }
 vector mix (vector x, vector y, vector a) { return x*(1-a) + y*a; }
@@ -163,246 +167,234 @@ vector normalize (vector v) BUILTIN;
 vector faceforward (vector N, vector I, vector Nref) BUILTIN;
 vector faceforward (vector N, vector I) BUILTIN;
 vector reflect (vector I, vector N) { return I - 2*dot(N,I)*N; }
-vector refract(vector I, vector N, float eta) {
-       float IdotN = dot(I, N);
-       float k = 1 - eta * eta * (1 - IdotN * IdotN);
-       return (k < 0) ? vector(0, 0, 0) : (eta * I - N * (eta * IdotN + sqrt(k)));
+vector refract (vector I, vector N, float eta) {
+    float IdotN = dot (I, N);
+    float k = 1 - eta*eta * (1 - IdotN*IdotN);
+    return (k < 0) ? vector(0,0,0) : (eta*I - N * (eta*IdotN + sqrt(k)));
 }
-void fresnel(vector I, normal N, float eta,
-             output float Kr, output float Kt,
-             output vector R, output vector T)
+void fresnel (vector I, normal N, float eta,
+              output float Kr, output float Kt,
+              output vector R, output vector T)
 {
-       float sqr(float x) {
-               return x * x;
-       }
-       float c = dot(I, N);
-       if (c < 0)
-               c = -c;
-       R = reflect(I, N);
-       float g = 1.0 / sqr(eta) - 1.0 + c * c;
-       if (g >= 0.0) {
-               g = sqrt(g);
-               float beta = g - c;
-               float F = (c * (g + c) - 1.0) / (c * beta + 1.0);
-               F = 0.5 * (1.0 + sqr(F));
-               F *= sqr(beta / (g + c));
-               Kr = F;
-               Kt = (1.0 - Kr) * eta * eta;
-               // OPT: the following recomputes some of the above values, but it
-               // gives us the same result as if the shader-writer called refract()
-               T = refract(I, N, eta);
-       }
-       else {
-               // total internal reflection
-               Kr = 1.0;
-               Kt = 0.0;
-               T = vector(0, 0, 0);
-       }
-#undef sqr
+    float sqr(float x) { return x*x; }
+    float c = dot(I, N);
+    if (c < 0)
+        c = -c;
+    R = reflect(I, N);
+    float g = 1.0 / sqr(eta) - 1.0 + c * c;
+    if (g >= 0.0) {
+        g = sqrt (g);
+        float beta = g - c;
+        float F = (c * (g+c) - 1.0) / (c * beta + 1.0);
+        F = 0.5 * (1.0 + sqr(F));
+        F *= sqr (beta / (g+c));
+        Kr = F;
+        Kt = (1.0 - Kr) * eta*eta;
+        // OPT: the following recomputes some of the above values, but it 
+        // gives us the same result as if the shader-writer called refract()
+        T = refract(I, N, eta);
+    } else {
+        // total internal reflection
+        Kr = 1.0;
+        Kt = 0.0;
+        T = vector (0,0,0);
+    }
 }
 
-void fresnel(vector I, normal N, float eta,
-             output float Kr, output float Kt)
+void fresnel (vector I, normal N, float eta,
+              output float Kr, output float Kt)
 {
-       vector R, T;
-       fresnel(I, N, eta, Kr, Kt, R, T);
+    vector R, T;
+    fresnel(I, N, eta, Kr, Kt, R, T);
 }
 
-point rotate(point q, float angle, point a, point b) BUILTIN;
 
-normal transform(matrix Mto, normal p) BUILTIN;
-vector transform(matrix Mto, vector p) BUILTIN;
-point transform(matrix Mto, point p) BUILTIN;
+normal transform (matrix Mto, normal p) BUILTIN;
+vector transform (matrix Mto, vector p) BUILTIN;
+point  transform (matrix Mto, point p) BUILTIN;
+normal transform (string from, string to, normal p) BUILTIN;
+vector transform (string from, string to, vector p) BUILTIN;
+point  transform (string from, string to, point p) BUILTIN;
+normal transform (string to, normal p) { return transform("common",to,p); }
+vector transform (string to, vector p) { return transform("common",to,p); }
+point  transform (string to, point p)  { return transform("common",to,p); }
 
-// Implementation of transform-with-named-space in terms of matrices:
+float transformu (string tounits, float x) BUILTIN;
+float transformu (string fromunits, string tounits, float x) BUILTIN;
 
-point transform(string tospace, point x)
+point rotate (point p, float angle, point a, point b)
 {
-       return transform(matrix("common", tospace), x);
+    vector axis = normalize (b - a);
+    float cosang, sinang;
+    sincos (angle, sinang, cosang);
+    float cosang1 = 1.0 - cosang;
+    float x = axis[0], y = axis[1], z = axis[2];
+    matrix M = matrix (x * x + (1.0 - x * x) * cosang,
+                       x * y * cosang1 + z * sinang,
+                       x * z * cosang1 - y * sinang,
+                       0.0,
+                       x * y * cosang1 - z * sinang,
+                       y * y + (1.0 - y * y) * cosang,
+                       y * z * cosang1 + x * sinang,
+                       0.0,
+                       x * z * cosang1 + y * sinang,
+                       y * z * cosang1 - x * sinang,
+                       z * z + (1.0 - z * z) * cosang,
+                       0.0,
+                       0.0, 0.0, 0.0, 1.0);
+    return transform (M, p-a) + a;
 }
 
-point transform(string fromspace, string tospace, point x)
-{
-       return transform(matrix(fromspace, tospace), x);
-}
-
-
-vector transform(string tospace, vector x)
-{
-       return transform(matrix("common", tospace), x);
-}
-
-vector transform(string fromspace, string tospace, vector x)
-{
-       return transform(matrix(fromspace, tospace), x);
-}
-
-
-normal transform(string tospace, normal x)
-{
-       return transform(matrix("common", tospace), x);
-}
-
-normal transform(string fromspace, string tospace, normal x)
-{
-       return transform(matrix(fromspace, tospace), x);
-}
-
-float transformu(string tounits, float x) BUILTIN;
-float transformu(string fromunits, string tounits, float x) BUILTIN;
 
 
 // Color functions
 
-float luminance(color c) {
-       return dot((vector)c, vector(0.2126, 0.7152, 0.0722));
-}
-
+float luminance (color c) BUILTIN;
+color blackbody (float temperatureK) BUILTIN;
+color wavelength_color (float wavelength_nm) BUILTIN;
 
 
-color transformc(string to, color x)
+color transformc (string to, color x)
 {
-       color rgb_to_hsv(color rgb) {   // See Foley & van Dam
-               float r = rgb[0], g = rgb[1], b = rgb[2];
-               float mincomp = min(r, min(g, b));
-               float maxcomp = max(r, max(g, b));
-               float delta = maxcomp - mincomp;  // chroma
-               float h, s, v;
-               v = maxcomp;
-               if (maxcomp > 0)
-                       s = delta / maxcomp;
-               else s = 0;
-               if (s <= 0)
-                       h = 0;
-               else {
-                       if      (r >= maxcomp) h = (g - b) / delta;
-                       else if (g >= maxcomp) h = 2 + (b - r) / delta;
-                       else h = 4 + (r - g) / delta;
-                       h /= 6;
-                       if (h < 0)
-                               h += 1;
-               }
-               return color(h, s, v);
-       }
-
-       color rgb_to_hsl(color rgb) {   // See Foley & van Dam
-               // First convert rgb to hsv, then to hsl
-               float minval = min(rgb[0], min(rgb[1], rgb[2]));
-               color hsv = rgb_to_hsv(rgb);
-               float maxval = hsv[2];   // v == maxval
-               float h = hsv[0], s, l = (minval + maxval) / 2;
-               if (minval == maxval)
-                       s = 0;  // special 'achromatic' case, hue is 0
-               else if (l <= 0.5)
-                       s = (maxval - minval) / (maxval + minval);
-               else
-                       s = (maxval - minval) / (2 - maxval - minval);
-               return color(h, s, l);
-       }
-
-       color r;
-       if (to == "rgb" || to == "RGB")
-               r = x;
-       else if (to == "hsv")
-               r = rgb_to_hsv(x);
-       else if (to == "hsl")
-               r = rgb_to_hsl(x);
-       else if (to == "YIQ")
-               r = color(dot(vector(0.299,  0.587,  0.114), (vector)x),
-                         dot(vector(0.596, -0.275, -0.321), (vector)x),
-                         dot(vector(0.212, -0.523,  0.311), (vector)x));
-       else if (to == "xyz")
-               r = color(dot(vector(0.412453, 0.357580, 0.180423), (vector)x),
-                         dot(vector(0.212671, 0.715160, 0.072169), (vector)x),
-                         dot(vector(0.019334, 0.119193, 0.950227), (vector)x));
-       else {
-               error("Unknown color space \"%s\"", to);
-               r = x;
-       }
-       return r;
+    color rgb_to_hsv (color rgb) {  // See Foley & van Dam
+        float r = rgb[0], g = rgb[1], b = rgb[2];
+        float mincomp = min (r, min (g, b));
+        float maxcomp = max (r, max (g, b));
+        float delta = maxcomp - mincomp;  // chroma
+        float h, s, v;
+        v = maxcomp;
+        if (maxcomp > 0)
+            s = delta / maxcomp;
+        else s = 0;
+        if (s <= 0)
+            h = 0;
+        else {
+            if      (r >= maxcomp) h = (g-b) / delta;
+            else if (g >= maxcomp) h = 2 + (b-r) / delta;
+            else                   h = 4 + (r-g) / delta;
+            h /= 6;
+            if (h < 0)
+                h += 1;
+        }
+        return color (h, s, v);
+    }
+
+    color rgb_to_hsl (color rgb) {  // See Foley & van Dam
+        // First convert rgb to hsv, then to hsl
+        float minval = min (rgb[0], min (rgb[1], rgb[2]));
+        color hsv = rgb_to_hsv (rgb);
+        float maxval = hsv[2];   // v == maxval
+        float h = hsv[0], s, l = (minval+maxval) / 2;
+        if (minval == maxval)
+            s = 0;  // special 'achromatic' case, hue is 0
+        else if (l <= 0.5)
+            s = (maxval - minval) / (maxval + minval);
+        else
+            s = (maxval - minval) / (2 - maxval - minval);
+        return color (h, s, l);
+    }
+
+    color r;
+    if (to == "rgb" || to == "RGB")
+        r = x;
+    else if (to == "hsv")
+        r = rgb_to_hsv (x);
+    else if (to == "hsl")
+        r = rgb_to_hsl (x);
+    else if (to == "YIQ")
+        r = color (dot (vector(0.299,  0.587,  0.114), (vector)x),
+                   dot (vector(0.596, -0.275, -0.321), (vector)x),
+                   dot (vector(0.212, -0.523,  0.311), (vector)x));
+    else if (to == "xyz")
+        r = color (dot (vector(0.412453, 0.357580, 0.180423), (vector)x),
+                   dot (vector(0.212671, 0.715160, 0.072169), (vector)x),
+                   dot (vector(0.019334, 0.119193, 0.950227), (vector)x));
+    else {
+        error ("Unknown color space \"%s\"", to);
+        r = x;
+    }
+    return r;
 }
 
 
-color transformc(string from, string to, color x)
+color transformc (string from, string to, color x)
 {
-       color hsv_to_rgb(color c) {  // Reference: Foley & van Dam
-               float h = c[0], s = c[1], v = c[2];
-               color r;
-               if (s < 0.0001) {
-                       r = v;
-               }
-               else {
-                       h = 6 * (h - floor(h));  // expand to [0..6)
-                       int hi = (int)h;
-                       float f = h - hi;
-                       float p = v * (1 - s);
-                       float q = v * (1 - s * f);
-                       float t = v * (1 - s * (1 - f));
-                       if      (hi == 0) r = color(v, t, p);
-                       else if (hi == 1) r = color(q, v, p);
-                       else if (hi == 2) r = color(p, v, t);
-                       else if (hi == 3) r = color(p, q, v);
-                       else if (hi == 4) r = color(t, p, v);
-                       else r = color(v, p, q);
-               }
-               return r;
-       }
-
-       color hsl_to_rgb(color c) {
-               float h = c[0], s = c[1], l = c[2];
-               // Easiest to convert hsl -> hsv, then hsv -> RGB (per Foley & van Dam)
-               float v = (l <= 0.5) ? (l * (1 + s)) : (l * (1 - s) + s);
-               color r;
-               if (v <= 0) {
-                       r = 0;
-               }
-               else {
-                       float min = 2 * l - v;
-                       s = (v - min) / v;
-                       r = hsv_to_rgb(color(h, s, v));
-               }
-               return r;
-       }
-
-       color r;
-       if (from == "rgb" || from == "RGB")
-               r = x;
-       else if (from == "hsv")
-               r = hsv_to_rgb(x);
-       else if (from == "hsl")
-               r = hsl_to_rgb(x);
-       else if (from == "YIQ")
-               r = color(dot(vector(1,  0.9557,  0.6199), (vector)x),
-                         dot(vector(1, -0.2716, -0.6469), (vector)x),
-                         dot(vector(1, -1.1082,  1.7051), (vector)x));
-       else if (from == "xyz")
-               r = color(dot(vector(3.240479, -1.537150, -0.498535), (vector)x),
-                         dot(vector(-0.969256,  1.875991,  0.041556), (vector)x),
-                         dot(vector(0.055648, -0.204043,  1.057311), (vector)x));
-       else {
-               error("Unknown color space \"%s\"", to);
-               r = x;
-       }
-       return transformc(to, r);
+    color hsv_to_rgb (color c) { // Reference: Foley & van Dam
+        float h = c[0], s = c[1], v = c[2];
+        color r;
+        if (s < 0.0001) {
+            r = v;
+        } else {
+            h = 6 * (h - floor(h));  // expand to [0..6)
+            int hi = (int)h;
+            float f = h - hi;
+            float p = v * (1-s);
+            float q = v * (1-s*f);
+            float t = v * (1-s*(1-f));
+            if      (hi == 0) r = color (v, t, p);
+            else if (hi == 1) r = color (q, v, p);
+            else if (hi == 2) r = color (p, v, t);
+            else if (hi == 3) r = color (p, q, v);
+            else if (hi == 4) r = color (t, p, v);
+            else              r = color (v, p, q);
+        }
+        return r;
+    }
+
+    color hsl_to_rgb (color c) {
+        float h = c[0], s = c[1], l = c[2];
+        // Easiest to convert hsl -> hsv, then hsv -> RGB (per Foley & van Dam)
+        float v = (l <= 0.5) ? (l * (1 + s)) : (l * (1 - s) + s);
+        color r;
+        if (v <= 0) {
+            r = 0;
+        } else {
+            float min = 2 * l - v;
+            s = (v - min) / v;
+            r = hsv_to_rgb (color (h, s, v));
+        }
+        return r;
+    }
+
+    color r;
+    if (from == "rgb" || from == "RGB")
+        r = x;
+    else if (from == "hsv")
+        r = hsv_to_rgb (x);
+    else if (from == "hsl")
+        r = hsl_to_rgb (x);
+    else if (from == "YIQ")
+        r = color (dot (vector(1,  0.9557,  0.6199), (vector)x),
+                   dot (vector(1, -0.2716, -0.6469), (vector)x),
+                   dot (vector(1, -1.1082,  1.7051), (vector)x));
+    else if (from == "xyz")
+        r = color (dot (vector( 3.240479, -1.537150, -0.498535), (vector)x),
+                   dot (vector(-0.969256,  1.875991,  0.041556), (vector)x),
+                   dot (vector( 0.055648, -0.204043,  1.057311), (vector)x));
+    else {
+        error ("Unknown color space \"%s\"", to);
+        r = x;
+    }
+    return transformc (to, r);
 }
 
  
 
 // Matrix functions
 
-float determinant(matrix m) BUILTIN;
-matrix transpose(matrix m) BUILTIN;
+float determinant (matrix m) BUILTIN;
+matrix transpose (matrix m) BUILTIN;
 
 
 
 // Pattern generation
 
-float step(float edge, float x) BUILTIN;
-color step(color edge, color x) BUILTIN;
-point step(point edge, point x) BUILTIN;
-vector step(vector edge, vector x) BUILTIN;
-normal step(normal edge, normal x) BUILTIN;
-float smoothstep(float edge0, float edge1, float x) BUILTIN;
+float step (float edge, float x) BUILTIN;
+color step (color edge, color x) BUILTIN;
+point step (point edge, point x) BUILTIN;
+vector step (vector edge, vector x) BUILTIN;
+normal step (normal edge, normal x) BUILTIN;
+float smoothstep (float edge0, float edge1, float x) BUILTIN;
 
 
 // Derivatives and area operators
@@ -413,26 +405,24 @@ float smoothstep(float edge0, float edge1, float x) BUILTIN;
 
 // String functions
 
-int strlen(string s) BUILTIN;
-int startswith(string s, string prefix) BUILTIN;
-int endswith(string s, string suffix) BUILTIN;
-string substr(string s, int start, int len) BUILTIN;
-string substr(string s, int start) {
-       return substr(s, start, strlen(s));
-}
+int strlen (string s) BUILTIN;
+int startswith (string s, string prefix) BUILTIN;
+int endswith (string s, string suffix) BUILTIN;
+string substr (string s, int start, int len) BUILTIN;
+string substr (string s, int start) { return substr (s, start, strlen(s)); }
 
 // Define concat in terms of shorter concat
-string concat(string a, string b, string c) {
-       return concat(concat(a, b), c);
+string concat (string a, string b, string c) {
+    return concat(concat(a,b), c);
 }
-string concat(string a, string b, string c, string d) {
-       return concat(concat(a, b, c), d);
+string concat (string a, string b, string c, string d) {
+    return concat(concat(a,b,c), d);
 }
-string concat(string a, string b, string c, string d, string e) {
-       return concat(concat(a, b, c, d), e);
+string concat (string a, string b, string c, string d, string e) {
+    return concat(concat(a,b,c,d), e);
 }
-string concat(string a, string b, string c, string d, string e, string f) {
-       return concat(concat(a, b, c, d, e), f);
+string concat (string a, string b, string c, string d, string e, string f) {
+    return concat(concat(a,b,c,d,e), f);
 }
 
 
@@ -442,19 +432,22 @@ string concat(string a, string b, string c, string d, string e, string f) {
 // Closures
 
 closure color diffuse(normal N) BUILTIN;
-closure color oren_nayar(normal N, float sigma) BUILTIN;
 closure color translucent(normal N) BUILTIN;
 closure color reflection(normal N, float eta) BUILTIN;
-closure color reflection(normal N) { return reflection(N, 0.0); }
+closure color reflection(normal N) { return reflection (N, 0.0); }
 closure color refraction(normal N, float eta) BUILTIN;
 closure color dielectric(normal N, float eta) BUILTIN;
 closure color transparent() BUILTIN;
-closure color microfacet_ggx(normal N, float ag) BUILTIN;
+closure color microfacet_ggx(normal N, float ag, float eta) BUILTIN;
 closure color microfacet_ggx_refraction(normal N, float ag, float eta) BUILTIN;
-closure color microfacet_beckmann(normal N, float ab) BUILTIN;
+closure color microfacet_beckmann(normal N, float ab, float eta) BUILTIN;
 closure color microfacet_beckmann_refraction(normal N, float ab, float eta) BUILTIN;
-closure color ward(normal N, vector T, float ax, float ay) BUILTIN;
-closure color ashikhmin_velvet(normal N, float sigma) BUILTIN;
+closure color ward(normal N, vector T,float ax, float ay) BUILTIN;
+closure color phong(normal N, float exponent) BUILTIN;
+closure color phong_ramp(normal N, float exponent, color colors[8]) BUILTIN;
+closure color hair_diffuse(vector T) BUILTIN;
+closure color hair_specular(vector T, float offset, float exponent) BUILTIN;
+closure color ashikhmin_velvet(normal N, float sigma, float eta) BUILTIN;
 closure color westin_backscatter(normal N, float roughness) BUILTIN;
 closure color westin_sheen(normal N, float edginess) BUILTIN;
 closure color bssrdf_cubic(color radius) BUILTIN;
@@ -464,10 +457,75 @@ closure color emission() BUILTIN;
 closure color debug(string tag) BUILTIN;
 closure color background() BUILTIN;
 closure color holdout() BUILTIN;
-closure color subsurface(float eta, float g, float mfp, float albedo) BUILTIN;
+closure color subsurface(float eta, float g, color mfp, color albedo) BUILTIN;
+
+closure color cloth(normal N, float s, float t, float dsdx, float dtdx, float dsdy, float dtdy,
+                    float area_scaled, vector dPdu, color diff_warp_col, color diff_weft_col,
+                    color spec_warp_col, color spec_weft_col, float fresnel_warp, float fresnel_weft,
+                    float spread_x_mult, float spread_y_mult, int pattern, float pattern_angle,
+                    float warp_width_scale, float weft_width_scale, float thread_count_mult_u,
+                    float thread_count_mult_v) BUILTIN;
+closure color cloth_specular(normal N, color spec_col[4], float eta[4], int thread_pattern[4],
+                             float pattern_weight[4], int   current_thread, float brdf_interp,
+                             float btf_interp, float uux, float vvx, float area_scaled, vector dPdu,
+                             float eccentricity[4], float angle[4], float Kx[4], float Ky[4],
+                             float Sx[4], float Sy[4]) BUILTIN;
+closure color fakefur_diffuse(normal N, vector T, float fur_reflectivity, float fur_transmission,
+                              float shadow_start, float shadow_end, float fur_attenuation, float fur_density,
+                              float fur_avg_radius, float fur_length, float fur_shadow_fraction) BUILTIN;
+closure color fakefur_specular(normal N, vector T, float offset, float exp, float fur_reflectivity,
+                               float fur_transmission, float shadow_start, float shadow_end,
+                               float fur_attenuation, float fur_density, float fur_avg_radius,
+                               float fur_length, float fur_shadow_fraction) BUILTIN;
+
+closure color fakefur_skin(vector N, vector T, float fur_reflectivity, float fur_transmission,
+                           float shadow_start, float shadow_end, float fur_attenuation, float fur_density,
+                           float fur_avg_radius, float fur_length) BUILTIN;
+
+
+closure color cloth(normal N, float s, float t, color diff_warp, color diff_weft, 
+                    color spec_warp, color spec_weft, float fresnel_warp, float fresnel_weft,
+                    float spread_x_mult, float spread_y_mult, int pattern, float pattern_angle,
+                    float warp_width_scale, float weft_width_scale, float thread_count_mult_u,
+                    float thread_count_mult_v)
+{
+
+    return cloth(N, s, t, Dx(s), Dx(t), Dy(s), Dy(t), area(P), dPdu, diff_warp, diff_weft, spec_warp, spec_weft,
+                 fresnel_warp, fresnel_weft, spread_x_mult, spread_y_mult, pattern, pattern_angle, 
+                 warp_width_scale, weft_width_scale, thread_count_mult_u, thread_count_mult_v);
+}
+
+closure color cloth(normal N, float s, float t, color diff_warp, color diff_weft, 
+                    color spec_warp, color spec_weft, float fresnel_warp, float fresnel_weft,
+                    float spread_x_mult, float spread_y_mult, int pattern, float pattern_angle,
+                    float warp_width_scale, float weft_width_scale, float thread_count_mult_u,
+                    float thread_count_mult_v, string tok, string val)
+{
+
+    return cloth(N, s, t, Dx(s), Dx(t), Dy(s), Dy(t), area(P), dPdu, diff_warp, diff_weft, spec_warp, spec_weft,
+                 fresnel_warp, fresnel_weft, spread_x_mult, spread_y_mult, pattern, pattern_angle, 
+                 warp_width_scale, weft_width_scale, thread_count_mult_u, thread_count_mult_v, tok, val);
+}
+
+
 
 // Renderer state
-int raytype(string typename) BUILTIN;
+int raytype (string typename) BUILTIN;
+// the individual 'isFOOray' functions are deprecated
+int iscameraray () { return raytype("camera"); }
+int isdiffuseray () { return raytype("diffuse"); }
+int isglossyray () { return raytype("glossy"); }
+int isshadowray () { return raytype("shadow"); }
+int getmatrix (string fromspace, string tospace, output matrix M) BUILTIN;
+int getmatrix (string fromspace, output matrix M) {
+    return getmatrix (fromspace, "common", M);
+}
+
+
+// Miscellaneous
+
+
+
 
 #undef BUILTIN
 #undef BUILTIN_DERIV
@@ -476,4 +534,3 @@ int raytype(string typename) BUILTIN;
 #undef PERCOMP2F
 
 #endif /* CCL_STDOSL_H */
-