Extend linearstep and smooth_linearstep to color/point/vector/normal (#994)

Author: lgritz

src/doc/languagespec.tex

@@ -61,7 +61,7 @@
 \emph{lg@imageworks.com}
 }
 \date{{\large Date: 31 Mar 2018 \\
- (with corrections, 1 Nov 2018)
+ (with corrections, 12 Apr 2019)
 }
 \bigskip
 \bigskip
@@ -3448,11 +3448,15 @@ \section{Pattern generation}
 performed component-by-component (separately for $x$, $y$, and $z$).
 \apiend
 
-\apiitem{float {\ce linearstep} (float edge0, float edge1, float x)}
+\apiitem{float {\ce linearstep} (float edge0, float edge1, float x) \\
+\emph{type} {\ce linearstep} (\emph{type} edge0, \emph{type} edge1, \emph{type} x)}
 \indexapi{linearstep()}
 Returns 0 if $x \le {\mathit edge0}$, and 1 if $x \ge {\mathit edge1}$,
 and performs a linear
 interpolation between 0 and 1 when ${\mathit edge0} < x < {\mathit edge1}$.
+This is equivalent to {\cf step(edge0, x)} when {\cf edge0 == edge1}.
+For \color and \point-like types, the computations are
+performed component-by-component (separately for $x$, $y$, and $z$).
 \apiend
 
 \apiitem{float {\ce smoothstep} (float edge0, float edge1, float x) \\
@@ -3466,17 +3470,20 @@ \section{Pattern generation}
 
 The \emph{type} may be any of of \float, \color, \point, \vector, or
 \normal.  For \color and \point-like types, the computations are
-performed component-by-component (separately for $x$, $y$, and $z$).
+performed component-by-component.
 \apiend
 
-\apiitem{float {\ce smooth_linearstep} (float edge0, float edge1, float x, float eps)}
+\apiitem{float {\ce smooth_linearstep} (float edge0, float edge1, float x, float eps) \\
+\emph{type} {\ce smooth_linearstep} (\emph{type} edge0, \emph{type} edge1, \emph{type} x, \emph{type} eps)}
 \indexapi{smooth_linearstep()}
 This function is strictly linear between ${\mathit edge0}+{\mathit eps}$ and ${\mathit edge1}-{\mathit eps}$
 but smoothly ramps to 0 between ${\mathit edge0}-{\mathit eps}$ and ${\mathit edge0}+{\mathit eps}$
 and smoothly ramps to 1 between ${\mathit edge1}-{\mathit eps}$ and ${\mathit edge1}+{\mathit eps}$.
 It is 0 when $x \le {\mathit edge0}-{\mathit eps}$, and 1 if $x \ge {\mathit edge1}+{\mathit eps}$,
 and performs a linear
 interpolation between 0 and 1 when ${\mathit edge0} < x < {\mathit edge1}$.
+For \color and \point-like types, the computations are
+performed component-by-component.
 \apiend
 
 

src/shaders/stdosl.h

@@ -343,17 +343,17 @@ normal step (normal edge, normal x) BUILTIN;
 float step (float edge, float x) BUILTIN;
 float smoothstep (float edge0, float edge1, float x) BUILTIN;
 
-color smoothstep (color edge0, color edge1, color in)
+color smoothstep (color edge0, color edge1, color x)
 {
-    return color (smoothstep(edge0[0], edge1[0], in[0]),
-                  smoothstep(edge0[1], edge1[1], in[1]),
-                  smoothstep(edge0[2], edge1[2], in[2]));
+    return color (smoothstep(edge0[0], edge1[0], x[0]),
+                  smoothstep(edge0[1], edge1[1], x[1]),
+                  smoothstep(edge0[2], edge1[2], x[2]));
 }
-vector smoothstep (vector edge0, vector edge1, vector in)
+vector smoothstep (vector edge0, vector edge1, vector x)
 {
-    return vector (smoothstep(edge0[0], edge1[0], in[0]),
-                   smoothstep(edge0[1], edge1[1], in[1]),
-                   smoothstep(edge0[2], edge1[2], in[2]));
+    return vector (smoothstep(edge0[0], edge1[0], x[0]),
+                   smoothstep(edge0[1], edge1[1], x[1]),
+                   smoothstep(edge0[2], edge1[2], x[2]));
 }
 
 float linearstep (float edge0, float edge1, float x) {
@@ -366,6 +366,18 @@ float linearstep (float edge0, float edge1, float x) {
     }
     return result;
 }
+color linearstep (color edge0, color edge1, color x)
+{
+    return color (linearstep(edge0[0], edge1[0], x[0]),
+                  linearstep(edge0[1], edge1[1], x[1]),
+                  linearstep(edge0[2], edge1[2], x[2]));
+}
+vector linearstep (vector edge0, vector edge1, vector x)
+{
+    return vector (linearstep(edge0[0], edge1[0], x[0]),
+                   linearstep(edge0[1], edge1[1], x[1]),
+                   linearstep(edge0[2], edge1[2], x[2]));
+}
 
 float smooth_linearstep (float edge0, float edge1, float x_, float eps_) {
     float result;
@@ -385,6 +397,19 @@ float smooth_linearstep (float edge0, float edge1, float x_, float eps_) {
     return result;
 }
 
+color smooth_linearstep (color edge0, color edge1, color x, color eps)
+{
+    return color (smooth_linearstep(edge0[0], edge1[0], x[0], eps[0]),
+                  smooth_linearstep(edge0[1], edge1[1], x[1], eps[1]),
+                  smooth_linearstep(edge0[2], edge1[2], x[2], eps[2]));
+}
+vector smooth_linearstep (vector edge0, vector edge1, vector x, vector eps)
+{
+    return vector (smooth_linearstep(edge0[0], edge1[0], x[0], eps[0]),
+                   smooth_linearstep(edge0[1], edge1[1], x[1], eps[1]),
+                   smooth_linearstep(edge0[2], edge1[2], x[2], eps[2]));
+}
+
 float aastep (float edge, float s, float dedge, float ds) {
     // Box filtered AA step
     float width = fabs(dedge) + fabs(ds);

testsuite/linearstep/ref/out.tif

@@ -2,15 +2,27 @@ shader
 test (output color Cout = 0)
 {
     Cout = 0;
-    if (v < 0.2)    // degenerate linearstep with coincident edges
+    if (v < 0.1)    // degenerate linearstep with coincident edges
         Cout = linearstep (0.5, 0.5, u);
-    else if (v < 0.4)  // ordinary linearstep
+    else if (v < 0.2)  // ordinary linearstep
         Cout = linearstep (0.25, 0.75, u);
-    else if (v < 0.6)  // deginerate sls with eps==0
+    else if (v < 0.3)  // degenerate sls with eps==0
         Cout = smooth_linearstep (0.25, 0.75, u, 0.0);
-    else if (v < 0.8)  // regular sls
+    else if (v < 0.4)  // regular sls
         Cout = smooth_linearstep (0.25, 0.75, u, 0.05);
-    else if (v < 1.0)  // degenerate sls with coincident edges
+    else if (v < 0.5)  // degenerate sls with coincident edges
         Cout = smooth_linearstep (0.5, 0.5, u, 0.0);
+
+    else if (v < 0.6)    // degenerate linearstep with coincident edges
+        Cout = linearstep (color(0.5), color(0.5), u);
+    else if (v < 0.7)  // ordinary linearstep
+        Cout = linearstep (color(0.25), color(0.75), u);
+    else if (v < 0.8)  // degenerate sls with eps==0
+        Cout = smooth_linearstep (color(0.25), color(0.75), u, color(0.0));
+    else if (v < 0.9)  // regular sls
+        Cout = smooth_linearstep (color(0.25), color(0.75), u, color(0.05));
+    else if (v <= 1.0)  // degenerate sls with coincident edges
+        Cout = smooth_linearstep (color(0.5), color(0.5), u, color(0.0));
+
     Cout = 0.1 + Cout * 0.8;
 }