irrlicht 1.8.4

include/CDynamicMeshBuffer.h

+// Copyright (C) 2008-2012 Nikolaus Gebhardt
+// This file is part of the "Irrlicht Engine".
+// For conditions of distribution and use, see copyright notice in irrlicht.h
+
+#ifndef __C_DYNAMIC_MESHBUFFER_H_INCLUDED__
+#define __C_DYNAMIC_MESHBUFFER_H_INCLUDED__
+
+#include "IDynamicMeshBuffer.h"
+
+#include "CVertexBuffer.h"
+#include "CIndexBuffer.h"
+
+namespace irr
+{
+namespace scene
+{
+
+	class CDynamicMeshBuffer: public IDynamicMeshBuffer
+	{
+	public:
+		//! constructor
+		CDynamicMeshBuffer(video::E_VERTEX_TYPE vertexType, video::E_INDEX_TYPE indexType)
+		{
+			VertexBuffer=new CVertexBuffer(vertexType);
+			IndexBuffer=new CIndexBuffer(indexType);
+		}
+
+		//! destructor
+		virtual ~CDynamicMeshBuffer()
+		{
+			if (VertexBuffer)
+				VertexBuffer->drop();
+			if (IndexBuffer)
+				IndexBuffer->drop();
+		}
+
+		virtual IVertexBuffer& getVertexBuffer() const
+		{
+			return *VertexBuffer;
+		}
+
+		virtual IIndexBuffer& getIndexBuffer() const
+		{
+			return *IndexBuffer;
+		}
+
+		virtual void setVertexBuffer(IVertexBuffer *newVertexBuffer)
+		{
+			if (newVertexBuffer)
+				newVertexBuffer->grab();
+			if (VertexBuffer)
+				VertexBuffer->drop();
+
+			VertexBuffer=newVertexBuffer;
+		}
+
+		virtual void setIndexBuffer(IIndexBuffer *newIndexBuffer)
+		{
+			if (newIndexBuffer)
+				newIndexBuffer->grab();
+			if (IndexBuffer)
+				IndexBuffer->drop();
+
+			IndexBuffer=newIndexBuffer;
+		}
+
+		//! Get Material of this buffer.
+		virtual const video::SMaterial& getMaterial() const
+		{
+			return Material;
+		}
+
+		//! Get Material of this buffer.
+		virtual video::SMaterial& getMaterial()
+		{
+			return Material;
+		}
+
+		//! Get bounding box
+		virtual const core::aabbox3d<f32>& getBoundingBox() const
+		{
+			return BoundingBox;
+		}
+
+		//! Set bounding box
+		virtual void setBoundingBox( const core::aabbox3df& box)
+		{
+			BoundingBox = box;
+		}
+
+		//! Recalculate bounding box
+		virtual void recalculateBoundingBox()
+		{
+			if (!getVertexBuffer().size())
+				BoundingBox.reset(0,0,0);
+			else
+			{
+				BoundingBox.reset(getVertexBuffer()[0].Pos);
+				for (u32 i=1; i<getVertexBuffer().size(); ++i)
+					BoundingBox.addInternalPoint(getVertexBuffer()[i].Pos);
+			}
+		}
+
+		video::SMaterial Material;
+		core::aabbox3d<f32> BoundingBox;
+	private:
+		IVertexBuffer *VertexBuffer;
+		IIndexBuffer *IndexBuffer;
+	};
+
+
+} // end namespace scene
+} // end namespace irr
+
+#endif
+

include/CIndexBuffer.h

+// Copyright (C) 2008-2012 Nikolaus Gebhardt
+// This file is part of the "Irrlicht Engine".
+// For conditions of distribution and use, see copyright notice in irrlicht.h
+
+#ifndef __C_INDEX_BUFFER_H_INCLUDED__
+#define __C_INDEX_BUFFER_H_INCLUDED__
+
+#include "IIndexBuffer.h"
+
+namespace irr
+{
+namespace scene
+{
+
+	class CIndexBuffer : public IIndexBuffer
+	{
+
+		class IIndexList
+		{
+		public:
+			virtual ~IIndexList(){};
+
+			virtual u32 stride() const =0;
+			virtual u32 size() const =0;
+			virtual void push_back(const u32 &element) =0;
+			virtual u32 operator [](u32 index) const =0;
+			virtual u32 getLast() =0;
+			virtual void setValue(u32 index, u32 value) =0;
+			virtual void set_used(u32 usedNow) =0;
+			virtual void reallocate(u32 new_size) =0;
+			virtual u32 allocated_size() const =0;
+			virtual void* pointer() =0;
+			virtual video::E_INDEX_TYPE getType() const =0;
+		};
+
+		template <class T>
+		class CSpecificIndexList : public IIndexList
+		{
+		public:
+			core::array<T> Indices;
+
+			virtual u32 stride() const {return sizeof(T);}
+
+			virtual u32 size() const {return Indices.size();}
+
+			virtual void push_back(const u32 &element)
+			{
+				// push const ref due to compiler problem with gcc 4.6, big endian
+				Indices.push_back((const T&)element);
+			}
+
+			virtual u32 operator [](u32 index) const
+			{
+				return (u32)(Indices[index]);
+			}
+
+			virtual u32 getLast() {return (u32)Indices.getLast();}
+
+			virtual void setValue(u32 index, u32 value)
+			{
+				Indices[index]=(T)value;
+			}
+
+			virtual void set_used(u32 usedNow)
+			{
+				Indices.set_used(usedNow);
+			}
+
+			virtual void reallocate(u32 new_size)
+			{
+				Indices.reallocate(new_size);
+			}
+
+			virtual u32 allocated_size() const
+			{
+				return Indices.allocated_size();
+			}
+
+			virtual void* pointer() {return Indices.pointer();}
+
+			virtual video::E_INDEX_TYPE getType() const
+			{
+				if (sizeof(T)==sizeof(u16))
+					return video::EIT_16BIT;
+				else
+					return video::EIT_32BIT;
+			}
+		};
+
+	public:
+		IIndexList *Indices;
+
+		CIndexBuffer(video::E_INDEX_TYPE IndexType) :Indices(0), MappingHint(EHM_NEVER), ChangedID(1)
+		{
+			setType(IndexType);
+		}
+
+		CIndexBuffer(const IIndexBuffer &IndexBufferCopy) :Indices(0), MappingHint(EHM_NEVER), ChangedID(1)
+		{
+			setType(IndexBufferCopy.getType());
+			reallocate(IndexBufferCopy.size());
+
+			for (u32 n=0;n<IndexBufferCopy.size();++n)
+				push_back(IndexBufferCopy[n]);
+		}
+
+		virtual ~CIndexBuffer()
+		{
+			delete Indices;
+		}
+
+		//virtual void setType(video::E_INDEX_TYPE IndexType);
+		virtual void setType(video::E_INDEX_TYPE IndexType)
+		{
+			IIndexList *NewIndices=0;
+
+			switch (IndexType)
+			{
+				case video::EIT_16BIT:
+				{
+					NewIndices=new CSpecificIndexList<u16>;
+					break;
+				}
+				case video::EIT_32BIT:
+				{
+					NewIndices=new CSpecificIndexList<u32>;
+					break;
+				}
+			}
+
+			if (Indices)
+			{
+				NewIndices->reallocate( Indices->size() );
+
+				for(u32 n=0;n<Indices->size();++n)
+					NewIndices->push_back((*Indices)[n]);
+
+				delete Indices;
+			}
+
+			Indices=NewIndices;
+		}
+
+		virtual void* getData() {return Indices->pointer();}
+
+		virtual video::E_INDEX_TYPE getType() const {return Indices->getType();}
+
+		virtual u32 stride() const {return Indices->stride();}
+
+		virtual u32 size() const
+		{
+			return Indices->size();
+		}
+
+		virtual void push_back(const u32 &element)
+		{
+			Indices->push_back(element);
+		}
+
+		virtual u32 operator [](u32 index) const
+		{
+			return (*Indices)[index];
+		}
+
+		virtual u32 getLast()
+		{
+			return Indices->getLast();
+		}
+
+		virtual void setValue(u32 index, u32 value)
+		{
+			Indices->setValue(index, value);
+		}
+
+		virtual void set_used(u32 usedNow)
+		{
+			Indices->set_used(usedNow);
+		}
+
+		virtual void reallocate(u32 new_size)
+		{
+			Indices->reallocate(new_size);
+		}
+
+		virtual u32 allocated_size() const
+		{
+			return Indices->allocated_size();
+		}
+
+		virtual void* pointer()
+		{
+			return Indices->pointer();
+		}
+
+		//! get the current hardware mapping hint
+		virtual E_HARDWARE_MAPPING getHardwareMappingHint() const
+		{
+			return MappingHint;
+		}
+
+		//! set the hardware mapping hint, for driver
+		virtual void setHardwareMappingHint( E_HARDWARE_MAPPING NewMappingHint )
+		{
+			MappingHint=NewMappingHint;
+		}
+
+		//! flags the mesh as changed, reloads hardware buffers
+		virtual void setDirty()
+		{
+			++ChangedID;
+		}
+
+		//! Get the currently used ID for identification of changes.
+		/** This shouldn't be used for anything outside the VideoDriver. */
+		virtual u32 getChangedID() const {return ChangedID;}
+
+		E_HARDWARE_MAPPING MappingHint;
+		u32 ChangedID;
+	};
+
+
+} // end namespace scene
+} // end namespace irr
+
+#endif
+

include/CMeshBuffer.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 __T_MESH_BUFFER_H_INCLUDED__
+#define __T_MESH_BUFFER_H_INCLUDED__
+
+#include "irrArray.h"
+#include "IMeshBuffer.h"
+
+namespace irr
+{
+namespace scene
+{
+	//! Template implementation of the IMeshBuffer interface
+	template <class T>
+	class CMeshBuffer : public IMeshBuffer
+	{
+	public:
+		//! Default constructor for empty meshbuffer
+		CMeshBuffer():ChangedID_Vertex(1),ChangedID_Index(1),MappingHint_Vertex(EHM_NEVER), MappingHint_Index(EHM_NEVER)
+		{
+			#ifdef _DEBUG
+			setDebugName("SMeshBuffer");
+			#endif
+		}
+
+
+		//! Get material of this meshbuffer
+		/** \return Material of this buffer */
+		virtual const video::SMaterial& getMaterial() const
+		{
+			return Material;
+		}
+
+
+		//! Get material of this meshbuffer
+		/** \return Material of this buffer */
+		virtual video::SMaterial& getMaterial()
+		{
+			return Material;
+		}
+
+
+		//! Get pointer to vertices
+		/** \return Pointer to vertices. */
+		virtual const void* getVertices() const
+		{
+			return Vertices.const_pointer();
+		}
+
+
+		//! Get pointer to vertices
+		/** \return Pointer to vertices. */
+		virtual void* getVertices()
+		{
+			return Vertices.pointer();
+		}
+
+
+		//! Get number of vertices
+		/** \return Number of vertices. */
+		virtual u32 getVertexCount() const
+		{
+			return Vertices.size();
+		}
+
+		//! Get type of index data which is stored in this meshbuffer.
+		/** \return Index type of this buffer. */
+		virtual video::E_INDEX_TYPE getIndexType() const
+		{
+			return video::EIT_16BIT;
+		}
+
+		//! Get pointer to indices
+		/** \return Pointer to indices. */
+		virtual const u16* getIndices() const
+		{
+			return Indices.const_pointer();
+		}
+
+
+		//! Get pointer to indices
+		/** \return Pointer to indices. */
+		virtual u16* getIndices()
+		{
+			return Indices.pointer();
+		}
+
+
+		//! Get number of indices
+		/** \return Number of indices. */
+		virtual u32 getIndexCount() const
+		{
+			return Indices.size();
+		}
+
+
+		//! Get the axis aligned bounding box
+		/** \return Axis aligned bounding box of this buffer. */
+		virtual const core::aabbox3d<f32>& getBoundingBox() const
+		{
+			return BoundingBox;
+		}
+
+
+		//! Set the axis aligned bounding box
+		/** \param box New axis aligned bounding box for this buffer. */
+		//! set user axis aligned bounding box
+		virtual void setBoundingBox(const core::aabbox3df& box)
+		{
+			BoundingBox = box;
+		}
+
+
+		//! Recalculate the bounding box.
+		/** should be called if the mesh changed. */
+		virtual void recalculateBoundingBox()
+		{
+			if (Vertices.empty())
+				BoundingBox.reset(0,0,0);
+			else
+			{
+				BoundingBox.reset(Vertices[0].Pos);
+				for (u32 i=1; i<Vertices.size(); ++i)
+					BoundingBox.addInternalPoint(Vertices[i].Pos);
+			}
+		}
+
+
+		//! Get type of vertex data stored in this buffer.
+		/** \return Type of vertex data. */
+		virtual video::E_VERTEX_TYPE getVertexType() const
+		{
+			return T().getType();
+		}
+
+		//! returns position of vertex i
+		virtual const core::vector3df& getPosition(u32 i) const
+		{
+			return Vertices[i].Pos;
+		}
+
+		//! returns position of vertex i
+		virtual core::vector3df& getPosition(u32 i)
+		{
+			return Vertices[i].Pos;
+		}
+
+		//! returns normal of vertex i
+		virtual const core::vector3df& getNormal(u32 i) const
+		{
+			return Vertices[i].Normal;
+		}
+
+		//! returns normal of vertex i
+		virtual core::vector3df& getNormal(u32 i)
+		{
+			return Vertices[i].Normal;
+		}
+
+		//! returns texture coord of vertex i
+		virtual const core::vector2df& getTCoords(u32 i) const
+		{
+			return Vertices[i].TCoords;
+		}
+
+		//! returns texture coord of vertex i
+		virtual core::vector2df& getTCoords(u32 i)
+		{
+			return Vertices[i].TCoords;
+		}
+
+
+		//! Append the vertices and indices to the current buffer
+		/** Only works for compatible types, i.e. either the same type
+		or the main buffer is of standard type. Otherwise, behavior is
+		undefined.
+		*/
+		virtual void append(const void* const vertices, u32 numVertices, const u16* const indices, u32 numIndices)
+		{
+			if (vertices == getVertices())
+				return;
+
+			const u32 vertexCount = getVertexCount();
+			u32 i;
+
+			Vertices.reallocate(vertexCount+numVertices);
+			for (i=0; i<numVertices; ++i)
+			{
+				Vertices.push_back(reinterpret_cast<const T*>(vertices)[i]);
+				BoundingBox.addInternalPoint(reinterpret_cast<const T*>(vertices)[i].Pos);
+			}
+
+			Indices.reallocate(getIndexCount()+numIndices);
+			for (i=0; i<numIndices; ++i)
+			{
+				Indices.push_back(indices[i]+vertexCount);
+			}
+		}
+
+
+		//! Append the meshbuffer to the current buffer
+		/** Only works for compatible types, i.e. either the same type
+		or the main buffer is of standard type. Otherwise, behavior is
+		undefined.
+		\param other Meshbuffer to be appended to this one.
+		*/
+		virtual void append(const IMeshBuffer* const other)
+		{
+			/*
+			if (this==other)
+				return;
+
+			const u32 vertexCount = getVertexCount();
+			u32 i;
+
+			Vertices.reallocate(vertexCount+other->getVertexCount());
+			for (i=0; i<other->getVertexCount(); ++i)
+			{
+				Vertices.push_back(reinterpret_cast<const T*>(other->getVertices())[i]);
+			}
+
+			Indices.reallocate(getIndexCount()+other->getIndexCount());
+			for (i=0; i<other->getIndexCount(); ++i)
+			{
+				Indices.push_back(other->getIndices()[i]+vertexCount);
+			}
+			BoundingBox.addInternalBox(other->getBoundingBox());
+			*/
+		}
+
+
+		//! get the current hardware mapping hint
+		virtual E_HARDWARE_MAPPING getHardwareMappingHint_Vertex() const
+		{
+			return MappingHint_Vertex;
+		}
+
+		//! get the current hardware mapping hint
+		virtual E_HARDWARE_MAPPING getHardwareMappingHint_Index() const
+		{
+			return MappingHint_Index;
+		}
+
+		//! set the hardware mapping hint, for driver
+		virtual void setHardwareMappingHint( E_HARDWARE_MAPPING NewMappingHint, E_BUFFER_TYPE Buffer=EBT_VERTEX_AND_INDEX )
+		{
+			if (Buffer==EBT_VERTEX_AND_INDEX || Buffer==EBT_VERTEX)
+				MappingHint_Vertex=NewMappingHint;
+			if (Buffer==EBT_VERTEX_AND_INDEX || Buffer==EBT_INDEX)
+				MappingHint_Index=NewMappingHint;
+		}
+
+
+		//! flags the mesh as changed, reloads hardware buffers
+		virtual void setDirty(E_BUFFER_TYPE Buffer=EBT_VERTEX_AND_INDEX)
+		{
+			if (Buffer==EBT_VERTEX_AND_INDEX ||Buffer==EBT_VERTEX)
+				++ChangedID_Vertex;
+			if (Buffer==EBT_VERTEX_AND_INDEX || Buffer==EBT_INDEX)
+				++ChangedID_Index;
+		}
+
+		//! Get the currently used ID for identification of changes.
+		/** This shouldn't be used for anything outside the VideoDriver. */
+		virtual u32 getChangedID_Vertex() const {return ChangedID_Vertex;}
+
+		//! Get the currently used ID for identification of changes.
+		/** This shouldn't be used for anything outside the VideoDriver. */
+		virtual u32 getChangedID_Index() const {return ChangedID_Index;}
+
+		u32 ChangedID_Vertex;
+		u32 ChangedID_Index;
+
+		//! hardware mapping hint
+		E_HARDWARE_MAPPING MappingHint_Vertex;
+		E_HARDWARE_MAPPING MappingHint_Index;
+
+		//! Material for this meshbuffer.
+		video::SMaterial Material;
+		//! Vertices of this buffer
+		core::array<T> Vertices;
+		//! Indices into the vertices of this buffer.
+		core::array<u16> Indices;
+		//! Bounding box of this meshbuffer.
+		core::aabbox3d<f32> BoundingBox;
+	};
+
+	//! Standard meshbuffer
+	typedef CMeshBuffer<video::S3DVertex> SMeshBuffer;
+	//! Meshbuffer with two texture coords per vertex, e.g. for lightmaps
+	typedef CMeshBuffer<video::S3DVertex2TCoords> SMeshBufferLightMap;
+	//! Meshbuffer with vertices having tangents stored, e.g. for normal mapping
+	typedef CMeshBuffer<video::S3DVertexTangents> SMeshBufferTangents;
+} // end namespace scene
+} // end namespace irr
+
+#endif
+
+

