1 files changed, 189 insertions, 0 deletions
diff --git a/src/others/irrlicht-1.8.1/include/SAnimatedMesh.h b/src/others/irrlicht-1.8.1/include/SAnimatedMesh.h
new file mode 100644
index 0000000..ced4060
--- /dev/null
+++ b/src/others/irrlicht-1.8.1/include/SAnimatedMesh.h
@@ -0,0 +1,189 @@
+// 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 __S_ANIMATED_MESH_H_INCLUDED__
+#define __S_ANIMATED_MESH_H_INCLUDED__
+#include "IAnimatedMesh.h"
+#include "IMesh.h"
+#include "aabbox3d.h"
+#include "irrArray.h"
+namespace irr
+{
+namespace scene
+{
+        //! Simple implementation of the IAnimatedMesh interface.
+        struct SAnimatedMesh : public IAnimatedMesh
+        {
+                //! constructor
+                SAnimatedMesh(scene::IMesh* mesh=0, scene::E_ANIMATED_MESH_TYPE type=scene::EAMT_UNKNOWN) : IAnimatedMesh(), FramesPerSecond(25.f), Type(type)
+                {
+                        #ifdef _DEBUG
+                        setDebugName("SAnimatedMesh");
+                        #endif
+                        addMesh(mesh);
+                        recalculateBoundingBox();
+                }
+                //! destructor
+                virtual ~SAnimatedMesh()
+                {
+                        // drop meshes
+                        for (u32 i=0; i<Meshes.size(); ++i)
+                                Meshes[i]->drop();
+                }
+                //! Gets the frame count of the animated mesh.
+                /** \return Amount of frames. If the amount is 1, it is a static, non animated mesh. */
+                virtual u32 getFrameCount() const
+                {
+                        return Meshes.size();
+                }
+                //! Gets the default animation speed of the animated mesh.
+                /** \return Amount of frames per second. If the amount is 0, it is a static, non animated mesh. */
+                virtual f32 getAnimationSpeed() const
+                {
+                        return FramesPerSecond;
+                }
+                //! Gets the frame count of the animated mesh.
+                /** \param fps Frames per second to play the animation with. 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)
+                {
+                        FramesPerSecond=fps;
+                }
+                //! 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: start frame
+                \param endFrameLoop: end frame
+                \return The animated mesh based on a detail level. */
+                virtual IMesh* getMesh(s32 frame, s32 detailLevel=255, s32 startFrameLoop=-1, s32 endFrameLoop=-1)
+                {
+                        if (Meshes.empty())
+                                return 0;
+                        return Meshes[frame];
+                }
+                //! adds a Mesh
+                void addMesh(IMesh* mesh)
+                {
+                        if (mesh)
+                        {
+                                mesh->grab();
+                                Meshes.push_back(mesh);
+                        }
+                }
+                //! Returns an axis aligned bounding box of the mesh.
+                /** \return A bounding box of this mesh is returned. */
+                virtual const core::aabbox3d<f32>& getBoundingBox() const
+                {
+                        return Box;
+                }
+                //! set user axis aligned bounding box
+                virtual void setBoundingBox(const core::aabbox3df& box)
+                {
+                        Box = box;
+                }
+                //! Recalculates the bounding box.
+                void recalculateBoundingBox()
+                {
+                        Box.reset(0,0,0);
+                        if (Meshes.empty())
+                                return;
+                        Box = Meshes[0]->getBoundingBox();
+                        for (u32 i=1; i<Meshes.size(); ++i)
+                                Box.addInternalBox(Meshes[i]->getBoundingBox());
+                }
+                //! Returns the type of the animated mesh.
+                virtual E_ANIMATED_MESH_TYPE getMeshType() const
+                {
+                        return Type;
+                }
+                //! returns amount of mesh buffers.
+                virtual u32 getMeshBufferCount() const
+                {
+                        if (Meshes.empty())
+                                return 0;
+                        return Meshes[0]->getMeshBufferCount();
+                }
+                //! returns pointer to a mesh buffer
+                virtual IMeshBuffer* getMeshBuffer(u32 nr) const
+                {
+                        if (Meshes.empty())
+                                return 0;
+                        return Meshes[0]->getMeshBuffer(nr);
+                }
+                //! Returns pointer to a mesh buffer which fits a material
+                /** \param material: material to search for
+                \return Returns the pointer to the mesh buffer or
+                NULL if there is no such mesh buffer. */
+                virtual IMeshBuffer* getMeshBuffer( const video::SMaterial &material) const
+                {
+                        if (Meshes.empty())
+                                return 0;
+                        return Meshes[0]->getMeshBuffer(material);
+                }
+                //! Set a material flag for all meshbuffers of this mesh.
+                virtual void setMaterialFlag(video::E_MATERIAL_FLAG flag, bool newvalue)
+                {
+                        for (u32 i=0; i<Meshes.size(); ++i)
+                                Meshes[i]->setMaterialFlag(flag, newvalue);
+                }
+                //! set the hardware mapping hint, for driver
+                virtual void setHardwareMappingHint( E_HARDWARE_MAPPING newMappingHint, E_BUFFER_TYPE buffer=EBT_VERTEX_AND_INDEX )
+                {
+                        for (u32 i=0; i<Meshes.size(); ++i)
+                                Meshes[i]->setHardwareMappingHint(newMappingHint, buffer);
+                }
+                //! flags the meshbuffer as changed, reloads hardware buffers
+                virtual void setDirty(E_BUFFER_TYPE buffer=EBT_VERTEX_AND_INDEX)
+                {
+                        for (u32 i=0; i<Meshes.size(); ++i)
+                                Meshes[i]->setDirty(buffer);
+                }
+                //! All meshes defining the animated mesh
+                core::array<IMesh*> Meshes;
+                //! The bounding box of this mesh
+                core::aabbox3d<f32> Box;
+                //! Default animation speed of this mesh.
+                f32 FramesPerSecond;
+                //! The type of the mesh.
+                E_ANIMATED_MESH_TYPE Type;
+        };
+} // end namespace scene
+} // end namespace irr
+#endif

