1 files changed, 274 insertions, 0 deletions
diff --git a/src/others/irrlicht-1.8.1/include/S3DVertex.h b/src/others/irrlicht-1.8.1/include/S3DVertex.h
new file mode 100644
index 0000000..bf0fd5b
--- /dev/null
+++ b/src/others/irrlicht-1.8.1/include/S3DVertex.h
@@ -0,0 +1,274 @@
+// 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_3D_VERTEX_H_INCLUDED__
+#define __S_3D_VERTEX_H_INCLUDED__
+#include "vector3d.h"
+#include "vector2d.h"
+#include "SColor.h"
+namespace irr
+{
+namespace video
+{
+//! Enumeration for all vertex types there are.
+enum E_VERTEX_TYPE
+{
+        //! Standard vertex type used by the Irrlicht engine, video::S3DVertex.
+        EVT_STANDARD = 0,
+        //! Vertex with two texture coordinates, video::S3DVertex2TCoords.
+        /** Usually used for geometry with lightmaps or other special materials. */
+        EVT_2TCOORDS,
+        //! Vertex with a tangent and binormal vector, video::S3DVertexTangents.
+        /** Usually used for tangent space normal mapping. */
+        EVT_TANGENTS
+};
+//! Array holding the built in vertex type names
+const char* const sBuiltInVertexTypeNames[] =
+{
+        "standard",
+        "2tcoords",
+        "tangents",
+        0
+};
+//! standard vertex used by the Irrlicht engine.
+struct S3DVertex
+{
+        //! default constructor
+        S3DVertex() {}
+        //! constructor
+        S3DVertex(f32 x, f32 y, f32 z, f32 nx, f32 ny, f32 nz, SColor c, f32 tu, f32 tv)
+                : Pos(x,y,z), Normal(nx,ny,nz), Color(c), TCoords(tu,tv) {}
+        //! constructor
+        S3DVertex(const core::vector3df& pos, const core::vector3df& normal,
+                SColor color, const core::vector2d<f32>& tcoords)
+                : Pos(pos), Normal(normal), Color(color), TCoords(tcoords) {}
+        //! Position
+        core::vector3df Pos;
+        //! Normal vector
+        core::vector3df Normal;
+        //! Color
+        SColor Color;
+        //! Texture coordinates
+        core::vector2d<f32> TCoords;
+        bool operator==(const S3DVertex& other) const
+        {
+                return ((Pos == other.Pos) && (Normal == other.Normal) &&
+                        (Color == other.Color) && (TCoords == other.TCoords));
+        }
+        bool operator!=(const S3DVertex& other) const
+        {
+                return ((Pos != other.Pos) || (Normal != other.Normal) ||
+                        (Color != other.Color) || (TCoords != other.TCoords));
+        }
+        bool operator<(const S3DVertex& other) const
+        {
+                return ((Pos < other.Pos) ||
+                                ((Pos == other.Pos) && (Normal < other.Normal)) ||
+                                ((Pos == other.Pos) && (Normal == other.Normal) && (Color < other.Color)) ||
+                                ((Pos == other.Pos) && (Normal == other.Normal) && (Color == other.Color) && (TCoords < other.TCoords)));
+        }
+        E_VERTEX_TYPE getType() const
+        {
+                return EVT_STANDARD;
+        }
+        S3DVertex getInterpolated(const S3DVertex& other, f32 d)
+        {
+                d = core::clamp(d, 0.0f, 1.0f);
+                return S3DVertex(Pos.getInterpolated(other.Pos, d),
+                                Normal.getInterpolated(other.Normal, d),
+                                Color.getInterpolated(other.Color, d),
+                                TCoords.getInterpolated(other.TCoords, d));
+        }
+};
+//! Vertex with two texture coordinates.
+/** Usually used for geometry with lightmaps
+or other special materials.
+*/
+struct S3DVertex2TCoords : public S3DVertex
+{
+        //! default constructor
+        S3DVertex2TCoords() : S3DVertex() {}
+        //! constructor with two different texture coords, but no normal
+        S3DVertex2TCoords(f32 x, f32 y, f32 z, SColor c, f32 tu, f32 tv, f32 tu2, f32 tv2)
+                : S3DVertex(x,y,z, 0.0f, 0.0f, 0.0f, c, tu,tv), TCoords2(tu2,tv2) {}
+        //! constructor with two different texture coords, but no normal
+        S3DVertex2TCoords(const core::vector3df& pos, SColor color,
+                const core::vector2d<f32>& tcoords, const core::vector2d<f32>& tcoords2)
+                : S3DVertex(pos, core::vector3df(), color, tcoords), TCoords2(tcoords2) {}
+        //! constructor with all values
+        S3DVertex2TCoords(const core::vector3df& pos, const core::vector3df& normal, const SColor& color,
+                const core::vector2d<f32>& tcoords, const core::vector2d<f32>& tcoords2)
+                : S3DVertex(pos, normal, color, tcoords), TCoords2(tcoords2) {}
+        //! constructor with all values
+        S3DVertex2TCoords(f32 x, f32 y, f32 z, f32 nx, f32 ny, f32 nz, SColor c, f32 tu, f32 tv, f32 tu2, f32 tv2)
+                : S3DVertex(x,y,z, nx,ny,nz, c, tu,tv), TCoords2(tu2,tv2) {}
+        //! constructor with the same texture coords and normal
+        S3DVertex2TCoords(f32 x, f32 y, f32 z, f32 nx, f32 ny, f32 nz, SColor c, f32 tu, f32 tv)
+                : S3DVertex(x,y,z, nx,ny,nz, c, tu,tv), TCoords2(tu,tv) {}
+        //! constructor with the same texture coords and normal
+        S3DVertex2TCoords(const core::vector3df& pos, const core::vector3df& normal,
+                SColor color, const core::vector2d<f32>& tcoords)
+                : S3DVertex(pos, normal, color, tcoords), TCoords2(tcoords) {}
+        //! constructor from S3DVertex
+        S3DVertex2TCoords(S3DVertex& o) : S3DVertex(o) {}
+        //! Second set of texture coordinates
+        core::vector2d<f32> TCoords2;
+        //! Equality operator
+        bool operator==(const S3DVertex2TCoords& other) const
+        {
+                return ((static_cast<S3DVertex>(*this)==other) &&
+                        (TCoords2 == other.TCoords2));
+        }
+        //! Inequality operator
+        bool operator!=(const S3DVertex2TCoords& other) const
+        {
+                return ((static_cast<S3DVertex>(*this)!=other) ||
+                        (TCoords2 != other.TCoords2));
+        }
+        bool operator<(const S3DVertex2TCoords& other) const
+        {
+                return ((static_cast<S3DVertex>(*this) < other) ||
+                                ((static_cast<S3DVertex>(*this) == other) && (TCoords2 < other.TCoords2)));
+        }
+        E_VERTEX_TYPE getType() const
+        {
+                return EVT_2TCOORDS;
+        }
+        S3DVertex2TCoords getInterpolated(const S3DVertex2TCoords& other, f32 d)
+        {
+                d = core::clamp(d, 0.0f, 1.0f);
+                return S3DVertex2TCoords(Pos.getInterpolated(other.Pos, d),
+                                Normal.getInterpolated(other.Normal, d),
+                                Color.getInterpolated(other.Color, d),
+                                TCoords.getInterpolated(other.TCoords, d),
+                                TCoords2.getInterpolated(other.TCoords2, d));
+        }
+};
+//! Vertex with a tangent and binormal vector.
+/** Usually used for tangent space normal mapping. */
+struct S3DVertexTangents : public S3DVertex
+{
+        //! default constructor
+        S3DVertexTangents() : S3DVertex() { }
+        //! constructor
+        S3DVertexTangents(f32 x, f32 y, f32 z, f32 nx=0.0f, f32 ny=0.0f, f32 nz=0.0f,
+                        SColor c = 0xFFFFFFFF, f32 tu=0.0f, f32 tv=0.0f,
+                        f32 tanx=0.0f, f32 tany=0.0f, f32 tanz=0.0f,
+                        f32 bx=0.0f, f32 by=0.0f, f32 bz=0.0f)
+                : S3DVertex(x,y,z, nx,ny,nz, c, tu,tv), Tangent(tanx,tany,tanz), Binormal(bx,by,bz) { }
+        //! constructor
+        S3DVertexTangents(const core::vector3df& pos, SColor c,
+                const core::vector2df& tcoords)
+                : S3DVertex(pos, core::vector3df(), c, tcoords) { }
+        //! constructor
+        S3DVertexTangents(const core::vector3df& pos,
+                const core::vector3df& normal, SColor c,
+                const core::vector2df& tcoords,
+                const core::vector3df& tangent=core::vector3df(),
+                const core::vector3df& binormal=core::vector3df())
+                : S3DVertex(pos, normal, c, tcoords), Tangent(tangent), Binormal(binormal) { }
+        //! Tangent vector along the x-axis of the texture
+        core::vector3df Tangent;
+        //! Binormal vector (tangent x normal)
+        core::vector3df Binormal;
+        bool operator==(const S3DVertexTangents& other) const
+        {
+                return ((static_cast<S3DVertex>(*this)==other) &&
+                        (Tangent == other.Tangent) &&
+                        (Binormal == other.Binormal));
+        }
+        bool operator!=(const S3DVertexTangents& other) const
+        {
+                return ((static_cast<S3DVertex>(*this)!=other) ||
+                        (Tangent != other.Tangent) ||
+                        (Binormal != other.Binormal));
+        }
+        bool operator<(const S3DVertexTangents& other) const
+        {
+                return ((static_cast<S3DVertex>(*this) < other) ||
+                                ((static_cast<S3DVertex>(*this) == other) && (Tangent < other.Tangent)) ||
+                                ((static_cast<S3DVertex>(*this) == other) && (Tangent == other.Tangent) && (Binormal < other.Binormal)));
+        }
+        E_VERTEX_TYPE getType() const
+        {
+                return EVT_TANGENTS;
+        }
+        S3DVertexTangents getInterpolated(const S3DVertexTangents& other, f32 d)
+        {
+                d = core::clamp(d, 0.0f, 1.0f);
+                return S3DVertexTangents(Pos.getInterpolated(other.Pos, d),
+                                Normal.getInterpolated(other.Normal, d),
+                                Color.getInterpolated(other.Color, d),
+                                TCoords.getInterpolated(other.TCoords, d),
+                                Tangent.getInterpolated(other.Tangent, d),
+                                Binormal.getInterpolated(other.Binormal, d));
+        }
+};
+inline u32 getVertexPitchFromType(E_VERTEX_TYPE vertexType)
+{
+        switch (vertexType)
+        {
+        case video::EVT_2TCOORDS:
+                return sizeof(video::S3DVertex2TCoords);
+        case video::EVT_TANGENTS:
+                return sizeof(video::S3DVertexTangents);
+        default:
+                return sizeof(video::S3DVertex);
+        }
+}
+} // end namespace video
+} // end namespace irr
+#endif

