IVideoDriver.h

Go to the documentation of this file.

// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h

#ifndef __IRR_I_VIDEO_DRIVER_H_INCLUDED__
#define __IRR_I_VIDEO_DRIVER_H_INCLUDED__

#include "rect.h"
#include "SColor.h"
#include "ITexture.h"
#include "irrArray.h"
#include "matrix4.h"
#include "plane3d.h"
#include "dimension2d.h"
#include "position2d.h"
#include "IMeshBuffer.h"
#include "triangle3d.h"
#include "EDriverTypes.h"
#include "EDriverFeatures.h"
#include "SExposedVideoData.h"
#include "SOverrideMaterial.h"

namespace irr
{
namespace io
{
        class IAttributes;
        struct SAttributeReadWriteOptions;
        class IReadFile;
        class IWriteFile;
} // end namespace io
namespace scene
{
        class IMeshBuffer;
        class IMesh;
        class IMeshManipulator;
        class ISceneNode;
} // end namespace scene

namespace video
{
        struct S3DVertex;
        struct S3DVertex2TCoords;
        struct S3DVertexTangents;
        struct 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 _IRR_MATERIAL_MAX_TEXTURES_>4
                ETS_TEXTURE_4,
#if _IRR_MATERIAL_MAX_TEXTURES_>5
                ETS_TEXTURE_5,
#if _IRR_MATERIAL_MAX_TEXTURES_>6
                ETS_TEXTURE_6,
#if _IRR_MATERIAL_MAX_TEXTURES_>7
                ETS_TEXTURE_7,
#endif
#endif
#endif
#endif
                ETS_COUNT = ETS_TEXTURE_0 + _IRR_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 c8* const FogTypeNames[] =
        {
                "FogExp",
                "FogLinear",
                "FogExp2",
                0
        };


        class IVideoDriver : public virtual IReferenceCounted
        {
        public:


                virtual bool beginScene(u16 clearFlag=(u16)(ECBF_COLOR|ECBF_DEPTH), SColor clearColor = SColor(255,0,0,0), f32 clearDepth = 1.f, u8 clearStencil = 0,
                        const SExposedVideoData& videoData=SExposedVideoData(), core::rect<s32>* sourceRect = 0) = 0;

                bool beginScene(bool backBuffer, bool zBuffer, SColor color = SColor(255,0,0,0),
                        const SExposedVideoData& videoData = SExposedVideoData(), core::rect<s32>* sourceRect = 0)
                {
                        u16 flag = 0;

                        if (backBuffer)
                                flag |= ECBF_COLOR;

                        if (zBuffer)
                                flag |= ECBF_DEPTH;

                        return beginScene(flag, color, 1.f, 0, videoData, sourceRect);
                }


                virtual bool endScene() = 0;


                virtual bool queryFeature(E_VIDEO_DRIVER_FEATURE feature) const =0;


                virtual void disableFeature(E_VIDEO_DRIVER_FEATURE feature, bool flag=true) =0;


                virtual const io::IAttributes& getDriverAttributes() const=0;


                virtual bool checkDriverReset() =0;


                virtual void setTransform(E_TRANSFORMATION_STATE state, const core::matrix4& mat) =0;


                virtual const core::matrix4& getTransform(E_TRANSFORMATION_STATE state) const =0;


                virtual u32 getImageLoaderCount() const = 0;


                virtual IImageLoader* getImageLoader(u32 n) = 0;


                virtual u32 getImageWriterCount() const = 0;


                virtual IImageWriter* getImageWriter(u32 n) = 0;


                virtual void setMaterial(const SMaterial& material) =0;


                virtual ITexture* getTexture(const io::path& filename) = 0;


                virtual ITexture* getTexture(io::IReadFile* file) =0;


                virtual ITexture* getTextureByIndex(u32 index) =0;


                virtual u32 getTextureCount() const = 0;


                virtual void renameTexture(ITexture* texture, const io::path& newName) = 0;


                virtual ITexture* addTexture(const core::dimension2d<u32>& size,
                        const io::path& name, ECOLOR_FORMAT format = ECF_A8R8G8B8) = 0;


                _IRR_DEPRECATED_ ITexture* addTexture(const io::path& name, IImage* image, void* mipmapData)
                {
                        if (image)
                                image->setMipMapsData(mipmapData, false, true);

                        return addTexture(name, image);
                }


                virtual ITexture* addTexture(const io::path& name, IImage* image) = 0;


                virtual ITexture* addTextureCubemap(const io::path& name, IImage* imagePosX, IImage* imageNegX, IImage* imagePosY,
                        IImage* imageNegY, IImage* imagePosZ, IImage* imageNegZ) = 0;


