Material.h

Go to the documentation of this file.

/**--------------------------------------------------------------------------------------------
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 NDEVR_DESIGN_API Material : public DesignObject
    {
    public:
        enum ShadingModel
        {
              e_flat          // Flat shading. Shading is done on per - face base, diffuse only.Also known as 'faceted shading'.
            , e_gouraud       // Simple Gouraud shading.
            , e_phong         // Phong - Shading - .
            , e_phong_blinn   // Phong - Blinn - Shading.
            , e_toon          // Shading per pixel. Also known as 'comic' shader.
            , e_oren_nayar    // Shading per pixel. Extension to standard Lambertian shading, taking the roughness of the material into account
            , e_minnaert      // Shading per pixel. Extension to standard Lambertian shading, taking the "darkness" of the material into account
            , e_cook_torrance // Special shader for metallic surfaces.
            , e_no_shading    // No shading at all. Constant light influence of 1.0.
            , e_fresnel       // Fresnel shading.
            , 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
        {
              e_no_linework
            , e_global_linework
            , e_modelspace_linework
        };
 
        enum TileTextureMode
        {
              e_tile_tex_undefined
            , e_tile_texture_wrap // A texture coordinate u|v is translated to u%1|v%1
            , e_tile_texture_clamp//Texture coordinates outside [0...1] are clamped to the nearest valid value.
            , e_tile_texture_decal // If the texture coordinates for a pixel are outside [0...1] the texture is not applied to that pixel
            , e_tile_texture_mirror//A texture coordinate u|v becomes u%1|v%1 if (u-(u%1))%2 is zero and 1-(u%1)|1-(v%1) otherwise
        };
        enum TextureCoordMode
        {
              e_tex_coord_undefined
            , e_use_mat_coordinates
            , e_project_sphere
            , e_project_cylinder
            , e_project_box
            , e_project_plane
        };
 
        enum MaterialProperties
        {
              e_two_sided
            , e_shading_model
            , e_opacity
            , e_bump_scale
            , e_shininess
            , e_reflectivity
            , e_wireframe
            , e_smooth_normals
            , e_pixel_thickness
            , e_grid_line_spacing
            , e_gridline_spacing_mode
            , e_is_dynamic_texture
            , e_model_space_material
            , e_color_value_palette
            , e_draw_by_property_channel
 
            , e_extra_property_color_min
            , e_extra_property_color_mid
            , e_extra_property_color_max
 
            , e_extra_property_value_min
            , e_extra_property_value_mid
            , e_extra_property_value_max
 
            , e_override_parent_material
            , e_override_camera_material
 
            , e_tile_texture_mode
            , e_texture_coord_mode
            , e_use_normal_for_tex_coord
            , e_ignore_depth
            , e_write_to_depth
            , e_depth_bias
            , e_fade_render_distance
            , e_max_render_distance
            , e_ignore_color_channel_lighting
        };
    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;
        void setShadingModel(ShadingModel model);
        void setTextureCoordinateMode(const TextureCoordMode& mode);
        TextureCoordMode getTextureCoordinateMode() const;
        void setTileTextureMode(const Vector<3, TileTextureMode>& modes);
        Vector<3, TileTextureMode> getTileTextureMode() const;
        ShadingModel getShadingModel() const;
        bool validate() const;
 
        template<class t_type>
        t_type getMaterialProperty(MaterialProperties mat_index) const
        {
            return m_base->material_table.get()[m_base->material_property_index[cast<uint04>(mat_index)]].get<t_type>(m_design_index);
        }
        template<class t_type>
        void setMaterialProperty(MaterialProperties mat_index, const t_type& type)
        {
            m_base->material_table.get()[m_base->material_property_index[cast<uint04>(mat_index)]].set(m_design_index, type);
        }
        template<class t_type>
        void updateMaterialProperty(MaterialProperties mat_index, const t_type& type, const void* lock_ptr = nullptr)
        {
            if (getMaterialProperty<t_type>(mat_index) != type)
            {
                WLock wLock(lock_ptr);
                setMaterialProperty(mat_index, type);
                updateModifiedTime();
            }
        }
        void colorBy(const DesignParameterAccumulator& accumulator);
        RGBColor convertValueToColor(fltp08 value) const;
        void copyFrom(const Material& mesh);
        void combineFrom(const Material& mesh);
 
        PrimitiveProperty defaultRenderProperty() const;
 
 
        template<class t_type>
        void setUVImage(UVType uv_index, const t_type& type)
        {
            uint04 column = m_base->uv_image_file[cast<uint04>(uv_index)];
            m_base->material_table.get()[column].set(m_design_index, type);
        }
        template<class t_type>
        void setUVColor(const t_type& type)
        {
            for (uint04 i = 0; i < cast<uint04>(UVType::e_uv_size); i++)
                setUVColor(cast<UVType>(i), type);
        }
        template<class t_type>
        void setUVColor(UVType uv_index, const t_type& type)
        {
            uint04 column = m_base->uv_color[cast<uint04>(uv_index)];
            m_base->material_table.get()[column].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);
                uint04 column = m_base->uv_color[cast<uint04>(uv_index)];
                m_base->material_table.get()[column].set(m_design_index, value);
                updateModifiedTime();
            }
        }
        template<class t_type>
        void setUVIntensity(UVType uv_index, const t_type& type)
        {
            uint04 column = m_base->uv_intensity[cast<uint04>(uv_index)];
            m_base->material_table.get()[column].set(m_design_index, type);
        }
        template<class t_type>
        void setUVLayer(UVType uv_index, const t_type& type)
        {
            uint04 column = m_base->uv_layer[cast<uint04>(uv_index)];
            m_base->material_table.get()[column].set(m_design_index, type);
        }
        void setUVMode(UVType uv_index, const UVMode& type);
        String 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 = DESIGN_PRIM;
        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<Material::MaterialProperties>;
}
namespace std//Define things to allow use within std libs
{
    template <>
    struct hash<NDEVR::Material>
    {
        std::size_t operator()(const NDEVR::Material& d) const noexcept
        {
            NDEVR::UUID s = d.uuid();
            std::size_t value = 0;
            for (NDEVR::uint01 i = 0; i < 8; i++)
                value = value * 256 + (s[i + 0U] ^ s[i + 8U]);
            return value;
        }
    };
};