feat: add xyz parameter type

src/Engine/Operator/Context.cpp

@@ -35,14 +35,14 @@ enzo::geo::Geometry enzo::op::Context::cloneInputGeo(unsigned int inputIndex)
 }
 
 // TODO: cache value
-enzo::bt::floatT enzo::op::Context::evalFloatParm(const char* parmName) const
+enzo::bt::floatT enzo::op::Context::evalFloatParm(const char* parmName, const unsigned int index) const
 {
     enzo::nt::GeometryOperator& selfOp = networkManager_.getGeoOperator(opId_);
     std::weak_ptr<prm::Parameter> parameter = selfOp.getParameter(parmName);
 
     if(auto sharedParm = parameter.lock())
     {
-        return sharedParm->evalFloat();
+        return sharedParm->evalFloat(index);
     }
     else
     {

src/Engine/Operator/Context.h

@@ -15,7 +15,7 @@ class Context
 public:
     Context(enzo::nt::OpId opId, enzo::nt::NetworkManager& networkManager);
     enzo::geo::Geometry cloneInputGeo(unsigned int inputIndex);
-    bt::floatT evalFloatParm(const char* parmName) const;
+    bt::floatT evalFloatParm(const char* parmName, const unsigned int index=0) const;
 private:
     enzo::nt::OpId opId_;
     enzo::nt::NetworkManager& networkManager_;

src/Engine/Parameter/Parameter.cpp

@@ -1,10 +1,13 @@
 #include "Engine/Parameter/Parameter.h"
+#include "Engine/Types.h"
 #include <iostream>
+#include <stdexcept>
+#include <string>
 
 enzo::prm::Parameter::Parameter(Template prmTemplate)
 : template_{prmTemplate}
 {
-    floatValue_ = prmTemplate.getDefault();
+    floatValues_ = std::vector<bt::floatT>(prmTemplate.getSize(), prmTemplate.getDefault());
     std::cout << "created new parameter: " << prmTemplate.getName() << "\n";
 }
 
@@ -13,13 +16,28 @@ std::string enzo::prm::Parameter::getName() const
     return template_.getName();
 }
 
-enzo::bt::floatT enzo::prm::Parameter::evalFloat() const
+enzo::bt::floatT enzo::prm::Parameter::evalFloat(unsigned int index) const
 {
-    return floatValue_;
+    if(index >= floatValues_.size())
+        throw std::out_of_range("Cannot access index: " + std::to_string(index) + " for parameter: " + getName());
+    return floatValues_[index];
 }
-void enzo::prm::Parameter::setFloat(bt::floatT value)
+
+enzo::prm::Type enzo::prm::Parameter::getType() const
 {
-    floatValue_ = value;
+    return template_.getType();
+}
+
+enzo::bt::String enzo::prm::Parameter::evalString() const
+{
+    return stringValue_;
+}
+
+void enzo::prm::Parameter::setFloat(bt::floatT value, unsigned int index)
+{
+    std::cout << "accessing at: " << index << "\n";
+    std::cout << "size: " << floatValues_.size() << "\n";
+    floatValues_[index] = value;
     valueChanged();
 }
 

src/Engine/Parameter/Parameter.h

@@ -10,12 +10,16 @@ class Parameter
 public:
     Parameter(Template prmTemplate);
     std::string getName() const;
-    bt::floatT evalFloat() const;
+    bt::floatT evalFloat(unsigned int index=0) const;
-    void setFloat(bt::floatT value);
+    bt::String evalString() const;
+    enzo::prm::Type getType() const;
+    
+    void setFloat(bt::floatT value, unsigned int index=0);
     boost::signals2::signal<void ()> valueChanged;
 private:
     Template template_;
-    bt::floatT floatValue_ = 0;
+    std::vector<bt::floatT> floatValues_;
+    bt::String stringValue_ = "";
 
 };
 }

src/Engine/Parameter/Template.cpp

@@ -1,8 +1,8 @@
 #include "Engine/Parameter/Template.h"
 #include "Engine/Parameter/Type.h"
 
-enzo::prm::Template::Template(enzo::prm::Type type, const char* name, bt::floatT theDefault)
+enzo::prm::Template::Template(enzo::prm::Type type, const char* name, bt::floatT theDefault, unsigned int vectorSize)
-: type_{type}, name_{name}, default_{theDefault}
+: type_{type}, name_{name}, default_{theDefault}, vectorSize_(vectorSize)
 {
     
 }
@@ -18,6 +18,18 @@ bool enzo::prm::Template::isValid() const
 
 }
 
+const enzo::prm::Type enzo::prm::Template::getType() const
+{
+    return type_;
+}
+
+const unsigned int enzo::prm::Template::getSize() const
+{
+    return vectorSize_;
+}
+
+
+
 const enzo::bt::floatT enzo::prm::Template::getDefault() const
 {
     return default_;

src/Engine/Parameter/Template.h

@@ -12,17 +12,21 @@ public:
         enzo::prm::Type type,
         const char* name,
         // TODO: change default to class that can store multiple types
-        bt::floatT theDefault
+        bt::floatT theDefault,
+        unsigned int vectorSize = 1
     );
     Template();
     const char* getName() const;
     const bt::floatT getDefault() const;
