Line data Source code
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 53992250 : struct S3DVertex
43 : {
44 : //! default constructor
45 4673731 : S3DVertex() {}
46 :
47 : //! constructor
48 4026917 : S3DVertex(f32 x, f32 y, f32 z, f32 nx, f32 ny, f32 nz, SColor c, f32 tu, f32 tv)
49 4026917 : : Pos(x,y,z), Normal(nx,ny,nz), Color(c), TCoords(tu,tv) {}
50 :
51 : //! constructor
52 10292567 : S3DVertex(const core::vector3df& pos, const core::vector3df& normal,
53 : SColor color, const core::vector2d<f32>& tcoords)
54 10292567 : : 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 0 : bool operator==(const S3DVertex& other) const
69 : {
70 0 : return ((Pos == other.Pos) && (Normal == other.Normal) &&
71 0 : (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 0 : bool operator<(const S3DVertex& other) const
81 : {
82 0 : return ((Pos < other.Pos) ||
83 0 : ((Pos == other.Pos) && (Normal < other.Normal)) ||
84 0 : ((Pos == other.Pos) && (Normal == other.Normal) && (Color < other.Color)) ||
85 0 : ((Pos == other.Pos) && (Normal == other.Normal) && (Color == other.Color) && (TCoords < other.TCoords)));
86 : }
87 :
88 51513 : E_VERTEX_TYPE getType() const
89 : {
90 51513 : 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 4905 : struct S3DVertex2TCoords : public S3DVertex
109 : {
110 : //! default constructor
111 0 : 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 0 : bool operator==(const S3DVertex2TCoords& other) const
148 : {
149 0 : return ((static_cast<S3DVertex>(*this)==other) &&
150 0 : (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 0 : bool operator<(const S3DVertex2TCoords& other) const
161 : {
162 0 : return ((static_cast<S3DVertex>(*this) < other) ||
163 0 : ((static_cast<S3DVertex>(*this) == other) && (TCoords2 < other.TCoords2)));
164 : }
165 :
166 0 : E_VERTEX_TYPE getType() const
167 : {
168 0 : 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 32467706 : struct S3DVertexTangents : public S3DVertex
186 : {
187 : //! default constructor
188 1519658 : 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 7195683 : 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 7195683 : : 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 0 : bool operator==(const S3DVertexTangents& other) const
217 : {
218 0 : return ((static_cast<S3DVertex>(*this)==other) &&
219 0 : (Tangent == other.Tangent) &&
220 0 : (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 0 : bool operator<(const S3DVertexTangents& other) const
231 : {
232 0 : return ((static_cast<S3DVertex>(*this) < other) ||
233 0 : ((static_cast<S3DVertex>(*this) == other) && (Tangent < other.Tangent)) ||
234 0 : ((static_cast<S3DVertex>(*this) == other) && (Tangent == other.Tangent) && (Binormal < other.Binormal)));
235 : }
236 :
237 1519479 : E_VERTEX_TYPE getType() const
238 : {
239 1519479 : 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 52969 : inline u32 getVertexPitchFromType(E_VERTEX_TYPE vertexType)
257 : {
258 52969 : switch (vertexType)
259 : {
260 : case video::EVT_2TCOORDS:
261 0 : return sizeof(video::S3DVertex2TCoords);
262 : case video::EVT_TANGENTS:
263 31115 : return sizeof(video::S3DVertexTangents);
264 : default:
265 21854 : return sizeof(video::S3DVertex);
266 : }
267 : }
268 :
269 :
270 : } // end namespace video
271 : } // end namespace irr
272 :
273 : #endif
274 :
|
