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

Go to the documentation of this file.

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

#ifndef __SP_RENDERSYSTEM_H__
#define __SP_RENDERSYSTEM_H__


#include "Base/spStandard.hpp"
#include "Base/spMaterialStates.hpp"
#include "Base/spImageManagement.hpp"
#include "Base/spTransformation2D.hpp"
#include "Base/spMathSpline.hpp"
#include "Base/spVertexFormatList.hpp"
#include "Base/spIndexFormat.hpp"
#include "Base/spInputOutput.hpp"
#include "Base/spDimension.hpp"
#include "Base/spGeometryStructures.hpp"
#include "Base/spMaterialColor.hpp"
#include "FileFormats/Image/spImageFileFormats.hpp"
#include "RenderSystem/spShaderProgram.hpp"
#include "RenderSystem/spTextureBase.hpp"
#include "RenderSystem/spRenderSystemMovie.hpp"
#include "RenderSystem/spRenderSystemFont.hpp"

#include <map>
#include <boost/shared_ptr.hpp>


namespace sp
{

class SoftPixelDevice;

#if defined(SP_PLATFORM_WINDOWS)
class SoftPixelDeviceWin32;
#endif

#if defined(SP_PLATFORM_LINUX)
class SoftPixelDeviceLinux;
#endif

namespace scene
{

class Camera;
class Mesh;
class MaterialNode;
class SceneGraph;

} // /namespace scene

namespace video
{


class TextureLayer;
class RenderContext;


class SP_EXPORT RenderSystem
{
    
    public:
        
        virtual ~RenderSystem();
        
        /* === Initialization functions === */
        
        virtual void setupConfiguration() = 0;
        
        /* === Renderer information === */
        
        static io::stringc getVendorNameByID(const u32 VendorID);
        
        virtual io::stringc getRenderer()       const = 0;  
        virtual io::stringc getVersion()        const = 0;  
        virtual io::stringc getVendor()         const = 0;  
        virtual io::stringc getShaderVersion()  const = 0;  
        
        virtual bool queryVideoSupport(const EVideoFeatureQueries Query) const = 0; 
        
        virtual bool queryExtensionSupport(const io::stringc &TargetExtension) const;
        
        virtual s32 getMultitexCount()          const = 0;  
        virtual s32 getMaxAnisotropicFilter()   const = 0;  
        virtual s32 getMaxLightCount()          const = 0;  
        
        virtual dim::EMatrixCoordinateSystmes getProjectionMatrixType() const;
        
        virtual void printWarning();
        
        /* === Video buffer control functions === */
        
        virtual void clearBuffers(const s32 ClearFlags = BUFFER_COLOR | BUFFER_DEPTH) = 0;
        
        /* === Configuration functions === */
        
        virtual void setShadeMode(const EShadeModeTypes ShadeMode);
        
        virtual void setFrontFace(bool isFrontFace);
        
        virtual void setClearColor(const color &Color);
        
        virtual void setColorMask(bool isRed, bool isGreen, bool isBlue, bool isAlpha = true);
        
        virtual void setDepthMask(bool Enable);
        
        virtual void setAntiAlias(bool isAntiAlias);
        
        virtual void setDepthRange(f32 Near, f32 Far);
        virtual void getDepthRange(f32 &Near, f32 &Far) const;
        
        virtual void setDepthClip(bool Enable);
        
        /* === Stencil buffer === */
        
        virtual void setStencilMask(u32 BitMask);
        
        virtual void setStencilMethod(const ESizeComparisionTypes Method, s32 Reference = 0, u32 BitMask = ~0);
        
        virtual void setStencilOperation(const EStencilOperations FailOp, const EStencilOperations ZFailOp, const EStencilOperations ZPassOp);
        
        virtual void setClearStencil(s32 Stencil);
        
        /* === Rendering functions === */
        
        virtual bool setupMaterialStates(const MaterialStates* Material, bool Forced = false) = 0;
        
        virtual void setupTextureLayer(
            u8 LayerIndex, const dim::matrix4f &TexMatrix, const ETextureEnvTypes EnvType,
            const EMappingGenTypes GenType, s32 MappingCoordsFlags
        );
        
        virtual void bindTextureLayers(const TextureLayerListType &TexLayers);
        virtual void unbindTextureLayers(const TextureLayerListType &TexLayers);
        
