D:/SoftwareEntwicklung/C++/HLC/Tools/SoftPixelEngine/repository/sources/RenderSystem/spShaderClass.hpp

Go to the documentation of this file.

/*
 * Shader class header
 * 
 * This file is part of the "SoftPixel Engine" (Copyright (c) 2008 by Lukas Hermanns)
 * See "SoftPixelEngine.hpp" for license information.
 */

#ifndef __SP_SHADER_CLASS_H__
#define __SP_SHADER_CLASS_H__


#include "Base/spStandard.hpp"
#include "Base/spInputOutput.hpp"
#include "Base/spBaseObject.hpp"
#include "RenderSystem/spShaderConfigTypes.hpp"
#include "RenderSystem/spComputeShader.hpp"


namespace sp
{

namespace scene { class MaterialNode; }

namespace video
{


class ConstantBuffer;

enum EBuildShaderFlags
{
    SHADERBUILD_CG          = 0x0002,
    SHADERBUILD_GLSL        = 0x0004,
    SHADERBUILD_HLSL3       = 0x0008,
    SHADERBUILD_HLSL5       = 0x0010,
    
    SHADERBUILD_VERTEX      = 0x0100,
    SHADERBUILD_PIXEL       = 0x0200,
    SHADERBUILD_GEOMETRY    = 0x0400,
    SHADERBUILD_HULL        = 0x0800,
    SHADERBUILD_DOMAIN      = 0x1000,
};


class Shader;
class VertexFormat;

class SP_EXPORT ShaderClass : public BaseObject
{
    
    public:
        
        virtual ~ShaderClass();
        
        /* === Functions === */
        
        virtual void bind(const scene::MaterialNode* Object = 0) = 0;
        
        virtual void unbind() = 0;
        
        virtual bool link() = 0;
        
        /* === Static functions === */
        
        static EShaderVersions getShaderVersion(s32 Flags);
        
        static bool build(
            const io::stringc &Name,
            
            ShaderClass* &ShdClass,
            VertexFormat* VertFmt,
            
            const std::list<io::stringc>* ShdBufferVertex,
            const std::list<io::stringc>* ShdBufferPixel,
            
            const io::stringc &VertexMain = "VertexMain",
            const io::stringc &PixelMain = "PixelMain",
            
            s32 Flags = SHADERBUILD_CG
        );
        
        /* === Inline functions === */
        
        inline void setObjectCallback(const ShaderObjectCallback &CallbackProc)
        {
            ObjectCallback_ = CallbackProc;
        }
        
        inline void setSurfaceCallback(const ShaderSurfaceCallback &CallbackProc)
        {
            SurfaceCallback_ = CallbackProc;
        }
        
        inline Shader* getVertexShader() const
        {
            return VertexShader_;
        }
        inline Shader* getPixelShader() const
        {
            return PixelShader_;
        }
        inline Shader* getGeometryShader() const
        {
            return GeometryShader_;
        }
        inline Shader* getHullShader() const
        {
            return HullShader_;
        }
        inline Shader* getDomainShader() const
        {
            return DomainShader_;
        }
        inline Shader* getComputeShader() const
        {
            return ComputeShader_;
        }
        
        inline const std::vector<ConstantBuffer*>& getConstantBufferList() const
        {
            return ConstBufferList_;
        }

        inline bool isHighLevel() const
        {
            return HighLevel_;
        }
        inline bool valid() const
        {
            return CompiledSuccessfully_;
        }
        
    protected:
        
        friend class Shader;
        
        ShaderClass();
        
        /* === Functions === */
        
        void printError(const io::stringc &Message);
        void printWarning(const io::stringc &Message);
        
        /* === Members === */
        
        ShaderObjectCallback ObjectCallback_;
        ShaderSurfaceCallback SurfaceCallback_;
        
        Shader* VertexShader_;
        Shader* PixelShader_;
        Shader* GeometryShader_;
        Shader* HullShader_;
        Shader* DomainShader_;
        Shader* ComputeShader_;
        
        std::vector<ConstantBuffer*> ConstBufferList_;

        bool HighLevel_;
        bool CompiledSuccessfully_;
        
};


} // /namespace scene

} // /namespace sp


#endif



// ================================================================================