GeometryBoolean.h

#pragma once
#include "DLLInfo.h"
#include <NDEVR/SoftwareService.h>
#include <NDEVR/GeometryVertices.h>
#include <NDEVR/Model.h>
#include <NDEVR/Buffer.h>
#include <NDEVR/GenericOption.h>
namespace NDEVR
{
    class DesignSelection;
    enum GeometryBooleanOperation
    {
          e_concatinate 
        , e_subtract    
        , e_cut         
    };
    class DesignObjectLookup;
    struct NDEVR_DESIGN_API BooleanDescription : public GenericOptionGroup
    {
        BooleanDescription(const TranslatedString& filter_name, const String& filter_id);
    };

    struct NDEVR_DESIGN_API GeometryBooleanParameters : public GenericOptionGroup, public GeometryVertices
    {
        GeometryBooleanParameters();
        const void* lock = nullptr;                       
        LogPtr log;                                       
        Buffer<Vertex<3, fltp04>> surface_positions;      
        Buffer<Ray<3, fltp04>> surface_normals;           
        Buffer<RGBColor> surface_colors;                  
        Buffer<Vector<3, uint04>> surface_triangles;      
        Buffer<Buffer<uint04>> surface_polygons;          
 
    };

    class NDEVR_DESIGN_API GeometryBoolean : public SoftwareService, public SoftwareServiceManager
    {
    protected:
        explicit GeometryBoolean(const TranslatedString& name, const String& id);
    public:
        static void SetupDefaultSurfaceObject(Model& target_surface_location, const void* lock);
        static const Dictionary<String, GeometryBoolean*>& AvailableBoolean();
        static void AddAvailableBooleanEngine(GeometryBoolean* filter);

        static void ExecuteBoolean(const JSONNode& active_filters, const DesignSelection& selection_to_surface, Model& target_surface_location, DesignObjectLookup* lookup, InfoPipe* log, const void* lock);
        static void ExecuteBoolean(const JSONNode& active_filters, const Buffer<Model>& models_to_surface, Model& target_surface_location, InfoPipe* log, const void* lock);
        static void ExecuteBoolean(const JSONNode& active_filters, GeometryBooleanParameters& params, Model& target_surface_location);
        static Buffer<BooleanDescription> GetAvailableDescriptions();
        static uint04 AvailableBooleanDescriptionCount();
        static String ToCommandString(const Buffer<BooleanDescription>& descriptions);
    public:
        GeometryBoolean(const GeometryBoolean& filter) = delete;  
        GeometryBoolean(const GeometryBoolean&& filter) = delete; 
        virtual ~GeometryBoolean() = default;                     
        virtual bool runBoolean(GeometryBooleanParameters& parameters) = 0;
        virtual bool canRunBoolean(const GeometryBooleanParameters&) { return true; }
        virtual Buffer<BooleanDescription> defaultBooleanArguments();
        [[nodiscard]] const TranslatedString& BooleanName() const { return m_name; }
        [[nodiscard]] const String& BooleanID() const { return m_id; }
    protected:
        TranslatedString m_name; 
        String m_id;             
    protected:
        static void PrepareForBoolean(const Matrix<fltp08>& transform, const Geometry& geo, GeometryBooleanParameters& params);
        static void ClearAllBoolean(Geometry& geo, InfoPipe* log, const void* lock);
        static void FinishBoolean(const Matrix<fltp08>& transform, Geometry& geo, const GeometryBooleanParameters& params);
    protected:
        static Dictionary<String, GeometryBoolean*> s_global_available_boolean_engines; 
    };
}