include/CVertexBuffer.h

+// Copyright (C) 2008-2012 Nikolaus Gebhardt
+// This file is part of the "Irrlicht Engine".
+// For conditions of distribution and use, see copyright notice in irrlicht.h
+
+#ifndef __C_VERTEX_BUFFER_H_INCLUDED__
+#define __C_VERTEX_BUFFER_H_INCLUDED__
+
+#include "IVertexBuffer.h"
+
+
+namespace irr
+{
+namespace scene
+{
+
+	class CVertexBuffer : public IVertexBuffer
+	{
+		class IVertexList
+		{
+		public:
+			virtual ~IVertexList(){};
+
+			virtual u32 stride() const =0;
+
+			virtual u32 size() const =0;
+
+			virtual void push_back (const video::S3DVertex &element) =0;
+			virtual video::S3DVertex& operator [](const u32 index) const =0;
+			virtual video::S3DVertex& getLast() =0;
+			virtual void set_used(u32 usedNow) =0;
+			virtual void reallocate(u32 new_size) =0;
+			virtual u32 allocated_size() const =0;
+			virtual video::S3DVertex* pointer() =0;
+			virtual video::E_VERTEX_TYPE getType() const =0;
+		};
+
+		template <class T>
+		class CSpecificVertexList : public IVertexList
+		{
+		public:
+			core::array<T> Vertices;
+
+			virtual u32 stride() const {return sizeof(T);}
+
+			virtual u32 size() const {return Vertices.size();}
+
+			virtual void push_back (const video::S3DVertex &element)
+			{Vertices.push_back((T&)element);}
+
+			virtual video::S3DVertex& operator [](const u32 index) const
+			{return (video::S3DVertex&)Vertices[index];}
+
+			virtual video::S3DVertex& getLast()
+			{return (video::S3DVertex&)Vertices.getLast();}
+
+			virtual void set_used(u32 usedNow)
+			{Vertices.set_used(usedNow);}
+
+			virtual void reallocate(u32 new_size)
+			{Vertices.reallocate(new_size);}
+
+			virtual u32 allocated_size() const
+			{
+				return Vertices.allocated_size();
+			}
+
+			virtual video::S3DVertex* pointer() {return Vertices.pointer();}
+
+			virtual video::E_VERTEX_TYPE getType() const {return T().getType();}
+		};
+
+	public:
+		IVertexList *Vertices;
+
+		CVertexBuffer(video::E_VERTEX_TYPE vertexType) : Vertices(0),
+				MappingHint(EHM_NEVER), ChangedID(1)
+		{
+			setType(vertexType);
+		}
+
+		CVertexBuffer(const IVertexBuffer &VertexBufferCopy) :
+				Vertices(0), MappingHint(EHM_NEVER),
+				ChangedID(1)
+		{
+			setType(VertexBufferCopy.getType());
+			reallocate(VertexBufferCopy.size());
+
+			for (u32 n=0;n<VertexBufferCopy.size();++n)
+				push_back(VertexBufferCopy[n]);
+		}
+
+		virtual ~CVertexBuffer()
+		{
+			delete Vertices;
+		}
+
+
+		virtual void setType(video::E_VERTEX_TYPE vertexType)
+		{
+			IVertexList *NewVertices=0;
+
+			switch (vertexType)
+			{
+				case video::EVT_STANDARD:
+				{
+					NewVertices=new CSpecificVertexList<video::S3DVertex>;
+					break;
+				}
+				case video::EVT_2TCOORDS:
+				{
+					NewVertices=new CSpecificVertexList<video::S3DVertex2TCoords>;
+					break;
+				}
+				case video::EVT_TANGENTS:
+				{
+					NewVertices=new CSpecificVertexList<video::S3DVertexTangents>;
+					break;
+				}
+			}
+			if (Vertices)
+			{
+				NewVertices->reallocate( Vertices->size() );
+
+				for(u32 n=0;n<Vertices->size();++n)
+					NewVertices->push_back((*Vertices)[n]);
+
+				delete Vertices;
+			}
+
+			Vertices=NewVertices;
+		}
+
+		virtual void* getData() {return Vertices->pointer();}
+
+		virtual video::E_VERTEX_TYPE getType() const {return Vertices->getType();}
+
+		virtual u32 stride() const {return Vertices->stride();}
+
+		virtual u32 size() const
+		{
+			return Vertices->size();
+		}
+
+		virtual void push_back (const video::S3DVertex &element)
+		{
+			Vertices->push_back(element);
+		}
+
+		virtual video::S3DVertex& operator [](const u32 index) const
+		{
+			return (*Vertices)[index];
+		}
+
+		virtual video::S3DVertex& getLast()
+		{
+			return Vertices->getLast();
+		}
+
+		virtual void set_used(u32 usedNow)
+		{
+			Vertices->set_used(usedNow);
+		}
+
+		virtual void reallocate(u32 new_size)
+		{
+			Vertices->reallocate(new_size);
+		}
+
+		virtual u32 allocated_size() const
+		{
+			return Vertices->allocated_size();
+		}
+
+		virtual video::S3DVertex* pointer()
+		{
+			return Vertices->pointer();
+		}
+
+		//! get the current hardware mapping hint
+		virtual E_HARDWARE_MAPPING getHardwareMappingHint() const
+		{
+			return MappingHint;
+		}
+
+		//! set the hardware mapping hint, for driver
+		virtual void setHardwareMappingHint( E_HARDWARE_MAPPING NewMappingHint )
+		{
+			MappingHint=NewMappingHint;
+		}
+
+		//! flags the mesh as changed, reloads hardware buffers
+		virtual void setDirty()
+		{
+			++ChangedID;
+		}
+
+		//! Get the currently used ID for identification of changes.
+		/** This shouldn't be used for anything outside the VideoDriver. */
+		virtual u32 getChangedID() const {return ChangedID;}
+
+		E_HARDWARE_MAPPING MappingHint;
+		u32 ChangedID;
+	};
+
+
+} // end namespace scene
+} // end namespace irr
+
+#endif
+

include/EAttributes.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 __E_ATTRIBUTES_H_INCLUDED__
+#define __E_ATTRIBUTES_H_INCLUDED__
+
+namespace irr
+{
+namespace io
+{
+
+//! Types of attributes available for IAttributes
+enum E_ATTRIBUTE_TYPE
+{
+	// integer attribute
+	EAT_INT = 0,
+
+	// float attribute
+	EAT_FLOAT,
+
+	// string attribute
+	EAT_STRING,
+
+	// boolean attribute
+	EAT_BOOL,
+
+	// enumeration attribute
+	EAT_ENUM,
+
+	// color attribute
+	EAT_COLOR,
+
+	// floating point color attribute
+	EAT_COLORF,
+
+	// 3d vector attribute
+	EAT_VECTOR3D,
+
+	// 2d position attribute
+	EAT_POSITION2D,
+
+	// vector 2d attribute
+	EAT_VECTOR2D,
+
+	// rectangle attribute
+	EAT_RECT,
+
+	// matrix attribute
+	EAT_MATRIX,
+
+	// quaternion attribute
+	EAT_QUATERNION,
+
+	// 3d bounding box
+	EAT_BBOX,
+
+	// plane
+	EAT_PLANE,
+
+	// 3d triangle
+	EAT_TRIANGLE3D,
+
+	// line 2d
+	EAT_LINE2D,
+
+	// line 3d
+	EAT_LINE3D,
+
+	// array of stringws attribute
+	EAT_STRINGWARRAY,
+
+	// array of float
+	EAT_FLOATARRAY,
+
+	// array of int
+	EAT_INTARRAY,
+
+	// binary data attribute
+	EAT_BINARY,
+
+	// texture reference attribute
+	EAT_TEXTURE,
+
+	// user pointer void*
+	EAT_USER_POINTER,
+
+	// dimension attribute
+	EAT_DIMENSION2D,
+
+	// known attribute type count
+	EAT_COUNT,
+
+	// unknown attribute
+	EAT_UNKNOWN
+};
+
+} // end namespace io
+} // end namespace irr
+
+#endif

include/ECullingTypes.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 __E_CULLING_TYPES_H_INCLUDED__
+#define __E_CULLING_TYPES_H_INCLUDED__
+
+#include "irrTypes.h"
+
+namespace irr
+{
+namespace scene
+{
+
+	//! An enumeration for all types of automatic culling for built-in scene nodes
+	enum E_CULLING_TYPE
+	{
+		EAC_OFF = 0,
+		EAC_BOX = 1,
+		EAC_FRUSTUM_BOX = 2,
+		EAC_FRUSTUM_SPHERE = 4,
+		EAC_OCC_QUERY = 8
+	};
+
+	//! Names for culling type
+	const c8* const AutomaticCullingNames[] =
+	{
+		"false",
+		"box",			// camera box against node box
+		"frustum_box",		// camera frustum against node box
+		"frustum_sphere",	// camera frustum against node sphere
+		"occ_query",	// occlusion query
+		0
+	};
+
+} // end namespace scene
+} // end namespace irr
+
+
+#endif // __E_CULLING_TYPES_H_INCLUDED__
+

include/EDebugSceneTypes.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 __E_DEBUG_SCENE_TYPES_H_INCLUDED__
+#define __E_DEBUG_SCENE_TYPES_H_INCLUDED__
+
+namespace irr
+{
+namespace scene
+{
+
+	//! An enumeration for all types of debug data for built-in scene nodes (flags)
+	enum E_DEBUG_SCENE_TYPE
+	{
+		//! No Debug Data ( Default )
+		EDS_OFF = 0,
+
+		//! Show Bounding Boxes of SceneNode
+		EDS_BBOX = 1,
+
+		//! Show Vertex Normals
+		EDS_NORMALS = 2,
+
+		//! Shows Skeleton/Tags
+		EDS_SKELETON = 4,
+
+		//! Overlays Mesh Wireframe
+		EDS_MESH_WIRE_OVERLAY = 8,
+
+		//! Temporary use transparency Material Type
+		EDS_HALF_TRANSPARENCY = 16,
+
+		//! Show Bounding Boxes of all MeshBuffers
+		EDS_BBOX_BUFFERS = 32,
+
+		//! EDS_BBOX | EDS_BBOX_BUFFERS
+		EDS_BBOX_ALL = EDS_BBOX | EDS_BBOX_BUFFERS,
+
+		//! Show all debug infos
+		EDS_FULL = 0xffffffff
+	};
+
+
+} // end namespace scene
+} // end namespace irr
+
+
+#endif // __E_DEBUG_SCENE_TYPES_H_INCLUDED__
+

include/EDeviceTypes.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 __E_DEVICE_TYPES_H_INCLUDED__
+#define __E_DEVICE_TYPES_H_INCLUDED__
+
+namespace irr
+{
+
+	//! An enum for the different device types supported by the Irrlicht Engine.
+	enum E_DEVICE_TYPE
+	{
+
+		//! A device native to Microsoft Windows
+		/** This device uses the Win32 API and works in all versions of Windows. */
+		EIDT_WIN32,
+
+		//! A device native to Windows CE devices
+		/** This device works on Windows Mobile, Pocket PC and Microsoft SmartPhone devices */
+		EIDT_WINCE,
+
+		//! A device native to Unix style operating systems.
+		/** This device uses the X11 windowing system and works in Linux, Solaris, FreeBSD, OSX and
+		other operating systems which support X11. */
+		EIDT_X11,
+
+		//! A device native to Mac OSX
+		/** This device uses Apple's Cocoa API and works in Mac OSX 10.2 and above. */
+		EIDT_OSX,
+
+		//! A device which uses Simple DirectMedia Layer
+		/** The SDL device works under all platforms supported by SDL but first must be compiled
+		in by defining the IRR_USE_SDL_DEVICE macro in IrrCompileConfig.h */
+		EIDT_SDL,
+
+		//! A device for raw framebuffer access
+		/** Best used with embedded devices and mobile systems.
+		Does not need X11 or other graphical subsystems.
+		May support hw-acceleration via OpenGL-ES for FBDirect */
+		EIDT_FRAMEBUFFER,
+
+		//! A simple text only device supported by all platforms.
+		/** This device allows applications to run from the command line without opening a window.
+		It can render the output of the software drivers to the console as ASCII. It only supports
+		mouse and keyboard in Windows operating systems. */
+		EIDT_CONSOLE,
+
+		//! This selection allows Irrlicht to choose the best device from the ones available.
+		/** If this selection is chosen then Irrlicht will try to use the IrrlichtDevice native
+		to your operating system. If this is unavailable then the X11, SDL and then console device
+		will be tried. This ensures that Irrlicht will run even if your platform is unsupported,
+		although it may not be able to render anything. */
+		EIDT_BEST
+	};
+
+} // end namespace irr
+
+#endif // __E_DEVICE_TYPES_H_INCLUDED__
+

