Merge pull request #425 from GPUOpen-LibrariesAndSDKs/develop

Merge version 2.0.13

CHANGELOG.MD

@@ -1,5 +1,21 @@
 # Change Log
 
+## Version 2.0.13
+- Improved interactivity with Interactive Renders.
+- Some issues with texture compression present in version 3.0.1 are fixed.
+- Issues with normal maps (related to texture compression) are also fixed.
+- Fixed issues with .rpr file export:
+    - Fixed the AOV names in config.json file.
+    - Fixed the contour rendering option in config.json file
+    - Export of .rpr file is made faster and textures are reused between animation frames.
+- Users no longer need to manually restart the render when switching render mode in Houdini.
+- Time-to-first-pixel is made faster when not using denoisers.
+- Added an ID parameter to Render Geometry Settings Node in Houdini for setting an explicit Object ID.
+- Add a Houdini Node RPR Material Properties for explicitly setting the Material ID to be used in the corresponding AOV.
+- Single and two-channel textures are handled correctly now.
+- Fixed USDPreviewSurface Normal Maps.
+
+
 ## Version 2.0
 ### New Features:
 -   The new plug-in version incorporates version 2.0 of our Radeon™ ProRender system and brings about the significant changes and enhancements:

CMakeLists.txt

@@ -36,3 +36,10 @@ add_subdirectory(pxr/imaging)
 install(FILES README.md DESTINATION .)
 install(FILES INSTALL.md DESTINATION .)
 install(FILES LICENSE.md DESTINATION .)
+
+install(
+    CODE
+    "FILE(WRITE \"${CMAKE_INSTALL_PREFIX}/version\"
+\"core:${RPR_VERSION_STRING}
+plugin:${HD_RPR_MAJOR_VERSION}.${HD_RPR_MINOR_VERSION}.${HD_RPR_PATCH_VERSION}
+\")")

cmake/defaults/ProjectDefaults.cmake

@@ -50,6 +50,8 @@ if (PXR_BUILD_TESTS)
     enable_testing()
 endif()
 
+include(parseVersion)
+
 if(NOT DEFINED RPR_SDK_PLATFORM)
     include(PlatformIntrospection)
     DETERMINE_PLATFORM(RPR_SDK_PLATFORM)

cmake/defaults/Version.cmake

@@ -24,4 +24,4 @@
 # Versioning information
 set(HD_RPR_MAJOR_VERSION "2")
 set(HD_RPR_MINOR_VERSION "0")
-set(HD_RPR_PATCH_VERSION "1")
+set(HD_RPR_PATCH_VERSION "13")

cmake/macros/parseVersion.cmake

@@ -0,0 +1,21 @@
+macro(parseVersion version_file prefix)
+    if(NOT EXISTS ${version_file})
+        message(FATAL_ERROR "Invalid ${prefix} SDK: missing ${version_file} file")
+    endif()
+
+    file(STRINGS "${version_file}" _major_version_str
+         REGEX "^#define[\t ]+${prefix}_VERSION_MAJOR[\t ]+.*")
+    file(STRINGS "${version_file}" _minor_version_str
+         REGEX "^#define[\t ]+${prefix}_VERSION_MINOR[\t ]+.*")
+    file(STRINGS "${version_file}" _revision_version_str
+         REGEX "^#define[\t ]+${prefix}_VERSION_REVISION[\t ]+.*")
+
+    string(REGEX REPLACE "^.*MAJOR[\t ]+([0-9]*).*$" "\\1"
+           ${prefix}_MAJOR_VERSION "${_major_version_str}")
+    string(REGEX REPLACE "^.*MINOR[\t ]+([0-9]*).*$" "\\1"
+           ${prefix}_MINOR_VERSION "${_minor_version_str}")
+    string(REGEX REPLACE "^.*REVISION[\t ]+([0-9]*).*$" "\\1"
+           ${prefix}_REVISION_VERSION "${_revision_version_str}")
+
+    set(${prefix}_VERSION_STRING "${${prefix}_MAJOR_VERSION}.${${prefix}_MINOR_VERSION}.${${prefix}_REVISION_VERSION}")
+endmacro()

