widget in viewport

src/Vtk/vtkViewport.cpp

@@ -1,6 +1,9 @@
 #include "vtkViewport.h"
-
+#include <vtkPropAssembly.h>
+#include <vtkPropCollection.h>
+#include <vtkProp3D.h>
 #include <vtkCamera.h>
+#include <algorithm>
 #include <vtkInteractorStyleTrackballCamera.h>
 #include <vtkObjectFactory.h>
 #include <vtkRenderWindow.h>
@@ -14,6 +17,8 @@
 #include <vtkCallbackCommand.h>
 #include <vtkMath.h>
 #include <cmath>
+#include <iostream>
+#include "vtkHandlerWidget.h"
 
 namespace uLib {
 namespace Vtk {
@@ -103,9 +108,94 @@ void Viewport::SetupPipeline(vtkRenderWindowInteractor* iren)
     m_CameraWidget->SetInteractor(iren);
     m_CameraWidget->On();
 #endif
-
     m_Renderer->SetBackground(0.15, 0.15, 0.15);
     m_Renderer->ResetCamera();
+
+    // Setup layering for overimposed rendering
+    if (iren->GetRenderWindow()) {
+        iren->GetRenderWindow()->SetNumberOfLayers(2);
+        m_Renderer->SetLayer(0);
+    }
+
+    // Setup Handler Widget
+    m_HandlerWidget = vtkSmartPointer<vtkHandlerWidget>::New();
+    m_HandlerWidget->SetInteractor(iren);
+    m_HandlerWidget->SetCurrentRenderer(m_Renderer);
+    if (m_HandlerWidget->GetOverlayRenderer()) {
+        m_HandlerWidget->GetOverlayRenderer()->SetLayer(1);
+    }
+
+    // Picking for selection
+    m_Picker = vtkSmartPointer<vtkCellPicker>::New();
+    vtkNew<vtkCallbackCommand> clickCallback;
+    clickCallback->SetClientData(this);
+    clickCallback->SetCallback([](vtkObject* caller, unsigned long, void* clientdata, void*){
+        auto* iren = static_cast<vtkRenderWindowInteractor*>(caller);
+        auto* self = static_cast<Viewport*>(clientdata);
+        
+        int* pos = iren->GetEventPosition();
+        self->m_Picker->Pick(pos[0], pos[1], 0, self->m_Renderer);
+        vtkProp* picked = self->m_Picker->GetViewProp();
+        
+        Puppet* target = nullptr;
+        if (picked) {
+            for (auto* p : self->m_Puppets) {
+                if (p->GetProp() == picked) {
+                    target = p;
+                    break;
+                }
+                auto* assembly = vtkPropAssembly::SafeDownCast(p->GetProp());
+                if (assembly) {
+                    bool found = false;
+                    auto* parts = assembly->GetParts();
+                    parts->InitTraversal();
+                    for (int i=0; i<parts->GetNumberOfItems(); ++i) {
+                        if (parts->GetNextProp() == picked) {
+                            found = true;
+                            break;
+                        }
+                    }
+                    if (found) {
+                        target = p;
+                        break;
+                    }
+                }
+            }
+        }
+        self->SelectPuppet(target);
+    });
+    iren->AddObserver(vtkCommand::LeftButtonPressEvent, clickCallback);
+
+    // Keyboard events for widget coordinate frame
+    vtkNew<vtkCallbackCommand> keyCallback;
+    keyCallback->SetClientData(this);
+    keyCallback->SetCallback([](vtkObject* caller, unsigned long, void* clientdata, void*){
+        auto* iren = static_cast<vtkRenderWindowInteractor*>(caller);
+        auto* self = static_cast<Viewport*>(clientdata);
+        
+        if (!self->m_HandlerWidget || !self->m_HandlerWidget->GetEnabled()) return;
+        
+        std::string key = iren->GetKeySym();
+        if (key == "l") {
+          self->m_HandlerWidget->SetReferenceFrame(vtkHandlerWidget::LOCAL);
+          std::cout << "Widget Frame: LOCAL" << std::endl;
+        }
+        else if (key == "g") {
+          self->m_HandlerWidget->SetReferenceFrame(vtkHandlerWidget::GLOBAL);
+          std::cout << "Widget Frame: GLOBAL" << std::endl;
+        }
+        else if (key == "c") {
+          self->m_HandlerWidget->SetReferenceFrame(vtkHandlerWidget::CENTER);
+          std::cout << "Widget Frame: CENTER" << std::endl;
+        }
+        else if (key == "k") {
+          self->m_HandlerWidget->SetReferenceFrame(vtkHandlerWidget::CENTER_LOCAL);
+          std::cout << "Widget Frame: CENTER_LOCAL" << std::endl;
+        }
+        
+        iren->Render();
+    });
+    iren->AddObserver(vtkCommand::KeyPressEvent, keyCallback);
 }
 
 void Viewport::Reset()
@@ -124,17 +214,43 @@ void Viewport::ZoomAuto()
 
 void Viewport::AddPuppet(Puppet& prop)
 {
+    m_Puppets.push_back(&prop);
     prop.ConnectRenderer(m_Renderer);
-    prop.ConnectInteractor(GetInteractor());
     Render();
 }
 
 void Viewport::RemovePuppet(Puppet& prop)
 {
+    if (prop.IsSelected()) SelectPuppet(nullptr);
+    auto it = std::find(m_Puppets.begin(), m_Puppets.end(), &prop);
+    if (it != m_Puppets.end()) m_Puppets.erase(it);
     prop.DisconnectRenderer(m_Renderer);
     Render();
 }
 
+void Viewport::SelectPuppet(Puppet* prop)
+{
+    for (auto* p : m_Puppets) {
+        p->SetSelected(p == prop);
+    }
+    
+    if (m_HandlerWidget) {
+        if (prop) {
+            vtkProp3D* prop3d = vtkProp3D::SafeDownCast(prop->GetProp());
+            if (prop3d) {
+                m_HandlerWidget->SetProp3D(prop3d);
+                m_HandlerWidget->SetEnabled(1);
+                m_HandlerWidget->PlaceWidget(prop3d->GetBounds());
+            }
+        } else {
+            m_HandlerWidget->SetEnabled(0);
+            m_HandlerWidget->SetProp3D(nullptr);
+        }
+    }
+    
+    Render();
+}
+
 void Viewport::addProp(vtkProp* prop)
 {
     if (m_Renderer) {