Provide GUI for scene tree, complete scene merging (any parent).

Author: Adnn

src/apps/ch11_ssao/ch11_ssao/Scene.cpp

@@ -16,7 +16,6 @@
 #include <renderer/Uniforms.h>
 
 #include <scenic/CameraGui.h>
-
 #include <scenic/ColorPalettes.h>
 #include <scenic/LoadScene.h>
 
@@ -139,7 +138,10 @@ std::filesystem::path getCacheModel(renderer::ReferencePath aModel)
 
 scenic::SceneTree prepareSceneTree(Engine & aEngine)
 {
-    scenic::SceneTree scene;
+    scenic::SceneTree scene{
+        .mTree = scenic::makeOneRootTree<scenic::Pose>()
+    };
+
     for (const auto & reference : gModelPaths)
     {
         scenic::SceneTree modelScene;
@@ -166,7 +168,7 @@ scenic::SceneTree prepareSceneTree(Engine & aEngine)
             scenic::Serializer serializer;
             serializer.serial(archive, modelScene);
         }
-        scenic::mergeScenes(scene, modelScene);
+        scenic::mergeScenes(scene, modelScene, scene.mTree.mFirstRoot);
     }
 
     return scene;
@@ -422,6 +424,25 @@ void Scene::presentUi(bool * aOpen)
         scenic::appendUi(mOrbitalCamera);
     }
 
+    ImGui::Spacing();
+    if (ImGui::CollapsingHeader("Scene tree"))
+    {
+        scenic::presentNodeTree(mSceneTree.mTree, mSceneTree.mTree.mFirstRoot, mSceneTreeGuiState);
+    }
+
+    if (auto selected = mSceneTreeGuiState.mSelected;
+        selected!= scenic::Node::gInvalidIndex)
+    {
+        std::string storage;
+        const std::string & name = mSceneTree.mTree.getSafeName(selected, storage);
+        ImGui::Begin(name.c_str(), aOpen);
+        if (auto modified = scenic::presentPose(mSceneTree.mTree.mLocalPose[selected]))
+        {
+            mSceneTree.mTree.setLocalPose(selected, *modified);
+        }
+        ImGui::End();
+    }
+
     if (ImGui::Button("Dump depth map"))
     {
         std::ofstream outFile{ "rtr_11-depth_texture.png", std::ios::binary };

src/apps/ch11_ssao/ch11_ssao/Scene.h

@@ -25,6 +25,8 @@
 
 #include <scenic/environment/Environment.h>
 
+#include <scenic/gui/HierarchyGui.h>
+
 
 namespace ad {
 
@@ -120,6 +122,7 @@ struct Scene
     };
 
     SceneControl mSceneControl;
+    scenic::TreeInteractionState mSceneTreeGuiState;
 };
 
 

src/libs/scenic/scenic/CMakeLists.txt