                virtual ITexture* addTextureCubemap(const irr::u32 sideLen, const io::path& name, ECOLOR_FORMAT format = ECF_A8R8G8B8) = 0;


                virtual ITexture* addRenderTargetTexture(const core::dimension2d<u32>& size,
                                const io::path& name = "rt", const ECOLOR_FORMAT format = ECF_UNKNOWN) =0;


                virtual ITexture* addRenderTargetTextureCubemap(const irr::u32 sideLen,
                                const 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 scene::IMeshBuffer* mb) =0;

                virtual void removeAllHardwareBuffers() =0;


                virtual void addOcclusionQuery(scene::ISceneNode* node,
                                const scene::IMesh* mesh=0) =0;

                virtual void removeOcclusionQuery(scene::ISceneNode* node) =0;

                virtual void removeAllOcclusionQueries() =0;


                virtual void runOcclusionQuery(scene::ISceneNode* node, bool visible=false) =0;


                virtual void runAllOcclusionQueries(bool visible=false) =0;


                virtual void updateOcclusionQuery(scene::ISceneNode* node, bool block=true) =0;


                virtual void updateAllOcclusionQueries(bool block=true) =0;


                virtual u32 getOcclusionQueryResult(scene::ISceneNode* node) const =0;

                virtual IRenderTarget* addRenderTarget() = 0;

                virtual void removeRenderTarget(IRenderTarget* renderTarget) = 0;

                virtual void removeAllRenderTargets() = 0;


                virtual void makeColorKeyTexture(video::ITexture* texture,
                                                video::SColor color,
                                                bool zeroTexels = false) const =0;


                virtual void makeColorKeyTexture(video::ITexture* texture,
                                core::position2d<s32> colorKeyPixelPos,
                                bool zeroTexels = false) const =0;


                virtual void makeNormalMapTexture(video::ITexture* texture, f32 amplitude=1.0f) const =0;


                virtual bool setRenderTargetEx(IRenderTarget* target, u16 clearFlag, SColor clearColor = SColor(255,0,0,0),
                        f32 clearDepth = 1.f, u8 clearStencil = 0) = 0;


                virtual bool setRenderTarget(ITexture* texture, u16 clearFlag=ECBF_COLOR|ECBF_DEPTH, SColor clearColor = SColor(255,0,0,0),
                        f32 clearDepth = 1.f, u8 clearStencil = 0) = 0;

                bool setRenderTarget(ITexture* texture, bool clearBackBuffer, bool clearZBuffer, SColor color = SColor(255,0,0,0))
                {
                        u16 flag = 0;

                        if (clearBackBuffer)
                                flag |= ECBF_COLOR;

                        if (clearZBuffer)
                                flag |= ECBF_DEPTH;

                        return setRenderTarget(texture, flag, color);
                }


                virtual void setViewPort(const core::rect<s32>& area) =0;


                virtual const core::rect<s32>& getViewPort() const =0;


                virtual void drawVertexPrimitiveList(const void* vertices, u32 vertexCount,
                                const void* indexList, u32 primCount,
                                E_VERTEX_TYPE vType=EVT_STANDARD,
                                scene::E_PRIMITIVE_TYPE pType=scene::EPT_TRIANGLES,
                                E_INDEX_TYPE iType=EIT_16BIT) =0;


                virtual void draw2DVertexPrimitiveList(const void* vertices, u32 vertexCount,
                                const void* indexList, u32 primCount,
                                E_VERTEX_TYPE vType=EVT_STANDARD,
                                scene::E_PRIMITIVE_TYPE pType=scene::EPT_TRIANGLES,
                                E_INDEX_TYPE iType=EIT_16BIT) =0;


                void drawIndexedTriangleList(const S3DVertex* vertices,
                        u32 vertexCount, const u16* indexList, u32 triangleCount)
                {
                        drawVertexPrimitiveList(vertices, vertexCount, indexList, triangleCount, EVT_STANDARD, scene::EPT_TRIANGLES, EIT_16BIT);
                }


                void drawIndexedTriangleList(const S3DVertex2TCoords* vertices,
                        u32 vertexCount, const u16* indexList, u32 triangleCount)
                {
                        drawVertexPrimitiveList(vertices, vertexCount, indexList, triangleCount, EVT_2TCOORDS, scene::EPT_TRIANGLES, EIT_16BIT);
                }


                void drawIndexedTriangleList(const S3DVertexTangents* vertices,
                        u32 vertexCount, const u16* indexList, u32 triangleCount)
                {
                        drawVertexPrimitiveList(vertices, vertexCount, indexList, triangleCount, EVT_TANGENTS, scene::EPT_TRIANGLES, EIT_16BIT);
                }


