Irrlicht 3D Engine
S3DVertex.h
Go to the documentation of this file.
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 
19 {
22 
24 
26 
28 
32 };
33 
35 const char* const sBuiltInVertexTypeNames[] =
36 {
37  "standard",
38  "2tcoords",
39  "tangents",
40  0
41 };
42 
44 struct S3DVertex
45 {
47  S3DVertex() {}
48 
50  S3DVertex(f32 x, f32 y, f32 z, f32 nx, f32 ny, f32 nz, SColor c, f32 tu, f32 tv)
51  : Pos(x,y,z), Normal(nx,ny,nz), Color(c), TCoords(tu,tv) {}
52 
54  S3DVertex(const core::vector3df& pos, const core::vector3df& normal,
55  SColor color, const core::vector2d<f32>& tcoords)
56  : Pos(pos), Normal(normal), Color(color), TCoords(tcoords) {}
57 
60 
63 
66 
69 
70  bool operator==(const S3DVertex& other) const
71  {
72  return ((Pos == other.Pos) && (Normal == other.Normal) &&
73  (Color == other.Color) && (TCoords == other.TCoords));
74  }
75 
76  bool operator!=(const S3DVertex& other) const
77  {
78  return ((Pos != other.Pos) || (Normal != other.Normal) ||
79  (Color != other.Color) || (TCoords != other.TCoords));
80  }
81 
82  bool operator<(const S3DVertex& other) const
83  {
84  return ((Pos < other.Pos) ||
85  ((Pos == other.Pos) && (Normal < other.Normal)) ||
86  ((Pos == other.Pos) && (Normal == other.Normal) && (Color < other.Color)) ||
87  ((Pos == other.Pos) && (Normal == other.Normal) && (Color == other.Color) && (TCoords < other.TCoords)));
88  }
89 
91  {
92  return EVT_STANDARD;
93  }
94 
95  //\param d d=0 returns other, d=1 returns this, values between interpolate.
97  {
98  d = core::clamp(d, 0.0f, 1.0f);
99  return S3DVertex(Pos.getInterpolated(other.Pos, d),
100  Normal.getInterpolated(other.Normal, d),
101  Color.getInterpolated(other.Color, d),
102  TCoords.getInterpolated(other.TCoords, d));
103  }
104 };
105 
106 
108 
112 {
115 
117  S3DVertex2TCoords(f32 x, f32 y, f32 z, SColor c, f32 tu, f32 tv, f32 tu2, f32 tv2)
118  : S3DVertex(x,y,z, 0.0f, 0.0f, 0.0f, c, tu,tv), TCoords2(tu2,tv2) {}
119 
122  const core::vector2d<f32>& tcoords, const core::vector2d<f32>& tcoords2)
123  : S3DVertex(pos, core::vector3df(), color, tcoords), TCoords2(tcoords2) {}
124 
126  S3DVertex2TCoords(const core::vector3df& pos, const core::vector3df& normal, const SColor& color,
127  const core::vector2d<f32>& tcoords, const core::vector2d<f32>& tcoords2)
128  : S3DVertex(pos, normal, color, tcoords), TCoords2(tcoords2) {}
129 
131  S3DVertex2TCoords(f32 x, f32 y, f32 z, f32 nx, f32 ny, f32 nz, SColor c, f32 tu, f32 tv, f32 tu2, f32 tv2)
132  : S3DVertex(x,y,z, nx,ny,nz, c, tu,tv), TCoords2(tu2,tv2) {}
133 
135  S3DVertex2TCoords(f32 x, f32 y, f32 z, f32 nx, f32 ny, f32 nz, SColor c, f32 tu, f32 tv)
136  : S3DVertex(x,y,z, nx,ny,nz, c, tu,tv), TCoords2(tu,tv) {}
137 
140  SColor color, const core::vector2d<f32>& tcoords)
141  : S3DVertex(pos, normal, color, tcoords), TCoords2(tcoords) {}
142 
145 
148 
150  bool operator==(const S3DVertex2TCoords& other) const
151  {
152  return ((static_cast<S3DVertex>(*this)==other) &&
153  (TCoords2 == other.TCoords2));
154  }
155 
157  bool operator!=(const S3DVertex2TCoords& other) const
158  {
159  return ((static_cast<S3DVertex>(*this)!=other) ||
160  (TCoords2 != other.TCoords2));
161  }
162 
163  bool operator<(const S3DVertex2TCoords& other) const
164  {
165  return ((static_cast<S3DVertex>(*this) < other) ||
166  ((static_cast<S3DVertex>(*this) == other) && (TCoords2 < other.TCoords2)));
167  }
168 
170  {
171  return EVT_2TCOORDS;
172  }
173 
174  //\param d d=0 returns other, d=1 returns this, values between interpolate.
176  {
177  d = core::clamp(d, 0.0f, 1.0f);
178  return S3DVertex2TCoords(Pos.getInterpolated(other.Pos, d),
179  Normal.getInterpolated(other.Normal, d),
180  Color.getInterpolated(other.Color, d),
181  TCoords.getInterpolated(other.TCoords, d),
182  TCoords2.getInterpolated(other.TCoords2, d));
183  }
184 };
185 
186 
188 
192 {
195 
197  S3DVertexTangents(f32 x, f32 y, f32 z, f32 nx=0.0f, f32 ny=0.0f, f32 nz=0.0f,
198  SColor c = 0xFFFFFFFF, f32 tu=0.0f, f32 tv=0.0f,
199  f32 tanx=0.0f, f32 tany=0.0f, f32 tanz=0.0f,
200  f32 bx=0.0f, f32 by=0.0f, f32 bz=0.0f)
201  : S3DVertex(x,y,z, nx,ny,nz, c, tu,tv), Tangent(tanx,tany,tanz), Binormal(bx,by,bz) { }
202 
205  const core::vector2df& tcoords)
206  : S3DVertex(pos, core::vector3df(), c, tcoords) { }
207 
210  const core::vector3df& normal, SColor c,
211  const core::vector2df& tcoords,
212  const core::vector3df& tangent=core::vector3df(),
213  const core::vector3df& binormal=core::vector3df())
214  : S3DVertex(pos, normal, c, tcoords), Tangent(tangent), Binormal(binormal) { }
215 
218 
221 
222  bool operator==(const S3DVertexTangents& other) const
223  {
224  return ((static_cast<S3DVertex>(*this)==other) &&
225  (Tangent == other.Tangent) &&
226  (Binormal == other.Binormal));
227  }
228 
229  bool operator!=(const S3DVertexTangents& other) const
230  {
231  return ((static_cast<S3DVertex>(*this)!=other) ||
232  (Tangent != other.Tangent) ||
233  (Binormal != other.Binormal));
234  }
235 
236  bool operator<(const S3DVertexTangents& other) const
237  {
238  return ((static_cast<S3DVertex>(*this) < other) ||
239  ((static_cast<S3DVertex>(*this) == other) && (Tangent < other.Tangent)) ||
240  ((static_cast<S3DVertex>(*this) == other) && (Tangent == other.Tangent) && (Binormal < other.Binormal)));
241  }
242 
244  {
245  return EVT_TANGENTS;
246  }
247 
249  {
250  d = core::clamp(d, 0.0f, 1.0f);
251  return S3DVertexTangents(Pos.getInterpolated(other.Pos, d),
252  Normal.getInterpolated(other.Normal, d),
253  Color.getInterpolated(other.Color, d),
254  TCoords.getInterpolated(other.TCoords, d),
255  Tangent.getInterpolated(other.Tangent, d),
256  Binormal.getInterpolated(other.Binormal, d));
257  }
258 };
259 
260 
261 
263 {
264  switch (vertexType)
265  {
266  case video::EVT_2TCOORDS:
267  return sizeof(video::S3DVertex2TCoords);
268  case video::EVT_TANGENTS:
269  return sizeof(video::S3DVertexTangents);
270  default:
271  return sizeof(video::S3DVertex);
272  }
273 }
274 
275 
276 } // end namespace video
277 } // end namespace irr
278 
279 #endif
280 
S3DVertex2TCoords(const core::vector3df &pos, const core::vector3df &normal, const SColor &color, const core::vector2d< f32 > &tcoords, const core::vector2d< f32 > &tcoords2)
constructor with all values
Definition: S3DVertex.h:126
bool operator==(const S3DVertex2TCoords &other) const
Equality operator.
Definition: S3DVertex.h:150
bool operator!=(const S3DVertexTangents &other) const
Definition: S3DVertex.h:229
core::vector2d< f32 > TCoords2
Second set of texture coordinates.
Definition: S3DVertex.h:147
S3DVertexTangents getInterpolated(const S3DVertexTangents &other, f32 d)
Definition: S3DVertex.h:248
core::vector3df Binormal
Binormal vector (tangent x normal)
Definition: S3DVertex.h:220
SColor getInterpolated(const SColor &other, f32 d) const
Interpolates the color with a f32 value to another color.
Definition: SColor.h:453
bool operator==(const S3DVertex &other) const
Definition: S3DVertex.h:70
float f32
32 bit floating point variable.
Definition: irrTypes.h:108
vector3d< T > getInterpolated(const vector3d< T > &other, f64 d) const
Creates an interpolated vector between this vector and another vector.
Definition: vector3d.h:247
core::vector3df Pos
Position.
Definition: S3DVertex.h:59
S3DVertex getInterpolated(const S3DVertex &other, f32 d)
Definition: S3DVertex.h:96
E_VERTEX_TYPE getType() const
Definition: S3DVertex.h:243
S3DVertex2TCoords(S3DVertex &o)
constructor from S3DVertex
Definition: S3DVertex.h:144
E_VERTEX_TYPE getType() const
Definition: S3DVertex.h:90
S3DVertex2TCoords()
default constructor
Definition: S3DVertex.h:114
bool operator<(const S3DVertex &other) const
Definition: S3DVertex.h:82
Everything in the Irrlicht Engine can be found in this namespace.
Definition: aabbox3d.h:12
Vertex with two texture coordinates, video::S3DVertex2TCoords.
Definition: S3DVertex.h:25
bool operator!=(const S3DVertex2TCoords &other) const
Inequality operator.
Definition: S3DVertex.h:157
vector3d< f32 > vector3df
Typedef for a f32 3d vector.
Definition: vector3d.h:447
vector2d< T > getInterpolated(const vector2d< T > &other, f64 d) const
Creates an interpolated vector between this vector and another vector.
Definition: vector2d.h:302
Vertex with two texture coordinates.
Definition: S3DVertex.h:111
S3DVertex2TCoords(const core::vector3df &pos, SColor color, const core::vector2d< f32 > &tcoords, const core::vector2d< f32 > &tcoords2)
constructor with two different texture coords, but no normal
Definition: S3DVertex.h:121
core::vector3df Tangent
Tangent vector along the x-axis of the texture.
Definition: S3DVertex.h:217
Vertex with a tangent and binormal vector, video::S3DVertexTangents.
Definition: S3DVertex.h:31
S3DVertex()
default constructor
Definition: S3DVertex.h:47
unsigned int u32
32 bit unsigned variable.
Definition: irrTypes.h:62
Standard vertex type used by the Irrlicht engine, video::S3DVertex.
Definition: S3DVertex.h:21
S3DVertex(f32 x, f32 y, f32 z, f32 nx, f32 ny, f32 nz, SColor c, f32 tu, f32 tv)
constructor
Definition: S3DVertex.h:50
S3DVertexTangents(const core::vector3df &pos, SColor c, const core::vector2df &tcoords)
constructor
Definition: S3DVertex.h:204
S3DVertex(const core::vector3df &pos, const core::vector3df &normal, SColor color, const core::vector2d< f32 > &tcoords)
constructor
Definition: S3DVertex.h:54
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())
constructor
Definition: S3DVertex.h:209
standard vertex used by the Irrlicht engine.
Definition: S3DVertex.h:44
S3DVertex2TCoords getInterpolated(const S3DVertex2TCoords &other, f32 d)
Definition: S3DVertex.h:175
S3DVertex2TCoords(f32 x, f32 y, f32 z, f32 nx, f32 ny, f32 nz, SColor c, f32 tu, f32 tv)
constructor with the same texture coords and normal
Definition: S3DVertex.h:135
S3DVertex2TCoords(const core::vector3df &pos, const core::vector3df &normal, SColor color, const core::vector2d< f32 > &tcoords)
constructor with the same texture coords and normal
Definition: S3DVertex.h:139
E_VERTEX_TYPE getType() const
Definition: S3DVertex.h:169
Class representing a 32 bit ARGB color.
Definition: SColor.h:314
bool operator<(const S3DVertex2TCoords &other) const
Definition: S3DVertex.h:163
SColor Color
Color.
Definition: S3DVertex.h:65
S3DVertex2TCoords(f32 x, f32 y, f32 z, SColor c, f32 tu, f32 tv, f32 tu2, f32 tv2)
constructor with two different texture coords, but no normal
Definition: S3DVertex.h:117
E_VERTEX_TYPE
Enumeration for all vertex types there are.
Definition: S3DVertex.h:18
S3DVertexTangents()
default constructor
Definition: S3DVertex.h:194
core::vector2d< f32 > TCoords
Texture coordinates.
Definition: S3DVertex.h:68
const char *const sBuiltInVertexTypeNames[]
Array holding the built in vertex type names.
Definition: S3DVertex.h:35
core::vector3df Normal
Normal vector.
Definition: S3DVertex.h:62
Vertex with a tangent and binormal vector.
Definition: S3DVertex.h:191
bool operator!=(const S3DVertex &other) const
Definition: S3DVertex.h:76
bool operator<(const S3DVertexTangents &other) const
Definition: S3DVertex.h:236
S3DVertex2TCoords(f32 x, f32 y, f32 z, f32 nx, f32 ny, f32 nz, SColor c, f32 tu, f32 tv, f32 tu2, f32 tv2)
constructor with all values
Definition: S3DVertex.h:131
bool operator==(const S3DVertexTangents &other) const
Definition: S3DVertex.h:222
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)
constructor
Definition: S3DVertex.h:197
const T clamp(const T &value, const T &low, const T &high)
clamps a value between low and high
Definition: irrMath.h:167
u32 getVertexPitchFromType(E_VERTEX_TYPE vertexType)
Definition: S3DVertex.h:262