← Back to branch summary

~baltix/+junk/irrlicht-test

« back to all changes in this revision

Viewing changes to include/CMeshBuffer.h

  • Committer: Mantas Kriaučiūnas
  • Date: 2011-07-18 13:06:25 UTC
  • Revision ID: mantas@akl.lt-20110718130625-c5pvifp61e7kj1ol
Included whole irrlicht SVN libraries to work around launchpad recipe issue with quilt, see https://answers.launchpad.net/launchpad/+question/165193

Show diffs side-by-side

added added

removed removed

Lines of Context:
include/CMeshBuffer.h
 
1
// Copyright (C) 2002-2011 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