IVideoDriver.h

// 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 "SMaterial.h"
#include "IMeshBuffer.h"
#include "triangle3d.h"
#include "EDriverTypes.h"
#include "EDriverFeatures.h"
#include "SExposedVideoData.h"
 
#include "IHardwareBuffer.h"
#include "IRWBuffer.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
{
    class IVertexDescriptor;
    struct S3DVertex;
    struct S3DVertex2TCoords;
    struct S3DVertexTangents;
    struct SLight;
    class IImageLoader;
    class IImageWriter;
    class IMaterialRenderer;
    class IGPUProgrammingServices;

    enum E_TRANSFORMATION_STATE
    {
        ETS_VIEW = 0,
        ETS_WORLD,
        ETS_PROJECTION,
        ETS_WORLD_INVERSE,
        ETS_WORLD_INVERSE_TRANSPOSE,
        ETS_VIEW_PROJECTION,
        ETS_WORLD_VIEW_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,
#if _IRR_MATERIAL_MAX_TEXTURES_>8
        ETS_TEXTURE_8,
#if _IRR_MATERIAL_MAX_TEXTURES_>9
        ETS_TEXTURE_9,
#if _IRR_MATERIAL_MAX_TEXTURES_>10
        ETS_TEXTURE_10,
#if _IRR_MATERIAL_MAX_TEXTURES_>11
        ETS_TEXTURE_11,
#if _IRR_MATERIAL_MAX_TEXTURES_>12
        ETS_TEXTURE_12,
#if _IRR_MATERIAL_MAX_TEXTURES_>13
        ETS_TEXTURE_13,
#if _IRR_MATERIAL_MAX_TEXTURES_>14
        ETS_TEXTURE_14,
#if _IRR_MATERIAL_MAX_TEXTURES_>15
        ETS_TEXTURE_15,
#if _IRR_MATERIAL_MAX_TEXTURES_>16
        ETS_TEXTURE_16,
#if _IRR_MATERIAL_MAX_TEXTURES_>17
        ETS_TEXTURE_17,
#if _IRR_MATERIAL_MAX_TEXTURES_>18
        ETS_TEXTURE_18,
#if _IRR_MATERIAL_MAX_TEXTURES_>19
        ETS_TEXTURE_19,
#if _IRR_MATERIAL_MAX_TEXTURES_>20
        ETS_TEXTURE_20,
#if _IRR_MATERIAL_MAX_TEXTURES_>21
        ETS_TEXTURE_21,
#if _IRR_MATERIAL_MAX_TEXTURES_>22
        ETS_TEXTURE_22,
#if _IRR_MATERIAL_MAX_TEXTURES_>23
        ETS_TEXTURE_23,
#if _IRR_MATERIAL_MAX_TEXTURES_>24
        ETS_TEXTURE_24,
#if _IRR_MATERIAL_MAX_TEXTURES_>25
        ETS_TEXTURE_25,
#if _IRR_MATERIAL_MAX_TEXTURES_>26
        ETS_TEXTURE_26,
#if _IRR_MATERIAL_MAX_TEXTURES_>27
        ETS_TEXTURE_27,
#if _IRR_MATERIAL_MAX_TEXTURES_>28
        ETS_TEXTURE_28,
#if _IRR_MATERIAL_MAX_TEXTURES_>29
        ETS_TEXTURE_29,
#if _IRR_MATERIAL_MAX_TEXTURES_>30
        ETS_TEXTURE_30,
#if _IRR_MATERIAL_MAX_TEXTURES_>31
        ETS_TEXTURE_31,
 
 
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
        ETS_COUNT
    };


    enum E_LOST_RESOURCE
    {
        ELR_DEVICE = 1,
        ELR_TEXTURES = 2,
        ELR_RTTS = 4,
        ELR_HW_BUFFERS = 8
    };


    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_FOG_TYPE
    {
        EFT_FOG_EXP=0,
        EFT_FOG_LINEAR,
        EFT_FOG_EXP2
    };
 
    const c8* const FogTypeNames[] =
    {
        "FogExp",
        "FogLinear",
        "FogExp2",
        0
    };
 
 
    enum E_CUBEMAP_FACE
    {
        ECUBE_LEFT = 0,
        ECUBE_RIGHT,
        ECUBE_UP,
        ECUBE_DOWN,
        ECUBE_FRONT,
        ECUBE_BACK
    };
 
    struct SOverrideMaterial
    {
        SMaterial Material;

        u32 EnableFlags;

        u16 EnablePasses;

        bool Enabled;

        SOverrideMaterial() : EnableFlags(0), EnablePasses(0), Enabled(false) {}

        void apply(SMaterial& material)
        {
            if (Enabled)
            {
                for (u32 i=0; i<32; ++i)
                {
                    const u32 num=(1<<i);
                    if (EnableFlags & num)
                    {
                        switch (num)
                        {
                        case EMF_WIREFRAME: material.Wireframe = Material.Wireframe; break;
                        case EMF_POINTCLOUD: material.PointCloud = Material.PointCloud; break;
                        case EMF_GOURAUD_SHADING: material.GouraudShading = Material.GouraudShading; break;
                        case EMF_LIGHTING: material.Lighting = Material.Lighting; break;
                        case EMF_ZBUFFER: material.ZBuffer = Material.ZBuffer; break;
                        case EMF_ZWRITE_ENABLE: material.ZWriteEnable = Material.ZWriteEnable; break;
                        case EMF_BACK_FACE_CULLING: material.BackfaceCulling = Material.BackfaceCulling; break;
                        case EMF_FRONT_FACE_CULLING: material.FrontfaceCulling = Material.FrontfaceCulling; break;
                        case EMF_BILINEAR_FILTER: material.TextureLayer[0].BilinearFilter = Material.TextureLayer[0].BilinearFilter; break;
                        case EMF_TRILINEAR_FILTER: material.TextureLayer[0].TrilinearFilter = Material.TextureLayer[0].TrilinearFilter; break;
                        case EMF_ANISOTROPIC_FILTER: material.TextureLayer[0].AnisotropicFilter = Material.TextureLayer[0].AnisotropicFilter; break;
                        case EMF_FOG_ENABLE: material.FogEnable = Material.FogEnable; break;
                        case EMF_NORMALIZE_NORMALS: material.NormalizeNormals = Material.NormalizeNormals; break;
                        case EMF_TEXTURE_WRAP:
                            material.TextureLayer[0].TextureWrapU = Material.TextureLayer[0].TextureWrapU;
                            material.TextureLayer[0].TextureWrapV = Material.TextureLayer[0].TextureWrapV;
                            break;
                        case EMF_ANTI_ALIASING: material.AntiAliasing = Material.AntiAliasing; break;
                        case EMF_COLOR_MASK: material.ColorMask = Material.ColorMask; break;
                        case EMF_COLOR_MATERIAL: material.ColorMaterial = Material.ColorMaterial; break;
                        case EMF_USE_MIP_MAPS: material.UseMipMaps = Material.UseMipMaps; break;
                        case EMF_BLEND_OPERATION: material.BlendOperation = Material.BlendOperation; break;
                        case EMF_BLEND_FACTOR: material.BlendFactor = Material.BlendFactor; break;
                        case EMF_POLYGON_OFFSET:
                            material.PolygonOffsetDirection = Material.PolygonOffsetDirection;
                            material.PolygonOffsetFactor = Material.PolygonOffsetFactor; break;
                        }
                    }
                }
            }
        }
 
    };
 
    struct IRenderTarget
    {
        IRenderTarget(ITexture* texture,
                E_COLOR_PLANE colorMask=ECP_ALL,
                E_BLEND_FACTOR blendFuncSrc=EBF_ONE,
                E_BLEND_FACTOR blendFuncDst=EBF_ONE_MINUS_SRC_ALPHA,
                E_BLEND_OPERATION blendOp=EBO_NONE) :
            RenderTexture(texture),
            TargetType(ERT_RENDER_TEXTURE), ColorMask(colorMask),
            BlendFuncSrc(blendFuncSrc), BlendFuncDst(blendFuncDst),
            BlendOp(blendOp) {}
        IRenderTarget(E_RENDER_TARGET target,
                E_COLOR_PLANE colorMask=ECP_ALL,
                E_BLEND_FACTOR blendFuncSrc=EBF_ONE,
                E_BLEND_FACTOR blendFuncDst=EBF_ONE_MINUS_SRC_ALPHA,
                E_BLEND_OPERATION blendOp=EBO_NONE) :
            RenderTexture(0),
            TargetType(target), ColorMask(colorMask),
            BlendFuncSrc(blendFuncSrc), BlendFuncDst(blendFuncDst),
            BlendOp(blendOp) {}
        bool operator!=(const IRenderTarget& other) const
        {
            return ((RenderTexture != other.RenderTexture) ||
                (TargetType != other.TargetType) ||
                (ColorMask != other.ColorMask) ||
                (BlendFuncSrc != other.BlendFuncSrc) ||
                (BlendFuncDst != other.BlendFuncDst) ||
                (BlendOp != other.BlendOp));
        }
        ITexture* RenderTexture;
        E_RENDER_TARGET TargetType:8;
        E_COLOR_PLANE ColorMask:8;
        E_BLEND_FACTOR BlendFuncSrc:4;
        E_BLEND_FACTOR BlendFuncDst:4;
        E_BLEND_OPERATION BlendOp:4;
    };
 
    class IVideoRenderTarget : public virtual IReferenceCounted
    {
    public:
        virtual u32 getWidth() = 0;
 
        virtual u32 getHeight() = 0;
 
        virtual void resize(u32 w, u32 h) = 0;
    };


    class IVideoDriver : public virtual IReferenceCounted
    {
    public:


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


        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 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* getTextureCube(
            const io::path& filenameX1,
            const io::path& filenameX2,
            const io::path& filenameY1,
            const io::path& filenameY2,
            const io::path& filenameZ1,
            const io::path& filenameZ2) = 0;
 
        virtual ITexture* getTextureCube(
            IImage *imageX1,
            IImage *imageX2,
            IImage *imageY1,
            IImage *imageY2,
            IImage *imageZ1,
            IImage *imageZ2) = 0;
 
        virtual ITexture* getTextureArray(core::array<io::path>& files) = 0;
        virtual ITexture* getTextureArray(IImage** images, u32 num) = 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;


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


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

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

        // Add FBO Array Texture
        virtual ITexture* addRenderTargetTextureArray(const core::dimension2d<u32>& size, u32 arraySize,
            const io::path& name = "rt", const ECOLOR_FORMAT format = ECF_UNKNOWN) = 0;

        virtual IVideoRenderTarget* addVideoRenderTarget(void *hwnd, u32 w, u32 h) = 0;
 
        virtual void removeVideoRenderTarget(IVideoRenderTarget* vrt) = 0;
 
        virtual void setVideoRenderTarget(IVideoRenderTarget* vrt) = 0;


        virtual void removeTexture(ITexture* texture) =0;


        virtual void removeAllTextures() =0;
 
        virtual IHardwareBuffer* createHardwareBuffer(scene::IIndexBuffer* indexBuffer) = 0;
 
        virtual IHardwareBuffer* createHardwareBuffer(scene::IVertexBuffer* vertexBuffer) = 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 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 setRenderTarget(video::ITexture* texture,
            bool clearBackBuffer=true, bool clearZBuffer=true,
            SColor color=video::SColor(0,0,0,0),
            video::ITexture* depthStencil = 0) =0;
        
        virtual bool setRenderTarget(video::ITexture* texture,
            video::ITexture* depthStencil,
            bool clearBackBuffer=true, bool clearZBuffer=true,
            SColor color=video::SColor(0,0,0,0))
        {
            return setRenderTarget(texture, clearBackBuffer, clearZBuffer, color, depthStencil);
        }

        virtual bool setRenderTarget(const core::array<video::IRenderTarget>& texture,
            bool clearBackBuffer=true, bool clearZBuffer=true,
            SColor color=video::SColor(0,0,0,0),
            video::ITexture* depthStencil = 0) =0;

        virtual bool setRenderTarget(const core::array<video::IRenderTarget>& texture,
            video::ITexture* depthStencil,
            bool clearBackBuffer=true, bool clearZBuffer=true,
            SColor color=video::SColor(0,0,0,0))
        {
            return setRenderTarget(texture, clearBackBuffer, clearZBuffer, color, depthStencil);
        }


        virtual bool setRenderTarget(E_RENDER_TARGET target, bool clearTarget=true,
                    bool clearZBuffer=true,
                    SColor color=video::SColor(0,0,0,0)) =0;
 
        virtual bool setRenderTargetArray(video::ITexture* texture, int arrayID, bool clearTarget = true,
            bool clearZBuffer = true,
            SColor color = video::SColor(0, 0, 0, 0)) = 0;
 
        virtual bool setRenderTargetCube(video::ITexture* texture, E_CUBEMAP_FACE face, bool clearTarget = true,
            bool clearZBuffer = true,
            SColor color = video::SColor(0, 0, 0, 0)) = 0;


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


        virtual const core::rect<s32>& getViewPort() const = 0;     
 
        virtual void setScissor(const core::rect<s32>& area) = 0;
 
        virtual const core::rect<s32>& getScissor() const = 0;
 
        virtual void enableScissor(bool b) = 0;


        virtual void draw3DLine(const core::vector3df& start,
            const core::vector3df& end, SColor color = SColor(255,255,255,255)) = 0;
 
        virtual void draw3DLine(const core::array<core::vector3df>& listPoint, SColor color) = 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 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 bool isMaterialTransparent(const SMaterial& material) = 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 s32 getTextureChange() const = 0;
        virtual s32 getDrawCall() const = 0;


        virtual u32 getPrimitiveCountDrawn( u32 mode =0 ) const =0;
        virtual u32 getTextureChangeCount(u32 param) 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 IImage* createImageFromFile(const io::path& filename) = 0;


        virtual IImage* createImageFromFile(io::IReadFile* file) =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 IRWBuffer* createRWBuffer(video::ECOLOR_FORMAT format, u32 numElements, void *initialData = NULL) = 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) =0;


        virtual u32 getMaterialRendererCount() const =0;


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


        virtual void setMaterialRendererName(s32 idx, const c8* name) =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 clearZBuffer() =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 core::stringc getVendorInfo() =0;
        virtual core::stringc getGPUName() = 0;


        virtual void setAmbientLight(const SColorf& color) =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 IVertexDescriptor* addVertexDescriptor(const core::stringc& pName) = 0;
 
        virtual IVertexDescriptor* getVertexDescriptor(u32 id) const = 0;
 
        virtual IVertexDescriptor* getVertexDescriptor(const core::stringc& pName) const = 0;
 
        virtual u32 getVertexDescriptorCount() const = 0;
        
        virtual void setDefaultFrameBuffer(int framebuffer) = 0;
        
        virtual int getDefaultFrameBuffer() = 0;

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

        virtual const core::matrix4& getTransform(E_TRANSFORMATION_STATE state) const = 0;
    };
 
} // end namespace video
} // end namespace irr
 
 
#endif