E:/Programming/MyProject/K_Game_hg/GameEngine/include/render/Shader.h

Go to the documentation of this file.

// Copyright 2006-2011 by Kat'Oun

#ifndef _SHADER_H_
#define _SHADER_H_

#include <EngineConfig.h>
#include <core/Types.h>
#include <resource/Resource.h>
#include <render/ShaderDefines.h>
#include <render/ShaderParamData.h>
#include <render/TextureDefines.h>
#include <render/Color.h>
#include <core/Vector2d.h>
#include <core/Vector3d.h>
#include <core/Vector4d.h>
#include <core/Matrix4.h>

#include <string>
#include <vector>
#include <map>

namespace resource
{
class Serializer;
}

namespace render
{

class Light;
class Texture;

struct ENGINE_PUBLIC_EXPORT ShaderParameter
{
        ShaderParameter();

        ShaderParameterType paramType;                  // Param type
        ShaderAutoParameterType autoParamType;  // Auto Param type
        u32 index;                                                              // Start index in buffer (either float, int or texture buffer)
        u32 elemCount;                                                  // Number of elements
};

class ENGINE_PUBLIC_EXPORT Shader: public resource::Resource
{
public:

        Shader(const std::string& name, resource::Serializer* serializer);
        virtual ~Shader();

        void setShaderType(const ShaderType& type);

        ShaderType getShaderType();

        void setSource(const std::string& source);

        void setEntryPoint(const std::string& entry);

        virtual void bind();

        virtual void unbind();

        virtual void updateAutoParameters(ShaderParamData& data);

        virtual void setParamerter(const std::string& name, const Color& col);
        virtual void setParamerter(const std::string& name, const core::vector2d& vec);
        virtual void setParamerter(const std::string& name, const core::vector3d& vec);
        virtual void setParamerter(const std::string& name, const core::vector4d& vec);
        virtual void setParamerter(const std::string& name, const core::matrix4& m);
        virtual void setParamerter(const std::string& name, const f32* val, u32 count);
        virtual void setParamerter(const std::string& name, const s32* val, u32 count);

        virtual void addParamerter(const std::string& name, ShaderParameterType type);

        void setAutoParamerter(const std::string& name, ShaderAutoParameterType type);

protected:

        void initProperties();
        
        virtual bool loadImpl();
        virtual void unloadImpl();

        ShaderType mShaderType;

        std::string mSource;            // The assembler source of the program (may be blank until file loaded)
        std::string mEntryPoint;        // Entry point eg. main_vp, main_fp etc

        ShaderParameter* createParameter(const std::string& name, ShaderParameterType type, u32 index, u32 elemCount);
        virtual ShaderParameter* createParameterImpl(const std::string& name);

        ShaderParameter* findParameter(const std::string& name);
        void writedParameterData(u32 index, const f32* val, u32 count);
        void writedParameterData(u32 index, const s32* val, u32 count);

        f32* getFloatPrameterData(u32 index);
        const f32* getFloatPrameterData(u32 index) const;

        s32* getIntPrameterData(u32 index);
        const s32* getIntPrameterData(u32 index) const;

        void removeAllParameters();

        static bool isFloat(ShaderParameterType type);
        static bool isFloat(ShaderAutoParameterType type);
        static bool isSampler(ShaderParameterType type);
        static u32 getElementCount(ShaderParameterType type);
        static u32 getElementCount(ShaderAutoParameterType type);
        static ShaderParameterType getType(ShaderAutoParameterType type);
        static ShaderParameterType getType(TextureType type);

        std::vector<f32> mFloatParameterData;
        std::vector<s32> mIntParameterData;
        hashmap<std::string, ShaderParameter*> mParameters;
};

} // end namespace render

#endif