IVideoDriver.hpp

// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in duckcpp/duckcpp.hpp
 
#ifndef DCPP_I_VIDEO_DRIVER_HPP_INCLUDED
#define DCPP_I_VIDEO_DRIVER_HPP_INCLUDED
 
#include <duckcpp/core/engine/rect.hpp>
#include <duckcpp/core/engine/SColor.hpp>
#include <duckcpp/core/engine/ITexture.hpp>
#include <duckcpp/core/engine/irrArray.hpp>
#include <duckcpp/core/engine/matrix4.hpp>
#include <duckcpp/core/engine/plane3d.hpp>
#include <duckcpp/core/engine/dimension2d.hpp>
#include <duckcpp/core/engine/position2d.hpp>
#include <duckcpp/core/engine/IMeshBuffer.hpp>
#include <duckcpp/core/engine/triangle3d.hpp>
#include <duckcpp/core/engine/EDriverTypes.hpp>
#include <duckcpp/core/engine/EDriverFeatures.hpp>
#include <duckcpp/core/engine/SExposedVideoData.hpp>
#include <duckcpp/core/engine/SOverrideMaterial.hpp>
 
namespace dcpp
{
namespace io
{
    class IAttributes;
    class SAttributeReadWriteOptions;
    class IReadFile;
    class IWriteFile;
} // end namespace io
namespace scene
{
    class IMeshBuffer;
    class IMesh;
    class IMeshManipulator;
    class ISceneNode;
} // end namespace scene
 
namespace video
{
    class S3DVertex;
    class S3DVertex2TCoords;
    class S3DVertexTangents;
    class SLight;
    class IImageLoader;
    class IImageWriter;
    class IMaterialRenderer;
    class IGPUProgrammingServices;
    class IRenderTarget;
 
    enum E_TRANSFORMATION_STATE
    {
        ETS_VIEW = 0,
        ETS_WORLD,
        ETS_PROJECTION,
        ETS_TEXTURE_0,
        ETS_TEXTURE_1,
        ETS_TEXTURE_2,
        ETS_TEXTURE_3,
#if _DCPP_MATERIAL_MAX_TEXTURES_>4
        ETS_TEXTURE_4,
#if _DCPP_MATERIAL_MAX_TEXTURES_>5
        ETS_TEXTURE_5,
#if _DCPP_MATERIAL_MAX_TEXTURES_>6
        ETS_TEXTURE_6,
#if _DCPP_MATERIAL_MAX_TEXTURES_>7
        ETS_TEXTURE_7,
#endif
#endif
#endif
#endif
        ETS_COUNT = ETS_TEXTURE_0 + _DCPP_MATERIAL_MAX_TEXTURES_
    };
 
 
    enum E_RENDER_TARGET
    {
        ERT_FRAME_BUFFER=0,
        ERT_RENDER_TEXTURE,
        ERT_MULTI_RENDER_TEXTURES,
        ERT_STEREO_LEFT_BUFFER,
        ERT_STEREO_RIGHT_BUFFER,
        ERT_STEREO_BOTH_BUFFERS,
        ERT_AUX_BUFFER0,
        ERT_AUX_BUFFER1,
        ERT_AUX_BUFFER2,
        ERT_AUX_BUFFER3,
        ERT_AUX_BUFFER4
    };
 
    enum E_CLEAR_BUFFER_FLAG
    {
        ECBF_NONE = 0,
        ECBF_COLOR = 1,
        ECBF_DEPTH = 2,
        ECBF_STENCIL = 4,
        ECBF_ALL = ECBF_COLOR|ECBF_DEPTH|ECBF_STENCIL
    };
 
    enum E_FOG_TYPE
    {
        EFT_FOG_EXP=0,
        EFT_FOG_LINEAR,
        EFT_FOG_EXP2
    };
 
