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