include/EDriverFeatures.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 __E_DRIVER_FEATURES_H_INCLUDED__
+#define __E_DRIVER_FEATURES_H_INCLUDED__
+
+namespace irr
+{
+namespace video
+{
+
+	//! enumeration for querying features of the video driver.
+	enum E_VIDEO_DRIVER_FEATURE
+	{
+		//! Is driver able to render to a surface?
+		EVDF_RENDER_TO_TARGET = 0,
+
+		//! Is hardeware transform and lighting supported?
+		EVDF_HARDWARE_TL,
+
+		//! Are multiple textures per material possible?
+		EVDF_MULTITEXTURE,
+
+		//! Is driver able to render with a bilinear filter applied?
+		EVDF_BILINEAR_FILTER,
+
+		//! Can the driver handle mip maps?
+		EVDF_MIP_MAP,
+
+		//! Can the driver update mip maps automatically?
+		EVDF_MIP_MAP_AUTO_UPDATE,
+
+		//! Are stencilbuffers switched on and does the device support stencil buffers?
+		EVDF_STENCIL_BUFFER,
+
+		//! Is Vertex Shader 1.1 supported?
+		EVDF_VERTEX_SHADER_1_1,
+
+		//! Is Vertex Shader 2.0 supported?
+		EVDF_VERTEX_SHADER_2_0,
+
+		//! Is Vertex Shader 3.0 supported?
+		EVDF_VERTEX_SHADER_3_0,
+
+		//! Is Pixel Shader 1.1 supported?
+		EVDF_PIXEL_SHADER_1_1,
+
+		//! Is Pixel Shader 1.2 supported?
+		EVDF_PIXEL_SHADER_1_2,
+
+		//! Is Pixel Shader 1.3 supported?
+		EVDF_PIXEL_SHADER_1_3,
+
+		//! Is Pixel Shader 1.4 supported?
+		EVDF_PIXEL_SHADER_1_4,
+
+		//! Is Pixel Shader 2.0 supported?
+		EVDF_PIXEL_SHADER_2_0,
+
+		//! Is Pixel Shader 3.0 supported?
+		EVDF_PIXEL_SHADER_3_0,
+
+		//! Are ARB vertex programs v1.0 supported?
+		EVDF_ARB_VERTEX_PROGRAM_1,
+
+		//! Are ARB fragment programs v1.0 supported?
+		EVDF_ARB_FRAGMENT_PROGRAM_1,
+
+		//! Is GLSL supported?
+		EVDF_ARB_GLSL,
+
+		//! Is HLSL supported?
+		EVDF_HLSL,
+
+		//! Are non-square textures supported?
+		EVDF_TEXTURE_NSQUARE,
+
+		//! Are non-power-of-two textures supported?
+		EVDF_TEXTURE_NPOT,
+
+		//! Are framebuffer objects supported?
+		EVDF_FRAMEBUFFER_OBJECT,
+
+		//! Are vertex buffer objects supported?
+		EVDF_VERTEX_BUFFER_OBJECT,
+
+		//! Supports Alpha To Coverage
+		EVDF_ALPHA_TO_COVERAGE,
+
+		//! Supports Color masks (disabling color planes in output)
+		EVDF_COLOR_MASK,
+
+		//! Supports multiple render targets at once
+		EVDF_MULTIPLE_RENDER_TARGETS,
+
+		//! Supports separate blend settings for multiple render targets
+		EVDF_MRT_BLEND,
+
+		//! Supports separate color masks for multiple render targets
+		EVDF_MRT_COLOR_MASK,
+
+		//! Supports separate blend functions for multiple render targets
+		EVDF_MRT_BLEND_FUNC,
+
+		//! Supports geometry shaders
+		EVDF_GEOMETRY_SHADER,
+
+		//! Supports occlusion queries
+		EVDF_OCCLUSION_QUERY,
+
+		//! Supports polygon offset/depth bias for avoiding z-fighting
+		EVDF_POLYGON_OFFSET,
+
+		//! Support for different blend functions. Without, only ADD is available
+		EVDF_BLEND_OPERATIONS,
+
+		//! Support for texture coord transformation via texture matrix
+		EVDF_TEXTURE_MATRIX,
+
+		//! Support for NVidia's CG shader language
+		EVDF_CG,
+
+		//! Only used for counting the elements of this enum
+		EVDF_COUNT
+	};
+
+} // end namespace video
+} // end namespace irr
+
+
+#endif
+

include/EDriverTypes.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 __E_DRIVER_TYPES_H_INCLUDED__
+#define __E_DRIVER_TYPES_H_INCLUDED__
+
+namespace irr
+{
+namespace video
+{
+
+	//! An enum for all types of drivers the Irrlicht Engine supports.
+	enum E_DRIVER_TYPE
+	{
+		//! Null driver, useful for applications to run the engine without visualisation.
+		/** The null device is able to load textures, but does not
+		render and display any graphics. */
+		EDT_NULL,
+
+		//! The Irrlicht Engine Software renderer.
+		/** Runs on all platforms, with every hardware. It should only
+		be used for 2d graphics, but it can also perform some primitive
+		3d functions. These 3d drawing functions are quite fast, but
+		very inaccurate, and don't even support clipping in 3D mode. */
+		EDT_SOFTWARE,
+
+		//! The Burning's Software Renderer, an alternative software renderer
+		/** Basically it can be described as the Irrlicht Software
+		renderer on steroids. It rasterizes 3D geometry perfectly: It
+		is able to perform correct 3d clipping, perspective correct
+		texture mapping, perspective correct color mapping, and renders
+		sub pixel correct, sub texel correct primitives. In addition,
+		it does bilinear texel filtering and supports more materials
+		than the EDT_SOFTWARE driver. This renderer has been written
+		entirely by Thomas Alten, thanks a lot for this huge
+		contribution. */
+		EDT_BURNINGSVIDEO,
+
+		//! Direct3D8 device, only available on Win32 platforms.
+		/** Performs hardware accelerated rendering of 3D and 2D
+		primitives. */
+		EDT_DIRECT3D8,
+
+		//! Direct3D 9 device, only available on Win32 platforms.
+		/** Performs hardware accelerated rendering of 3D and 2D
+		primitives. */
+		EDT_DIRECT3D9,
+
+		//! OpenGL device, available on most platforms.
+		/** Performs hardware accelerated rendering of 3D and 2D
+		primitives. */
+		EDT_OPENGL,
+
+		//! No driver, just for counting the elements
+		EDT_COUNT
+	};
+
+} // end namespace video
+} // end namespace irr
+
+
+#endif
+

include/EGUIAlignment.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 __E_GUI_ALIGNMENT_H_INCLUDED__
+#define __E_GUI_ALIGNMENT_H_INCLUDED__
+
+namespace irr
+{
+namespace gui
+{
+enum EGUI_ALIGNMENT
+{
+	//! Aligned to parent's top or left side (default)
+	EGUIA_UPPERLEFT=0,
+	//! Aligned to parent's bottom or right side
+	EGUIA_LOWERRIGHT,
+	//! Aligned to the center of parent
+	EGUIA_CENTER,
+	//! Stretched to fit parent
+	EGUIA_SCALE
+};
+
+//! Names for alignments
+const c8* const GUIAlignmentNames[] =
+{
+	"upperLeft",
+	"lowerRight",
+	"center",
+	"scale",
+	0
+};
+
+} // namespace gui
+} // namespace irr
+
+#endif // __E_GUI_ALIGNMENT_H_INCLUDED__
+

include/EGUIElementTypes.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 __E_GUI_ELEMENT_TYPES_H_INCLUDED__
+#define __E_GUI_ELEMENT_TYPES_H_INCLUDED__
+
+#include "irrTypes.h"
+
+namespace irr
+{
+namespace gui
+{
+
+//! List of all basic Irrlicht GUI elements.
+/** An IGUIElement returns this when calling IGUIElement::getType(); */
+enum EGUI_ELEMENT_TYPE
+{
+	//! A button (IGUIButton)
+	EGUIET_BUTTON = 0,
+
+	//! A check box (IGUICheckBox)
+	EGUIET_CHECK_BOX,
+
+	//! A combo box (IGUIComboBox)
+	EGUIET_COMBO_BOX,
+
+	//! A context menu (IGUIContextMenu)
+	EGUIET_CONTEXT_MENU,
+
+	//! A menu (IGUIMenu)
+	EGUIET_MENU,
+
+	//! An edit box (IGUIEditBox)
+	EGUIET_EDIT_BOX,
+
+	//! A file open dialog (IGUIFileOpenDialog)
+	EGUIET_FILE_OPEN_DIALOG,
+
+	//! A color select open dialog (IGUIColorSelectDialog)
+	EGUIET_COLOR_SELECT_DIALOG,
+
+	//! A in/out fader (IGUIInOutFader)
+	EGUIET_IN_OUT_FADER,
+
+	//! An image (IGUIImage)
+	EGUIET_IMAGE,
+
+	//! A list box (IGUIListBox)
+	EGUIET_LIST_BOX,
+
+	//! A mesh viewer (IGUIMeshViewer)
+	EGUIET_MESH_VIEWER,
+
+	//! A message box (IGUIWindow)
+	EGUIET_MESSAGE_BOX,
+
+	//! A modal screen
+	EGUIET_MODAL_SCREEN,
+
+	//! A scroll bar (IGUIScrollBar)
+	EGUIET_SCROLL_BAR,
+
+	//! A spin box (IGUISpinBox)
+	EGUIET_SPIN_BOX,
+
+	//! A static text (IGUIStaticText)
+	EGUIET_STATIC_TEXT,
+
+	//! A tab (IGUITab)
+	EGUIET_TAB,
+
+	//! A tab control
+	EGUIET_TAB_CONTROL,
+
+	//! A Table
+	EGUIET_TABLE,
+
+	//! A tool bar (IGUIToolBar)
+	EGUIET_TOOL_BAR,
+
+	//! A Tree View
+	EGUIET_TREE_VIEW,
+
+	//! A window
+	EGUIET_WINDOW,
+
+	//! Unknown type.
+	EGUIET_ELEMENT,
+
+	//! The root of the GUI
+	EGUIET_ROOT,
+
+	//! Not an element, amount of elements in there
+	EGUIET_COUNT,
+
+	//! This enum is never used, it only forces the compiler to compile this enumeration to 32 bit.
+	EGUIET_FORCE_32_BIT = 0x7fffffff
+
+};
+
+//! Names for built-in element types
+const c8* const GUIElementTypeNames[] =
+{
+	"button",
+	"checkBox",
+	"comboBox",
+	"contextMenu",
+	"menu",
+	"editBox",
+	"fileOpenDialog",
+	"colorSelectDialog",
+	"inOutFader",
+	"image",
+	"listBox",
+	"meshViewer",
+	"messageBox",
+	"modalScreen",
+	"scrollBar",
+	"spinBox",
+	"staticText",
+	"tab",
+	"tabControl",
+	"table",
+	"toolBar",
+	"treeview",
+	"window",
+	"element",
+	"root",
+	0
+};
+
+} // end namespace gui
+} // end namespace irr
+
+#endif
+
+
+
+

include/EHardwareBufferFlags.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 __E_HARDWARE_BUFFER_FLAGS_INCLUDED__
+#define __E_HARDWARE_BUFFER_FLAGS_INCLUDED__
+
+namespace irr
+{
+namespace scene
+{
+
+	enum E_HARDWARE_MAPPING
+	{
+		//! Don't store on the hardware
+		EHM_NEVER=0,
+
+		//! Rarely changed, usually stored completely on the hardware
+		EHM_STATIC,
+
+		//! Sometimes changed, driver optimized placement
+		EHM_DYNAMIC,
+
+		//! Always changed, cache optimizing on the GPU
+		EHM_STREAM
+	};
+
+	enum E_BUFFER_TYPE
+	{
+		//! Does not change anything
+		EBT_NONE=0,
+		//! Change the vertex mapping
+		EBT_VERTEX,
+		//! Change the index mapping
+		EBT_INDEX,
+		//! Change both vertex and index mapping to the same value
+		EBT_VERTEX_AND_INDEX
+	};
+
+} // end namespace scene
+} // end namespace irr
+
+#endif
+

include/EMaterialFlags.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 __E_MATERIAL_FLAGS_H_INCLUDED__
+#define __E_MATERIAL_FLAGS_H_INCLUDED__
+
+namespace irr
+{
+namespace video
+{
+
+	//! Material flags
+	enum E_MATERIAL_FLAG
+	{
+		//! Draw as wireframe or filled triangles? Default: false
+		EMF_WIREFRAME = 0x1,
+
+		//! Draw as point cloud or filled triangles? Default: false
+		EMF_POINTCLOUD = 0x2,
+
+		//! Flat or Gouraud shading? Default: true
+		EMF_GOURAUD_SHADING = 0x4,
+
+		//! Will this material be lighted? Default: true
+		EMF_LIGHTING = 0x8,
+
+		//! Is the ZBuffer enabled? Default: true
+		EMF_ZBUFFER = 0x10,
+
+		//! May be written to the zbuffer or is it readonly. Default: true
+		/** This flag is ignored, if the material type is a transparent type. */
+		EMF_ZWRITE_ENABLE = 0x20,
+
+		//! Is backface culling enabled? Default: true
+		EMF_BACK_FACE_CULLING = 0x40,
+
+		//! Is frontface culling enabled? Default: false
+		/** Overrides EMF_BACK_FACE_CULLING if both are enabled. */
+		EMF_FRONT_FACE_CULLING = 0x80,
+
+		//! Is bilinear filtering enabled? Default: true
+		EMF_BILINEAR_FILTER = 0x100,
+
+		//! Is trilinear filtering enabled? Default: false
+		/** If the trilinear filter flag is enabled,
+		the bilinear filtering flag is ignored. */
+		EMF_TRILINEAR_FILTER = 0x200,
+
+		//! Is anisotropic filtering? Default: false
+		/** In Irrlicht you can use anisotropic texture filtering in
+		conjunction with bilinear or trilinear texture filtering
+		to improve rendering results. Primitives will look less
+		blurry with this flag switched on. */
+		EMF_ANISOTROPIC_FILTER = 0x400,
+
+		//! Is fog enabled? Default: false
+		EMF_FOG_ENABLE = 0x800,
+
+		//! Normalizes normals. Default: false
+		/** You can enable this if you need to scale a dynamic lighted
+		model. Usually, its normals will get scaled too then and it
+		will get darker. If you enable the EMF_NORMALIZE_NORMALS flag,
+		the normals will be normalized again, and the model will look
+		as bright as it should. */
+		EMF_NORMALIZE_NORMALS = 0x1000,
+
+		//! Access to all layers texture wrap settings. Overwrites separate layer settings.
+		EMF_TEXTURE_WRAP = 0x2000,
+
+		//! AntiAliasing mode
+		EMF_ANTI_ALIASING = 0x4000,
+
+		//! ColorMask bits, for enabling the color planes
+		EMF_COLOR_MASK = 0x8000,
+
+		//! ColorMaterial enum for vertex color interpretation
+		EMF_COLOR_MATERIAL = 0x10000,
+
+		//! Flag for enabling/disabling mipmap usage
+		EMF_USE_MIP_MAPS = 0x20000,
+
+		//! Flag for blend operation
+		EMF_BLEND_OPERATION = 0x40000,
+
+		//! Flag for polygon offset
+		EMF_POLYGON_OFFSET = 0x80000
+	};
+
+} // end namespace video
+} // end namespace irr
+
+
+#endif // __E_MATERIAL_FLAGS_H_INCLUDED__
+

