CUShader.h

//
//  CUShader.h
//  Cornell University Game Library (CUGL)
//
//  This module provides the abstract base class for our shader classes.
//  It supports compilations and has diagnostic tools for errors.  It is not
//  useful for rendering, because there is no way to get the data there.
//
//  Because it is abstract, it has only a basic constructor.  It has no
//  initializers or allocator.
//
//  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_SHADER_H__
#define __CU_SHADER_H__

#include "../math/CUMathBase.h"
#include <string>

// A stringification trick to define shaders easily
// Note the version lockdown for non-OpenGLES systems
#if CU_GL_PLATFORM == CU_GL_OPENGLES
    #define SHADER(A) "#version 300 es\n" #A
#else
    #define SHADER(A) "#version 140\n" #A
#endif

namespace cugl {

class Shader {
#pragma mark Values
protected:
    GLuint _program;
    GLuint _vertShader;
    GLuint _fragShader;
    const char* _vertSource;
    const char* _fragSource;
    bool _active;
    
#pragma mark -
#pragma mark Constructors
public:
    Shader() :_program(0), _vertShader(0), _fragShader(0),
            _vertSource(nullptr), _fragSource(nullptr),
            _active(false) {};

    ~Shader() { dispose(); }

    virtual void dispose();

#pragma mark -
#pragma mark Attributes

    std::string getVertSource() const {
        return (_vertSource ? std::string(_vertSource) : "");
    }
    
    std::string getFragSource() const {
        return (_fragSource ? std::string(_fragSource) : "");
    }

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

    bool isActive() const { return _active; }
    
    GLuint getProgram() const { return _program; }

#pragma mark -
#pragma mark Rendering

    virtual void bind();
    
    virtual void unbind();

#pragma mark -
#pragma mark Compilation
protected:
    virtual bool compile();
    
    static bool validateShader(GLuint shader, const char* type);

    static void logShaderError(GLuint shader);

    static void logProgramError(GLuint shader);
};
    
}

#endif /* __CU_SHADER_H__ */