api: Add ShadingSystem query to ask if attribute derivatives are requested. (#1932)

This PR adds an API to ask the shading system if derivatives are required for attributes needed by a shader group.

Signed-off-by: Curtis Black <[email protected]>

Author: curtisblack

src/include/OSL/oslexec.h

@@ -483,6 +483,9 @@ class OSLEXECPUBLIC ShadingSystem {
     ///   ptr userdata_offsets       Retrieves a pointer to the array of
     ///                                 int describing the userdata offsets
     ///                                 within the heap.
+    ///   ptr userdata_derivs        Retrieves a pointer to the array of
+    ///                                 bools (as bytes) describing if derivatives
+    ///                                 are requested for each userdata.
     ///   int num_attributes_needed  The number of attribute/scope pairs that
     ///                                are known to be queried by the group (the
     ///                                length of the attributes_needed and
@@ -499,6 +502,9 @@ class OSLEXECPUBLIC ShadingSystem {
     ///                                in the attributes_needed array.
     ///   ptr attribute_types        Retrieves a pointer to the array of
     ///                                 TypeDesc describing the attributes.
+    ///   ptr attribute_derivs       Retrieves a pointer to the array of
+    ///                                 bools (as bytes) describing if derivatives
+    ///                                 are requested for each attribute.
     ///   int unknown_attributes_needed  Nonzero if additional attributes may be
     ///                                  needed, whose names will not be known
     ///                                  until the shader actually runs.

src/liboslexec/oslexec_pvt.h

@@ -218,10 +218,11 @@ struct AttributeNeeded {
     ustring name;
     ustring scope;
     TypeDesc type;
+    bool derivs;
 
     AttributeNeeded(ustring name, ustring scope = ustring(),
-                    TypeDesc type = TypeUnknown)
-        : name(name), scope(scope), type(type)
+                    TypeDesc type = TypeUnknown, bool derivs = false)
+        : name(name), scope(scope), type(type), derivs(derivs)
     {
     }
 
@@ -240,6 +241,7 @@ struct AttributeNeeded {
         // Ignore vector semantics
         // if (a.type.vecsemantics != b.type.vecsemantics)
         //     return a.type.vecsemantics < b.type.vecsemantics;
+        // Do not sort based on derivs
         return false;  // they are equal
     }
 };
@@ -2035,6 +2037,7 @@ class ShaderGroup {
     std::vector<ustring> m_attributes_needed;
     std::vector<ustring> m_attribute_scopes;
     std::vector<TypeDesc> m_attribute_types;
+    std::vector<char> m_attribute_derivs;
     std::vector<ustring> m_renderer_outputs;  ///< Names of renderer outputs
     std::vector<SymLocationDesc> m_symlocs;   ///< SORTED!!
     bool m_unknown_textures_needed;

src/liboslexec/runtimeoptimize.cpp

@@ -3369,39 +3369,51 @@ RuntimeOptimizer::run()
                 Symbol* sym1 = opargsym(op, 1);
                 OSL_DASSERT(sym1 && sym1->typespec().is_string());
                 if (sym1->is_constant()) {
+                    const auto insert = [&](const AttributeNeeded& attr) {
+                        auto found = m_attributes_needed.find(attr);
+                        if (found == m_attributes_needed.end())
+                            m_attributes_needed.insert(attr);
+                        else if (attr.derivs && !found->derivs) {
+                            m_attributes_needed.erase(found);
+                            m_attributes_needed.insert(attr);
+                        }
+                    };
                     if (op.nargs() == 3) {
                         Symbol* sym2 = opargsym(op, 2);
                         // getattribute( attributename, result )
-                        m_attributes_needed.insert(
-                            AttributeNeeded(sym1->get_string(), ustring(),
-                                            sym2->typespec().simpletype()));
+                        insert(AttributeNeeded(sym1->get_string(), ustring(),
+                                               sym2->typespec().simpletype(),
+                                               sym2->has_derivs()));
                     } else if (op.nargs() == 4) {
                         Symbol* sym2 = opargsym(op, 2);
                         Symbol* sym3 = opargsym(op, 3);
                         if (sym2->typespec().is_string()) {
                             // getattribute( scopename, attributename, result )
                             if (sym2->is_constant()) {
-                                m_attributes_needed.insert(AttributeNeeded(
+                                insert(AttributeNeeded(
                                     sym2->get_string(), sym1->get_string(),
-                                    sym3->typespec().simpletype()));
+                                    sym3->typespec().simpletype(),
+                                    sym3->has_derivs()));
                             } else {
                                 m_unknown_attributes_needed = true;
                             }
                         } else {
                             // getattribute( attributename, arrayindex, result )
-                            m_attributes_needed.insert(
+                            insert(
                                 AttributeNeeded(sym1->get_string(), ustring(),
-                                                sym3->typespec().simpletype()));
+                                                sym3->typespec().simpletype(),
+                                                sym3->has_derivs()));
                         }
                     } else if (op.nargs() == 5) {
                         Symbol* sym2 = opargsym(op, 2);
                         Symbol* sym4 = opargsym(op, 4);
                         if (sym2->typespec().is_string()) {
                             // getattribute( scopename, attributename, arrayindex, result )
                             if (sym2->is_constant()) {
-                                m_attributes_needed.insert(AttributeNeeded(
+                                insert(AttributeNeeded(
                                     sym2->get_string(), sym1->get_string(),
-                                    sym4->typespec().simpletype()));
+                                    sym4->typespec().simpletype(),
+                                    sym4->has_derivs()));
                             } else {
                                 m_unknown_attributes_needed = true;
                             }

src/liboslexec/shadingsys.cpp

@@ -2282,6 +2282,11 @@ ShadingSystemImpl::getattribute(ShaderGroup* group, string_view name,
         *(TypeDesc**)val = n ? &group->m_attribute_types[0] : NULL;
         return true;
     }
+    if (name == "attribute_derivs" && type.basetype == TypeDesc::PTR) {
+        size_t n     = group->m_attribute_derivs.size();
+        *(char**)val = n ? &group->m_attribute_derivs[0] : NULL;
+        return true;
+    }
     if (name == "unknown_attributes_needed" && type == TypeInt) {
         *(int*)val = (int)group->m_unknown_attributes_needed;
         return true;
@@ -3792,6 +3797,7 @@ ShadingSystemImpl::optimize_group(ShaderGroup& group, ShadingContext* ctx,
             group.m_attributes_needed.push_back(f.name);
             group.m_attribute_scopes.push_back(f.scope);
             group.m_attribute_types.push_back(f.type);
+            group.m_attribute_derivs.push_back(f.derivs);
         }
         group.m_optimized = true;