include/EMaterialTypes.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 __E_MATERIAL_TYPES_H_INCLUDED__
+#define __E_MATERIAL_TYPES_H_INCLUDED__
+
+namespace irr
+{
+namespace video
+{
+
+	//! Abstracted and easy to use fixed function/programmable pipeline material modes.
+	enum E_MATERIAL_TYPE
+	{
+		//! Standard solid material.
+		/** Only first texture is used, which is supposed to be the
+		diffuse material. */
+		EMT_SOLID = 0,
+
+		//! Solid material with 2 texture layers.
+		/** The second is blended onto the first using the alpha value
+		of the vertex colors. This material is currently not implemented in OpenGL.
+		*/
+		EMT_SOLID_2_LAYER,
+
+		//! Material type with standard lightmap technique
+		/** There should be 2 textures: The first texture layer is a
+		diffuse map, the second is a light map. Dynamic light is
+		ignored. */
+		EMT_LIGHTMAP,
+
+		//! Material type with lightmap technique like EMT_LIGHTMAP.
+		/** But lightmap and diffuse texture are added instead of modulated. */
+		EMT_LIGHTMAP_ADD,
+
+		//! Material type with standard lightmap technique
+		/** There should be 2 textures: The first texture layer is a
+		diffuse map, the second is a light map. Dynamic light is
+		ignored. The texture colors are effectively multiplied by 2
+		for brightening. Like known in DirectX as D3DTOP_MODULATE2X. */
+		EMT_LIGHTMAP_M2,
+
+		//! Material type with standard lightmap technique
+		/** There should be 2 textures: The first texture layer is a
+		diffuse map, the second is a light map. Dynamic light is
+		ignored. The texture colors are effectively multiplyied by 4
+		for brightening. Like known in DirectX as D3DTOP_MODULATE4X. */
+		EMT_LIGHTMAP_M4,
+
+		//! Like EMT_LIGHTMAP, but also supports dynamic lighting.
+		EMT_LIGHTMAP_LIGHTING,
+
+		//! Like EMT_LIGHTMAP_M2, but also supports dynamic lighting.
+		EMT_LIGHTMAP_LIGHTING_M2,
+
+		//! Like EMT_LIGHTMAP_4, but also supports dynamic lighting.
+		EMT_LIGHTMAP_LIGHTING_M4,
+
+		//! Detail mapped material.
+		/** The first texture is diffuse color map, the second is added
+		to this and usually displayed with a bigger scale value so that
+		it adds more detail. The detail map is added to the diffuse map
+		using ADD_SIGNED, so that it is possible to add and substract
+		color from the diffuse map. For example a value of
+		(127,127,127) will not change the appearance of the diffuse map
+		at all. Often used for terrain rendering. */
+		EMT_DETAIL_MAP,
+
+		//! Look like a reflection of the environment around it.
+		/** To make this possible, a texture called 'sphere map' is
+		used, which must be set as the first texture. */
+		EMT_SPHERE_MAP,
+
+		//! A reflecting material with an optional non reflecting texture layer.
+		/** The reflection map should be set as first texture. */
+		EMT_REFLECTION_2_LAYER,
+
+		//! A transparent material.
+		/** Only the first texture is used. The new color is calculated
+		by simply adding the source color and the dest color. This
+		means if for example a billboard using a texture with black
+		background and a red circle on it is drawn with this material,
+		the result is that only the red circle will be drawn a little
+		bit transparent, and everything which was black is 100%
+		transparent and not visible. This material type is useful for
+		particle effects. */
+		EMT_TRANSPARENT_ADD_COLOR,
+
+		//! Makes the material transparent based on the texture alpha channel.
+		/** The final color is blended together from the destination
+		color and the texture color, using the alpha channel value as
+		blend factor. Only first texture is used. If you are using
+		this material with small textures, it is a good idea to load
+		the texture in 32 bit mode
+		(video::IVideoDriver::setTextureCreationFlag()). Also, an alpha
+		ref is used, which can be manipulated using
+		SMaterial::MaterialTypeParam. This value controls how sharp the
+		edges become when going from a transparent to a solid spot on
+		the texture. */
+		EMT_TRANSPARENT_ALPHA_CHANNEL,
+
+		//! Makes the material transparent based on the texture alpha channel.
+		/** If the alpha channel value is greater than 127, a
+		pixel is written to the target, otherwise not. This
+		material does not use alpha blending and is a lot faster
+		than EMT_TRANSPARENT_ALPHA_CHANNEL. It is ideal for drawing
+		stuff like leafes of plants, because the borders are not
+		blurry but sharp. Only first texture is used. If you are
+		using this material with small textures and 3d object, it
+		is a good idea to load the texture in 32 bit mode
+		(video::IVideoDriver::setTextureCreationFlag()). */
+		EMT_TRANSPARENT_ALPHA_CHANNEL_REF,
+
+		//! Makes the material transparent based on the vertex alpha value.
+		EMT_TRANSPARENT_VERTEX_ALPHA,
+
+		//! A transparent reflecting material with an optional additional non reflecting texture layer.
+		/** The reflection map should be set as first texture. The
+		transparency depends on the alpha value in the vertex colors. A
+		texture which will not reflect can be set as second texture.
+		Please note that this material type is currently not 100%
+		implemented in OpenGL. */
+		EMT_TRANSPARENT_REFLECTION_2_LAYER,
+
+		//! A solid normal map renderer.
+		/** First texture is the color map, the second should be the
+		normal map. Note that you should use this material only when
+		drawing geometry consisting of vertices of type
+		S3DVertexTangents (EVT_TANGENTS). You can convert any mesh into
+		this format using IMeshManipulator::createMeshWithTangents()
+		(See SpecialFX2 Tutorial). This shader runs on vertex shader
+		1.1 and pixel shader 1.1 capable hardware and falls back to a
+		fixed function lighted material if this hardware is not
+		available. Only two lights are supported by this shader, if
+		there are more, the nearest two are chosen. */
+		EMT_NORMAL_MAP_SOLID,
+
+		//! A transparent normal map renderer.
+		/** First texture is the color map, the second should be the
+		normal map. Note that you should use this material only when
+		drawing geometry consisting of vertices of type
+		S3DVertexTangents (EVT_TANGENTS). You can convert any mesh into
+		this format using IMeshManipulator::createMeshWithTangents()
+		(See SpecialFX2 Tutorial). This shader runs on vertex shader
+		1.1 and pixel shader 1.1 capable hardware and falls back to a
+		fixed function lighted material if this hardware is not
+		available. Only two lights are supported by this shader, if
+		there are more, the nearest two are chosen. */
+		EMT_NORMAL_MAP_TRANSPARENT_ADD_COLOR,
+
+		//! A transparent (based on the vertex alpha value) normal map renderer.
+		/** First texture is the color map, the second should be the
+		normal map. Note that you should use this material only when
+		drawing geometry consisting of vertices of type
+		S3DVertexTangents (EVT_TANGENTS). You can convert any mesh into
+		this format using IMeshManipulator::createMeshWithTangents()
+		(See SpecialFX2 Tutorial). This shader runs on vertex shader
+		1.1 and pixel shader 1.1 capable hardware and falls back to a
+		fixed function lighted material if this hardware is not
+		available.  Only two lights are supported by this shader, if
+		there are more, the nearest two are chosen. */
+		EMT_NORMAL_MAP_TRANSPARENT_VERTEX_ALPHA,
+
+		//! Just like EMT_NORMAL_MAP_SOLID, but uses parallax mapping.
+		/** Looks a lot more realistic. This only works when the
+		hardware supports at least vertex shader 1.1 and pixel shader
+		1.4. First texture is the color map, the second should be the
+		normal map. The normal map texture should contain the height
+		value in the alpha component. The
+		IVideoDriver::makeNormalMapTexture() method writes this value
+		automatically when creating normal maps from a heightmap when
+		using a 32 bit texture. The height scale of the material
+		(affecting the bumpiness) is being controlled by the
+		SMaterial::MaterialTypeParam member. If set to zero, the
+		default value (0.02f) will be applied. Otherwise the value set
+		in SMaterial::MaterialTypeParam is taken. This value depends on
+		with which scale the texture is mapped on the material. Too
+		high or low values of MaterialTypeParam can result in strange
+		artifacts. */
+		EMT_PARALLAX_MAP_SOLID,
+
+		//! A material like EMT_PARALLAX_MAP_SOLID, but transparent.
+		/** Using EMT_TRANSPARENT_ADD_COLOR as base material. */
+		EMT_PARALLAX_MAP_TRANSPARENT_ADD_COLOR,
+
+		//! A material like EMT_PARALLAX_MAP_SOLID, but transparent.
+		/** Using EMT_TRANSPARENT_VERTEX_ALPHA as base material. */
+		EMT_PARALLAX_MAP_TRANSPARENT_VERTEX_ALPHA,
+
+		//! BlendFunc = source * sourceFactor + dest * destFactor ( E_BLEND_FUNC )
+		/** Using only first texture. Generic blending method. */
+		EMT_ONETEXTURE_BLEND,
+
+		//! This value is not used. It only forces this enumeration to compile to 32 bit.
+		EMT_FORCE_32BIT = 0x7fffffff
+	};
+
+	//! Array holding the built in material type names
+	const char* const sBuiltInMaterialTypeNames[] =
+	{
+		"solid",
+		"solid_2layer",
+		"lightmap",
+		"lightmap_add",
+		"lightmap_m2",
+		"lightmap_m4",
+		"lightmap_light",
+		"lightmap_light_m2",
+		"lightmap_light_m4",
+		"detail_map",
+		"sphere_map",
+		"reflection_2layer",
+		"trans_add",
+		"trans_alphach",
+		"trans_alphach_ref",
+		"trans_vertex_alpha",
+		"trans_reflection_2layer",
+		"normalmap_solid",
+		"normalmap_trans_add",
+		"normalmap_trans_vertexalpha",
+		"parallaxmap_solid",
+		"parallaxmap_trans_add",
+		"parallaxmap_trans_vertexalpha",
+		"onetexture_blend",
+		0
+	};
+
+} // end namespace video
+} // end namespace irr
+
+
+#endif // __E_MATERIAL_TYPES_H_INCLUDED__
+

include/EMeshWriterEnums.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 __E_MESH_WRITER_ENUMS_H_INCLUDED__
+#define __E_MESH_WRITER_ENUMS_H_INCLUDED__
+
+#include "irrTypes.h"
+
+namespace irr
+{
+namespace scene
+{
+
+	//! An enumeration for all supported types of built-in mesh writers
+	/** A scene mesh writers is represented by a four character code
+	such as 'irrm' or 'coll' instead of simple numbers, to avoid
+	name clashes with external mesh writers.*/
+	enum EMESH_WRITER_TYPE
+	{
+		//! Irrlicht native mesh writer, for static .irrmesh files.
+		EMWT_IRR_MESH     = MAKE_IRR_ID('i','r','r','m'),
+
+		//! COLLADA mesh writer for .dae and .xml files
+		EMWT_COLLADA      = MAKE_IRR_ID('c','o','l','l'),
+
+		//! STL mesh writer for .stl files
+		EMWT_STL          = MAKE_IRR_ID('s','t','l',0),
+
+		//! OBJ mesh writer for .obj files
+		EMWT_OBJ          = MAKE_IRR_ID('o','b','j',0),
+
+		//! PLY mesh writer for .ply files
+		EMWT_PLY          = MAKE_IRR_ID('p','l','y',0)
+	};
+
+
+	//! flags configuring mesh writing
+	enum E_MESH_WRITER_FLAGS
+	{
+		//! no writer flags
+		EMWF_NONE = 0,
+
+		//! write lightmap textures out if possible
+		EMWF_WRITE_LIGHTMAPS = 0x1,
+
+		//! write in a way that consumes less disk space
+		EMWF_WRITE_COMPRESSED = 0x2,
+
+		//! write in binary format rather than text
+		EMWF_WRITE_BINARY = 0x4
+	};
+
+} // end namespace scene
+} // end namespace irr
+
+
+#endif // __E_MESH_WRITER_ENUMS_H_INCLUDED__
+

include/EMessageBoxFlags.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 __E_MESSAGE_BOX_FLAGS_H_INCLUDED__
+#define __E_MESSAGE_BOX_FLAGS_H_INCLUDED__
+
+namespace irr
+{
+namespace gui
+{
+
+//! enumeration for message box layout flags
+enum EMESSAGE_BOX_FLAG
+{
+	//! Flag for the ok button
+	EMBF_OK = 0x1,
+
+	//! Flag for the cancel button
+	EMBF_CANCEL = 0x2,
+
+	//! Flag for the yes button
+	EMBF_YES = 0x4,
+
+	//! Flag for the no button
+	EMBF_NO = 0x8,
+
+	//! This value is not used. It only forces this enumeration to compile in 32 bit.
+	EMBF_FORCE_32BIT = 0x7fffffff
+};
+
+} // namespace gui
+} // namespace irr
+
+#endif
+

include/EPrimitiveTypes.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 __E_PRIMITIVE_TYPES_H_INCLUDED__
+#define __E_PRIMITIVE_TYPES_H_INCLUDED__
+
+namespace irr
+{
+namespace scene
+{
+
+	//! Enumeration for all primitive types there are.
+	enum E_PRIMITIVE_TYPE
+	{
+		//! All vertices are non-connected points.
+		EPT_POINTS=0,
+
+		//! All vertices form a single connected line.
+		EPT_LINE_STRIP,
+
+		//! Just as LINE_STRIP, but the last and the first vertex is also connected.
+		EPT_LINE_LOOP,
+
+		//! Every two vertices are connected creating n/2 lines.
+		EPT_LINES,
+
+		//! After the first two vertices each vertex defines a new triangle.
+		//! Always the two last and the new one form a new triangle.
+		EPT_TRIANGLE_STRIP,
+
+		//! After the first two vertices each vertex defines a new triangle.
+		//! All around the common first vertex.
+		EPT_TRIANGLE_FAN,
+
+		//! Explicitly set all vertices for each triangle.
+		EPT_TRIANGLES,
+
+		//! After the first two vertices each further tw vetices create a quad with the preceding two.
+		EPT_QUAD_STRIP,
+
+		//! Every four vertices create a quad.
+		EPT_QUADS,
+
+		//! Just as LINE_LOOP, but filled.
+		EPT_POLYGON,
+
+		//! The single vertices are expanded to quad billboards on the GPU.
+		EPT_POINT_SPRITES
+	};
+
+} // end namespace scene
+} // end namespace irr
+
+#endif
+

include/ESceneNodeAnimatorTypes.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 __E_SCENE_NODE_ANIMATOR_TYPES_H_INCLUDED__
+#define __E_SCENE_NODE_ANIMATOR_TYPES_H_INCLUDED__
+
+namespace irr
+{
+namespace scene
+{
+
+	//! An enumeration for all types of built-in scene node animators
+	enum ESCENE_NODE_ANIMATOR_TYPE
+	{
+		//! Fly circle scene node animator
+		ESNAT_FLY_CIRCLE = 0,
+
+		//! Fly straight scene node animator
+		ESNAT_FLY_STRAIGHT,
+
+		//! Follow spline scene node animator
+		ESNAT_FOLLOW_SPLINE,
+
+		//! Rotation scene node animator
+		ESNAT_ROTATION,
+
+		//! Texture scene node animator
+		ESNAT_TEXTURE,
+
+		//! Deletion scene node animator
+		ESNAT_DELETION,
+
+		//! Collision respose scene node animator
+		ESNAT_COLLISION_RESPONSE,
+
+		//! FPS camera animator
+		ESNAT_CAMERA_FPS,
+
+		//! Maya camera animator
+		ESNAT_CAMERA_MAYA,
+
+		//! Amount of built-in scene node animators
+		ESNAT_COUNT,
+
+		//! Unknown scene node animator
+		ESNAT_UNKNOWN,
+
+		//! This enum is never used, it only forces the compiler to compile this enumeration to 32 bit.
+		ESNAT_FORCE_32_BIT = 0x7fffffff
+	};
+
+} // end namespace scene
+} // end namespace irr
+
+
+#endif
+