        virtual void setupShaderClass(const scene::MaterialNode* Object, ShaderClass* ShaderObject);
        
        virtual void updateMaterialStates(MaterialStates* Material, bool isClear = false);
        
        virtual void updateLight(
            u32 LightID, const scene::ELightModels LightType, bool isVolumetric,
            const dim::vector3df &Direction, f32 SpotInnerConeAngle, f32 SpotOuterConeAngle,
            f32 AttenuationConstant, f32 AttenuationLinear, f32 AttenuationQuadratic
        );
        
        /* === Hardware mesh buffers === */
        
        virtual void createVertexBuffer(void* &BufferID) = 0;
        virtual void createIndexBuffer(void* &BufferID) = 0;
        
        virtual void deleteVertexBuffer(void* &BufferID) = 0;
        virtual void deleteIndexBuffer(void* &BufferID) = 0;
        
        virtual void updateVertexBuffer(
            void* BufferID, const dim::UniversalBuffer &BufferData, const VertexFormat* Format, const EHWBufferUsage Usage
        ) = 0;
        virtual void updateIndexBuffer(
            void* BufferID, const dim::UniversalBuffer &BufferData, const IndexFormat* Format, const EHWBufferUsage Usage
        ) = 0;
        
        virtual void updateVertexBufferElement(void* BufferID, const dim::UniversalBuffer &BufferData, u32 Index) = 0;
        virtual void updateIndexBufferElement(void* BufferID, const dim::UniversalBuffer &BufferData, u32 Index) = 0;
        
        virtual void drawMeshBuffer(const MeshBuffer* MeshBuffer) = 0;
        
        virtual void drawMeshBufferPlain(const MeshBuffer* MeshBuffer, bool useFirstTextureLayer = false);
        
        /* === Render states === */
        
        virtual void setRenderMode(const ERenderModes Mode);
        
        virtual void setRenderState(const ERenderStates Type, s32 State) = 0;
        virtual s32 getRenderState(const ERenderStates Type) const = 0;
        
        /* === Lighting === */
        
        virtual void addDynamicLightSource(
            u32 LightID, scene::ELightModels Type,
            video::color &Diffuse, video::color &Ambient, video::color &Specular,
            f32 AttenuationConstant, f32 AttenuationLinear, f32 AttenuationQuadratic
        );
        
        virtual void setLightStatus(u32 LightID, bool Enable, bool UseAllRCs = false);
        
        virtual void setLightColor(
            u32 LightID,
            const video::color &Diffuse, const video::color &Ambient, const video::color &Specular,
            bool UseAllRCs = false
        );
        
        /* === Fog effect === */
        
        virtual void setFog(const EFogTypes Type);
        virtual EFogTypes getFog() const;
        
        virtual void setFogColor(const video::color &Color);
        virtual video::color getFogColor() const;
        
        virtual void setFogRange(f32 Range, f32 NearPlane = 1.0f, f32 FarPlane = 1000.0f, const EFogModes Mode = FOG_PALE);
        virtual void getFogRange(f32 &Range, f32 &NearPlane, f32 &FarPlane, EFogModes &Mode);
        
        /* === Clipping planes === */
        
        virtual void setClipPlane(u32 Index, const dim::plane3df &Plane, bool Enable);
        
        /* === Shader programs === */
        
        virtual ShaderClass* createShaderClass(VertexFormat* VertexInputLayout = 0);
        virtual void deleteShaderClass(ShaderClass* ShaderClassObj, bool DeleteAppendantShaders = false);
        
        virtual Shader* loadShader(
            ShaderClass* ShaderClassObj, const EShaderTypes Type, const EShaderVersions Version,
            const io::stringc &Filename, const io::stringc &EntryPoint = "", s32 Flags = 0,
            const std::list<io::stringc> &PreShaderCode = std::list<io::stringc>()
        );
        
        virtual Shader* createShader(
            ShaderClass* ShaderClassObj, const EShaderTypes Type, const EShaderVersions Version,
            const std::list<io::stringc> &ShaderBuffer, const io::stringc &EntryPoint = ""
        );
        
