fix: Bugs in vector2.h, vector4.h, color2.h, color4.h, docs (#1892)

Fix a variety of typos in the 2- and 4-component color and vector
helper structs. Very embarrassing!

Also embarrassing, a typo in the docs had said that the way to
overload the `!=` operator was with a function called
`__operator__ne__` while actually, all along it had been
`__operator__neq__`.

Comprehensive test of color2, color4, vector2, vector4.

New testing header: testsuite/common/shaders/osl-unittest.h
This has utilities to make it easier to make unit tests for shader
functions in our testsuite.

Various other minor fixes to these headers.

Signed-off-by: Larry Gritz <[email protected]>

Author: lgritz

src/cmake/testing.cmake

@@ -252,7 +252,7 @@ macro (osl_add_all_tests)
                 bug-param-duplicate bug-peep bug-return
                 calculatenormal-reg
                 cellnoise closure closure-array closure-layered closure-parameters closure-zero closure-conditional
-                color color-reg colorspace comparison
+                color color2 color4 color-reg colorspace comparison
                 complement-reg compile-buffer compassign-bool compassign-reg
                 component-range
                 control-flow-reg connect-components
@@ -378,7 +378,7 @@ macro (osl_add_all_tests)
                 userdata userdata-partial userdata-custom userdata-passthrough
                 vararray-connect vararray-default
                 vararray-deserialize vararray-param
-                vecctr vector vector-reg
+                vecctr vector vector2 vector4 vector-reg
                 wavelength_color wavelength_color-reg Werror xml xml-reg )
 
     # Only run the ocio test if the OIIO we are using has OCIO support

src/doc/languagespec.tex

@@ -2760,7 +2760,7 @@ \subsection{Operator overloading}
 {\cf \bfseries >} & {\cf __operator__gt__} &  \\
 {\cf \bfseries >=} & {\cf __operator__ge__} & \\
 {\cf \bfseries ==} & {\cf __operator__eq__} & \\
-{\cf \bfseries !=} & {\cf __operator__ne__} & \\[1.5ex]
+{\cf \bfseries !=} & {\cf __operator__neq__} & \\[1.5ex]
 {\cf \bfseries \&} & {\cf __operator__bitand__} & \\
 {\cf \bfseries \textasciicircum} & {\cf __operator__xor__} & \\
 {\cf \bfseries |} & {\cf __operator__bitor__} & \\

src/doc/syntax.md

@@ -518,7 +518,7 @@ Operator    | Overload function name | notes
 `>` | `__operator__gt__` | 
 `>=` | `__operator__ge__` |
 `==` | `__operator__eq__` |
-`!=` | `__operator__ne__` |
+`!=` | `__operator__neq__` |
 `\&` | `__operator__bitand__` |
 `^` | `__operator__xor__` |
 `\|` | `__operator__bitor__` |

src/shaders/color2.h

@@ -26,7 +26,7 @@ color2 __operator__neg__(color2 a)
 
 color2 __operator__add__(color2 a, color2 b)
 {
-    return color2(a.r + a.r, b.a + b.a);
+    return color2(a.r + b.r, a.a + b.a);
 }
 
 color2 __operator__add__(color2 a, int b)
@@ -66,17 +66,17 @@ color2 __operator__sub__(color2 a, float b)
 
 color2 __operator__sub__(int a, color2 b)
 {
-    return b - color2(a, a);
+    return color2(a,a) - b;
 }
 
 color2 __operator__sub__(float a, color2 b)
 {
-    return b - color2(a, a);
+    return color2(a,a) - b;
 }
 
 color2 __operator__mul__(color2 a, color2 b)
 {
-    return color2(a.r * a.r, b.a * b.a);
+    return color2(a.r * b.r, a.a * b.a);
 }
 
 color2 __operator__mul__(color2 a, int b)
@@ -106,13 +106,13 @@ color2 __operator__div__(color2 a, color2 b)
 
 color2 __operator__div__(color2 a, int b)
 {
-    float b_inv = 1/b;
+    float b_inv = 1.0 / float(b);
     return a * color2(b_inv, b_inv);
 }
 
 color2 __operator__div__(color2 a, float b)
 {
-    float b_inv = 1/b;
+    float b_inv = 1.0 / b;
     return a * color2(b_inv, b_inv);
 }
 
@@ -128,10 +128,10 @@ color2 __operator__div__(float a, color2 b)
 
 int __operator__eq__(color2 a, color2 b)
 {
-    return (a.r == a.r) && (b.a == b.a);
+    return (a.r == b.r) && (a.a == b.a);
 }
 
-int __operator__ne__(color2 a, color2 b)
+int __operator__neq__(color2 a, color2 b)
 {
     return (a.r != b.r) || (a.a != b.a);
 }
@@ -231,8 +231,8 @@ color2 min(color2 a, float b)
 
 color2 fmod(color2 a, color2 b)
 {
-    return color2(fmod(a.r, a.r),
-                  fmod(b.a, b.a));
+    return color2(fmod(a.r, b.r),
+                  fmod(a.a, b.a));
 }
 
 color2 fmod(color2 a, int b)
@@ -303,5 +303,3 @@ color2 atan2(color2 a, color2 b)
     return color2(atan2(a.r, b.r),
                   atan2(a.a, b.a));
 }
-
-

src/shaders/color4.h

