Irrlicht Engine: IVideoDriver.h Source File

Home | Namespaces | Hierarchy | Alphabetical List | Class list | Files | Namespace Members | Class members | File members | Tutorials

# IVideoDriver.h

Go to the documentation of this file.

    00001 // Copyright (C) 2002-2010 Nikolaus Gebhardt
    00002 // This file is part of the "Irrlicht Engine".
    00003 // For conditions of distribution and use, see copyright notice in irrlicht.h
    00004
    00005 #ifndef __IRR_I_VIDEO_DRIVER_H_INCLUDED__
    00006 #define __IRR_I_VIDEO_DRIVER_H_INCLUDED__
    00007
    00008 #include "rect.h"
    00009 #include "SColor.h"
    00010 #include "ITexture.h"
    00011 #include "irrArray.h"
    00012 #include "matrix4.h"
    00013 #include "plane3d.h"
    00014 #include "dimension2d.h"
    00015 #include "position2d.h"
    00016 #include "SMaterial.h"
    00017 #include "IMeshBuffer.h"
    00018 #include "triangle3d.h"
    00019 #include "EDriverTypes.h"
    00020 #include "EDriverFeatures.h"
    00021 #include "SExposedVideoData.h"
    00022
    00023 namespace irr
    00024 {
    00025 namespace io
    00026 {
    00027         class IAttributes;
    00028         class IReadFile;
    00029         class IWriteFile;
    00030 } // end namespace io
    00031 namespace scene
    00032 {
    00033         class IMeshBuffer;
    00034         class IMeshManipulator;
    00035 } // end namespace scene
    00036
    00037 namespace video
    00038 {
    00039         struct S3DVertex;
    00040         struct S3DVertex2TCoords;
    00041         struct S3DVertexTangents;
    00042         struct SLight;
    00043         class IImageLoader;
    00044         class IImageWriter;
    00045         class IMaterialRenderer;
    00046         class IGPUProgrammingServices;
    00047
    00049         enum E_TRANSFORMATION_STATE
    00050         {
    00052                 ETS_VIEW = 0,
    00054                 ETS_WORLD,
    00056                 ETS_PROJECTION,
    00058                 ETS_TEXTURE_0,
    00060                 ETS_TEXTURE_1,
    00062                 ETS_TEXTURE_2,
    00064                 ETS_TEXTURE_3,
    00065 #if _IRR_MATERIAL_MAX_TEXTURES_>4
    00067                 ETS_TEXTURE_4,
    00068 #if _IRR_MATERIAL_MAX_TEXTURES_>5
    00070                 ETS_TEXTURE_5,
    00071 #if _IRR_MATERIAL_MAX_TEXTURES_>6
    00073                 ETS_TEXTURE_6,
    00074 #if _IRR_MATERIAL_MAX_TEXTURES_>7
    00076                 ETS_TEXTURE_7,
    00077 #endif
    00078 #endif
    00079 #endif
    00080 #endif
    00082                 ETS_COUNT
    00083         };
    00084
    00086
    00089         enum E_LOST_RESSOURCE
    00090         {
    00092                 ELR_DEVICE = 1,
    00094                 ELR_TEXTURES = 2,
    00096                 ELR_RTTS = 4,
    00098                 ELR_HW_BUFFERS = 8
    00099         };
    00100
    00102
    00103         enum E_RENDER_TARGET
    00104         {
    00106                 ERT_FRAME_BUFFER=0,
    00108                 ERT_RENDER_TEXTURE,
    00110                 ERT_MULTI_RENDER_TEXTURES,
    00112                 ERT_STEREO_LEFT_BUFFER,
    00114                 ERT_STEREO_RIGHT_BUFFER,
    00116                 ERT_STEREO_BOTH_BUFFERS,
    00118                 ERT_AUX_BUFFER0,
    00120                 ERT_AUX_BUFFER1,
    00122                 ERT_AUX_BUFFER2,
    00124                 ERT_AUX_BUFFER3,
    00126                 ERT_AUX_BUFFER4
    00127         };
    00128
    00130         enum E_FOG_TYPE
    00131         {
    00132                 EFT_FOG_EXP=0,
    00133                 EFT_FOG_LINEAR,
    00134                 EFT_FOG_EXP2
    00135         };
    00136
    00137         const c8* const FogTypeNames[] =
    00138         {
    00139                 "FogExp",
    00140                 "FogLinear",
    00141                 "FogExp2",
    00142                 0
    00143         };
    00144
    00145         struct SOverrideMaterial
    00146         {
    00148                 SMaterial Material;
    00150
    00151                 u32 EnableFlags;
    00153
    00154                 u16 EnablePasses;
    00156
    00158                 bool Enabled;
    00159
    00161                 SOverrideMaterial() : EnableFlags(0), EnablePasses(0), Enabled(false) {}
    00162
    00164                 void apply(SMaterial& material)
    00165                 {
    00166                         if (Enabled)
    00167                         {
    00168                                 for (u32 i=0; i<32; ++i)
    00169                                 {
    00170                                         const u32 num=(1<<i);
    00171                                         if (EnableFlags & num)
    00172                                         {
    00173                                                 switch (num)
    00174                                                 {
    00175                                                 case EMF_WIREFRAME: material.Wireframe = Material.Wireframe; break;
    00176                                                 case EMF_POINTCLOUD: material.PointCloud = Material.PointCloud; break;
    00177                                                 case EMF_GOURAUD_SHADING: material.GouraudShading = Material.GouraudShading; break;
    00178                                                 case EMF_LIGHTING: material.Lighting = Material.Lighting; break;
    00179                                                 case EMF_ZBUFFER: material.ZBuffer = Material.ZBuffer; break;
    00180                                                 case EMF_ZWRITE_ENABLE: material.ZWriteEnable = Material.ZWriteEnable; break;
    00181                                                 case EMF_BACK_FACE_CULLING: material.BackfaceCulling = Material.BackfaceCulling; break;
    00182                                                 case EMF_FRONT_FACE_CULLING: material.FrontfaceCulling = Material.FrontfaceCulling; break;
    00183                                                 case EMF_FOG_ENABLE: material.FogEnable = Material.FogEnable; break;
    00184                                                 case EMF_NORMALIZE_NORMALS: material.NormalizeNormals = Material.NormalizeNormals; break;
    00185                                                 case EMF_ANTI_ALIASING: material.AntiAliasing = Material.AntiAliasing; break;
    00186                                                 case EMF_COLOR_MASK: material.ColorMask = Material.ColorMask; break;
    00187                                                 case EMF_BILINEAR_FILTER: material.TextureLayer[0].BilinearFilter = Material.TextureLayer[0].BilinearFilter; break;
    00188                                                 case EMF_TRILINEAR_FILTER: material.TextureLayer[0].TrilinearFilter = Material.TextureLayer[0].TrilinearFilter; break;
    00189                                                 case EMF_ANISOTROPIC_FILTER: material.TextureLayer[0].AnisotropicFilter = Material.TextureLayer[0].AnisotropicFilter; break;
    00190                                                 case EMF_TEXTURE_WRAP:
    00191                                                         material.TextureLayer[0].TextureWrapU = Material.TextureLayer[0].TextureWrapU;
    00192                                                         material.TextureLayer[0].TextureWrapV = Material.TextureLayer[0].TextureWrapV;
    00193                                                         break;
    00194                                                 }
    00195                                         }
    00196                                 }
    00197                         }
    00198                 }
    00199
    00200         };
    00201
    00202         struct IRenderTarget
    00203         {
    00204                 IRenderTarget(ITexture* texture,
    00205                                 E_COLOR_PLANE colorMask=ECP_ALL,
    00206                                 E_BLEND_FACTOR blendFuncSrc=EBF_ONE,
    00207                                 E_BLEND_FACTOR blendFuncDst=EBF_ONE_MINUS_SRC_ALPHA,
    00208                                 bool blendEnable=false) :
    00209                         RenderTexture(texture),
    00210                         TargetType(ERT_RENDER_TEXTURE), ColorMask(colorMask),
    00211                         BlendFuncSrc(blendFuncSrc), BlendFuncDst(blendFuncDst),
    00212                         BlendEnable(blendEnable) {}
    00213                 IRenderTarget(E_RENDER_TARGET target,
    00214                                 E_COLOR_PLANE colorMask=ECP_ALL,
    00215                                 E_BLEND_FACTOR blendFuncSrc=EBF_ONE,
    00216                                 E_BLEND_FACTOR blendFuncDst=EBF_ONE_MINUS_SRC_ALPHA,
    00217                                 bool blendEnable=false) :
    00218                         RenderTexture(0),
    00219                         TargetType(target), ColorMask(colorMask),
    00220                         BlendFuncSrc(blendFuncSrc), BlendFuncDst(blendFuncDst),
    00221                         BlendEnable(blendEnable) {}
    00222                 ITexture* RenderTexture;
    00223                 E_RENDER_TARGET TargetType:8;
    00224                 E_COLOR_PLANE ColorMask:8;
    00225                 E_BLEND_FACTOR BlendFuncSrc:4;
    00226                 E_BLEND_FACTOR BlendFuncDst:4;
    00227                 bool BlendEnable;
    00228         };
    00229
    00231
    00238         class IVideoDriver : public virtual IReferenceCounted
    00239         {
    00240         public:
    00241
    00243
    00260                 virtual bool beginScene(bool backBuffer=true, bool zBuffer=true,
    00261                                 SColor color=SColor(255,0,0,0),
    00262                                 const SExposedVideoData& videoData=SExposedVideoData(),
    00263                                 core::rect<s32>* sourceRect=0) =0;
    00264
    00266
    00269                 virtual bool endScene() =0;
    00270
    00272
    00275                 virtual bool queryFeature(E_VIDEO_DRIVER_FEATURE feature) const =0;
    00276
    00278
    00282                 virtual void disableFeature(E_VIDEO_DRIVER_FEATURE feature, bool flag=true) =0;
    00283
    00285
    00288                 virtual bool checkDriverReset() =0;
    00289
    00291
    00294                 virtual void setTransform(E_TRANSFORMATION_STATE state, const core::matrix4& mat) =0;
    00295
    00297
    00299                 virtual const core::matrix4& getTransform(E_TRANSFORMATION_STATE state) const =0;
    00300
    00302
    00303                 virtual u32 getImageLoaderCount() const = 0;
    00304
    00306
    00309                 virtual IImageLoader* getImageLoader(u32 n) = 0;
    00310
    00312
    00313                 virtual u32 getImageWriterCount() const = 0;
    00314
    00316
    00319                 virtual IImageWriter* getImageWriter(u32 n) = 0;
    00320
    00322
    00324                 virtual void setMaterial(const SMaterial& material) =0;
    00325
    00327
    00336                 virtual ITexture* getTexture(const io::path& filename) = 0;
    00337
    00339
    00348                 virtual ITexture* getTexture(io::IReadFile* file) =0;
    00349
    00351
    00357                 virtual ITexture* getTextureByIndex(u32 index) =0;
    00358
    00360
    00361                 virtual u32 getTextureCount() const = 0;
    00362
    00364
    00366                 virtual void renameTexture(ITexture* texture, const io::path& newName) = 0;
    00367
    00369
    00378                 virtual ITexture* addTexture(const core::dimension2d<u32>& size,
    00379                         const io::path& name, ECOLOR_FORMAT format = ECF_A8R8G8B8) = 0;
    00380
    00382
    00392                 virtual ITexture* addTexture(const io::path& name, IImage* image, void* mipmapData=0) = 0;
    00393
    00395
    00404                 virtual ITexture* addRenderTargetTexture(const core::dimension2d<u32>& size,
    00405                                 const io::path& name = "rt", const ECOLOR_FORMAT format = ECF_UNKNOWN) =0;
    00406
    00408
    00415                 virtual void removeTexture(ITexture* texture) =0;
    00416
    00418
    00424                 virtual void removeAllTextures() =0;
    00425
    00427                 virtual void removeHardwareBuffer(const scene::IMeshBuffer* mb) =0;
    00428
    00430                 virtual void removeAllHardwareBuffers() =0;
    00431
    00433
    00448                 virtual void makeColorKeyTexture(video::ITexture* texture,
    00449                                                 video::SColor color,
    00450                                                 bool zeroTexels = false) const =0;
    00451
    00453
    00464                 virtual void makeColorKeyTexture(video::ITexture* texture,
    00465                                 core::position2d<s32> colorKeyPixelPos,
    00466                                 bool zeroTexels = false) const =0;
    00467
    00469
    00476                 virtual void makeNormalMapTexture(video::ITexture* texture, f32 amplitude=1.0f) const =0;
    00477
    00479
    00510                 virtual bool setRenderTarget(video::ITexture* texture,
    00511                         bool clearBackBuffer=true, bool clearZBuffer=true,
    00512                         SColor color=video::SColor(0,0,0,0)) =0;
    00513
    00515
    00526                 virtual bool setRenderTarget(E_RENDER_TARGET target, bool clearTarget=true,
    00527                                         bool clearZBuffer=true,
    00528                                         SColor color=video::SColor(0,0,0,0)) =0;
    00529
    00531                 virtual bool setRenderTarget(const core::array<video::IRenderTarget>& texture,
    00532                         bool clearBackBuffer=true, bool clearZBuffer=true,
    00533                         SColor color=video::SColor(0,0,0,0)) =0;
    00534
    00536
    00539                 virtual void setViewPort(const core::rect<s32>& area) =0;
    00540
    00542
    00543                 virtual const core::rect<s32>& getViewPort() const =0;
    00544
    00546
    00560                 virtual void drawVertexPrimitiveList(const void* vertices, u32 vertexCount,
    00561                                 const void* indexList, u32 primCount,
    00562                                 E_VERTEX_TYPE vType=EVT_STANDARD,
    00563                                 scene::E_PRIMITIVE_TYPE pType=scene::EPT_TRIANGLES,
    00564                                 E_INDEX_TYPE iType=EIT_16BIT) =0;
    00565
    00567
    00586                 virtual void draw2DVertexPrimitiveList(const void* vertices, u32 vertexCount,
    00587                                 const void* indexList, u32 primCount,
    00588                                 E_VERTEX_TYPE vType=EVT_STANDARD,
    00589                                 scene::E_PRIMITIVE_TYPE pType=scene::EPT_TRIANGLES,
    00590                                 E_INDEX_TYPE iType=EIT_16BIT) =0;
    00591
    00593
    00601                 void drawIndexedTriangleList(const S3DVertex* vertices,
    00602                         u32 vertexCount, const u16* indexList, u32 triangleCount)
    00603                 {
    00604                         drawVertexPrimitiveList(vertices, vertexCount, indexList, triangleCount, EVT_STANDARD, scene::EPT_TRIANGLES, EIT_16BIT);
    00605                 }
    00606
    00608
    00616                 void drawIndexedTriangleList(const S3DVertex2TCoords* vertices,
    00617                         u32 vertexCount, const u16* indexList, u32 triangleCount)
    00618                 {
    00619                         drawVertexPrimitiveList(vertices, vertexCount, indexList, triangleCount, EVT_2TCOORDS, scene::EPT_TRIANGLES, EIT_16BIT);
    00620                 }
    00621
    00623
    00631                 void drawIndexedTriangleList(const S3DVertexTangents* vertices,
    00632                         u32 vertexCount, const u16* indexList, u32 triangleCount)
    00633                 {
    00634                         drawVertexPrimitiveList(vertices, vertexCount, indexList, triangleCount, EVT_TANGENTS, scene::EPT_TRIANGLES, EIT_16BIT);
    00635                 }
    00636
    00638
    00646                 void drawIndexedTriangleFan(const S3DVertex* vertices,
    00647                         u32 vertexCount, const u16* indexList, u32 triangleCount)
    00648                 {
    00649                         drawVertexPrimitiveList(vertices, vertexCount, indexList, triangleCount, EVT_STANDARD, scene::EPT_TRIANGLE_FAN, EIT_16BIT);
    00650                 }
    00651
    00653
    00661                 void drawIndexedTriangleFan(const S3DVertex2TCoords* vertices,
    00662                         u32 vertexCount, const u16* indexList, u32 triangleCount)
    00663                 {
    00664                         drawVertexPrimitiveList(vertices, vertexCount, indexList, triangleCount, EVT_2TCOORDS, scene::EPT_TRIANGLE_FAN, EIT_16BIT);
    00665                 }
    00666
    00668
    00676                 void drawIndexedTriangleFan(const S3DVertexTangents* vertices,
    00677                         u32 vertexCount, const u16* indexList, u32 triangleCount)
    00678                 {
    00679                         drawVertexPrimitiveList(vertices, vertexCount, indexList, triangleCount, EVT_TANGENTS, scene::EPT_TRIANGLE_FAN, EIT_16BIT);
    00680                 }
    00681
    00683
    00697                 virtual void draw3DLine(const core::vector3df& start,
    00698                         const core::vector3df& end, SColor color = SColor(255,255,255,255)) =0;
    00699
    00701
    00714                 virtual void draw3DTriangle(const core::triangle3df& triangle,
    00715                         SColor color = SColor(255,255,255,255)) =0;
    00716
    00718
    00729                 virtual void draw3DBox(const core::aabbox3d<f32>& box,
    00730                         SColor color = SColor(255,255,255,255)) =0;
    00731
    00733
    00736                 virtual void draw2DImage(const video::ITexture* texture,
    00737                         const core::position2d<s32>& destPos) =0;
    00738
    00740
    00755                 virtual void draw2DImage(const video::ITexture* texture, const core::position2d<s32>& destPos,
    00756                         const core::rect<s32>& sourceRect, const core::rect<s32>* clipRect =0,
    00757                         SColor color=SColor(255,255,255,255), bool useAlphaChannelOfTexture=false) =0;
    00758
    00760
    00779                 virtual void draw2DImageBatch(const video::ITexture* texture,
    00780                                 const core::position2d<s32>& pos,
    00781                                 const core::array<core::rect<s32> >& sourceRects,
    00782                                 const core::array<s32>& indices,
    00783                                 s32 kerningWidth=0,
    00784                                 const core::rect<s32>* clipRect=0,
    00785                                 SColor color=SColor(255,255,255,255),
    00786                                 bool useAlphaChannelOfTexture=false) =0;
    00787
    00789
    00804                 virtual void draw2DImageBatch(const video::ITexture* texture,
    00805                                 const core::array<core::position2d<s32> >& positions,
    00806                                 const core::array<core::rect<s32> >& sourceRects,
    00807                                 const core::rect<s32>* clipRect=0,
    00808                                 SColor color=SColor(255,255,255,255),
    00809                                 bool useAlphaChannelOfTexture=false) =0;
    00810
    00812
    00821                 virtual void draw2DImage(const video::ITexture* texture, const core::rect<s32>& destRect,
    00822                         const core::rect<s32>& sourceRect, const core::rect<s32>* clipRect =0,
    00823                         const video::SColor * const colors=0, bool useAlphaChannelOfTexture=false) =0;
    00824
    00826
    00833                 virtual void draw2DRectangle(SColor color, const core::rect<s32>& pos,
    00834                         const core::rect<s32>* clip =0) =0;
    00835
    00837
    00853                 virtual void draw2DRectangle(const core::rect<s32>& pos,
    00854                                 SColor colorLeftUp, SColor colorRightUp,
    00855                                 SColor colorLeftDown, SColor colorRightDown,
    00856                                 const core::rect<s32>* clip =0) =0;
    00857
    00859
    00862                 virtual void draw2DRectangleOutline(const core::recti& pos,
    00863                                 SColor color=SColor(255,255,255,255)) =0;
    00864
    00866
    00871                 virtual void draw2DLine(const core::position2d<s32>& start,
    00872                                         const core::position2d<s32>& end,
    00873                                         SColor color=SColor(255,255,255,255)) =0;
    00874
    00876
    00879                 virtual void drawPixel(u32 x, u32 y, const SColor& color) =0;
    00880
    00882
    00894                 virtual void draw2DPolygon(core::position2d<s32> center,
    00895                                 f32 radius,
    00896                                 video::SColor color=SColor(100,255,255,255),
    00897                                 s32 vertexCount=10) =0;
    00898
    00900
    00911                 virtual void drawStencilShadowVolume(const core::vector3df* triangles, s32 count, bool zfail=true) =0;
    00912
    00914
    00933                 virtual void drawStencilShadow(bool clearStencilBuffer=false,
    00934                         video::SColor leftUpEdge = video::SColor(255,0,0,0),
    00935                         video::SColor rightUpEdge = video::SColor(255,0,0,0),
    00936                         video::SColor leftDownEdge = video::SColor(255,0,0,0),
    00937                         video::SColor rightDownEdge = video::SColor(255,0,0,0)) =0;
    00938
    00940
    00941                 virtual void drawMeshBuffer(const scene::IMeshBuffer* mb) =0;
    00942
    00944
    00960                 virtual void setFog(SColor color=SColor(0,255,255,255),
    00961                                 E_FOG_TYPE fogType=EFT_FOG_LINEAR,
    00962                                 f32 start=50.0f, f32 end=100.0f, f32 density=0.01f,
    00963                                 bool pixelFog=false, bool rangeFog=false) =0;
    00964
    00966                 virtual void getFog(SColor& color, E_FOG_TYPE& fogType,
    00967                                 f32& start, f32& end, f32& density,
    00968                                 bool& pixelFog, bool& rangeFog) = 0;
    00969
    00971
    00972                 virtual ECOLOR_FORMAT getColorFormat() const =0;
    00973
    00975
    00976                 virtual const core::dimension2d<u32>& getScreenSize() const =0;
    00977
    00979
    00983                 virtual const core::dimension2d<u32>& getCurrentRenderTargetSize() const =0;
    00984
    00986
    00991                 virtual s32 getFPS() const =0;
    00992
    00994
    00998                 virtual u32 getPrimitiveCountDrawn( u32 mode =0 ) const =0;
    00999
    01001                 virtual void deleteAllDynamicLights() =0;
    01002
    01006                 virtual s32 addDynamicLight(const SLight& light) =0;
    01007
    01009
    01010                 virtual u32 getMaximalDynamicLightAmount() const =0;
    01011
    01013
    01014                 virtual u32 getDynamicLightCount() const =0;
    01015
    01017
    01020                 virtual const SLight& getDynamicLight(u32 idx) const =0;
    01021
    01025                 virtual void turnLightOn(s32 lightIndex, bool turnOn) =0;
    01026
    01028
    01030                 virtual const wchar_t* getName() const =0;
    01031
    01033
    01039                 virtual void addExternalImageLoader(IImageLoader* loader) =0;
    01040
    01042
    01048                 virtual void addExternalImageWriter(IImageWriter* writer) =0;
    01049
    01051
    01054                 virtual u32 getMaximalPrimitiveCount() const =0;
    01055
    01057
    01066                 virtual void setTextureCreationFlag(E_TEXTURE_CREATION_FLAG flag, bool enabled=true) =0;
    01067
    01069
    01072                 virtual bool getTextureCreationFlag(E_TEXTURE_CREATION_FLAG flag) const =0;
    01073
    01075
    01083                 virtual IImage* createImageFromFile(const io::path& filename) = 0;
    01084
    01086
    01093                 virtual IImage* createImageFromFile(io::IReadFile* file) =0;
    01094
    01096
    01103                 virtual bool writeImageToFile(IImage* image, const io::path& filename, u32 param = 0) = 0;
    01104
    01106
    01114                 virtual bool writeImageToFile(IImage* image, io::IWriteFile* file, u32 param =0) =0;
    01115
    01117
    01131                 virtual IImage* createImageFromData(ECOLOR_FORMAT format,
    01132                         const core::dimension2d<u32>& size, void *data,
    01133                         bool ownForeignMemory=false,
    01134                         bool deleteMemory = true) =0;
    01135
    01137
    01143                 virtual IImage* createImage(ECOLOR_FORMAT format, const core::dimension2d<u32>& size) =0;
    01144
    01146
    01152                 virtual IImage* createImage(ECOLOR_FORMAT format, IImage *imageToCopy) =0;
    01153
    01155
    01162                 virtual IImage* createImage(IImage* imageToCopy,
    01163                                 const core::position2d<s32>& pos,
    01164                                 const core::dimension2d<u32>& size) =0;
    01165
    01167
    01174                 virtual IImage* createImage(ITexture* texture,
    01175                                 const core::position2d<s32>& pos,
    01176                                 const core::dimension2d<u32>& size) =0;
    01177
    01179
    01181                 virtual void OnResize(const core::dimension2d<u32>& size) =0;
    01182
    01184
    01204                 virtual s32 addMaterialRenderer(IMaterialRenderer* renderer, const c8* name =0) =0;
    01205
    01207
    01211                 virtual IMaterialRenderer* getMaterialRenderer(u32 idx) =0;
    01212
    01214
    01215                 virtual u32 getMaterialRendererCount() const =0;
    01216
    01218
    01227                 virtual const c8* getMaterialRendererName(u32 idx) const =0;
    01228
    01230
    01235                 virtual void setMaterialRendererName(s32 idx, const c8* name) =0;
    01236
    01238
    01245                 virtual io::IAttributes* createAttributesFromMaterial(const video::SMaterial& material) =0;
    01246
    01248
    01254                 virtual void fillMaterialStructureFromAttributes(video::SMaterial& outMaterial, io::IAttributes* attributes) =0;
    01255
    01257
    01260                 virtual const SExposedVideoData& getExposedVideoData() =0;
    01261
    01263
    01264                 virtual E_DRIVER_TYPE getDriverType() const =0;
    01265
    01267
    01270                 virtual IGPUProgrammingServices* getGPUProgrammingServices() =0;
    01271
    01273                 virtual scene::IMeshManipulator* getMeshManipulator() =0;
    01274
    01276
    01282                 virtual void clearZBuffer() =0;
    01283
    01285
    01286                 virtual IImage* createScreenShot() =0;
    01287
    01289
    01293                 virtual video::ITexture* findTexture(const io::path& filename) = 0;
    01294
    01296
    01304                 virtual bool setClipPlane(u32 index, const core::plane3df& plane, bool enable=false) =0;
    01305
    01307
    01313                 virtual void enableClipPlane(u32 index, bool enable) =0;
    01314
    01316
    01317                 virtual void setMinHardwareBufferVertexCount(u32 count) =0;
    01318
    01320
    01324                 virtual SOverrideMaterial& getOverrideMaterial() =0;
    01325
    01327
    01340                 virtual SMaterial& getMaterial2D() =0;
    01341
    01343
    01345                 virtual void enableMaterial2D(bool enable=true) =0;
    01346
    01348                 virtual core::stringc getVendorInfo() =0;
    01349
    01351
    01354                 virtual void setAmbientLight(const SColorf& color) =0;
    01355
    01357
    01360                 virtual void setAllowZWriteOnTransparent(bool flag) =0;
    01361
    01363                 virtual core::dimension2du getMaxTextureSize() const =0;
    01364         };
    01365
    01366 } // end namespace video
    01367 } // end namespace irr
    01368
    01369
    01370 #endif
    01371

| The Irrlicht Engine Documentation © 2003-2010 by Nikolaus Gebhardt. Generated on Sun Oct 24 12:41:57 2010 by Doxygen (1.6.2)