    const dcpp::char_kt* const FogTypeNames[] =
    {
        "FogExp",
        "FogLinear",
        "FogExp2",
        0
    };
 
 
    class IVideoDriver : public virtual IReferenceCounted
    {
    public:
 
 
        virtual bool beginScene(
            dcpp::uint16_kt clearFlag,
            dcpp::video::SColor clearColor,
            dcpp::float32_kt clearDepth = 1.0f,
            dcpp::uint8_kt clearStencil = 0,
            const dcpp::video::SExposedVideoData & videoData=dcpp::video::SExposedVideoData{},
            dcpp::nub::recti * sourceRect = nullptr
        ) = 0;
 
 
        bool beginScene(
            dcpp::video::SColor color = dcpp::video::SColor{255,0,0,0},
            const dcpp::video::SExposedVideoData & videoData = dcpp::video::SExposedVideoData{},
            dcpp::nub::recti * sourceRect = nullptr
        )
        {
            return this->beginScene(
                dcpp::video::ECBF_COLOR | dcpp::video::ECBF_DEPTH,
                color,
                1.0f,
                0,
                videoData,
                sourceRect
            );
        }
 
 
        virtual bool endScene() = 0;
 
 
        bool swapScenes(
            dcpp::uint16_kt clearFlag,
            dcpp::video::SColor clearColor,
            dcpp::float32_kt clearDepth = 1.0f,
            dcpp::uint8_kt clearStencil = 0,
            const dcpp::video::SExposedVideoData & videoData=dcpp::video::SExposedVideoData{},
            dcpp::nub::recti * sourceRect = nullptr
        )
        {
            return
                this->endScene()
                    &&
                this->beginScene(
                    clearFlag, clearColor, clearDepth, clearStencil, videoData, sourceRect
                )
            ;
        }
 
 
        bool swapScenes(
            dcpp::video::SColor color = dcpp::video::SColor{255,0,0,0},
            const dcpp::video::SExposedVideoData & videoData = dcpp::video::SExposedVideoData{},
            dcpp::nub::recti * sourceRect = nullptr
        )
        {
            return
                this->endScene()
                    &&
                this->beginScene(
                    color,
                    videoData,
                    sourceRect
                );
        }
 
 
        virtual bool queryFeature(E_VIDEO_DRIVER_FEATURE feature) const =0;
 
 
        virtual void disableFeature(E_VIDEO_DRIVER_FEATURE feature, bool flag=true) =0;
 
 
        virtual const dcpp::io::IAttributes& getDriverAttributes() const=0;
 
 
        virtual bool checkDriverReset() =0;
 
 
        virtual void setTransform(E_TRANSFORMATION_STATE state, const dcpp::nub::matrix4& mat) =0;
 
 
        virtual const dcpp::nub::matrix4& getTransform(E_TRANSFORMATION_STATE state) const =0;
 
 
        virtual dcpp::uint32_kt getImageLoaderCount() const = 0;
 
 
        virtual IImageLoader* getImageLoader(dcpp::uint32_kt n) = 0;
 
 
        virtual dcpp::uint32_kt getImageWriterCount() const = 0;
 
 
        virtual IImageWriter* getImageWriter(dcpp::uint32_kt n) = 0;
 
 
        virtual void setMaterial(const SMaterial& material) =0;
 
 
        virtual ITexture* getTexture(const dcpp::io::path& filename) = 0;
 
 
        virtual ITexture* getTexture(dcpp::io::IReadFile* file) =0;
 
 
        virtual ITexture* getTextureByIndex(dcpp::uint32_kt index) =0;
 
 
        virtual dcpp::uint32_kt getTextureCount() const = 0;
 
 
        virtual void renameTexture(ITexture* texture, const dcpp::io::path& newName) = 0;
 
 
        virtual ITexture* addTexture(const dcpp::nub::dimension2du& size,
            const dcpp::io::path& name, ECOLOR_FORMAT format = ECF_A8R8G8B8) = 0;
 
 
        DCPP_DEPRECATED ITexture* addTexture(const dcpp::io::path& name, IImage* image, void* mipmapData)
        {
            if (image)
                image->setMipMapsData(mipmapData, false, true);
 
            return addTexture(name, image);
        }
 
 
        virtual ITexture* addTexture(const dcpp::io::path& name, IImage* image) = 0;
 
 
        virtual ITexture* addTextureCubemap(const dcpp::io::path& name, IImage* imagePosX, IImage* imageNegX, IImage* imagePosY,
            IImage* imageNegY, IImage* imagePosZ, IImage* imageNegZ) = 0;
 
 
        virtual ITexture* addTextureCubemap(const dcpp::uint32_kt sideLen, const dcpp::io::path& name, ECOLOR_FORMAT format = ECF_A8R8G8B8) = 0;
 
 
        virtual ITexture* addRenderTargetTexture(const dcpp::nub::dimension2du& size,
                const dcpp::io::path& name = "rt", const ECOLOR_FORMAT format = ECF_UNKNOWN) =0;
 
 
        virtual ITexture* addRenderTargetTextureCubemap(const dcpp::uint32_kt sideLen,
                const dcpp::io::path& name = "rt", const ECOLOR_FORMAT format = ECF_UNKNOWN) =0;
 
 
        virtual void removeTexture(ITexture* texture) =0;
 
 
        virtual void removeAllTextures() =0;
 