        virtual ShaderClass* loadShaderClass(
            const io::stringc &FilenameVertex, const io::stringc &FilenamePixel,
            const EShaderVersions VersionVertex, const EShaderVersions VersionPixel,
            const io::stringc &EntryPointVertex = "", const io::stringc &EntryPointPixel = ""
        );
        
        virtual ShaderClass* createCgShaderClass(VertexFormat* VertexInputLayout = 0);
        
        virtual Shader* createCgShader(
            ShaderClass* ShaderClassObj, const EShaderTypes Type, const EShaderVersions Version,
            const std::list<io::stringc> &ShaderBuffer, const io::stringc &EntryPoint = "",
            const c8** CompilerOptions = 0
        );
        
        virtual void deleteShader(Shader* ShaderObj);
        
        virtual void unbindShaders();
        
        virtual bool runComputeShader(
            Shader* ShaderObj, ComputeShaderIO* IOInterface, const dim::vector3di &GroupSize
        );
        
        virtual ComputeShaderIO* createComputeShaderIO();
        virtual void deleteComputeShaderIO(ComputeShaderIO* &IOInterface);
        
        /* === Simple drawing functions === */
        
        virtual void beginSceneRendering();
        virtual void endSceneRendering();
        
        virtual void beginDrawing2D();
        virtual void endDrawing2D();
        
        virtual void beginDrawing3D();
        virtual void endDrawing3D();
        
        virtual void setBlending(const EBlendingTypes SourceBlend, const EBlendingTypes DestBlend);
        
        virtual void setClipping(bool Enable, const dim::point2di &Position, const dim::size2di &Size);
        
        virtual void setViewport(const dim::point2di &Position, const dim::size2di &Size);
        
        virtual bool setRenderTarget(Texture* Target);
        virtual Texture* getRenderTarget() const;
        
        virtual void setLineSize(s32 Size = 1);
        
        virtual void setPointSize(s32 Size = 1);
        
        /* === Image drawing === */
        
        virtual void draw2DImage(
            const Texture* Tex, const dim::point2di &Position, const color &Color = color(255)
        );
        
        virtual void draw2DImage(
            const Texture* Tex, const dim::rect2di &Position,
            const dim::rect2df &Clipping = dim::rect2df(0.0f, 0.0f, 1.0f, 1.0f),
            const color &Color = color(255)
        );
        
        virtual void draw2DImage(
            const Texture* Tex, const dim::point2di &Position, f32 Rotation, f32 Radius, const color &Color = color(255)
        );
        
        virtual void draw2DImage(
            const Texture* Tex,
            dim::rect2di Position,
            const dim::rect2df &Clipping,
            f32 Rotation,
            const dim::point2df &RotationPoint = dim::point2df(0.5f, 0.5f),
            const color &lefttopColor = color(255),
            const color &righttopColor = color(255),
            const color &rightbottomColor = color(255),
            const color &leftbottomColor = color(255)
        );
        
        virtual void draw2DImage(
            const Texture* Tex,
            const dim::point2di &lefttopPosition,
            const dim::point2di &righttopPosition,
            const dim::point2di &rightbottomPosition,
            const dim::point2di &leftbottomPosition,
            const dim::point2df &lefttopClipping = dim::point2df(0.0f, 0.0f),
            const dim::point2df &righttopClipping = dim::point2df(1.0f, 0.0f),
            const dim::point2df &rightbottomClipping = dim::point2df(1.0f, 1.0f),
            const dim::point2df &leftbottomClipping = dim::point2df(0.0f, 1.0f),
            const color &lefttopColor = color(255),
            const color &righttopColor = color(255),
            const color &rightbottomColor = color(255),
            const color &leftbottomColor = color(255)
        );
        
        /* === Primitive drawing === */
        
        virtual color getPixelColor(const dim::point2di &Position) const;
        
        virtual f32 getPixelDepth(const dim::point2di &Position) const;
        
        virtual void draw2DPoint(const dim::point2di &Position, const color &Color = color(255));
        
        virtual void draw2DLine(
            const dim::point2di &PositionA, const dim::point2di &PositionB, const color &Color = color(255)
        );
        
        virtual void draw2DLine(
            const dim::point2di &PositionA, const dim::point2di &PositionB, const color &ColorA, const color &ColorB
        );
        
        virtual void draw2DRectangle(
            const dim::rect2di &Rect, const color &Color = 255, bool isSolid = true
        );
        
