Texture.h

Go to the documentation of this file.

#pragma once
 
#pragma warning(disable:4250)
 
#include "../Geometry/Size.h"
#include "../Geometry/Bounds.h"
#include "../GL.h"
#include "../Graphics.h"
#include "../Containers/Image.h"
#include "Drawables.h"
 
namespace Gorgon { namespace Graphics {
 
    class Texture : public virtual TextureSource {
    public:
 
        Texture() {
            Set(0, ColorMode::Invalid, {0, 0});
        }
 
        Texture(GL::Texture id, ColorMode mode, const Geometry::Size &size) {
            Set(id, mode, size);
        }
 
        Texture(GL::Texture id, ColorMode mode, const Geometry::Size &size, const Geometry::Bounds &location) {
            Set(id, mode, size, location);
        }
 
        Texture(const Containers::Image &image) : Texture(GL::GenerateTexture(image), image.GetMode(), image.GetSize()) {
            owner=true;
        }
 
        Texture(Texture &other) : id(other.id), size(other.size), owner(false) {
            memcpy(coordinates, other.coordinates, sizeof(coordinates));
        }
 
        Texture(Texture &&other) : id(other.id), mode(other.mode), size(other.size), owner(other.owner) {
            memcpy(coordinates, other.coordinates, sizeof(coordinates));
            other.owner=false;
        }
 
        void Swap(Texture &other) {
            using std::swap;
 
            swap(id, other.id);
            swap(size, other.size);
            swap(mode, other.mode);
            swap(coordinates, other.coordinates);
            swap(owner, other.owner);
        }
 
        virtual ~Texture() {
            Destroy();
        }
 
        void Set(const Containers::Image &image) {
            Destroy();
 
            id=GL::GenerateTexture(image);
            size=image.GetSize();
            mode = image.GetMode();
            owner=true;
 
            memcpy(coordinates, fullcoordinates, sizeof(fullcoordinates));
        }
 
        void Set(GL::Texture id) {
            if(owner) {
                GL::DestroyTexture(id);
            }
            
            owner = false;
            this->id=id;
        }
 
        void Set(GL::Texture id, ColorMode mode, const Geometry::Size &size) {
            Destroy();
 
            this->id=id;
            this->size=size;
            this->mode=mode;
 
            memcpy(coordinates, fullcoordinates, sizeof(fullcoordinates));
        }
 
        void Set(GL::Texture id, ColorMode mode, const Geometry::Size &size, const Geometry::Bounds &location) {
            Destroy();
 
            this->id=id;
            this->size=location.GetSize();
            this->mode=mode;
 
            coordinates[0] ={float(location.Left)/size.Width, float(location.Top)/size.Height};
            coordinates[1] ={float(location.Right)/size.Width, float(location.Top)/size.Height};
            coordinates[2] ={float(location.Right)/size.Width, float(location.Bottom)/size.Height};
            coordinates[3] ={float(location.Left)/size.Width, float(location.Bottom)/size.Height};
        }
        
 
        void Assume(GL::Texture id, ColorMode mode, const Geometry::Size &size) {
            Set(id, mode, size);
            
            owner = true;
        }
 
        void Assume(GL::Texture id, ColorMode mode, const Geometry::Size &size, const Geometry::Bounds &location) {
            Set(id, mode, size, location);
            
            owner = true;
        }
        
        void CreateEmpty(const Geometry::Size &size, ColorMode mode) {
            id = GL::GenerateEmptyTexture(size, mode);
            this->size = size;
            this->mode = mode;
            
            owner = true;
        }
 
        virtual GL::Texture GetID() const override final {
            return id;
        }
 
        virtual Geometry::Size GetImageSize() const override final {
            return size;
        }
 
        virtual const Geometry::Pointf *GetCoordinates() const override final {
            return coordinates;
        }
        
        ColorMode GetMode() const override {
            return mode;
        }
 
        void Destroy() {
            if(owner) {
                GL::DestroyTexture(id);
            }
            id=0;
            owner=false;
            size={0, 0};
        }
 
        GL::Texture Release() {
            auto id=this->id;
            this->id=0;
            owner=false;
            size={0, 0};
 
            return id;
        }
 
    protected:
 
        GL::Texture id = 0;
 
        Geometry::Size size ={0, 0};
        
        ColorMode mode;
 
        bool owner = false;
 
        Geometry::Pointf coordinates[4];
    };
 
 
    class TextureImage : public virtual Texture, public virtual Image {
    public:
        TextureImage() { }
 
        TextureImage(TextureImage &other) : Texture(other) {
        }
 
        TextureImage(TextureImage &&other) {
            id=other.id;
            size=other.size;
            owner=other.owner;
            mode=other.mode;
            memcpy(coordinates, other.coordinates, sizeof(coordinates));
            other.owner=false;
            other.id = 0;
        }
 
        TextureImage(GL::Texture id, ColorMode mode, const Geometry::Size &size) : Texture(id, mode, size) {
        }
 
        TextureImage(GL::Texture id, ColorMode mode, const Geometry::Size &size, const Geometry::Bounds &location) : Texture(id, mode, size, location) {
        }
 
        TextureImage(const Containers::Image &image) : Texture(image) {
        }
 
    };
    
    
    class TextureProvider : public virtual TextureImage, public virtual ImageProvider {
    public:
        TextureProvider() { }
        
        TextureProvider(TextureProvider &other) : Texture(other) {
        }
        
        TextureProvider(TextureProvider &&other) : Texture(std::move(other)) {
        }
        
        TextureProvider(GL::Texture id, ColorMode mode, const Geometry::Size &size) : Texture(id, mode, size) {
        }
        
        TextureProvider(GL::Texture id, ColorMode mode, const Geometry::Size &size, const Geometry::Bounds &location) : Texture(id, mode, size, location) {
        }
        
        TextureProvider(const Containers::Image &image) : Texture(image) {
        }
        
        //types are derived not to type the same code for every class
        virtual auto MoveOutProvider() -> decltype(*this) override {
            auto ret = new std::remove_reference<decltype(*this)>::type(std::move(*this));
            
            return *ret;
        }
        
        virtual Geometry::Size GetSize() const override {
            auto diff = coordinates[2] - coordinates[0];
            
            return {int(diff.X * size.Width + 0.9999), int(diff.Y * size.Height + 0.9999)};
        }
        
    protected:
        Geometry::Size getsize() const override {
            return GetSize();
        }
    };
 
} }