        virtual void removeHardwareBuffer(const dcpp::scene::IMeshBuffer* mb) =0;
 
        virtual void removeAllHardwareBuffers() =0;
 
 
        virtual void addOcclusionQuery(dcpp::scene::ISceneNode* node,
                const dcpp::scene::IMesh* mesh=0) =0;
 
        virtual void removeOcclusionQuery(dcpp::scene::ISceneNode* node) =0;
 
        virtual void removeAllOcclusionQueries() =0;
 
 
        virtual void runOcclusionQuery(dcpp::scene::ISceneNode* node, bool visible=false) =0;
 
 
        virtual void runAllOcclusionQueries(bool visible=false) =0;
 
 
        virtual void updateOcclusionQuery(dcpp::scene::ISceneNode* node, bool block=true) =0;
 
 
        virtual void updateAllOcclusionQueries(bool block=true) =0;
 
 
        virtual dcpp::uint32_kt getOcclusionQueryResult(const dcpp::scene::ISceneNode* node) const =0;
 
        virtual IRenderTarget* addRenderTarget() = 0;
 
        virtual void removeRenderTarget(IRenderTarget* renderTarget) = 0;
 
        virtual void removeAllRenderTargets() = 0;
 
 
        virtual void makeColorKeyTexture(dcpp::video::ITexture* texture,
                        dcpp::video::SColor color,
                        bool zeroTexels = false) const =0;
 
 
        virtual void makeColorKeyTexture(dcpp::video::ITexture* texture,
                dcpp::nub::position2di colorKeyPixelPos,
                bool zeroTexels = false) const =0;
 
 
        virtual void makeNormalMapTexture(dcpp::video::ITexture* texture, dcpp::float32_kt amplitude=1.0f) const =0;
 
 
        virtual bool setRenderTargetEx(IRenderTarget* target, dcpp::uint16_kt clearFlag, SColor clearColor = SColor(255,0,0,0),
            dcpp::float32_kt clearDepth = 1.f, dcpp::uint8_kt clearStencil = 0) = 0;
 
 
        virtual bool setRenderTarget(ITexture* texture, dcpp::uint16_kt clearFlag=ECBF_COLOR|ECBF_DEPTH, SColor clearColor = SColor(255,0,0,0),
            dcpp::float32_kt clearDepth = 1.f, dcpp::uint8_kt clearStencil = 0) = 0;
 
