CUTexture.h

//
//  CUTexture.hpp
//  CUGL
//
//  Created by Walker White on 6/24/16.
//  Copyright © 2016 Game Design Initiative at Cornell. All rights reserved.
//

#ifndef _CU_TEXTURE_H__
#define _CU_TEXTURE_H__

#include <cugl/math/CUMathBase.h>
#include <cugl/math/CUSize.h>

namespace cugl {

class Texture : public std::enable_shared_from_this<Texture> {
#pragma mark Values
public:
    enum class PixelFormat : GLenum {
        RGBA = GL_RGBA,
        RGB  = GL_RGBA,
        RED  = GL_RED,
        ALPHA = GL_ALPHA,
        UNDEFINED = GL_RG
    };
    
private:
    GLuint _buffer;

    unsigned int _width;
    
    unsigned int _height;

    PixelFormat _pixelFormat;

    std::string _name;
    
    GLuint _minFilter;

    GLuint _magFilter;
    
    GLuint _wrapS;

    GLuint _wrapT;

    bool _hasMipmaps;


    std::shared_ptr<Texture> _parent;
    
    GLfloat _minS;

    GLfloat _maxS;
    
    GLfloat _minT;

    GLfloat _maxT;

    bool _active;
    
#pragma mark -
#pragma mark Constructors
public:
    Texture();
    
    ~Texture() { dispose(); }
    
    void dispose();

    bool init(int width, int height, PixelFormat format = PixelFormat::RGBA);

    bool initWithData(const void *data, int width, int height,
                      PixelFormat format = PixelFormat::RGBA);
    
    bool initWithFile(const std::string& filename);

#pragma mark -
#pragma mark Static Constructors

    static std::shared_ptr<Texture> alloc(int width, int height,
                                          PixelFormat format = PixelFormat::RGBA) {
        std::shared_ptr<Texture> result = std::make_shared<Texture>();
        return (result->init(width, height, (cugl::Texture::PixelFormat)format) ? result : nullptr);
    }

    static std::shared_ptr<Texture> allocWithData(const void *data, int width, int height,
                                                  PixelFormat format = PixelFormat::RGBA) {
        std::shared_ptr<Texture> result = std::make_shared<Texture>();
        return (result->initWithData(data, width, height, (cugl::Texture::PixelFormat)format) ? result : nullptr);

    }
   
    
    static std::shared_ptr<Texture> allocWithFile(const std::string& filename) {
        std::shared_ptr<Texture> result = std::make_shared<Texture>();
        return (result->initWithFile(filename) ? result : nullptr);
    }

#pragma mark -
#pragma mark Setters

    const Texture& operator=(const void *data) {
        return set(data);
    }

    const Texture& set(const void *data);

#pragma mark -
#pragma mark Attributes

    bool isReady() const { return _buffer != 0; }

    bool isActive() const   {
        return (_parent != nullptr ? _parent->isActive() : _active);
    }
    
    bool hasMipMaps() const {
        return (_parent != nullptr ? _parent->hasMipMaps() : _hasMipmaps);
    }

    void buildMipMaps();
    
    GLuint getBuffer() { return _buffer; }
    
    void setName(std::string name) { _name = name; }
    
    const std::string& getName() const { return _name; }
    
    unsigned int getWidth()  const { return _width;  }
    
    unsigned int getHeight() const { return _height; }
    
    Size getSize() { return Size((float)_width,(float)_height); }
    
    PixelFormat getFormat() const { return _pixelFormat; }
    
    GLuint getMinFilter() const {
        return (_parent != nullptr ? _parent->getMinFilter() : _minFilter);
    }

    GLuint getMagFilter() const {
        return (_parent != nullptr ? _parent->getMagFilter() : _magFilter);
    }

    void setMinFilter(GLuint minFilter);
    
    void setMagFilter(GLuint magFilter);

    GLuint getWrapS() const {
        return (_parent != nullptr ? _parent->getWrapS() : _wrapS);
    }

    GLuint getWrapT() const {
        return (_parent != nullptr ? _parent->getWrapT() : _wrapT);
    }

    void setWrapS(GLuint wrap);

    void setWrapT(GLuint wrap);

    
#pragma mark -
#pragma mark Atlas Support

    const std::shared_ptr<Texture>& getParent() const { return _parent; }

    std::shared_ptr<Texture> getParent() { return _parent; }
    
    std::shared_ptr<Texture> getSubTexture(GLfloat minS, GLfloat maxS, GLfloat minT, GLfloat maxT);
    
    bool isSubTexture() const { return _parent != nullptr; }

    GLfloat getMinS() const { return _minS; }

    GLfloat getMinT() const { return _minT; }

    GLfloat getMaxS() const { return _maxS; }

    GLfloat getMaxT() const { return _maxT; }

// TODO:: Ninepatch support
    
#pragma mark -
#pragma mark Rendering

    void bind();
    
    void unbind();
    
#pragma mark -
#pragma mark Conversions

    std::string toString(bool verbose = false) const;
    
    operator std::string() const { return toString(); }

};

}

#endif /* _CU_TEXTURE_H__ */