        virtual void draw2DRectangle(
            const dim::rect2di &Rect, const color &lefttopColor, const color &righttopColor,
            const color &rightbottomColor, const color &leftbottomColor, bool isSolid = true
        );
        
        virtual void draw2DBox(
            const dim::point2di &Position, const dim::size2di &Size, const color &Color = 255, bool isSolid = true
        );
        
        virtual void draw2DCircle(const dim::point2di &Position, s32 Radius, const color &Color = 255);
        
        virtual void draw2DEllipse(
            const dim::point2di &Position, const dim::size2di &Radius, const color &Color = 255
        );
        
        /* === Extra drawing functions === */
        
        virtual void draw2DPolygon(
            const ERenderPrimitives Type, const scene::SPrimitiveVertex2D* VerticesList, u32 Count
        );
        virtual void draw2DPolygonImage(
            const ERenderPrimitives Type, Texture* Tex, const scene::SPrimitiveVertex2D* VerticesList, u32 Count
        );
        
        /* === 3D drawing functions === */
        
        virtual void draw3DPoint(
            const dim::vector3df &Position, const color &Color = 255
        );
        virtual void draw3DLine(
            const dim::vector3df &PositionA, const dim::vector3df &PositionB, const color &Color = 255
        );
        virtual void draw3DLine(
            const dim::vector3df &PositionA, const dim::vector3df &PositionB, const color &ColorA, const color &ColorB
        );
        virtual void draw3DEllipse(
            const dim::vector3df &Position, const dim::vector3df &Rotation = 0.0f,
            const dim::size2df &Radius = 0.5f, const color &Color = 255
        );
        virtual void draw3DTriangle(
            Texture* Tex, const dim::triangle3df &Triangle, const color &Color = 255
        );
        
        virtual void draw3DBox(
            const dim::aabbox3df &BoundBox, const dim::matrix4f &Transformation, const color &Color = color(255)
        );
        
        virtual void draw3DBox(const dim::obbox3df &BoundBox, const color &Color = color(255));
        
        /* === Texture loading and creating === */
        
        void setTextureGenFlags(const ETextureGenFlags Flag, const s32 Value);
        
        EImageFileFormats getImageFileFormat(io::File* TexFile) const;
        EImageFileFormats getImageFileFormat(const io::stringc &Filename) const;
        
        virtual Texture* loadTexture(const io::stringc &Filename);
        
        virtual Texture* loadTexture(ImageLoader* Loader);
        
        virtual Texture* getTexture(const io::stringc &Filename);
        
        virtual std::list<Texture*> loadTextureList(const io::stringc &Filename);
        
        bool saveTexture(const Texture* Tex, io::stringc Filename, const EImageFileFormats FileFormat = IMAGEFORMAT_BMP);
        
        void deleteTexture(Texture* &Tex);
        
        virtual bool isTexture(const Texture* Tex) const;
        
        virtual Texture* copyTexture(const Texture* Tex);
        
        virtual Texture* createTexture(
            const dim::size2di &Size, const EPixelFormats Format = PIXELFORMAT_RGB, const u8* ImageBuffer = 0
        );
        
        virtual Texture* createTexture(
            const dim::size2di &Size, const EPixelFormats Format, const f32* ImageBuffer
        );
        
        virtual Texture* createTexture(const STextureCreationFlags &CreationFlags) = 0;
        
        virtual Texture* createCubeMap(const dim::size2di &Size, bool isRenderTarget = true);
        
        virtual Texture* createScreenShot(const dim::point2di &Position = 0, dim::size2di Size = 0);
        
        virtual void createScreenShot(Texture* Tex, const dim::point2di &Position = 0);
        
        virtual void setFillColor(const video::color &Color);
        
        virtual void clearTextureList();
        virtual void reloadTextureList();
        
        Texture* createTextureFromDeviceBitmap(void* BitmapDC, void* Bitmap);
        
        void deleteVertexFormat(VertexFormat* Format);
        
        /* === Movie loading === */
        
        Movie* loadMovie(const io::stringc &Filename, s32 Resolution = 256);
        void deleteMovie(Movie* &MovieObject);
        
        /* === Font loading and text drawing === */
        
