CUTexture.h

//
//  CUTexture.h
//  Cornell University Game Library (CUGL)
//
//  This module provides the class for representing a 2D OpenGL texture. This
//  class also provides support for texture atlases.  Any non-repeating texture
//  can produce a subtexture.  A subtexture wraps the same texture data (and so
//  does not require a context switch in the rendering pipeline), but has
//  different start and end boundaries, as defined by minS, maxS, minT and maxT
//
//  CUGL MIT License:
//      This software is provided 'as-is', without any express or implied
//      warranty.  In no event will the authors be held liable for any damages
//      arising from the use of this software.
//
//      Permission is granted to anyone to use this software for any purpose,
//      including commercial applications, and to alter it and redistribute it
//      freely, subject to the following restrictions:
//
//      1. The origin of this software must not be misrepresented; you must not
//      claim that you wrote the original software. If you use this software
//      in a product, an acknowledgment in the product documentation would be
//      appreciated but is not required.
//
//      2. Altered source versions must be plainly marked as such, and must not
//      be misrepresented as being the original software.
//
//      3. This notice may not be removed or altered from any source distribution.
//
//  Author: Walker White
//  Version: 6/23/16

#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__ */