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

#pragma once
#ifndef ATTRIBUTE_H
#define ATTRIBUTE_H

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

#include <string>

UNISHADER_BEGIN

class ShaderProgram;


class UniShader_API Attribute : public SignalSender, public SignalReceiver, public ObjectBase{
public:
        Attribute(ShaderProgram& program, std::string name);
        typedef SafePtr<Attribute> Ptr; 
        typedef SafePtr<const Attribute> PtrConst; 
        virtual const std::string& getClassName() const; 
        ~Attribute();


        class ReadingMode{
        public:
                enum myEnum{NONE, 
                                        CHAR, 
                                        UNSIGNED_CHAR, 
                                        SHORT, 
                                        UNSIGNED_SHORT, 
                                        INT, 
                                        UNSIGNED_INT, 
                                        FLOAT, 
                                        DOUBLE 
                };
        private:
                myEnum m_en;
        public:
                ReadingMode(){}
                ReadingMode(const ReadingMode& ref):m_en(ref.m_en){}
                ReadingMode(myEnum en){ m_en = en; }
                ReadingMode& operator =(myEnum en){ m_en = en; return *this; }
                operator myEnum(){ return m_en; }
        };


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


        void connectBuffer(BufferBase::Ptr buffer, unsigned int offset = 0, unsigned int stride = 0);


        void disconnectBuffer();


        void normalize(bool norm);


        unsigned int getBufferOffset() const;


        unsigned int getBufferStride() const;


        const GLSLType& getGLSLType() const;


        ReadingMode getReadingMode() const;


        std::string getName() const;
        

        void setBufferOffset(unsigned int offset);


        void setBufferStride(unsigned int stride);


        void setReadingMode(ReadingMode readingMode);
        

        bool prepare();


        void apply();


        virtual bool handleSignal(unsigned int signalID, const ObjectBase* callerPtr);
private:
        ShaderProgram& m_program;
        BufferBase::Ptr m_buffer;
        GLSLType m_type;
        std::string m_name;
        int m_location;
        unsigned int m_offset;
        unsigned int m_stride;
        ReadingMode m_readingMode;
        bool m_normalize;
        bool m_prepared;
};

UNISHADER_END

#endif