TextureUnmanaged.hpp

#ifndef RAYLIB_CPP_INCLUDE_TEXTUREUNMANAGED_HPP_
#define RAYLIB_CPP_INCLUDE_TEXTUREUNMANAGED_HPP_
 
#include <string>
#include <string_view>
 
#include "./Image.hpp"
#include "./Material.hpp"
#include "./RaylibException.hpp"
#include "./Image.hpp"
#include "./RadiansDegrees.hpp"
 
namespace raylib {
class TextureUnmanaged : public ::Texture {
public:
    TextureUnmanaged() : ::Texture{0, 0, 0, 0, 0} {
        // Nothing.
    }
 
    TextureUnmanaged(
        unsigned int id,
        int width,
        int height,
        int mipmaps = 1,
        int format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8)
        : ::Texture{id, width, height, mipmaps, format} {
        // Nothing.
    }
 
    TextureUnmanaged(const ::Texture& texture)
        : ::Texture{texture.id, texture.width, texture.height, texture.mipmaps, texture.format} {
        // Nothing.
    }
 
    TextureUnmanaged(const ::Image& image) { Load(image); }
 
    TextureUnmanaged(const ::Image& image, int layout) { Load(image, layout); }
 
    TextureUnmanaged(const std::string_view fileName) {
        Load(fileName);
    }
 
    TextureUnmanaged(::Texture&& other) : ::Texture{other.id, other.width, other.height, other.mipmaps, other.format} {
        // Nothing.
    }
 
    GETTER(unsigned int, Id, id)
    GETTER(int, Width, width)
    GETTER(int, Height, height)
    GETTER(int, Mipmaps, mipmaps)
    GETTER(int, Format, format)
 
    TextureUnmanaged& operator=(const ::Texture& texture) {
        set(texture);
        return *this;
    }
 
    Vector2 GetSize() const {
        return {static_cast<float>(width), static_cast<float>(height)};
    }
 
    void Load(const ::Image& image) {
        set(::LoadTextureFromImage(image));
        if (!IsValid()) {
            throw RaylibException("Failed to load Texture from Image");
        }
    }
 
    void Load(const ::Image& image, int layoutType) {
        set(::LoadTextureCubemap(image, layoutType));
        if (!IsValid()) {
            throw RaylibException("Failed to load Texture from Cubemap");
        }
    }
 
    void Load(const std::string_view fileName) {
        set(::LoadTexture(fileName.data()));
        if (!IsValid()) {
            throw RaylibException("Failed to load Texture from file: " + std::string(fileName));
        }
    }
 
    void Unload() {
        // Protect against calling UnloadTexture() twice.
        if (id != 0) {
            ::UnloadTexture(*this);
            id = 0;
        }
    }
 
    TextureUnmanaged& Update(const void* pixels) {
        ::UpdateTexture(*this, pixels);
        return *this;
    }
 
    TextureUnmanaged& Update(::Rectangle rec, const void* pixels) {
        UpdateTextureRec(*this, rec, pixels);
        return *this;
    }
 
    Image GetData() const {
        return ::LoadImageFromTexture(*this);
    }
 
    operator Image() { return GetData(); }
 
    TextureUnmanaged& GenMipmaps() {
        ::GenTextureMipmaps(this);
        return *this;
    }
 
    TextureUnmanaged& SetFilter(int filterMode) {
        ::SetTextureFilter(*this, filterMode);
        return *this;
    }
 
    TextureUnmanaged& SetWrap(int wrapMode) {
        ::SetTextureWrap(*this, wrapMode);
        return *this;
    }
 
    void Draw(int posX = 0, int posY = 0, ::Color tint = {255, 255, 255, 255}) const {
        ::DrawTexture(*this, posX, posY, tint);
    }
 
    void Draw(::Vector2 position, ::Color tint = {255, 255, 255, 255}) const { ::DrawTextureV(*this, position, tint); }
 
    void Draw(::Vector2 position, Degree rotation, float scale = 1.0f,
            ::Color tint = {255, 255, 255, 255}) const {
        ::DrawTextureEx(*this, position, rotation, scale, tint);
    }
 
    void Draw(::Rectangle sourceRec, ::Vector2 position = {0, 0}, ::Color tint = {255, 255, 255, 255}) const {
        ::DrawTextureRec(*this, sourceRec, position, tint);
    }
 
    void Draw(::Rectangle sourceRec, ::Rectangle destRec, ::Vector2 origin = {0, 0},
            Degree rotation = 0, ::Color tint = {255, 255, 255, 255}) const {
        ::DrawTexturePro(*this, sourceRec, destRec, origin, rotation, tint);
    }
 
    void Draw(::NPatchInfo nPatchInfo, ::Rectangle destRec, ::Vector2 origin = {0, 0},
            Radian rotation = 0, ::Color tint = {255, 255, 255, 255}) const {
        ::DrawTextureNPatch(*this, nPatchInfo, destRec, origin, rotation, tint);
    }
 
    void
    DrawBillboard(const ::Camera& camera, ::Vector3 position, float size, ::Color tint = {255, 255, 255, 255}) const {
        ::DrawBillboard(camera, *this, position, size, tint);
    }
 
    void DrawBillboard(
        const ::Camera& camera,
        ::Rectangle source,
        ::Vector3 position,
        ::Vector2 size,
        ::Color tint = {255, 255, 255, 255}) const {
        DrawBillboardRec(camera, *this, source, position, size, tint);
    }
 
    void DrawBillboard(const ::Camera& camera,
            ::Rectangle source, Vector3 position,
            ::Vector3 up, Vector2 size, Vector2 origin, Degree rotation = 0.0f,
            ::Color tint = {255, 255, 255, 255}) const {
        DrawBillboardPro(camera, *this, source, position, up, size, origin, rotation, tint);
    }
 
    TextureUnmanaged& SetMaterial(::Material* material, int mapType = MATERIAL_MAP_NORMAL) {
        ::SetMaterialTexture(material, mapType, *this);
        return *this;
    }
 
    TextureUnmanaged& SetMaterial(const ::Material& material, int mapType = MATERIAL_MAP_NORMAL) {
        ::SetMaterialTexture(const_cast<::Material*>(&material), mapType, *this);
        return *this;
    }
 
    TextureUnmanaged& SetShapes(const ::Rectangle& source) {
        ::SetShapesTexture(*this, source);
        return *this;
    }
 
    TextureUnmanaged& SetShaderValue(const ::Shader& shader, int locIndex) {
        ::SetShaderValueTexture(shader, locIndex, *this);
        return *this;
    }
 
    [[nodiscard]] bool IsValid() const { return IsTextureValid(*this); }
protected:
    void set(const ::Texture& texture) {
        id = texture.id;
        width = texture.width;
        height = texture.height;
        mipmaps = texture.mipmaps;
        format = texture.format;
    }
};
 
// Create the TextureUnmanaged aliases.
using Texture2DUnmanaged = TextureUnmanaged;
using TextureCubemapUnmanaged = TextureUnmanaged;
 
} // namespace raylib
 
using RTextureUnmanaged = raylib::TextureUnmanaged;
using RTexture2DUnmanaged = raylib::Texture2DUnmanaged;
using RTextureCubemapUnmanaged = raylib::TextureCubemapUnmanaged;
 
#endif // RAYLIB_CPP_INCLUDE_TEXTUREUNMANAGED_HPP_