From 37fc7c464e5ca16eb97076ea1c835191c7fd0079 Mon Sep 17 00:00:00 2001
From: SEB SCHMIDT <sschmidt@wetafx.co.nz>
Date: Tue, 30 Jul 2024 01:48:58 +1200
Subject: [PATCH] Adding Hydra Generative Procedural Example of a simple
 Triangle

Signed-off-by: Seb Schmidt <sschmidt@wetafx.co.nz>
---
 README.md                                |   1 +
 src/CMakeLists.txt                       |   1 +
 src/hdGpTri/CMakeLists.txt               |  25 +++
 src/hdGpTri/debugCodes.cpp               |  18 ++
 src/hdGpTri/debugCodes.h                 |  15 ++
 src/hdGpTri/plugInfo.json                |  22 ++
 src/hdGpTri/scenes/triangle.usda         |  42 ++++
 src/hdGpTri/scenes/triangleAnimated.usda |  23 ++
 src/hdGpTri/triGenerative.cpp            | 265 +++++++++++++++++++++++
 src/hdGpTri/triGenerative.h              |  52 +++++
 10 files changed, 464 insertions(+)
 create mode 100644 src/hdGpTri/CMakeLists.txt
 create mode 100644 src/hdGpTri/debugCodes.cpp
 create mode 100644 src/hdGpTri/debugCodes.h
 create mode 100644 src/hdGpTri/plugInfo.json
 create mode 100644 src/hdGpTri/scenes/triangle.usda
 create mode 100644 src/hdGpTri/scenes/triangleAnimated.usda
 create mode 100644 src/hdGpTri/triGenerative.cpp
 create mode 100644 src/hdGpTri/triGenerative.h

diff --git a/README.md b/README.md
index 9bfd1de..74f98ce 100644
--- a/README.md
+++ b/README.md
@@ -26,6 +26,7 @@ Huge thanks to Pixar's USD team for providing a highly extensible platform!
 - [usdTriImagingHd2](./src/usdTriImagingHd2): A *Hydra 2 only* prim adapter which images the **Triangle** prim type. [*]
 - [usdTriFileFormat](./src/usdTriFileFormat): A file format plugin which authors a triangular mesh for a `.triangle` payload.
 - [hdTri](./src/hdTri): A hydra renderer plugin which images a triangle (in the most direct sense).
+- [hdGpTri](./src/hdGpTri): A generative procedural plugin which creates a triangle (in the most direct sense).
 - [usdviewTri](./src/usdviewTri): An usdview plugin providing a menu command to define child Triangle prim(s) under selected paths.
 
 [*] We deliberatly split the Hydra 1 & 2 Triangle Prim Adapters into two plugins/sources to outline the differences
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 42f1746..28864fd 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -16,6 +16,7 @@ endif()
 
 add_subdirectory(usdTriFileFormat)
 add_subdirectory(hdTri)
