1 // Copyright (C) 2002-2012 Nikolaus Gebhardt
\r
2 // This file is part of the "Irrlicht Engine".
\r
3 // For conditions of distribution and use, see copyright notice in irrlicht.h
\r
5 #ifndef __C_VIDEO_NULL_H_INCLUDED__
\r
6 #define __C_VIDEO_NULL_H_INCLUDED__
\r
8 #include "IVideoDriver.h"
\r
9 #include "IFileSystem.h"
\r
10 #include "IGPUProgrammingServices.h"
\r
11 #include "irrArray.h"
\r
12 #include "irrString.h"
\r
13 #include "IAttributes.h"
\r
15 #include "IMeshBuffer.h"
\r
16 #include "IMeshSceneNode.h"
\r
17 #include "CFPSCounter.h"
\r
18 #include "S3DVertex.h"
\r
19 #include "SVertexIndex.h"
\r
20 #include "SExposedVideoData.h"
\r
29 } // end namespace io
\r
35 class CNullDriver : public IVideoDriver, public IGPUProgrammingServices
\r
40 CNullDriver(io::IFileSystem* io, const core::dimension2d<u32>& screenSize);
\r
43 virtual ~CNullDriver();
\r
45 virtual bool beginScene(u16 clearFlag, SColor clearColor = SColor(255,0,0,0), f32 clearDepth = 1.f, u8 clearStencil = 0,
\r
46 const SExposedVideoData& videoData = SExposedVideoData(), core::rect<s32>* sourceRect = 0) override;
\r
48 bool endScene() override;
\r
50 //! Disable a feature of the driver.
\r
51 void disableFeature(E_VIDEO_DRIVER_FEATURE feature, bool flag=true) override;
\r
53 //! queries the features of the driver, returns true if feature is available
\r
54 bool queryFeature(E_VIDEO_DRIVER_FEATURE feature) const override;
\r
56 //! Get attributes of the actual video driver
\r
57 const io::IAttributes& getDriverAttributes() const override;
\r
59 //! sets transformation
\r
60 void setTransform(E_TRANSFORMATION_STATE state, const core::matrix4& mat) override;
\r
62 //! Retrieve the number of image loaders
\r
63 u32 getImageLoaderCount() const override;
\r
65 //! Retrieve the given image loader
\r
66 IImageLoader* getImageLoader(u32 n) override;
\r
68 //! Retrieve the number of image writers
\r
69 u32 getImageWriterCount() const override;
\r
71 //! Retrieve the given image writer
\r
72 IImageWriter* getImageWriter(u32 n) override;
\r
75 void setMaterial(const SMaterial& material) override;
\r
78 ITexture* getTexture(const io::path& filename) override;
\r
81 ITexture* getTexture(io::IReadFile* file) override;
\r
83 //! Returns a texture by index
\r
84 ITexture* getTextureByIndex(u32 index) override;
\r
86 //! Returns amount of textures currently loaded
\r
87 u32 getTextureCount() const override;
\r
89 //! Renames a texture
\r
90 void renameTexture(ITexture* texture, const io::path& newName) override;
\r
92 ITexture* addTexture(const core::dimension2d<u32>& size, const io::path& name, ECOLOR_FORMAT format = ECF_A8R8G8B8) override;
\r
94 ITexture* addTexture(const io::path& name, IImage* image) override;
\r
96 virtual ITexture* addTextureCubemap(const io::path& name, IImage* imagePosX, IImage* imageNegX, IImage* imagePosY,
\r
97 IImage* imageNegY, IImage* imagePosZ, IImage* imageNegZ) override;
\r
99 ITexture* addTextureCubemap(const irr::u32 sideLen, const io::path& name, ECOLOR_FORMAT format = ECF_A8R8G8B8) override;
\r
101 virtual bool setRenderTargetEx(IRenderTarget* target, u16 clearFlag, SColor clearColor = SColor(255,0,0,0),
\r
102 f32 clearDepth = 1.f, u8 clearStencil = 0) override;
\r
104 virtual bool setRenderTarget(ITexture* texture, u16 clearFlag, SColor clearColor = SColor(255,0,0,0),
\r
105 f32 clearDepth = 1.f, u8 clearStencil = 0) override;
\r
107 //! sets a viewport
\r
108 void setViewPort(const core::rect<s32>& area) override;
\r
110 //! gets the area of the current viewport
\r
111 const core::rect<s32>& getViewPort() const override;
\r
113 //! draws a vertex primitive list
\r
114 virtual void drawVertexPrimitiveList(const void* vertices, u32 vertexCount,
\r
115 const void* indexList, u32 primitiveCount,
\r
116 E_VERTEX_TYPE vType=EVT_STANDARD, scene::E_PRIMITIVE_TYPE pType=scene::EPT_TRIANGLES,
\r
117 E_INDEX_TYPE iType=EIT_16BIT) override;
\r
119 //! draws a vertex primitive list in 2d
\r
120 virtual void draw2DVertexPrimitiveList(const void* vertices, u32 vertexCount,
\r
121 const void* indexList, u32 primitiveCount,
\r
122 E_VERTEX_TYPE vType=EVT_STANDARD, scene::E_PRIMITIVE_TYPE pType=scene::EPT_TRIANGLES,
\r
123 E_INDEX_TYPE iType=EIT_16BIT) override;
\r
125 //! Draws a 3d line.
\r
126 virtual void draw3DLine(const core::vector3df& start,
\r
127 const core::vector3df& end, SColor color = SColor(255,255,255,255)) override;
\r
129 [[deprecated]] virtual void draw3DTriangle(const core::triangle3df& triangle,
\r
130 SColor color = SColor(255,255,255,255)) {}
\r
132 //! Draws a 3d axis aligned box.
\r
133 virtual void draw3DBox(const core::aabbox3d<f32>& box,
\r
134 SColor color = SColor(255,255,255,255)) override;
\r
136 //! draws an 2d image
\r
137 void draw2DImage(const video::ITexture* texture, const core::position2d<s32>& destPos, bool useAlphaChannelOfTexture) override;
\r
139 //! draws a set of 2d images, using a color and the alpha
\r
140 /** channel of the texture if desired. The images are drawn
\r
141 beginning at pos and concatenated in one line. All drawings
\r
142 are clipped against clipRect (if != 0).
\r
143 The subtextures are defined by the array of sourceRects
\r
144 and are chosen by the indices given.
\r
145 \param texture: Texture to be drawn.
\r
146 \param pos: Upper left 2d destination position where the image will be drawn.
\r
147 \param sourceRects: Source rectangles of the image.
\r
148 \param indices: List of indices which choose the actual rectangle used each time.
\r
149 \param kerningWidth: offset on position
\r
150 \param clipRect: Pointer to rectangle on the screen where the image is clipped to.
\r
151 This pointer can be 0. Then the image is not clipped.
\r
152 \param color: Color with which the image is colored.
\r
153 Note that the alpha component is used: If alpha is other than 255, the image will be transparent.
\r
154 \param useAlphaChannelOfTexture: If true, the alpha channel of the texture is
\r
155 used to draw the image. */
\r
156 [[deprecated]] virtual void draw2DImageBatch(const video::ITexture* texture,
\r
157 const core::position2d<s32>& pos,
\r
158 const core::array<core::rect<s32> >& sourceRects,
\r
159 const core::array<s32>& indices,
\r
160 s32 kerningWidth = 0,
\r
161 const core::rect<s32>* clipRect = 0,
\r
162 SColor color=SColor(255,255,255,255),
\r
163 bool useAlphaChannelOfTexture=false) {}
\r
165 //! Draws a set of 2d images, using a color and the alpha channel of the texture.
\r
166 /** All drawings are clipped against clipRect (if != 0).
\r
167 The subtextures are defined by the array of sourceRects and are
\r
168 positioned using the array of positions.
\r
169 \param texture Texture to be drawn.
\r
170 \param pos Array of upper left 2d destinations where the images
\r
172 \param sourceRects Source rectangles of the image.
\r
173 \param clipRect Pointer to rectangle on the screen where the
\r
174 images are clipped to.
\r
175 If this pointer is 0 then the image is not clipped.
\r
176 \param color Color with which the image is drawn.
\r
177 Note that the alpha component is used. If alpha is other than
\r
178 255, the image will be transparent.
\r
179 \param useAlphaChannelOfTexture: If true, the alpha channel of
\r
180 the texture is used to draw the image. */
\r
181 virtual void draw2DImageBatch(const video::ITexture* texture,
\r
182 const core::array<core::position2d<s32> >& positions,
\r
183 const core::array<core::rect<s32> >& sourceRects,
\r
184 const core::rect<s32>* clipRect=0,
\r
185 SColor color=SColor(255,255,255,255),
\r
186 bool useAlphaChannelOfTexture=false) override;
\r
188 //! Draws a 2d image, using a color (if color is other then Color(255,255,255,255)) and the alpha channel of the texture if wanted.
\r
189 virtual void draw2DImage(const video::ITexture* texture, const core::position2d<s32>& destPos,
\r
190 const core::rect<s32>& sourceRect, const core::rect<s32>* clipRect = 0,
\r
191 SColor color=SColor(255,255,255,255), bool useAlphaChannelOfTexture=false) override;
\r
193 //! Draws a part of the texture into the rectangle.
\r
194 virtual void draw2DImage(const video::ITexture* texture, const core::rect<s32>& destRect,
\r
195 const core::rect<s32>& sourceRect, const core::rect<s32>* clipRect = 0,
\r
196 const video::SColor* const colors=0, bool useAlphaChannelOfTexture=false) override;
\r
198 //! Draws a 2d rectangle
\r
199 void draw2DRectangle(SColor color, const core::rect<s32>& pos, const core::rect<s32>* clip = 0) override;
\r
201 //! Draws a 2d rectangle with a gradient.
\r
202 virtual void draw2DRectangle(const core::rect<s32>& pos,
\r
203 SColor colorLeftUp, SColor colorRightUp, SColor colorLeftDown, SColor colorRightDown,
\r
204 const core::rect<s32>* clip = 0) override;
\r
206 //! Draws the outline of a 2d rectangle
\r
207 [[deprecated]] virtual void draw2DRectangleOutline(const core::recti& pos, SColor color=SColor(255,255,255,255)) {}
\r
209 //! Draws a 2d line.
\r
210 virtual void draw2DLine(const core::position2d<s32>& start,
\r
211 const core::position2d<s32>& end,
\r
212 SColor color=SColor(255,255,255,255)) override;
\r
215 [[deprecated]] virtual void drawPixel(u32 x, u32 y, const SColor & color) {}
\r
217 //! Draws a non filled concyclic reqular 2d polygon.
\r
218 [[deprecated]] virtual void draw2DPolygon(core::position2d<s32> center,
\r
219 f32 radius, video::SColor Color, s32 vertexCount) {}
\r
221 virtual void setFog(SColor color=SColor(0,255,255,255),
\r
222 E_FOG_TYPE fogType=EFT_FOG_LINEAR,
\r
223 f32 start=50.0f, f32 end=100.0f, f32 density=0.01f,
\r
224 bool pixelFog=false, bool rangeFog=false) override;
\r
226 virtual void getFog(SColor& color, E_FOG_TYPE& fogType,
\r
227 f32& start, f32& end, f32& density,
\r
228 bool& pixelFog, bool& rangeFog) override;
\r
230 //! get color format of the current color buffer
\r
231 ECOLOR_FORMAT getColorFormat() const override;
\r
233 //! get screen size
\r
234 const core::dimension2d<u32>& getScreenSize() const override;
\r
236 //! get current render target
\r
237 IRenderTarget* getCurrentRenderTarget() const;
\r
239 //! get render target size
\r
240 const core::dimension2d<u32>& getCurrentRenderTargetSize() const override;
\r
242 // get current frames per second value
\r
243 s32 getFPS() const override;
\r
245 //! returns amount of primitives (mostly triangles) were drawn in the last frame.
\r
246 //! very useful method for statistics.
\r
247 u32 getPrimitiveCountDrawn( u32 param = 0 ) const override;
\r
249 //! \return Returns the name of the video driver. Example: In case of the DIRECT3D8
\r
250 //! driver, it would return "Direct3D8.1".
\r
251 const wchar_t* getName() const override;
\r
253 //! Sets the dynamic ambient light color. The default color is
\r
254 //! (0,0,0,0) which means it is dark.
\r
255 //! \param color: New color of the ambient light.
\r
256 void setAmbientLight(const SColorf& color) override;
\r
258 //! Get the global ambient light currently used by the driver
\r
259 const SColorf& getAmbientLight() const override;
\r
261 //! Adds an external image loader to the engine.
\r
262 void addExternalImageLoader(IImageLoader* loader) override;
\r
264 //! Adds an external image writer to the engine.
\r
265 void addExternalImageWriter(IImageWriter* writer) override;
\r
267 //! Draws a shadow volume into the stencil buffer. To draw a stencil shadow, do
\r
268 //! this: First, draw all geometry. Then use this method, to draw the shadow
\r
269 //! volume. Then, use IVideoDriver::drawStencilShadow() to visualize the shadow.
\r
270 [[deprecated]] virtual void drawStencilShadowVolume(const core::array<core::vector3df>& triangles,
\r
271 bool zfail=true, u32 debugDataVisible=0) {}
\r
273 //! Fills the stencil shadow with color. After the shadow volume has been drawn
\r
274 //! into the stencil buffer using IVideoDriver::drawStencilShadowVolume(), use this
\r
275 //! to draw the color of the shadow.
\r
276 [[deprecated]] virtual void drawStencilShadow(bool clearStencilBuffer=false,
\r
277 video::SColor leftUpEdge = video::SColor(0,0,0,0),
\r
278 video::SColor rightUpEdge = video::SColor(0,0,0,0),
\r
279 video::SColor leftDownEdge = video::SColor(0,0,0,0),
\r
280 video::SColor rightDownEdge = video::SColor(0,0,0,0)) {}
\r
283 //! Removes a texture from the texture cache and deletes it, freeing lot of
\r
285 void removeTexture(ITexture* texture) override;
\r
287 //! Removes all texture from the texture cache and deletes them, freeing lot of
\r
289 void removeAllTextures() override;
\r
291 //! Creates a render target texture.
\r
292 virtual ITexture* addRenderTargetTexture(const core::dimension2d<u32>& size,
\r
293 const io::path& name, const ECOLOR_FORMAT format = ECF_UNKNOWN) override;
\r
295 //! Creates a render target texture for a cubemap
\r
296 ITexture* addRenderTargetTextureCubemap(const irr::u32 sideLen,
\r
297 const io::path& name, const ECOLOR_FORMAT format) override;
\r
299 //! Creates an 1bit alpha channel of the texture based of an color key.
\r
300 void makeColorKeyTexture(video::ITexture* texture, video::SColor color, bool zeroTexels) const override;
\r
302 //! Creates an 1bit alpha channel of the texture based of an color key position.
\r
303 virtual void makeColorKeyTexture(video::ITexture* texture, core::position2d<s32> colorKeyPixelPos,
\r
304 bool zeroTexels) const override;
\r
306 //! Returns the maximum amount of primitives (mostly vertices) which
\r
307 //! the device is able to render with one drawIndexedTriangleList
\r
309 u32 getMaximalPrimitiveCount() const override;
\r
311 //! Enables or disables a texture creation flag.
\r
312 void setTextureCreationFlag(E_TEXTURE_CREATION_FLAG flag, bool enabled) override;
\r
314 //! Returns if a texture creation flag is enabled or disabled.
\r
315 bool getTextureCreationFlag(E_TEXTURE_CREATION_FLAG flag) const override;
\r
317 core::array<IImage*> createImagesFromFile(const io::path& filename, E_TEXTURE_TYPE* type = 0) override;
\r
319 core::array<IImage*> createImagesFromFile(io::IReadFile* file, E_TEXTURE_TYPE* type = 0) override;
\r
321 //! Creates a software image from a byte array.
\r
322 /** \param useForeignMemory: If true, the image will use the data pointer
\r
323 directly and own it from now on, which means it will also try to delete [] the
\r
324 data when the image will be destructed. If false, the memory will by copied. */
\r
325 virtual IImage* createImageFromData(ECOLOR_FORMAT format,
\r
326 const core::dimension2d<u32>& size, void *data, bool ownForeignMemory = false,
\r
327 bool deleteMemory = true) override;
\r
329 //! Creates an empty software image.
\r
330 IImage* createImage(ECOLOR_FORMAT format, const core::dimension2d<u32>& size) override;
\r
332 //! Creates a software image from another image.
\r
333 IImage* createImage(ECOLOR_FORMAT format, IImage *imageToCopy) override;
\r
335 //! Creates a software image from part of another image.
\r
336 virtual IImage* createImage(IImage* imageToCopy,
\r
337 const core::position2d<s32>& pos,
\r
338 const core::dimension2d<u32>& size) override;
\r
340 //! Creates a software image from part of a texture.
\r
341 virtual IImage* createImage(ITexture* texture,
\r
342 const core::position2d<s32>& pos,
\r
343 const core::dimension2d<u32>& size) override;
\r
345 //! Draws a mesh buffer
\r
346 void drawMeshBuffer(const scene::IMeshBuffer* mb) override;
\r
348 //! Draws the normals of a mesh buffer
\r
349 virtual void drawMeshBufferNormals(const scene::IMeshBuffer* mb, f32 length=10.f,
\r
350 SColor color=0xffffffff) override;
\r
352 //! Check if the driver supports creating textures with the given color format
\r
353 bool queryTextureFormat(ECOLOR_FORMAT format) const override
\r
359 struct SHWBufferLink
\r
361 SHWBufferLink(const scene::IMeshBuffer *_MeshBuffer)
\r
362 :MeshBuffer(_MeshBuffer),
\r
363 ChangedID_Vertex(0),ChangedID_Index(0),
\r
364 Mapped_Vertex(scene::EHM_NEVER),Mapped_Index(scene::EHM_NEVER)
\r
367 MeshBuffer->grab();
\r
368 MeshBuffer->setHWBuffer(reinterpret_cast<void*>(this));
\r
372 virtual ~SHWBufferLink()
\r
375 MeshBuffer->setHWBuffer(NULL);
\r
376 MeshBuffer->drop();
\r
380 const scene::IMeshBuffer *MeshBuffer;
\r
381 u32 ChangedID_Vertex;
\r
382 u32 ChangedID_Index;
\r
383 scene::E_HARDWARE_MAPPING Mapped_Vertex;
\r
384 scene::E_HARDWARE_MAPPING Mapped_Index;
\r
385 std::list<SHWBufferLink*>::iterator listPosition;
\r
388 //! Gets hardware buffer link from a meshbuffer (may create or update buffer)
\r
389 virtual SHWBufferLink *getBufferLink(const scene::IMeshBuffer* mb);
\r
391 //! updates hardware buffer if needed (only some drivers can)
\r
392 virtual bool updateHardwareBuffer(SHWBufferLink *HWBuffer) {return false;}
\r
394 //! Draw hardware buffer (only some drivers can)
\r
395 virtual void drawHardwareBuffer(SHWBufferLink *HWBuffer) {}
\r
397 //! Delete hardware buffer
\r
398 virtual void deleteHardwareBuffer(SHWBufferLink *HWBuffer);
\r
400 //! Create hardware buffer from mesh (only some drivers can)
\r
401 virtual SHWBufferLink *createHardwareBuffer(const scene::IMeshBuffer* mb) {return 0;}
\r
404 //! Remove hardware buffer
\r
405 void removeHardwareBuffer(const scene::IMeshBuffer* mb) override;
\r
407 //! Remove all hardware buffers
\r
408 void removeAllHardwareBuffers() override;
\r
410 //! Update all hardware buffers, remove unused ones
\r
411 virtual void updateAllHardwareBuffers();
\r
413 //! is vbo recommended on this mesh?
\r
414 virtual bool isHardwareBufferRecommend(const scene::IMeshBuffer* mb);
\r
416 //! Create occlusion query.
\r
417 /** Use node for identification and mesh for occlusion test. */
\r
418 virtual void addOcclusionQuery(scene::ISceneNode* node,
\r
419 const scene::IMesh* mesh=0) override;
\r
421 //! Remove occlusion query.
\r
422 void removeOcclusionQuery(scene::ISceneNode* node) override;
\r
424 //! Remove all occlusion queries.
\r
425 void removeAllOcclusionQueries() override;
\r
427 //! Run occlusion query. Draws mesh stored in query.
\r
428 /** If the mesh shall not be rendered visible, use
\r
429 overrideMaterial to disable the color and depth buffer. */
\r
430 void runOcclusionQuery(scene::ISceneNode* node, bool visible=false) override;
\r
432 //! Run all occlusion queries. Draws all meshes stored in queries.
\r
433 /** If the meshes shall not be rendered visible, use
\r
434 overrideMaterial to disable the color and depth buffer. */
\r
435 void runAllOcclusionQueries(bool visible=false) override;
\r
437 //! Update occlusion query. Retrieves results from GPU.
\r
438 /** If the query shall not block, set the flag to false.
\r
439 Update might not occur in this case, though */
\r
440 void updateOcclusionQuery(scene::ISceneNode* node, bool block=true) override;
\r
442 //! Update all occlusion queries. Retrieves results from GPU.
\r
443 /** If the query shall not block, set the flag to false.
\r
444 Update might not occur in this case, though */
\r
445 void updateAllOcclusionQueries(bool block=true) override;
\r
447 //! Return query result.
\r
448 /** Return value is the number of visible pixels/fragments.
\r
449 The value is a safe approximation, i.e. can be larger than the
\r
450 actual value of pixels. */
\r
451 u32 getOcclusionQueryResult(scene::ISceneNode* node) const override;
\r
453 //! Create render target.
\r
454 IRenderTarget* addRenderTarget() override;
\r
456 //! Remove render target.
\r
457 void removeRenderTarget(IRenderTarget* renderTarget) override;
\r
459 //! Remove all render targets.
\r
460 void removeAllRenderTargets() override;
\r
462 //! Only used by the engine internally.
\r
463 /** Used to notify the driver that the window was resized. */
\r
464 void OnResize(const core::dimension2d<u32>& size) override;
\r
466 //! Adds a new material renderer to the video device.
\r
467 virtual s32 addMaterialRenderer(IMaterialRenderer* renderer,
\r
468 const char* name = 0) override;
\r
470 //! Returns driver and operating system specific data about the IVideoDriver.
\r
471 const SExposedVideoData& getExposedVideoData() override;
\r
473 //! Returns type of video driver
\r
474 E_DRIVER_TYPE getDriverType() const override;
\r
476 //! Returns the transformation set by setTransform
\r
477 const core::matrix4& getTransform(E_TRANSFORMATION_STATE state) const override;
\r
479 //! Returns pointer to the IGPUProgrammingServices interface.
\r
480 IGPUProgrammingServices* getGPUProgrammingServices() override;
\r
482 //! Adds a new material renderer to the VideoDriver, using pixel and/or
\r
483 //! vertex shaders to render geometry.
\r
484 virtual s32 addShaderMaterial(const c8* vertexShaderProgram = 0,
\r
485 const c8* pixelShaderProgram = 0,
\r
486 IShaderConstantSetCallBack* callback = 0,
\r
487 E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID,
\r
488 s32 userData=0) override;
\r
490 //! Like IGPUProgrammingServices::addShaderMaterial(), but tries to load the
\r
491 //! programs from files.
\r
492 virtual s32 addShaderMaterialFromFiles(io::IReadFile* vertexShaderProgram = 0,
\r
493 io::IReadFile* pixelShaderProgram = 0,
\r
494 IShaderConstantSetCallBack* callback = 0,
\r
495 E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID,
\r
496 s32 userData=0) override;
\r
498 //! Like IGPUProgrammingServices::addShaderMaterial(), but tries to load the
\r
499 //! programs from files.
\r
500 virtual s32 addShaderMaterialFromFiles(const io::path& vertexShaderProgramFileName,
\r
501 const io::path& pixelShaderProgramFileName,
\r
502 IShaderConstantSetCallBack* callback = 0,
\r
503 E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID,
\r
504 s32 userData=0) override;
\r
506 //! Returns pointer to material renderer or null
\r
507 IMaterialRenderer* getMaterialRenderer(u32 idx) const override;
\r
509 //! Returns amount of currently available material renderers.
\r
510 u32 getMaterialRendererCount() const override;
\r
512 //! Returns name of the material renderer
\r
513 const char* getMaterialRendererName(u32 idx) const override;
\r
515 //! Adds a new material renderer to the VideoDriver, based on a high level shading
\r
516 //! language. Currently only HLSL in D3D9 is supported.
\r
517 virtual s32 addHighLevelShaderMaterial(
\r
518 const c8* vertexShaderProgram,
\r
519 const c8* vertexShaderEntryPointName = 0,
\r
520 E_VERTEX_SHADER_TYPE vsCompileTarget = EVST_VS_1_1,
\r
521 const c8* pixelShaderProgram = 0,
\r
522 const c8* pixelShaderEntryPointName = 0,
\r
523 E_PIXEL_SHADER_TYPE psCompileTarget = EPST_PS_1_1,
\r
524 const c8* geometryShaderProgram = 0,
\r
525 const c8* geometryShaderEntryPointName = "main",
\r
526 E_GEOMETRY_SHADER_TYPE gsCompileTarget = EGST_GS_4_0,
\r
527 scene::E_PRIMITIVE_TYPE inType = scene::EPT_TRIANGLES,
\r
528 scene::E_PRIMITIVE_TYPE outType = scene::EPT_TRIANGLE_STRIP,
\r
529 u32 verticesOut = 0,
\r
530 IShaderConstantSetCallBack* callback = 0,
\r
531 E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID,
\r
532 s32 userData = 0) override;
\r
534 //! Like IGPUProgrammingServices::addShaderMaterial() (look there for a detailed description),
\r
535 //! but tries to load the programs from files.
\r
536 virtual s32 addHighLevelShaderMaterialFromFiles(
\r
537 const io::path& vertexShaderProgramFile,
\r
538 const c8* vertexShaderEntryPointName = "main",
\r
539 E_VERTEX_SHADER_TYPE vsCompileTarget = EVST_VS_1_1,
\r
540 const io::path& pixelShaderProgramFile = "",
\r
541 const c8* pixelShaderEntryPointName = "main",
\r
542 E_PIXEL_SHADER_TYPE psCompileTarget = EPST_PS_1_1,
\r
543 const io::path& geometryShaderProgramFileName="",
\r
544 const c8* geometryShaderEntryPointName = "main",
\r
545 E_GEOMETRY_SHADER_TYPE gsCompileTarget = EGST_GS_4_0,
\r
546 scene::E_PRIMITIVE_TYPE inType = scene::EPT_TRIANGLES,
\r
547 scene::E_PRIMITIVE_TYPE outType = scene::EPT_TRIANGLE_STRIP,
\r
548 u32 verticesOut = 0,
\r
549 IShaderConstantSetCallBack* callback = 0,
\r
550 E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID,
\r
551 s32 userData = 0) override;
\r
553 //! Like IGPUProgrammingServices::addShaderMaterial() (look there for a detailed description),
\r
554 //! but tries to load the programs from files.
\r
555 virtual s32 addHighLevelShaderMaterialFromFiles(
\r
556 io::IReadFile* vertexShaderProgram,
\r
557 const c8* vertexShaderEntryPointName = "main",
\r
558 E_VERTEX_SHADER_TYPE vsCompileTarget = EVST_VS_1_1,
\r
559 io::IReadFile* pixelShaderProgram = 0,
\r
560 const c8* pixelShaderEntryPointName = "main",
\r
561 E_PIXEL_SHADER_TYPE psCompileTarget = EPST_PS_1_1,
\r
562 io::IReadFile* geometryShaderProgram= 0,
\r
563 const c8* geometryShaderEntryPointName = "main",
\r
564 E_GEOMETRY_SHADER_TYPE gsCompileTarget = EGST_GS_4_0,
\r
565 scene::E_PRIMITIVE_TYPE inType = scene::EPT_TRIANGLES,
\r
566 scene::E_PRIMITIVE_TYPE outType = scene::EPT_TRIANGLE_STRIP,
\r
567 u32 verticesOut = 0,
\r
568 IShaderConstantSetCallBack* callback = 0,
\r
569 E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID,
\r
570 s32 userData = 0) override;
\r
572 //! Returns a pointer to the mesh manipulator.
\r
573 scene::IMeshManipulator* getMeshManipulator() override;
\r
575 void clearBuffers(u16 flag, SColor color = SColor(255,0,0,0), f32 depth = 1.f, u8 stencil = 0) override;
\r
577 //! Returns an image created from the last rendered frame.
\r
578 IImage* createScreenShot(video::ECOLOR_FORMAT format=video::ECF_UNKNOWN, video::E_RENDER_TARGET target=video::ERT_FRAME_BUFFER) override;
\r
580 //! Writes the provided image to disk file
\r
581 bool writeImageToFile(IImage* image, const io::path& filename, u32 param = 0) override;
\r
583 //! Writes the provided image to a file.
\r
584 bool writeImageToFile(IImage* image, io::IWriteFile * file, u32 param = 0) override;
\r
586 //! Sets the name of a material renderer.
\r
587 void setMaterialRendererName(s32 idx, const char* name) override;
\r
589 //! Swap the material renderers used for certain id's
\r
590 void swapMaterialRenderers(u32 idx1, u32 idx2, bool swapNames) override;
\r
592 //! looks if the image is already loaded
\r
593 video::ITexture* findTexture(const io::path& filename) override;
\r
595 //! Set/unset a clipping plane.
\r
596 //! There are at least 6 clipping planes available for the user to set at will.
\r
597 //! \param index: The plane index. Must be between 0 and MaxUserClipPlanes.
\r
598 //! \param plane: The plane itself.
\r
599 //! \param enable: If true, enable the clipping plane else disable it.
\r
600 bool setClipPlane(u32 index, const core::plane3df& plane, bool enable=false) override;
\r
602 //! Enable/disable a clipping plane.
\r
603 //! There are at least 6 clipping planes available for the user to set at will.
\r
604 //! \param index: The plane index. Must be between 0 and MaxUserClipPlanes.
\r
605 //! \param enable: If true, enable the clipping plane else disable it.
\r
606 void enableClipPlane(u32 index, bool enable) override;
\r
608 //! Returns the graphics card vendor name.
\r
609 core::stringc getVendorInfo() override {return "Not available on this driver.";}
\r
611 //! Set the minimum number of vertices for which a hw buffer will be created
\r
612 /** \param count Number of vertices to set as minimum. */
\r
613 void setMinHardwareBufferVertexCount(u32 count) override;
\r
615 //! Get the global Material, which might override local materials.
\r
616 /** Depending on the enable flags, values from this Material
\r
617 are used to override those of local materials of some
\r
618 meshbuffer being rendered. */
\r
619 SOverrideMaterial& getOverrideMaterial() override;
\r
621 //! Get the 2d override material for altering its values
\r
622 SMaterial& getMaterial2D() override;
\r
624 //! Enable the 2d override material
\r
625 void enableMaterial2D(bool enable=true) override;
\r
627 //! Only used by the engine internally.
\r
628 void setAllowZWriteOnTransparent(bool flag) override
\r
629 { AllowZWriteOnTransparent=flag; }
\r
631 //! Returns the maximum texture size supported.
\r
632 core::dimension2du getMaxTextureSize() const override;
\r
634 //! Used by some SceneNodes to check if a material should be rendered in the transparent render pass
\r
635 bool needsTransparentRenderPass(const irr::video::SMaterial& material) const override;
\r
637 //! Color conversion convenience function
\r
638 /** Convert an image (as array of pixels) from source to destination
\r
639 array, thereby converting the color format. The pixel size is
\r
640 determined by the color formats.
\r
641 \param sP Pointer to source
\r
642 \param sF Color format of source
\r
643 \param sN Number of pixels to convert, both array must be large enough
\r
644 \param dP Pointer to destination
\r
645 \param dF Color format of destination
\r
647 virtual void convertColor(const void* sP, ECOLOR_FORMAT sF, s32 sN,
\r
648 void* dP, ECOLOR_FORMAT dF) const override;
\r
650 //! deprecated method
\r
651 virtual ITexture* createRenderTargetTexture(const core::dimension2d<u32>& size,
\r
654 bool checkDriverReset() override {return false;}
\r
657 //! deletes all textures
\r
658 void deleteAllTextures();
\r
660 //! opens the file and loads it into the surface
\r
661 ITexture* loadTextureFromFile(io::IReadFile* file, const io::path& hashName = "");
\r
663 //! adds a surface, not loaded or created by the Irrlicht Engine
\r
664 void addTexture(ITexture* surface);
\r
666 virtual ITexture* createDeviceDependentTexture(const io::path& name, IImage* image);
\r
668 virtual ITexture* createDeviceDependentTextureCubemap(const io::path& name, const core::array<IImage*>& image);
\r
670 //! checks triangle count and print warning if wrong
\r
671 bool checkPrimitiveCount(u32 prmcnt) const;
\r
673 bool checkImage(const core::array<IImage*>& image) const;
\r
675 // adds a material renderer and drops it afterwards. To be used for internal creation
\r
676 s32 addAndDropMaterialRenderer(IMaterialRenderer* m);
\r
678 //! deletes all material renderers
\r
679 void deleteMaterialRenders();
\r
681 // prints renderer version
\r
682 void printVersion();
\r
684 inline bool getWriteZBuffer(const SMaterial& material) const
\r
686 switch ( material.ZWriteEnable )
\r
688 case video::EZW_OFF:
\r
690 case video::EZW_AUTO:
\r
691 return AllowZWriteOnTransparent || ! needsTransparentRenderPass(material);
\r
692 case video::EZW_ON:
\r
695 return true; // never should get here, but some compilers don't know and complain
\r
700 video::ITexture* Surface;
\r
702 bool operator < (const SSurface& other) const
\r
704 return Surface->getName() < other.Surface->getName();
\r
708 struct SMaterialRenderer
\r
710 core::stringc Name;
\r
711 IMaterialRenderer* Renderer;
\r
714 struct SDummyTexture : public ITexture
\r
716 SDummyTexture(const io::path& name, E_TEXTURE_TYPE type) : ITexture(name, type) {};
\r
718 void setSize(const core::dimension2d<u32>& size) { Size = OriginalSize = size; }
\r
720 void* lock(E_TEXTURE_LOCK_MODE mode = ETLM_READ_WRITE, u32 mipmapLevel=0, u32 layer = 0, E_TEXTURE_LOCK_FLAGS lockFlags = ETLF_FLIP_Y_UP_RTT) override { return 0; }
\r
721 void unlock()override {}
\r
722 void regenerateMipMapLevels(void* data = 0, u32 layer = 0) override {}
\r
724 core::array<SSurface> Textures;
\r
728 SOccQuery(scene::ISceneNode* node, const scene::IMesh* mesh=0) : Node(node), Mesh(mesh), PID(0), Result(0xffffffff), Run(0xffffffff)
\r
736 SOccQuery(const SOccQuery& other) : Node(other.Node), Mesh(other.Mesh), PID(other.PID), Result(other.Result), Run(other.Run)
\r
752 SOccQuery& operator=(const SOccQuery& other)
\r
757 Result=other.Result;
\r
766 bool operator==(const SOccQuery& other) const
\r
768 return other.Node==Node;
\r
771 scene::ISceneNode* Node;
\r
772 const scene::IMesh* Mesh;
\r
781 core::array<SOccQuery> OcclusionQueries;
\r
783 core::array<IRenderTarget*> RenderTargets;
\r
785 // Shared objects used with simplified IVideoDriver::setRenderTarget method with ITexture* param.
\r
786 IRenderTarget* SharedRenderTarget;
\r
787 core::array<ITexture*> SharedDepthTextures;
\r
789 IRenderTarget* CurrentRenderTarget;
\r
790 core::dimension2d<u32> CurrentRenderTargetSize;
\r
792 core::array<video::IImageLoader*> SurfaceLoader;
\r
793 core::array<video::IImageWriter*> SurfaceWriter;
\r
794 core::array<SMaterialRenderer> MaterialRenderers;
\r
796 std::list<SHWBufferLink*> HWBufferList;
\r
798 io::IFileSystem* FileSystem;
\r
800 //! mesh manipulator
\r
801 scene::IMeshManipulator* MeshManipulator;
\r
803 core::rect<s32> ViewPort;
\r
804 core::dimension2d<u32> ScreenSize;
\r
805 core::matrix4 TransformationMatrix;
\r
807 CFPSCounter FPSCounter;
\r
809 u32 PrimitivesDrawn;
\r
810 u32 MinVertexCountForVBO;
\r
812 u32 TextureCreationFlags;
\r
818 SExposedVideoData ExposedData;
\r
820 io::IAttributes* DriverAttributes;
\r
822 SOverrideMaterial OverrideMaterial;
\r
823 SMaterial OverrideMaterial2D;
\r
824 SMaterial InitMaterial2D;
\r
825 bool OverrideMaterial2DEnabled;
\r
827 E_FOG_TYPE FogType;
\r
830 bool AllowZWriteOnTransparent;
\r
832 bool FeatureEnabled[video::EVDF_COUNT];
\r
834 SColorf AmbientLight;
\r
837 } // end namespace video
\r
838 } // end namespace irr
\r
projects / irrlicht.git / blob