@@ -21,6 +21,8 @@ set(${TARGET_NAME}_HEADERS
     files/Archives.h
     files/Serializer.h
 
+    gui/HierarchyGui.h
+
     log/Logging.h
     log/Logging-channels.h
     log/Logging-init.h
@@ -42,6 +44,8 @@ set(${TARGET_NAME}_SOURCES
     environment/EnvironmentUtilities.cpp
     environment/Skybox.cpp
 
+    gui/HierarchyGui.cpp
+
     files/Archives.cpp
     files/Serializer.cpp
 

src/libs/scenic/scenic/Hierarchy.h

@@ -3,6 +3,8 @@
 
 #include <math/Vector.h>
 
+// TODO: should split this header into a separate helpers, to avoid including string
+#include <string>
 #include <vector>
 
 #include <cassert>
@@ -36,9 +38,21 @@ struct NodeTree
 {
     std::size_t size() const;
 
+    bool hasChild(Node::Index aNode) const;
+    bool hasParent(Node::Index aNode) const;
+    bool hasName(Node::Index aNode) const;
+
     /// @param aParent if set to gInvalidIndex, the call adds a root node.
     Node::Index addNode(Node::Index aParent, T_pose aLocalPose);
 
+    void setLocalPose(Node::Index aNode, T_pose aLocalPose);
+    void recurseGlobalPose(Node::Index aNode, const T_pose & aParentGlobalPose);
+
+    /// @brief Return the name of the node if available, or a generated name between angle brackets.
+    /// @return A reference to the string that contains the name, which **might not** be provided aClientStorage.
+    [[nodiscard]] const std::string & getSafeName(Node::Index aNode,
+                                                  std::string & aClientStorage) const;
+
     /// @brief Insert provided subtree into this NodeTree.
     /// @param aSubtree 
     /// @param aInsertionParent The parent for the inserted subtree.
@@ -58,6 +72,21 @@ struct NodeTree
 };
 
 
+template <class T_pose>
+NodeTree<T_pose> makeOneRootTree(T_pose aRootPose = {})
+{
+    return NodeTree<T_pose>{
+        .mHierarchy{
+            Node{
+                .mLastSibling = 0,
+            },
+        },
+        .mLocalPose{aRootPose},
+        .mGlobalPose{aRootPose},
+        .mFirstRoot = 0,
+    };
+}
+
 
 template <class T_pose>
 std::size_t NodeTree<T_pose>::size() const
@@ -68,6 +97,48 @@ std::size_t NodeTree<T_pose>::size() const
 }
 
 
+template <class T_pose>
+bool NodeTree<T_pose>::hasChild(Node::Index aNode) const
+{
+    return mHierarchy[aNode].mFirstChild != Node::gInvalidIndex;
+}
+
+
+template <class T_pose>
+bool NodeTree<T_pose>::hasParent(Node::Index aNode) const
+{
+    return mHierarchy[aNode].mParent != Node::gInvalidIndex;
+}
+
+
+template <class T_pose>
+bool NodeTree<T_pose>::hasName(Node::Index aNode) const
+{
+    // TODO: implement node names
+    return false;
+}
+
+
+template <class T_pose>
+[[nodiscard]] const std::string & NodeTree<T_pose>::getSafeName(Node::Index aNode, std::string & aClientStorage) const
+{
+    if (hasName(aNode))
+    {
+#if !defined(NDEBUG)
+        // Give a consistent message if the client wrongfully use the storage as result.
+        aClientStorage = "<nulled>";
+#endif
+        // Should return the reference to the internally stored string, without copy to client storage
+        /*return aTree.mNodeNames[aNode]*/
+        throw std::logic_error{"not implemented"};
+    }
+    else
+    {
+        aClientStorage = "<node_" + std::to_string(aNode) + ">";
+        return aClientStorage;
+    }
+}
+
 template <class T_pose>
 Node::Index NodeTree<T_pose>::addNode(Node::Index aParent, T_pose aLocalPose)
 {
@@ -135,31 +206,75 @@ Node::Index NodeTree<T_pose>::addNode(Node::Index aParent, T_pose aLocalPose)
     return thisIndex;
 }
 
-// TODO: ideally would not be exposed to clients, or moved to a generic header
-namespace utils {
 
-    template <class T_element>
-    std::vector<T_element> & append(std::vector<T_element> & aReceiver,
-                                    const std::vector<T_element> aAppended)
+template <class T_pose>
+void NodeTree<T_pose>::setLocalPose(Node::Index aNode, T_pose aLocalPose)
+{
+    mLocalPose[aNode] = std::move(aLocalPose);
+    recurseGlobalPose(aNode,
+                      hasParent(aNode) ? mGlobalPose[mHierarchy[aNode].mParent]
+                                         : T_pose{});
+}
+
+
+template <class T_pose>
+void NodeTree<T_pose>::recurseGlobalPose(Node::Index aNode,
+                                         const T_pose & aParentGlobalPose)
+{
+    mGlobalPose[aNode] = composeLeftToRight(mLocalPose[aNode], aParentGlobalPose);
+
+    for(Node::Index childIdx = mHierarchy[aNode].mFirstChild;
+        childIdx != Node::gInvalidIndex;
+        childIdx = mHierarchy[childIdx].mNextSibling)    
     {
-        aReceiver.reserve(aReceiver.size() + aAppended.size());
-        aReceiver.insert(aReceiver.end(), aAppended.begin(), aAppended.end());
-        return aReceiver;
+        recurseGlobalPose(childIdx, mGlobalPose[aNode]);
     }
+}
 
 
-    inline void shiftNode(Node & aNode, Node::Index aOffset, unsigned int aLevelOffset)
-    {
+// TODO: ideally would not be exposed to clients, or moved to a generic header
+namespace utils {
+
+template <class T_element>
+std::vector<T_element> & append(std::vector<T_element> & aReceiver,
+                                const std::vector<T_element> aAppended)
+{
+    aReceiver.reserve(aReceiver.size() + aAppended.size());
+    aReceiver.insert(aReceiver.end(), aAppended.begin(), aAppended.end());
+    return aReceiver;
+}
+
+
+inline void shiftNode(Node & aNode, Node::Index aOffset, unsigned int aLevelOffset)
+{
 #define SHIFT(member) if(aNode.##member != Node::gInvalidIndex) aNode.##member += aOffset
 
-        SHIFT(mParent);
-        SHIFT(mFirstChild);
-        SHIFT(mNextSibling);
-        SHIFT(mLastSibling);
-        aNode.mLevel += aLevelOffset;
+    SHIFT(mParent);
+    SHIFT(mFirstChild);
+    SHIFT(mNextSibling);
+    SHIFT(mLastSibling);
+    aNode.mLevel += aLevelOffset;
 
 #undef SHIFT
+}
+
+template <class T_pose>
+void appendSiblings(Node::Index & aFirstSibling, 
+                    Node::Index aAppendedSibling,
+                    NodeTree<T_pose> & aTree)
+{
+    if (aFirstSibling == Node::gInvalidIndex)
+    {
+        aFirstSibling = aAppendedSibling;
+    }
+    else
+    {
+        auto & lastSibling = aTree.mHierarchy[aFirstSibling].mLastSibling;
+        assert(aTree.mHierarchy[lastSibling].mNextSibling == Node::gInvalidIndex);
+        aTree.mHierarchy[lastSibling].mNextSibling = aAppendedSibling;
+        lastSibling = aTree.mHierarchy[aAppendedSibling].mLastSibling;
     }
+}
 
 
 }; // namespace utils
@@ -193,22 +308,24 @@ Node::Index NodeTree<T_pose>::insert(const NodeTree & aSubtree,
     {
         utils::shiftNode(mHierarchy[idx], initialSize, insertionLevel);
     }
+    Node::Index shiftedSubtreeRoot = aSubtree.mFirstRoot + initialSize;
 
     utils::append(mLocalPose, aSubtree.mLocalPose);
 
     if (aInsertionParent != Node::gInvalidIndex)
     {
-        // TODO #scenegraph: Recalculate global poses
-        assert(false);
+        // Resize global pose container to receive values during the recursive descend
+        mGlobalPose.resize(initialSize + aSubtree.size());
+        recurseGlobalPose(shiftedSubtreeRoot, mGlobalPose[aInsertionParent]);
+
+        utils::appendSiblings(mHierarchy[aInsertionParent].mFirstChild,
+                              shiftedSubtreeRoot,
+                              *this);
     }
     else // Insert the subtree as a root node
     {
         utils::append(mGlobalPose, aSubtree.mGlobalPose);
-
-        auto & lastRoot = mHierarchy[mFirstRoot].mLastSibling;
-        assert(mHierarchy[lastRoot].mNextSibling == Node::gInvalidIndex);
-        mHierarchy[lastRoot].mNextSibling = aSubtree.mFirstRoot + initialSize;
-        lastRoot = aSubtree.mHierarchy[aSubtree.mFirstRoot].mLastSibling + initialSize;
+        utils::appendSiblings(mFirstRoot, shiftedSubtreeRoot, *this);
     }
 
     return initialSize;

src/libs/scenic/scenic/gui/HierarchyGui.cpp

@@ -0,0 +1,28 @@
+#include "HierarchyGui.h"
+
+
+
+namespace ad::scenic {
+
+
+std::optional<Pose> presentPose(const Pose & aPose)
+{
+    math::EulerAngles<float> euler{math::toEulerAngles(aPose.mOrientation)};
+    bool changed =
+        ImGui::SliderAngle("X (roll)",  &euler.x.data(), -180, 180)
+        | ImGui::SliderAngle("Y (pitch)", &euler.y.data(), -89.f, 89.f)
+        | ImGui::SliderAngle("Z (yaw)",   &euler.z.data(), -180, 180)
+        ;
+
+    if (changed)
+    {
+        Pose result{aPose};
+        result.mOrientation = toQuaternion(euler);
+        return result;
+    }
+
+    return std::nullopt;
+}
+
+
+} // namespce ad::scenic