material.hpp

Go to the documentation of this file.

/*
 * Copyright (C) 2023  Christopher J. Howard
 *
 * This file is part of Antkeeper source code.
 *
 * Antkeeper source code is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Antkeeper source code is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Antkeeper source code.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef ANTKEEPER_RENDER_MATERIAL_HPP
#define ANTKEEPER_RENDER_MATERIAL_HPP
 
#include <cstdint>
#include <engine/gl/shader-template.hpp>
#include <engine/render/material-blend-mode.hpp>
#include <engine/render/material-variable.hpp>
#include <engine/render/material-shadow-mode.hpp>
#include <engine/utility/hash/fnv1a.hpp>
#include <unordered_map>
 
namespace render {
 
class material
{
public:
    material() = default;
    
    material(const material& other);
    
    ~material() = default;
    
    material& operator=(const material& other);
    
    
    void set_two_sided(bool two_sided) noexcept;
    
    void set_blend_mode(material_blend_mode mode) noexcept;
    
    void set_shadow_mode(material_shadow_mode mode) noexcept;
    
    void set_flags(std::uint32_t flags) noexcept;
    
    [[nodiscard]] inline bool is_two_sided() const noexcept
    {
        return two_sided;
    }
    
    [[nodiscard]] inline material_blend_mode get_blend_mode() const noexcept
    {
        return blend_mode;
    }
    
    [[nodiscard]] inline material_shadow_mode get_shadow_mode() const noexcept
    {
        return shadow_mode;
    }
    
    [[nodiscard]] inline std::uint32_t get_flags() const noexcept
    {
        return flags;
    }
    
    
    
    void set_shader_template(std::shared_ptr<gl::shader_template> shader_template);
    
    [[nodiscard]] inline const std::shared_ptr<gl::shader_template>& get_shader_template() const noexcept
    {
        return shader_template;
    }
    
    void set_variable(hash::fnv1a32_t key, std::shared_ptr<material_variable_base> value);
    
    [[nodiscard]] std::shared_ptr<material_variable_base> get_variable(hash::fnv1a32_t key) const;
    
    [[nodiscard]] inline const std::unordered_map<hash::fnv1a32_t, std::shared_ptr<material_variable_base>>& get_variables() const noexcept
    {
        return variable_map;
    }
    
    
    [[nodiscard]] inline std::size_t hash() const noexcept
    {
        return m_hash;
    }
    
private:
    void rehash() noexcept;
    
    bool two_sided{false};
    material_blend_mode blend_mode{material_blend_mode::opaque};
    material_shadow_mode shadow_mode{material_shadow_mode::opaque};
    std::uint32_t flags{0};
    std::shared_ptr<gl::shader_template> shader_template;
    std::unordered_map<hash::fnv1a32_t, std::shared_ptr<material_variable_base>> variable_map;
    std::size_t m_hash{0};
};
 
} // namespace render
 
#endif // ANTKEEPER_RENDER_MATERIAL_HPP