        virtual Font* createFont(const io::stringc &FontName = "", s32 FontSize = 0, s32 Flags = 0);
        
        virtual Font* createTexturedFont(const io::stringc &FontName = "", s32 FontSize = 0, s32 Flags = 0);
        virtual Font* createBitmapFont(const io::stringc &FontName = "", s32 FontSize = 0, s32 Flags = 0);
        
        virtual Font* createFont(video::Texture* FontTexture);
        virtual Font* createFont(video::Texture* FontTexture, const io::stringc &FontXMLFile);
        virtual Font* createFont(video::Texture* FontTexture, const std::vector<SFontGlyph> &GlyphList, s32 FontHeight);
        
        virtual Texture* createFontTexture(
            std::vector<SFontGlyph> &GlyphList, const io::stringc &FontName = "", s32 FontSize = 0, s32 Flags = 0
        );
        
        virtual void deleteFont(Font* FontObj);
        
        virtual void draw2DText(
            const Font* FontObject, const dim::point2di &Position, const io::stringc &Text,
            const color &Color = color(255), s32 Flags = 0
        );
        
        virtual void draw3DText(
            const Font* FontObject, const dim::matrix4f &Transformation, const io::stringc &Text, const color &Color = color(255)
        );
        
        /* === Matrix controll === */
        
        /* Update the render matrix (with the SoftPixel-modelview matrix) */
        virtual void updateModelviewMatrix() = 0;
        
        virtual void matrixWorldViewReset();
        
        virtual void setProjectionMatrix(const dim::matrix4f &Matrix);
        virtual void setViewMatrix      (const dim::matrix4f &Matrix);
        virtual void setWorldMatrix     (const dim::matrix4f &Matrix);
        virtual void setTextureMatrix   (const dim::matrix4f &Matrix, u8 TextureLayer = 0);
        virtual void setColorMatrix     (const dim::matrix4f &Matrix);
        
        virtual dim::matrix4f getProjectionMatrix() const;
        virtual dim::matrix4f getViewMatrix      () const;
        virtual dim::matrix4f getWorldMatrix     () const;
        virtual dim::matrix4f getTextureMatrix   (u8 TextureLayer = 0) const;
        virtual dim::matrix4f getColorMatrix     () const;
        
        /* === Static functions === */
        
        static u32 queryDrawCalls();
        static u32 queryMeshBufferBindings();
        static u32 queryTextureLayerBindings();
        
        static u32 queryMaterialUpdates();
        
        /* === Inline functions === */
        
        inline ERenderSystems getRendererType() const
        {
            return RendererType_;
        }
        
        #if defined(SP_PLATFORM_WINDOWS)
        inline HDC getDeviceContext() const
        {
            return DeviceContext_;
        }
        #endif
        
        inline bool getDepthClip() const
        {
            return DepthRange_.Enabled;
        }
        
        inline const std::list<Shader*>& getShaderList() const
        {
            return ShaderList_;
        }
        inline const std::list<ShaderClass*>& getShaderClassList() const
        {
            return ShaderClassList_;
        }
        inline const std::list<ComputeShaderIO*>& getComputeShaderIOList() const
        {
            return ComputeShaderIOList_;
        }
        
        inline void setSurfaceCallback(const ShaderSurfaceCallback &CallbackProc)
        {
            ShaderSurfaceCallback_ = CallbackProc;
        }
        
        inline void setGlobalShaderClass(ShaderClass* GlobalShaderClass)
        {
            GlobalShaderClass_ = GlobalShaderClass;
        }
        inline ShaderClass* getGlobalShaderClass() const
        {
            return GlobalShaderClass_;
        }
        
        inline void setTextureGenFlags(const STextureCreationFlags &Flags)
        {
            TexGenFlags_ = Flags;
        }
        inline STextureCreationFlags getTextureGenFlags() const
        {
            return TexGenFlags_;
        }
        
        inline std::list<Texture*> getTextureList() const
        {
            return TextureList_;
        }
        
        inline void setFontTransformation(const dim::matrix4f &Transform)
        {
            FontTransform_ = Transform;
        }
        inline dim::matrix4f getFontTransformation() const
        {
            return FontTransform_;
        }
        
