diff options
Diffstat (limited to 'libraries/irrlicht-1.8.1/include/CMeshBuffer.h')
-rw-r--r-- | libraries/irrlicht-1.8.1/include/CMeshBuffer.h | 301 |
1 files changed, 301 insertions, 0 deletions
diff --git a/libraries/irrlicht-1.8.1/include/CMeshBuffer.h b/libraries/irrlicht-1.8.1/include/CMeshBuffer.h new file mode 100644 index 0000000..7512a38 --- /dev/null +++ b/libraries/irrlicht-1.8.1/include/CMeshBuffer.h | |||
@@ -0,0 +1,301 @@ | |||
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 __T_MESH_BUFFER_H_INCLUDED__ | ||
6 | #define __T_MESH_BUFFER_H_INCLUDED__ | ||
7 | |||
8 | #include "irrArray.h" | ||
9 | #include "IMeshBuffer.h" | ||
10 | |||
11 | namespace irr | ||
12 | { | ||
13 | namespace scene | ||
14 | { | ||
15 | //! Template implementation of the IMeshBuffer interface | ||
16 | template <class T> | ||
17 | class CMeshBuffer : public IMeshBuffer | ||
18 | { | ||
19 | public: | ||
20 | //! Default constructor for empty meshbuffer | ||
21 | CMeshBuffer():ChangedID_Vertex(1),ChangedID_Index(1),MappingHint_Vertex(EHM_NEVER), MappingHint_Index(EHM_NEVER) | ||
22 | { | ||
23 | #ifdef _DEBUG | ||
24 | setDebugName("SMeshBuffer"); | ||
25 | #endif | ||
26 | } | ||
27 | |||
28 | |||
29 | //! Get material of this meshbuffer | ||
30 | /** \return Material of this buffer */ | ||
31 | virtual const video::SMaterial& getMaterial() const | ||
32 | { | ||
33 | return Material; | ||
34 | } | ||
35 | |||
36 | |||
37 | //! Get material of this meshbuffer | ||
38 | /** \return Material of this buffer */ | ||
39 | virtual video::SMaterial& getMaterial() | ||
40 | { | ||
41 | return Material; | ||
42 | } | ||
43 | |||
44 | |||
45 | //! Get pointer to vertices | ||
46 | /** \return Pointer to vertices. */ | ||
47 | virtual const void* getVertices() const | ||
48 | { | ||
49 | return Vertices.const_pointer(); | ||
50 | } | ||
51 | |||
52 | |||
53 | //! Get pointer to vertices | ||
54 | /** \return Pointer to vertices. */ | ||
55 | virtual void* getVertices() | ||
56 | { | ||
57 | return Vertices.pointer(); | ||
58 | } | ||
59 | |||
60 | |||
61 | //! Get number of vertices | ||
62 | /** \return Number of vertices. */ | ||
63 | virtual u32 getVertexCount() const | ||
64 | { | ||
65 | return Vertices.size(); | ||
66 | } | ||
67 | |||
68 | //! Get type of index data which is stored in this meshbuffer. | ||
69 | /** \return Index type of this buffer. */ | ||
70 | virtual video::E_INDEX_TYPE getIndexType() const | ||
71 | { | ||
72 | return video::EIT_16BIT; | ||
73 | } | ||
74 | |||
75 | //! Get pointer to indices | ||
76 | /** \return Pointer to indices. */ | ||
77 | virtual const u16* getIndices() const | ||
78 | { | ||
79 | return Indices.const_pointer(); | ||
80 | } | ||
81 | |||
82 | |||
83 | //! Get pointer to indices | ||
84 | /** \return Pointer to indices. */ | ||
85 | virtual u16* getIndices() | ||
86 | { | ||
87 | return Indices.pointer(); | ||
88 | } | ||
89 | |||
90 | |||
91 | //! Get number of indices | ||
92 | /** \return Number of indices. */ | ||
93 | virtual u32 getIndexCount() const | ||
94 | { | ||
95 | return Indices.size(); | ||
96 | } | ||
97 | |||
98 | |||
99 | //! Get the axis aligned bounding box | ||
100 | /** \return Axis aligned bounding box of this buffer. */ | ||
101 | virtual const core::aabbox3d<f32>& getBoundingBox() const | ||
102 | { | ||
103 | return BoundingBox; | ||
104 | } | ||
105 | |||
106 | |||
107 | //! Set the axis aligned bounding box | ||
108 | /** \param box New axis aligned bounding box for this buffer. */ | ||
109 | //! set user axis aligned bounding box | ||
110 | virtual void setBoundingBox(const core::aabbox3df& box) | ||
111 | { | ||
112 | BoundingBox = box; | ||
113 | } | ||
114 | |||
115 | |||
116 | //! Recalculate the bounding box. | ||
117 | /** should be called if the mesh changed. */ | ||
118 | virtual void recalculateBoundingBox() | ||
119 | { | ||
120 | if (Vertices.empty()) | ||
121 | BoundingBox.reset(0,0,0); | ||
122 | else | ||
123 | { | ||
124 | BoundingBox.reset(Vertices[0].Pos); | ||
125 | for (u32 i=1; i<Vertices.size(); ++i) | ||
126 | BoundingBox.addInternalPoint(Vertices[i].Pos); | ||
127 | } | ||
128 | } | ||
129 | |||
130 | |||
131 | //! Get type of vertex data stored in this buffer. | ||
132 | /** \return Type of vertex data. */ | ||
133 | virtual video::E_VERTEX_TYPE getVertexType() const | ||
134 | { | ||
135 | return T().getType(); | ||
136 | } | ||
137 | |||
138 | //! returns position of vertex i | ||
139 | virtual const core::vector3df& getPosition(u32 i) const | ||
140 | { | ||
141 | return Vertices[i].Pos; | ||
142 | } | ||
143 | |||
144 | //! returns position of vertex i | ||
145 | virtual core::vector3df& getPosition(u32 i) | ||
146 | { | ||
147 | return Vertices[i].Pos; | ||
148 | } | ||
149 | |||
150 | //! returns normal of vertex i | ||
151 | virtual const core::vector3df& getNormal(u32 i) const | ||
152 | { | ||
153 | return Vertices[i].Normal; | ||
154 | } | ||
155 | |||
156 | //! returns normal of vertex i | ||
157 | virtual core::vector3df& getNormal(u32 i) | ||
158 | { | ||
159 | return Vertices[i].Normal; | ||
160 | } | ||
161 | |||
162 | //! returns texture coord of vertex i | ||
163 | virtual const core::vector2df& getTCoords(u32 i) const | ||
164 | { | ||
165 | return Vertices[i].TCoords; | ||
166 | } | ||
167 | |||
168 | //! returns texture coord of vertex i | ||
169 | virtual core::vector2df& getTCoords(u32 i) | ||
170 | { | ||
171 | return Vertices[i].TCoords; | ||
172 | } | ||
173 | |||
174 | |||
175 | //! Append the vertices and indices to the current buffer | ||
176 | /** Only works for compatible types, i.e. either the same type | ||
177 | or the main buffer is of standard type. Otherwise, behavior is | ||
178 | undefined. | ||
179 | */ | ||
180 | virtual void append(const void* const vertices, u32 numVertices, const u16* const indices, u32 numIndices) | ||
181 | { | ||
182 | if (vertices == getVertices()) | ||
183 | return; | ||
184 | |||
185 | const u32 vertexCount = getVertexCount(); | ||
186 | u32 i; | ||
187 | |||
188 | Vertices.reallocate(vertexCount+numVertices); | ||
189 | for (i=0; i<numVertices; ++i) | ||
190 | { | ||
191 | Vertices.push_back(reinterpret_cast<const T*>(vertices)[i]); | ||
192 | BoundingBox.addInternalPoint(reinterpret_cast<const T*>(vertices)[i].Pos); | ||
193 | } | ||
194 | |||
195 | Indices.reallocate(getIndexCount()+numIndices); | ||
196 | for (i=0; i<numIndices; ++i) | ||
197 | { | ||
198 | Indices.push_back(indices[i]+vertexCount); | ||
199 | } | ||
200 | } | ||
201 | |||
202 | |||
203 | //! Append the meshbuffer to the current buffer | ||
204 | /** Only works for compatible types, i.e. either the same type | ||
205 | or the main buffer is of standard type. Otherwise, behavior is | ||
206 | undefined. | ||
207 | \param other Meshbuffer to be appended to this one. | ||
208 | */ | ||
209 | virtual void append(const IMeshBuffer* const other) | ||
210 | { | ||
211 | /* | ||
212 | if (this==other) | ||
213 | return; | ||
214 | |||
215 | const u32 vertexCount = getVertexCount(); | ||
216 | u32 i; | ||
217 | |||
218 | Vertices.reallocate(vertexCount+other->getVertexCount()); | ||
219 | for (i=0; i<other->getVertexCount(); ++i) | ||
220 | { | ||
221 | Vertices.push_back(reinterpret_cast<const T*>(other->getVertices())[i]); | ||
222 | } | ||
223 | |||
224 | Indices.reallocate(getIndexCount()+other->getIndexCount()); | ||
225 | for (i=0; i<other->getIndexCount(); ++i) | ||
226 | { | ||
227 | Indices.push_back(other->getIndices()[i]+vertexCount); | ||
228 | } | ||
229 | BoundingBox.addInternalBox(other->getBoundingBox()); | ||
230 | */ | ||
231 | } | ||
232 | |||
233 | |||
234 | //! get the current hardware mapping hint | ||
235 | virtual E_HARDWARE_MAPPING getHardwareMappingHint_Vertex() const | ||
236 | { | ||
237 | return MappingHint_Vertex; | ||
238 | } | ||
239 | |||
240 | //! get the current hardware mapping hint | ||
241 | virtual E_HARDWARE_MAPPING getHardwareMappingHint_Index() const | ||
242 | { | ||
243 | return MappingHint_Index; | ||
244 | } | ||
245 | |||
246 | //! set the hardware mapping hint, for driver | ||
247 | virtual void setHardwareMappingHint( E_HARDWARE_MAPPING NewMappingHint, E_BUFFER_TYPE Buffer=EBT_VERTEX_AND_INDEX ) | ||
248 | { | ||
249 | if (Buffer==EBT_VERTEX_AND_INDEX || Buffer==EBT_VERTEX) | ||
250 | MappingHint_Vertex=NewMappingHint; | ||
251 | if (Buffer==EBT_VERTEX_AND_INDEX || Buffer==EBT_INDEX) | ||
252 | MappingHint_Index=NewMappingHint; | ||
253 | } | ||
254 | |||
255 | |||
256 | //! flags the mesh as changed, reloads hardware buffers | ||
257 | virtual void setDirty(E_BUFFER_TYPE Buffer=EBT_VERTEX_AND_INDEX) | ||
258 | { | ||
259 | if (Buffer==EBT_VERTEX_AND_INDEX ||Buffer==EBT_VERTEX) | ||
260 | ++ChangedID_Vertex; | ||
261 | if (Buffer==EBT_VERTEX_AND_INDEX || Buffer==EBT_INDEX) | ||
262 | ++ChangedID_Index; | ||
263 | } | ||
264 | |||
265 | //! Get the currently used ID for identification of changes. | ||
266 | /** This shouldn't be used for anything outside the VideoDriver. */ | ||
267 | virtual u32 getChangedID_Vertex() const {return ChangedID_Vertex;} | ||
268 | |||
269 | //! Get the currently used ID for identification of changes. | ||
270 | /** This shouldn't be used for anything outside the VideoDriver. */ | ||
271 | virtual u32 getChangedID_Index() const {return ChangedID_Index;} | ||
272 | |||
273 | u32 ChangedID_Vertex; | ||
274 | u32 ChangedID_Index; | ||
275 | |||
276 | //! hardware mapping hint | ||
277 | E_HARDWARE_MAPPING MappingHint_Vertex; | ||
278 | E_HARDWARE_MAPPING MappingHint_Index; | ||
279 | |||
280 | //! Material for this meshbuffer. | ||
281 | video::SMaterial Material; | ||
282 | //! Vertices of this buffer | ||
283 | core::array<T> Vertices; | ||
284 | //! Indices into the vertices of this buffer. | ||
285 | core::array<u16> Indices; | ||
286 | //! Bounding box of this meshbuffer. | ||
287 | core::aabbox3d<f32> BoundingBox; | ||
288 | }; | ||
289 | |||
290 | //! Standard meshbuffer | ||
291 | typedef CMeshBuffer<video::S3DVertex> SMeshBuffer; | ||
292 | //! Meshbuffer with two texture coords per vertex, e.g. for lightmaps | ||
293 | typedef CMeshBuffer<video::S3DVertex2TCoords> SMeshBufferLightMap; | ||
294 | //! Meshbuffer with vertices having tangents stored, e.g. for normal mapping | ||
295 | typedef CMeshBuffer<video::S3DVertexTangents> SMeshBufferTangents; | ||
296 | } // end namespace scene | ||
297 | } // end namespace irr | ||
298 | |||
299 | #endif | ||
300 | |||
301 | |||