aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/libraries/irrlicht-1.8/include/S3DVertex.h
diff options
context:
space:
mode:
Diffstat (limited to 'libraries/irrlicht-1.8/include/S3DVertex.h')
-rw-r--r--libraries/irrlicht-1.8/include/S3DVertex.h274
1 files changed, 0 insertions, 274 deletions
diff --git a/libraries/irrlicht-1.8/include/S3DVertex.h b/libraries/irrlicht-1.8/include/S3DVertex.h
deleted file mode 100644
index 706cf4b..0000000
--- a/libraries/irrlicht-1.8/include/S3DVertex.h
+++ /dev/null
@@ -1,274 +0,0 @@
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
12namespace irr
13{
14namespace video
15{
16
17//! Enumeration for all vertex types there are.
18enum 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
33const char* const sBuiltInVertexTypeNames[] =
34{
35 "standard",
36 "2tcoords",
37 "tangents",
38 0
39};
40
41//! standard vertex used by the Irrlicht engine.
42struct 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
106or other special materials.
107*/
108struct 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. */
185struct 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
256inline 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
generated by cgit v1.1 at 2024-11-03 22:22:17 +0000