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 __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 1028620 : class CMeshBuffer : public IMeshBuffer
18 : {
19 : public:
20 : //! Default constructor for empty meshbuffer
21 511927 : 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 511927 : }
27 :
28 :
29 : //! Get material of this meshbuffer
30 : /** \return Material of this buffer */
31 150 : virtual const video::SMaterial& getMaterial() const
32 : {
33 150 : return Material;
34 : }
35 :
36 :
37 : //! Get material of this meshbuffer
38 : /** \return Material of this buffer */
39 108940839 : virtual video::SMaterial& getMaterial()
40 : {
41 108940839 : return Material;
42 : }
43 :
44 :
45 : //! Get pointer to vertices
46 : /** \return Pointer to vertices. */
47 1456168 : virtual const void* getVertices() const
48 : {
49 1456168 : return Vertices.const_pointer();
50 : }
51 :
52 :
53 : //! Get pointer to vertices
54 : /** \return Pointer to vertices. */
55 1650163 : virtual void* getVertices()
56 : {
57 1650163 : return Vertices.pointer();
58 : }
59 :
60 :
61 : //! Get number of vertices
62 : /** \return Number of vertices. */
63 6455961 : virtual u32 getVertexCount() const
64 : {
65 6455961 : 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 1970865 : virtual video::E_INDEX_TYPE getIndexType() const
71 : {
72 1970865 : return video::EIT_16BIT;
73 : }
74 :
75 : //! Get pointer to indices
76 : /** \return Pointer to indices. */
77 1456168 : virtual const u16* getIndices() const
78 : {
79 1456168 : return Indices.const_pointer();
80 : }
81 :
82 :
83 : //! Get pointer to indices
84 : /** \return Pointer to indices. */
85 1089670 : virtual u16* getIndices()
86 : {
87 1089670 : return Indices.pointer();
88 : }
89 :
90 :
91 : //! Get number of indices
92 : /** \return Number of indices. */
93 3077844 : virtual u32 getIndexCount() const
94 : {
95 3077844 : return Indices.size();
96 : }
97 :
98 :
99 : //! Get the axis aligned bounding box
100 : /** \return Axis aligned bounding box of this buffer. */
101 537240 : virtual const core::aabbox3d<f32>& getBoundingBox() const
102 : {
103 537240 : 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 0 : virtual void setBoundingBox(const core::aabbox3df& box)
111 : {
112 0 : BoundingBox = box;
113 0 : }
114 :
115 :
116 : //! Recalculate the bounding box.
117 : /** should be called if the mesh changed. */
118 537240 : virtual void recalculateBoundingBox()
119 : {
120 537240 : if (Vertices.empty())
121 0 : BoundingBox.reset(0,0,0);
122 : else
123 : {
124 537240 : BoundingBox.reset(Vertices[0].Pos);
125 15145447 : for (u32 i=1; i<Vertices.size(); ++i)
126 14608207 : BoundingBox.addInternalPoint(Vertices[i].Pos);
127 : }
128 537240 : }
129 :
130 :
131 : //! Get type of vertex data stored in this buffer.
132 : /** \return Type of vertex data. */
133 1571172 : virtual video::E_VERTEX_TYPE getVertexType() const
134 : {
135 1571172 : return T().getType();
136 : }
137 :
138 : //! returns position of vertex i
139 0 : virtual const core::vector3df& getPosition(u32 i) const
140 : {
141 0 : return Vertices[i].Pos;
142 : }
143 :
144 : //! returns position of vertex i
145 16193319 : virtual core::vector3df& getPosition(u32 i)
146 : {
147 16193319 : return Vertices[i].Pos;
148 : }
149 :
150 : //! returns normal of vertex i
151 0 : virtual const core::vector3df& getNormal(u32 i) const
152 : {
153 0 : return Vertices[i].Normal;
154 : }
155 :
156 : //! returns normal of vertex i
157 31021807 : virtual core::vector3df& getNormal(u32 i)
158 : {
159 31021807 : return Vertices[i].Normal;
160 : }
161 :
162 : //! returns texture coord of vertex i
163 0 : virtual const core::vector2df& getTCoords(u32 i) const
164 : {
165 0 : return Vertices[i].TCoords;
166 : }
167 :
168 : //! returns texture coord of vertex i
169 0 : virtual core::vector2df& getTCoords(u32 i)
170 : {
171 0 : 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 529672 : virtual void append(const void* const vertices, u32 numVertices, const u16* const indices, u32 numIndices)
181 : {
182 529672 : if (vertices == getVertices())
183 0 : return;
184 :
185 529672 : const u32 vertexCount = getVertexCount();
186 : u32 i;
187 :
188 529672 : Vertices.reallocate(vertexCount+numVertices);
189 14964683 : for (i=0; i<numVertices; ++i)
190 : {
191 14435011 : Vertices.push_back(reinterpret_cast<const T*>(vertices)[i]);
192 14435011 : BoundingBox.addInternalPoint(reinterpret_cast<const T*>(vertices)[i].Pos);
193 : }
194 :
195 529672 : Indices.reallocate(getIndexCount()+numIndices);
196 28069126 : for (i=0; i<numIndices; ++i)
197 : {
198 27539454 : 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 0 : 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 0 : }
232 :
233 :
234 : //! get the current hardware mapping hint
235 1456018 : virtual E_HARDWARE_MAPPING getHardwareMappingHint_Vertex() const
236 : {
237 1456018 : return MappingHint_Vertex;
238 : }
239 :
240 : //! get the current hardware mapping hint
241 1456018 : virtual E_HARDWARE_MAPPING getHardwareMappingHint_Index() const
242 : {
243 1456018 : return MappingHint_Index;
244 : }
245 :
246 : //! set the hardware mapping hint, for driver
247 0 : virtual void setHardwareMappingHint( E_HARDWARE_MAPPING NewMappingHint, E_BUFFER_TYPE Buffer=EBT_VERTEX_AND_INDEX )
248 : {
249 0 : if (Buffer==EBT_VERTEX_AND_INDEX || Buffer==EBT_VERTEX)
250 0 : MappingHint_Vertex=NewMappingHint;
251 0 : if (Buffer==EBT_VERTEX_AND_INDEX || Buffer==EBT_INDEX)
252 0 : MappingHint_Index=NewMappingHint;
253 0 : }
254 :
255 :
256 : //! flags the mesh as changed, reloads hardware buffers
257 0 : virtual void setDirty(E_BUFFER_TYPE Buffer=EBT_VERTEX_AND_INDEX)
258 : {
259 0 : if (Buffer==EBT_VERTEX_AND_INDEX ||Buffer==EBT_VERTEX)
260 0 : ++ChangedID_Vertex;
261 0 : if (Buffer==EBT_VERTEX_AND_INDEX || Buffer==EBT_INDEX)
262 0 : ++ChangedID_Index;
263 0 : }
264 :
265 : //! Get the currently used ID for identification of changes.
266 : /** This shouldn't be used for anything outside the VideoDriver. */
267 0 : 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 0 : 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 :
|
