ParameterSlicer.h

#pragma once
#include <NDEVR/DesignParameter.h>
#include <NDEVR/DesignCommand.h>
#include <NDEVR/DesignObjectResourceCache.h>
#if NDEVR_CROSS_SECTION
namespace NDEVR
{
    class Model;
    class Geometry;
    class PolylineValueSliceIterator;
    class InfoPipe;

    struct ParameterSlicerArgs
    {
        Model linework_root;                            
        Buffer<Model> models_to_slice;                  
        PolylineValueSliceIterator* slicer = nullptr;   
        DesignParameter parameter;                      
        LogPtr log;                                     
        DesignObjectResourceCache resource_cache;       
        const void* lock = nullptr;                     
    };

    struct ValueSlicePlane
    {
        Buffer<Buffer<uint04>> segments;                    
        Buffer<Vertex<3, fltp04>> polyline_vertices;        
        Dictionary<String, Buffer<fltp04>> properties;      
        fltp08 value;                                       
        String name;                                        
        TranslatedString group;                             
    };

    class PolylineValueSliceIterator
    {
    public:
        virtual Buffer<ValueSlicePlane> slicePlanes(const Matrix<fltp08>& transform, const DesignParameter& param) = 0;

        virtual void cleanupSlicePlanes(const Matrix<fltp08>&, Buffer<ValueSlicePlane>&) { /*Do nothing*/ };
    };

    class EvenSliceIterator : public PolylineValueSliceIterator
    {
        Buffer<ValueSlicePlane> slicePlanes(const Matrix<fltp08>& transform, const DesignParameter& param) override;
    public:
        Bounds<1, fltp08> bounds;   
        fltp08 spacing = 1.0;       
    };

    struct PolylineValueSliceCache
    {
        Matrix<fltp08> slice_transform;                 
        DesignParameter parameter;                      
        Buffer<ValueSlicePlane> planes;                 
        Buffer<Triangle<3, fltp08>> triangles;          
        Buffer<Vector<3, fltp08>> triangle_values;      
        PolylineValueSliceIterator* slice_plane;        
        DesignObjectResourceCache resource_cache;       
        LogPtr log;                                     
    };

    class PolylineValueSlicer
    {
    public:
        static void CreateActiveLinework(ParameterSlicerArgs& args);

        static constexpr StringView SliceTypeName() { return "polyline_slice"; }
    protected:
        static void SliceIntoLineSegments(uint04 slice_index, PolylineValueSliceCache& args);

        static void PrepareCache(const Matrix<fltp08>& transform, const Geometry& geo, PolylineValueSliceCache& params);

        static void FinishSegmenting(const Matrix<fltp08>& transform, Model& model, uint04 slice_index, PolylineValueSliceCache& params);

        static void AddVertices(Geometry& geo, const ValueSlicePlane& plane, const Matrix<fltp08>& mat);
    };

    class ParameterSlicerCommand : public DesignCommand
    {
    public:
        NDEVR_DESIGN_API ParameterSlicerCommand(const Bounds<1, fltp08>& bounds, fltp08 spacing, DesignParameter param);

        virtual ~ParameterSlicerCommand() {};

        NDEVR_DESIGN_API virtual void execute(DesignObjectLookup* lookup) override;

        virtual bool canCombineWith(const DynamicPointer<DesignCommand>&) override { return false; };

        virtual bool isAsyncExecution() const override { return true; };

        NDEVR_DESIGN_API virtual StringView icon() const override;

        NDEVR_DESIGN_API virtual TranslatedString name() const override;

        virtual bool addTarget(UUID target_id) override { targets.add(target_id); return true; }
    public:
        Buffer<UUID> targets;           
    protected:
        Bounds<1, fltp08> m_bounds;     
        fltp08 m_spacing;               
        DesignParameter m_param;        
    };
}
#endif