+add_subdirectory(hdGpTri)
 
 # Install top-level plugInfo for including per-library plugInfo(s).
 install(
diff --git a/src/hdGpTri/CMakeLists.txt b/src/hdGpTri/CMakeLists.txt
new file mode 100644
index 0000000..3f1124a
--- /dev/null
+++ b/src/hdGpTri/CMakeLists.txt
@@ -0,0 +1,25 @@
+usd_plugin(hdGpTri
+
+    PUBLIC_HEADERS_INSTALL_PREFIX
+        ${ORGANIZATION}
+
+    PYTHON_INSTALL_PREFIX
+        ${ORGANIZATION}
+
+    LIBRARIES
+        js
+        plug
+        tf
+        sdf
+        vt
+        gf
+        hdGp
+        arch
+
+    CPPFILES
+        triGenerative.cpp
+        debugCodes.cpp
+
+    RESOURCE_FILES
+        plugInfo.json
+)
diff --git a/src/hdGpTri/debugCodes.cpp b/src/hdGpTri/debugCodes.cpp
new file mode 100644
index 0000000..cf720a7
--- /dev/null
+++ b/src/hdGpTri/debugCodes.cpp
@@ -0,0 +1,18 @@
+//
+// Copyright © 2024 Weta Digital Limited
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+#include "debugCodes.h"
+#include "pxr/base/tf/debug.h"
+#include <pxr/base/tf/registryManager.h>
+
+PXR_NAMESPACE_OPEN_SCOPE
+
+TF_REGISTRY_FUNCTION(TfDebug)
+{
+    TF_DEBUG_ENVIRONMENT_SYMBOL(
+        USDTRI_GENERATIVE, "Debug symbol for the usdTri GenerativeProcedural.");
+}
+
+PXR_NAMESPACE_CLOSE_SCOPE
diff --git a/src/hdGpTri/debugCodes.h b/src/hdGpTri/debugCodes.h
new file mode 100644
index 0000000..14f80ec
--- /dev/null
+++ b/src/hdGpTri/debugCodes.h
@@ -0,0 +1,15 @@
+//
+// Copyright © 2024 Weta Digital Limited
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+#pragma once
+
+#include <pxr/pxr.h>
+#include <pxr/base/tf/debug.h>
+
+PXR_NAMESPACE_OPEN_SCOPE
+
+TF_DEBUG_CODES(USDTRI_GENERATIVE);
+
+PXR_NAMESPACE_CLOSE_SCOPE
diff --git a/src/hdGpTri/plugInfo.json b/src/hdGpTri/plugInfo.json
new file mode 100644
index 0000000..e6e8978
--- /dev/null
+++ b/src/hdGpTri/plugInfo.json
@@ -0,0 +1,22 @@
+{
+    "Plugins": [
+        {
+            "Info": {
+                "Types": {
+                    "TriProceduralPlugin": {
+                        "bases": [
+                            "HdGpGenerativeProceduralPlugin"
+                        ],
+                        "displayName": "triangle",
+                        "priority" : 0
+                    }
+                }
+            },
+            "LibraryPath": "../../hdGpTri.so",
+            "Name": "hdGpTri",
+            "ResourcePath": "resources",
+            "Root": "..",
+            "Type": "library"
+        }
+    ]
+}
diff --git a/src/hdGpTri/scenes/triangle.usda b/src/hdGpTri/scenes/triangle.usda
new file mode 100644
index 0000000..a3534f3
--- /dev/null
+++ b/src/hdGpTri/scenes/triangle.usda
@@ -0,0 +1,42 @@
+#usda 1.0
+
+
+def Scope "World"
+{
+    def GenerativeProcedural "myGenerativeProc" (
+        prepend apiSchemas = ["HydraGenerativeProceduralAPI"]
+    )
+    {
+        token primvars:hdGp:proceduralType = "triangle"
+        double primvars:sideLength = 1.0
+    }
+
+    def Scope "leaf_transformed"
+    {
+
+        def GenerativeProcedural "myGenerativeProcTransformed" (
+            prepend apiSchemas = ["HydraGenerativeProceduralAPI"]
+        )
+        {
+            token primvars:hdGp:proceduralType = "triangle"
+            double primvars:sideLength = 1.0
+
+            matrix4d xformOp:transform:transform1 = ( (1, 0, 0, 0), (0, 1, 0, 0), (0, 0, 1, 0), (15, 15, 15, 1) )
+            uniform token[] xformOpOrder = ["xformOp:transform:transform1"]
+        }
+    }
+    def Xform "transformed"
+    {
+        matrix4d xformOp:transform:transform1 = ( (1, 0, 0, 0), (0, 1, 0, 0), (0, 0, 1, 0), (15, 15, 15, 1) )
+        uniform token[] xformOpOrder = ["xformOp:transform:transform1"]
+
+        def GenerativeProcedural "myGenerativeProcTransformed" (
+            prepend apiSchemas = ["HydraGenerativeProceduralAPI"]
+        )
+        {
+            token primvars:hdGp:proceduralType = "triangle"
+            double primvars:sideLength = 1.0
+
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/hdGpTri/scenes/triangleAnimated.usda b/src/hdGpTri/scenes/triangleAnimated.usda
new file mode 100644
index 0000000..3b1f115
--- /dev/null
+++ b/src/hdGpTri/scenes/triangleAnimated.usda
@@ -0,0 +1,23 @@
+#usda 1.0
+(
+    startFrame = 1
+    endFrame = 10
+)
+
+def Scope "World"
+{
+    def GenerativeProcedural "myGenerativeProcAnimated" (
+        prepend apiSchemas = ["HydraGenerativeProceduralAPI"]
+    )
+    {
+        token primvars:hdGp:proceduralType = "triangle"
+        double primvars:sideLength = 1.0
+        double primvars:sideLength.timeSamples = {
+            1: 1,
+            10: 10
+        }
+
+        matrix4d xformOp:transform:transform1 = ( (1, 0, 0, 0), (0, 1, 0, 0), (0, 0, 1, 0), (30, 30, 30, 1) )
+        uniform token[] xformOpOrder = ["xformOp:transform:transform1"]
+    }
+}
\ No newline at end of file
diff --git a/src/hdGpTri/triGenerative.cpp b/src/hdGpTri/triGenerative.cpp
new file mode 100644
index 0000000..00b8d3a
--- /dev/null
+++ b/src/hdGpTri/triGenerative.cpp
@@ -0,0 +1,265 @@
+//
+// Copyright © 2024 Weta FX Limited
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include "./triGenerative.h"
+#include "./debugCodes.h"
+#include <pxr/imaging/hd/retainedDataSource.h>
+#include <pxr/imaging/hd/primvarsSchema.h>
+#include <pxr/imaging/hd/meshSchema.h>
+#include <pxr/imaging/hd/tokens.h>
+#include <pxr/imaging/hd/xformSchema.h>
+#include <pxr/base/tf/token.h>
+#include <pxr/base/tf/stringUtils.h>
+
+PXR_NAMESPACE_USING_DIRECTIVE
+
+namespace {
+TF_DEFINE_PRIVATE_TOKENS(_makeSomeStuffTokens, (sideLength)(myTriangle));
+}
+
+/// @brief the data-source containing the Point positions for a triangle
+/// based on the sideLength
+class _PointsFromSideLengthDataSource : public HdVec3fArrayDataSource
+{
+public:
+    HD_DECLARE_DATASOURCE(_PointsFromSideLengthDataSource);
+
+    bool GetContributingSampleTimesForInterval(
+        Time startTime,
+        Time endTime,
+        std::vector<Time>* outSampleTimes) override
+    {
+
+        const bool result =
+            _sideLengthDs->GetContributingSampleTimesForInterval(
+                startTime, endTime, outSampleTimes);
+
+        TF_DEBUG(USDTRI_GENERATIVE)
+            .Msg("GetContributingSampleTimesForInterval -  (%f-%f) @ %lu  \n",
+                 startTime,
+                 endTime,
+                 outSampleTimes->size());
+        return result;
+    }
+
+    VtValue GetValue(Time shutterOffset)
+    {
+        return VtValue(GetTypedValue(shutterOffset));
+    }
+
+    VtArray<GfVec3f> GetTypedValue(Time shutterOffset)
+    {
+
+        const double sideLength =
+            _sideLengthDs->GetValue(shutterOffset).UncheckedGet<double>();
+
+        VtVec3fArray points{
+            GfVec3f(0.0f, 0.57735027f * sideLength, 0.0f),
+            GfVec3f(-0.5f * sideLength, -0.28867513f * sideLength, 0.0f),
+            GfVec3f(0.5f * sideLength, -0.28867513f * sideLength, 0.0f)
+        };
+        return points;
+    }
+
+private:
+    _PointsFromSideLengthDataSource(HdSampledDataSourceHandle sideLengthDs)
+      : _sideLengthDs(sideLengthDs)
+    {
+    }
+
+    HdSampledDataSourceHandle _sideLengthDs;
+};
+
+_MakeTriGenerativeProcedural::_MakeTriGenerativeProcedural(
+    const SdfPath& i_primPath)
+  : HdGpGenerativeProcedural(i_primPath)
+{
+}
+
+HdGpGenerativeProcedural*
+_MakeTriGenerativeProcedural::New(const SdfPath& i_primPath)
+{
+    return new _MakeTriGenerativeProcedural(i_primPath);
+}
+
+HdGpGenerativeProcedural::DependencyMap
+_MakeTriGenerativeProcedural::UpdateDependencies(
+    const HdSceneIndexBaseRefPtr& i_inputScene)
+{
+    TF_DEBUG(USDTRI_GENERATIVE)
+        .Msg("UpdateDependencies @ Prim - <%s> \n",
+             _GetProceduralPrimPath().GetText());
+
+    HdGpGenerativeProcedural::DependencyMap result;
+    HdSceneIndexPrim myPrim = i_inputScene->GetPrim(_GetProceduralPrimPath());
+
+    HdPrimvarsSchema primvars =
+        HdPrimvarsSchema::GetFromParent(myPrim.dataSource);
+
+    if (HdSampledDataSourceHandle ds =
+            primvars.GetPrimvar(_makeSomeStuffTokens->sideLength)
+                .GetPrimvarValue()) {
+        VtValue v = ds->GetValue(0.0f);
+        if (v.IsHolding<double>()) {
+            result[_GetProceduralPrimPath().AppendChild(
+                _makeSomeStuffTokens->myTriangle)] = {
+                HdPrimvarsSchema::GetPointsLocator(),
+                HdXformSchema::GetDefaultLocator(),
+            };
+        }
+    }
+    return result;
+}
+
+HdGpGenerativeProcedural::ChildPrimTypeMap
+_MakeTriGenerativeProcedural::Update(
+    const HdSceneIndexBaseRefPtr& i_inputScene,
+    const HdGpGenerativeProcedural::ChildPrimTypeMap& i_previousResult,
+    const HdGpGenerativeProcedural::DependencyMap& i_dirtiedDependencies,
+    HdSceneIndexObserver::DirtiedPrimEntries* o_outputDirtiedPrims)
+{
+    TF_DEBUG(USDTRI_GENERATIVE)
+        .Msg("Update @ Prim - <%s> \n", _GetProceduralPrimPath().GetText());
+
+    ChildPrimTypeMap result;
+    HdSceneIndexPrim myPrim = i_inputScene->GetPrim(_GetProceduralPrimPath());
+
+    SdfPath primPath = _GetProceduralPrimPath();
+    primPath = primPath.AppendChild(_makeSomeStuffTokens->myTriangle);
+
+    // check if any incoming dependencies affect us
+    bool lengthChanged = false;
+    for (const auto& dd : i_dirtiedDependencies) {
+
+        std::stringstream myStr;
+        myStr << dd.second;
+        TF_DEBUG(USDTRI_GENERATIVE)
+            .Msg("DirtiedDependencies - <%s - %s>\n",
+                 dd.first.GetText(),
+                 myStr.str().c_str());
+
+        // our length-value likely changed if the sideLength primvar on our
+        // procedural prim is dirtied
+        lengthChanged |=
+            ((dd.first == _GetProceduralPrimPath()) &&
+             (dd.second.Contains(HdPrimvarsSchema::GetDefaultLocator().Append(
+                 _makeSomeStuffTokens->sideLength))));
+    }
+
+    // check if any length values have changed
+    double sideLength = 1.0f;
+    if (HdSampledDataSourceHandle sideLengthDS =
+            HdPrimvarsSchema::GetFromParent(myPrim.dataSource)
+                .GetPrimvar(_makeSomeStuffTokens->sideLength)
+                .GetPrimvarValue()) {
+        VtValue v = sideLengthDS->GetValue(0.0f /* timeStamp */);
+        // this does not allow animated
+        if (v.IsHolding<double>()) {
+            sideLength = v.UncheckedGet<double>();
+
+            // our length-value also likely changed if the sideLength value is
+            // different than our stored value _sideLength
+            lengthChanged |= (sideLength != _sideLength);
+            _sideLengthDs = sideLengthDS;
+        }
+    }
+
+    TF_DEBUG(USDTRI_GENERATIVE)
+        .Msg("Update @ Prim - <%s> lengthChanged - %d \n",
+             _GetProceduralPrimPath().GetText(),
+             lengthChanged);
+
+    if (lengthChanged) {
+        // new
+        o_outputDirtiedPrims->emplace_back(
+            primPath, HdPrimvarsSchema::GetPointsLocator());
+    }
+
+    // new
+    result[primPath] = HdPrimTypeTokens->mesh;
+    return result;
+}
+
+HdContainerDataSourceHandle
+_MakeTriGenerativeProcedural::_GetChildPrimvarsDs()
+{
+    HdContainerDataSourceHandle primvarsDs = HdRetainedContainerDataSource::New(
+        HdPrimvarsSchemaTokens->points,
+        HdPrimvarSchema::Builder()
+            .SetPrimvarValue(
+                _PointsFromSideLengthDataSource::New(_sideLengthDs))
+            .SetInterpolation(HdPrimvarSchema::BuildInterpolationDataSource(
+                HdPrimvarSchemaTokens->vertex))
+            .SetRole(HdPrimvarSchema::BuildRoleDataSource(
+                HdPrimvarSchemaTokens->point))
+            .Build());
+
+    return primvarsDs;
+}
+
+HdContainerDataSourceHandle
+_MakeTriGenerativeProcedural::_GetChildMeshDs()
+{
+    // a triangle just has 3 vertices
+    static const VtIntArray faceVertexCounts = { 3 };
+
+    // the faceVertex indices
+    static const VtIntArray faceVertexIndices = { 0, 1, 2 };
+
+    using _IntArrayDs = HdRetainedTypedSampledDataSource<VtIntArray>;
+
+    // create a data-soure for faceVertexCounts
+    static const _IntArrayDs::Handle fvcDs = _IntArrayDs::New(faceVertexCounts);
+
+    // create a data-soure for faceVertexIndices
+    static const _IntArrayDs::Handle fviDs =
+        _IntArrayDs::New(faceVertexIndices);
+
+    // create a data-soure for our mesh
+    static const HdContainerDataSourceHandle meshDs =
+        HdMeshSchema::Builder()
+            .SetTopology(HdMeshTopologySchema::Builder()
+                             .SetFaceVertexCounts(fvcDs)
+                             .SetFaceVertexIndices(fviDs)
+                             .Build())
+            .Build();
+
+    return meshDs;
+}
+
+HdSceneIndexPrim
+_MakeTriGenerativeProcedural::GetChildPrim(
+    const HdSceneIndexBaseRefPtr& i_inputScene,
+    const SdfPath& i_childPrimPath)
+{
+    TF_DEBUG(USDTRI_GENERATIVE)
+        .Msg("GetChildPrim @ Prim - <%s> \n", i_childPrimPath.GetText());
+
+    HdSceneIndexPrim result;
+
+    if (i_childPrimPath == _GetProceduralPrimPath().AppendChild(
+                               _makeSomeStuffTokens->myTriangle)) {
+        result.primType = HdPrimTypeTokens->mesh;
+        result.dataSource =
+            HdRetainedContainerDataSource::New(HdPrimvarsSchemaTokens->primvars,
+                                               _GetChildPrimvarsDs(),
+                                               HdPrimTypeTokens->mesh,
+                                               _GetChildMeshDs());
+    }
+    return result;
+}
+
+HdGpGenerativeProcedural*
+TriProceduralPlugin::Construct(const SdfPath& i_proceduralPrimPath)
+{
+    return _MakeTriGenerativeProcedural::New(i_proceduralPrimPath);
+}
+
+TF_REGISTRY_FUNCTION(TfType)
+{
+    HdGpGenerativeProceduralPluginRegistry::
+        Define<TriProceduralPlugin, HdGpGenerativeProceduralPlugin>();
+}
diff --git a/src/hdGpTri/triGenerative.h b/src/hdGpTri/triGenerative.h
new file mode 100644
index 0000000..85f6fb4
--- /dev/null
+++ b/src/hdGpTri/triGenerative.h
@@ -0,0 +1,52 @@
+//
+// Copyright © 2024 Weta FX Limited
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include <pxr/imaging/hdGp/sceneIndexPlugin.h>
+#include <pxr/imaging/hdGp/generativeProcedural.h>
+#include <pxr/imaging/hdGp/generativeProceduralPlugin.h>
+#include <pxr/imaging/hdGp/generativeProceduralPluginRegistry.h>
+
+PXR_NAMESPACE_OPEN_SCOPE
+
+class _MakeTriGenerativeProcedural : public HdGpGenerativeProcedural
+{
+
+public:
+    _MakeTriGenerativeProcedural(const SdfPath& i_primPath);
+
+    static HdGpGenerativeProcedural* New(const SdfPath& i_primPath);
+
+    HdGpGenerativeProcedural::DependencyMap UpdateDependencies(
+        const HdSceneIndexBaseRefPtr& i_inputScene) override;
+
+    ChildPrimTypeMap Update(const HdSceneIndexBaseRefPtr& i_inputScene,
+                            const ChildPrimTypeMap& i_previousResult,
+                            const DependencyMap& i_dirtiedDependencies,
+                            HdSceneIndexObserver::DirtiedPrimEntries*
+                                o_outputDirtiedPrims) override;
+
+    HdSceneIndexPrim GetChildPrim(const HdSceneIndexBaseRefPtr& i_inputScene,
+                                  const SdfPath& i_childPrimPath) override;
+
+private:
+    HdContainerDataSourceHandle _GetChildMeshDs();
+    HdContainerDataSourceHandle _GetChildPrimvarsDs();
+
+    double _sideLength = 1.0f;
+    HdSampledDataSourceHandle _displayColorDs;
+    HdSampledDataSourceHandle _sideLengthDs;
+};
+
+class TriProceduralPlugin : public HdGpGenerativeProceduralPlugin
+{
+public:
+    TriProceduralPlugin() = default;
+
+    HdGpGenerativeProcedural* Construct(
+        const SdfPath& i_proceduralPrimPath) override;
+};
+
+PXR_NAMESPACE_CLOSE_SCOPE
\ No newline at end of file