Parameter.h

#pragma once
#include "Engine/Core/Types.h"
#include "Engine/Parameter/Template.h"
#include <boost/signals2.hpp>
#include <memory>
#include <optional>
#include <string_view>
#include <variant>
 
namespace enzo::expr {
class ExpressionContext;
}
 
namespace enzo::prm {
 
using PrmValues = std::variant<std::vector<floatT>, std::vector<intT>, std::vector<String>>;
 
class Parameter
{
  public:
    Parameter(Template prmTemplate);
    virtual ~Parameter() = default;
 
    std::string getName() const;
    std::string getLabel() const;
    enzo::prm::Type getType() const;
    enzo::prm::ValueType getValueType() const;
    unsigned int getVectorSize() const;
 
    floatT evalFloat(unsigned int index = 0) const;
    String evalString(unsigned int index = 0) const;
    intT evalInt(unsigned int index = 0) const;
 
    // Variants that report a driving expression's failure. The value still falls
    // back to the stored literal on failure, and error is left empty on success
    // or when the component holds no expression.
    floatT evalFloat(unsigned int index, String& error) const;
    intT evalInt(unsigned int index, String& error) const;
    String evalString(unsigned int index, String& error) const;
 
    // Read every value the parameter holds as a list. A scalar parameter
    // returns one element, a vector parameter one per component, and a
    // multi-value parameter such as a multi select dropdown one per selection.
    std::vector<floatT> evalFloats() const;
    std::vector<String> evalStrings() const;
    std::vector<intT> evalInts() const;
 
    void setInt(intT value, unsigned int index = 0);
    void setFloat(floatT value, unsigned int index = 0);
    void setString(String value, unsigned int index = 0);
 
    // A component may hold a daslang expression instead of a literal. When set,
    // the eval functions run the expression to produce the value, and setting a
    // literal clears it.
    void setExpression(String expression, unsigned int index = 0);
    void clearExpression(unsigned int index = 0);
    bool hasExpression(unsigned int index = 0) const;
 
    std::optional<String> getExpression(unsigned int index = 0) const;
 
    std::optional<String> getExpressionError(unsigned int index = 0) const;
 
    PrmValues getValues() const;
    void setValues(const PrmValues& values);
 
    // Multiparm instances. Each instance is a group of field parameters cloned
    // from the instance template. The live count is the number of instances.
    unsigned int getInstanceCount() const;
    const std::vector<std::shared_ptr<Parameter>>& getInstance(unsigned int instanceIndex) const;
    std::shared_ptr<Parameter>
    getInstanceField(unsigned int instanceIndex, std::string_view fieldName) const;
    void addInstance();
    void removeInstance(unsigned int instanceIndex);
    void moveInstance(unsigned int fromIndex, unsigned int toIndex);
 
    const Template& getTemplate();
 
    boost::signals2::signal<void()> valueChanged;
 
  protected:
    virtual void onFloatSet_(const PrmValues& before) {}
    void handleValueChange_();
 
    virtual std::unique_ptr<expr::ExpressionContext> makeExpressionContext_() const;
 
    virtual void
    submitExpressionDependencies_(const expr::ExpressionContext& context, unsigned int index) const
    {
    }
 
    floatT clampToRange_(floatT value, unsigned int index) const;
    intT clampToRange_(intT value, unsigned int index) const;
 
    // Reads a component's stored literal converted to the requested type. A float
    // and an int store convert to each other with a plain numeric cast, while any
    // other mismatch yields the type's default. e.g. an int parameter read as a
    // float casts cleanly, but a string parameter read as a float gives zero.
    floatT readFloatLiteral_(unsigned int index) const;
    intT readIntLiteral_(unsigned int index) const;
    String readStringLiteral_(unsigned int index) const;
    std::vector<std::shared_ptr<Parameter>> buildInstance_(unsigned int instanceIndex);
 
    Template template_;
    PrmValues values_;
    // One optional expression per component, parallel to the value vector. An
    // empty slot means the component uses its literal value.
    std::vector<std::optional<String>> expressions_;
    std::vector<std::vector<std::shared_ptr<Parameter>>> instances_;
};
} // namespace enzo::prm