1 files changed, 301 insertions, 0 deletions
diff --git a/src/others/irrlicht-1.8.1/include/CMeshBuffer.h b/src/others/irrlicht-1.8.1/include/CMeshBuffer.h
new file mode 100644
index 0000000..7512a38
--- /dev/null
+++ b/src/others/irrlicht-1.8.1/include/CMeshBuffer.h
@@ -0,0 +1,301 @@
+// 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

diff --git a/src/others/irrlicht-1.8.1/include/CMeshBuffer.h b/src/others/irrlicht-1.8.1/include/CMeshBuffer.h new file mode 100644 index 0000000..7512a38 --- /dev/null +++ b/src/others/irrlicht-1.8.1/include/CMeshBuffer.h
@@ -0,0 +1,301 @@
	1	// Copyright (C) 2002-2012 Nikolaus Gebhardt
	2	// This file is part of the "Irrlicht Engine".
	3	// For conditions of distribution and use, see copyright notice in irrlicht.h
	4
	5	#ifndef __T_MESH_BUFFER_H_INCLUDED__
	6	#define __T_MESH_BUFFER_H_INCLUDED__
	7
	8	#include "irrArray.h"
	9	#include "IMeshBuffer.h"
	10
	11	namespace irr
	12	{
	13	namespace scene
	14	{
	15	//! Template implementation of the IMeshBuffer interface
	16	template <class T>
	17	class CMeshBuffer : public IMeshBuffer
	18	{
	19	public:
	20	//! Default constructor for empty meshbuffer
	21	CMeshBuffer():ChangedID_Vertex(1),ChangedID_Index(1),MappingHint_Vertex(EHM_NEVER), MappingHint_Index(EHM_NEVER)
	22	{
	23	#ifdef _DEBUG
	24	setDebugName("SMeshBuffer");
	25	#endif
	26	}
	27
	28
	29	//! Get material of this meshbuffer
	30	/** \return Material of this buffer */
	31	virtual const video::SMaterial& getMaterial() const
	32	{
	33	return Material;
	34	}
	35
	36
	37	//! Get material of this meshbuffer
	38	/** \return Material of this buffer */
	39	virtual video::SMaterial& getMaterial()
	40	{
	41	return Material;
	42	}
	43
	44
	45	//! Get pointer to vertices
	46	/** \return Pointer to vertices. */
	47	virtual const void* getVertices() const
	48	{
	49	return Vertices.const_pointer();
	50	}
	51
	52
	53	//! Get pointer to vertices
	54	/** \return Pointer to vertices. */
	55	virtual void* getVertices()
	56	{
	57	return Vertices.pointer();
	58	}
	59
	60
	61	//! Get number of vertices
	62	/** \return Number of vertices. */
	63	virtual u32 getVertexCount() const
	64	{
	65	return Vertices.size();
	66	}
	67
	68	//! Get type of index data which is stored in this meshbuffer.
	69	/** \return Index type of this buffer. */
	70	virtual video::E_INDEX_TYPE getIndexType() const
	71	{
	72	return video::EIT_16BIT;
	73	}
	74
	75	//! Get pointer to indices
	76	/** \return Pointer to indices. */
	77	virtual const u16* getIndices() const
	78	{
	79	return Indices.const_pointer();
	80	}
	81
	82
	83	//! Get pointer to indices
	84	/** \return Pointer to indices. */
	85	virtual u16* getIndices()
	86	{
	87	return Indices.pointer();
	88	}
	89
	90
	91	//! Get number of indices
	92	/** \return Number of indices. */
	93	virtual u32 getIndexCount() const
	94	{
	95	return Indices.size();
	96	}
	97
	98
	99	//! Get the axis aligned bounding box
	100	/** \return Axis aligned bounding box of this buffer. */
	101	virtual const core::aabbox3d<f32>& getBoundingBox() const
	102	{
	103	return BoundingBox;
	104	}
	105
	106
	107	//! Set the axis aligned bounding box
	108	/** \param box New axis aligned bounding box for this buffer. */
	109	//! set user axis aligned bounding box
	110	virtual void setBoundingBox(const core::aabbox3df& box)
	111	{
	112	BoundingBox = box;
	113	}
	114
	115
	116	//! Recalculate the bounding box.
	117	/** should be called if the mesh changed. */
	118	virtual void recalculateBoundingBox()
	119	{
	120	if (Vertices.empty())
	121	BoundingBox.reset(0,0,0);
	122	else
	123	{
	124	BoundingBox.reset(Vertices[0].Pos);
	125	for (u32 i=1; i<Vertices.size(); ++i)
	126	BoundingBox.addInternalPoint(Vertices[i].Pos);
	127	}
	128	}
	129
	130
	131	//! Get type of vertex data stored in this buffer.
	132	/** \return Type of vertex data. */
	133	virtual video::E_VERTEX_TYPE getVertexType() const
	134	{
	135	return T().getType();
	136	}
	137
	138	//! returns position of vertex i
	139	virtual const core::vector3df& getPosition(u32 i) const
	140	{
	141	return Vertices[i].Pos;
	142	}
	143
	144	//! returns position of vertex i
	145	virtual core::vector3df& getPosition(u32 i)
	146	{
	147	return Vertices[i].Pos;
	148	}
	149
	150	//! returns normal of vertex i
	151	virtual const core::vector3df& getNormal(u32 i) const
	152	{
	153	return Vertices[i].Normal;
	154	}
	155
	156	//! returns normal of vertex i
	157	virtual core::vector3df& getNormal(u32 i)
	158	{
	159	return Vertices[i].Normal;
	160	}
	161
	162	//! returns texture coord of vertex i
	163	virtual const core::vector2df& getTCoords(u32 i) const
	164	{
	165	return Vertices[i].TCoords;
	166	}
	167
	168	//! returns texture coord of vertex i
	169	virtual core::vector2df& getTCoords(u32 i)
	170	{
	171	return Vertices[i].TCoords;
	172	}
	173
	174
	175	//! Append the vertices and indices to the current buffer
	176	/** Only works for compatible types, i.e. either the same type
	177	or the main buffer is of standard type. Otherwise, behavior is
	178	undefined.
	179	*/
	180	virtual void append(const void* const vertices, u32 numVertices, const u16* const indices, u32 numIndices)
	181	{
	182	if (vertices == getVertices())
	183	return;
	184
	185	const u32 vertexCount = getVertexCount();
	186	u32 i;
	187
	188	Vertices.reallocate(vertexCount+numVertices);
	189	for (i=0; i<numVertices; ++i)
	190	{
	191	Vertices.push_back(reinterpret_cast<const T*>(vertices)[i]);
	192	BoundingBox.addInternalPoint(reinterpret_cast<const T*>(vertices)[i].Pos);
	193	}
	194
	195	Indices.reallocate(getIndexCount()+numIndices);
	196	for (i=0; i<numIndices; ++i)
	197	{
	198	Indices.push_back(indices[i]+vertexCount);
	199	}
	200	}
	201
	202
	203	//! Append the meshbuffer to the current buffer
	204	/** Only works for compatible types, i.e. either the same type
	205	or the main buffer is of standard type. Otherwise, behavior is
	206	undefined.
	207	\param other Meshbuffer to be appended to this one.
	208	*/
	209	virtual void append(const IMeshBuffer* const other)
	210	{
	211	/*
	212	if (this==other)
	213	return;
	214
	215	const u32 vertexCount = getVertexCount();
	216	u32 i;
	217
	218	Vertices.reallocate(vertexCount+other->getVertexCount());
	219	for (i=0; i<other->getVertexCount(); ++i)
	220	{
	221	Vertices.push_back(reinterpret_cast<const T*>(other->getVertices())[i]);
	222	}
	223
	224	Indices.reallocate(getIndexCount()+other->getIndexCount());
	225	for (i=0; i<other->getIndexCount(); ++i)
	226	{
	227	Indices.push_back(other->getIndices()[i]+vertexCount);
	228	}
	229	BoundingBox.addInternalBox(other->getBoundingBox());
	230	*/
	231	}
	232
	233
	234	//! get the current hardware mapping hint
	235	virtual E_HARDWARE_MAPPING getHardwareMappingHint_Vertex() const
	236	{
	237	return MappingHint_Vertex;
	238	}
	239
	240	//! get the current hardware mapping hint
	241	virtual E_HARDWARE_MAPPING getHardwareMappingHint_Index() const
	242	{
	243	return MappingHint_Index;
	244	}
	245
	246	//! set the hardware mapping hint, for driver
	247	virtual void setHardwareMappingHint( E_HARDWARE_MAPPING NewMappingHint, E_BUFFER_TYPE Buffer=EBT_VERTEX_AND_INDEX )
	248	{
	249	if (Buffer==EBT_VERTEX_AND_INDEX \|\| Buffer==EBT_VERTEX)
	250	MappingHint_Vertex=NewMappingHint;
	251	if (Buffer==EBT_VERTEX_AND_INDEX \|\| Buffer==EBT_INDEX)
	252	MappingHint_Index=NewMappingHint;
	253	}
	254
	255
	256	//! flags the mesh as changed, reloads hardware buffers
	257	virtual void setDirty(E_BUFFER_TYPE Buffer=EBT_VERTEX_AND_INDEX)
	258	{
	259	if (Buffer==EBT_VERTEX_AND_INDEX \|\|Buffer==EBT_VERTEX)
	260	++ChangedID_Vertex;
	261	if (Buffer==EBT_VERTEX_AND_INDEX \|\| Buffer==EBT_INDEX)
	262	++ChangedID_Index;
	263	}
	264
	265	//! Get the currently used ID for identification of changes.
	266	/** This shouldn't be used for anything outside the VideoDriver. */
	267	virtual u32 getChangedID_Vertex() const {return ChangedID_Vertex;}
	268
	269	//! Get the currently used ID for identification of changes.
	270	/** This shouldn't be used for anything outside the VideoDriver. */
	271	virtual u32 getChangedID_Index() const {return ChangedID_Index;}
	272
	273	u32 ChangedID_Vertex;
	274	u32 ChangedID_Index;
	275
	276	//! hardware mapping hint
	277	E_HARDWARE_MAPPING MappingHint_Vertex;
	278	E_HARDWARE_MAPPING MappingHint_Index;
	279
	280	//! Material for this meshbuffer.
	281	video::SMaterial Material;
	282	//! Vertices of this buffer
	283	core::array<T> Vertices;
	284	//! Indices into the vertices of this buffer.
	285	core::array<u16> Indices;
	286	//! Bounding box of this meshbuffer.
	287	core::aabbox3d<f32> BoundingBox;
	288	};
	289
	290	//! Standard meshbuffer
	291	typedef CMeshBuffer<video::S3DVertex> SMeshBuffer;
	292	//! Meshbuffer with two texture coords per vertex, e.g. for lightmaps
	293	typedef CMeshBuffer<video::S3DVertex2TCoords> SMeshBufferLightMap;
	294	//! Meshbuffer with vertices having tangents stored, e.g. for normal mapping
	295	typedef CMeshBuffer<video::S3DVertexTangents> SMeshBufferTangents;
	296	} // end namespace scene
	297	} // end namespace irr
	298
	299	#endif
	300
	301