GeometrySurfacing.h

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants
Licensee a limited, non-exclusive, non-transferable, royalty-free license
(without the right to sublicense) to use the API solely for the purpose of
Licensee's internal development efforts to develop applications for which
the API was provided.
 
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: GeometrySurfacing
File: GeometrySurfacing
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "DLLInfo.h"
#if NDEVR_SURFACING
#include <NDEVR/SoftwareService.h>
#include <NDEVR/GeometryVertices.h>
#include <NDEVR/Model.h>
#include <NDEVR/Material.h>
#include <NDEVR/DesignCommand.h>
#include <NDEVR/Buffer.h>
#include <NDEVR/SelectionArea.h>
#include <NDEVR/GenericOption.h>
#include <NDEVR/JSONNode.h>
#include <NDEVR/INIInterface.h>
namespace NDEVR
{
    template<uint01 t_dims, class t_type>
    class SelectionArea;
    class DesignObjectLookup;
    class DesignSelection;
    class NDEVR_SURFACING_API SurfacingDescription : public GenericOptionGroup, public INIInterface
    {
    public:
        SurfacingDescription(const TranslatedString& filter_name, const StringView& filter_id);
        virtual void getINI(INIFactory& factory) override;
        uint04 use_counts = 0;  
        uint04 priority = 0;    
    };
    struct SurfacePostProcessingOptions
    {
        fltp08 combine_vertex_epsilon = 0.0;    
        bool combine_vertices = false;          
    };
    struct GenerateMaterialInformation
    {
        Material::UVMode mode = Material::UVMode::e_background;     
        RGBColor constant_color = Constant<RGBColor>::Invalid;      
    };
    class NormalFlipper;
    struct NDEVR_SURFACING_API GeometrySurfacingParameters : public GenericOptionGroup, public GeometryVertices
    {
        GeometrySurfacingParameters();
        GeometrySurfacingParameters(const SurfacingDescription& description);
        void flipPositionElevations();
        [[nodiscard]] uint04 surfacePrimitiveSize() const;
        [[nodiscard]] bool hasSameOptions(const GeometrySurfacingParameters& params) const;
        GenerateMaterialInformation material_info;                      
        const void* lock = nullptr;                                     
        LogPtr log = nullptr;                                           
        NormalFlipper* normal_flipper = nullptr;                            
        DesignObjectLookup* lookup = nullptr;                           
        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;                        
        fltp08 linework_surface_delta = 0.01;                           
        fltp08 mesh_surface_delta = 0.01;                               
        bool surface_linework = false;                                  
        bool surface_meshes = false;                                    
        bool include_colors = false;                                    
        bool simplify_meshes = false;                                   
        SurfacePostProcessingOptions post_processing_options;           
        Model target_surface_location;                                  
        UUID normal_cache_id;                                           
    };
    class NormalFlipper : public SoftwareService
    {
    public:
        virtual bool shouldFlipNormal(uint04 idx, GeometrySurfacingParameters& parameters, const Ray<3, fltp04>& normal) = 0;
    };
    class NDEVR_SURFACING_API GeometrySurfacing : public SoftwareServiceManager
    {
    protected:
        explicit GeometrySurfacing(const TranslatedString& name, const StringView& id);
    public:
        GeometrySurfacing(const GeometrySurfacing& filter) = delete;
        GeometrySurfacing(const GeometrySurfacing&& filter) = delete;
        virtual ~GeometrySurfacing() = default;
        virtual bool runSurfacing(GeometrySurfacingParameters& parameters) = 0;
        [[nodiscard]] virtual bool canRunSurfacing(const GeometrySurfacingParameters&) { return true; }
        [[nodiscard]] virtual Buffer<SurfacingDescription> defaultSurfacingArguments();
        [[nodiscard]] const TranslatedString& surfacingName() const { return m_name; }
        [[nodiscard]] const String& surfacingID() const { return m_id; }
    public:
        static void SetupDefaultSurfaceObject(GeometrySurfacingParameters& params);
        static void SetupDefaultSurfaceMaterial(GeometrySurfacingParameters& params);
        static const Dictionary<String, GeometrySurfacing*>& AvailableSurfacing();
        static void AddAvailableSurfacingEngine(GeometrySurfacing* filter);
        static void ExecuteSurfacing(GeometrySurfacingParameters& params, const DesignSelection& selection_to_surface);
        static void ExecuteSurfacing(GeometrySurfacingParameters& params, const Buffer<Model>& models_to_surface);
        static void ExecuteSurfacing(GeometrySurfacingParameters& params, const Buffer<SelectionArea<3, fltp08>>& boundary_areas);
        [[nodiscard]] static Buffer<SurfacingDescription> GetAvailableDescriptions();
        [[nodiscard]] static uint04 AvailableSurfacingDescriptionCount();
        [[nodiscard]] static String ToCommandString(const SurfacingDescription& descriptions);
        static void ClearCache();
        [[nodiscard]] static String CreateDescription(GeometrySurfacingParameters& params);
        static void FindSurfaceColors(GeometrySurfacingParameters& params, fltp04 max_distance = Constant<fltp04>::Max);
    protected:
        static void PrepareForSurfacing(const Matrix<fltp08>& transform, const Model& model, const Geometry& geo, GeometrySurfacingParameters& params);
        static void ClearAllSurfacing(Geometry& geo, InfoPipe* log, const void* lock);
        static void FinishSurfacing(GeometrySurfacingParameters& params, const Buffer<SelectionArea<3, fltp08>>& boundary_areas);
        static void FilterSurface(const Matrix<fltp08>& transform, GeometrySurfacingParameters& params, const Buffer<SelectionArea<3, fltp08>>& boundary_areas);
        static void FilterVertices(GeometrySurfacingParameters& params);
        static void SetupGeometry(Geometry& geo, const GeometrySurfacingParameters& params);
    protected:
        static Dictionary<String, GeometrySurfacing*> s_global_available_surfacing_engines; 
    protected:
        TranslatedString m_name;    
        String m_id;                
    };
    class GeometrySurfacingCommand : public DesignCommand
    {
    public:
        NDEVR_SURFACING_API GeometrySurfacingCommand(const GeometrySurfacingParameters& params, const UUID& output_id = Constant<UUID>::Invalid);
        NDEVR_SURFACING_API GeometrySurfacingCommand(const SurfacingDescription& description, bool include_colors, bool include_lines, const UUID& output_id = Constant<UUID>::Invalid);
        virtual ~GeometrySurfacingCommand() {};
        NDEVR_SURFACING_API virtual void execute(DesignObjectLookup* lookup) override;
        virtual bool isAsyncExecution() const override { return true; }
        NDEVR_SURFACING_API StringView icon() const override;
        NDEVR_SURFACING_API TranslatedString name() const override;
        virtual bool addTarget(UUID target_id) override { targets.add(target_id); return true; }
    public:
        Buffer<UUID> targets;                               
    protected:
        GeometrySurfacingParameters m_params;               
        UUID m_output_id = Constant<UUID>::Invalid;         
        UUID m_generated_id = Constant<UUID>::Invalid;      
    };
}
#endif