feat: Optional texture argument for colorspace (part 1 -- don't reject) (#1966)

Optional texture argument for colorspace (part 1 -- don't reject)

A while back, we proposed a new optional token/value parameter for the
texture functions: "colorspace", followed by a color space name, which
indicates that the texture name referenced is understood to be in that
colorspace (this is passed to the TextureSystem, which has known for
some time how to ensure the right transformations are applied as tile
data is read in).

We do not fully implement this yet! It's more involved than I have
time to get right by the scheduled OSL 1.14 non-beta release (which
was supposed to have been on Apr 1, oh no). Not wanting to delay
things further, this change at least causes the use of the new
parameter (which apparently, MaterialX has been using) to be silently
accepted and ignored, rather than generating runtime errors. We'll
come back right away for a more complete working implementation.

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

Author: lgritz

src/cmake/testing.cmake

@@ -392,7 +392,7 @@ macro (osl_add_all_tests)
                 test-fmt-cxpf  test-fmt-noise test-fmt-matrixcolor 
                 test-fmt-stpf test-fmt-errorwarning test-fmt-errorwarning-repeats
                 texture-alpha texture-alpha-derivs
-                texture-blur texture-connected-options
+                texture-blur texture-colorspace texture-connected-options
                 texture-derivs texture-environment texture-errormsg
                 texture-environment-opts-reg
                 texture-firstchannel texture-interp

src/include/OSL/batched_texture.h

@@ -45,6 +45,12 @@ struct UniformTextureOptions {
 #endif
     float fill                = 0.0f;     ///< Fill value for missing channels
     const float* missingcolor = nullptr;  ///< Color for missing texture
+#ifdef OIIO_TEXTURESYSTEM_SUPPORTS_COLORSPACE
+    int colortransformid = 0;  ///< Color space id of the texture
+#endif
+    // Options set INTERNALLY by libtexture after the options are passed
+    // by the user.  Users should not attempt to alter these!
+    int private_envlayout = 0;  // Layout for environment wrap
 };
 
 template<int WidthT> struct VaryingTextureOptions {
@@ -72,7 +78,7 @@ template<int WidthT> struct BatchedTextureOptions {
 
     // Options set INTERNALLY by libtexture after the options are passed
     // by the user.  Users should not attempt to alter these!
-    int private_envlayout = 0;  // Layout for environment wrap
+    // int private_envlayout = 0;  // Layout for environment wrap
 
     // Implementation detail
     // keep order synchronized to the data members in this structure
@@ -96,6 +102,9 @@ template<int WidthT> struct BatchedTextureOptions {
         conservative_filter,
         fill,
         missingcolor,
+#ifdef OIIO_TEXTURESYSTEM_SUPPORTS_COLORSPACE
+        colortransformid,
+#endif
         private_envlayout,
         count
     };
@@ -220,6 +229,12 @@ static_assert(
     offsetof(OIIO::TextureOptBatch, missingcolor)
         == uniform_offset + offsetof(UniformTextureOptions, missingcolor),
     "BatchedTextureOptions members offset different than OIIO::TextureOptBatch");
+#    ifdef OIIO_TEXTURESYSTEM_SUPPORTS_COLORSPACE
+static_assert(
+    offsetof(OIIO::TextureOptBatch, colortransformid)
+        == uniform_offset + offsetof(UniformTextureOptions, colortransformid),
+    "BatchedTextureOptions members offset different than OIIO::TextureOptBatch");
+#    endif
 
 OSL_PRAGMA_WARNING_POP
 }  // namespace validate_offsets

src/include/OSL/strdecls.h

@@ -142,9 +142,10 @@ STRDECL("CIE", CIE)
 STRDECL("AdobeRGB", AdobeRGB)
 STRDECL("ACES2065-1", ACES2065_1)
 STRDECL("ACEScg", ACEScg)
+STRDECL("colorspace", colorspace)
 STRDECL("colorsystem", colorsystem)
 STRDECL("arraylength", arraylength)
 STRDECL("unknown", unknown)
 STRDECL("ERROR: Unknown color space transformation \"%s\" -> \"%s\"\n",
         ErrorColorTransform)
-STRDECL("world", world)
+STRDECL("world", world)

src/liboslexec/batched_llvm_gen.cpp

@@ -4316,6 +4316,9 @@ llvm_batched_texture_options(BatchedBackendLLVM& rop, int opnum,
     llvm::Value* anisotropic         = rop.ll.constant(32);
     llvm::Value* conservative_filter = rop.ll.constant(1);
     llvm::Value* fill                = rop.ll.constant(0.0f);
+#ifdef OIIO_TEXTURESYSTEM_SUPPORTS_COLORSPACE
+    llvm::Value* colortransformid = rop.ll.constant(0);
+#endif
 
     bool is_swrap_uniform = true;
     bool is_twrap_uniform = true;
@@ -4606,6 +4609,18 @@ llvm_batched_texture_options(BatchedBackendLLVM& rop, int opnum,
             continue;
         }
 
+        if (name == Strings::colorspace && valtype == TypeDesc::STRING) {
+            if (Val.is_constant()) {
+                // Just ignore this option for now.
+                // FIXME: need full implementation
+                continue;
+            } else {
+                rop.shadingcontext()->errorfmt(
+                    "texture{} optional argument \"{}\" must be constant after optimization ({}:{})",
+                    tex3d ? "3d" : "", name, op.sourcefile(), op.sourceline());
+                continue;
+            }
+        }
         if (name == Strings::time
             && (valtype == TypeDesc::FLOAT || valtype == TypeDesc::INT)) {
             // NOTE: currently no supported 3d texture format makes use of time.
@@ -4693,6 +4708,14 @@ llvm_batched_texture_options(BatchedBackendLLVM& rop, int opnum,
                                         static_cast<int>(
                                             LLVMMemberIndex::missingcolor)));
 
+#ifdef OIIO_TEXTURESYSTEM_SUPPORTS_COLORSPACE
+    // FIXME: We currently ignore the color space, so just make it 0
+    rop.ll.op_unmasked_store(
+        colortransformid,
+        rop.ll.GEP(bto_type, bto, 0,
+                   static_cast<int>(LLVMMemberIndex::colortransformid)));
+#endif
+
     // blur's and width's are always communicated as wide, we we will handle them here
     rop.ll.op_unmasked_store(sblur, rop.ll.GEP(bto_type, bto, 0,
                                                static_cast<int>(
@@ -4936,6 +4959,7 @@ llvm_batched_texture_varying_options(BatchedBackendLLVM& rop, int opnum,
             continue;
         }
 
+        SKIP_PARAM_WIDE_STRING(colorspace)
         SKIP_PARAM_WIDE_FLOAT(time)
 
         rop.shadingcontext()->errorfmt(

src/liboslexec/batched_llvm_instance.cpp

@@ -769,6 +769,7 @@ BatchedBackendLLVM::llvm_type_batched_texture_options()
     sg_types.push_back(ll.type_int());                 // conservative_filter
     sg_types.push_back(ll.type_float());               // fill
     sg_types.push_back(ll.type_ptr(ll.type_float()));  // missingcolor
+    sg_types.push_back(ll.type_int());                 // colortransformid
 
     // Private internal data
     sg_types.push_back(ll.type_int());  // envlayout
@@ -2748,7 +2749,9 @@ BatchedBackendLLVM::build_offsets_of_BatchedTextureOptions(
     offset_by_index.push_back(uniform_offset
                               + offsetof(UniformTextureOptions, missingcolor));
     offset_by_index.push_back(
-        offsetof(BatchedTextureOptions<WidthT>, private_envlayout));
+        uniform_offset + offsetof(UniformTextureOptions, colortransformid));
+    offset_by_index.push_back(
+        uniform_offset + offsetof(UniformTextureOptions, private_envlayout));
 }
 
 

src/liboslexec/llvm_gen.cpp

@@ -2756,6 +2756,19 @@ llvm_gen_texture_options(BackendLLVM& rop, int opnum, int first_optional_arg,
                                  rop.ll.constant(nchans), val);
             continue;
         }
+        if (name == Strings::colorspace && valtype == TypeDesc::STRING) {
+            if (Val.is_constant()) {
+                // Just ignore this option for now.
+                // FIXME: need full implementation
+                continue;
+            } else {
+                rop.shadingcontext()->errorfmt(
+                    "texture{} optional argument \"{}\" must be constant after optimization ({}:{})",
+                    tex3d ? "3d" : "", name, op.sourcefile(), op.sourceline());
+                continue;
+            }
+        }
+
 
         // PARAM_FLOAT(time)
         if (name == Strings::time

testsuite/texture-colorspace/BATCHED

@@ -0,0 +1,5 @@
+Compiled test.osl -> test.oso
+
+Output Cout to out.exr
+color space - none specified: 0.5 0.5 0.5
+color space - sRGB: 0.5 0.5 0.5

testsuite/texture-colorspace/ref/out.txt

@@ -0,0 +1,9 @@
+#!/usr/bin/env python
+
+# Copyright Contributors to the Open Shading Language project.
+# SPDX-License-Identifier: BSD-3-Clause
+# https://github.com/AcademySoftwareFoundation/OpenShadingLanguage
+
+command += oiiotool ("-pattern constant:color=0.5,0.5,0.5 64x64 3 -d half -otex grey.exr")
+command += testshade("-g 1 1 --center -od half -o Cout out.exr test")
+outputs = [ "out.txt" ]

testsuite/texture-colorspace/run.py

@@ -0,0 +1,13 @@
+// Copyright Contributors to the Open Shading Language project.
+// SPDX-License-Identifier: BSD-3-Clause
+// https://github.com/AcademySoftwareFoundation/OpenShadingLanguage
+
+shader
+test (string filename = "grey.exr",
+      output color Cout = 0)
+{
+    Cout = (color)texture (filename, u, v);
+    printf("color space - none specified: %g\n", Cout);
+    Cout = (color)texture (filename, u, v, "colorspace", "sRGB");
+    printf("color space - sRGB: %g\n", Cout);
+}