CUSpriteBatch.h

//
//  CUSpriteBatch.h
//  Cornell University Game Library (CUGL)
//
//  This module provides one-stop shopping for basic 2d graphics.  Despite the
//  name, it is also capable of drawing solid shapes, as well as wireframes.
//  The only time you might want a separate class is when you need another
//  shader.  And even then, you can swap out the shader for this class.
//
//  This class uses our standard shared-pointer architecture.
//
//  1. The constructor does not perform any initialization; it just sets all
//     attributes to their defaults.
//
//  2. All initialization takes place via init methods, which can fail if an
//     object is initialized more than once.
//
//  3. All allocation takes place via static constructors which return a shared
//     pointer.
//
//  CUGL zlib 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_SPRITE_BATCH_H__
#define __CU_SPRITE_BATCH_H__

#include <SDL/SDL.h>
#include <cugl/math/CUMathBase.h>
#include <cugl/math/CUMat4.h>
#include <cugl/renderer/CUVertex.h>
#include <vector>

#define DEFAULT_CAPACITY 8192

namespace cugl {

class SpriteShader;
class Affine2;
class Texture;
class Rect;
class Poly2;
    
class SpriteBatch {
#pragma mark Values
private:
    std::shared_ptr<SpriteShader> _shader;
    unsigned int _capacity;
    
    GLuint _vertArray;
    GLuint _vertBuffer;
    GLuint _indxBuffer;
    
    Vertex2* _vertData;
    GLuint*  _indxData;
    
    unsigned int _vertMax;
    unsigned int _vertSize;

    unsigned int _indxMax;
    unsigned int _indxSize;

    std::shared_ptr<Texture> _texture;
    Color4 _color;
    GLenum _command;
    Mat4 _perspective;
    
    GLenum _blendEquation;
    GLenum _srcFactor;
    GLenum _dstFactor;
    
    unsigned int _vertTotal;
    unsigned int _callTotal;
    
    bool _initialized;
    bool _active;

    static std::shared_ptr<Texture> _blank;

    
#pragma mark -
#pragma mark Constructors
public:
    SpriteBatch();
    
    ~SpriteBatch() { dispose(); }

    void dispose();
    
    bool init();
    
    bool init(std::shared_ptr<SpriteShader> shader) {
        return init(DEFAULT_CAPACITY,shader);
    }
    
    bool init(unsigned int capacity);
    
    bool init(unsigned int capacity, std::shared_ptr<SpriteShader> shader);
    
#pragma mark -
#pragma mark Static Constructors

    static std::shared_ptr<SpriteBatch> alloc() {
        std::shared_ptr<SpriteBatch> result = std::make_shared<SpriteBatch>();
        return (result->init() ? result : nullptr);
    }
    
    static std::shared_ptr<SpriteBatch> alloc(unsigned int capacity) {
        std::shared_ptr<SpriteBatch> result = std::make_shared<SpriteBatch>();
        return (result->init(capacity) ? result : nullptr);
    }
    
#pragma mark -
#pragma mark Attributes

    bool isReady() const { return _initialized; }
    
    bool isDrawing() const { return _active; }

    unsigned int getVerticesDrawn() const { return _vertTotal; }

    unsigned int getCallsMade() const { return _callTotal; }

    void setShader(const std::shared_ptr<SpriteShader>& shader);
    
    const std::shared_ptr<SpriteShader>& getShader() const { return _shader; }
    
    void setColor(Color4 color) { _color = color; }

    Color4 getColor() const { return _color; }
    
    void setTexture(const std::shared_ptr<Texture>& texture);

    const std::shared_ptr<Texture>& getTexture() const { return _texture; }
    
    static const std::shared_ptr<Texture>& getBlankTexture();

    // TODO: Orthographic support from query
    void setPerspective(const Mat4& perspective);
    
    const Mat4& getPerspective() const { return _perspective; }
    
    void setBlendFunc(GLenum srcFactor, GLenum dstFactor);
    
    GLenum getSourceBlendFactor() const { return _srcFactor; }

    GLenum getDestinationBlendFactor() const { return _srcFactor; }
    
    void setBlendEquation(GLenum equation);

    GLenum getBlendEquation() const { return _blendEquation; }
    
#pragma mark -
#pragma mark Rendering

    void begin();
    
    void begin(const Mat4& perspective) {
        setPerspective(perspective); begin();
    }
    
    void end();
    
    void flush();

#pragma mark -
#pragma mark Solid Shapes

    void fill(const Rect& rect);
    