cmake/modules/FindRif.cmake

@@ -53,32 +53,13 @@ if(NOT DEFINED RIF_MODELS_DIR)
     set(RIF_MODELS_DIR "${RIF_LOCATION}/models")
 endif()
 
-set(RIF_VERSION_FILE "${RIF_LOCATION_INCLUDE}/RadeonImageFilters_version.h")
-if(NOT EXISTS ${RIF_VERSION_FILE})
-    message(FATAL_ERROR "Invalid RIF SDK: missing ${RIF_VERSION_FILE} file")
-endif()
-
-file(STRINGS "${RIF_VERSION_FILE}" _rif_major_version_str
-     REGEX "^#define[\t ]+RIF_VERSION_MAJOR[\t ]+.*")
-file(STRINGS "${RIF_VERSION_FILE}" _rif_minor_version_str
-     REGEX "^#define[\t ]+RIF_VERSION_MINOR[\t ]+.*")
-file(STRINGS "${RIF_VERSION_FILE}" _rif_revision_version_str
-     REGEX "^#define[\t ]+RIF_VERSION_REVISION[\t ]+.*")
-
-string(REGEX REPLACE "^.*MAJOR[\t ]+([0-9]*).*$" "\\1"
-       RIF_MAJOR_VERSION "${_rif_major_version_str}")
-string(REGEX REPLACE "^.*MINOR[\t ]+([0-9]*).*$" "\\1"
-       RIF_MINOR_VERSION "${_rif_minor_version_str}")
-string(REGEX REPLACE "^.*REVISION[\t ]+([0-9]*).*$" "\\1"
-       RIF_REVISION_VERSION "${_rif_revision_version_str}")
-
-set(RIF_VERSION_STRING "${RIF_MAJOR_VERSION}.${RIF_MINOR_VERSION}.${RIF_REVISION_VERSION}")
+parseVersion("${RIF_LOCATION_INCLUDE}/RadeonImageFilters_version.h" RIF)
 
 include(FindPackageHandleStandardArgs)
 
 find_package_handle_standard_args(Rif
     REQUIRED_VARS
-        RIF_VERSION_STRING
         RIF_LOCATION_INCLUDE
+        RIF_VERSION_STRING
         RIF_LIBRARY
 )

cmake/modules/FindRpr.cmake

@@ -81,11 +81,14 @@ if(NOT RPR_PLUGINS)
     message(FATAL_ERROR "At least one RPR plugin required")
 endif()
 
+parseVersion("${RPR_LOCATION_INCLUDE}/RadeonProRender.h" RPR)
+
 include(FindPackageHandleStandardArgs)
 
 find_package_handle_standard_args(Rpr
     REQUIRED_VARS
         RPR_LOCATION_INCLUDE
+        RPR_VERSION_STRING
         RPR_LOADSTORE_LIBRARY
         RPR_LIBRARY
 )

deps/CMakeLists.txt

@@ -50,7 +50,7 @@ add_library(cpprpr STATIC
     ${RPR_CPP_WRAPPER_LOCATION}/RadeonProRenderCpp.cpp
     ${RPR_CPP_WRAPPER_LOCATION}/tinyxml2.cpp)
 set_target_properties(cpprpr PROPERTIES POSITION_INDEPENDENT_CODE ON)
