shader.h

Go to the documentation of this file.

#ifndef GLW_SHADER_H
#define GLW_SHADER_H

#include <string>
#include <iostream>

#include "./object.h"

namespace glw
{

class ShaderArguments : public ObjectArguments
{
        public:

                typedef ObjectArguments BaseType;
                typedef ShaderArguments ThisType;

                std::string source;

                ShaderArguments(void)
                        : BaseType()
                {
                        ;
                }

                void clear(void)
                {
                        BaseType::clear();
                        this->source.clear();
                }
};

class Shader : public Object
{
        friend class Context;

        public:

                typedef Object BaseType;
                typedef Shader ThisType;

                virtual ~Shader(void)
                {
                        this->destroy();
                }

                const std::string & source(void) const
                {
                        return this->m_source;
                }

                const std::string & log(void) const
                {
                        return this->m_log;
                }

                bool isCompiled(void) const
                {
                        return this->m_compiled;
                }

        protected:

                std::string  m_source;
                std::string  m_log;
                bool         m_compiled;

                Shader(Context * ctx)
                        : BaseType   (ctx)
                        , m_compiled (false)
                {
                        ;
                }

                virtual GLenum shaderType(void) const = 0;

                bool create(const ShaderArguments & args)
                {
                        this->destroy();
                        const GLenum shType = this->shaderType();
                        this->m_name = glCreateShader(shType);
                        this->compile(args.source);
                        return this->m_compiled;
                }

                virtual void doDestroy(void)
                {
                        glDeleteShader(this->m_name);
                        this->m_source.clear();
                        this->m_log.clear();
                        this->m_compiled = false;
                }

                virtual bool doIsValid(void) const
                {
                        return this->m_compiled;
                }

                void compile(const std::string & source)
                {
                        const char * src = source.c_str();
                        glShaderSource(this->m_name, 1, &src, 0);
                        glCompileShader(this->m_name);

                        GLint compileStatus = 0;
                        glGetShaderiv(this->m_name, GL_COMPILE_STATUS, &compileStatus);

                        this->m_source   = source;
                        this->m_log      = ThisType::getInfoLog(this->m_name);
                        this->m_compiled = (compileStatus != GL_FALSE);

#if GLW_PRINT_LOG_TO_STDERR
                        std::cerr << "---------------------------" << std::endl;
                        std::cerr << "[";
                        switch (this->shaderType())
                        {
                                case GL_VERTEX_SHADER   : std::cerr << "Vertex ";   break;
                                case GL_GEOMETRY_SHADER : std::cerr << "Geometry "; break;
                                case GL_FRAGMENT_SHADER : std::cerr << "Fragment "; break;
                                default: break;
                        }
                        std::cerr << "Shader Compile Log]: " << ((this->m_compiled) ? ("OK") : ("FAILED")) << std::endl;
                        std::cerr << this->m_log << std::endl;
                        std::cerr << "---------------------------" << std::endl;
#endif
                }

        private:

                static std::string getInfoLog(GLuint Shader)
                {
                        std::string log;

                        GLint logLen = 0;
                        glGetShaderiv(Shader, GL_INFO_LOG_LENGTH, &logLen);
                        if (logLen > 0)
                        {
                                char * sLog = new char[logLen + 1];
                                glGetShaderInfoLog(Shader, logLen, &logLen, sLog);
                                if (logLen > 0)
                                {
                                        if (sLog[0] != '\0')
                                        {
                                                sLog[logLen - 1] = '\0';
                                                log = sLog;
                                        }
                                }
                                delete [] sLog;
                        }
                        return log;
                }
};

namespace detail { template <> struct BaseOf <Shader> { typedef Object Type; }; };
typedef   detail::ObjectSharedPointerTraits  <Shader> ::Type ShaderPtr;

class SafeShader : public SafeObject
{
        friend class Context;
        friend class BoundShader;

        public:

                typedef SafeObject BaseType;
                typedef SafeShader ThisType;

                SafeShader(void)
                        : BaseType()
                {
                        ;
                }

                const std::string & source(void) const
                {
                        return this->object()->source();
                }

                const std::string & log(void) const
                {
                        return this->object()->log();
                }

                bool isCompiled(void) const
                {
                        return this->object()->isCompiled();
                }

        protected:

                SafeShader(const ShaderPtr & shader)
                        : BaseType(shader)
                {
                        ;
                }

                const ShaderPtr & object(void) const
                {
                        return static_cast<const ShaderPtr &>(BaseType::object());
                }

                ShaderPtr & object(void)
                {
                        return static_cast<ShaderPtr &>(BaseType::object());
                }
};

namespace detail { template <> struct BaseOf     <SafeShader> { typedef SafeObject Type; }; };
namespace detail { template <> struct ObjectBase <SafeShader> { typedef Shader     Type; }; };
namespace detail { template <> struct ObjectSafe <Shader    > { typedef SafeShader Type; }; };
typedef   detail::ObjectSharedPointerTraits      <SafeShader> ::Type ShaderHandle;

class ShaderBindingParams : public ObjectBindingParams
{
        public:

                typedef ObjectBindingParams BaseType;
                typedef ShaderBindingParams ThisType;

                ShaderBindingParams(void)
                        : BaseType()
                {
                        ;
                }

                ShaderBindingParams(GLenum aTarget, GLenum aUnit)
                        : BaseType(aTarget, aUnit)
                {
                        ;
                }
};

class BoundShader : public BoundObject
{
        friend class Context;

        public:

                typedef BoundObject BaseType;
                typedef BoundShader ThisType;

                BoundShader(void)
                        : BaseType()
                {
                        ;
                }

                const ShaderHandle & handle(void) const
                {
                        return static_cast<const ShaderHandle &>(BaseType::handle());
                }

                ShaderHandle & handle(void)
                {
                        return static_cast<ShaderHandle &>(BaseType::handle());
                }

        protected:

                BoundShader(const ShaderHandle & handle, const ShaderBindingParams & params)
                        : BaseType(handle, params)
                {
                        ;
                }

                const ShaderPtr & object(void) const
                {
                        return this->handle()->object();
                }

                ShaderPtr & object(void)
                {
                        return this->handle()->object();
                }

                virtual void bind(void)
                {
                        ;
                }

                virtual void unbind(void)
                {
                        ;
                }
};

namespace detail { template <> struct ParamsOf    <BoundShader> { typedef ShaderBindingParams Type; }; };
namespace detail { template <> struct BaseOf      <BoundShader> { typedef BoundObject Type; }; };
namespace detail { template <> struct ObjectBase  <BoundShader> { typedef Shader      Type; }; };
namespace detail { template <> struct ObjectBound <Shader     > { typedef BoundShader Type; }; };
typedef   detail::ObjectSharedPointerTraits       <BoundShader> ::Type  BoundShaderHandle;

};

#endif // GLW_SHADER_H