PointScript.h

#pragma once
#include "Engine/Attribute/AttributeHandle.h"
#include "Engine/Core/Types.h"
#include "Engine/Expression/DasRuntime.h"
#include <deque>
#include <memory>
#include <optional>
#include <vector>
 
namespace enzo::geo {
class Primitive;
}
 
namespace enzo::expr {
 
class ExpressionContext;
 
struct AttributeBinding
{
    String name;
    attr::AttributeType type;
    bool written = false;
};
 
class PointScript
{
  public:
    static std::shared_ptr<PointScript> compile(const String& code, String& error);
 
    const std::vector<AttributeBinding>& getBindings() const { return bindings_; }
 
    std::shared_ptr<PointScript> clone() const;
 
    bool addWrittenAttributes(geo::Primitive& output, String& error) const;
 
    bool run(
        const geo::Primitive& input,
        geo::Primitive& output,
        Offset begin,
        Offset end,
        const ExpressionContext* context,
        String& error
    );
 
  private:
    // Values the script works on for one point, one list per attribute type.
    template <typename Value> struct BindingValues
    {
        std::deque<Value> values;
        std::vector<std::optional<attr::AttributeHandleRO<Value>>> inputs;
        std::vector<std::optional<attr::AttributeHandle<Value>>> outputs;
 
        // Reads a point's values from the input, leaving missing attributes at the default value.
        void loadFrom(Offset point)
        {
            for (size_t valueIndex = 0; valueIndex < values.size(); ++valueIndex)
            {
                const auto& input = inputs[valueIndex];
                values[valueIndex] = input ? input->getValue(point) : Value{};
            }
        }
 
        // Writes a point's values back to the output attributes.
        void storeTo(Offset point)
        {
            for (size_t valueIndex = 0; valueIndex < values.size(); ++valueIndex)
            {
                auto& output = outputs[valueIndex];
                if (output) output->setValue(point, values[valueIndex]);
            }
        }
    };
 
    PointScript(std::shared_ptr<CompiledScript> compiled, std::vector<AttributeBinding> bindings);
 
    template <typename Action> void visitBindingValues(attr::AttributeType type, Action&& action);
    template <typename Action> void visitAllBindingValues(Action&& action);
    bool resolveAttributes(const geo::Primitive& input, geo::Primitive& output, String& error);
 
    std::shared_ptr<CompiledScript> compiled_;
    std::vector<AttributeBinding> bindings_;
 
    BindingValues<floatT> floats_;
    BindingValues<intT> ints_;
    BindingValues<Vector3> vectors_;
    BindingValues<boolT> bools_;
 
    // The point offset followed by a pointer to each binding's value.
    std::vector<ScriptArgument> arguments_;
};
 
} // namespace enzo::expr