Material.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: Design
File: Material
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
 
#include <NDEVR/DesignObject.h>
#include <NDEVR/Table.h>
#include <NDEVR/Pointer.h>
#include <NDEVR/BaseValues.h>
#include <NDEVR/VectorFunctions.h>
namespace NDEVR
{
    class DesignParameterAccumulator;
    class Model;
    class ImageFactory;

    enum class NDPM
    {
          two_sided                       
        , shading_model                   
        , opacity                         
        , bump_scale                      
        , shininess                       
        , reflectivity                    
        , wireframe                       
        , smooth_normals                  
        , pixel_thickness                 
        , grid_line_spacing               
        , gridline_spacing_mode           
        , model_space_material            
        , color_value_palette             
        , draw_by_property_channel        
        , extra_property_value_min        
        , extra_property_value_mid        
        , extra_property_value_max        
        , override_parent_material        
        , override_camera_material        
        , tile_texture_mode               
        , texture_coord_mode              
        , use_normal_for_tex_coord        
        , ignore_depth                    
        , write_to_depth                  
        , depth_bias                      
        , fade_render_distance            
        , max_render_distance             
        , ignore_color_channel_lighting   
        , material_property_size          
    };
    template<> struct PropertySpec<NDPM::two_sided> { using type = bool; };
    template<> struct PropertySpec<NDPM::opacity> { using type = fltp04; };
    template<> struct PropertySpec<NDPM::bump_scale> { using type = fltp04; };
    template<> struct PropertySpec<NDPM::shininess> { using type = fltp04; };
    template<> struct PropertySpec<NDPM::reflectivity> { using type = fltp04; };
    template<> struct PropertySpec<NDPM::wireframe> { using type = bool; };
    template<> struct PropertySpec<NDPM::smooth_normals> { using type = bool; };
    template<> struct PropertySpec<NDPM::pixel_thickness> { using type = fltp04; };
    template<> struct PropertySpec<NDPM::shading_model> { using type = uint04; };
    template<> struct PropertySpec<NDPM::tile_texture_mode> { using type = Vector<3, uint01>; };
    template<> struct PropertySpec<NDPM::gridline_spacing_mode> { using type = uint01; };
    template<> struct PropertySpec<NDPM::color_value_palette> { using type = Buffer<RGBColor>; };
    template<> struct PropertySpec<NDPM::grid_line_spacing> { using type = Vector<4, fltp08>; };
    template<> struct PropertySpec<NDPM::draw_by_property_channel> { using type = StringView; };
    template<> struct PropertySpec<NDPM::extra_property_value_min> { using type = fltp08; };
    template<> struct PropertySpec<NDPM::extra_property_value_mid> { using type = fltp08; };
    template<> struct PropertySpec<NDPM::extra_property_value_max> { using type = fltp08; };
    template<> struct PropertySpec<NDPM::override_parent_material> { using type = bool; };
    template<> struct PropertySpec<NDPM::override_camera_material> { using type = bool; };
    template<> struct PropertySpec<NDPM::use_normal_for_tex_coord> { using type = bool; };
    template<> struct PropertySpec<NDPM::model_space_material> { using type = bool; };
    template<> struct PropertySpec<NDPM::texture_coord_mode> { using type = uint01; };
    template<> struct PropertySpec<NDPM::ignore_depth> { using type = bool; };
    template<> struct PropertySpec<NDPM::write_to_depth> { using type = bool; };
    template<> struct PropertySpec<NDPM::depth_bias> { using type = fltp04; };
    template<> struct PropertySpec<NDPM::fade_render_distance> { using type = fltp08; };
    template<> struct PropertySpec<NDPM::max_render_distance> { using type = fltp08; };
    template<> struct PropertySpec<NDPM::ignore_color_channel_lighting> { using type = bool; };

    template<>
    class PropertyColumnInterface<NDPM>
    {
    public:
        static constexpr TableColumn* column(const DesignInfo* object, NDPM property)
        {
            return object->m_base->material_properties[eint01(property)];
        }

        static constexpr uint04 index(const DesignInfo* object, NDPM)
        {
            return object->m_design_index;
        }
    };

    class NDEVR_DESIGN_API Material : public DesignObject
    {
    public:
        enum ShadingModel
        {
              e_flat          
            , e_gouraud       
            , e_phong         
            , e_phong_blinn   
            , e_toon          
            , e_oren_nayar    
            , e_minnaert      
            , e_cook_torrance 
            , e_no_shading    
            , e_fresnel       
            , e_pbr           
            , e_ibl           
            , e_water         
            , e_background_gradiant 
            , e_skybox        
            , e_number_of_shading_models 
        };

        enum UVMode
        {
              e_none                            
            , e_solid_color                     
            , e_color_channel                   
            , e_scaled_channel                  
            , e_color_by_model                  
            , e_background                      
            , e_background_contrast             
            , e_background_contrast_plus_solid  
            , e_image                           
            , e_color_by_layer                  
            , e_highlight                       
        };

        enum GridLineMode : uint01
        {
              e_no_linework = 0         
            , e_global_linework = 1     
            , e_modelspace_linework = 2 
            , e_invalid = 255           
        };

        enum TileTextureMode
        {
              e_tile_tex_undefined 
            , e_tile_texture_wrap  
            , e_tile_texture_clamp 
            , e_tile_texture_decal 
            , e_tile_texture_mirror 
        };