diff --git a/src/others/irrlicht-1.8.1/include/SAnimatedMesh.h b/src/others/irrlicht-1.8.1/include/SAnimatedMesh.h new file mode 100644 index 0000000..ced4060 --- /dev/null +++ b/src/others/irrlicht-1.8.1/include/SAnimatedMesh.h
@@ -0,0 +1,189 @@
	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 __S_ANIMATED_MESH_H_INCLUDED__
	6	#define __S_ANIMATED_MESH_H_INCLUDED__
	7
	8	#include "IAnimatedMesh.h"
	9	#include "IMesh.h"
	10	#include "aabbox3d.h"
	11	#include "irrArray.h"
	12
	13	namespace irr
	14	{
	15	namespace scene
	16	{
	17
	18	//! Simple implementation of the IAnimatedMesh interface.
	19	struct SAnimatedMesh : public IAnimatedMesh
	20	{
	21	//! constructor
	22	SAnimatedMesh(scene::IMesh* mesh=0, scene::E_ANIMATED_MESH_TYPE type=scene::EAMT_UNKNOWN) : IAnimatedMesh(), FramesPerSecond(25.f), Type(type)
	23	{
	24	#ifdef _DEBUG
	25	setDebugName("SAnimatedMesh");
	26	#endif
	27	addMesh(mesh);
	28	recalculateBoundingBox();
	29	}
	30
	31	//! destructor
	32	virtual ~SAnimatedMesh()
	33	{
	34	// drop meshes
	35	for (u32 i=0; i<Meshes.size(); ++i)
	36	Meshes[i]->drop();
	37	}
	38
	39	//! Gets the frame count of the animated mesh.
	40	/** \return Amount of frames. If the amount is 1, it is a static, non animated mesh. */
	41	virtual u32 getFrameCount() const
	42	{
	43	return Meshes.size();
	44	}
	45
	46	//! Gets the default animation speed of the animated mesh.
	47	/** \return Amount of frames per second. If the amount is 0, it is a static, non animated mesh. */
	48	virtual f32 getAnimationSpeed() const
	49	{
	50	return FramesPerSecond;
	51	}
	52
	53	//! Gets the frame count of the animated mesh.
	54	/** \param fps Frames per second to play the animation with. If the amount is 0, it is not animated.
	55	The actual speed is set in the scene node the mesh is instantiated in.*/
	56	virtual void setAnimationSpeed(f32 fps)
	57	{
	58	FramesPerSecond=fps;
	59	}
	60
	61	//! Returns the IMesh interface for a frame.
	62	/** \param frame: Frame number as zero based index. The maximum frame number is
	63	getFrameCount() - 1;
	64	\param detailLevel: Level of detail. 0 is the lowest,
	65	255 the highest level of detail. Most meshes will ignore the detail level.
	66	\param startFrameLoop: start frame
	67	\param endFrameLoop: end frame
	68	\return The animated mesh based on a detail level. */
	69	virtual IMesh* getMesh(s32 frame, s32 detailLevel=255, s32 startFrameLoop=-1, s32 endFrameLoop=-1)
	70	{
	71	if (Meshes.empty())
	72	return 0;
	73
	74	return Meshes[frame];
	75	}
	76
	77	//! adds a Mesh
	78	void addMesh(IMesh* mesh)
	79	{
	80	if (mesh)
	81	{
	82	mesh->grab();
	83	Meshes.push_back(mesh);
	84	}
	85	}
	86
	87	//! Returns an axis aligned bounding box of the mesh.
	88	/** \return A bounding box of this mesh is returned. */
	89	virtual const core::aabbox3d<f32>& getBoundingBox() const
	90	{
	91	return Box;
	92	}
	93
	94	//! set user axis aligned bounding box
	95	virtual void setBoundingBox(const core::aabbox3df& box)
	96	{
	97	Box = box;
	98	}
	99
	100	//! Recalculates the bounding box.
	101	void recalculateBoundingBox()
	102	{
	103	Box.reset(0,0,0);
	104
	105	if (Meshes.empty())
	106	return;
	107
	108	Box = Meshes[0]->getBoundingBox();
	109
	110	for (u32 i=1; i<Meshes.size(); ++i)
	111	Box.addInternalBox(Meshes[i]->getBoundingBox());
	112	}
	113
	114	//! Returns the type of the animated mesh.
	115	virtual E_ANIMATED_MESH_TYPE getMeshType() const
	116	{
	117	return Type;
	118	}
	119
	120	//! returns amount of mesh buffers.
	121	virtual u32 getMeshBufferCount() const
	122	{
	123	if (Meshes.empty())
	124	return 0;
	125
	126	return Meshes[0]->getMeshBufferCount();
	127	}
	128
	129	//! returns pointer to a mesh buffer
	130	virtual IMeshBuffer* getMeshBuffer(u32 nr) const
	131	{
	132	if (Meshes.empty())
	133	return 0;
	134
	135	return Meshes[0]->getMeshBuffer(nr);
	136	}
	137
	138	//! Returns pointer to a mesh buffer which fits a material
	139	/** \param material: material to search for
	140	\return Returns the pointer to the mesh buffer or
	141	NULL if there is no such mesh buffer. */
	142	virtual IMeshBuffer* getMeshBuffer( const video::SMaterial &material) const
	143	{
	144	if (Meshes.empty())
	145	return 0;
	146
	147	return Meshes[0]->getMeshBuffer(material);
	148	}
	149
	150	//! Set a material flag for all meshbuffers of this mesh.
	151	virtual void setMaterialFlag(video::E_MATERIAL_FLAG flag, bool newvalue)
	152	{
	153	for (u32 i=0; i<Meshes.size(); ++i)
	154	Meshes[i]->setMaterialFlag(flag, newvalue);
	155	}
	156
	157	//! set the hardware mapping hint, for driver
	158	virtual void setHardwareMappingHint( E_HARDWARE_MAPPING newMappingHint, E_BUFFER_TYPE buffer=EBT_VERTEX_AND_INDEX )
	159	{
	160	for (u32 i=0; i<Meshes.size(); ++i)
	161	Meshes[i]->setHardwareMappingHint(newMappingHint, buffer);
	162	}
	163
	164	//! flags the meshbuffer as changed, reloads hardware buffers
	165	virtual void setDirty(E_BUFFER_TYPE buffer=EBT_VERTEX_AND_INDEX)
	166	{
	167	for (u32 i=0; i<Meshes.size(); ++i)
	168	Meshes[i]->setDirty(buffer);
	169	}
	170
	171	//! All meshes defining the animated mesh
	172	core::array<IMesh*> Meshes;
	173
	174	//! The bounding box of this mesh
	175	core::aabbox3d<f32> Box;
	176
	177	//! Default animation speed of this mesh.
	178	f32 FramesPerSecond;
	179
	180	//! The type of the mesh.
	181	E_ANIMATED_MESH_TYPE Type;
	182	};
	183
	184
	185	} // end namespace scene
	186	} // end namespace irr
	187
	188	#endif
	189