diff --git a/src/others/irrlicht-1.8.1/include/S3DVertex.h b/src/others/irrlicht-1.8.1/include/S3DVertex.h new file mode 100644 index 0000000..bf0fd5b --- /dev/null +++ b/src/others/irrlicht-1.8.1/include/S3DVertex.h
@@ -0,0 +1,274 @@
	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_3D_VERTEX_H_INCLUDED__
	6	#define __S_3D_VERTEX_H_INCLUDED__
	7
	8	#include "vector3d.h"
	9	#include "vector2d.h"
	10	#include "SColor.h"
	11
	12	namespace irr
	13	{
	14	namespace video
	15	{
	16
	17	//! Enumeration for all vertex types there are.
	18	enum E_VERTEX_TYPE
	19	{
	20	//! Standard vertex type used by the Irrlicht engine, video::S3DVertex.
	21	EVT_STANDARD = 0,
	22
	23	//! Vertex with two texture coordinates, video::S3DVertex2TCoords.
	24	/** Usually used for geometry with lightmaps or other special materials. */
	25	EVT_2TCOORDS,
	26
	27	//! Vertex with a tangent and binormal vector, video::S3DVertexTangents.
	28	/** Usually used for tangent space normal mapping. */
	29	EVT_TANGENTS
	30	};
	31
	32	//! Array holding the built in vertex type names
	33	const char* const sBuiltInVertexTypeNames[] =
	34	{
	35	"standard",
	36	"2tcoords",
	37	"tangents",
	38	0
	39	};
	40
	41	//! standard vertex used by the Irrlicht engine.
	42	struct S3DVertex
	43	{
	44	//! default constructor
	45	S3DVertex() {}
	46
	47	//! constructor
	48	S3DVertex(f32 x, f32 y, f32 z, f32 nx, f32 ny, f32 nz, SColor c, f32 tu, f32 tv)
	49	: Pos(x,y,z), Normal(nx,ny,nz), Color(c), TCoords(tu,tv) {}
	50
	51	//! constructor
	52	S3DVertex(const core::vector3df& pos, const core::vector3df& normal,
	53	SColor color, const core::vector2d<f32>& tcoords)
	54	: Pos(pos), Normal(normal), Color(color), TCoords(tcoords) {}
	55
	56	//! Position
	57	core::vector3df Pos;
	58
	59	//! Normal vector
	60	core::vector3df Normal;
	61
	62	//! Color
	63	SColor Color;
	64
	65	//! Texture coordinates
	66	core::vector2d<f32> TCoords;
	67
	68	bool operator==(const S3DVertex& other) const
	69	{
	70	return ((Pos == other.Pos) && (Normal == other.Normal) &&
	71	(Color == other.Color) && (TCoords == other.TCoords));
	72	}
	73
	74	bool operator!=(const S3DVertex& other) const
	75	{
	76	return ((Pos != other.Pos) \|\| (Normal != other.Normal) \|\|
	77	(Color != other.Color) \|\| (TCoords != other.TCoords));
	78	}
	79
	80	bool operator<(const S3DVertex& other) const
	81	{
	82	return ((Pos < other.Pos) \|\|
	83	((Pos == other.Pos) && (Normal < other.Normal)) \|\|
	84	((Pos == other.Pos) && (Normal == other.Normal) && (Color < other.Color)) \|\|
	85	((Pos == other.Pos) && (Normal == other.Normal) && (Color == other.Color) && (TCoords < other.TCoords)));
	86	}
	87
	88	E_VERTEX_TYPE getType() const
	89	{
	90	return EVT_STANDARD;
	91	}
	92
	93	S3DVertex getInterpolated(const S3DVertex& other, f32 d)
	94	{
	95	d = core::clamp(d, 0.0f, 1.0f);
	96	return S3DVertex(Pos.getInterpolated(other.Pos, d),
	97	Normal.getInterpolated(other.Normal, d),
	98	Color.getInterpolated(other.Color, d),
	99	TCoords.getInterpolated(other.TCoords, d));
	100	}
	101	};
	102
	103
	104	//! Vertex with two texture coordinates.
	105	/** Usually used for geometry with lightmaps
	106	or other special materials.
	107	*/
	108	struct S3DVertex2TCoords : public S3DVertex
	109	{
	110	//! default constructor
	111	S3DVertex2TCoords() : S3DVertex() {}
	112
	113	//! constructor with two different texture coords, but no normal
	114	S3DVertex2TCoords(f32 x, f32 y, f32 z, SColor c, f32 tu, f32 tv, f32 tu2, f32 tv2)
	115	: S3DVertex(x,y,z, 0.0f, 0.0f, 0.0f, c, tu,tv), TCoords2(tu2,tv2) {}
	116
	117	//! constructor with two different texture coords, but no normal
	118	S3DVertex2TCoords(const core::vector3df& pos, SColor color,
	119	const core::vector2d<f32>& tcoords, const core::vector2d<f32>& tcoords2)
	120	: S3DVertex(pos, core::vector3df(), color, tcoords), TCoords2(tcoords2) {}
	121
	122	//! constructor with all values
	123	S3DVertex2TCoords(const core::vector3df& pos, const core::vector3df& normal, const SColor& color,
	124	const core::vector2d<f32>& tcoords, const core::vector2d<f32>& tcoords2)
	125	: S3DVertex(pos, normal, color, tcoords), TCoords2(tcoords2) {}
	126
	127	//! constructor with all values
	128	S3DVertex2TCoords(f32 x, f32 y, f32 z, f32 nx, f32 ny, f32 nz, SColor c, f32 tu, f32 tv, f32 tu2, f32 tv2)
	129	: S3DVertex(x,y,z, nx,ny,nz, c, tu,tv), TCoords2(tu2,tv2) {}
	130
	131	//! constructor with the same texture coords and normal
	132	S3DVertex2TCoords(f32 x, f32 y, f32 z, f32 nx, f32 ny, f32 nz, SColor c, f32 tu, f32 tv)
	133	: S3DVertex(x,y,z, nx,ny,nz, c, tu,tv), TCoords2(tu,tv) {}
	134
	135	//! constructor with the same texture coords and normal
	136	S3DVertex2TCoords(const core::vector3df& pos, const core::vector3df& normal,
	137	SColor color, const core::vector2d<f32>& tcoords)
	138	: S3DVertex(pos, normal, color, tcoords), TCoords2(tcoords) {}
	139
	140	//! constructor from S3DVertex
	141	S3DVertex2TCoords(S3DVertex& o) : S3DVertex(o) {}
	142
	143	//! Second set of texture coordinates
	144	core::vector2d<f32> TCoords2;
	145
	146	//! Equality operator
	147	bool operator==(const S3DVertex2TCoords& other) const
	148	{
	149	return ((static_cast<S3DVertex>(*this)==other) &&
	150	(TCoords2 == other.TCoords2));
	151	}
	152
	153	//! Inequality operator
	154	bool operator!=(const S3DVertex2TCoords& other) const
	155	{
	156	return ((static_cast<S3DVertex>(*this)!=other) \|\|
	157	(TCoords2 != other.TCoords2));
	158	}
	159
	160	bool operator<(const S3DVertex2TCoords& other) const
	161	{
	162	return ((static_cast<S3DVertex>(*this) < other) \|\|
	163	((static_cast<S3DVertex>(*this) == other) && (TCoords2 < other.TCoords2)));
	164	}
	165
	166	E_VERTEX_TYPE getType() const
	167	{
	168	return EVT_2TCOORDS;
	169	}
	170
	171	S3DVertex2TCoords getInterpolated(const S3DVertex2TCoords& other, f32 d)
	172	{
	173	d = core::clamp(d, 0.0f, 1.0f);
	174	return S3DVertex2TCoords(Pos.getInterpolated(other.Pos, d),
	175	Normal.getInterpolated(other.Normal, d),
	176	Color.getInterpolated(other.Color, d),
	177	TCoords.getInterpolated(other.TCoords, d),
	178	TCoords2.getInterpolated(other.TCoords2, d));
	179	}
	180	};
	181
	182
	183	//! Vertex with a tangent and binormal vector.
	184	/** Usually used for tangent space normal mapping. */
	185	struct S3DVertexTangents : public S3DVertex
	186	{
	187	//! default constructor
	188	S3DVertexTangents() : S3DVertex() { }
	189
	190	//! constructor
	191	S3DVertexTangents(f32 x, f32 y, f32 z, f32 nx=0.0f, f32 ny=0.0f, f32 nz=0.0f,
	192	SColor c = 0xFFFFFFFF, f32 tu=0.0f, f32 tv=0.0f,
	193	f32 tanx=0.0f, f32 tany=0.0f, f32 tanz=0.0f,
	194	f32 bx=0.0f, f32 by=0.0f, f32 bz=0.0f)
	195	: S3DVertex(x,y,z, nx,ny,nz, c, tu,tv), Tangent(tanx,tany,tanz), Binormal(bx,by,bz) { }
	196
	197	//! constructor
	198	S3DVertexTangents(const core::vector3df& pos, SColor c,
	199	const core::vector2df& tcoords)
	200	: S3DVertex(pos, core::vector3df(), c, tcoords) { }
	201
	202	//! constructor
	203	S3DVertexTangents(const core::vector3df& pos,
	204	const core::vector3df& normal, SColor c,
	205	const core::vector2df& tcoords,
	206	const core::vector3df& tangent=core::vector3df(),
	207	const core::vector3df& binormal=core::vector3df())
	208	: S3DVertex(pos, normal, c, tcoords), Tangent(tangent), Binormal(binormal) { }
	209
	210	//! Tangent vector along the x-axis of the texture
	211	core::vector3df Tangent;
	212
	213	//! Binormal vector (tangent x normal)
	214	core::vector3df Binormal;
	215
	216	bool operator==(const S3DVertexTangents& other) const
	217	{
	218	return ((static_cast<S3DVertex>(*this)==other) &&
	219	(Tangent == other.Tangent) &&
	220	(Binormal == other.Binormal));
	221	}
	222
	223	bool operator!=(const S3DVertexTangents& other) const
	224	{
	225	return ((static_cast<S3DVertex>(*this)!=other) \|\|
	226	(Tangent != other.Tangent) \|\|
	227	(Binormal != other.Binormal));
	228	}
	229
	230	bool operator<(const S3DVertexTangents& other) const
	231	{
	232	return ((static_cast<S3DVertex>(*this) < other) \|\|
	233	((static_cast<S3DVertex>(*this) == other) && (Tangent < other.Tangent)) \|\|
	234	((static_cast<S3DVertex>(*this) == other) && (Tangent == other.Tangent) && (Binormal < other.Binormal)));
	235	}
	236
	237	E_VERTEX_TYPE getType() const
	238	{
	239	return EVT_TANGENTS;
	240	}
	241
	242	S3DVertexTangents getInterpolated(const S3DVertexTangents& other, f32 d)
	243	{
	244	d = core::clamp(d, 0.0f, 1.0f);
	245	return S3DVertexTangents(Pos.getInterpolated(other.Pos, d),
	246	Normal.getInterpolated(other.Normal, d),
	247	Color.getInterpolated(other.Color, d),
	248	TCoords.getInterpolated(other.TCoords, d),
	249	Tangent.getInterpolated(other.Tangent, d),
	250	Binormal.getInterpolated(other.Binormal, d));
	251	}
	252	};
	253
	254
	255
	256	inline u32 getVertexPitchFromType(E_VERTEX_TYPE vertexType)
	257	{
	258	switch (vertexType)
	259	{
	260	case video::EVT_2TCOORDS:
	261	return sizeof(video::S3DVertex2TCoords);
	262	case video::EVT_TANGENTS:
	263	return sizeof(video::S3DVertexTangents);
	264	default:
	265	return sizeof(video::S3DVertex);
	266	}
	267	}
	268
	269
	270	} // end namespace video
	271	} // end namespace irr
	272
	273	#endif
	274