        inline void setTexLayerVisibleMask(s32 VisibleMask)
        {
            TexLayerVisibleMask_ = VisibleMask;
        }
        inline s32 getTexLayerVisibleMask() const
        {
            return TexLayerVisibleMask_;
        }
        
        inline void setClipping(bool Enable)
        {
            setClipping(Enable, 0, 0);
        }
        
        inline void setupDefaultBlending()
        {
            setBlending(BLEND_SRCALPHA, BLEND_INVSRCALPHA);
        }
        
        inline ERenderModes getRenderMode() const
        {
            return RenderMode_;
        }
        
        template <class T> T* createVertexFormat()
        {
            T* NewFormat = new T();
            VertexFormatList_.push_back(NewFormat);
            return NewFormat;
        }
        
        inline VertexFormatDefault* getVertexFormatDefault() const
        {
            return VertexFormatDefault_;
        }
        inline VertexFormatReduced* getVertexFormatReduced() const
        {
            return VertexFormatReduced_;
        }
        inline VertexFormatExtended* getVertexFormatExtended() const
        {
            return VertexFormatExtended_;
        }
        inline VertexFormatFull* getVertexFormatFull() const
        {
            return VertexFormatFull_;
        }
        
        inline const MaterialStates* getMaterialDrawing2D() const
        {
            return Material2DDrawing_;
        }
        inline const MaterialStates* getMaterialDrawing3D() const
        {
            return Material3DDrawing_;
        }
        
        inline const std::list<VertexFormat*>& getVertexFormatList() const
        {
            return VertexFormatList_;
        }
        
        inline const video::Texture* getDefaultTexture(const EDefaultTextures Type)
        {
            return Type < DEFAULT_TEXTURE_COUNT ? DefaultTextures_[Type] : 0;
        }
        
    protected:
        
        /* === Friends === */
        
        friend class Font;
        friend class GLTextureBase;
        friend class OpenGLTexture;
        friend class OpenGLES1Texture;
        friend class GLFramebufferObject;
        friend class sp::SoftPixelDevice;
        friend class VertexFormat;
        friend class VertexFormatUniversal;
        friend class Texture;
        friend class TextureLayer;
        friend class MeshBuffer;
        friend class SoftPixelDevice;
        
        #if defined(SP_PLATFORM_WINDOWS)
        friend class sp::SoftPixelDeviceWin32;
        #endif
        
        #if defined(SP_PLATFORM_LINUX)
        friend class sp::SoftPixelDeviceLinux;
        #endif
        
        #if defined(SP_PLATFORM_ANDROID)
        friend class sp::SoftPixelDeviceAndroid;
        #endif
        
        /* === Enumerations === */
        
        enum ERenderQueries
        {
            RENDERQUERY_SHADER = 0,
            RENDERQUERY_GEOMETRY_SHADER,
            RENDERQUERY_TESSELLATION_SHADER,
            RENDERQUERY_CONSTANT_BUFFER,

            RENDERQUERY_RENDERTARGET,
            RENDERQUERY_MULTISAMPLE_RENDERTARGET,
            RENDERQUERY_MULTI_TEXTURE,
            RENDERQUERY_CUBEMAP_ARRAY,
            
            RENDERQUERY_HARDWARE_MESHBUFFER,
            RENDERQUERY_HARDWARE_INSTANCING,
            
            RENDERQUERY_FOG_COORD,
            
            RENDERQUERY_COUNT,
        };
        
        /* === Structures === */
        
        struct SFogStates
        {
            SFogStates() :
                Type    (FOG_NONE   ),
                Mode    (FOG_PALE   ),
                Range   (0.0f       ),
                Near    (0.0f       ),
                Far     (0.0f       )
            {
            }
            ~SFogStates()
            {
            }
            
            /* Members */
            EFogTypes Type;
            EFogModes Mode;
            f32 Range, Near, Far;
            video::color Color;
        };
        
        struct SDepthRange
        {
            SDepthRange() :
                Enabled (true),
                Near    (0.0f),
                Far     (1.0f)
            {
            }
            ~SDepthRange()
            {
            }
            
            /* Members */
            bool Enabled;
            f32 Near, Far;
        };
        
        /* === Functions === */
        
        RenderSystem(const ERenderSystems Type);
        
        virtual void setup2DDrawing();
        virtual void setup3DDrawing();
        