        bool setRenderTarget(ITexture* texture, bool clearBackBuffer, bool clearZBuffer, SColor color = SColor(255,0,0,0))
        {
            dcpp::uint16_kt flag = 0;
 
            if (clearBackBuffer)
                flag |= ECBF_COLOR;
 
            if (clearZBuffer)
                flag |= ECBF_DEPTH;
 
            return setRenderTarget(texture, flag, color);
        }
 
 
        virtual void setViewPort(const dcpp::nub::recti& area) =0;
 
 
        virtual const dcpp::nub::recti& getViewPort() const =0;
 
 
        virtual void drawVertexPrimitiveList(const void* vertices, dcpp::uint32_kt vertexCount,
                const void* indexList, dcpp::uint32_kt primCount,
                E_VERTEX_TYPE vType=EVT_STANDARD,
                dcpp::scene::E_PRIMITIVE_TYPE pType=dcpp::scene::EPT_TRIANGLES,
                E_INDEX_TYPE iType=EIT_16BIT) =0;
 
 
        virtual void draw2DVertexPrimitiveList(const void* vertices, dcpp::uint32_kt vertexCount,
                const void* indexList, dcpp::uint32_kt primCount,
                E_VERTEX_TYPE vType=EVT_STANDARD,
                dcpp::scene::E_PRIMITIVE_TYPE pType=dcpp::scene::EPT_TRIANGLES,
                E_INDEX_TYPE iType=EIT_16BIT) =0;
 
 
        void drawIndexedTriangleList(const S3DVertex* vertices,
            dcpp::uint32_kt vertexCount, const dcpp::uint16_kt* indexList, dcpp::uint32_kt triangleCount)
        {
            drawVertexPrimitiveList(vertices, vertexCount, indexList, triangleCount, EVT_STANDARD, dcpp::scene::EPT_TRIANGLES, EIT_16BIT);
        }
 
 
        void drawIndexedTriangleList(const S3DVertex2TCoords* vertices,
            dcpp::uint32_kt vertexCount, const dcpp::uint16_kt* indexList, dcpp::uint32_kt triangleCount)
        {
            drawVertexPrimitiveList(vertices, vertexCount, indexList, triangleCount, EVT_2TCOORDS, dcpp::scene::EPT_TRIANGLES, EIT_16BIT);
        }
 
 
        void drawIndexedTriangleList(const S3DVertexTangents* vertices,
            dcpp::uint32_kt vertexCount, const dcpp::uint16_kt* indexList, dcpp::uint32_kt triangleCount)
        {
            drawVertexPrimitiveList(vertices, vertexCount, indexList, triangleCount, EVT_TANGENTS, dcpp::scene::EPT_TRIANGLES, EIT_16BIT);
        }
 
 
        void drawIndexedTriangleFan(const S3DVertex* vertices,
            dcpp::uint32_kt vertexCount, const dcpp::uint16_kt* indexList, dcpp::uint32_kt triangleCount)
        {
            drawVertexPrimitiveList(vertices, vertexCount, indexList, triangleCount, EVT_STANDARD, dcpp::scene::EPT_TRIANGLE_FAN, EIT_16BIT);
        }
 
 
        void drawIndexedTriangleFan(const S3DVertex2TCoords* vertices,
            dcpp::uint32_kt vertexCount, const dcpp::uint16_kt* indexList, dcpp::uint32_kt triangleCount)
        {
            drawVertexPrimitiveList(vertices, vertexCount, indexList, triangleCount, EVT_2TCOORDS, dcpp::scene::EPT_TRIANGLE_FAN, EIT_16BIT);
        }
 
 
        void drawIndexedTriangleFan(const S3DVertexTangents* vertices,
            dcpp::uint32_kt vertexCount, const dcpp::uint16_kt* indexList, dcpp::uint32_kt triangleCount)
        {
            drawVertexPrimitiveList(vertices, vertexCount, indexList, triangleCount, EVT_TANGENTS, dcpp::scene::EPT_TRIANGLE_FAN, EIT_16BIT);
        }
 
 
        virtual void draw3DLine(const dcpp::nub::vector3df& start,
            const dcpp::nub::vector3df& end, SColor color = SColor(255,255,255,255)) =0;
 
 
        virtual void draw3DTriangle(const dcpp::nub::triangle3df& triangle,
            SColor color = SColor(255,255,255,255)) =0;
 
 
        virtual void draw3DBox(const dcpp::nub::aabbox3df& box,
            SColor color = SColor(255,255,255,255)) =0;
 
 
        virtual void draw2DImage(const dcpp::video::ITexture* texture,
            const dcpp::nub::position2di& destPos, bool useAlphaChannelOfTexture=false) =0;
 
 
        virtual void draw2DImage(const dcpp::video::ITexture* texture, const dcpp::nub::position2di& destPos,
            const dcpp::nub::recti& sourceRect, const dcpp::nub::recti* clipRect =0,
            SColor color=SColor(255,255,255,255), bool useAlphaChannelOfTexture=false) =0;
 
 
        virtual void draw2DImageBatch(const dcpp::video::ITexture* texture,
                const dcpp::nub::position2di& pos,
                const dcpp::nub::array<dcpp::nub::recti >& sourceRects,
                const dcpp::nub::array<dcpp::int32_kt>& indices,
                dcpp::int32_kt kerningWidth=0,
                const dcpp::nub::recti* clipRect=0,
                SColor color=SColor(255,255,255,255),
                bool useAlphaChannelOfTexture=false) =0;
 
 
        virtual void draw2DImageBatch(const dcpp::video::ITexture* texture,
                const dcpp::nub::array<dcpp::nub::position2di >& positions,
                const dcpp::nub::array<dcpp::nub::recti >& sourceRects,
                const dcpp::nub::recti* clipRect=0,
                SColor color=SColor(255,255,255,255),
                bool useAlphaChannelOfTexture=false) =0;
 
 
        virtual void draw2DImage(const dcpp::video::ITexture* texture, const dcpp::nub::recti& destRect,
            const dcpp::nub::recti& sourceRect, const dcpp::nub::recti* clipRect =0,
            const dcpp::video::SColor * const colors=0, bool useAlphaChannelOfTexture=false) =0;
 
 
        virtual void draw2DRectangle(SColor color, const dcpp::nub::recti& pos,
            const dcpp::nub::recti* clip =0) =0;
 
 
        virtual void draw2DRectangle(const dcpp::nub::recti& pos,
                SColor colorLeftUp, SColor colorRightUp,
                SColor colorLeftDown, SColor colorRightDown,
                const dcpp::nub::recti* clip =0) =0;
 
 
        virtual void draw2DRectangleOutline(const dcpp::nub::recti& pos,
                SColor color=SColor(255,255,255,255)) =0;
 
 
        virtual void draw2DLine(const dcpp::nub::position2di& start,
                    const dcpp::nub::position2di& end,
                    SColor color=SColor(255,255,255,255)) =0;
 
 
        virtual void drawPixel(dcpp::uint32_kt x, dcpp::uint32_kt y, const SColor& color) =0;
 
 
        virtual void draw2DPolygon(dcpp::nub::position2di center,
                dcpp::float32_kt radius,
                dcpp::video::SColor color=SColor(100,255,255,255),
                dcpp::int32_kt vertexCount=10) =0;
 
 
        virtual void drawStencilShadowVolume(const dcpp::nub::array<dcpp::nub::vector3df>& triangles, bool zfail=true, dcpp::uint32_kt debugDataVisible=0) =0;
 
 
        virtual void drawStencilShadow(bool clearStencilBuffer=false,
            dcpp::video::SColor leftUpEdge = dcpp::video::SColor(255,0,0,0),
            dcpp::video::SColor rightUpEdge = dcpp::video::SColor(255,0,0,0),
            dcpp::video::SColor leftDownEdge = dcpp::video::SColor(255,0,0,0),
            dcpp::video::SColor rightDownEdge = dcpp::video::SColor(255,0,0,0)) =0;
 
 
        virtual void drawMeshBuffer(const dcpp::scene::IMeshBuffer* mb) =0;
 
 
        virtual void drawMeshBufferNormals(const dcpp::scene::IMeshBuffer* mb, dcpp::float32_kt length=10.f, SColor color=0xffffffff) =0;
 
 
        virtual void setFog(SColor color=SColor(0,255,255,255),
                E_FOG_TYPE fogType=EFT_FOG_LINEAR,
                dcpp::float32_kt start=50.0f, dcpp::float32_kt end=100.0f, dcpp::float32_kt density=0.01f,
                bool pixelFog=false, bool rangeFog=false) =0;
 
