← Back to branch summary

~baltix/+junk/irrlicht-test

« back to all changes in this revision

Viewing changes to source/Irrlicht/CSceneLoaderIrr.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/CSceneLoaderIrr.cpp
 
1
#include "CSceneLoaderIrr.h"
 
2
#include "ISceneNodeAnimatorFactory.h"
 
3
#include "ISceneUserDataSerializer.h"
 
4
#include "ISceneManager.h"
 
5
#include "IVideoDriver.h"
 
6
#include "IFileSystem.h"
 
7
#include "os.h"
 
8
 
 
9
namespace irr
 
10
{
 
11
namespace scene
 
12
{
 
13
 
 
14
//! Constructor
 
15
CSceneLoaderIrr::CSceneLoaderIrr(ISceneManager *smgr, io::IFileSystem* fs)
 
16
 : SceneManager(smgr), FileSystem(fs),
 
17
   IRR_XML_FORMAT_SCENE(L"irr_scene"), IRR_XML_FORMAT_NODE(L"node"), IRR_XML_FORMAT_NODE_ATTR_TYPE(L"type"),
 
18
   IRR_XML_FORMAT_ATTRIBUTES(L"attributes"), IRR_XML_FORMAT_MATERIALS(L"materials"),
 
19
   IRR_XML_FORMAT_ANIMATORS(L"animators"), IRR_XML_FORMAT_USERDATA(L"userData")
 
20
{
 
21
 
 
22
}
 
23
 
 
24
//! Destructor
 
25
CSceneLoaderIrr::~CSceneLoaderIrr()
 
26
{
 
27
 
 
28
}
 
29
 
 
30
//! Returns true if the class might be able to load this file.
 
31
bool CSceneLoaderIrr::isALoadableFileExtension(const io::path& filename) const
 
32
{
 
33
        return core::hasFileExtension(filename, "irr");
 
34
}
 
35
 
 
36
//! Returns true if the class might be able to load this file.
 
37
bool CSceneLoaderIrr::isALoadableFileFormat(io::IReadFile *file) const
 
38
{
 
39
        // todo: check inside the file
 
40
        return true;
 
41
}
 
42
 
 
43
//! Loads the scene into the scene manager.
 
44
bool CSceneLoaderIrr::loadScene(io::IReadFile* file, ISceneUserDataSerializer* userDataSerializer,
 
45
        ISceneNode* rootNode)
 
46
{
 
47
        if (!file)
 
48
        {
 
49
                os::Printer::log("Unable to open scene file", ELL_ERROR);
 
50
                return false;
 
51
        }
 
52
 
 
53
        io::IXMLReader* reader = FileSystem->createXMLReader(file);
 
54
        if (!reader)
 
55
        {
 
56
                os::Printer::log("Scene is not a valid XML file", file->getFileName().c_str(), ELL_ERROR);
 
57
                return false;
 
58
        }
 
59
 
 
60
        // TODO: COLLADA_CREATE_SCENE_INSTANCES can be removed when the COLLADA loader is a scene loader
 
61
        bool oldColladaSingleMesh = SceneManager->getParameters()->getAttributeAsBool(COLLADA_CREATE_SCENE_INSTANCES);
 
62
        SceneManager->getParameters()->setAttribute(COLLADA_CREATE_SCENE_INSTANCES, false);
 
63
 
 
64
        // read file
 
65
        while (reader->read())
 
66
        {
 
67
                readSceneNode(reader, rootNode, userDataSerializer);
 
68
        }
 
69
 
 
70
        // restore old collada parameters
 
71
        SceneManager->getParameters()->setAttribute(COLLADA_CREATE_SCENE_INSTANCES, oldColladaSingleMesh);
 
72
 
 
73
        // clean up
 
74
        reader->drop();
 
75
        return true;
 
76
}
 
77
 
 
78
 
 
79
//! Reads the next node
 
80
void CSceneLoaderIrr::readSceneNode(io::IXMLReader* reader, ISceneNode* parent,
 
81
        ISceneUserDataSerializer* userDataSerializer)
 
82
{
 
83
        if (!reader)
 
84
                return;
 
85
 
 
86
        scene::ISceneNode* node = 0;
 
87
 
 
88
        if (!parent && IRR_XML_FORMAT_SCENE==reader->getNodeName())
 
89
                node = SceneManager->getRootSceneNode();
 
90
        else if (parent && IRR_XML_FORMAT_NODE==reader->getNodeName())
 
91
        {
 
92
                // find node type and create it
 
93
                core::stringc attrName = reader->getAttributeValue(IRR_XML_FORMAT_NODE_ATTR_TYPE.c_str());
 
94
 
 
95
                node = SceneManager->addSceneNode(attrName.c_str(), parent);
 
96
 
 
97
                if (!node)
 
98
                        os::Printer::log("Could not create scene node of unknown type", attrName.c_str());
 
99
        }
 
100
        else
 
101
                node=parent;
 
102
 
 
103
        // read attributes
 
104
        while(reader->read())
 
105
        {
 
106
                bool endreached = false;
 
107
 
 
108
                const wchar_t* name = reader->getNodeName();
 
109
 
 
110
                switch (reader->getNodeType())
 
111
                {
 
112
                case io::EXN_ELEMENT_END:
 
113
                        if ((IRR_XML_FORMAT_NODE  == name) ||
 
114
                                (IRR_XML_FORMAT_SCENE == name))
 
115
                        {
 
116
                                endreached = true;
 
117
                        }
 
118
                        break;
 
119
                case io::EXN_ELEMENT:
 
120
                        if (IRR_XML_FORMAT_ATTRIBUTES == name)
 
121
                        {
 
122
                                // read attributes
 
123
                                io::IAttributes* attr = FileSystem->createEmptyAttributes(SceneManager->getVideoDriver());
 
124
                                attr->read(reader, true);
 
125
 
 
126
                                if (node)
 
127
                                        node->deserializeAttributes(attr);
 
128
 
 
129
                                attr->drop();
 
130
                        }
 
131
                        else
 
132
                        if (IRR_XML_FORMAT_MATERIALS == name)
 
133
                                readMaterials(reader, node);
 
134
                        else
 
135
                        if (IRR_XML_FORMAT_ANIMATORS == name)
 
136
                                readAnimators(reader, node);
 
137
                        else
 
138
                        if (IRR_XML_FORMAT_USERDATA  == name)
 
139
                                readUserData(reader, node, userDataSerializer);
 
140
                        else
 
141
                        if ((IRR_XML_FORMAT_NODE  == name) ||
 
142
                                (IRR_XML_FORMAT_SCENE == name))
 
143
                        {
 
144
                                readSceneNode(reader, node, userDataSerializer);
 
145
                        }
 
146
                        else
 
147
                        {
 
148
                                os::Printer::log("Found unknown element in irrlicht scene file",
 
149
                                                core::stringc(name).c_str());
 
150
                        }
 
151
                        break;
 
152
                default:
 
153
                        break;
 
154
                }
 
155
 
 
156
                if (endreached)
 
157
                        break;
 
158
        }
 
159
        if (node && userDataSerializer)
 
160
                userDataSerializer->OnCreateNode(node);
 
161
}
 
162
 
 
163
//! reads materials of a node
 
164
void CSceneLoaderIrr::readMaterials(io::IXMLReader* reader, ISceneNode* node)
 
165
{
 
166
        u32 nr = 0;
 
167
 
 
168
        while(reader->read())
 
169
        {
 
170
                const wchar_t* name = reader->getNodeName();
 
171
 
 
172
                switch(reader->getNodeType())
 
173
                {
 
174
                case io::EXN_ELEMENT_END:
 
175
                        if (IRR_XML_FORMAT_MATERIALS == name)
 
176
                                return;
 
177
                        break;
 
178
                case io::EXN_ELEMENT:
 
179
                        if (IRR_XML_FORMAT_ATTRIBUTES == name)
 
180
                        {
 
181
                                // read materials from attribute list
 
182
                                io::IAttributes* attr = FileSystem->createEmptyAttributes(SceneManager->getVideoDriver());
 
183
                                attr->read(reader);
 
184
 
 
185
                                if (node && node->getMaterialCount() > nr)
 
186
                                {
 
187
                                        SceneManager->getVideoDriver()->fillMaterialStructureFromAttributes(
 
188
                                                node->getMaterial(nr), attr);
 
189
                                }
 
190
 
 
191
                                attr->drop();
 
192
                                ++nr;
 
193
                        }
 
194
                        break;
 
195
                default:
 
196
                        break;
 
197
                }
 
198
        }
 
199
}
 
200
 
 
201
 
 
202
//! reads animators of a node
 
203
void CSceneLoaderIrr::readAnimators(io::IXMLReader* reader, ISceneNode* node)
 
204
{
 
205
        while(reader->read())
 
206
        {
 
207
                const wchar_t* name = reader->getNodeName();
 
208
 
 
209
                switch(reader->getNodeType())
 
210
                {
 
211
                case io::EXN_ELEMENT_END:
 
212
                        if (IRR_XML_FORMAT_ANIMATORS == name)
 
213
                                return;
 
214
                        break;
 
215
                case io::EXN_ELEMENT:
 
216
                        if (IRR_XML_FORMAT_ATTRIBUTES == name)
 
217
                        {
 
218
                                // read animator data from attribute list
 
219
                                io::IAttributes* attr = FileSystem->createEmptyAttributes(SceneManager->getVideoDriver());
 
220
                                attr->read(reader);
 
221
 
 
222
                                if (node)
 
223
                                {
 
224
                                        core::stringc typeName = attr->getAttributeAsString("Type");
 
225
                                        ISceneNodeAnimator* anim = SceneManager->createSceneNodeAnimator(typeName.c_str(), node);
 
226
 
 
227
                                        if (anim)
 
228
                                        {
 
229
                                                anim->deserializeAttributes(attr);
 
230
                                                anim->drop();
 
231
                                        }
 
232
                                }
 
233
 
 
234
                                attr->drop();
 
235
                        }
 
236
                        break;
 
237
                default:
 
238
                        break;
 
239
                }
 
240
        }
 
241
}
 
242
 
 
243
 
 
244
//! reads user data of a node
 
245
void CSceneLoaderIrr::readUserData(io::IXMLReader* reader, ISceneNode* node, ISceneUserDataSerializer* userDataSerializer)
 
246
{
 
247
        while(reader->read())
 
248
        {
 
249
                const wchar_t* name = reader->getNodeName();
 
250
 
 
251
                switch(reader->getNodeType())
 
252
                {
 
253
                case io::EXN_ELEMENT_END:
 
254
                        if (IRR_XML_FORMAT_USERDATA == name)
 
255
                                return;
 
256
                        break;
 
257
                case io::EXN_ELEMENT:
 
258
                        if (IRR_XML_FORMAT_ATTRIBUTES == name)
 
259
                        {
 
260
                                // read user data from attribute list
 
261
                                io::IAttributes* attr = FileSystem->createEmptyAttributes(SceneManager->getVideoDriver());
 
262
                                attr->read(reader);
 
263
 
 
264
                                if (node && userDataSerializer)
 
265
                                {
 
266
                                        userDataSerializer->OnReadUserData(node, attr);
 
267
                                }
 
268
 
 
269
                                attr->drop();
 
270
                        }
 
271
                        break;
 
272
                default:
 
273
                        break;
 
274
                }
 
275
        }
 
276
}
 
277
 
 
278
} // scene
 
279
} // irr
 
280