        virtual Shader* createEmptyShaderWithError(
            const io::stringc &Message, ShaderClass* ShaderClassObj, const EShaderTypes Type, const EShaderVersions Version
        );
        
        virtual void createDeviceFont(
            void* FontObject, const io::stringc &FontName, const dim::size2di &FontSize,
            s32 Flags = 0, s32 CharSet = 0
        ) const;
        
        virtual std::vector<SFontGlyph> getCharWidths(void* FontObject) const;
        
        virtual void updateVertexInputLayout(VertexFormat* Format, bool isCreate);
        
        virtual void createDefaultResources();
        virtual void deleteDefaultResources();
        
        virtual void releaseFontObject(Font* FontObj);
        
        virtual void drawTexturedFont(const Font* FontObj, const dim::point2di &Position, const io::stringc &Text, const color &Color);
        virtual void drawBitmapFont(const Font* FontObj, const dim::point2di &Position, const io::stringc &Text, const color &Color);
        
        void unbindPrevTextureLayers();
        void noticeTextureLayerChanged(const TextureLayer* TexLayer);
        
        /* === Static functions === */
        
        static void resetQueryCounters();
        
        /* === Members === */
        
        /* Identity member */
        ERenderSystems RendererType_;
        
        /* Context members */
        #if defined(SP_PLATFORM_WINDOWS)
        HDC DeviceContext_;
        UINT PixelFormat_;
        #elif defined(SP_PLATFORM_LINUX)
        Display* Display_;
        Window* Window_;
        #endif
        
        /* Object lists */
        std::list<Texture*>         TextureList_;
        std::list<Shader*>          ShaderList_;
        std::list<ShaderClass*>     ShaderClassList_;
        std::list<ComputeShaderIO*> ComputeShaderIOList_;
        std::list<Font*>            FontList_;
        std::list<Movie*>           MovieList_;
        
        std::map<std::string, Texture*> TextureMap_;
        
        std::vector<RenderContext*> ContextList_;
        
        /* Semaphores */
        CriticalSection TextureListSemaphore_;
        
        /* States and flags */
        u8 StdFillColor_[4];
        
        SFogStates Fog_;
        STextureCreationFlags TexGenFlags_;
        SDepthRange DepthRange_;
        
        /* Render states */
        ERenderModes RenderMode_;
        
        dim::matrix4f Matrix2D_;
        dim::matrix4f FontTransform_;
        u32 MaxClippingPlanes_;
        
        bool isFrontFace_;
        
        s32 TexLayerVisibleMask_;
        
        /* Render target */
        Texture* RenderTarget_;
        
        /* Shader programs */
        ShaderClass* CurShaderClass_;
        ShaderClass* GlobalShaderClass_;
        ShaderSurfaceCallback ShaderSurfaceCallback_;
        
        const MaterialStates* PrevMaterial_;
        const TextureLayerListType* PrevTextureLayers_;
        
        MaterialStates* Material2DDrawing_;
        MaterialStates* Material3DDrawing_;
        
        /* Vertex formats */
        std::list<VertexFormat*> VertexFormatList_;
        
        VertexFormatDefault*    VertexFormatDefault_;
        VertexFormatReduced*    VertexFormatReduced_;
        VertexFormatExtended*   VertexFormatExtended_;
        VertexFormatFull*       VertexFormatFull_;
        
        /* Queries */
        bool RenderQuery_[RENDERQUERY_COUNT];
        
        #ifdef SP_DEBUGMODE
        
        static u32 NumDrawCalls_;           
        static u32 NumMeshBufferBindings_;  
        static u32 NumTexLayerBindings_;    
        static u32 NumMaterialUpdates_;     
        
        #endif
        
    private:
        
        /* === Functions === */
        
        void createDefaultVertexFormats();
        void createDefaultTextures();
        void createDrawingMaterials();
        
        bool loadShaderResourceFile(
            io::FileSystem &FileSys, const io::stringc &Filename, std::list<io::stringc> &ShaderBuffer
        );
        
        static bool hasStringIncludeDirective(const io::stringc &Line, io::stringc &Filename);
        
        /* === Members === */
        
        video::Texture* DefaultTextures_[DEFAULT_TEXTURE_COUNT];
        
};


} // /namespace video

} // /namespace sp


#endif



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