include/ESceneNodeTypes.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 __E_SCENE_NODE_TYPES_H_INCLUDED__
+#define __E_SCENE_NODE_TYPES_H_INCLUDED__
+
+#include "irrTypes.h"
+
+namespace irr
+{
+namespace scene
+{
+
+	//! An enumeration for all types of built-in scene nodes
+	/** A scene node type is represented by a four character code
+	such as 'cube' or 'mesh' instead of simple numbers, to avoid
+	name clashes with external scene nodes.*/
+	enum ESCENE_NODE_TYPE
+	{
+		//! of type CSceneManager (note that ISceneManager is not(!) an ISceneNode)
+		ESNT_SCENE_MANAGER	= MAKE_IRR_ID('s','m','n','g'),
+
+		//! simple cube scene node
+		ESNT_CUBE           = MAKE_IRR_ID('c','u','b','e'),
+
+		//! Sphere scene node
+		ESNT_SPHERE         = MAKE_IRR_ID('s','p','h','r'),
+
+		//! Text Scene Node
+		ESNT_TEXT           = MAKE_IRR_ID('t','e','x','t'),
+
+		//! Water Surface Scene Node
+		ESNT_WATER_SURFACE  = MAKE_IRR_ID('w','a','t','r'),
+
+		//! Terrain Scene Node
+		ESNT_TERRAIN        = MAKE_IRR_ID('t','e','r','r'),
+
+		//! Sky Box Scene Node
+		ESNT_SKY_BOX        = MAKE_IRR_ID('s','k','y','_'),
+
+		//! Sky Dome Scene Node
+		ESNT_SKY_DOME       = MAKE_IRR_ID('s','k','y','d'),
+
+		//! Shadow Volume Scene Node
+		ESNT_SHADOW_VOLUME  = MAKE_IRR_ID('s','h','d','w'),
+
+		//! Octree Scene Node
+		ESNT_OCTREE         = MAKE_IRR_ID('o','c','t','r'),
+
+		//! Mesh Scene Node
+		ESNT_MESH           = MAKE_IRR_ID('m','e','s','h'),
+
+		//! Light Scene Node
+		ESNT_LIGHT          = MAKE_IRR_ID('l','g','h','t'),
+
+		//! Empty Scene Node
+		ESNT_EMPTY          = MAKE_IRR_ID('e','m','t','y'),
+
+		//! Dummy Transformation Scene Node
+		ESNT_DUMMY_TRANSFORMATION = MAKE_IRR_ID('d','m','m','y'),
+
+		//! Camera Scene Node
+		ESNT_CAMERA         = MAKE_IRR_ID('c','a','m','_'),
+
+		//! Billboard Scene Node
+		ESNT_BILLBOARD      = MAKE_IRR_ID('b','i','l','l'),
+
+		//! Animated Mesh Scene Node
+		ESNT_ANIMATED_MESH  = MAKE_IRR_ID('a','m','s','h'),
+
+		//! Particle System Scene Node
+		ESNT_PARTICLE_SYSTEM = MAKE_IRR_ID('p','t','c','l'),
+
+		//! Quake3 Shader Scene Node
+		ESNT_Q3SHADER_SCENE_NODE  = MAKE_IRR_ID('q','3','s','h'),
+
+		//! Quake3 Model Scene Node ( has tag to link to )
+		ESNT_MD3_SCENE_NODE  = MAKE_IRR_ID('m','d','3','_'),
+
+		//! Volume Light Scene Node
+		ESNT_VOLUME_LIGHT  = MAKE_IRR_ID('v','o','l','l'),
+
+		//! Maya Camera Scene Node
+		/** Legacy, for loading version <= 1.4.x .irr files */
+		ESNT_CAMERA_MAYA    = MAKE_IRR_ID('c','a','m','M'),
+
+		//! First Person Shooter Camera
+		/** Legacy, for loading version <= 1.4.x .irr files */
+		ESNT_CAMERA_FPS     = MAKE_IRR_ID('c','a','m','F'),
+
+		//! Unknown scene node
+		ESNT_UNKNOWN        = MAKE_IRR_ID('u','n','k','n'),
+
+		//! Will match with any scene node when checking types
+		ESNT_ANY            = MAKE_IRR_ID('a','n','y','_')
+	};
+
+
+
+} // end namespace scene
+} // end namespace irr
+
+
+#endif
+

include/EShaderTypes.h

+#ifndef __E_SHADER_TYPES_H_INCLUDED__
+#define __E_SHADER_TYPES_H_INCLUDED__
+
+#include "irrTypes.h"
+
+namespace irr
+{
+namespace video
+{
+
+//! Compile target enumeration for the addHighLevelShaderMaterial() method.
+enum E_VERTEX_SHADER_TYPE
+{
+	EVST_VS_1_1 = 0,
+	EVST_VS_2_0,
+	EVST_VS_2_a,
+	EVST_VS_3_0,
+	EVST_VS_4_0,
+	EVST_VS_4_1,
+	EVST_VS_5_0,
+
+	//! This is not a type, but a value indicating how much types there are.
+	EVST_COUNT
+};
+
+//! Names for all vertex shader types, each entry corresponds to a E_VERTEX_SHADER_TYPE entry.
+const c8* const VERTEX_SHADER_TYPE_NAMES[] = {
+	"vs_1_1",
+	"vs_2_0",
+	"vs_2_a",
+	"vs_3_0",
+	"vs_4_0",
+	"vs_4_1",
+	"vs_5_0",
+	0 };
+
+//! Compile target enumeration for the addHighLevelShaderMaterial() method.
+enum E_PIXEL_SHADER_TYPE
+{
+	EPST_PS_1_1 = 0,
+	EPST_PS_1_2,
+	EPST_PS_1_3,
+	EPST_PS_1_4,
+	EPST_PS_2_0,
+	EPST_PS_2_a,
+	EPST_PS_2_b,
+	EPST_PS_3_0,
+	EPST_PS_4_0,
+	EPST_PS_4_1,
+	EPST_PS_5_0,
+
+	//! This is not a type, but a value indicating how much types there are.
+	EPST_COUNT
+};
+
+//! Names for all pixel shader types, each entry corresponds to a E_PIXEL_SHADER_TYPE entry.
+const c8* const PIXEL_SHADER_TYPE_NAMES[] = {
+	"ps_1_1",
+	"ps_1_2",
+	"ps_1_3",
+	"ps_1_4",
+	"ps_2_0",
+	"ps_2_a",
+	"ps_2_b",
+	"ps_3_0",
+	"ps_4_0",
+	"ps_4_1",
+	"ps_5_0",
+	0 };
+
+//! Enum for supported geometry shader types
+enum E_GEOMETRY_SHADER_TYPE
+{
+	EGST_GS_4_0 = 0,
+
+	//! This is not a type, but a value indicating how much types there are.
+	EGST_COUNT
+};
+
+//! String names for supported geometry shader types
+const c8* const GEOMETRY_SHADER_TYPE_NAMES[] = {
+	"gs_4_0",
+	0 };
+
+
+} // end namespace video
+} // end namespace irr
+
+#endif // __E_SHADER_TYPES_H_INCLUDED__
+

include/ETerrainElements.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 __E_TERRAIN_ELEMENTS_H__
+#define __E_TERRAIN_ELEMENTS_H__
+
+namespace irr
+{
+namespace scene
+{
+
+	//! enumeration for patch sizes specifying the size of patches in the TerrainSceneNode
+	enum E_TERRAIN_PATCH_SIZE
+	{
+		//! patch size of 9, at most, use 4 levels of detail with this patch size.
+		ETPS_9 = 9,
+
+		//! patch size of 17, at most, use 5 levels of detail with this patch size.
+		ETPS_17 = 17,
+
+		//! patch size of 33, at most, use 6 levels of detail with this patch size.
+		ETPS_33 = 33,
+
+		//! patch size of 65, at most, use 7 levels of detail with this patch size.
+		ETPS_65 = 65,
+
+		//! patch size of 129, at most, use 8 levels of detail with this patch size.
+		ETPS_129 = 129
+	};
+
+} // end namespace scene
+} // end namespace irr
+
+#endif
+

include/IAnimatedMesh.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 __I_ANIMATED_MESH_H_INCLUDED__
+#define __I_ANIMATED_MESH_H_INCLUDED__
+
+#include "aabbox3d.h"
+#include "IMesh.h"
+
+namespace irr
+{
+namespace scene
+{
+	//! Possible types of (animated) meshes.
+	enum E_ANIMATED_MESH_TYPE
+	{
+		//! Unknown animated mesh type.
+		EAMT_UNKNOWN = 0,
+
+		//! Quake 2 MD2 model file
+		EAMT_MD2,
+
+		//! Quake 3 MD3 model file
+		EAMT_MD3,
+
+		//! Maya .obj static model
+		EAMT_OBJ,
+
+		//! Quake 3 .bsp static Map
+		EAMT_BSP,
+
+		//! 3D Studio .3ds file
+		EAMT_3DS,
+
+		//! My3D Mesh, the file format by Zhuck Dimitry
+		EAMT_MY3D,
+
+		//! Pulsar LMTools .lmts file. This Irrlicht loader was written by Jonas Petersen
+		EAMT_LMTS,
+
+		//! Cartography Shop .csm file. This loader was created by Saurav Mohapatra.
+		EAMT_CSM,
+
+		//! .oct file for Paul Nette's FSRad or from Murphy McCauley's Blender .oct exporter.
+		/** The oct file format contains 3D geometry and lightmaps and
+		can be loaded directly by Irrlicht */
+		EAMT_OCT,
+
+		//! Halflife MDL model file
+		EAMT_MDL_HALFLIFE,
+
+		//! generic skinned mesh
+		EAMT_SKINNED
+	};
+
+	//! Interface for an animated mesh.
+	/** There are already simple implementations of this interface available so
+	you don't have to implement this interface on your own if you need to:
+	You might want to use irr::scene::SAnimatedMesh, irr::scene::SMesh,
+	irr::scene::SMeshBuffer etc. */
+	class IAnimatedMesh : public IMesh
+	{
+	public:
+
+		//! Gets the frame count of the animated mesh.
+		/** \return The amount of frames. If the amount is 1,
+		it is a static, non animated mesh. */
+		virtual u32 getFrameCount() const = 0;
+
+		//! Gets the animation speed of the animated mesh.
+		/** \return The number of frames per second to play the
+		animation with by default. If the amount is 0,
+		it is a static, non animated mesh. */
+		virtual f32 getAnimationSpeed() const = 0;
+
+		//! Sets the animation speed of the animated mesh.
+		/** \param fps Number of frames per second to play the
+		animation with by default. If the amount is 0,
+		it is not animated. The actual speed is set in the
+		scene node the mesh is instantiated in.*/
+		virtual void setAnimationSpeed(f32 fps) =0;
+
+		//! Returns the IMesh interface for a frame.
+		/** \param frame: Frame number as zero based index. The maximum
+		frame number is getFrameCount() - 1;
+		\param detailLevel: Level of detail. 0 is the lowest, 255 the
+		highest level of detail. Most meshes will ignore the detail level.
+		\param startFrameLoop: Because some animated meshes (.MD2) are
+		blended between 2 static frames, and maybe animated in a loop,
+		the startFrameLoop and the endFrameLoop have to be defined, to
+		prevent the animation to be blended between frames which are
+		outside of this loop.
+		If startFrameLoop and endFrameLoop are both -1, they are ignored.
+		\param endFrameLoop: see startFrameLoop.
+		\return Returns the animated mesh based on a detail level. */
+		virtual IMesh* getMesh(s32 frame, s32 detailLevel=255, s32 startFrameLoop=-1, s32 endFrameLoop=-1) = 0;
+
+		//! Returns the type of the animated mesh.
+		/** In most cases it is not neccessary to use this method.
+		This is useful for making a safe downcast. For example,
+		if getMeshType() returns EAMT_MD2 it's safe to cast the
+		IAnimatedMesh to IAnimatedMeshMD2.
+		\returns Type of the mesh. */
+		virtual E_ANIMATED_MESH_TYPE getMeshType() const
+		{
+			return EAMT_UNKNOWN;
+		}
+	};
+
+} // end namespace scene
+} // end namespace irr
+
+#endif
+

include/IAnimatedMeshMD2.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 __I_ANIMATED_MESH_MD2_H_INCLUDED__
+#define __I_ANIMATED_MESH_MD2_H_INCLUDED__
+
+#include "IAnimatedMesh.h"
+
+namespace irr
+{
+namespace scene
+{
+
+	//! Types of standard md2 animations
+	enum EMD2_ANIMATION_TYPE
+	{
+		EMAT_STAND = 0,
+		EMAT_RUN,
+		EMAT_ATTACK,
+		EMAT_PAIN_A,
+		EMAT_PAIN_B,
+		EMAT_PAIN_C,
+		EMAT_JUMP,
+		EMAT_FLIP,
+		EMAT_SALUTE,
+		EMAT_FALLBACK,
+		EMAT_WAVE,
+		EMAT_POINT,
+		EMAT_CROUCH_STAND,
+		EMAT_CROUCH_WALK,
+		EMAT_CROUCH_ATTACK,
+		EMAT_CROUCH_PAIN,
+		EMAT_CROUCH_DEATH,
+		EMAT_DEATH_FALLBACK,
+		EMAT_DEATH_FALLFORWARD,
+		EMAT_DEATH_FALLBACKSLOW,
+		EMAT_BOOM,
+
+		//! Not an animation, but amount of animation types.
+		EMAT_COUNT
+	};
+
+	//! Interface for using some special functions of MD2 meshes
+	class IAnimatedMeshMD2 : public IAnimatedMesh
+	{
+	public:
+
+		//! Get frame loop data for a default MD2 animation type.
+		/** \param l The EMD2_ANIMATION_TYPE to get the frames for.
+		\param outBegin The returned beginning frame for animation type specified.
+		\param outEnd The returned ending frame for the animation type specified.
+		\param outFPS The number of frames per second, this animation should be played at.
+		\return beginframe, endframe and frames per second for a default MD2 animation type. */
+		virtual void getFrameLoop(EMD2_ANIMATION_TYPE l, s32& outBegin,
+			s32& outEnd, s32& outFPS) const = 0;
+
+		//! Get frame loop data for a special MD2 animation type, identified by name.
+		/** \param name Name of the animation.
+		\param outBegin The returned beginning frame for animation type specified.
+		\param outEnd The returned ending frame for the animation type specified.
+		\param outFPS The number of frames per second, this animation should be played at.
+		\return beginframe, endframe and frames per second for a special MD2 animation type. */
+		virtual bool getFrameLoop(const c8* name,
+			s32& outBegin, s32& outEnd, s32& outFPS) const = 0;
+
+		//! Get amount of md2 animations in this file.
+		virtual s32 getAnimationCount() const = 0;
+
+		//! Get name of md2 animation.
+		/** \param nr: Zero based index of animation. */
+		virtual const c8* getAnimationName(s32 nr) const = 0;
+	};
+
+} // end namespace scene
+} // end namespace irr
+
+#endif
+

include/IAnimatedMeshMD3.h

