D:/Visual Studio 2010/Projects/Unishader project/Unishader/include/UniShader/ShaderObject.h

#pragma once
#ifndef SHADER_OBJECT_H
#define SHADER_OBJECT_H

#include <UniShader/Config.h>
#include <UniShader/Utility.h>
#include <UniShader/ObjectBase.h>
#include <UniShader/Signal.h>

#include <memory>
#include <string>

UNISHADER_BEGIN


class UniShader_API ShaderObject : public SignalSender, public ObjectBase{
private:
        ShaderObject();

public:
        typedef std::shared_ptr<ShaderObject> Ptr; 
        typedef std::shared_ptr<const ShaderObject> PtrConst; 
        virtual const std::string& getClassName() const; 
        ~ShaderObject();

        class Type{
        public:
                enum myEnum{NONE, 
                                        VERTEX, 
                                        GEOMETRY, 
                                        FRAGMENT, 
                                        UNRECOGNIZED 
                };
        private:
                myEnum m_en;
        public:
                Type(){}
                Type(const Type& ref):m_en(ref.m_en){}
                Type(myEnum en){ m_en = en; }
                Type& operator =(myEnum en){ m_en = en; return *this; }
                operator myEnum(){ return m_en; }
        };

        class CompilationStatus{
        public:
                enum myEnum{PENDING_COMPILATION, 
                                        SUCCESSFUL_COMPILATION, 
                                        FAILED_COMPILATION 
                };
        private:
                myEnum m_en;
        public:
                CompilationStatus(){}
                CompilationStatus(const CompilationStatus& ref):m_en(ref.m_en){}
                CompilationStatus(myEnum en){ m_en = en; }
                CompilationStatus& operator =(myEnum en){ m_en = en; return *this; }
                operator myEnum(){ return m_en; }
        };
        

        class SignalID{
        public:
                enum Types{     CHANGED, 
                                        RECOMPILED 
                }; 
        };


        static Ptr create();


        bool loadFile(const std::string fileName, Type shaderType = Type::NONE);


        bool loadCode(const std::string code, Type shaderType);

        /*
                Compile shader object if needed.
                \return True if shader object is successfully compiled.
        */
        bool ensureCompilation();
        

        unsigned int getGlID() const;


        Type getType() const;


        CompilationStatus getCompilationStatus() const;

private:
        bool compile();
        bool printShaderInfoLog() const;
        int getShaderSize(const std::string &shaderName) const;
        bool readShaderSource(const std::string& fileName, std::string& shaderText);
        bool translateLiterals(std::string &shaderText);

        unsigned int m_shaderObjectID;
        Type m_type;
        CompilationStatus m_compilationStatus;
};

UNISHADER_END

#endif