Material.hpp

#ifndef RAYLIB_CPP_INCLUDE_MATERIAL_HPP_
#define RAYLIB_CPP_INCLUDE_MATERIAL_HPP_
 
#include <span>
#include <string>
#include <string_view>
#include <vector>
 
#include "./raylib-cpp-utils.hpp"
#include "./raylib.hpp"
 
namespace raylib {
class Material : public ::Material {
public:
    Material(const ::Material& material) : ::Material(material) {  }
 
    Material() : ::Material(LoadMaterialDefault()) { }
 
    Material(const Material&) = delete;
 
    Material(Material&& other) noexcept {
        set(other);
 
        other.maps = nullptr;
        other.shader = {};
        other.params[0] = 0.0f;
        other.params[1] = 0.0f;
        other.params[2] = 0.0f;
        other.params[3] = 0.0f;
    }
 
    ~Material() { Unload(); }
 
    static std::vector<Material> Load(const std::string_view fileName) {
        int count = 0;
        // TODO(RobLoach): Material::Load() possibly leaks the materials array.
        ::Material* materials = ::LoadMaterials(fileName.data(), &count);
        return std::vector<Material>(materials, materials + count);
    }
 
    GETTERSETTER(::Shader, Shader, shader)
    GETTERSETTER(::MaterialMap*, Maps, maps)
    // TODO(RobLoach): Resolve the Material params being a float[4].
    // GETTERSETTER(float[4], Params, params)
 
    Material& operator=(const ::Material& material) {
        set(material);
        return *this;
    }
 
    Material& operator=(const Material&) = delete;
 
    Material& operator=(Material&& other) noexcept {
        if (this == &other) {
            return *this;
        }
 
        Unload();
        set(other);
 
        other.maps = nullptr;
        other.shader = {};
 
        return *this;
    }
 
    void Unload() {
        if (maps != nullptr) {
            ::UnloadMaterial(*this);
            maps = nullptr;
        }
    }
 
    Material& SetTexture(int mapType, const ::Texture2D& texture) {
        ::SetMaterialTexture(this, mapType, texture);
        return *this;
    }
 
    void DrawMesh(const ::Mesh& mesh, ::Matrix transform) const { ::DrawMesh(mesh, *this, transform); }
 
    void DrawMesh(const ::Mesh& mesh, ::Matrix* transforms, int instances) const {
        ::DrawMeshInstanced(mesh, *this, transforms, instances);
    }
 
    inline void DrawMesh(const ::Mesh& mesh, std::span<::Matrix> transforms) const {
        ::DrawMeshInstanced(mesh, *this, transforms.data(), static_cast<int>(transforms.size()));
    }
 
    [[nodiscard]] bool IsValid() const { return ::IsMaterialValid(*this); }
protected:
    void set(const ::Material& material) {
        shader = material.shader;
        maps = material.maps;
        params[0] = material.params[0];
        params[1] = material.params[1];
        params[2] = material.params[2];
        params[3] = material.params[3];
    }
};
} // namespace raylib
 
using RMaterial = raylib::Material;
 
#endif // RAYLIB_CPP_INCLUDE_MATERIAL_HPP_