                void drawIndexedTriangleFan(const S3DVertex* vertices,
                        u32 vertexCount, const u16* indexList, u32 triangleCount)
                {
                        drawVertexPrimitiveList(vertices, vertexCount, indexList, triangleCount, EVT_STANDARD, scene::EPT_TRIANGLE_FAN, EIT_16BIT);
                }


                void drawIndexedTriangleFan(const S3DVertex2TCoords* vertices,
                        u32 vertexCount, const u16* indexList, u32 triangleCount)
                {
                        drawVertexPrimitiveList(vertices, vertexCount, indexList, triangleCount, EVT_2TCOORDS, scene::EPT_TRIANGLE_FAN, EIT_16BIT);
                }


                void drawIndexedTriangleFan(const S3DVertexTangents* vertices,
                        u32 vertexCount, const u16* indexList, u32 triangleCount)
                {
                        drawVertexPrimitiveList(vertices, vertexCount, indexList, triangleCount, EVT_TANGENTS, scene::EPT_TRIANGLE_FAN, EIT_16BIT);
                }


                virtual void draw3DLine(const core::vector3df& start,
                        const core::vector3df& end, SColor color = SColor(255,255,255,255)) =0;


                virtual void draw3DTriangle(const core::triangle3df& triangle,
                        SColor color = SColor(255,255,255,255)) =0;


                virtual void draw3DBox(const core::aabbox3d<f32>& box,
                        SColor color = SColor(255,255,255,255)) =0;


                virtual void draw2DImage(const video::ITexture* texture,
                        const core::position2d<s32>& destPos, bool useAlphaChannelOfTexture=false) =0;


                virtual void draw2DImage(const video::ITexture* texture, const core::position2d<s32>& destPos,
                        const core::rect<s32>& sourceRect, const core::rect<s32>* clipRect =0,
                        SColor color=SColor(255,255,255,255), bool useAlphaChannelOfTexture=false) =0;


                virtual void draw2DImageBatch(const video::ITexture* texture,
                                const core::position2d<s32>& pos,
                                const core::array<core::rect<s32> >& sourceRects,
                                const core::array<s32>& indices,
                                s32 kerningWidth=0,
                                const core::rect<s32>* clipRect=0,
                                SColor color=SColor(255,255,255,255),
                                bool useAlphaChannelOfTexture=false) =0;


                virtual void draw2DImageBatch(const video::ITexture* texture,
                                const core::array<core::position2d<s32> >& positions,
                                const core::array<core::rect<s32> >& sourceRects,
                                const core::rect<s32>* clipRect=0,
                                SColor color=SColor(255,255,255,255),
                                bool useAlphaChannelOfTexture=false) =0;


                virtual void draw2DImage(const video::ITexture* texture, const core::rect<s32>& destRect,
                        const core::rect<s32>& sourceRect, const core::rect<s32>* clipRect =0,
                        const video::SColor * const colors=0, bool useAlphaChannelOfTexture=false) =0;


                virtual void draw2DRectangle(SColor color, const core::rect<s32>& pos,
                        const core::rect<s32>* clip =0) =0;


                virtual void draw2DRectangle(const core::rect<s32>& pos,
                                SColor colorLeftUp, SColor colorRightUp,
                                SColor colorLeftDown, SColor colorRightDown,
                                const core::rect<s32>* clip =0) =0;


                virtual void draw2DRectangleOutline(const core::recti& pos,
                                SColor color=SColor(255,255,255,255)) =0;


                virtual void draw2DLine(const core::position2d<s32>& start,
                                        const core::position2d<s32>& end,
                                        SColor color=SColor(255,255,255,255)) =0;


                virtual void drawPixel(u32 x, u32 y, const SColor& color) =0;


                virtual void draw2DPolygon(core::position2d<s32> center,
                                f32 radius,
                                video::SColor color=SColor(100,255,255,255),
                                s32 vertexCount=10) =0;


                virtual void drawStencilShadowVolume(const core::array<core::vector3df>& triangles, bool zfail=true, u32 debugDataVisible=0) =0;


                virtual void drawStencilShadow(bool clearStencilBuffer=false,
                        video::SColor leftUpEdge = video::SColor(255,0,0,0),
                        video::SColor rightUpEdge = video::SColor(255,0,0,0),
                        video::SColor leftDownEdge = video::SColor(255,0,0,0),
                        video::SColor rightDownEdge = video::SColor(255,0,0,0)) =0;


