💿🐜 Antkeeper source code
https://antkeeper.com
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
373 lines
9.6 KiB
373 lines
9.6 KiB
/*
|
|
* 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/utility/fundamental-types.hpp>
|
|
#include <engine/gl/texture-1d.hpp>
|
|
#include <engine/gl/texture-2d.hpp>
|
|
#include <engine/gl/texture-3d.hpp>
|
|
#include <engine/gl/texture-cube.hpp>
|
|
#include <engine/render/material-variable-type.hpp>
|
|
#include <memory>
|
|
#include <vector>
|
|
|
|
namespace render {
|
|
|
|
/**
|
|
* Abstract base class for material variables.
|
|
*/
|
|
class material_variable_base
|
|
{
|
|
public:
|
|
/**
|
|
* Destructs a material variable base.
|
|
*/
|
|
virtual ~material_variable_base() = default;
|
|
|
|
/**
|
|
* Returns the material variable data type.
|
|
*/
|
|
[[nodiscard]] virtual constexpr material_variable_type type() const noexcept = 0;
|
|
|
|
/**
|
|
* Returns the number of elements in an array variable, or `1` if the variable is not an array.
|
|
*/
|
|
[[nodiscard]] virtual std::size_t size() const noexcept = 0;
|
|
|
|
/**
|
|
* Creates a copy of this material property.
|
|
*/
|
|
[[nodiscard]] virtual std::unique_ptr<material_variable_base> clone() const = 0;
|
|
};
|
|
|
|
/**
|
|
* Material variable.
|
|
*
|
|
* @tparam T Material variable value type.
|
|
*/
|
|
template <class T>
|
|
class material_variable: public material_variable_base
|
|
{
|
|
public:
|
|
/// Material variable element type.
|
|
using element_type = T;
|
|
|
|
/**
|
|
* Constructs a material variable.
|
|
*
|
|
* @param size Number of elements in the array, or `1` if the variable is not an array.
|
|
* @param value Value with which to initialize the elements.
|
|
*/
|
|
inline explicit material_variable(std::size_t size, const element_type& value = element_type()):
|
|
elements(size, value)
|
|
{}
|
|
|
|
/**
|
|
* Constructs a material variable with a single element.
|
|
*/
|
|
inline material_variable():
|
|
material_variable(1)
|
|
{}
|
|
|
|
/**
|
|
* Constructs a material variable from a list of element values.
|
|
*
|
|
* @param list List of element values.
|
|
*/
|
|
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);
|
|
}
|
|
|
|
/**
|
|
* Sets the value of the the variable, or the value of the first element if the variable is an array.
|
|
*
|
|
* @param value Value to set.
|
|
*/
|
|
inline void set(const element_type& value)
|
|
{
|
|
elements.front() = value;
|
|
}
|
|
|
|
/**
|
|
* Sets the value of a single element in an array variable.
|
|
*
|
|
* @param index Index of an element.
|
|
* @param value Value to set.
|
|
*/
|
|
inline void set(std::size_t index, const element_type& value)
|
|
{
|
|
elements[index] = value;
|
|
}
|
|
|
|
/**
|
|
* Returns a reference to the first element in the array.
|
|
*/
|
|
[[nodiscard]] inline const element_type& get() const
|
|
{
|
|
return elements.front();
|
|
}
|
|
|
|
/**
|
|
* Returns a reference to the element at a given index.
|
|
*
|
|
* @param index Index of an element.
|
|
*
|
|
* @return Reference to the element at @p index.
|
|
*/
|
|
[[nodiscard]] inline const element_type& get(std::size_t index) const
|
|
{
|
|
return elements[index];
|
|
}
|
|
|
|
/**
|
|
* Returns a pointer to the element array.
|
|
*/
|
|
[[nodiscard]] inline const element_type* data() const noexcept
|
|
{
|
|
return elements.data();
|
|
}
|
|
|
|
private:
|
|
std::vector<element_type> elements;
|
|
};
|
|
|
|
/// Boolean material variable.
|
|
using material_bool = material_variable<bool>;
|
|
|
|
/// 2-dimensional boolean vector material variable.
|
|
using material_bool2 = material_variable<bool2>;
|
|
|
|
/// 3-dimensional boolean vector material variable.
|
|
using material_bool3 = material_variable<bool3>;
|
|
|
|
/// 4-dimensional boolean vector material variable.
|
|
using material_bool4 = material_variable<bool4>;
|
|
|
|
/// Integer material variable.
|
|
using material_int = material_variable<int>;
|
|
|
|
/// 2-dimensional integer vector material variable.
|
|
using material_int2 = material_variable<int2>;
|
|
|
|
/// 3-dimensional integer vector material variable.
|
|
using material_int3 = material_variable<int3>;
|
|
|
|
/// 4-dimensional integer vector material variable.
|
|
using material_int4 = material_variable<int4>;
|
|
|
|
/// Unsigned integer material variable.
|
|
using material_uint = material_variable<unsigned int>;
|
|
|
|
/// 2-dimensional unsigned integer vector material variable.
|
|
using material_uint2 = material_variable<uint2>;
|
|
|
|
/// 3-dimensional unsigned integer vector material variable.
|
|
using material_uint3 = material_variable<uint3>;
|
|
|
|
/// 4-dimensional unsigned integer vector material variable.
|
|
using material_uint4 = material_variable<uint4>;
|
|
|
|
/// Floating-point material variable.
|
|
using material_float = material_variable<float>;
|
|
|
|
/// 2-dimensional floating-point vector material variable.
|
|
using material_float2 = material_variable<float2>;
|
|
|
|
/// 3-dimensional floating-point vector material variable.
|
|
using material_float3 = material_variable<float3>;
|
|
|
|
/// 4-dimensional floating-point vector material variable.
|
|
using material_float4 = material_variable<float4>;
|
|
|
|
/// 2x2 floating-point matrix material variable.
|
|
using material_float2x2 = material_variable<float2x2>;
|
|
|
|
/// 3x3 floating-point matrix material variable.
|
|
using material_float3x3 = material_variable<float3x3>;
|
|
|
|
/// 4x4 floating-point matrix material variable.
|
|
using material_float4x4 = material_variable<float4x4>;
|
|
|
|
/// 1-dimensional texture material variable.
|
|
using material_texture_1d = material_variable<std::shared_ptr<gl::texture_1d>>;
|
|
|
|
/// 2-dimensional texture material variable.
|
|
using material_texture_2d = material_variable<std::shared_ptr<gl::texture_2d>>;
|
|
|
|
/// 3-dimensional texture material variable.
|
|
using material_texture_3d = material_variable<std::shared_ptr<gl::texture_3d>>;
|
|
|
|
/// Cube texture material variable.
|
|
using material_texture_cube = material_variable<std::shared_ptr<gl::texture_cube>>;
|
|
|
|
template <>
|
|
inline constexpr material_variable_type material_bool::type() const noexcept
|
|
{
|
|
return material_variable_type::bool1;
|
|
}
|
|
|
|
template <>
|
|
inline constexpr material_variable_type material_bool2::type() const noexcept
|
|
{
|
|
return material_variable_type::bool2;
|
|
}
|
|
|
|
template <>
|
|
inline constexpr material_variable_type material_bool3::type() const noexcept
|
|
{
|
|
return material_variable_type::bool3;
|
|
}
|
|
|
|
template <>
|
|
inline constexpr material_variable_type material_bool4::type() const noexcept
|
|
{
|
|
return material_variable_type::bool4;
|
|
}
|
|
|
|
template <>
|
|
inline constexpr material_variable_type material_int::type() const noexcept
|
|
{
|
|
return material_variable_type::int1;
|
|
}
|
|
|
|
template <>
|
|
inline constexpr material_variable_type material_int2::type() const noexcept
|
|
{
|
|
return material_variable_type::int2;
|
|
}
|
|
|
|
template <>
|
|
inline constexpr material_variable_type material_int3::type() const noexcept
|
|
{
|
|
return material_variable_type::int3;
|
|
}
|
|
|
|
template <>
|
|
inline constexpr material_variable_type material_int4::type() const noexcept
|
|
{
|
|
return material_variable_type::int4;
|
|
}
|
|
|
|
template <>
|
|
inline constexpr material_variable_type material_uint::type() const noexcept
|
|
{
|
|
return material_variable_type::uint1;
|
|
}
|
|
|
|
template <>
|
|
inline constexpr material_variable_type material_uint2::type() const noexcept
|
|
{
|
|
return material_variable_type::uint2;
|
|
}
|
|
|
|
template <>
|
|
inline constexpr material_variable_type material_uint3::type() const noexcept
|
|
{
|
|
return material_variable_type::uint3;
|
|
}
|
|
|
|
template <>
|
|
inline constexpr material_variable_type material_uint4::type() const noexcept
|
|
{
|
|
return material_variable_type::uint4;
|
|
}
|
|
|
|
template <>
|
|
inline constexpr material_variable_type material_float::type() const noexcept
|
|
{
|
|
return material_variable_type::float1;
|
|
}
|
|
|
|
template <>
|
|
inline constexpr material_variable_type material_float2::type() const noexcept
|
|
{
|
|
return material_variable_type::float2;
|
|
}
|
|
|
|
template <>
|
|
inline constexpr material_variable_type material_float3::type() const noexcept
|
|
{
|
|
return material_variable_type::float3;
|
|
}
|
|
|
|
template <>
|
|
inline constexpr material_variable_type material_float4::type() const noexcept
|
|
{
|
|
return material_variable_type::float4;
|
|
}
|
|
|
|
template <>
|
|
inline constexpr material_variable_type material_float2x2::type() const noexcept
|
|
{
|
|
return material_variable_type::float2x2;
|
|
}
|
|
|
|
template <>
|
|
inline constexpr material_variable_type material_float3x3::type() const noexcept
|
|
{
|
|
return material_variable_type::float3x3;
|
|
}
|
|
|
|
template <>
|
|
inline constexpr material_variable_type material_float4x4::type() const noexcept
|
|
{
|
|
return material_variable_type::float4x4;
|
|
}
|
|
|
|
template <>
|
|
inline constexpr material_variable_type material_texture_1d::type() const noexcept
|
|
{
|
|
return material_variable_type::texture_1d;
|
|
}
|
|
|
|
template <>
|
|
inline constexpr material_variable_type material_texture_2d::type() const noexcept
|
|
{
|
|
return material_variable_type::texture_2d;
|
|
}
|
|
|
|
template <>
|
|
inline constexpr material_variable_type material_texture_3d::type() const noexcept
|
|
{
|
|
return material_variable_type::texture_3d;
|
|
}
|
|
|
|
template <>
|
|
inline constexpr material_variable_type material_texture_cube::type() const noexcept
|
|
{
|
|
return material_variable_type::texture_cube;
|
|
}
|
|
|
|
} // namespace render
|
|
|
|
#endif // ANTKEEPER_RENDER_MATERIAL_VARIABLE_HPP
|