RenderTexture.hpp

#ifndef RAYLIB_CPP_INCLUDE_RENDERTEXTURE_HPP_
#define RAYLIB_CPP_INCLUDE_RENDERTEXTURE_HPP_
 
#include "./raylib.hpp"
#include "./raylib-cpp-utils.hpp"
#include "./RaylibException.hpp"
#include "./TextureUnmanaged.hpp"
 
namespace raylib {
class RenderTexture : public ::RenderTexture {
 public:
    RenderTexture() {
        id = 0;
    }
 
    RenderTexture(const ::RenderTexture& renderTexture) {
        set(renderTexture);
    }
 
    RenderTexture(unsigned int id, const ::Texture& texture, const ::Texture& depth) :
        ::RenderTexture{id, texture, depth} {}
 
    RenderTexture(int width, int height) {
        set(::LoadRenderTexture(width, height));
    }
 
    RenderTexture(const RenderTexture&) = delete;
 
    RenderTexture(RenderTexture&& other) {
        set(other);
 
        other.id = 0;
        other.texture = {};
        other.depth = {};
    }
 
    GETTER(unsigned int, Id, id)
 
    
    TextureUnmanaged GetTexture() {
        return texture;
    }
 
    void SetTexture(const ::Texture& newTexture) {
        texture = newTexture;
    }
 
    TextureUnmanaged GetDepth() {
        return depth;
    }
 
    void SetDepth(const ::Texture& newDepth) {
        depth = newDepth;
    }
 
    RenderTexture& operator=(const ::RenderTexture& texture) {
        set(texture);
        return *this;
    }
 
    RenderTexture& operator=(const RenderTexture&) = delete;
 
    RenderTexture& operator=(RenderTexture&& other) noexcept {
        if (this == &other) {
            return *this;
        }
 
        Unload();
        set(other);
 
        other.id = 0;
        other.texture = {};
        other.depth = {};
 
        return *this;
    }
 
    ~RenderTexture() {
        Unload();
    }
 
    void Unload() {
        UnloadRenderTexture(*this);
    }
 
    RenderTexture& BeginMode() {
        ::BeginTextureMode(*this);
        return *this;
    }
 
    RenderTexture& EndMode() {
        ::EndTextureMode();
        return *this;
    }
 
    static RenderTexture Load(int width, int height) {
        return ::LoadRenderTexture(width, height);
    }
 
    bool IsReady() const {
        return ::IsRenderTextureReady(*this);
    }
 
 protected:
    void set(const ::RenderTexture& renderTexture) {
        id = renderTexture.id;
        texture = renderTexture.texture;
        depth = renderTexture.depth;
    }
};
 
using RenderTexture2D = RenderTexture;
 
}  // namespace raylib
 
using RRenderTexture = raylib::RenderTexture;
using RRenderTexture2D = raylib::RenderTexture2D;
 
#endif  // RAYLIB_CPP_INCLUDE_RENDERTEXTURE_HPP_