        virtual void getFog(SColor& color, E_FOG_TYPE& fogType,
                dcpp::float32_kt& start, dcpp::float32_kt& end, dcpp::float32_kt& density,
                bool& pixelFog, bool& rangeFog) = 0;
 
 
        virtual ECOLOR_FORMAT getColorFormat() const =0;
 
 
        virtual const dcpp::nub::dimension2du& getScreenSize() const =0;
 
 
        virtual const dcpp::nub::dimension2du& getCurrentRenderTargetSize() const =0;
 
 
        virtual dcpp::int32_kt getFPS() const =0;
 
 
        virtual dcpp::uint32_kt getPrimitiveCountDrawn( dcpp::uint32_kt mode =0 ) const =0;
 
        virtual void deleteAllDynamicLights() =0;
 
        virtual dcpp::int32_kt addDynamicLight(const SLight& light) =0;
 
 
        virtual dcpp::uint32_kt getMaximalDynamicLightAmount() const =0;
 
 
        virtual dcpp::uint32_kt getDynamicLightCount() const =0;
 
 
        virtual const SLight& getDynamicLight(dcpp::uint32_kt idx) const =0;
 
        virtual void turnLightOn(dcpp::int32_kt lightIndex, bool turnOn) =0;
 
 
        virtual const wchar_t* getName() const =0;
 
 
        virtual void addExternalImageLoader(IImageLoader* loader) =0;
 
 
        virtual void addExternalImageWriter(IImageWriter* writer) =0;
 
 
        virtual dcpp::uint32_kt getMaximalPrimitiveCount() const =0;
 
 
        virtual void setTextureCreationFlag(E_TEXTURE_CREATION_FLAG flag, bool enabled=true) =0;
 
 
        virtual bool getTextureCreationFlag(E_TEXTURE_CREATION_FLAG flag) const =0;
 
 
        virtual dcpp::nub::array<IImage*> createImagesFromFile(const dcpp::io::path& filename, E_TEXTURE_TYPE* type = 0) = 0;
 
 
        virtual dcpp::nub::array<IImage*> createImagesFromFile(dcpp::io::IReadFile* file, E_TEXTURE_TYPE* type = 0) = 0;
 
 
        IImage* createImageFromFile(const dcpp::io::path& filename)
        {
            dcpp::nub::array<IImage*> imageArray = createImagesFromFile(filename);
 
            for (dcpp::uint32_kt i = 1; i < imageArray.size(); ++i)
                imageArray[i]->drop();
 
            return (imageArray.size() > 0) ? imageArray[0] : 0;
        }
 
 
        IImage* createImageFromFile(dcpp::io::IReadFile* file)
        {
            dcpp::nub::array<IImage*> imageArray = createImagesFromFile(file);
 
            for (dcpp::uint32_kt i = 1; i < imageArray.size(); ++i)
                imageArray[i]->drop();
 
            return (imageArray.size() > 0) ? imageArray[0] : 0;
        }
 
 
        virtual bool writeImageToFile(IImage* image, const dcpp::io::path& filename, dcpp::uint32_kt param = 0) = 0;
 
 
        virtual bool writeImageToFile(IImage* image, dcpp::io::IWriteFile* file, dcpp::uint32_kt param =0) =0;
 
 
        virtual IImage* createImageFromData(ECOLOR_FORMAT format,
            const dcpp::nub::dimension2du& size, void *data, bool ownForeignMemory = false,
            bool deleteMemory = true) = 0;
 
 
        virtual IImage* createImage(ECOLOR_FORMAT format, const dcpp::nub::dimension2du& size) =0;
 
 
        DCPP_DEPRECATED virtual IImage* createImage(ECOLOR_FORMAT format, IImage *imageToCopy) =0;
 
 
        DCPP_DEPRECATED virtual IImage* createImage(IImage* imageToCopy,
                const dcpp::nub::position2di& pos,
                const dcpp::nub::dimension2du& size) =0;
 
 
        virtual IImage* createImage(ITexture* texture,
                const dcpp::nub::position2di& pos,
                const dcpp::nub::dimension2du& size) =0;
 
 
        virtual void OnResize(const dcpp::nub::dimension2du& size) =0;
 
 
        virtual dcpp::int32_kt addMaterialRenderer(IMaterialRenderer* renderer, const dcpp::char_kt* name =0) =0;
 
 
        virtual IMaterialRenderer* getMaterialRenderer(dcpp::uint32_kt idx) const = 0;
 
 
        virtual dcpp::uint32_kt getMaterialRendererCount() const =0;
 
 
        virtual const dcpp::char_kt* getMaterialRendererName(dcpp::uint32_kt idx) const =0;
 
 
        virtual void setMaterialRendererName(dcpp::uint32_kt idx, const dcpp::char_kt* name) =0;
 
 
        virtual void swapMaterialRenderers(dcpp::uint32_kt idx1, dcpp::uint32_kt idx2, bool swapNames=true) = 0;
 
 
        virtual dcpp::io::IAttributes* createAttributesFromMaterial(const dcpp::video::SMaterial& material,
            dcpp::io::SAttributeReadWriteOptions* options=0) =0;
 
 
        virtual void fillMaterialStructureFromAttributes(dcpp::video::SMaterial& outMaterial, dcpp::io::IAttributes* attributes) =0;
 
 
        virtual const SExposedVideoData& getExposedVideoData() =0;
 
 
        virtual E_DRIVER_TYPE getDriverType() const =0;
 
 
        virtual IGPUProgrammingServices* getGPUProgrammingServices() =0;
 