+// Copyright (C) 2007-2012 Nikolaus Gebhardt / Thomas Alten
+// This file is part of the "Irrlicht Engine".
+// For conditions of distribution and use, see copyright notice in irrlicht.h
+
+#ifndef __I_ANIMATED_MESH_MD3_H_INCLUDED__
+#define __I_ANIMATED_MESH_MD3_H_INCLUDED__
+
+#include "IAnimatedMesh.h"
+#include "IQ3Shader.h"
+#include "quaternion.h"
+
+namespace irr
+{
+namespace scene
+{
+
+	enum eMD3Models
+	{
+		EMD3_HEAD = 0,
+		EMD3_UPPER,
+		EMD3_LOWER,
+		EMD3_WEAPON,
+		EMD3_NUMMODELS
+	};
+
+	//! Animation list
+	enum EMD3_ANIMATION_TYPE
+	{
+		// Animations for both lower and upper parts of the player
+		EMD3_BOTH_DEATH_1 = 0,
+		EMD3_BOTH_DEAD_1,
+		EMD3_BOTH_DEATH_2,
+		EMD3_BOTH_DEAD_2,
+		EMD3_BOTH_DEATH_3,
+		EMD3_BOTH_DEAD_3,
+
+		// Animations for the upper part
+		EMD3_TORSO_GESTURE,
+		EMD3_TORSO_ATTACK_1,
+		EMD3_TORSO_ATTACK_2,
+		EMD3_TORSO_DROP,
+		EMD3_TORSO_RAISE,
+		EMD3_TORSO_STAND_1,
+		EMD3_TORSO_STAND_2,
+
+		// Animations for the lower part
+		EMD3_LEGS_WALK_CROUCH,
+		EMD3_LEGS_WALK,
+		EMD3_LEGS_RUN,
+		EMD3_LEGS_BACK,
+		EMD3_LEGS_SWIM,
+		EMD3_LEGS_JUMP_1,
+		EMD3_LEGS_LAND_1,
+		EMD3_LEGS_JUMP_2,
+		EMD3_LEGS_LAND_2,
+		EMD3_LEGS_IDLE,
+		EMD3_LEGS_IDLE_CROUCH,
+		EMD3_LEGS_TURN,
+
+		//! Not an animation, but amount of animation types.
+		EMD3_ANIMATION_COUNT
+	};
+
+	struct SMD3AnimationInfo
+	{
+		//! First frame
+		s32 first;
+		//! Last frame
+		s32 num;
+		//! Looping frames
+		s32 looping;
+		//! Frames per second
+		s32 fps;
+	};
+
+
+// byte-align structures
+#include "irrpack.h"
+
+	//! this holds the header info of the MD3 file
+	struct SMD3Header
+	{
+		c8	headerID[4];	//id of file, always "IDP3"
+		s32	Version;	//this is a version number, always 15
+		s8	fileName[68];	//sometimes left Blank... 65 chars, 32bit aligned == 68 chars
+		s32	numFrames;	//number of KeyFrames
+		s32	numTags;	//number of 'tags' per frame
+		s32	numMeshes;	//number of meshes/skins
+		s32	numMaxSkins;	//maximum number of unique skins used in md3 file. artefact md2
+		s32	frameStart;	//starting position of frame-structur
+		s32	tagStart;	//starting position of tag-structures
+		s32	tagEnd;		//ending position of tag-structures/starting position of mesh-structures
+		s32	fileSize;
+	} PACK_STRUCT;
+
+	//! this holds the header info of an MD3 mesh section
+	struct SMD3MeshHeader
+	{
+		c8 meshID[4];		//id, must be IDP3
+		c8 meshName[68];	//name of mesh 65 chars, 32 bit aligned == 68 chars
+
+		s32 numFrames;		//number of meshframes in mesh
+		s32 numShader;		//number of skins in mesh
+		s32 numVertices;	//number of vertices
+		s32 numTriangles;	//number of Triangles
+
+		s32 offset_triangles;	//starting position of Triangle data, relative to start of Mesh_Header
+		s32 offset_shaders;	//size of header
+		s32 offset_st;		//starting position of texvector data, relative to start of Mesh_Header
+		s32 vertexStart;	//starting position of vertex data,relative to start of Mesh_Header
+		s32 offset_end;
+	} PACK_STRUCT;
+
+
+	//! Compressed Vertex Data
+	struct SMD3Vertex
+	{
+		s16 position[3];
+		u8 normal[2];
+	} PACK_STRUCT;
+
+	//! Texture Coordinate
+	struct SMD3TexCoord
+	{
+		f32 u;
+		f32 v;
+	} PACK_STRUCT;
+
+	//! Triangle Index
+	struct SMD3Face
+	{
+		s32 Index[3];
+	} PACK_STRUCT;
+
+
+// Default alignment
+#include "irrunpack.h"
+
+	//! Holding Frame Data for a Mesh
+	struct SMD3MeshBuffer : public IReferenceCounted
+	{
+		SMD3MeshHeader MeshHeader;
+
+		core::stringc Shader;
+		core::array < s32 > Indices;
+		core::array < SMD3Vertex > Vertices;
+		core::array < SMD3TexCoord > Tex;
+	};
+
+	//! hold a tag info for connecting meshes
+	/** Basically its an alternate way to describe a transformation. */
+	struct SMD3QuaternionTag
+	{
+		virtual ~SMD3QuaternionTag()
+		{
+			position.X = 0.f;
+		}
+
+		// construct copy constructor
+		SMD3QuaternionTag( const SMD3QuaternionTag & copyMe )
+		{
+			*this = copyMe;
+		}
+
+		// construct for searching
+		SMD3QuaternionTag( const core::stringc& name )
+			: Name ( name ) {}
+
+		// construct from a position and euler angles in degrees
+		SMD3QuaternionTag ( const core::vector3df &pos, const core::vector3df &angle )
+			: position(pos), rotation(angle * core::DEGTORAD) {}
+
+		// set to matrix
+		void setto ( core::matrix4 &m )
+		{
+			rotation.getMatrix ( m, position );
+		}
+
+		bool operator == ( const SMD3QuaternionTag &other ) const
+		{
+			return Name == other.Name;
+		}
+
+		SMD3QuaternionTag & operator=( const SMD3QuaternionTag & copyMe )
+		{
+			Name = copyMe.Name;
+			position = copyMe.position;
+			rotation = copyMe.rotation;
+			return *this;
+		}
+
+		core::stringc Name;
+		core::vector3df position;
+		core::quaternion rotation;
+	};
+
+	//! holds a associative list of named quaternions
+	struct SMD3QuaternionTagList
+	{
+		SMD3QuaternionTagList()
+		{
+			Container.setAllocStrategy(core::ALLOC_STRATEGY_SAFE);
+		}
+
+		// construct copy constructor
+		SMD3QuaternionTagList(const SMD3QuaternionTagList& copyMe)
+		{
+			*this = copyMe;
+		}
+
+		virtual ~SMD3QuaternionTagList() {}
+
+		SMD3QuaternionTag* get(const core::stringc& name)
+		{
+			SMD3QuaternionTag search ( name );
+			s32 index = Container.linear_search ( search );
+			if ( index >= 0 )
+				return &Container[index];
+			return 0;
+		}
+
+		u32 size () const
+		{
+			return Container.size();
+		}
+
+		void set_used(u32 new_size)
+		{
+			s32 diff = (s32) new_size - (s32) Container.allocated_size();
+			if ( diff > 0 )
+			{
+				SMD3QuaternionTag e("");
+				for ( s32 i = 0; i < diff; ++i )
+					Container.push_back(e);
+			}
+		}
+
+		const SMD3QuaternionTag& operator[](u32 index) const
+		{
+			return Container[index];
+		}
+
+		SMD3QuaternionTag& operator[](u32 index)
+		{
+			return Container[index];
+		}
+
+		void push_back(const SMD3QuaternionTag& other)
+		{
+			Container.push_back(other);
+		}
+
+		SMD3QuaternionTagList& operator = (const SMD3QuaternionTagList & copyMe)
+		{
+			Container = copyMe.Container;
+			return *this;
+		}
+
+	private:
+		core::array < SMD3QuaternionTag > Container;
+	};
+
+
+	//! Holding Frames Buffers and Tag Infos
+	struct SMD3Mesh: public IReferenceCounted
+	{
+		SMD3Mesh ()
+		{
+			MD3Header.numFrames = 0;
+		}
+
+		virtual ~SMD3Mesh()
+		{
+			for (u32 i=0; i<Buffer.size(); ++i)
+				Buffer[i]->drop();
+		}
+
+		core::stringc Name;
+		core::array<SMD3MeshBuffer*> Buffer;
+		SMD3QuaternionTagList TagList;
+		SMD3Header MD3Header;
+	};
+
+
+	//! Interface for using some special functions of MD3 meshes
+	class IAnimatedMeshMD3 : public IAnimatedMesh
+	{
+	public:
+
+		//! tune how many frames you want to render inbetween.
+		virtual void setInterpolationShift(u32 shift, u32 loopMode) =0;
+
+		//! get the tag list of the mesh.
+		virtual SMD3QuaternionTagList* getTagList(s32 frame, s32 detailLevel, s32 startFrameLoop, s32 endFrameLoop) =0;
+
+		//! get the original md3 mesh.
+		virtual SMD3Mesh* getOriginalMesh() =0;
+	};
+
+} // end namespace scene
+} // end namespace irr
+
+#endif
+

include/IAnimatedMeshSceneNode.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 __I_ANIMATED_MESH_SCENE_NODE_H_INCLUDED__
+#define __I_ANIMATED_MESH_SCENE_NODE_H_INCLUDED__
+
+#include "ISceneNode.h"
+#include "IBoneSceneNode.h"
+#include "IAnimatedMeshMD2.h"
+#include "IAnimatedMeshMD3.h"
+
+namespace irr
+{
+namespace scene
+{
+	class IShadowVolumeSceneNode;
+
+	enum E_JOINT_UPDATE_ON_RENDER
+	{
+		//! do nothing
+		EJUOR_NONE = 0,
+
+		//! get joints positions from the mesh (for attached nodes, etc)
+		EJUOR_READ,
+
+		//! control joint positions in the mesh (eg. ragdolls, or set the animation from animateJoints() )
+		EJUOR_CONTROL
+	};
+
+
+	class IAnimatedMeshSceneNode;
+
+	//! Callback interface for catching events of ended animations.
+	/** Implement this interface and use
+	IAnimatedMeshSceneNode::setAnimationEndCallback to be able to
+	be notified if an animation playback has ended.
+	**/
+	class IAnimationEndCallBack : public virtual IReferenceCounted
+	{
+	public:
+
+		//! Will be called when the animation playback has ended.
+		/** See IAnimatedMeshSceneNode::setAnimationEndCallback for
+		more informations.
+		\param node: Node of which the animation has ended. */
+		virtual void OnAnimationEnd(IAnimatedMeshSceneNode* node) = 0;
+	};
+
+	//! Scene node capable of displaying an animated mesh and its shadow.
+	/** The shadow is optional: If a shadow should be displayed too, just
+	invoke the IAnimatedMeshSceneNode::createShadowVolumeSceneNode().*/
+	class IAnimatedMeshSceneNode : public ISceneNode
+	{
+	public:
+
+		//! Constructor
+		IAnimatedMeshSceneNode(ISceneNode* parent, ISceneManager* mgr, s32 id,
+			const core::vector3df& position = core::vector3df(0,0,0),
+			const core::vector3df& rotation = core::vector3df(0,0,0),
+			const core::vector3df& scale = core::vector3df(1.0f, 1.0f, 1.0f))
+			: ISceneNode(parent, mgr, id, position, rotation, scale) {}
+
+		//! Destructor
+		virtual ~IAnimatedMeshSceneNode() {}
+
+		//! Sets the current frame number.
+		/** From now on the animation is played from this frame.
+		\param frame: Number of the frame to let the animation be started from.
+		The frame number must be a valid frame number of the IMesh used by this
+		scene node. Set IAnimatedMesh::getMesh() for details. */
+		virtual void setCurrentFrame(f32 frame) = 0;
+
+		//! Sets the frame numbers between the animation is looped.
+		/** The default is 0 - MaximalFrameCount of the mesh.
+		\param begin: Start frame number of the loop.
+		\param end: End frame number of the loop.
+		\return True if successful, false if not. */
+		virtual bool setFrameLoop(s32 begin, s32 end) = 0;
+
+		//! Sets the speed with which the animation is played.
+		/** \param framesPerSecond: Frames per second played. */
+		virtual void setAnimationSpeed(f32 framesPerSecond) = 0;
+
+		//! Gets the speed with which the animation is played.
+		/** \return Frames per second played. */
+		virtual f32 getAnimationSpeed() const =0;
+
+		//! Creates shadow volume scene node as child of this node.
+		/** The shadow can be rendered using the ZPass or the zfail
+		method. ZPass is a little bit faster because the shadow volume
+		creation is easier, but with this method there occur ugly
+		looking artifacs when the camera is inside the shadow volume.
+		These error do not occur with the ZFail method.
+		\param shadowMesh: Optional custom mesh for shadow volume.
+		\param id: Id of the shadow scene node. This id can be used to
+		identify the node later.
+		\param zfailmethod: If set to true, the shadow will use the
+		zfail method, if not, zpass is used.
+		\param infinity: Value used by the shadow volume algorithm to
+		scale the shadow volume (for zfail shadow volume we support only
+		finite shadows, so camera zfar must be larger than shadow back cap,
+		which is depend on infinity parameter).
+		\return Pointer to the created shadow scene node. This pointer
+		should not be dropped. See IReferenceCounted::drop() for more
+		information. */
+		virtual IShadowVolumeSceneNode* addShadowVolumeSceneNode(const IMesh* shadowMesh=0,
+			s32 id=-1, bool zfailmethod=true, f32 infinity=1000.0f) = 0;
+
+
+		//! Get a pointer to a joint in the mesh (if the mesh is a bone based mesh).
+		/** With this method it is possible to attach scene nodes to
+		joints for example possible to attach a weapon to the left hand
+		of an animated model. This example shows how:
+		\code
+		ISceneNode* hand =
+			yourAnimatedMeshSceneNode->getJointNode("LeftHand");
+		hand->addChild(weaponSceneNode);
+		\endcode
+		Please note that the joint returned by this method may not exist
+		before this call and the joints in the node were created by it.
+		\param jointName: Name of the joint.
+		\return Pointer to the scene node which represents the joint
+		with the specified name. Returns 0 if the contained mesh is not
+		an skinned mesh or the name of the joint could not be found. */
+		virtual IBoneSceneNode* getJointNode(const c8* jointName)=0;
+
+		//! same as getJointNode(const c8* jointName), but based on id
+		virtual IBoneSceneNode* getJointNode(u32 jointID) = 0;
+
+		//! Gets joint count.
+		/** \return Amount of joints in the mesh. */
+		virtual u32 getJointCount() const = 0;
+
+		//! Starts a default MD2 animation.
+		/** With this method it is easily possible to start a Run,
+		Attack, Die or whatever animation, if the mesh contained in
+		this scene node is an md2 mesh. Otherwise, nothing happens.
+		\param anim: An MD2 animation type, which should be played, for
+		example EMAT_STAND for the standing animation.
+		\return True if successful, and false if not, for example if
+		the mesh in the scene node is not a md2 mesh. */
+		virtual bool setMD2Animation(EMD2_ANIMATION_TYPE anim) = 0;
+
+		//! Starts a special MD2 animation.
+		/** With this method it is easily possible to start a Run,
+		Attack, Die or whatever animation, if the mesh contained in
+		this scene node is an md2 mesh. Otherwise, nothing happens.
+		This method uses a character string to identify the animation.
+		If the animation is a standard md2 animation, you might want to
+		start this animation with the EMD2_ANIMATION_TYPE enumeration
+		instead.
+		\param animationName: Name of the animation which should be
+		played.
+		\return Returns true if successful, and false if not, for
+		example if the mesh in the scene node is not an md2 mesh, or no
+		animation with this name could be found. */
+		virtual bool setMD2Animation(const c8* animationName) = 0;
+
+		//! Returns the currently displayed frame number.
+		virtual f32 getFrameNr() const = 0;
+		//! Returns the current start frame number.
+		virtual s32 getStartFrame() const = 0;
+		//! Returns the current end frame number.
+		virtual s32 getEndFrame() const = 0;
+
+		//! Sets looping mode which is on by default.
+		/** If set to false, animations will not be played looped. */
+		virtual void setLoopMode(bool playAnimationLooped) = 0;
+
+		//! returns the current loop mode
+		/** When true the animations are played looped */
+		virtual bool getLoopMode() const = 0;
+
+		//! Sets a callback interface which will be called if an animation playback has ended.
+		/** Set this to 0 to disable the callback again.
+		Please note that this will only be called when in non looped
+		mode, see IAnimatedMeshSceneNode::setLoopMode(). */
+		virtual void setAnimationEndCallback(IAnimationEndCallBack* callback=0) = 0;
+
+		//! Sets if the scene node should not copy the materials of the mesh but use them in a read only style.
+		/** In this way it is possible to change the materials a mesh
+		causing all mesh scene nodes referencing this mesh to change
+		too. */
+		virtual void setReadOnlyMaterials(bool readonly) = 0;
+
+		//! Returns if the scene node should not copy the materials of the mesh but use them in a read only style
+		virtual bool isReadOnlyMaterials() const = 0;
+
+		//! Sets a new mesh
+		virtual void setMesh(IAnimatedMesh* mesh) = 0;
+
+		//! Returns the current mesh
+		virtual IAnimatedMesh* getMesh(void) = 0;
+
+		//! Get the absolute transformation for a special MD3 Tag if the mesh is a md3 mesh, or the absolutetransformation if it's a normal scenenode
+		virtual const SMD3QuaternionTag* getMD3TagTransformation( const core::stringc & tagname) = 0;
+
+		//! Set how the joints should be updated on render
+		virtual void setJointMode(E_JOINT_UPDATE_ON_RENDER mode)=0;
+
+		//! Sets the transition time in seconds
+		/** Note: This needs to enable joints, and setJointmode set to
+		EJUOR_CONTROL. You must call animateJoints(), or the mesh will
+		not animate. */
+		virtual void setTransitionTime(f32 Time) =0;
+
+		//! animates the joints in the mesh based on the current frame.
+		/** Also takes in to account transitions. */
+		virtual void animateJoints(bool CalculateAbsolutePositions=true) = 0;
+
+		//! render mesh ignoring its transformation.
+		/** Culling is unaffected. */
+		virtual void setRenderFromIdentity( bool On )=0;
+
+		//! Creates a clone of this scene node and its children.
+		/** \param newParent An optional new parent.
+		\param newManager An optional new scene manager.
+		\return The newly created clone of this node. */
+		virtual ISceneNode* clone(ISceneNode* newParent=0, ISceneManager* newManager=0) = 0;
+
+	};
+
+} // end namespace scene
+} // end namespace irr
+
+#endif
+

