OSL / Cycles:

* Update the stdosl header file, from official osl 1.2.
This commit is contained in:
Thomas Dinges 2012-09-02 13:23:44 +00:00
parent 25fc454ce0
commit 6c02a8fc8c

@ -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 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 to, color x)
color transformc (string from, 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 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 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 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 (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 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 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 */