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 
30 };
31 
33 const char* const sBuiltInVertexTypeNames[] =
34 {
35  "standard",
36  "2tcoords",
37  "tangents",
38  0
39 };
40 
42 struct S3DVertex
43 {
45  S3DVertex() {}
46 
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 
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 
58 
61 
64 
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 
89  {
90  return EVT_STANDARD;
91  }
92 
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 
105 
109 {
112 
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 
119  const core::vector2d<f32>& tcoords, const core::vector2d<f32>& tcoords2)
120  : S3DVertex(pos, core::vector3df(), color, tcoords), TCoords2(tcoords2) {}
121 
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 
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 
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 
137  SColor color, const core::vector2d<f32>& tcoords)
138  : S3DVertex(pos, normal, color, tcoords), TCoords2(tcoords) {}
139 
142 
145 
147  bool operator==(const S3DVertex2TCoords& other) const
148  {
149  return ((static_cast<S3DVertex>(*this)==other) &&
150  (TCoords2 == other.TCoords2));
151  }
152 
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 
167  {
168  return EVT_2TCOORDS;
169  }
170 
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 
184 
186 {
189 
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 
199  const core::vector2df& tcoords)
200  : S3DVertex(pos, core::vector3df(), c, tcoords) { }
201 
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 
212 
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 
238  {
239  return EVT_TANGENTS;
240  }
241 
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 
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 
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:123
bool operator==(const S3DVertex2TCoords &other) const
Equality operator.
Definition: S3DVertex.h:147
bool operator!=(const S3DVertexTangents &other) const
Definition: S3DVertex.h:223
core::vector2d< f32 > TCoords2
Second set of texture coordinates.
Definition: S3DVertex.h:144
S3DVertexTangents getInterpolated(const S3DVertexTangents &other, f32 d)
Definition: S3DVertex.h:242
core::vector3df Binormal
Binormal vector (tangent x normal)
Definition: S3DVertex.h:214
SColor getInterpolated(const SColor &other, f32 d) const
Interpolates the color with a f32 value to another color.
Definition: SColor.h:340
bool operator==(const S3DVertex &other) const
Definition: S3DVertex.h:68
float f32
32 bit floating point variable.
Definition: irrTypes.h:104
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:57
S3DVertex getInterpolated(const S3DVertex &other, f32 d)
Definition: S3DVertex.h:93
E_VERTEX_TYPE getType() const
Definition: S3DVertex.h:237
S3DVertex2TCoords(S3DVertex &o)
constructor from S3DVertex
Definition: S3DVertex.h:141
E_VERTEX_TYPE getType() const
Definition: S3DVertex.h:88
S3DVertex2TCoords()
default constructor
Definition: S3DVertex.h:111
bool operator<(const S3DVertex &other) const
Definition: S3DVertex.h:80
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:154
vector3d< f32 > vector3df
Typedef for a f32 3d vector.
Definition: vector3d.h:445
vector2d< T > getInterpolated(const vector2d< T > &other, f64 d) const
Creates an interpolated vector between this vector and another vector.
Definition: vector2d.h:278
Vertex with two texture coordinates.
Definition: S3DVertex.h:108
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:118
core::vector3df Tangent
Tangent vector along the x-axis of the texture.
Definition: S3DVertex.h:211
Vertex with a tangent and binormal vector, video::S3DVertexTangents.
Definition: S3DVertex.h:29
S3DVertex()
default constructor
Definition: S3DVertex.h:45
unsigned int u32
32 bit unsigned variable.
Definition: irrTypes.h:58
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:48
S3DVertexTangents(const core::vector3df &pos, SColor c, const core::vector2df &tcoords)
constructor
Definition: S3DVertex.h:198
S3DVertex(const core::vector3df &pos, const core::vector3df &normal, SColor color, const core::vector2d< f32 > &tcoords)
constructor
Definition: S3DVertex.h:52
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:203
standard vertex used by the Irrlicht engine.
Definition: S3DVertex.h:42
S3DVertex2TCoords getInterpolated(const S3DVertex2TCoords &other, f32 d)
Definition: S3DVertex.h:171
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:132
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:136
E_VERTEX_TYPE getType() const
Definition: S3DVertex.h:166
Class representing a 32 bit ARGB color.
Definition: SColor.h:201
bool operator<(const S3DVertex2TCoords &other) const
Definition: S3DVertex.h:160
SColor Color
Color.
Definition: S3DVertex.h:63
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:114
E_VERTEX_TYPE
Enumeration for all vertex types there are.
Definition: S3DVertex.h:18
S3DVertexTangents()
default constructor
Definition: S3DVertex.h:188
core::vector2d< f32 > TCoords
Texture coordinates.
Definition: S3DVertex.h:66
const char *const sBuiltInVertexTypeNames[]
Array holding the built in vertex type names.
Definition: S3DVertex.h:33
core::vector3df Normal
Normal vector.
Definition: S3DVertex.h:60
Vertex with a tangent and binormal vector.
Definition: S3DVertex.h:185
bool operator!=(const S3DVertex &other) const
Definition: S3DVertex.h:74
bool operator<(const S3DVertexTangents &other) const
Definition: S3DVertex.h:230
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:128
bool operator==(const S3DVertexTangents &other) const
Definition: S3DVertex.h:216
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:191
const T clamp(const T &value, const T &low, const T &high)
clamps a value between low and high
Definition: irrMath.h:166
u32 getVertexPitchFromType(E_VERTEX_TYPE vertexType)
Definition: S3DVertex.h:256