        enum TextureCoordMode
        {
              e_tex_coord_undefined 
            , e_use_mat_coordinates 
            , e_project_sphere      
            , e_project_cylinder    
            , e_project_box         
            , e_project_plane       
        };
    public:
        Material() = default;

        Material(uint04 index, DesignObjectBase* property_table);

        Material(DesignObjectBase* property_table);

        explicit Material(const DesignObject& obj);

        bool hasActiveImage() const;

        bool hasImageData() const;

        TranslatedString displayName() const;

        TranslatedString appearanceName() const;

        bool hasOpacity() const;

        void setupAsDefault();

        bool isSupportedByShadingModel(UVType type) const;

        TextureCoordMode getTextureCoordinateMode() const;

        void setTileTextureMode(const Vector<3, TileTextureMode>& modes);

        Vector<3, TileTextureMode> getTileTextureMode() const;

        ShadingModel getShadingModel() const;

        bool validate() const;

        void colorBy(const DesignParameterAccumulator& accumulator);

        RGBColor convertValueToColor(fltp08 value) const;

        void copyFrom(const Material& mesh);

        void combineFrom(const Material& mesh);

        void ensureImageDataLoaded(ImageFactory& factory);

        PrimitiveProperty defaultRenderProperty() const;

        void setUVImage(UVType uv_index, const StringView& type)
        {
            m_base->uv_image_file[cast<uint01>(uv_index)]->set(m_design_index, type);
        }

        template<class t_type>
        void setUVColor(const t_type& type)
        {
            for (uint01 i = 0; i < cast<uint01>(UVType::e_uv_size); i++)
                setUVColor(cast<UVType>(i), type);
        }

        template<class t_type>
        void setUVColor(UVType uv_index, const t_type& type)
        {
            m_base->uv_color[cast<uint01>(uv_index)]->set(m_design_index, type);
        }

        template<class t_type>
        void updateUVColor(const t_type& type, const void* lock_ptr = nullptr)
        {
            for (uint04 i = 0; i < cast<uint04>(UVType::e_uv_size); i++)
                updateUVColor(cast<UVType>(i), type, lock_ptr);
        }

        template<class t_type>
        void updateUVColor(UVType uv_index, const t_type& value, const void* lock_ptr = nullptr)
        {
            if (getUVColor(uv_index) != value)
            {
                WLock lock(lock_ptr);
                m_base->uv_color[cast<uint01>(uv_index)]->set(m_design_index, value);
                updateModifiedTime();
            }
        }

        template<class t_type>
        void setUVIntensity(UVType uv_index, const t_type& type)
        {
            m_base->uv_intensity[cast<uint01>(uv_index)]->set(m_design_index, type);
        }

        template<class t_type>
        void setUVLayer(UVType uv_index, const t_type& type)
        {
            m_base->uv_layer[cast<uint01>(uv_index)]->set(m_design_index, type);
        }

        void setUVMode(UVType uv_index, const UVMode& type);

        StringView getUVImage(UVType uv_index) const;

        RGBColor getUVColor(UVType uv_index) const;

        fltp04 getUVIntensity(UVType uv_index) const;

        uint04 getUVLayer(UVType uv_index) const;

        UVMode getUVMode(UVType uv_index) const;

        bool hasActiveUVImage(UVType index) const;

        bool hasUVIntensity(UVType index) const;

        void cleanupMaterial();

        bool hasUVLayer(UVType index) const;

        bool hasUVColor(UVType index) const;

        bool hasPerVertexColoring(UVType type = UVType::e_KD) const;

        bool hasModelDependentColor(UVType type) const;

        bool hasModelDependentColor() const;

        [[nodiscard]] RGBColor constantColor(Model model, RGBColor background_color = RGBColor(255, 255, 255), UVType type = UVType::e_KD) const;

        Buffer<RGBColor> palette() const;

        void setPalette(const Buffer<RGBColor>& palette);

        void updateModifiedTime(const Time& time = Time::SystemTime());
    };

    template<>
    struct ObjectInfo<Material, false, false>
    {
        static const uint01 Dimensions = 0;   
        static const bool Vector = false;      
        static const bool Buffer = false;      
        static const bool Primitive = true;    
        static const bool Pointer = false;     
        static const bool Unsigned = false;    
        static const bool Float = false;       
        static const bool Integer = false;     
        static const bool Number = false;      
        static const bool Enum = false;        
        static const bool String = false;      
        static const bool Color = false;       
        static const bool Boolean = false;     

        static constexpr ObjectInfo<Material, false, false> VectorSub() { return ObjectInfo<Material, false, false>(); }
    };
    template class NDEVR_DESIGN_API StringStream<Material::GridLineMode>;
    template class NDEVR_DESIGN_API StringStream<Material::TextureCoordMode>;
    template class NDEVR_DESIGN_API StringStream<Material::TileTextureMode>;
    template class NDEVR_DESIGN_API StringStream<Material::UVMode>;
    template class NDEVR_DESIGN_API StringStream<Material::ShadingModel>;
    template class NDEVR_DESIGN_API StringStream<NDPM>;
}

namespace std//Define things to allow use within std libs
{
    template <>
    struct hash<Material>
    {
        std::size_t operator()(const Material& d) const noexcept
        {
            UUID s = d.get<NDPO::guid>();
            std::size_t value = 0;
            for (uint01 i = 0; i < 8; i++)
                value = value * 256 + (s[i + 0U] ^ s[i + 8U]);
            return value;
        }
    };
};