OSL / Cycles:
* Update the stdosl header file, from official osl 1.2.
This commit is contained in:
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 */
|
||||
|
||||
|
Loading…
Reference in New Issue
Block a user