                virtual void drawMeshBuffer(const scene::IMeshBuffer* mb) =0;


                virtual void drawMeshBufferNormals(const scene::IMeshBuffer* mb, f32 length=10.f, SColor color=0xffffffff) =0;


                virtual void setFog(SColor color=SColor(0,255,255,255),
                                E_FOG_TYPE fogType=EFT_FOG_LINEAR,
                                f32 start=50.0f, f32 end=100.0f, f32 density=0.01f,
                                bool pixelFog=false, bool rangeFog=false) =0;

                virtual void getFog(SColor& color, E_FOG_TYPE& fogType,
                                f32& start, f32& end, f32& density,
                                bool& pixelFog, bool& rangeFog) = 0;


                virtual ECOLOR_FORMAT getColorFormat() const =0;


                virtual const core::dimension2d<u32>& getScreenSize() const =0;


                virtual const core::dimension2d<u32>& getCurrentRenderTargetSize() const =0;


                virtual s32 getFPS() const =0;


                virtual u32 getPrimitiveCountDrawn( u32 mode =0 ) const =0;

                virtual void deleteAllDynamicLights() =0;

                virtual s32 addDynamicLight(const SLight& light) =0;


                virtual u32 getMaximalDynamicLightAmount() const =0;


                virtual u32 getDynamicLightCount() const =0;


                virtual const SLight& getDynamicLight(u32 idx) const =0;

                virtual void turnLightOn(s32 lightIndex, bool turnOn) =0;


                virtual const wchar_t* getName() const =0;


                virtual void addExternalImageLoader(IImageLoader* loader) =0;


                virtual void addExternalImageWriter(IImageWriter* writer) =0;


                virtual u32 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 core::array<IImage*> createImagesFromFile(const io::path& filename, E_TEXTURE_TYPE* type = 0) = 0;


                virtual core::array<IImage*> createImagesFromFile(io::IReadFile* file, E_TEXTURE_TYPE* type = 0) = 0;


                IImage* createImageFromFile(const io::path& filename)
                {
                        core::array<IImage*> imageArray = createImagesFromFile(filename);

                        for (u32 i = 1; i < imageArray.size(); ++i)
                                imageArray[i]->drop();

                        return (imageArray.size() > 0) ? imageArray[0] : 0;
                }


                IImage* createImageFromFile(io::IReadFile* file)
                {
                        core::array<IImage*> imageArray = createImagesFromFile(file);

                        for (u32 i = 1; i < imageArray.size(); ++i)
                                imageArray[i]->drop();

                        return (imageArray.size() > 0) ? imageArray[0] : 0;
                }


                virtual bool writeImageToFile(IImage* image, const io::path& filename, u32 param = 0) = 0;


                virtual bool writeImageToFile(IImage* image, io::IWriteFile* file, u32 param =0) =0;


                virtual IImage* createImageFromData(ECOLOR_FORMAT format,
                        const core::dimension2d<u32>& size, void *data, bool ownForeignMemory = false,
                        bool deleteMemory = true) = 0;


                virtual IImage* createImage(ECOLOR_FORMAT format, const core::dimension2d<u32>& size) =0;


                _IRR_DEPRECATED_ virtual IImage* createImage(ECOLOR_FORMAT format, IImage *imageToCopy) =0;


                _IRR_DEPRECATED_ virtual IImage* createImage(IImage* imageToCopy,
                                const core::position2d<s32>& pos,
                                const core::dimension2d<u32>& size) =0;


                virtual IImage* createImage(ITexture* texture,
                                const core::position2d<s32>& pos,
                                const core::dimension2d<u32>& size) =0;


                virtual void OnResize(const core::dimension2d<u32>& size) =0;


                virtual s32 addMaterialRenderer(IMaterialRenderer* renderer, const c8* name =0) =0;


                virtual IMaterialRenderer* getMaterialRenderer(u32 idx) const = 0;


                virtual u32 getMaterialRendererCount() const =0;


                virtual const c8* getMaterialRendererName(u32 idx) const =0;


                virtual void setMaterialRendererName(s32 idx, const c8* name) =0;


                virtual void swapMaterialRenderers(u32 idx1, u32 idx2, bool swapNames=true) = 0;


                virtual io::IAttributes* createAttributesFromMaterial(const video::SMaterial& material,
                        io::SAttributeReadWriteOptions* options=0) =0;


                virtual void fillMaterialStructureFromAttributes(video::SMaterial& outMaterial, io::IAttributes* attributes) =0;


                virtual const SExposedVideoData& getExposedVideoData() =0;


                virtual E_DRIVER_TYPE getDriverType() const =0;