include/IAttributeExchangingObject.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 __I_ATTRIBUTE_EXCHANGING_OBJECT_H_INCLUDED__
+#define __I_ATTRIBUTE_EXCHANGING_OBJECT_H_INCLUDED__
+
+#include "IReferenceCounted.h"
+
+
+namespace irr
+{
+
+namespace io
+{
+
+class IAttributes;
+
+//! Enumeration flags passed through SAttributeReadWriteOptions to the IAttributeExchangingObject object
+enum E_ATTRIBUTE_READ_WRITE_FLAGS
+{
+	//! Serialization/Deserializion is done for an xml file
+	EARWF_FOR_FILE = 0x00000001,
+
+	//! Serialization/Deserializion is done for an editor property box
+	EARWF_FOR_EDITOR = 0x00000002,
+
+	//! When writing filenames, relative paths should be used
+	EARWF_USE_RELATIVE_PATHS = 0x00000004
+};
+
+
+//! struct holding data describing options
+struct SAttributeReadWriteOptions
+{
+	//! Constructor
+	SAttributeReadWriteOptions()
+		: Flags(0), Filename(0)
+	{
+	}
+
+	//! Combination of E_ATTRIBUTE_READ_WRITE_FLAGS or other, custom ones
+	s32 Flags;
+
+	//! Optional filename
+	const fschar_t* Filename;
+};
+
+
+//! An object which is able to serialize and deserialize its attributes into an attributes object
+class IAttributeExchangingObject : virtual public IReferenceCounted
+{
+public:
+
+	//! Writes attributes of the object.
+	/** Implement this to expose the attributes of your scene node animator for
+	scripting languages, editors, debuggers or xml serialization purposes. */
+	virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options=0) const {}
+
+	//! Reads attributes of the object.
+	/** Implement this to set the attributes of your scene node animator for
+	scripting languages, editors, debuggers or xml deserialization purposes. */
+	virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options=0) {}
+
+};
+
+} // end namespace io
+} // end namespace irr
+
+#endif
+

include/IBillboardSceneNode.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 __I_BILLBOARD_SCENE_NODE_H_INCLUDED__
+#define __I_BILLBOARD_SCENE_NODE_H_INCLUDED__
+
+#include "ISceneNode.h"
+
+namespace irr
+{
+namespace scene
+{
+
+//! A billboard scene node.
+/** A billboard is like a 3d sprite: A 2d element,
+which always looks to the camera. It is usually used for explosions, fire,
+lensflares, particles and things like that.
+*/
+class IBillboardSceneNode : public ISceneNode
+{
+public:
+
+	//! Constructor
+	IBillboardSceneNode(ISceneNode* parent, ISceneManager* mgr, s32 id,
+		const core::vector3df& position = core::vector3df(0,0,0))
+		: ISceneNode(parent, mgr, id, position) {}
+
+	//! Sets the size of the billboard, making it rectangular.
+	virtual void setSize(const core::dimension2d<f32>& size) = 0;
+
+	//! Sets the size of the billboard with independent widths of the bottom and top edges.
+	/** \param[in] height The height of the billboard.
+	\param[in] bottomEdgeWidth The width of the bottom edge of the billboard.
+	\param[in] topEdgeWidth The width of the top edge of the billboard.
+	*/
+	virtual void setSize(f32 height, f32 bottomEdgeWidth, f32 topEdgeWidth) = 0;
+
+	//! Returns the size of the billboard.
+	/** This will return the width of the bottom edge of the billboard.
+	Use getWidths() to retrieve the bottom and top edges independently.
+	\return Size of the billboard.
+	*/
+	virtual const core::dimension2d<f32>& getSize() const = 0;
+
+	//! Gets the size of the the billboard and handles independent top and bottom edge widths correctly.
+	/** \param[out] height The height of the billboard.
+	\param[out] bottomEdgeWidth The width of the bottom edge of the billboard.
+	\param[out] topEdgeWidth The width of the top edge of the billboard.
+	*/
+	virtual void getSize(f32& height, f32& bottomEdgeWidth, f32& topEdgeWidth) const =0;
+
+	//! Set the color of all vertices of the billboard
+	/** \param[in] overallColor Color to set */
+	virtual void setColor(const video::SColor& overallColor) = 0;
+
+	//! Set the color of the top and bottom vertices of the billboard
+	/** \param[in] topColor Color to set the top vertices
+	\param[in] bottomColor Color to set the bottom vertices */
+	virtual void setColor(const video::SColor& topColor,
+			const video::SColor& bottomColor) = 0;
+
+	//! Gets the color of the top and bottom vertices of the billboard
+	/** \param[out] topColor Stores the color of the top vertices
+	\param[out] bottomColor Stores the color of the bottom vertices */
+	virtual void getColor(video::SColor& topColor,
+			video::SColor& bottomColor) const = 0;
+};
+
+} // end namespace scene
+} // end namespace irr
+
+
+#endif
+

include/IBillboardTextSceneNode.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 __I_BILLBOARD_TEXT_SCENE_NODE_H_INCLUDED__
+#define __I_BILLBOARD_TEXT_SCENE_NODE_H_INCLUDED__
+
+#include "IBillboardSceneNode.h"
+
+namespace irr
+{
+namespace scene
+{
+
+//! A billboard text scene node.
+/** Acts like a billboard which displays the currently set text.
+  Due to the exclusion of RTTI in Irrlicht we have to avoid multiple
+  inheritance. Hence, changes to the ITextSceneNode interface have
+  to be copied here manually.
+*/
+class IBillboardTextSceneNode : public IBillboardSceneNode
+{
+public:
+
+	//! Constructor
+	IBillboardTextSceneNode(ISceneNode* parent, ISceneManager* mgr, s32 id,
+		const core::vector3df& position = core::vector3df(0,0,0))
+		: IBillboardSceneNode(parent, mgr, id, position) {}
+
+	//! Sets the size of the billboard.
+	virtual void setSize(const core::dimension2d<f32>& size) = 0;
+
+	//! Returns the size of the billboard.
+	virtual const core::dimension2d<f32>& getSize() const = 0;
+
+	//! Set the color of all vertices of the billboard
+	/** \param overallColor: the color to set */
+	virtual void setColor(const video::SColor & overallColor) = 0;
+
+	//! Set the color of the top and bottom vertices of the billboard
+	/** \param topColor: the color to set the top vertices
+	\param bottomColor: the color to set the bottom vertices */
+	virtual void setColor(const video::SColor & topColor, const video::SColor & bottomColor) = 0;
+
+	//! Gets the color of the top and bottom vertices of the billboard
+	/** \param topColor: stores the color of the top vertices
+	\param bottomColor: stores the color of the bottom vertices */
+	virtual void getColor(video::SColor & topColor, video::SColor & bottomColor) const = 0;
+
+	//! sets the text string
+	virtual void setText(const wchar_t* text) = 0;
+
+	//! sets the color of the text
+	virtual void setTextColor(video::SColor color) = 0;
+};
+
+} // end namespace scene
+} // end namespace irr
+
+
+#endif
+

include/IBoneSceneNode.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 __I_BONE_SCENE_NODE_H_INCLUDED__
+#define __I_BONE_SCENE_NODE_H_INCLUDED__
+
+#include "ISceneNode.h"
+
+namespace irr
+{
+namespace scene
+{
+
+	//! Enumeration for different bone animation modes
+	enum E_BONE_ANIMATION_MODE
+	{
+		//! The bone is usually animated, unless it's parent is not animated
+		EBAM_AUTOMATIC=0,
+
+		//! The bone is animated by the skin, if it's parent is not animated then animation will resume from this bone onward
+		EBAM_ANIMATED,
+
+		//! The bone is not animated by the skin
+		EBAM_UNANIMATED,
+
+		//! Not an animation mode, just here to count the available modes
+		EBAM_COUNT
+
+	};
+
+	enum E_BONE_SKINNING_SPACE
+	{
+		//! local skinning, standard
+		EBSS_LOCAL=0,
+
+		//! global skinning
+		EBSS_GLOBAL,
+
+		EBSS_COUNT
+	};
+
+	//! Names for bone animation modes
+	const c8* const BoneAnimationModeNames[] =
+	{
+		"automatic",
+		"animated",
+		"unanimated",
+		0,
+	};
+
+
+	//! Interface for bones used for skeletal animation.
+	/** Used with ISkinnedMesh and IAnimatedMeshSceneNode. */
+	class IBoneSceneNode : public ISceneNode
+	{
+	public:
+
+		IBoneSceneNode(ISceneNode* parent, ISceneManager* mgr, s32 id=-1) :
+			ISceneNode(parent, mgr, id),positionHint(-1),scaleHint(-1),rotationHint(-1) { }
+
+		//! Get the name of the bone
+		/** \deprecated Use getName instead. This method may be removed by Irrlicht 1.9 */
+		_IRR_DEPRECATED_ virtual const c8* getBoneName() const { return getName(); }
+
+		//! Get the index of the bone
+		virtual u32 getBoneIndex() const = 0;
+
+		//! Sets the animation mode of the bone.
+		/** \return True if successful. (Unused) */
+		virtual bool setAnimationMode(E_BONE_ANIMATION_MODE mode) = 0;
+
+		//! Gets the current animation mode of the bone
+		virtual E_BONE_ANIMATION_MODE getAnimationMode() const = 0;
+
+		//! Get the axis aligned bounding box of this node
+		virtual const core::aabbox3d<f32>& getBoundingBox() const = 0;
+
+		//! Returns the relative transformation of the scene node.
+		//virtual core::matrix4 getRelativeTransformation() const = 0;
+
+		//! The animation method.
+		virtual void OnAnimate(u32 timeMs) =0;
+
+		//! The render method.
+		/** Does nothing as bones are not visible. */
+		virtual void render() { }
+
+		//! How the relative transformation of the bone is used
+		virtual void setSkinningSpace( E_BONE_SKINNING_SPACE space ) =0;
+
+		//! How the relative transformation of the bone is used
+		virtual E_BONE_SKINNING_SPACE getSkinningSpace() const =0;
+
+		//! Updates the absolute position based on the relative and the parents position
+		virtual void updateAbsolutePositionOfAllChildren()=0;
+
+		s32 positionHint;
+		s32 scaleHint;
+		s32 rotationHint;
+	};
+
+
+} // end namespace scene
+} // end namespace irr
+
+#endif
+

