← Back to branch summary

~baltix/+junk/irrlicht-test

« back to all changes in this revision

Viewing changes to source/Irrlicht/CTriangleSelector.cpp

  • 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:
source/Irrlicht/CTriangleSelector.cpp
 
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
#include "CTriangleSelector.h"
 
6
#include "ISceneNode.h"
 
7
#include "IMeshBuffer.h"
 
8
#include "IAnimatedMeshSceneNode.h"
 
9
 
 
10
namespace irr
 
11
{
 
12
namespace scene
 
13
{
 
14
 
 
15
//! constructor
 
16
CTriangleSelector::CTriangleSelector(ISceneNode* node)
 
17
: SceneNode(node), AnimatedNode(0), LastMeshFrame(-1)
 
18
{
 
19
        #ifdef _DEBUG
 
20
        setDebugName("CTriangleSelector");
 
21
        #endif
 
22
}
 
23
 
 
24
 
 
25
//! constructor
 
26
CTriangleSelector::CTriangleSelector(const IMesh* mesh, ISceneNode* node)
 
27
: SceneNode(node), AnimatedNode(0)
 
28
{
 
29
        #ifdef _DEBUG
 
30
        setDebugName("CTriangleSelector");
 
31
        #endif
 
32
 
 
33
        createFromMesh(mesh);
 
34
}
 
35
 
 
36
CTriangleSelector::CTriangleSelector(IAnimatedMeshSceneNode* node)
 
37
: SceneNode(reinterpret_cast<ISceneNode*>(node)), AnimatedNode(node)
 
38
{
 
39
        #ifdef _DEBUG
 
40
        setDebugName("CTriangleSelector");
 
41
        #endif
 
42
 
 
43
        if (!AnimatedNode)
 
44
                return;
 
45
 
 
46
        IAnimatedMesh * animatedMesh = AnimatedNode->getMesh();
 
47
        if (!animatedMesh)
 
48
                return;
 
49
 
 
50
        IMesh * mesh = animatedMesh->getMesh((s32)AnimatedNode->getFrameNr());
 
51
 
 
52
        if (mesh)
 
53
                createFromMesh(mesh);
 
54
}
 
55
 
 
56
void CTriangleSelector::createFromMesh(const IMesh * mesh)
 
57
{
 
58
        const u32 cnt = mesh->getMeshBufferCount();
 
59
        u32 totalFaceCount = 0;
 
60
        for (u32 j=0; j<cnt; ++j)
 
61
                totalFaceCount += mesh->getMeshBuffer(j)->getIndexCount();
 
62
        totalFaceCount /= 3;
 
63
        Triangles.reallocate(totalFaceCount);
 
64
 
 
65
        for (u32 i=0; i<cnt; ++i)
 
66
        {
 
67
                const IMeshBuffer* buf = mesh->getMeshBuffer(i);
 
68
 
 
69
                const u32 idxCnt = buf->getIndexCount();
 
70
                const u16* const indices = buf->getIndices();
 
71
 
 
72
                for (u32 j=0; j<idxCnt; j+=3)
 
73
                {
 
74
                        Triangles.push_back(core::triangle3df(
 
75
                                        buf->getPosition(indices[j+0]),
 
76
                                        buf->getPosition(indices[j+1]),
 
77
                                        buf->getPosition(indices[j+2])));
 
78
                }
 
79
        }
 
80
}
 
81
 
 
82
void CTriangleSelector::updateFromMesh(const IMesh* mesh) const
 
83
{
 
84
        if (!mesh)
 
85
                return;
 
86
 
 
87
        u32 meshBuffers = mesh->getMeshBufferCount();
 
88
        u32 triangleCount = 0;
 
89
 
 
90
        for (u32 i = 0; i < meshBuffers; ++i)
 
91
        {
 
92
                IMeshBuffer* buf = mesh->getMeshBuffer(i);
 
93
                u32 idxCnt = buf->getIndexCount();
 
94
                const u16* indices = buf->getIndices();
 
95
 
 
96
                switch (buf->getVertexType())
 
97
                {
 
98
                case video::EVT_STANDARD:
 
99
                        {
 
100
                                video::S3DVertex* vtx = (video::S3DVertex*)buf->getVertices();
 
101
                                for (u32 index = 0; index < idxCnt; index += 3)
 
102
                                {
 
103
                                        core::triangle3df & tri = Triangles[triangleCount++];
 
104
                                        tri.pointA = vtx[indices[index + 0]].Pos;
 
105
                                        tri.pointB = vtx[indices[index + 1]].Pos;
 
106
                                        tri.pointC = vtx[indices[index + 2]].Pos;
 
107
                                }
 
108
                        }
 
109
                        break;
 
110
                case video::EVT_2TCOORDS:
 
111
                        {
 
112
                                video::S3DVertex2TCoords* vtx = (video::S3DVertex2TCoords*)buf->getVertices();
 
113
                                for (u32 index = 0; index < idxCnt; index += 3)
 
114
                                {
 
115
                                        core::triangle3df & tri = Triangles[triangleCount++];
 
116
                                        tri.pointA = vtx[indices[index + 0]].Pos;
 
117
                                        tri.pointB = vtx[indices[index + 1]].Pos;
 
118
                                        tri.pointC = vtx[indices[index + 2]].Pos;
 
119
                                }
 
120
                        }
 
121
                        break;
 
122
                case video::EVT_TANGENTS:
 
123
                        {
 
124
                                video::S3DVertexTangents* vtx = (video::S3DVertexTangents*)buf->getVertices();
 
125
                                for (u32 index = 0; index < idxCnt; index += 3)
 
126
                                {
 
127
                                        core::triangle3df & tri = Triangles[triangleCount++];
 
128
                                        tri.pointA = vtx[indices[index + 0]].Pos;
 
129
                                        tri.pointB = vtx[indices[index + 1]].Pos;
 
130
                                        tri.pointC = vtx[indices[index + 2]].Pos;
 
131
                                }
 
132
                        }
 
133
                        break;
 
134
                }
 
135
        }
 
136
}
 
137
 
 
138
 
 
139
//! constructor
 
140
CTriangleSelector::CTriangleSelector(const core::aabbox3d<f32>& box, ISceneNode* node)
 
141
: SceneNode(node)
 
142
{
 
143
        #ifdef _DEBUG
 
144
        setDebugName("CTriangleSelector");
 
145
        #endif
 
146
 
 
147
        // TODO
 
148
}
 
149
 
 
150
 
 
151
 
 
152
void CTriangleSelector::update(void) const
 
153
{
 
154
        if (!AnimatedNode)
 
155
                return; //< harmless no-op
 
156
 
 
157
        s32 currentFrame = (s32)AnimatedNode->getFrameNr();
 
158
        if (currentFrame == LastMeshFrame)
 
159
                return; //< Nothing to do
 
160
 
 
161
        LastMeshFrame = currentFrame;
 
162
        IAnimatedMesh * animatedMesh = AnimatedNode->getMesh();
 
163
 
 
164
        if (animatedMesh)
 
165
        {
 
166
                IMesh * mesh = animatedMesh->getMesh(LastMeshFrame);
 
167
 
 
168
                if (mesh)
 
169
                        updateFromMesh(mesh);
 
170
        }
 
171
}
 
172
 
 
173
//! Gets all triangles.
 
174
void CTriangleSelector::getTriangles(core::triangle3df* triangles,
 
175
                                        s32 arraySize, s32& outTriangleCount,
 
176
                                        const core::matrix4* transform) const
 
177
{
 
178
        // Update my triangles if necessary
 
179
        update();
 
180
 
 
181
        s32 cnt = Triangles.size();
 
182
        if (cnt > arraySize)
 
183
                cnt = arraySize;
 
184
 
 
185
        core::matrix4 mat;
 
186
 
 
187
        if (transform)
 
188
                mat = *transform;
 
189
 
 
190
        if (SceneNode)
 
191
                mat *= SceneNode->getAbsoluteTransformation();
 
192
 
 
193
        for (s32 i=0; i<cnt; ++i)
 
194
        {
 
195
                mat.transformVect( triangles[i].pointA, Triangles[i].pointA );
 
196
                mat.transformVect( triangles[i].pointB, Triangles[i].pointB );
 
197
                mat.transformVect( triangles[i].pointC, Triangles[i].pointC );
 
198
        }
 
199
 
 
200
        outTriangleCount = cnt;
 
201
}
 
202
 
 
203
 
 
204
 
 
205
//! Gets all triangles which lie within a specific bounding box.
 
206
void CTriangleSelector::getTriangles(core::triangle3df* triangles,
 
207
                                        s32 arraySize, s32& outTriangleCount,
 
208
                                        const core::aabbox3d<f32>& box,
 
209
                                        const core::matrix4* transform) const
 
210
{
 
211
        // return all triangles
 
212
        return getTriangles(triangles, arraySize, outTriangleCount, transform);
 
213
}
 
214
 
 
215
 
 
216
//! Gets all triangles which have or may have contact with a 3d line.
 
217
void CTriangleSelector::getTriangles(core::triangle3df* triangles,
 
218
                                        s32 arraySize, s32& outTriangleCount,
 
219
                                        const core::line3d<f32>& line,
 
220
                                        const core::matrix4* transform) const
 
221
{
 
222
        // return all triangles
 
223
        return getTriangles(triangles, arraySize, outTriangleCount, transform);
 
224
}
 
225
 
 
226
 
 
227
//! Returns amount of all available triangles in this selector
 
228
s32 CTriangleSelector::getTriangleCount() const
 
229
{
 
230
        return Triangles.size();
 
231
}
 
232
 
 
233
 
 
234
/* Get the number of TriangleSelectors that are part of this one.
 
235
Only useful for MetaTriangleSelector others return 1
 
236
*/
 
237
u32 CTriangleSelector::getSelectorCount() const
 
238
{
 
239
        return 1;
 
240
}
 
241
 
 
242
 
 
243
/* Get the TriangleSelector based on index based on getSelectorCount.
 
244
Only useful for MetaTriangleSelector others return 'this' or 0
 
245
*/
 
246
ITriangleSelector* CTriangleSelector::getSelector(u32 index)
 
247
{
 
248
        if (index)
 
249
                return 0;
 
250
        else
 
251
                return this;
 
252
}
 
253
 
 
254
 
 
255
/* Get the TriangleSelector based on index based on getSelectorCount.
 
256
Only useful for MetaTriangleSelector others return 'this' or 0
 
257
*/
 
258
const ITriangleSelector* CTriangleSelector::getSelector(u32 index) const
 
259
{
 
260
        if (index)
 
261
                return 0;
 
262
        else
 
263
                return this;
 
264
}
 
265
 
 
266
 
 
267
} // end namespace scene
 
268
} // end namespace irr
 
269