    void fill(const Rect& rect, const Vec2& origin, const Vec2& scale, float angle, const Vec2& offset);
    
    void fill(const Rect& rect, const Vec2& origin, const Mat4& transform);
    
    void fill(const Rect& rect, const Vec2& origin, const Affine2& transform);

    void fill(const Poly2& poly);

    void fill(const Poly2& poly, const Vec2& offset);
    
    void fill(const Poly2& poly, const Vec2& origin, const Vec2& scale, float angle, const Vec2& offset);

    void fill(const Poly2& poly, const Vec2& origin, const Mat4& transform);
    
    void fill(const Poly2& poly, const Vec2& origin, const Affine2& transform);

    void fill(const std::vector<Vertex2>& vertices, const std::vector<unsigned short>& indices,
              const Mat4& transform, bool tint = true) {
        fill(vertices.data(),(unsigned int)vertices.size(),0,indices.data(),(unsigned int)indices.size(),0,transform,tint);
    }

    void fill(const std::vector<Vertex2>& vertices, const std::vector<unsigned short>& indices,
              const Affine2& transform, bool tint = true) {
        fill(vertices.data(),(unsigned int)vertices.size(),0,indices.data(),(unsigned int)indices.size(),0,transform,tint);
    }

    void fill(const Vertex2* vertices, unsigned int vsize, unsigned int voffset,
              const unsigned short* indices, unsigned int isize, unsigned int ioffset,
              const Mat4& transform, bool tint = true);

    void fill(const Vertex2* vertices, unsigned int vsize, unsigned int voffset,
              const unsigned short* indices, unsigned int isize, unsigned int ioffset,
              const Affine2& transform, bool tint = true);

#pragma mark -
#pragma mark Outlines

    void outline(const Rect& rect);
 
    void outline(const Rect& rect, const Vec2& origin, const Vec2& scale, float angle, const Vec2& offset);
    
    void outline(const Rect& rect, const Vec2& origin, const Mat4& transform);
    
    void outline(const Rect& rect, const Vec2& origin, const Affine2& transform);
    
    void outline(const Poly2& poly);
    
    void outline(const Poly2& poly, const Vec2& offset);
    
    void outline(const Poly2& poly, const Vec2& origin, const Vec2& scale, float angle, const Vec2& offset);
    
    void outline(const Poly2& poly, const Vec2& origin, const Mat4& transform);
    
    void outline(const Poly2& poly, const Vec2& origin, const Affine2& transform);
    
    void outline(const std::vector<Vertex2>& vertices, const std::vector<unsigned short>& indices,
                 const Mat4& transform, bool tint = true) {
        outline(vertices.data(),(unsigned int)vertices.size(),0,indices.data(),(unsigned int)indices.size(),0,transform,tint);
    }
    
    void outline(const std::vector<Vertex2>& vertices, const std::vector<unsigned short>& indices,
                 const Affine2& transform, bool tint = true) {
        outline(vertices.data(),(unsigned int)vertices.size(),0,indices.data(),(unsigned int)indices.size(),0,transform,tint);
    }
    
    void outline(const Vertex2* vertices, unsigned int vsize, unsigned int voffset,
                 const unsigned short* indices, unsigned int isize, unsigned int ioffset,
                 const Mat4& transform, bool tint = true);
    
    void outline(const Vertex2* vertices, unsigned int vsize, unsigned int voffset,
                 const unsigned short* indices, unsigned int isize, unsigned int ioffset,
                 const Affine2& transform, bool tint = true);
    
#pragma mark -
#pragma mark Convenience Methods

    void draw(const std::shared_ptr<Texture>& texture, const Vec2& position);
    
    void draw(const std::shared_ptr<Texture>& texture, Color4 color, const Vec2& position);
    
    void draw(const std::shared_ptr<Texture>& texture, const Rect& bounds) {
        setTexture(texture); setColor(Color4::WHITE);
        fill(bounds);
    }

    void draw(const std::shared_ptr<Texture>& texture, Color4 color, const Rect& bounds) {
        setTexture(texture); setColor(color);
        fill(bounds);
    }

    void draw(const std::shared_ptr<Texture>& texture,
              const Vec2& origin, const Vec2& scale, float angle, const Vec2& offset);
    
    void draw(const std::shared_ptr<Texture>& texture, Color4 color,
              const Vec2& origin, const Vec2& scale, float angle, const Vec2& offset);
    