+    const prm::Type getType() const;
+    const unsigned int getSize() const;
     bool isValid() const;
 private:
     enzo::prm::Type type_;
     bt::floatT default_;
     // TODO: make a class that holds token and name
     const char* name_;
+    unsigned int vectorSize_;
 
 };
 

src/Engine/Types.h

@@ -31,12 +31,14 @@ namespace enzo
         using intT = int64_t;
         using Vector3 = Eigen::Vector3d;
         using Vector4 = Eigen::Vector4d;
+        using String = std::string;
     }
     namespace prm
     {
         enum class Type
         {
             STRING,
+            XYZ,
             FLOAT,
             INT,
             TOGGLE

src/Gui/Parameters/AbstractFormParm.cpp

@@ -1,8 +1,10 @@
 #include "Gui/Parameters/AbstractFormParm.h"
+#include "Engine/Types.h"
 #include "Gui/Parameters/AbstractSliderParm.h"
 #include <qboxlayout.h>
 #include <QLabel>
 #include <iostream>
+#include <qlabel.h>
 
 
 enzo::ui::AbstractFormParm::AbstractFormParm(std::weak_ptr<prm::Parameter> parameter)
@@ -15,29 +17,60 @@ enzo::ui::AbstractFormParm::AbstractFormParm(std::weak_ptr<prm::Parameter> param
         label->setStyleSheet("QLabel{background: none}");
         label->setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Preferred);
 
-        auto slider = new AbstractSliderParm();
-        slider->setValue(sharedParameter->evalFloat());
-
         mainLayout_ = new QHBoxLayout();
         mainLayout_->addWidget(label);
-        mainLayout_->addWidget(slider);
         mainLayout_->setContentsMargins(0,0,0,0);
 
+        switch(sharedParameter->getType())
+        {
+            case prm::Type::FLOAT:
+            {
+                AbstractSliderParm* slider;
+                slider = new AbstractSliderParm();
+                slider->setValue(sharedParameter->evalFloat());
+                mainLayout_->addWidget(slider);
+                connect(slider, &AbstractSliderParm::valueChanged, this, [this](bt::floatT value){this->changeValue(value, 0);}); 
+                break;
+            }
+            case prm::Type::XYZ:
+            {
+                AbstractSliderParm* slider1 = new AbstractSliderParm();
+                AbstractSliderParm* slider2 = new AbstractSliderParm();
+                AbstractSliderParm* slider3 = new AbstractSliderParm();
+                slider1->setValue(sharedParameter->evalFloat());
+                QHBoxLayout* vectorLayout = new QHBoxLayout();
+                vectorLayout->addWidget(slider1);
+                vectorLayout->addWidget(slider2);
+                vectorLayout->addWidget(slider3);
+                mainLayout_->addLayout(vectorLayout);
+                connect(slider1, &AbstractSliderParm::valueChanged, this, [this](bt::floatT value){this->changeValue(value, 0);}); 
+                connect(slider2, &AbstractSliderParm::valueChanged, this, [this](bt::floatT value){this->changeValue(value, 1);}); 
+                connect(slider3, &AbstractSliderParm::valueChanged, this, [this](bt::floatT value){this->changeValue(value, 2);}); 
+                break;
+            }
+            default:
+                throw std::runtime_error("Parameter panel: paremeter type not accounted for");
+
+        }
+
+
+
+
         setFixedHeight(24);
         setProperty("class", "Parameter");
         setStyleSheet(".Parameter { background-color: none;}");
         setLayout(mainLayout_);
 
-        connect(slider, &AbstractSliderParm::valueChanged, this, &AbstractFormParm::changeValue); 
     }
 
 }
 
-void enzo::ui::AbstractFormParm::changeValue(enzo::bt::floatT value)
+
+void enzo::ui::AbstractFormParm::changeValue(enzo::bt::floatT value, unsigned int index)
 {
     if(auto sharedParameter=parameter_.lock())
     {
-        sharedParameter->setFloat(value);
+        sharedParameter->setFloat(value, index);
     }
     else
     {
@@ -46,3 +79,4 @@ void enzo::ui::AbstractFormParm::changeValue(enzo::bt::floatT value)
     }
      
 }
+

src/Gui/Parameters/AbstractFormParm.h

@@ -15,7 +15,7 @@ public:
     AbstractFormParm(std::weak_ptr<prm::Parameter> parameter);
 
 protected Q_SLOTS:
-    void changeValue(bt::floatT value);
+    void changeValue(bt::floatT value, unsigned int index=0);
 
 private:
     QHBoxLayout* mainLayout_;

src/Gui/ParametersPanel/ParametersPanel.cpp

@@ -1,5 +1,6 @@
 #include "Gui/ParametersPanel/ParametersPanel.h"
 #include "Engine/Operator/GeometryOperator.h"