-target_include_directories(cpprpr PUBLIC ${RPR_CPP_WRAPPER_LOCATION} ${RPRMTLXLOADER_LOCATION})
+target_include_directories(cpprpr PUBLIC ${RPRMTLXLOADER_LOCATION} ${RPR_CPP_WRAPPER_LOCATION})
 target_link_libraries(cpprpr PUBLIC rpr MaterialXCore MaterialXFormat)
 target_compile_definitions(cpprpr PUBLIC
     RPR_CPPWRAPER_DISABLE_MUTEXLOCK

deps/rprMtlxLoader/rprMtlxLoader.cpp

@@ -367,6 +367,7 @@ struct RprMappedNode : public RprNode {
 struct RprImageNode : public RprMappedNode {
     // TODO: support frame ranges
 
+    std::string type;
     std::string file;
     std::string layer;
     mx::ValuePtr defaultValue;
@@ -379,7 +380,7 @@ struct RprImageNode : public RprMappedNode {
     // TODO: can we support this in RPR?
     //std::string filtertype;
 
-    RprImageNode(LoaderContext* context);
+    RprImageNode(std::string const& type, LoaderContext* context);
     ~RprImageNode() override = default;
 
     rpr_status SetInput(mx::Element* inputElement, std::string const& value, std::string const& valueType, LoaderContext* context) override;
@@ -824,7 +825,7 @@ Node::Ptr Node::Create(mx::Node* mtlxNode, LoaderContext* context) {
         };
         rprNodeMapping = &s_sqrtMapping;
     } else if (mtlxNode->getCategory() == "image") {
-        return std::make_unique<RprImageNode>(context);
+        return std::make_unique<RprImageNode>(mtlxNode->getType(), context);
     } else if (mtlxNode->getCategory() == "swizzle") {
         // TODO: implement healthy man swizzle
 
@@ -1371,7 +1372,7 @@ rpr_status RprMappedNode::SetInput(mx::Element* inputElement, std::string const&
     return RprNode::SetInput(inputIt->second, valueString, valueType, context);
 }
 
-RprImageNode::RprImageNode(LoaderContext* context)
+RprImageNode::RprImageNode(std::string const& type, LoaderContext* context)
     : RprMappedNode(
         [context]() {
             rpr_material_node node = nullptr;
@@ -1386,7 +1387,8 @@ RprImageNode::RprImageNode(LoaderContext* context)
             };
             return &s_imageMapping;
         }()
-    ) {
+    )
+    , type(type) {
 
 }
 
@@ -1995,6 +1997,7 @@ RPRMtlxLoader::Result RPRMtlxLoader::Load(
                     outImageNodes.emplace_back();
                     auto& outImageNode = outImageNodes.back();
 
+                    std::swap(outImageNode.type, imageNode->type);
                     std::swap(outImageNode.file, imageNode->file);
                     std::swap(outImageNode.layer, imageNode->layer);
                     std::swap(outImageNode.defaultValue, imageNode->defaultValue);

deps/rprMtlxLoader/rprMtlxLoader.h

@@ -41,6 +41,9 @@ class RPRMtlxLoader {
         static const size_t kInvalidRootNodeIndex = size_t(-1);
 
         struct ImageNode {
+            /// MaterialX type
+            std::string type;
+
             /// The URI of an image file.
             /// It's responsibility of the loader user to setup rpr_image and bind it to rprNode
             std::string file;

pxr/imaging/plugin/hdRpr/CMakeLists.txt

@@ -29,7 +29,7 @@ endif(HoudiniUSD_FOUND)
 set(GEN_SCRIPT_PYTHON ${PYTHON_EXECUTABLE})
 set(GENERATION_SCRIPTS_DIR ${CMAKE_CURRENT_SOURCE_DIR}/python)
 set(GEN_SCRIPT ${GENERATION_SCRIPTS_DIR}/generateFiles.py)
-set(GEN_SCRIPT_ARGS \"${GENERATION_SCRIPTS_DIR}\" \"${CMAKE_CURRENT_BINARY_DIR}\")
+set(GEN_SCRIPT_ARGS \"${CMAKE_CURRENT_BINARY_DIR}\")
 set(GENERATED_FILES
     ${CMAKE_CURRENT_BINARY_DIR}/config.h
     ${CMAKE_CURRENT_BINARY_DIR}/config.cpp)
@@ -39,7 +39,7 @@ set(GENERATION_DEPENDENT_FILES ${GEN_SCRIPT}
     ${GENERATION_SCRIPTS_DIR}/generateRenderSettingFiles.py
     ${GENERATION_SCRIPTS_DIR}/generateGeometrySettingFiles.py)
 if(HoudiniUSD_FOUND)
-    set(GEN_SCRIPT_ARGS --houdini_root \"${HOUDINI_ROOT}\" ${GEN_SCRIPT_ARGS})
+    set(GEN_SCRIPT_ARGS --for_houdini ${GEN_SCRIPT_ARGS})
     set(GENERATED_FILES ${GENERATED_FILES}
         ${CMAKE_CURRENT_BINARY_DIR}/HdRprPlugin_Light.ds
         ${CMAKE_CURRENT_BINARY_DIR}/HdRprPlugin_Global.ds
@@ -62,8 +62,6 @@ if(HoudiniUSD_FOUND)
     }\")")
 endif()
 
-set(GEN_SCRIPT_ARGS --python_exe "\"${GEN_SCRIPT_PYTHON}\"" ${GEN_SCRIPT_ARGS})
-
 add_custom_command(
     COMMAND ${GEN_SCRIPT_PYTHON} ${GEN_SCRIPT} ${GEN_SCRIPT_ARGS}
     DEPENDS ${GENERATION_DEPENDENT_FILES}

pxr/imaging/plugin/hdRpr/aovDescriptor.cpp

@@ -25,7 +25,7 @@ TF_INSTANTIATE_SINGLETON(HdRprAovRegistry);
 TF_DEFINE_PUBLIC_TOKENS(HdRprAovTokens, HDRPR_AOV_TOKENS);
 
 HdRprAovRegistry::HdRprAovRegistry() {
-    const auto rprAovMax = RPR_AOV_LPE_8 + 1;
+    const auto rprAovMax = RPR_AOV_CRYPTOMATTE_OBJ2 + 1;
     const GfVec4f idClearValue(255.0f, 255.0f, 255.0f, 0.0f);
 
     m_aovDescriptors.resize(rprAovMax);
@@ -61,7 +61,13 @@ HdRprAovRegistry::HdRprAovRegistry() {
             RPR_AOV_LPE_5,
             RPR_AOV_LPE_6,
             RPR_AOV_LPE_7,
-            RPR_AOV_LPE_8
+            RPR_AOV_LPE_8,
+            RPR_AOV_CRYPTOMATTE_MAT0,
+            RPR_AOV_CRYPTOMATTE_MAT1,
+            RPR_AOV_CRYPTOMATTE_MAT2,
+            RPR_AOV_CRYPTOMATTE_OBJ0,
+            RPR_AOV_CRYPTOMATTE_OBJ1,
+            RPR_AOV_CRYPTOMATTE_OBJ2,
         }) {
         m_aovDescriptors[rprAovId] = HdRprAovDescriptor(rprAovId);
     }
@@ -78,6 +84,7 @@ HdRprAovRegistry::HdRprAovRegistry() {
     m_aovDescriptors[RPR_AOV_BACKGROUND] = HdRprAovDescriptor(RPR_AOV_BACKGROUND, false);
     m_aovDescriptors[RPR_AOV_VELOCITY] = HdRprAovDescriptor(RPR_AOV_VELOCITY, false);
     m_aovDescriptors[RPR_AOV_VIEW_SHADING_NORMAL] = HdRprAovDescriptor(RPR_AOV_VIEW_SHADING_NORMAL, false);
+    m_aovDescriptors[RPR_AOV_CAMERA_NORMAL] = HdRprAovDescriptor(RPR_AOV_CAMERA_NORMAL, false);
 
     m_computedAovDescriptors.resize(kComputedAovsCount);
     m_computedAovDescriptors[kNdcDepth] = HdRprAovDescriptor(kNdcDepth, false, HdFormatFloat32, GfVec4f(std::numeric_limits<float>::infinity()), true);
@@ -135,6 +142,13 @@ HdRprAovRegistry::HdRprAovRegistry() {
     addAovNameLookup(HdRprAovTokens->lpe6, m_aovDescriptors[RPR_AOV_LPE_6]);
     addAovNameLookup(HdRprAovTokens->lpe7, m_aovDescriptors[RPR_AOV_LPE_7]);
     addAovNameLookup(HdRprAovTokens->lpe8, m_aovDescriptors[RPR_AOV_LPE_8]);
+    addAovNameLookup(HdRprAovTokens->cameraNormal, m_aovDescriptors[RPR_AOV_CAMERA_NORMAL]);
+    addAovNameLookup(HdRprAovTokens->cryptomatteMat0, m_aovDescriptors[RPR_AOV_CRYPTOMATTE_MAT0]);
+    addAovNameLookup(HdRprAovTokens->cryptomatteMat1, m_aovDescriptors[RPR_AOV_CRYPTOMATTE_MAT1]);
+    addAovNameLookup(HdRprAovTokens->cryptomatteMat2, m_aovDescriptors[RPR_AOV_CRYPTOMATTE_MAT2]);
+    addAovNameLookup(HdRprAovTokens->cryptomatteObj0, m_aovDescriptors[RPR_AOV_CRYPTOMATTE_OBJ0]);
+    addAovNameLookup(HdRprAovTokens->cryptomatteObj1, m_aovDescriptors[RPR_AOV_CRYPTOMATTE_OBJ1]);
+    addAovNameLookup(HdRprAovTokens->cryptomatteObj2, m_aovDescriptors[RPR_AOV_CRYPTOMATTE_OBJ2]);
 }
 
 HdRprAovDescriptor const& HdRprAovRegistry::GetAovDesc(TfToken const& name) {

pxr/imaging/plugin/hdRpr/aovDescriptor.h

@@ -65,6 +65,13 @@ PXR_NAMESPACE_OPEN_SCOPE
     (lpe6) \
     (lpe7) \
     (lpe8) \
+    (cameraNormal) \
+    (cryptomatteMat0) \
+    (cryptomatteMat1) \
+    (cryptomatteMat2) \
+    (cryptomatteObj0) \
+    (cryptomatteObj1) \
+    (cryptomatteObj2) \
 
 TF_DECLARE_PUBLIC_TOKENS(HdRprAovTokens, HDRPR_AOV_TOKENS);
 

pxr/imaging/plugin/hdRpr/mesh.cpp

@@ -360,7 +360,9 @@ void HdRprMesh::Sync(HdSceneDelegate* sceneDelegate,
         }
     }
 
+    bool isIgnoreContourDirty = false;
     bool isVisibilityMaskDirty = false;
+    bool isIdDirty = false;
     if (*dirtyBits & HdChangeTracker::DirtyPrimvar) {
         HdRprGeometrySettings geomSettings = {};
         geomSettings.visibilityMask = kVisibleAll;
@@ -376,6 +378,16 @@ void HdRprMesh::Sync(HdSceneDelegate* sceneDelegate,
             m_visibilityMask = geomSettings.visibilityMask;
             isVisibilityMaskDirty = true;
         }
+
+        if (m_id != geomSettings.id) {
+            m_id = geomSettings.id;
+            isIdDirty = true;
+        }
+
+        if (m_ignoreContour != geomSettings.ignoreContour) {
+            m_ignoreContour = geomSettings.ignoreContour;
+            isIgnoreContourDirty = true;
+        }
     }
 
     m_smoothNormals = m_displayStyle.flatShadingEnabled;
@@ -420,7 +432,6 @@ void HdRprMesh::Sync(HdSceneDelegate* sceneDelegate,
 
         if (m_geomSubsets.empty()) {
             if (auto rprMesh = rprApi->CreateMesh(m_points, m_faceVertexIndices, m_normals, m_normalIndices, m_uvs, m_uvIndices, m_faceVertexCounts, m_topology.GetOrientation())) {
-                rprApi->SetMeshId(rprMesh, GetPrimId());
                 m_rprMeshes.push_back(rprMesh);
             }
         } else {
@@ -524,7 +535,6 @@ void HdRprMesh::Sync(HdSceneDelegate* sceneDelegate,
                 }
 
                 if (auto rprMesh = rprApi->CreateMesh(subsetPoints, subsetIndexes, subsetNormals, subsetNormalIndices, subsetUv, subsetUvIndices, subsetVertexPerFace, m_topology.GetOrientation())) {
-                    rprApi->SetMeshId(rprMesh, GetPrimId());
                     m_rprMeshes.push_back(rprMesh);
                     ++it;
                 } else {
@@ -664,7 +674,6 @@ void HdRprMesh::Sync(HdSceneDelegate* sceneDelegate,
                                 int32_t meshId = GetPrimId();
                                 for (int j = meshInstances.size(); j < newNumInstances; ++j) {
                                     meshInstances.push_back(rprApi->CreateMeshInstance(m_rprMeshes[i]));
-                                    rprApi->SetMeshId(meshInstances.back(), meshId);
                                 }
                             }
                         }
@@ -696,6 +705,24 @@ void HdRprMesh::Sync(HdSceneDelegate* sceneDelegate,
             }
         }
 
+        if (newMesh || isIdDirty) {
+            uint32_t id = m_id >= 0 ? uint32_t(m_id) : GetPrimId();
+            for (auto& rprMesh : m_rprMeshes) {
+                rprApi->SetMeshId(rprMesh, id);
+            }
+            for (auto& instances : m_rprMeshInstances) {
+                for (auto& rprMesh : instances) {
+                    rprApi->SetMeshId(rprMesh, id);
+                }
+            }
+        }
+
+        if (newMesh || isIgnoreContourDirty) {
+            for (auto& rprMesh : m_rprMeshes) {
+                rprApi->SetMeshIgnoreContour(rprMesh, m_ignoreContour);
+            }
+        }
+
         if (updateTransform) {
             for (auto& rprMesh : m_rprMeshes) {
                 rprApi->SetTransform(rprMesh, m_transformSamples.count, m_transformSamples.times.data(), m_transformSamples.values.data());

pxr/imaging/plugin/hdRpr/mesh.h

@@ -96,7 +96,9 @@ class HdRprMesh final : public HdRprBaseRprim<HdMesh> {
     HdDisplayStyle m_displayStyle;
     int m_refineLevel = 0;
 
-    uint32_t m_visibilityMask;
+    int m_id = -1;
+    uint32_t m_visibilityMask = 0;
+    bool m_ignoreContour;
 };
 
 PXR_NAMESPACE_CLOSE_SCOPE

pxr/imaging/plugin/hdRpr/primvarUtil.cpp

@@ -17,7 +17,9 @@ limitations under the License.
 PXR_NAMESPACE_OPEN_SCOPE
 
 TF_DEFINE_PRIVATE_TOKENS(HdRprGeometryPrimvarTokens,
+    ((id, "rpr:id"))
     ((subdivisionLevel, "rpr:subdivisionLevel"))
+    ((ignoreContour, "rpr:ignoreContour"))
     ((visibilityPrimary, "rpr:visibilityPrimary"))
     ((visibilityShadow, "rpr:visibilityShadow"))
     ((visibilityReflection, "rpr:visibilityReflection"))
@@ -49,11 +51,15 @@ void HdRprParseGeometrySettings(
     };
 
     for (auto& desc : constantPrimvarDescs) {
-        if (desc.name == HdRprGeometryPrimvarTokens->subdivisionLevel) {
+        if (desc.name == HdRprGeometryPrimvarTokens->id) {
+            HdRprGetConstantPrimvar(HdRprGeometryPrimvarTokens->id, sceneDelegate, id, &geomSettings->id);
+        } else if (desc.name == HdRprGeometryPrimvarTokens->subdivisionLevel) {
             int subdivisionLevel;
             if (HdRprGetConstantPrimvar(HdRprGeometryPrimvarTokens->subdivisionLevel, sceneDelegate, id, &subdivisionLevel)) {
                 geomSettings->subdivisionLevel = std::max(0, std::min(subdivisionLevel, 7));
             }
+        } else if (desc.name == HdRprGeometryPrimvarTokens->ignoreContour) {
+            HdRprGetConstantPrimvar(HdRprGeometryPrimvarTokens->ignoreContour, sceneDelegate, id, &geomSettings->ignoreContour);
         } else if (desc.name == HdRprGeometryPrimvarTokens->visibilityPrimary) {
             setVisibilityFlag(HdRprGeometryPrimvarTokens->visibilityPrimary, kVisiblePrimary);
         } else if (desc.name == HdRprGeometryPrimvarTokens->visibilityShadow) {