CUSpriteShader.h

//
//  CUSpriteShader.h
//  Cornell University Game Library (CUGL)
//
//  This module provides the default shader for a sprite batch.  You may replace
//  the shader code, but all shaders must support the attributes and uniforms
//  listed below.
//
//  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 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_SPRITE_SHADER_H__
#define __CU_SPRITE_SHADER_H__
 
#include <cugl/renderer/CUShader.h>
#include <cugl/renderer/CUTexture.h>
#include <cugl/math/CUMat4.h>
 
namespace cugl {
 
class SpriteShader : public Shader {
#pragma mark Values
private:
    GLint _aPosition;
    GLint _aColor;
    GLint _aTexCoord;
    GLint _uPerspective;
    GLint _uTexture;
 
    Mat4  _mPerspective;
    
    std::shared_ptr<Texture> _mTexture;
    
#pragma mark -
#pragma mark Constructors
public:
    SpriteShader() : Shader(), _aPosition(-1), _aColor(-1), _aTexCoord(-1),
                               _uPerspective(-1), _uTexture(-1) { }
 
    ~SpriteShader() { dispose(); }
 
    void dispose() override;
 
    bool init();
    
    bool init(std::string vsource, std::string fsource) {
        return init(vsource.c_str(),fsource.c_str());
    }
 
    bool init(const char* vsource, const char* fsource);
 
#pragma mark -
#pragma mark Static Constructors
 
    static std::shared_ptr<SpriteShader> alloc() {
        std::shared_ptr<SpriteShader> result = std::make_shared<SpriteShader>();
        return (result->init() ? result : nullptr);
    }
    
    static std::shared_ptr<SpriteShader> alloc(std::string vsource, std::string fsource) {
        std::shared_ptr<SpriteShader> result = std::make_shared<SpriteShader>();
        return (result->init(vsource, fsource) ? result : nullptr);
    }
    
    static std::shared_ptr<SpriteShader> alloc(const char* vsource, const char* fsource) {
        std::shared_ptr<SpriteShader> result = std::make_shared<SpriteShader>();
        return (result->init(vsource, fsource) ? result : nullptr);
    }
    
#pragma mark -
#pragma mark Attributes
 
    GLint getPositionAttr() const { return _aPosition; }
 
    GLint getColorAttr() const { return _aColor; }
 
    GLint getTexCoodAttr() const { return _aTexCoord; }
    
    GLint getPerspectiveUni() const { return _uPerspective; }
 
    GLint getTextureUni() const { return _uTexture; }
    
    void setPerspective(const Mat4&  matrix);
 
    const Mat4& getPerspective() { return _mPerspective; }
 
    void setTexture(const std::shared_ptr<Texture>& texture);
    
    std::shared_ptr<Texture> getTexture() { return _mTexture; }
 
    const std::shared_ptr<Texture>& getTexture() const { return _mTexture; }
 
#pragma mark -
#pragma mark Rendering
 
    void attach(GLuint vArray, GLuint vBuffer);
 
    void bind() override;
    
    void unbind() override;
 
#pragma mark -
#pragma mark Compilation
protected:
    bool compile() override;
 
    bool validateVariable(GLint variable, const char* name);
 
};
 
}
 
#endif /* __CU_SPRITE_SHADER_H__ */