                virtual IGPUProgrammingServices* getGPUProgrammingServices() =0;

                virtual scene::IMeshManipulator* getMeshManipulator() =0;

                virtual void clearBuffers(u16 flag, SColor color = SColor(255,0,0,0), f32 depth = 1.f, u8 stencil = 0) = 0;

                _IRR_DEPRECATED_ void clearBuffers(bool backBuffer, bool depthBuffer, bool stencilBuffer, SColor color)
                {
                        u16 flag = 0;

                        if (backBuffer)
                                flag |= ECBF_COLOR;

                        if (depthBuffer)
                                flag |= ECBF_DEPTH;

                        if (stencilBuffer)
                                flag |= ECBF_STENCIL;

                        clearBuffers(flag, color);
                }


                _IRR_DEPRECATED_ void clearZBuffer()
                {
                        clearBuffers(ECBF_DEPTH, SColor(255,0,0,0), 1.f, 0);
                }


                virtual IImage* createScreenShot(video::ECOLOR_FORMAT format=video::ECF_UNKNOWN, video::E_RENDER_TARGET target=video::ERT_FRAME_BUFFER) =0;


                virtual video::ITexture* findTexture(const io::path& filename) = 0;


                virtual bool setClipPlane(u32 index, const core::plane3df& plane, bool enable=false) =0;


                virtual void enableClipPlane(u32 index, bool enable) =0;


                virtual void setMinHardwareBufferVertexCount(u32 count) =0;


                virtual SOverrideMaterial& getOverrideMaterial() =0;


                virtual SMaterial& getMaterial2D() =0;


                virtual void enableMaterial2D(bool enable=true) =0;

                virtual core::stringc getVendorInfo() =0;


                virtual void setAmbientLight(const SColorf& color) =0;

                virtual const SColorf& getAmbientLight() const = 0;


                virtual void setAllowZWriteOnTransparent(bool flag) =0;

                virtual core::dimension2du getMaxTextureSize() const =0;


                virtual void convertColor(const void* sP, ECOLOR_FORMAT sF, s32 sN,
                                void* dP, ECOLOR_FORMAT dF) const =0;


                virtual bool queryTextureFormat(ECOLOR_FORMAT format) const = 0;

                virtual bool needsTransparentRenderPass(const irr::video::SMaterial& material) const = 0;

                // 2021_10_4 By Oil GPU operations
                virtual bool removeMaterialRenderer(u32 idx) { return false; }

                enum E_SHADER_VAR_TYPE
                {
                        ESVT_INT32 = 0,
                        ESVT_FLOAT32,
                        ESVT_VEC2,
                        ESVT_VEC3,
                        ESVT_VEC4,
                        ESVT_MAT4,
                        ESVT_COUNT
                };
                struct SShaderConstant
                {
                        SShaderConstant(const irr::core::stringc& name = irr::core::stringc(), E_SHADER_VAR_TYPE type = ESVT_FLOAT32, const void* data = 0)
                        {
                                Type = type;
                                Name = name;
                                Data = data;
                                ID = -1;
                        }
                        bool isOk() const
                        {
                                return ID > -1 && Data && !Name.empty() ? true : false;
                        }
                        bool operator==( const struct SShaderConstant& other ) const
                        {
                                if( Name == other.Name && !Name.empty() && !other.Name.empty() )
                                        return true;

                                return false;
                        }

                        E_SHADER_VAR_TYPE Type;
                        irr::s32 ID;
                        irr::core::stringc Name;
                        const void* Data; // ref only
                };
                virtual void addShaderConstant( const SShaderConstant& value ) { }
                virtual SShaderConstant* getShaderConstant(irr::u32 num) { return 0; }
                virtual void clearShaderConstant() { }
                virtual irr::u32 getShaderConstantSize() const { return 0; }

                // 2016_1_5 By Oil setArea
                // 2016_1_1 By Oil setVirtualScreenSize
                // 2015_7_6 By Oil 
                virtual void setVirtualScreenSize(const core::dimension2du& size) { }
                virtual core::dimension2du getVirtualScreenSize() const { return core::dimension2du(0, 0); }
#if defined(__WIN32__)
                virtual void setArea(int offset_x, int offset_y, const core::dimension2du& size, const core::dimension2du& max_size) { }
                virtual core::vector2di getAreaOffset() const { return core::vector2di(0, 0); }
                virtual core::dimension2du getAreaSize() const { return core::dimension2du(0, 0); }
                virtual core::dimension2du getAreaMax() const { return core::dimension2du(0, 0); }
#endif // __WIN32__

        };

} // end namespace video
} // end namespace irr


#endif