include/ICameraSceneNode.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 __I_CAMERA_SCENE_NODE_H_INCLUDED__
+#define __I_CAMERA_SCENE_NODE_H_INCLUDED__
+
+#include "ISceneNode.h"
+#include "IEventReceiver.h"
+
+namespace irr
+{
+namespace scene
+{
+	struct SViewFrustum;
+
+	//! Scene Node which is a (controlable) camera.
+	/** The whole scene will be rendered from the cameras point of view.
+	Because the ICameraScenNode is a SceneNode, it can be attached to any
+	other scene node, and will follow its parents movement, rotation and so
+	on.
+	*/
+	class ICameraSceneNode : public ISceneNode, public IEventReceiver
+	{
+	public:
+
+		//! Constructor
+		ICameraSceneNode(ISceneNode* parent, ISceneManager* mgr, s32 id,
+			const core::vector3df& position = core::vector3df(0,0,0),
+			const core::vector3df& rotation = core::vector3df(0,0,0),
+			const core::vector3df& scale = core::vector3df(1.0f,1.0f,1.0f))
+			: ISceneNode(parent, mgr, id, position, rotation, scale), IsOrthogonal(false) {}
+
+		//! Sets the projection matrix of the camera.
+		/** The core::matrix4 class has some methods to build a
+		projection matrix. e.g:
+		core::matrix4::buildProjectionMatrixPerspectiveFovLH.
+		Note that the matrix will only stay as set by this method until
+		one of the following Methods are called: setNearValue,
+		setFarValue, setAspectRatio, setFOV.
+		\param projection The new projection matrix of the camera.
+		\param isOrthogonal Set this to true if the matrix is an
+		orthogonal one (e.g. from matrix4::buildProjectionMatrixOrtho).
+		*/
+		virtual void setProjectionMatrix(const core::matrix4& projection, bool isOrthogonal=false) =0;
+
+		//! Gets the current projection matrix of the camera.
+		/** \return The current projection matrix of the camera. */
+		virtual const core::matrix4& getProjectionMatrix() const =0;
+
+		//! Gets the current view matrix of the camera.
+		/** \return The current view matrix of the camera. */
+		virtual const core::matrix4& getViewMatrix() const =0;
+
+		//! Sets a custom view matrix affector.
+		/** The matrix passed here, will be multiplied with the view
+		matrix when it gets updated. This allows for custom camera
+		setups like, for example, a reflection camera.
+		\param affector The affector matrix. */
+		virtual void setViewMatrixAffector(const core::matrix4& affector) =0;
+
+		//! Get the custom view matrix affector.
+		/** \return The affector matrix. */
+		virtual const core::matrix4& getViewMatrixAffector() const =0;
+
+		//! It is possible to send mouse and key events to the camera.
+		/** Most cameras may ignore this input, but camera scene nodes
+		which are created for example with
+		ISceneManager::addCameraSceneNodeMaya or
+		ISceneManager::addCameraSceneNodeFPS, may want to get
+		this input for changing their position, look at target or
+		whatever. */
+		virtual bool OnEvent(const SEvent& event) =0;
+
+		//! Sets the look at target of the camera
+		/** If the camera's target and rotation are bound ( @see
+		bindTargetAndRotation() ) then calling this will also change
+		the camera's scene node rotation to match the target.
+		Note that setTarget uses the current absolute position 
+		internally, so if you changed setPosition since last rendering you must
+		call updateAbsolutePosition before using this function.
+		\param pos Look at target of the camera, in world co-ordinates. */
+		virtual void setTarget(const core::vector3df& pos) =0;
+
+		//! Sets the rotation of the node.
+		/** This only modifies the relative rotation of the node.
+		If the camera's target and rotation are bound ( @see
+		bindTargetAndRotation() ) then calling this will also change
+		the camera's target to match the rotation.
+		\param rotation New rotation of the node in degrees. */
+		virtual void setRotation(const core::vector3df& rotation) =0;
+
+		//! Gets the current look at target of the camera
+		/** \return The current look at target of the camera, in world co-ordinates */
+		virtual const core::vector3df& getTarget() const =0;
+
+		//! Sets the up vector of the camera.
+		/** \param pos: New upvector of the camera. */
+		virtual void setUpVector(const core::vector3df& pos) =0;
+
+		//! Gets the up vector of the camera.
+		/** \return The up vector of the camera, in world space. */
+		virtual const core::vector3df& getUpVector() const =0;
+
+		//! Gets the value of the near plane of the camera.
+		/** \return The value of the near plane of the camera. */
+		virtual f32 getNearValue() const =0;
+
+		//! Gets the value of the far plane of the camera.
+		/** \return The value of the far plane of the camera. */
+		virtual f32 getFarValue() const =0;
+
+		//! Gets the aspect ratio of the camera.
+		/** \return The aspect ratio of the camera. */
+		virtual f32 getAspectRatio() const =0;
+
+		//! Gets the field of view of the camera.
+		/** \return The field of view of the camera in radians. */
+		virtual f32 getFOV() const =0;
+
+		//! Sets the value of the near clipping plane. (default: 1.0f)
+		/** \param zn: New z near value. */
+		virtual void setNearValue(f32 zn) =0;
+
+		//! Sets the value of the far clipping plane (default: 2000.0f)
+		/** \param zf: New z far value. */
+		virtual void setFarValue(f32 zf) =0;
+
+		//! Sets the aspect ratio (default: 4.0f / 3.0f)
+		/** \param aspect: New aspect ratio. */
+		virtual void setAspectRatio(f32 aspect) =0;
+
+		//! Sets the field of view (Default: PI / 2.5f)
+		/** \param fovy: New field of view in radians. */
+		virtual void setFOV(f32 fovy) =0;
+
+		//! Get the view frustum.
+		/** Needed sometimes by bspTree or LOD render nodes.
+		\return The current view frustum. */
+		virtual const SViewFrustum* getViewFrustum() const =0;
+
+		//! Disables or enables the camera to get key or mouse inputs.
+		/** If this is set to true, the camera will respond to key
+		inputs otherwise not. */
+		virtual void setInputReceiverEnabled(bool enabled) =0;
+
+		//! Checks if the input receiver of the camera is currently enabled.
+		virtual bool isInputReceiverEnabled() const =0;
+
+		//! Checks if a camera is orthogonal.
+		virtual bool isOrthogonal() const
+		{
+			_IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
+			return IsOrthogonal;
+		}
+
+		//! Binds the camera scene node's rotation to its target position and vice vera, or unbinds them.
+		/** When bound, calling setRotation() will update the camera's
+		target position to be along its +Z axis, and likewise calling
+		setTarget() will update its rotation so that its +Z axis will
+		point at the target point. FPS camera use this binding by
+		default; other cameras do not.
+		\param bound True to bind the camera's scene node rotation
+		and targetting, false to unbind them.
+		@see getTargetAndRotationBinding() */
+		virtual void bindTargetAndRotation(bool bound) =0;
+
+		//! Queries if the camera scene node's rotation and its target position are bound together.
+		/** @see bindTargetAndRotation() */
+		virtual bool getTargetAndRotationBinding(void) const =0;
+
+		//! Writes attributes of the camera node
+		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options=0) const
+		{
+			ISceneNode::serializeAttributes(out, options);
+
+			if (!out)
+				return;
+			out->addBool	("IsOrthogonal", IsOrthogonal );
+		}
+
+		//! Reads attributes of the camera node
+		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options=0)
+		{
+			ISceneNode::deserializeAttributes(in, options);
+			if (!in)
+				return;
+
+			if ( in->findAttribute("IsOrthogonal") )
+				IsOrthogonal = in->getAttributeAsBool("IsOrthogonal");
+		}
+
+	protected:
+
+		void cloneMembers(ICameraSceneNode* toCopyFrom)
+		{
+			IsOrthogonal = toCopyFrom->IsOrthogonal;
+		}
+
+		bool IsOrthogonal;
+	};
+
+} // end namespace scene
+} // end namespace irr
+
+#endif
+

include/ICursorControl.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 __I_CURSOR_CONTROL_H_INCLUDED__
+#define __I_CURSOR_CONTROL_H_INCLUDED__
+
+#include "IReferenceCounted.h"
+#include "position2d.h"
+#include "rect.h"
+
+namespace irr
+{
+namespace gui
+{
+
+	class IGUISpriteBank;
+
+	//! Default icons for cursors
+	enum ECURSOR_ICON
+	{
+		// Following cursors might be system specific, or might use an Irrlicht icon-set. No guarantees so far.
+		ECI_NORMAL,		// arrow
+		ECI_CROSS,		// Crosshair
+		ECI_HAND, 		// Hand
+		ECI_HELP,		// Arrow and question mark
+		ECI_IBEAM,		// typical text-selection cursor
+		ECI_NO, 		// should not click icon
+		ECI_WAIT, 		// hourclass
+		ECI_SIZEALL,  	// arrow in all directions
+		ECI_SIZENESW,	// resizes in direction north-east or south-west
+		ECI_SIZENWSE, 	// resizes in direction north-west or south-east
+		ECI_SIZENS, 	// resizes in direction north or south
+		ECI_SIZEWE, 	// resizes in direction west or east
+		ECI_UP,			// up-arrow
+
+		// Implementer note: Should we add system specific cursors, which use guaranteed the system icons,
+		// then I would recommend using a naming scheme like ECI_W32_CROSS, ECI_X11_CROSSHAIR and adding those
+		// additionally.
+
+		ECI_COUNT		// maximal of defined cursors. Note that higher values can be created at runtime
+	};
+
+	//! Names for ECURSOR_ICON
+	const c8* const GUICursorIconNames[ECI_COUNT+1] =
+	{
+		"normal",
+		"cross",
+		"hand",
+		"help",
+		"ibeam",
+		"no",
+		"wait",
+		"sizeall",
+		"sizenesw",
+		"sizenwse",
+		"sizens",
+		"sizewe",
+		"sizeup",
+		0
+	};
+
+	//! structure used to set sprites as cursors.
+	struct SCursorSprite
+	{
+		SCursorSprite()
+		: SpriteBank(0), SpriteId(-1)
+		{
+		}
+
+		SCursorSprite( gui::IGUISpriteBank * spriteBank, s32 spriteId, const core::position2d<s32> &hotspot=(core::position2d<s32>(0,0)) )
+		: SpriteBank(spriteBank), SpriteId(spriteId), HotSpot(hotspot)
+		{
+		}
+
+		IGUISpriteBank * SpriteBank;
+		s32 SpriteId;
+		core::position2d<s32> HotSpot;
+	};
+
+	//! platform specific behavior flags for the cursor
+	enum ECURSOR_PLATFORM_BEHAVIOR
+	{
+		//! default - no platform specific behavior
+		ECPB_NONE = 0,
+
+		//! On X11 try caching cursor updates as XQueryPointer calls can be expensive.
+		/** Update cursor positions only when the irrlicht timer has been updated or the timer is stopped.
+			This means you usually get one cursor update per device->run() which will be fine in most cases.
+			See this forum-thread for a more detailed explanation:
+			http://irrlicht.sourceforge.net/forum/viewtopic.php?f=7&t=45525
+		*/
+		ECPB_X11_CACHE_UPDATES = 1
+	};
+
+	//! Interface to manipulate the mouse cursor.
+	class ICursorControl : public virtual IReferenceCounted
+	{
+	public:
+
+		//! Changes the visible state of the mouse cursor.
+		/** \param visible: The new visible state. If true, the cursor will be visible,
+		if false, it will be invisible. */
+		virtual void setVisible(bool visible) = 0;
+
+		//! Returns if the cursor is currently visible.
+		/** \return True if the cursor is visible, false if not. */
+		virtual bool isVisible() const = 0;
+
+		//! Sets the new position of the cursor.
+		/** The position must be
+		between (0.0f, 0.0f) and (1.0f, 1.0f), where (0.0f, 0.0f) is
+		the top left corner and (1.0f, 1.0f) is the bottom right corner of the
+		render window.
+		\param pos New position of the cursor. */
+		virtual void setPosition(const core::position2d<f32> &pos) = 0;
+
+		//! Sets the new position of the cursor.
+		/** The position must be
+		between (0.0f, 0.0f) and (1.0f, 1.0f), where (0.0f, 0.0f) is
+		the top left corner and (1.0f, 1.0f) is the bottom right corner of the
+		render window.
+		\param x New x-coord of the cursor.
+		\param y New x-coord of the cursor. */
+		virtual void setPosition(f32 x, f32 y) = 0;
+
+		//! Sets the new position of the cursor.
+		/** \param pos: New position of the cursor. The coordinates are pixel units. */
+		virtual void setPosition(const core::position2d<s32> &pos) = 0;
+
+		//! Sets the new position of the cursor.
+		/** \param x New x-coord of the cursor. The coordinates are pixel units.
+		\param y New y-coord of the cursor. The coordinates are pixel units. */
+		virtual void setPosition(s32 x, s32 y) = 0;
+
+		//! Returns the current position of the mouse cursor.
+		/** \return Returns the current position of the cursor. The returned position
+		is the position of the mouse cursor in pixel units. */
+		virtual const core::position2d<s32>& getPosition() = 0;
+
+		//! Returns the current position of the mouse cursor.
+		/** \return Returns the current position of the cursor. The returned position
+		is a value between (0.0f, 0.0f) and (1.0f, 1.0f), where (0.0f, 0.0f) is
+		the top left corner and (1.0f, 1.0f) is the bottom right corner of the
+		render window. */
+		virtual core::position2d<f32> getRelativePosition() = 0;
+
+		//! Sets an absolute reference rect for setting and retrieving the cursor position.
+		/** If this rect is set, the cursor position is not being calculated relative to
+		the rendering window but to this rect. You can set the rect pointer to 0 to disable
+		this feature again. This feature is useful when rendering into parts of foreign windows
+		for example in an editor.
+		\param rect: A pointer to an reference rectangle or 0 to disable the reference rectangle.*/
+		virtual void setReferenceRect(core::rect<s32>* rect=0) = 0;
+
+
+		//! Sets the active cursor icon
+		/** Setting cursor icons is so far only supported on Win32 and Linux */
+		virtual void setActiveIcon(ECURSOR_ICON iconId) {}
+
+		//! Gets the currently active icon
+		virtual ECURSOR_ICON getActiveIcon() const { return gui::ECI_NORMAL; }
+
+		//! Add a custom sprite as cursor icon.
+		/** \return Identification for the icon */
+		virtual ECURSOR_ICON addIcon(const gui::SCursorSprite& icon) { return gui::ECI_NORMAL; }
+
+		//! replace a cursor icon.
+		/** Changing cursor icons is so far only supported on Win32 and Linux
+			Note that this only changes the icons within your application, system cursors outside your
+			application will not be affected.
+		*/
+		virtual void changeIcon(ECURSOR_ICON iconId, const gui::SCursorSprite& sprite) {}
+
+		//! Return a system-specific size which is supported for cursors. Larger icons will fail, smaller icons might work.
+		virtual core::dimension2di getSupportedIconSize() const { return core::dimension2di(0,0); }
+
+		//! Set platform specific behavior flags.
+		virtual void setPlatformBehavior(ECURSOR_PLATFORM_BEHAVIOR behavior) {}
+
+		//! Return platform specific behavior.
+		/** \return Behavior set by setPlatformBehavior or ECPB_NONE for platforms not implementing specific behaviors.
+		*/
+		virtual ECURSOR_PLATFORM_BEHAVIOR getPlatformBehavior() const { return ECPB_NONE; }
+	};
+
+
+} // end namespace gui
+} // end namespace irr
+
+#endif
+

include/IDummyTransformationSceneNode.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 __I_DUMMY_TRANSFORMATION_SCENE_NODE_H_INCLUDED__
+#define __I_DUMMY_TRANSFORMATION_SCENE_NODE_H_INCLUDED__
+
+#include "ISceneNode.h"
+
+namespace irr
+{
+namespace scene
+{
+
+//! Dummy scene node for adding additional transformations to the scene graph.
+/** This scene node does not render itself, and does not respond to set/getPosition,
+set/getRotation and set/getScale. Its just a simple scene node that takes a
+matrix as relative transformation, making it possible to insert any transformation
+anywhere into the scene graph.
+This scene node is for example used by the IAnimatedMeshSceneNode for emulating
+joint scene nodes when playing skeletal animations.
+*/
+class IDummyTransformationSceneNode : public ISceneNode
+{
+public:
+
+	//! Constructor
+	IDummyTransformationSceneNode(ISceneNode* parent, ISceneManager* mgr, s32 id)
+		: ISceneNode(parent, mgr, id) {}
+
+	//! Returns a reference to the current relative transformation matrix.
+	/** This is the matrix, this scene node uses instead of scale, translation
+	and rotation. */
+	virtual core::matrix4& getRelativeTransformationMatrix() = 0;
+};
+
+} // end namespace scene
+} // end namespace irr
+
+
+#endif
+

include/IGUICheckBox.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 __I_GUI_CHECKBOX_H_INCLUDED__
+#define __I_GUI_CHECKBOX_H_INCLUDED__
+
+#include "IGUIElement.h"
+
+namespace irr
+{
+namespace gui
+{
+
+	//! GUI Check box interface.
+	/** \par This element can create the following events of type EGUI_EVENT_TYPE:
+	\li EGET_CHECKBOX_CHANGED
+	*/
+	class IGUICheckBox : public IGUIElement
+	{
+	public:
+
+		//! constructor
+		IGUICheckBox(IGUIEnvironment* environment, IGUIElement* parent, s32 id, core::rect<s32> rectangle)
+			: IGUIElement(EGUIET_CHECK_BOX, environment, parent, id, rectangle) {}
+
+		//! Set if box is checked.
+		virtual void setChecked(bool checked) = 0;
+
+		//! Returns true if box is checked.
+		virtual bool isChecked() const = 0;
+	};
+
+} // end namespace gui
+} // end namespace irr
+
+#endif
+

include/IGUIColorSelectDialog.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 __I_GUI_COLOR_SELECT_DIALOG_H_INCLUDED__
+#define __I_GUI_COLOR_SELECT_DIALOG_H_INCLUDED__
+
+#include "IGUIElement.h"
+
+namespace irr
+{
+namespace gui
+{
+
+	//! Standard color chooser dialog.
+	class IGUIColorSelectDialog : public IGUIElement
+	{
+	public:
+
+		//! constructor
+		IGUIColorSelectDialog(IGUIEnvironment* environment, IGUIElement* parent, s32 id, core::rect<s32> rectangle)
+			: IGUIElement(EGUIET_COLOR_SELECT_DIALOG, environment, parent, id, rectangle) {}
+	};
+
+
+} // end namespace gui
+} // end namespace irr
+
+#endif
+