        virtual dcpp::scene::IMeshManipulator* getMeshManipulator() =0;
 
        virtual void clearBuffers(dcpp::uint16_kt flag, SColor color = SColor(255,0,0,0), dcpp::float32_kt depth = 1.f, dcpp::uint8_kt stencil = 0) = 0;
 
        DCPP_DEPRECATED void clearBuffers(bool backBuffer, bool depthBuffer, bool stencilBuffer, SColor color)
        {
            dcpp::uint16_kt flag = 0;
 
            if (backBuffer)
                flag |= ECBF_COLOR;
 
            if (depthBuffer)
                flag |= ECBF_DEPTH;
 
            if (stencilBuffer)
                flag |= ECBF_STENCIL;
 
            clearBuffers(flag, color);
        }
 
 
        void clearZBuffer()
        {
            clearBuffers(ECBF_DEPTH, SColor(255,0,0,0), 1.f, 0);
        }
 
 
        virtual IImage* createScreenShot(dcpp::video::ECOLOR_FORMAT format=dcpp::video::ECF_UNKNOWN, dcpp::video::E_RENDER_TARGET target=dcpp::video::ERT_FRAME_BUFFER) =0;
 
 
        virtual dcpp::video::ITexture* findTexture(const dcpp::io::path& filename) = 0;
 
 
        virtual bool setClipPlane(dcpp::uint32_kt index, const dcpp::nub::plane3df& plane, bool enable=false) =0;
 
 
        virtual void enableClipPlane(dcpp::uint32_kt index, bool enable) =0;
 
 
        virtual void setMinHardwareBufferVertexCount(dcpp::uint32_kt count) =0;
 
 
        virtual SOverrideMaterial& getOverrideMaterial() =0;
 
 
        virtual SMaterial& getMaterial2D() =0;
 
 
        virtual void enableMaterial2D(bool enable=true) =0;
 
        virtual dcpp::nub::string getVendorInfo() =0;
 
 
        virtual void setAmbientLight(const SColorf& color) =0;
 
 
        virtual void setAllowZWriteOnTransparent(bool flag) =0;
 
        virtual dcpp::nub::dimension2du getMaxTextureSize() const =0;
 
 
        virtual void convertColor(const void* sP, ECOLOR_FORMAT sF, dcpp::int32_kt sN,
                void* dP, ECOLOR_FORMAT dF) const =0;
 
 
        virtual bool queryTextureFormat(ECOLOR_FORMAT format) const = 0;
 
        virtual bool needsTransparentRenderPass(const dcpp::video::SMaterial& material) const = 0;
    };
 
} // end namespace video
} // end namespace dcpp
 
 
#endif