material-variable.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_VARIABLE_HPP
#define ANTKEEPER_RENDER_MATERIAL_VARIABLE_HPP
 
#include <engine/math/vector.hpp>
#include <engine/math/matrix.hpp>
#include <engine/gl/texture.hpp>
#include <engine/render/material-variable-type.hpp>
#include <memory>
#include <vector>
 
namespace render {
 
class material_variable_base
{
public:
    virtual ~material_variable_base() = default;
    
    [[nodiscard]] virtual constexpr material_variable_type type() const noexcept = 0;
    
    [[nodiscard]] virtual std::size_t size() const noexcept = 0;
    
    [[nodiscard]] virtual std::unique_ptr<material_variable_base> clone() const = 0;
};
 
template <class T>
class material_variable: public material_variable_base
{
public:
    using element_type = T;
    
    inline explicit material_variable(std::size_t size, const element_type& value = element_type()):
        elements(size, value)
    {}
    
    inline material_variable():
        material_variable(1)
    {}
    
    inline explicit material_variable(std::initializer_list<element_type> list):
        elements(list)
    {}
    
    [[nodiscard]] virtual constexpr material_variable_type type() const noexcept override;
    
    [[nodiscard]] inline std::size_t size() const noexcept override
    {
        return elements.size();
    }
    
    [[nodiscard]] inline std::unique_ptr<material_variable_base> clone() const override
    {
        return std::make_unique<material_variable<T>>(*this);
    }
    
    inline void set(const element_type& value)
    {
        elements.front() = value;
    }
    
    inline void set(std::size_t index, const element_type& value)
    {
        elements[index] = value;
    }
    
    [[nodiscard]] inline const element_type& get() const
    {
        return elements.front();
    }
    
    [[nodiscard]] inline const element_type& get(std::size_t index) const
    {
        return elements[index];
    }
    
    [[nodiscard]] inline const element_type* data() const noexcept
    {
        return elements.data();
    }
    
private:
    std::vector<element_type> elements;
};
 
using matvar_bool = material_variable<bool>;
 
using matvar_bvec2 = material_variable<math::bvec2>;
 
using matvar_bvec3 = material_variable<math::bvec3>;
 
using matvar_bvec4 = material_variable<math::bvec4>;
 
using matvar_int = material_variable<int>;
 
using matvar_ivec2 = material_variable<math::ivec2>;
 
using matvar_ivec3 = material_variable<math::ivec3>;
 
using matvar_ivec4 = material_variable<math::ivec4>;
 
using matvar_uint = material_variable<unsigned int>;
 
using matvar_uvec2 = material_variable<math::uvec2>;
 
using matvar_uvec3 = material_variable<math::uvec3>;
 
using matvar_uvec4 = material_variable<math::uvec4>;
 
using matvar_float = material_variable<float>;
 
using matvar_fvec2 = material_variable<math::fvec2>;
 
using matvar_fvec3 = material_variable<math::fvec3>;
 
using matvar_fvec4 = material_variable<math::fvec4>;
 
using matvar_fmat2 = material_variable<math::fmat2>;
 
using matvar_fmat3 = material_variable<math::fmat3>;
 
using matvar_fmat4 = material_variable<math::fmat4>;
 
using matvar_texture_1d = material_variable<std::shared_ptr<gl::texture_1d>>;
 
using matvar_texture_2d = material_variable<std::shared_ptr<gl::texture_2d>>;
 
using matvar_texture_3d = material_variable<std::shared_ptr<gl::texture_3d>>;
 
using matvar_texture_cube = material_variable<std::shared_ptr<gl::texture_cube>>;
 
template <>
inline constexpr material_variable_type matvar_bool::type() const noexcept
{
    return material_variable_type::bvec1;
}
 
template <>
inline constexpr material_variable_type matvar_bvec2::type() const noexcept
{
    return material_variable_type::bvec2;
}
 
template <>
inline constexpr material_variable_type matvar_bvec3::type() const noexcept
{
    return material_variable_type::bvec3;
}
 
template <>
inline constexpr material_variable_type matvar_bvec4::type() const noexcept
{
    return material_variable_type::bvec4;
}
 
template <>
inline constexpr material_variable_type matvar_int::type() const noexcept
{
    return material_variable_type::ivec1;
}
 
template <>
inline constexpr material_variable_type matvar_ivec2::type() const noexcept
{
    return material_variable_type::ivec2;
}
 
template <>
inline constexpr material_variable_type matvar_ivec3::type() const noexcept
{
    return material_variable_type::ivec3;
}
 
template <>
inline constexpr material_variable_type matvar_ivec4::type() const noexcept
{
    return material_variable_type::ivec4;
}
 
template <>
inline constexpr material_variable_type matvar_uint::type() const noexcept
{
    return material_variable_type::uvec1;
}
 
template <>
inline constexpr material_variable_type matvar_uvec2::type() const noexcept
{
    return material_variable_type::uvec2;
}
 
template <>
inline constexpr material_variable_type matvar_uvec3::type() const noexcept
{
    return material_variable_type::uvec3;
}
 
template <>
inline constexpr material_variable_type matvar_uvec4::type() const noexcept
{
    return material_variable_type::uvec4;
}
 
template <>
inline constexpr material_variable_type matvar_float::type() const noexcept
{
    return material_variable_type::fvec1;
}
 
template <>
inline constexpr material_variable_type matvar_fvec2::type() const noexcept
{
    return material_variable_type::fvec2;
}
 
template <>
inline constexpr material_variable_type matvar_fvec3::type() const noexcept
{
    return material_variable_type::fvec3;
}
 
template <>
inline constexpr material_variable_type matvar_fvec4::type() const noexcept
{
    return material_variable_type::fvec4;
}
 
template <>
inline constexpr material_variable_type matvar_fmat2::type() const noexcept
{
    return material_variable_type::fmat2;
}
 
template <>
inline constexpr material_variable_type matvar_fmat3::type() const noexcept
{
    return material_variable_type::fmat3;
}
 
template <>
inline constexpr material_variable_type matvar_fmat4::type() const noexcept
{
    return material_variable_type::fmat4;
}
 
template <>
inline constexpr material_variable_type matvar_texture_1d::type() const noexcept
{
    return material_variable_type::texture_1d;
}
 
template <>
inline constexpr material_variable_type matvar_texture_2d::type() const noexcept
{
    return material_variable_type::texture_2d;
}
 
template <>
inline constexpr material_variable_type matvar_texture_3d::type() const noexcept
{
    return material_variable_type::texture_3d;
}
 
template <>
inline constexpr material_variable_type matvar_texture_cube::type() const noexcept
{
    return material_variable_type::texture_cube;
}
 
} // namespace render
 
#endif // ANTKEEPER_RENDER_MATERIAL_VARIABLE_HPP