@@ -106,13 +106,13 @@ color4 __operator__div__(color4 a, color4 b)
 
 color4 __operator__div__(color4 a, int b)
 {
-    float b_inv = 1/b;
+    float b_inv = 1.0 / float(b);
     return a * color4(color(b_inv), b_inv);
 }
 
 color4 __operator__div__(color4 a, float b)
 {
-    float b_inv = 1/b;
+    float b_inv = 1.0 / b;
     return a * color4(color(b_inv), b_inv);
 }
 
@@ -131,7 +131,7 @@ int __operator__eq__(color4 a, color4 b)
     return (a.rgb == b.rgb) && (a.a == b.a);
 }
 
-int __operator__ne__(color4 a, color4 b)
+int __operator__neq__(color4 a, color4 b)
 {
     return (a.rgb != b.rgb) || (a.a != b.a);
 }
@@ -183,11 +183,6 @@ color4 mix(color4 a, color4 b, float x )
                   mix(a.a, b.a, x));
 }
 
-float dot(color4 a, color b)
-{
-    return dot(a.rgb, b);
-}
-
 color4 smoothstep(color4 edge0, color4 edge1, color4 c)
 {
     return color4(smoothstep(edge0.rgb, edge1.rgb, c.rgb),

src/shaders/matrix33.h

@@ -7,6 +7,9 @@
 #define MATRIX33_H
 
 
+// matrix33 is just a trick to make what appears to be a 3x3 matrix, but
+// underneath using a native OSL (4x4) matrix with appropriate zeroed extra
+// components to make the math all work out equivalently.
 struct matrix33
 {
     matrix m;
@@ -159,6 +162,3 @@ normal transform(matrix33 a, normal b)
 {
     return transform(a.m, b);
 }
-
-
-

src/shaders/vector2.h

@@ -105,13 +105,13 @@ vector2 __operator__div__(vector2 a, vector2 b)
 
 vector2 __operator__div__(vector2 a, int b)
 {
-    float b_inv = 1/b;
+    float b_inv = 1.0 / float(b);
     return a * vector2(b_inv, b_inv);
 }
 
 vector2 __operator__div__(vector2 a, float b)
 {
-    float b_inv = 1/b;
+    float b_inv = 1.0 / b;
     return a * vector2(b_inv, b_inv);
 }
 
@@ -130,7 +130,7 @@ int __operator__eq__(vector2 a, vector2 b)
     return (a.x == b.x) && (a.y == b.y);
 }
 
-int __operator__ne__(vector2 a, vector2 b)
+int __operator__neq__(vector2 a, vector2 b)
 {
     return (a.x != b.x) || (a.y != b.y);
 }
@@ -221,25 +221,25 @@ vector2 max(vector2 a, vector2 b)
                     max(a.y, b.y));
 }
 
-vector2 max(vector2 a, float b)
+vector2 min(vector2 a, vector2 b)
 {
-    return max(a, vector2(b, b));
+    return vector2 (min(a.x, b.x),
+                    min(a.y, b.y));
 }
 
-vector2 normalize(vector2 a)
+vector2 min(vector2 a, float b)
 {
-    return a / length(a);
+    return min(a, vector2(b, b));
 }
 
-vector2 min(vector2 a, vector2 b)
+vector2 max(vector2 a, float b)
 {
-    return vector2 (min(a.x, a.x),
-                    min(b.y, b.y));
+    return max(a, vector2(b, b));
 }
 
-vector2 min(vector2 a, float b)
+vector2 normalize(vector2 a)
 {
-    return min(a, vector2(b, b));
+    return a / length(a);
 }
 
 vector2 mod(vector2 a, vector2 b)
@@ -307,13 +307,11 @@ vector2 acos(vector2 a)
 vector2 atan2(vector2 a, float f)
 {
     return vector2(atan2(a.x, f),
-                  atan2(a.y, f));
+                   atan2(a.y, f));
 }
 
 vector2 atan2(vector2 a, vector2 b)
 {
     return vector2(atan2(a.x, b.x),
-                  atan2(a.y, b.y));
+                   atan2(a.y, b.y));
 }
-
-

src/shaders/vector4.h

@@ -108,13 +108,13 @@ vector4 __operator__div__(vector4 a, vector4 b)
 
 vector4 __operator__div__(vector4 a, int b)
 {
-    float b_inv = 1/b;
+    float b_inv = 1.0 / float(b);
     return a * vector4(b_inv, b_inv, b_inv, b_inv);
 }
 
 vector4 __operator__div__(vector4 a, float b)
 {
-    float b_inv = 1/b;
+    float b_inv = 1.0 / b;
     return a * vector4(b_inv, b_inv, b_inv, b_inv);
 }
 
@@ -133,7 +133,7 @@ int __operator__eq__(vector4 a, vector4 b)
     return (a.x == b.x) && (a.y == b.y) && (a.z == b.z) && (a.w == b.w);
 }
 
-int __operator__ne__(vector4 a, vector4 b)
+int __operator__neq__(vector4 a, vector4 b)
 {
     return (a.x != b.x) || (a.y != b.y) || (a.z != b.z) || (a.w != b.w);
 }
@@ -269,11 +269,6 @@ vector4 max(vector4 a, float b)
     return max(a, vector4(b, b, b, b));
 }
 
-vector4 normalize(vector4 a)
-{
-    return a / length(a);
-}
-
 vector4 min(vector4 a, vector4 b)
 {
     return vector4 (min(a.x, b.x),
@@ -287,6 +282,11 @@ vector4 min(vector4 a, float b)
     return min(a, vector4(b, b, b, b));
 }
 
+vector4 normalize(vector4 a)
+{
+    return a / length(a);
+}
+
 vector4 fmod(vector4 a, vector4 b)
 {
     return vector4 (fmod(a.x, b.x),