    void draw(const std::shared_ptr<Texture>& texture, const Rect& bounds,
              const Vec2& origin, const Vec2& scale, float angle, const Vec2& offset) {
        setTexture(texture); setColor(Color4::WHITE);
        fill(bounds, origin, scale, angle, offset);
    }

    void draw(const std::shared_ptr<Texture>& texture, Color4 color, const Rect& bounds,
              const Vec2& origin, const Vec2& scale, float angle, const Vec2& offset) {
        setTexture(texture); setColor(color);
        fill(bounds, origin, scale, angle, offset);
    }

    void draw(const std::shared_ptr<Texture>& texture, const Vec2& origin, const Mat4& transform);
    
    void draw(const std::shared_ptr<Texture>& texture, Color4 color, const Vec2& origin, const Mat4& transform);
    
    void draw(const std::shared_ptr<Texture>& texture, const Rect& bounds,
              const Vec2& origin, const Mat4& transform) {
        setTexture(texture); setColor(Color4::WHITE);
        fill(bounds, origin, transform);
    }

    void draw(const std::shared_ptr<Texture>& texture, Color4 color, const Rect& bounds,
              const Vec2& origin, const Mat4& transform) {
        setTexture(texture); setColor(color);
        fill(bounds, origin, transform);
    }

    void draw(const std::shared_ptr<Texture>& texture, const Vec2& origin, const Affine2& transform);
    
    void draw(const std::shared_ptr<Texture>& texture, Color4 color,
              const Vec2& origin, const Affine2& transform);
    
    void draw(const std::shared_ptr<Texture>& texture, const Rect& bounds,
              const Vec2& origin, const Affine2& transform) {
        setTexture(texture); setColor(Color4::WHITE);
        fill(bounds, origin, transform);
    }
    
    void draw(const std::shared_ptr<Texture>& texture, Color4 color, const Rect& bounds,
              const Vec2& origin, const Affine2& transform) {
        setTexture(texture); setColor(color);
        fill(bounds, origin, transform);
    }

    void draw(const std::shared_ptr<Texture>& texture, const Poly2& poly, const Vec2& offset) {
        setTexture(texture); setColor(Color4::WHITE);
        fill(poly, offset);
    }

    void draw(const std::shared_ptr<Texture>& texture, Color4 color, const Poly2& poly, const Vec2& offset) {
        setTexture(texture); setColor(color);
        fill(poly, offset);
    }
    
    void draw(const std::shared_ptr<Texture>& texture, const Poly2& poly,
              const Vec2& origin, const Vec2& scale, float angle, const Vec2& offset) {
        setTexture(texture); setColor(Color4::WHITE);
        fill(poly, origin, scale, angle, offset);
    }

    void draw(const std::shared_ptr<Texture>& texture, Color4 color, const Poly2& poly,
              const Vec2& origin, const Vec2& scale, float angle, const Vec2& offset) {
        setTexture(texture); setColor(color);
        fill(poly, origin, scale, angle, offset);
    }

    void draw(const std::shared_ptr<Texture>& texture, const Poly2& poly,
              const Vec2& origin, const Mat4& transform) {
        setTexture(texture); setColor(Color4::WHITE);
        fill(poly, origin, transform);
    }
    
    void draw(const std::shared_ptr<Texture>& texture, Color4 color, const Poly2& poly,
              const Vec2& origin, const Mat4& transform) {
        setTexture(texture); setColor(color);
        fill(poly, origin, transform);
    }

    void draw(const std::shared_ptr<Texture>& texture, const Poly2& poly,
              const Vec2& origin, const Affine2& transform) {
        setTexture(texture); setColor(Color4::WHITE);
        fill(poly, origin, transform);
    }
    
    void draw(const std::shared_ptr<Texture>& texture, Color4 color, const Poly2& poly,
              const Vec2& origin, const Affine2& transform) {
        setTexture(texture); setColor(color);
        fill(poly, origin, transform);
    }

#pragma mark -
#pragma mark Internal Helpers
private:
    void setCommand(GLenum command);
    
    GLenum getCommand() const { return _command; }
    
    bool validateBuffer(GLuint buffer, const char* message);
    
    unsigned int prepare(const Rect& rect,  bool solid);

    unsigned int prepare(const Poly2& poly, bool solid);

    unsigned int prepare(const Vertex2* vertices, unsigned int vsize, unsigned int voffset,
                         const unsigned short* indices, unsigned int isize, unsigned int ioffset,
                         bool solid, bool tint = true);

};

}

#endif /* __CU_SPRITE_BATCH_H__ */