+#include "Engine/Types.h"
 #include "Gui/Parameters/AbstractSliderParm.h"
 #include "Gui/Parameters/AbstractFormParm.h"
 #include "Gui/Parameters/FloatParm.h"
@@ -10,6 +11,7 @@
 #include <qnamespace.h>
 #include <qwidget.h>
 #include <QLineEdit>
+#include <stdexcept>
 
 ParametersPanel::ParametersPanel(QWidget *parent, Qt::WindowFlags f)
 : QWidget(parent, f)
@@ -42,6 +44,7 @@ ParametersPanel::ParametersPanel(QWidget *parent, Qt::WindowFlags f)
 
 void ParametersPanel::selectionChanged()
 {
+    using namespace enzo;
     enzo::nt::NetworkManager& nm = enzo::nt::nm();
     std::optional<enzo::nt::OpId> displayOpId = nm.getDisplayOp();
 
@@ -58,7 +61,25 @@ void ParametersPanel::selectionChanged()
     auto parameters = displayOp.getParameters();
     for(auto parameter : parameters)
     {
+        auto parameterShared = parameter.lock();
+        if(!parameterShared) throw std::runtime_error("Failed to lock parameter");
+
+        
+
         parametersLayout_->addWidget(new enzo::ui::AbstractFormParm(parameter));
+        // switch(parameterShared->getType())
+        // {
+        //     case prm::Type::FLOAT:
+        //         parametersLayout_->addWidget(new enzo::ui::AbstractFormParm(parameter));
+        //         break;
+        //     case prm::Type::VECTOR3:
+        //         parametersLayout_->addWidget(new enzo::ui::VectorParr(parameter));
+        //         break;
+        //     default:
+        //         throw std::runtime_error("Parameter panel: paremeter type not accounted for");
+
+        // }
+
     }
 }
 

src/OpDefs/GopTransform.cpp

@@ -29,13 +29,16 @@ void GopTransform::cookOp(enzo::op::Context context)
         ga::AttributeHandleVector3 PAttrHandle(PAttr);
 
         Eigen::Affine3d transform = Eigen::Affine3d::Identity();
-        transform.rotate(Eigen::AngleAxisd(context.evalFloatParm("rotateX"), Eigen::Vector3d(1,0,0)));
+
-        transform.rotate(Eigen::AngleAxisd(context.evalFloatParm("rotateY"), Eigen::Vector3d(0,1,0)));
+        const bt::floatT rotateX = context.evalFloatParm("rotate", 0);
-        transform.rotate(Eigen::AngleAxisd(context.evalFloatParm("rotateZ"), Eigen::Vector3d(0,0,1)));
+        const bt::floatT rotateY = context.evalFloatParm("rotate", 1);
-        transform.translate(bt::Vector3(context.evalFloatParm("translateX"), context.evalFloatParm("translateY"), context.evalFloatParm("translateZ")));
+        const bt::floatT rotateZ = context.evalFloatParm("rotate", 2);
+        transform.rotate(Eigen::AngleAxisd(rotateX, Eigen::Vector3d(1,0,0)));
+        transform.rotate(Eigen::AngleAxisd(rotateY, Eigen::Vector3d(0,1,0)));
+        transform.rotate(Eigen::AngleAxisd(rotateZ, Eigen::Vector3d(0,0,1)));
 
         const Eigen::Matrix3d  R = transform.linear();
-        const Eigen::Vector3d  t = transform.translation();
+        const Eigen::Vector3d  t = bt::Vector3(context.evalFloatParm("translate", 0), context.evalFloatParm("translate", 1), context.evalFloatParm("translate", 2));
 
         const size_t N = PAttrHandle.getSize();
 
@@ -45,8 +48,7 @@ void GopTransform::cookOp(enzo::op::Context context)
             for(size_t i=range.begin(); i<range.end(); ++i)
             {
                 enzo::bt::Vector3 pointPos = PAttrHandle.getValue(i);
-                pointPos = R * pointPos + t;
+                pointPos = (R * pointPos) + t;
-                // pointPos = transform*pointPos;
                 PAttrHandle.setValue(i, pointPos);
             }
         });
@@ -60,12 +62,8 @@ void GopTransform::cookOp(enzo::op::Context context)
 
 enzo::prm::Template GopTransform::parameterList[] = 
 {
-    enzo::prm::Template(enzo::prm::Type::FLOAT, "translateX", 0),
+    enzo::prm::Template(enzo::prm::Type::XYZ, "translate", 0, 3),
-    enzo::prm::Template(enzo::prm::Type::FLOAT, "translateY", 0),
+    enzo::prm::Template(enzo::prm::Type::XYZ, "rotate", 0, 3),
-    enzo::prm::Template(enzo::prm::Type::FLOAT, "translateZ", 0),
-    enzo::prm::Template(enzo::prm::Type::FLOAT, "rotateX", 0),
-    enzo::prm::Template(enzo::prm::Type::FLOAT, "rotateY", 0),
-    enzo::prm::Template(enzo::prm::Type::FLOAT, "rotateZ", 0),
     enzo::prm::Terminator
 };