[612] | 1 | /* |
---|
| 2 | * ORXONOX - the hottest 3D action shooter ever to exist |
---|
| 3 | * |
---|
| 4 | * |
---|
| 5 | * License notice: |
---|
| 6 | * |
---|
| 7 | * This program is free software; you can redistribute it and/or |
---|
| 8 | * modify it under the terms of the GNU General Public License |
---|
| 9 | * as published by the Free Software Foundation; either version 2 |
---|
| 10 | * of the License, or (at your option) any later version. |
---|
| 11 | * |
---|
| 12 | * This program is distributed in the hope that it will be useful, |
---|
| 13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
---|
| 14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
---|
| 15 | * GNU General Public License for more details. |
---|
| 16 | * |
---|
| 17 | * You should have received a copy of the GNU General Public License |
---|
| 18 | * along with this program; if not, write to the Free Software |
---|
| 19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. |
---|
| 20 | * |
---|
| 21 | * Author: |
---|
| 22 | * Benjamin Knecht <beni_at_orxonox.net>, (C) 2007 |
---|
| 23 | * Co-authors: |
---|
| 24 | * ... |
---|
| 25 | * |
---|
| 26 | */ |
---|
| 27 | |
---|
| 28 | /** |
---|
| 29 | @file Orxonox.cc |
---|
| 30 | @brief Orxonox Main Class |
---|
| 31 | */ |
---|
| 32 | |
---|
[784] | 33 | // Precompiled Headers |
---|
[786] | 34 | #include "OrxonoxStableHeaders.h" |
---|
[784] | 35 | |
---|
[612] | 36 | //****** OGRE ****** |
---|
| 37 | #include <OgreException.h> |
---|
| 38 | #include <OgreRoot.h> |
---|
| 39 | #include <OgreFrameListener.h> |
---|
| 40 | #include <OgreRenderWindow.h> |
---|
| 41 | #include <OgreTextureManager.h> |
---|
| 42 | #include <OgreResourceGroupManager.h> |
---|
| 43 | #include <OgreConfigFile.h> |
---|
| 44 | #include <OgreOverlay.h> |
---|
| 45 | #include <OgreOverlayManager.h> |
---|
| 46 | |
---|
| 47 | //****** OIS ******* |
---|
| 48 | #include <OIS/OIS.h> |
---|
| 49 | |
---|
| 50 | //****** STD ******* |
---|
| 51 | #include <iostream> |
---|
[673] | 52 | #include <exception> |
---|
[612] | 53 | |
---|
| 54 | //***** ORXONOX **** |
---|
[871] | 55 | //misc |
---|
[742] | 56 | #include "util/Sleep.h" |
---|
[708] | 57 | |
---|
[612] | 58 | // loader and audio |
---|
[871] | 59 | //#include "loader/LevelLoader.h" |
---|
[873] | 60 | //#include "audio/AudioManager.h" |
---|
[612] | 61 | |
---|
| 62 | // network |
---|
[873] | 63 | //#include "network/Server.h" |
---|
| 64 | //#include "network/Client.h" |
---|
| 65 | //#include "network/NetworkFrameListener.h" |
---|
[612] | 66 | |
---|
| 67 | // objects |
---|
| 68 | #include "objects/Tickable.h" |
---|
[748] | 69 | #include "tools/Timer.h" |
---|
[873] | 70 | //#include "objects/NPC.h" |
---|
[612] | 71 | #include "core/ArgReader.h" |
---|
| 72 | #include "core/Factory.h" |
---|
| 73 | #include "core/Debug.h" |
---|
[871] | 74 | #include "core/Loader.h" |
---|
[873] | 75 | //#include "hud/HUD.h" |
---|
| 76 | //#include "objects/weapon/BulletManager.h" |
---|
[729] | 77 | #include "GraphicsEngine.h" |
---|
[874] | 78 | |
---|
| 79 | #include "core/ClassTreeMask.h" |
---|
| 80 | #include "objects/WorldEntity.h" |
---|
| 81 | #include "core/DebugLevel.h" |
---|
| 82 | #include "core/BaseObject.h" |
---|
| 83 | #include "objects/Test.h" |
---|
| 84 | #include "objects/test1.h" |
---|
| 85 | #include "objects/test2.h" |
---|
| 86 | #include "objects/test3.h" |
---|
[612] | 87 | |
---|
[667] | 88 | #include "Orxonox.h" |
---|
[612] | 89 | |
---|
| 90 | namespace orxonox |
---|
| 91 | { |
---|
| 92 | // put this in a seperate Class or solve the problem in another fashion |
---|
[708] | 93 | class OrxListener : public Ogre::FrameListener |
---|
[612] | 94 | { |
---|
| 95 | public: |
---|
[873] | 96 | OrxListener(OIS::Keyboard *keyboard/*, audio::AudioManager* auMan*/, gameMode mode) |
---|
[616] | 97 | { |
---|
[612] | 98 | mKeyboard = keyboard; |
---|
| 99 | mode_=mode; |
---|
[873] | 100 | // auMan_ = auMan; |
---|
[616] | 101 | } |
---|
[612] | 102 | |
---|
[708] | 103 | bool frameStarted(const Ogre::FrameEvent& evt) |
---|
[612] | 104 | { |
---|
[873] | 105 | // auMan_->update(); |
---|
| 106 | // updateAI(); |
---|
[612] | 107 | |
---|
[873] | 108 | // if(mode_ == PRESENTATION) |
---|
| 109 | // server_g->tick(evt.timeSinceLastFrame); |
---|
| 110 | // else if(mode_ == CLIENT) |
---|
| 111 | // client_g->tick(evt.timeSinceLastFrame); |
---|
[612] | 112 | |
---|
[616] | 113 | usleep(10); |
---|
[612] | 114 | |
---|
[616] | 115 | mKeyboard->capture(); |
---|
[612] | 116 | return !mKeyboard->isKeyDown(OIS::KC_ESCAPE); |
---|
| 117 | } |
---|
[873] | 118 | /* |
---|
[627] | 119 | void updateAI() |
---|
| 120 | { |
---|
| 121 | for(Iterator<NPC> it = ObjectList<NPC>::start(); it; ++it) |
---|
| 122 | { |
---|
| 123 | it->update(); |
---|
| 124 | } |
---|
| 125 | } |
---|
[873] | 126 | */ |
---|
[612] | 127 | private: |
---|
| 128 | gameMode mode_; |
---|
| 129 | OIS::Keyboard *mKeyboard; |
---|
[873] | 130 | // audio::AudioManager* auMan_; |
---|
[616] | 131 | }; |
---|
[612] | 132 | |
---|
| 133 | // init static singleton reference of Orxonox |
---|
| 134 | Orxonox* Orxonox::singletonRef_ = NULL; |
---|
| 135 | |
---|
| 136 | /** |
---|
| 137 | * create a new instance of Orxonox |
---|
| 138 | */ |
---|
| 139 | Orxonox::Orxonox() |
---|
| 140 | { |
---|
| 141 | this->ogre_ = new GraphicsEngine(); |
---|
| 142 | this->dataPath_ = ""; |
---|
[871] | 143 | // this->loader_ = 0; |
---|
[873] | 144 | // this->auMan_ = 0; |
---|
[616] | 145 | this->singletonRef_ = 0; |
---|
| 146 | this->keyboard_ = 0; |
---|
| 147 | this->mouse_ = 0; |
---|
| 148 | this->inputManager_ = 0; |
---|
| 149 | this->frameListener_ = 0; |
---|
| 150 | this->root_ = 0; |
---|
[612] | 151 | } |
---|
| 152 | |
---|
| 153 | /** |
---|
| 154 | * destruct Orxonox |
---|
| 155 | */ |
---|
| 156 | Orxonox::~Orxonox() |
---|
| 157 | { |
---|
| 158 | // nothing to delete as for now |
---|
| 159 | } |
---|
| 160 | |
---|
| 161 | /** |
---|
| 162 | * initialization of Orxonox object |
---|
| 163 | * @param argc argument counter |
---|
| 164 | * @param argv list of arguments |
---|
| 165 | * @param path path to config (in home dir or something) |
---|
| 166 | */ |
---|
[715] | 167 | void Orxonox::init(int argc, char **argv, std::string path) |
---|
[612] | 168 | { |
---|
| 169 | //TODO: find config file (assuming executable directory) |
---|
| 170 | //TODO: read config file |
---|
| 171 | //TODO: give config file to Ogre |
---|
[715] | 172 | std::string mode; |
---|
[612] | 173 | // if(argc>=2) |
---|
[715] | 174 | // mode = std::string(argv[1]); |
---|
[612] | 175 | // else |
---|
| 176 | // mode = ""; |
---|
| 177 | ArgReader ar = ArgReader(argc, argv); |
---|
| 178 | ar.checkArgument("mode", mode, false); |
---|
| 179 | ar.checkArgument("data", this->dataPath_, false); |
---|
| 180 | ar.checkArgument("ip", serverIp_, false); |
---|
[637] | 181 | //mode = "presentation"; |
---|
[612] | 182 | if(ar.errorHandling()) die(); |
---|
[715] | 183 | if(mode == std::string("server")) |
---|
[612] | 184 | { |
---|
| 185 | serverInit(path); |
---|
| 186 | mode_ = SERVER; |
---|
| 187 | } |
---|
[715] | 188 | else if(mode == std::string("client")) |
---|
[612] | 189 | { |
---|
| 190 | clientInit(path); |
---|
| 191 | mode_ = CLIENT; |
---|
| 192 | } |
---|
[715] | 193 | else if(mode == std::string("presentation")) |
---|
[612] | 194 | { |
---|
| 195 | serverInit(path); |
---|
| 196 | mode_ = PRESENTATION; |
---|
| 197 | } |
---|
| 198 | else{ |
---|
| 199 | standaloneInit(path); |
---|
| 200 | mode_ = STANDALONE; |
---|
| 201 | } |
---|
| 202 | } |
---|
| 203 | |
---|
| 204 | /** |
---|
| 205 | * start modules |
---|
| 206 | */ |
---|
| 207 | void Orxonox::start() |
---|
| 208 | { |
---|
| 209 | //TODO: start modules |
---|
| 210 | ogre_->startRender(); |
---|
| 211 | //TODO: run engine |
---|
[667] | 212 | Factory::createClassHierarchy(); |
---|
[612] | 213 | createScene(); |
---|
| 214 | setupScene(); |
---|
| 215 | setupInputSystem(); |
---|
| 216 | if(mode_!=CLIENT){ // remove this in future ---- presentation hack |
---|
| 217 | } |
---|
| 218 | else |
---|
| 219 | std::cout << "client here" << std::endl; |
---|
| 220 | createFrameListener(); |
---|
| 221 | switch(mode_){ |
---|
| 222 | case PRESENTATION: |
---|
| 223 | //ogre_->getRoot()->addFrameListener(new network::ServerFrameListener()); |
---|
| 224 | //std::cout << "could not add framelistener" << std::endl; |
---|
[873] | 225 | // server_g->open(); |
---|
[612] | 226 | break; |
---|
| 227 | case CLIENT: |
---|
[873] | 228 | // client_g->establishConnection(); |
---|
[612] | 229 | break; |
---|
| 230 | case SERVER: |
---|
| 231 | case STANDALONE: |
---|
| 232 | default: |
---|
| 233 | break; |
---|
| 234 | } |
---|
[874] | 235 | |
---|
| 236 | #define testandcout(code) \ |
---|
| 237 | std::cout << #code << " " << code << "\n" |
---|
| 238 | /* |
---|
| 239 | std::cout << "Test 1\n"; |
---|
| 240 | BaseObject* test1; |
---|
| 241 | test1 = new BaseObject(); |
---|
| 242 | test1 = new BaseObject(); |
---|
| 243 | test1 = new BaseObject(); |
---|
| 244 | |
---|
| 245 | std::cout << "Test 2\n"; |
---|
| 246 | A1* test2; |
---|
| 247 | test2 = new A1(); |
---|
| 248 | test2 = new A1(); |
---|
| 249 | test2 = new A1(); |
---|
| 250 | |
---|
| 251 | std::cout << "Test 3\n"; |
---|
| 252 | BaseObject* test3; |
---|
| 253 | test3 = new BaseObject(); |
---|
| 254 | test3 = new BaseObject(); |
---|
| 255 | test3 = new BaseObject(); |
---|
| 256 | |
---|
| 257 | std::cout << "Test 4\n"; |
---|
| 258 | A3* test4; |
---|
| 259 | test4 = new A3(); |
---|
| 260 | test4 = new A3(); |
---|
| 261 | test4 = new A3(); |
---|
| 262 | |
---|
| 263 | |
---|
| 264 | std::cout << "Test 5\n"; |
---|
| 265 | A1* test5_01 = new A1(); |
---|
| 266 | A2* test5_02 = new A2(); |
---|
| 267 | A3* test5_03 = new A3(); |
---|
| 268 | A1B1* test5_04 = new A1B1(); |
---|
| 269 | A1B2* test5_05 = new A1B2(); |
---|
| 270 | A2B1* test5_06 = new A2B1(); |
---|
| 271 | A2B2* test5_07 = new A2B2(); |
---|
| 272 | A3B1* test5_08 = new A3B1(); |
---|
| 273 | A3B2* test5_09 = new A3B2(); |
---|
| 274 | A1B1C1* test5_10 = new A1B1C1(); |
---|
| 275 | A1B1C2* test5_11 = new A1B1C2(); |
---|
| 276 | A1B2C1* test5_12 = new A1B2C1(); |
---|
| 277 | A2B1C1* test5_13 = new A2B1C1(); |
---|
| 278 | A2B2C1* test5_14 = new A2B2C1(); |
---|
| 279 | A3B1C1* test5_15 = new A3B1C1(); |
---|
| 280 | A3B1C2* test5_16 = new A3B1C2(); |
---|
| 281 | A3B2C1* test5_17 = new A3B2C1(); |
---|
| 282 | A3B2C2* test5_18 = new A3B2C2(); |
---|
| 283 | */ |
---|
| 284 | /* |
---|
| 285 | OrxonoxClass* test5 = 0; |
---|
| 286 | for (int i = 0; i <= 18; i++) |
---|
| 287 | { |
---|
| 288 | if (i == 0) test5 = new BaseObject; |
---|
| 289 | if (i == 1) test5 = test5_01; |
---|
| 290 | if (i == 2) test5 = test5_02; |
---|
| 291 | if (i == 3) test5 = test5_03; |
---|
| 292 | if (i == 4) test5 = test5_04; |
---|
| 293 | if (i == 5) test5 = test5_05; |
---|
| 294 | if (i == 6) test5 = test5_06; |
---|
| 295 | if (i == 7) test5 = test5_07; |
---|
| 296 | if (i == 8) test5 = test5_08; |
---|
| 297 | if (i == 9) test5 = test5_09; |
---|
| 298 | if (i == 10) test5 = test5_10; |
---|
| 299 | if (i == 11) test5 = test5_11; |
---|
| 300 | if (i == 12) test5 = test5_12; |
---|
| 301 | if (i == 13) test5 = test5_13; |
---|
| 302 | if (i == 14) test5 = test5_14; |
---|
| 303 | if (i == 15) test5 = test5_15; |
---|
| 304 | if (i == 16) test5 = test5_16; |
---|
| 305 | if (i == 17) test5 = test5_17; |
---|
| 306 | if (i == 18) test5 = test5_18; |
---|
| 307 | |
---|
| 308 | std::cout << "\n"; |
---|
| 309 | std::cout << test5->getIdentifier()->getName() << " (" << test5->getIdentifier()->getNetworkID() << "): parents: " << test5->getIdentifier()->getParents() << "\n"; |
---|
| 310 | std::cout << test5->getIdentifier()->getName() << " (" << test5->getIdentifier()->getNetworkID() << "): children: " << test5->getIdentifier()->getChildren() << "\n"; |
---|
| 311 | std::cout << test5->getIdentifier()->getName() << " (" << test5->getIdentifier()->getNetworkID() << "): direct parents: " << test5->getIdentifier()->getDirectParents() << "\n"; |
---|
| 312 | std::cout << test5->getIdentifier()->getName() << " (" << test5->getIdentifier()->getNetworkID() << "): direct children: " << test5->getIdentifier()->getDirectChildren() << "\n"; |
---|
| 313 | } |
---|
| 314 | */ |
---|
| 315 | /* |
---|
| 316 | for (std::map<std::string, Identifier*>::const_iterator it = Factory::getFactoryBegin(); it != Factory::getFactoryEnd(); ++it) |
---|
| 317 | std::cout << "Class with ID " << (*it).second->getNetworkID() << ": " << ID((*it).second->getNetworkID()) << " / " << ID((*it).second->getNetworkID())->getName() << std::endl; |
---|
| 318 | |
---|
| 319 | std::cout << "Class with ID 100: " << ID(100) << "\n"; |
---|
| 320 | std::cout << "ID of BaseObject: " << Class(BaseObject)->getNetworkID() << "\n"; |
---|
| 321 | |
---|
| 322 | std::cout << "\nChange ID of BaseObject to 100\n"; |
---|
| 323 | Class(BaseObject)->setNetworkID(100); |
---|
| 324 | std::cout << "Class with ID 100: " << ID(100) << "\n"; |
---|
| 325 | std::cout << "Class with ID 1: " << ID(1) << "\n"; |
---|
| 326 | std::cout << "ID of BaseObject: " << Class(BaseObject)->getNetworkID() << "\n"; |
---|
| 327 | |
---|
| 328 | std::cout << "\nChange ID of BaseObject to 3\n"; |
---|
| 329 | Class(BaseObject)->setNetworkID(3); |
---|
| 330 | std::cout << "Class with ID 100: " << ID(100) << "\n"; |
---|
| 331 | std::cout << "Class with ID 1: " << ID(1) << "\n"; |
---|
| 332 | std::cout << "Class with ID 3: " << ID(3) << "\n"; |
---|
| 333 | std::cout << "ID of BaseObject: " << Class(BaseObject)->getNetworkID() << "\n"; |
---|
| 334 | std::cout << "ID of Test1: " << Class(Test1)->getNetworkID() << "\n"; |
---|
| 335 | */ |
---|
| 336 | /* |
---|
| 337 | std::cout << "\n"; |
---|
| 338 | std::cout << "isA(XYZ)-Test:\n"; |
---|
| 339 | std::cout << "test5_01 = A1, Erwartet: 1 0 0 1 0\n"; |
---|
| 340 | testandcout(test5_01->isA(Class(A1))); |
---|
| 341 | testandcout(test5_01->isA(Class(A2))); |
---|
| 342 | testandcout(test5_01->isA(Class(A1B1))); |
---|
| 343 | testandcout(test5_01->isA(Class(BaseObject))); |
---|
| 344 | testandcout(test5_01->isA(Class(Interface1))); |
---|
| 345 | |
---|
| 346 | std::cout << "\n"; |
---|
| 347 | std::cout << "test5_02 = A2, Erwartet: 0 1 0 1 0\n"; |
---|
| 348 | testandcout(test5_02->isA(Class(A1))); |
---|
| 349 | testandcout(test5_02->isA(Class(A2))); |
---|
| 350 | testandcout(test5_02->isA(Class(A1B1))); |
---|
| 351 | testandcout(test5_02->isA(Class(BaseObject))); |
---|
| 352 | testandcout(test5_02->isA(Class(Interface1))); |
---|
| 353 | |
---|
| 354 | std::cout << "\n"; |
---|
| 355 | std::cout << "test5_01 = A3, Erwartet: 0 0 0 1 1\n"; |
---|
| 356 | testandcout(test5_03->isA(Class(A1))); |
---|
| 357 | testandcout(test5_03->isA(Class(A2))); |
---|
| 358 | testandcout(test5_03->isA(Class(A1B1))); |
---|
| 359 | testandcout(test5_03->isA(Class(BaseObject))); |
---|
| 360 | testandcout(test5_03->isA(Class(Interface1))); |
---|
| 361 | |
---|
| 362 | std::cout << "\n"; |
---|
| 363 | std::cout << "isDirectA(XYZ)-Test:\n"; |
---|
| 364 | std::cout << "test5_01 = A1, Erwartet: 1 0 0 0 0\n"; |
---|
| 365 | testandcout(test5_01->isExactlyA(Class(A1))); |
---|
| 366 | testandcout(test5_01->isExactlyA(Class(A2))); |
---|
| 367 | testandcout(test5_01->isExactlyA(Class(A1B1))); |
---|
| 368 | testandcout(test5_01->isExactlyA(Class(BaseObject))); |
---|
| 369 | testandcout(test5_01->isExactlyA(Class(Interface1))); |
---|
| 370 | |
---|
| 371 | std::cout << "\n"; |
---|
| 372 | std::cout << "test5_02 = A2, Erwartet: 0 1 0 0 0\n"; |
---|
| 373 | testandcout(test5_02->isExactlyA(Class(A1))); |
---|
| 374 | testandcout(test5_02->isExactlyA(Class(A2))); |
---|
| 375 | testandcout(test5_02->isExactlyA(Class(A1B1))); |
---|
| 376 | testandcout(test5_02->isExactlyA(Class(BaseObject))); |
---|
| 377 | testandcout(test5_02->isExactlyA(Class(Interface1))); |
---|
| 378 | |
---|
| 379 | std::cout << "\n"; |
---|
| 380 | std::cout << "test5_03 = A3, Erwartet: 0 0 0 0 0\n"; |
---|
| 381 | testandcout(test5_03->isExactlyA(Class(A1))); |
---|
| 382 | testandcout(test5_03->isExactlyA(Class(A2))); |
---|
| 383 | testandcout(test5_03->isExactlyA(Class(A1B1))); |
---|
| 384 | testandcout(test5_03->isExactlyA(Class(BaseObject))); |
---|
| 385 | testandcout(test5_03->isExactlyA(Class(Interface1))); |
---|
| 386 | |
---|
| 387 | std::cout << "\n"; |
---|
| 388 | std::cout << "isChildOf(XYZ)-Test:\n"; |
---|
| 389 | std::cout << "test5_04 = A1B1, Erwartet: 1 0 1 0 0 0 0\n"; |
---|
| 390 | testandcout(test5_04->isChildOf(Class(A1))); |
---|
| 391 | testandcout(test5_04->isChildOf(Class(A2))); |
---|
| 392 | testandcout(test5_04->isChildOf(Class(BaseObject))); |
---|
| 393 | testandcout(test5_04->isChildOf(Class(Interface1))); |
---|
| 394 | testandcout(test5_04->isChildOf(Class(Interface2))); |
---|
| 395 | testandcout(test5_04->isChildOf(Class(A1B1C2))); |
---|
| 396 | testandcout(test5_04->isChildOf(Class(A1B1))); |
---|
| 397 | |
---|
| 398 | std::cout << "\n"; |
---|
| 399 | std::cout << "test5_06 = A2B1, Erwartet: 0 1 1 0 0 0 0\n"; |
---|
| 400 | testandcout(test5_06->isChildOf(Class(A1))); |
---|
| 401 | testandcout(test5_06->isChildOf(Class(A2))); |
---|
| 402 | testandcout(test5_06->isChildOf(Class(BaseObject))); |
---|
| 403 | testandcout(test5_06->isChildOf(Class(Interface1))); |
---|
| 404 | testandcout(test5_06->isChildOf(Class(Interface2))); |
---|
| 405 | testandcout(test5_06->isChildOf(Class(A1B1C2))); |
---|
| 406 | testandcout(test5_06->isChildOf(Class(A1B1))); |
---|
| 407 | |
---|
| 408 | std::cout << "\n"; |
---|
| 409 | std::cout << "test5_07 = A2B2, Erwartet: 0 1 1 1 0 0\n"; |
---|
| 410 | testandcout(test5_07->isChildOf(Class(A1))); |
---|
| 411 | testandcout(test5_07->isChildOf(Class(A2))); |
---|
| 412 | testandcout(test5_07->isChildOf(Class(BaseObject))); |
---|
| 413 | testandcout(test5_07->isChildOf(Class(Interface1))); |
---|
| 414 | testandcout(test5_07->isChildOf(Class(Interface2))); |
---|
| 415 | testandcout(test5_07->isChildOf(Class(A1B1C2))); |
---|
| 416 | |
---|
| 417 | std::cout << "\n"; |
---|
| 418 | std::cout << "test5_08 = A3B1, Erwartet: 0 0 1 1 0 0\n"; |
---|
| 419 | testandcout(test5_08->isChildOf(Class(A1))); |
---|
| 420 | testandcout(test5_08->isChildOf(Class(A2))); |
---|
| 421 | testandcout(test5_08->isChildOf(Class(BaseObject))); |
---|
| 422 | testandcout(test5_08->isChildOf(Class(Interface1))); |
---|
| 423 | testandcout(test5_08->isChildOf(Class(Interface2))); |
---|
| 424 | testandcout(test5_08->isChildOf(Class(A1B1C2))); |
---|
| 425 | |
---|
| 426 | std::cout << "\n"; |
---|
| 427 | std::cout << "test5_09 = A3B2, Erwartet: 0 0 1 1 1 0\n"; |
---|
| 428 | testandcout(test5_09->isChildOf(Class(A1))); |
---|
| 429 | testandcout(test5_09->isChildOf(Class(A2))); |
---|
| 430 | testandcout(test5_09->isChildOf(Class(BaseObject))); |
---|
| 431 | testandcout(test5_09->isChildOf(Class(Interface1))); |
---|
| 432 | testandcout(test5_09->isChildOf(Class(Interface2))); |
---|
| 433 | testandcout(test5_09->isChildOf(Class(A1B1C2))); |
---|
| 434 | |
---|
| 435 | std::cout << "\n"; |
---|
| 436 | std::cout << "isDirectChildOf(XYZ)-Test:\n"; |
---|
| 437 | std::cout << "test5_04 = A1B1, Erwartet: 1 0 0 0 0 0 0\n"; |
---|
| 438 | testandcout(test5_04->isDirectChildOf(Class(A1))); |
---|
| 439 | testandcout(test5_04->isDirectChildOf(Class(A2))); |
---|
| 440 | testandcout(test5_04->isDirectChildOf(Class(BaseObject))); |
---|
| 441 | testandcout(test5_04->isDirectChildOf(Class(Interface1))); |
---|
| 442 | testandcout(test5_04->isDirectChildOf(Class(Interface2))); |
---|
| 443 | testandcout(test5_04->isDirectChildOf(Class(A1B1C2))); |
---|
| 444 | testandcout(test5_04->isDirectChildOf(Class(A1B1))); |
---|
| 445 | |
---|
| 446 | std::cout << "\n"; |
---|
| 447 | std::cout << "test5_06 = A2B1, Erwartet: 0 1 0 0 0 0 0\n"; |
---|
| 448 | testandcout(test5_06->isDirectChildOf(Class(A1))); |
---|
| 449 | testandcout(test5_06->isDirectChildOf(Class(A2))); |
---|
| 450 | testandcout(test5_06->isDirectChildOf(Class(BaseObject))); |
---|
| 451 | testandcout(test5_06->isDirectChildOf(Class(Interface1))); |
---|
| 452 | testandcout(test5_06->isDirectChildOf(Class(Interface2))); |
---|
| 453 | testandcout(test5_06->isDirectChildOf(Class(A1B1C2))); |
---|
| 454 | testandcout(test5_06->isDirectChildOf(Class(A1B1))); |
---|
| 455 | |
---|
| 456 | std::cout << "\n"; |
---|
| 457 | std::cout << "test5_07 = A2B2, Erwartet: 0 1 0 1 0 0\n"; |
---|
| 458 | testandcout(test5_07->isDirectChildOf(Class(A1))); |
---|
| 459 | testandcout(test5_07->isDirectChildOf(Class(A2))); |
---|
| 460 | testandcout(test5_07->isDirectChildOf(Class(BaseObject))); |
---|
| 461 | testandcout(test5_07->isDirectChildOf(Class(Interface1))); |
---|
| 462 | testandcout(test5_07->isDirectChildOf(Class(Interface2))); |
---|
| 463 | testandcout(test5_07->isDirectChildOf(Class(A1B1C2))); |
---|
| 464 | |
---|
| 465 | std::cout << "\n"; |
---|
| 466 | std::cout << "test5_08 = A3B1, Erwartet: 0 0 0 0 0 0\n"; |
---|
| 467 | testandcout(test5_08->isDirectChildOf(Class(A1))); |
---|
| 468 | testandcout(test5_08->isDirectChildOf(Class(A2))); |
---|
| 469 | testandcout(test5_08->isDirectChildOf(Class(BaseObject))); |
---|
| 470 | testandcout(test5_08->isDirectChildOf(Class(Interface1))); |
---|
| 471 | testandcout(test5_08->isDirectChildOf(Class(Interface2))); |
---|
| 472 | testandcout(test5_08->isDirectChildOf(Class(A1B1C2))); |
---|
| 473 | |
---|
| 474 | std::cout << "\n"; |
---|
| 475 | std::cout << "test5_09 = A3B2, Erwartet: 0 0 0 0 1 0\n"; |
---|
| 476 | testandcout(test5_09->isDirectChildOf(Class(A1))); |
---|
| 477 | testandcout(test5_09->isDirectChildOf(Class(A2))); |
---|
| 478 | testandcout(test5_09->isDirectChildOf(Class(BaseObject))); |
---|
| 479 | testandcout(test5_09->isDirectChildOf(Class(Interface1))); |
---|
| 480 | testandcout(test5_09->isDirectChildOf(Class(Interface2))); |
---|
| 481 | testandcout(test5_09->isDirectChildOf(Class(A1B1C2))); |
---|
| 482 | |
---|
| 483 | std::cout << "\n"; |
---|
| 484 | |
---|
| 485 | std::cout << "isParentOf(XYZ)-Test:\n"; |
---|
| 486 | std::cout << "test1 = BaseObject, Erwartet: 0 0 1 1 1 1 1\n"; |
---|
| 487 | testandcout(test1->isParentOf(Class(BaseObject))); |
---|
| 488 | testandcout(test1->isParentOf(Class(Interface1))); |
---|
| 489 | testandcout(test1->isParentOf(Class(A1))); |
---|
| 490 | testandcout(test1->isParentOf(Class(A2))); |
---|
| 491 | testandcout(test1->isParentOf(Class(A1B1))); |
---|
| 492 | testandcout(test1->isParentOf(Class(A2B2))); |
---|
| 493 | testandcout(test1->isParentOf(Class(A3B1C2))); |
---|
| 494 | |
---|
| 495 | std::cout << "\n"; |
---|
| 496 | std::cout << "test5_01 = A1, Erwartet: 0 0 0 0 1 0 0\n"; |
---|
| 497 | testandcout(test5_01->isParentOf(Class(BaseObject))); |
---|
| 498 | testandcout(test5_01->isParentOf(Class(Interface1))); |
---|
| 499 | testandcout(test5_01->isParentOf(Class(A1))); |
---|
| 500 | testandcout(test5_01->isParentOf(Class(A2))); |
---|
| 501 | testandcout(test5_01->isParentOf(Class(A1B1))); |
---|
| 502 | testandcout(test5_01->isParentOf(Class(A2B2))); |
---|
| 503 | testandcout(test5_01->isParentOf(Class(A3B1C2))); |
---|
| 504 | |
---|
| 505 | std::cout << "\n"; |
---|
| 506 | std::cout << "Interface1, Erwartet: 0 0 0 0 0 1 1\n"; |
---|
| 507 | testandcout(Class(Interface1)->isParentOf(Class(BaseObject))); |
---|
| 508 | testandcout(Class(Interface1)->isParentOf(Class(Interface1))); |
---|
| 509 | testandcout(Class(Interface1)->isParentOf(Class(A1))); |
---|
| 510 | testandcout(Class(Interface1)->isParentOf(Class(A2))); |
---|
| 511 | testandcout(Class(Interface1)->isParentOf(Class(A1B1))); |
---|
| 512 | testandcout(Class(Interface1)->isParentOf(Class(A2B2))); |
---|
| 513 | testandcout(Class(Interface1)->isParentOf(Class(A3B1C2))); |
---|
| 514 | |
---|
| 515 | std::cout << "\n"; |
---|
| 516 | std::cout << "isDirectParentOf(XYZ)-Test:\n"; |
---|
| 517 | std::cout << "test1 = BaseObject, Erwartet: 0 0 1 1 0 0 0\n"; |
---|
| 518 | testandcout(test1->isDirectParentOf(Class(BaseObject))); |
---|
| 519 | testandcout(test1->isDirectParentOf(Class(Interface1))); |
---|
| 520 | testandcout(test1->isDirectParentOf(Class(A1))); |
---|
| 521 | testandcout(test1->isDirectParentOf(Class(A2))); |
---|
| 522 | testandcout(test1->isDirectParentOf(Class(A1B1))); |
---|
| 523 | testandcout(test1->isDirectParentOf(Class(A2B2))); |
---|
| 524 | testandcout(test1->isDirectParentOf(Class(A3B1C2))); |
---|
| 525 | |
---|
| 526 | std::cout << "\n"; |
---|
| 527 | std::cout << "test5_01 = A1, Erwartet: 0 0 0 0 1 0 0\n"; |
---|
| 528 | testandcout(test5_01->isDirectParentOf(Class(BaseObject))); |
---|
| 529 | testandcout(test5_01->isDirectParentOf(Class(Interface1))); |
---|
| 530 | testandcout(test5_01->isDirectParentOf(Class(A1))); |
---|
| 531 | testandcout(test5_01->isDirectParentOf(Class(A2))); |
---|
| 532 | testandcout(test5_01->isDirectParentOf(Class(A1B1))); |
---|
| 533 | testandcout(test5_01->isDirectParentOf(Class(A2B2))); |
---|
| 534 | testandcout(test5_01->isDirectParentOf(Class(A3B1C2))); |
---|
| 535 | |
---|
| 536 | std::cout << "\n"; |
---|
| 537 | std::cout << "Interface1, Erwartet: 0 0 0 0 0 1 0\n"; |
---|
| 538 | testandcout(Class(Interface1)->isDirectParentOf(Class(BaseObject))); |
---|
| 539 | testandcout(Class(Interface1)->isDirectParentOf(Class(Interface1))); |
---|
| 540 | testandcout(Class(Interface1)->isDirectParentOf(Class(A1))); |
---|
| 541 | testandcout(Class(Interface1)->isDirectParentOf(Class(A2))); |
---|
| 542 | testandcout(Class(Interface1)->isDirectParentOf(Class(A1B1))); |
---|
| 543 | testandcout(Class(Interface1)->isDirectParentOf(Class(A2B2))); |
---|
| 544 | testandcout(Class(Interface1)->isDirectParentOf(Class(A3B1C2))); |
---|
| 545 | */ |
---|
| 546 | /* |
---|
| 547 | std::cout << "Test 6\n"; |
---|
| 548 | std::cout << "1\n"; |
---|
| 549 | Identifier* test6_01 = Class(A1B1); |
---|
| 550 | std::cout << "2\n"; |
---|
| 551 | Identifier* test6_02 = Class(A1B1); |
---|
| 552 | std::cout << "3\n"; |
---|
| 553 | Identifier* test6_03 = Class(A1); |
---|
| 554 | std::cout << "4\n"; |
---|
| 555 | Identifier* test6_04 = Class(A1B1C1); |
---|
| 556 | std::cout << "5\n"; |
---|
| 557 | Identifier* test6_05 = Class(A1B1); |
---|
| 558 | std::cout << "6\n"; |
---|
| 559 | Identifier* test6_06 = Class(A1B1C1); |
---|
| 560 | |
---|
| 561 | std::cout << "7\n"; |
---|
| 562 | |
---|
| 563 | std::cout << "\n"; |
---|
| 564 | std::cout << "BaseObject: parents: " << Class(BaseObject)->getParents() << "\n"; |
---|
| 565 | std::cout << "BaseObject: children: " << Class(BaseObject)->getChildren() << "\n"; |
---|
| 566 | std::cout << "BaseObject: direct parents: " << Class(BaseObject)->getDirectParents() << "\n"; |
---|
| 567 | std::cout << "BaseObject: direct children: " << Class(BaseObject)->getDirectChildren() << "\n"; |
---|
| 568 | |
---|
| 569 | std::cout << "\n"; |
---|
| 570 | std::cout << "A1: parents: " << Class(A1)->getParents() << "\n"; |
---|
| 571 | std::cout << "A1: children: " << Class(A1)->getChildren() << "\n"; |
---|
| 572 | std::cout << "A1: direct parents: " << Class(A1)->getDirectParents() << "\n"; |
---|
| 573 | std::cout << "A1: direct children: " << Class(A1)->getDirectChildren() << "\n"; |
---|
| 574 | |
---|
| 575 | std::cout << "\n"; |
---|
| 576 | std::cout << "A1B1: parents: " << Class(A1B1)->getParents() << "\n"; |
---|
| 577 | std::cout << "A1B1: children: " << Class(A1B1)->getChildren() << "\n"; |
---|
| 578 | std::cout << "A1B1: direct parents: " << Class(A1B1)->getDirectParents() << "\n"; |
---|
| 579 | std::cout << "A1B1: direct children: " << Class(A1B1)->getDirectChildren() << "\n"; |
---|
| 580 | |
---|
| 581 | std::cout << "\n"; |
---|
| 582 | std::cout << "A1B1C1: parents: " << Class(A1B1C1)->getParents() << "\n"; |
---|
| 583 | std::cout << "A1B1C1: children: " << Class(A1B1C1)->getChildren() << "\n"; |
---|
| 584 | std::cout << "A1B1C1: direct parents: " << Class(A1B1C1)->getDirectParents() << "\n"; |
---|
| 585 | std::cout << "A1B1C1: direct children: " << Class(A1B1C1)->getDirectChildren() << "\n"; |
---|
| 586 | |
---|
| 587 | std::cout << "\n"; |
---|
| 588 | std::cout << "A3B1C1 child of A3: " << Class(A3B1C1)->isChildOf(Class(A3)) << "\n"; |
---|
| 589 | std::cout << "\n"; |
---|
| 590 | std::cout << "A2 parent of A2B1C1: " << Class(A2)->isParentOf(Class(A2B1C1)) << "\n"; |
---|
| 591 | |
---|
| 592 | std::cout << "8\n"; |
---|
| 593 | */ |
---|
| 594 | /* |
---|
| 595 | std::cout << "Test 7\n"; |
---|
| 596 | std::cout << "1\n"; |
---|
| 597 | SubclassIdentifier<A1B1> test7_01; |
---|
| 598 | test7_01 = Class(A1B1C1); |
---|
| 599 | |
---|
| 600 | SubclassIdentifier<A1B1> test7_02; |
---|
| 601 | test7_02 = Class(A1B1); |
---|
| 602 | |
---|
| 603 | std::cout << test7_01->getName() << "\n"; |
---|
| 604 | std::cout << test7_02->getName() << "\n"; |
---|
| 605 | */ |
---|
| 606 | /* |
---|
| 607 | // ## WARNING - CRASH! ## |
---|
| 608 | std::cout << "2\n"; |
---|
| 609 | |
---|
| 610 | SubclassIdentifier<A1B1> test7_03; |
---|
| 611 | test7_03 = Class(A1); |
---|
| 612 | |
---|
| 613 | SubclassIdentifier<A1B1> test7_04; |
---|
| 614 | test7_04 = Class(A1B2); |
---|
| 615 | |
---|
| 616 | SubclassIdentifier<A1B1> test7_05; |
---|
| 617 | test7_05 = Class(A2); |
---|
| 618 | // ## END WARNING - CRASH! ## |
---|
| 619 | */ |
---|
| 620 | /* |
---|
| 621 | std::cout << "Test 8\n"; |
---|
| 622 | |
---|
| 623 | std::cout << "1\n"; |
---|
| 624 | Test1* test8_01 = new Test1; |
---|
| 625 | Test3* test8_03 = new Test3; |
---|
| 626 | test8_03->usefullClassesIsATest(test8_01); |
---|
| 627 | |
---|
| 628 | std::cout << "2\n"; |
---|
| 629 | Test2* test8_02 = new Test2; |
---|
| 630 | test8_03->usefullClassesIsATest(test8_02); |
---|
| 631 | |
---|
| 632 | std::cout << "3\n"; |
---|
| 633 | test8_01->setUsefullClass1(Class(Test1)); |
---|
| 634 | test8_01->setUsefullClass1(test8_02->getIdentifier()); |
---|
| 635 | test8_01->setUsefullClass2(Class(Test2)); |
---|
| 636 | test8_01->setUsefullClassOfTypeTest3(Class(Test3)); |
---|
| 637 | test8_01->setUsefullClassOfTypeTest3(test8_03->getIdentifier()); |
---|
| 638 | |
---|
| 639 | |
---|
| 640 | testandcout(test8_01->isA(Class(Test1))); |
---|
| 641 | testandcout(test8_01->isA(Class(Test2))); |
---|
| 642 | testandcout(test8_01->isA(Class(Test3))); |
---|
| 643 | |
---|
| 644 | Test2* test8_04 = new Test2; |
---|
| 645 | testandcout(test8_02->isA(Class(Test1))); |
---|
| 646 | testandcout(test8_02->isA(Class(Test2))); |
---|
| 647 | testandcout(test8_02->isA(Class(Test3))); |
---|
| 648 | |
---|
| 649 | Test3* test8_05 = new Test3; |
---|
| 650 | testandcout(test8_03->isA(Class(Test1))); |
---|
| 651 | testandcout(test8_03->isA(Class(Test2))); |
---|
| 652 | testandcout(test8_03->isA(Class(Test3))); |
---|
| 653 | |
---|
| 654 | delete test8_01; |
---|
| 655 | delete test8_02; |
---|
| 656 | delete test8_03; |
---|
| 657 | */ |
---|
| 658 | /* |
---|
| 659 | std::cout << "Test 9\n"; |
---|
| 660 | std::cout << "1\n"; |
---|
| 661 | Identifier* test9_01 = Class(A3); |
---|
| 662 | BaseObject* test9_02 = test9_01->fabricate(); |
---|
| 663 | std::cout << test9_02->getIdentifier()->getName() << "\n"; |
---|
| 664 | |
---|
| 665 | std::cout << "\n2\n"; |
---|
| 666 | BaseObject* test9_03 = Class(A1B2)->fabricate(); |
---|
| 667 | std::cout << test9_03->getIdentifier()->getName() << "\n"; |
---|
| 668 | |
---|
| 669 | std::cout << "\n3\n"; |
---|
| 670 | SubclassIdentifier<A1> test9_04; |
---|
| 671 | test9_04 = Class(A1B1C1); |
---|
| 672 | A1* test9_05 = test9_04.fabricate(); |
---|
| 673 | std::cout << test9_05->getIdentifier()->getName() << "\n"; |
---|
| 674 | |
---|
| 675 | std::cout << "\n4\n"; |
---|
| 676 | BaseObject* test9_06 = ID("A2B2")->fabricate(); |
---|
| 677 | std::cout << test9_06->getIdentifier()->getName() << "\n"; |
---|
| 678 | |
---|
| 679 | std::cout << "\n5\n"; |
---|
| 680 | delete test9_02; |
---|
| 681 | delete test9_03; |
---|
| 682 | delete test9_05; |
---|
| 683 | delete test9_06; |
---|
| 684 | */ |
---|
| 685 | /* |
---|
| 686 | std::cout << "Test 10\n"; |
---|
| 687 | Identifier* test10_01 = Class(A1B2); |
---|
| 688 | Identifier* test10_02 = Class(A2); |
---|
| 689 | Identifier* test10_03 = Class(A3B1C1); |
---|
| 690 | |
---|
| 691 | BaseObject* test10_04 = test10_01->fabricate(); |
---|
| 692 | BaseObject* test10_05 = test10_02->fabricate(); |
---|
| 693 | BaseObject* test10_06 = test10_03->fabricate(); |
---|
| 694 | |
---|
| 695 | BaseObject* test10_07; |
---|
| 696 | for (int i = 0; i < 10; i++) |
---|
| 697 | test10_07 = ID("A1B1C1")->fabricate(); |
---|
| 698 | |
---|
| 699 | std::cout << "1\n"; |
---|
| 700 | int count; |
---|
| 701 | |
---|
| 702 | count = 0; for (Iterator<BaseObject> it = ObjectList<BaseObject>::start(); it; ++it) { count++; } |
---|
| 703 | std::cout << "Anzahl BaseObjects: " << count << "\n"; |
---|
| 704 | count = 0; for (Iterator<A1> it = ObjectList<A1>::start(); it; ++it) { count++; } |
---|
| 705 | std::cout << "Anzahl A1: " << count << "\n"; |
---|
| 706 | count = 0; for (Iterator<A1B1> it = ObjectList<A1B1>::start(); it; ++it) { count++; } |
---|
| 707 | std::cout << "Anzahl A1B1: " << count << "\n"; |
---|
| 708 | count = 0; for (Iterator<A1B1C1> it = ObjectList<A1B1C1>::start(); it; ++it) { count++; } |
---|
| 709 | std::cout << "Anzahl A1B1C1: " << count << "\n"; |
---|
| 710 | count = 0; for (Iterator<A2> it = ObjectList<A2>::start(); it; ++it) { count++; } |
---|
| 711 | std::cout << "Anzahl A2: " << count << "\n"; |
---|
| 712 | |
---|
| 713 | std::cout << "2\n"; |
---|
| 714 | BaseObject* test10_08; |
---|
| 715 | BaseObject* test10_09 = 0; |
---|
| 716 | BaseObject* test10_10 = 0; |
---|
| 717 | for (int i = 0; i < 10; i++) |
---|
| 718 | { |
---|
| 719 | test10_08 = ID("A2B1C1")->fabricate(); |
---|
| 720 | std::string objName = "A2B1C1#"; |
---|
| 721 | objName += '0' + i; |
---|
| 722 | test10_08->setName(objName); |
---|
| 723 | |
---|
| 724 | if (i == 0) |
---|
| 725 | test10_09 = test10_08; |
---|
| 726 | |
---|
| 727 | if (i == 5) |
---|
| 728 | test10_10 = test10_08; |
---|
| 729 | } |
---|
| 730 | |
---|
| 731 | count = 0; for (Iterator<BaseObject> it = ObjectList<BaseObject>::start(); it; ++it) { count++; } |
---|
| 732 | std::cout << "Anzahl BaseObjects: " << count << "\n"; |
---|
| 733 | count = 0; for (Iterator<A1> it = ObjectList<A1>::start(); it; ++it) { count++; } |
---|
| 734 | std::cout << "Anzahl A1: " << count << "\n"; |
---|
| 735 | count = 0; for (Iterator<A1B1> it = ObjectList<A1B1>::start(); it; ++it) { count++; } |
---|
| 736 | std::cout << "Anzahl A1B1: " << count << "\n"; |
---|
| 737 | count = 0; for (Iterator<A1B1C1> it = ObjectList<A1B1C1>::start(); it; ++it) { count++; } |
---|
| 738 | std::cout << "Anzahl A1B1C1: " << count << "\n"; |
---|
| 739 | count = 0; for (Iterator<A2> it = ObjectList<A2>::start(); it; ++it) { count++; } |
---|
| 740 | std::cout << "Anzahl A2: " << count << "\n"; |
---|
| 741 | |
---|
| 742 | for (Iterator<A2B1C1> it = ObjectList<A2B1C1>::start(); it; ++it) |
---|
| 743 | std::cout << "Name: " << it->getName() << "\n"; |
---|
| 744 | |
---|
| 745 | std::cout << "3\n"; |
---|
| 746 | for (Iterator<A2B1C1> it = ObjectList<A2B1C1>::end(); it; --it) |
---|
| 747 | std::cout << "Name: " << it->getName() << "\n"; |
---|
| 748 | |
---|
| 749 | std::cout << "4\n"; |
---|
| 750 | delete test10_08; |
---|
| 751 | |
---|
| 752 | count = 0; for (Iterator<BaseObject> it = ObjectList<BaseObject>::start(); it; ++it) { count++; } |
---|
| 753 | std::cout << "Anzahl BaseObjects: " << count << "\n"; |
---|
| 754 | count = 0; for (Iterator<A1> it = ObjectList<A1>::start(); it; ++it) { count++; } |
---|
| 755 | std::cout << "Anzahl A1: " << count << "\n"; |
---|
| 756 | count = 0; for (Iterator<A1B1> it = ObjectList<A1B1>::start(); it; ++it) { count++; } |
---|
| 757 | std::cout << "Anzahl A1B1: " << count << "\n"; |
---|
| 758 | count = 0; for (Iterator<A1B1C1> it = ObjectList<A1B1C1>::start(); it; ++it) { count++; } |
---|
| 759 | std::cout << "Anzahl A1B1C1: " << count << "\n"; |
---|
| 760 | count = 0; for (Iterator<A2> it = ObjectList<A2>::start(); it; ++it) { count++; } |
---|
| 761 | std::cout << "Anzahl A2: " << count << "\n"; |
---|
| 762 | |
---|
| 763 | std::cout << "5\n"; |
---|
| 764 | for (Iterator<A2B1C1> it = ObjectList<A2B1C1>::start(); it; ++it) |
---|
| 765 | std::cout << "Name: " << it->getName() << "\n"; |
---|
| 766 | |
---|
| 767 | std::cout << "6\n"; |
---|
| 768 | for (Iterator<A2B1C1> it = ObjectList<A2B1C1>::end(); it; --it) |
---|
| 769 | std::cout << "Name: " << it->getName() << "\n"; |
---|
| 770 | |
---|
| 771 | std::cout << "7\n"; |
---|
| 772 | delete test10_09; |
---|
| 773 | |
---|
| 774 | count = 0; for (Iterator<BaseObject> it = ObjectList<BaseObject>::end(); it; --it) { count++; } |
---|
| 775 | std::cout << "Anzahl BaseObjects: " << count << "\n"; |
---|
| 776 | count = 0; for (Iterator<A1> it = ObjectList<A1>::end(); it; --it) { count++; } |
---|
| 777 | std::cout << "Anzahl A1: " << count << "\n"; |
---|
| 778 | count = 0; for (Iterator<A1B1> it = ObjectList<A1B1>::end(); it; --it) { count++; } |
---|
| 779 | std::cout << "Anzahl A1B1: " << count << "\n"; |
---|
| 780 | count = 0; for (Iterator<A1B1C1> it = ObjectList<A1B1C1>::end(); it; --it) { count++; } |
---|
| 781 | std::cout << "Anzahl A1B1C1: " << count << "\n"; |
---|
| 782 | count = 0; for (Iterator<A2> it = ObjectList<A2>::end(); it; --it) { count++; } |
---|
| 783 | std::cout << "Anzahl A2: " << count << "\n"; |
---|
| 784 | |
---|
| 785 | std::cout << "8\n"; |
---|
| 786 | for (Iterator<A2B1C1> it = ObjectList<A2B1C1>::start(); it; ++it) |
---|
| 787 | std::cout << "Name: " << it->getName() << "\n"; |
---|
| 788 | |
---|
| 789 | std::cout << "9\n"; |
---|
| 790 | for (Iterator<A2B1C1> it = ObjectList<A2B1C1>::end(); it; --it) |
---|
| 791 | std::cout << "Name: " << it->getName() << "\n"; |
---|
| 792 | |
---|
| 793 | std::cout << "10\n"; |
---|
| 794 | delete test10_10; |
---|
| 795 | |
---|
| 796 | count = 0; for (Iterator<BaseObject> it = ObjectList<BaseObject>::start(); it; ++it) { count++; } |
---|
| 797 | std::cout << "Anzahl BaseObjects: " << count << "\n"; |
---|
| 798 | count = 0; for (Iterator<A1> it = ObjectList<A1>::start(); it; ++it) { count++; } |
---|
| 799 | std::cout << "Anzahl A1: " << count << "\n"; |
---|
| 800 | count = 0; for (Iterator<A1B1> it = ObjectList<A1B1>::start(); it; ++it) { count++; } |
---|
| 801 | std::cout << "Anzahl A1B1: " << count << "\n"; |
---|
| 802 | count = 0; for (Iterator<A1B1C1> it = ObjectList<A1B1C1>::start(); it; ++it) { count++; } |
---|
| 803 | std::cout << "Anzahl A1B1C1: " << count << "\n"; |
---|
| 804 | count = 0; for (Iterator<A2> it = ObjectList<A2>::start(); it; ++it) { count++; } |
---|
| 805 | std::cout << "Anzahl A2: " << count << "\n"; |
---|
| 806 | |
---|
| 807 | std::cout << "11\n"; |
---|
| 808 | for (Iterator<A2B1C1> it = ObjectList<A2B1C1>::start(); it; ++it) |
---|
| 809 | std::cout << "Name: " << it->getName() << "\n"; |
---|
| 810 | |
---|
| 811 | std::cout << "12\n"; |
---|
| 812 | for (Iterator<A2B1C1> it = ObjectList<A2B1C1>::end(); it; --it) |
---|
| 813 | std::cout << "Name: " << it->getName() << "\n"; |
---|
| 814 | |
---|
| 815 | std::cout << "13\n"; |
---|
| 816 | */ |
---|
| 817 | /* |
---|
| 818 | std::cout << "Test 11\n"; |
---|
| 819 | std::cout << "1\n"; |
---|
| 820 | int count2 = 0; for (Iterator<Tickable> it = ObjectList<Tickable>::start(); it; ++it) { count2++; } |
---|
| 821 | std::cout << "AnzahlTickable: " << count2 << "\n"; |
---|
| 822 | |
---|
| 823 | Test1* test11_1; |
---|
| 824 | for (int i = 0; i < 3; i++) |
---|
| 825 | test11_1 = new Test1; |
---|
| 826 | |
---|
| 827 | count2 = 0; for (Iterator<Tickable> it = ObjectList<Tickable>::start(); it; ++it) { count2++; } |
---|
| 828 | std::cout << "AnzahlTickable: " << count2 << "\n"; |
---|
| 829 | |
---|
| 830 | for (Iterator<Tickable> it = ObjectList<Tickable>::start(); it; ++it) |
---|
| 831 | it->tick(0); |
---|
| 832 | |
---|
| 833 | std::cout << "2\n"; |
---|
| 834 | Test2* test11_2 = new Test2; |
---|
| 835 | |
---|
| 836 | |
---|
| 837 | std::cout << "3\n"; |
---|
| 838 | Test3* test11_3 = new Test3; |
---|
| 839 | test11_3->configOutput(); |
---|
| 840 | |
---|
| 841 | std::cout << "4\n"; |
---|
| 842 | */ |
---|
| 843 | /* |
---|
| 844 | std::cout << "Test 12\n"; |
---|
| 845 | std::cout << "1\n"; |
---|
| 846 | |
---|
| 847 | WorldEntity* test12_1 = new WorldEntity; |
---|
| 848 | |
---|
| 849 | std::cout << sizeof(WorldEntity) << std::endl; |
---|
| 850 | |
---|
| 851 | std::cout << "2\n"; |
---|
| 852 | */ |
---|
| 853 | /* |
---|
| 854 | std::cout << "Test 13\n"; |
---|
| 855 | |
---|
| 856 | #define BoolToYesNo(bool) \ |
---|
| 857 | if (bool) \ |
---|
| 858 | std::cout << "yes "; \ |
---|
| 859 | else \ |
---|
| 860 | std::cout << "no " |
---|
| 861 | |
---|
| 862 | #define TestClassTreeMask(mask) \ |
---|
| 863 | std::cout << "========== ClassTreeMask-Test ===========" << std::endl; \ |
---|
| 864 | std::cout << mask << std::endl << std::endl; \ |
---|
| 865 | std::cout << " "; \ |
---|
| 866 | BoolToYesNo(mask.isIncluded(Class(BaseObject))); \ |
---|
| 867 | std::cout << std::endl; \ |
---|
| 868 | \ |
---|
| 869 | std::cout << " "; \ |
---|
| 870 | BoolToYesNo(mask.isIncluded(Class(A1))); \ |
---|
| 871 | std::cout << " "; \ |
---|
| 872 | BoolToYesNo(mask.isIncluded(Class(A2))); \ |
---|
| 873 | std::cout << " "; \ |
---|
| 874 | BoolToYesNo(mask.isIncluded(Class(A3))); \ |
---|
| 875 | std::cout << std::endl; \ |
---|
| 876 | \ |
---|
| 877 | std::cout << " "; \ |
---|
| 878 | BoolToYesNo(mask.isIncluded(Class(A1B1))); \ |
---|
| 879 | std::cout << " "; \ |
---|
| 880 | BoolToYesNo(mask.isIncluded(Class(A1B2))); \ |
---|
| 881 | std::cout << " "; \ |
---|
| 882 | BoolToYesNo(mask.isIncluded(Class(A2B1))); \ |
---|
| 883 | std::cout << " "; \ |
---|
| 884 | BoolToYesNo(mask.isIncluded(Class(A2B2))); \ |
---|
| 885 | std::cout << " "; \ |
---|
| 886 | BoolToYesNo(mask.isIncluded(Class(A3B1))); \ |
---|
| 887 | std::cout << " "; \ |
---|
| 888 | BoolToYesNo(mask.isIncluded(Class(A3B2))); \ |
---|
| 889 | std::cout << std::endl; \ |
---|
| 890 | \ |
---|
| 891 | BoolToYesNo(mask.isIncluded(Class(A1B1C1))); \ |
---|
| 892 | BoolToYesNo(mask.isIncluded(Class(A1B1C2))); \ |
---|
| 893 | BoolToYesNo(mask.isIncluded(Class(A1B2C1))); \ |
---|
| 894 | std::cout << " "; \ |
---|
| 895 | BoolToYesNo(mask.isIncluded(Class(A2B1C1))); \ |
---|
| 896 | std::cout << " "; \ |
---|
| 897 | BoolToYesNo(mask.isIncluded(Class(A2B2C1))); \ |
---|
| 898 | std::cout << " "; \ |
---|
| 899 | BoolToYesNo(mask.isIncluded(Class(A3B1C1))); \ |
---|
| 900 | BoolToYesNo(mask.isIncluded(Class(A3B1C2))); \ |
---|
| 901 | BoolToYesNo(mask.isIncluded(Class(A3B2C1))); \ |
---|
| 902 | BoolToYesNo(mask.isIncluded(Class(A3B2C2))); \ |
---|
| 903 | std::cout << std::endl; \ |
---|
| 904 | std::cout << "=========================================" << std::endl |
---|
| 905 | |
---|
| 906 | std::cout << "1\n"; |
---|
| 907 | |
---|
| 908 | ClassTreeMask test13_1; |
---|
| 909 | test13_1.exclude(Class(A1B1)); |
---|
| 910 | test13_1.exclude(Class(A2)); |
---|
| 911 | test13_1.include(Class(A2B2)); |
---|
| 912 | test13_1.exclude(Class(A2B2C1)); |
---|
| 913 | test13_1.exclude(Class(A3B1)); |
---|
| 914 | test13_1.include(Class(A3B1C2)); |
---|
| 915 | test13_1.exclude(Class(A3B2C1)); |
---|
| 916 | test13_1.exclude(Class(A3B2C2)); |
---|
| 917 | std::cout << "Mask 1:\n"; |
---|
| 918 | TestClassTreeMask(test13_1); |
---|
| 919 | |
---|
| 920 | ClassTreeMask test13_2; |
---|
| 921 | test13_2.exclude(Class(BaseObject)); |
---|
| 922 | test13_2.include(Class(A1)); |
---|
| 923 | test13_2.exclude(Class(A1B2)); |
---|
| 924 | test13_2.exclude(Class(A1B1C2)); |
---|
| 925 | test13_2.include(Class(A2)); |
---|
| 926 | test13_2.exclude(Class(A2B2)); |
---|
| 927 | test13_2.include(Class(A3B1)); |
---|
| 928 | test13_2.include(Class(A3B2)); |
---|
| 929 | test13_2.exclude(Class(A3B2C2)); |
---|
| 930 | std::cout << std::endl; |
---|
| 931 | std::cout << "Mask 2:\n"; |
---|
| 932 | TestClassTreeMask(test13_2); |
---|
| 933 | |
---|
| 934 | std::cout << "2\n"; |
---|
| 935 | |
---|
| 936 | ClassTreeMask test13_3; |
---|
| 937 | test13_3.include(Class(A1), true, false); |
---|
| 938 | test13_3.exclude(Class(A1B2), true, false); |
---|
| 939 | test13_3.exclude(Class(A1B1C2), true, false); |
---|
| 940 | test13_3.include(Class(A2), true, false); |
---|
| 941 | test13_3.exclude(Class(A2B2), true, false); |
---|
| 942 | test13_3.include(Class(A3B1), true, false); |
---|
| 943 | test13_3.include(Class(A3B2), true, false); |
---|
| 944 | test13_3.exclude(Class(A3B2C2), true, false); |
---|
| 945 | std::cout << std::endl; |
---|
| 946 | std::cout << "Mask 2 without excluded BaseObject:\n"; |
---|
| 947 | TestClassTreeMask(test13_3); |
---|
| 948 | test13_3.exclude(Class(BaseObject), false, false); |
---|
| 949 | std::cout << std::endl; |
---|
| 950 | std::cout << "Mask 2 with BaseObject excluded afterwards without overwrite:\n"; |
---|
| 951 | TestClassTreeMask(test13_3); |
---|
| 952 | test13_3.exclude(Class(BaseObject), true); |
---|
| 953 | std::cout << std::endl; |
---|
| 954 | std::cout << "Mask 2 with BaseObject excluded afterwards with overwrite:\n"; |
---|
| 955 | TestClassTreeMask(test13_3); |
---|
| 956 | |
---|
| 957 | ClassTreeMask test13_4; |
---|
| 958 | test13_4.include(Class(A3B2)); |
---|
| 959 | test13_4.exclude(Class(A1B1C2)); |
---|
| 960 | test13_4.include(Class(A3B1)); |
---|
| 961 | test13_4.exclude(Class(A3B2C2)); |
---|
| 962 | test13_4.exclude(Class(BaseObject)); |
---|
| 963 | test13_4.include(Class(A2)); |
---|
| 964 | test13_4.exclude(Class(A1B2)); |
---|
| 965 | test13_4.exclude(Class(A2B2)); |
---|
| 966 | test13_4.include(Class(A1)); |
---|
| 967 | std::cout << std::endl; |
---|
| 968 | std::cout << "Mask 2 created in random order with overwrite and clean:\n"; |
---|
| 969 | TestClassTreeMask(test13_4); |
---|
| 970 | |
---|
| 971 | ClassTreeMask test13_4_2; |
---|
| 972 | test13_4_2.include(Class(A3B2), false, false); |
---|
| 973 | test13_4_2.exclude(Class(A1B1C2), false, false); |
---|
| 974 | test13_4_2.include(Class(A3B1), false, false); |
---|
| 975 | test13_4_2.exclude(Class(A3B2C2), false, false); |
---|
| 976 | test13_4_2.exclude(Class(BaseObject), false, false); |
---|
| 977 | test13_4_2.include(Class(A2), false, false); |
---|
| 978 | test13_4_2.exclude(Class(A1B2), false, false); |
---|
| 979 | test13_4_2.exclude(Class(A2B2), false, false); |
---|
| 980 | test13_4_2.include(Class(A1), false, false); |
---|
| 981 | std::cout << std::endl; |
---|
| 982 | std::cout << "Mask 2 created in random order without overwrite and without clean:\n"; |
---|
| 983 | TestClassTreeMask(test13_4_2); |
---|
| 984 | |
---|
| 985 | std::cout << "3\n"; |
---|
| 986 | |
---|
| 987 | ClassTreeMask test13_6 = !test13_1; |
---|
| 988 | std::cout << std::endl; |
---|
| 989 | std::cout << "Mask 1 inverted:\n"; |
---|
| 990 | TestClassTreeMask(test13_6); |
---|
| 991 | |
---|
| 992 | std::cout << "4\n"; |
---|
| 993 | |
---|
| 994 | ClassTreeMask test13_7 = test13_1 + test13_2; |
---|
| 995 | std::cout << std::endl; |
---|
| 996 | std::cout << "Mask 1 + Mask 2:\n"; |
---|
| 997 | TestClassTreeMask(test13_7); |
---|
| 998 | |
---|
| 999 | std::cout << "5\n"; |
---|
| 1000 | |
---|
| 1001 | ClassTreeMask test13_8 = test13_1 * test13_2; |
---|
| 1002 | std::cout << std::endl; |
---|
| 1003 | std::cout << "Mask 1 * Mask 2:\n"; |
---|
| 1004 | TestClassTreeMask(test13_8); |
---|
| 1005 | |
---|
| 1006 | std::cout << "6\n"; |
---|
| 1007 | |
---|
| 1008 | ClassTreeMask test13_9 = test13_1 - test13_2; |
---|
| 1009 | std::cout << std::endl; |
---|
| 1010 | std::cout << "Mask 1 - Mask 2:\n"; |
---|
| 1011 | TestClassTreeMask(test13_9); |
---|
| 1012 | |
---|
| 1013 | std::cout << "7\n"; |
---|
| 1014 | |
---|
| 1015 | ClassTreeMask test13_10 = test13_1 ^ test13_2; |
---|
| 1016 | std::cout << std::endl; |
---|
| 1017 | std::cout << "Mask 1 ^ Mask 2:\n"; |
---|
| 1018 | TestClassTreeMask(test13_10); |
---|
| 1019 | |
---|
| 1020 | std::cout << "8\n"; |
---|
| 1021 | |
---|
| 1022 | ClassTreeMask test13_12(!test13_1); |
---|
| 1023 | std::cout << std::endl; |
---|
| 1024 | std::cout << "Mask 1 inverted assigned with copyconstructor + the original from before:\n"; |
---|
| 1025 | TestClassTreeMask(test13_12); |
---|
| 1026 | TestClassTreeMask(test13_1); |
---|
| 1027 | |
---|
| 1028 | |
---|
| 1029 | ClassTreeMask test13_13 = test13_1 + test13_2; |
---|
| 1030 | std::cout << std::endl; |
---|
| 1031 | std::cout << "Mask 1 + Mask 2 assigned with copyconstructor + originals from before:\n"; |
---|
| 1032 | TestClassTreeMask(test13_13); |
---|
| 1033 | TestClassTreeMask(test13_1); |
---|
| 1034 | TestClassTreeMask(test13_2); |
---|
| 1035 | |
---|
| 1036 | ClassTreeMask test13_14 = test13_1; |
---|
| 1037 | test13_14 += test13_2; |
---|
| 1038 | std::cout << std::endl; |
---|
| 1039 | std::cout << "Mask 1 + Mask 2 with += operator + original of mask 2 from before:\n"; |
---|
| 1040 | TestClassTreeMask(test13_14); |
---|
| 1041 | TestClassTreeMask(test13_2); |
---|
| 1042 | |
---|
| 1043 | test13_1 = test13_1; |
---|
| 1044 | std::cout << std::endl; |
---|
| 1045 | std::cout << "Mask 1 assigned with = operator to itself:\n"; |
---|
| 1046 | TestClassTreeMask(test13_1); |
---|
| 1047 | |
---|
| 1048 | std::cout << "9\n"; |
---|
| 1049 | |
---|
| 1050 | ClassTreeMask test13_15; |
---|
| 1051 | test13_15.exclude(Class(Interface1)); |
---|
| 1052 | std::cout << std::endl; |
---|
| 1053 | std::cout << "Mask with excluded Interface 1:\n"; |
---|
| 1054 | TestClassTreeMask(test13_15); |
---|
| 1055 | |
---|
| 1056 | ClassTreeMask test13_16 = test13_1; |
---|
| 1057 | test13_16.exclude(Class(Interface1)); |
---|
| 1058 | std::cout << std::endl; |
---|
| 1059 | std::cout << "Mask 1 with excluded Interface 1 (overwrite):\n"; |
---|
| 1060 | TestClassTreeMask(test13_16); |
---|
| 1061 | |
---|
| 1062 | ClassTreeMask test13_17 = test13_1; |
---|
| 1063 | test13_17.exclude(Class(Interface1), false); |
---|
| 1064 | std::cout << std::endl; |
---|
| 1065 | std::cout << "Mask 1 with excluded Interface 1 (without overwrite):\n"; |
---|
| 1066 | TestClassTreeMask(test13_17); |
---|
| 1067 | |
---|
| 1068 | ClassTreeMask test13_18 = test13_2; |
---|
| 1069 | test13_18.exclude(Class(Interface1), false); |
---|
| 1070 | std::cout << std::endl; |
---|
| 1071 | std::cout << "Mask 2 with excluded Interface 1 (without overwrite):\n"; |
---|
| 1072 | TestClassTreeMask(test13_18); |
---|
| 1073 | |
---|
| 1074 | std::cout << "10\n"; |
---|
| 1075 | |
---|
| 1076 | ClassTreeMask test13_19; |
---|
| 1077 | test13_19.exclude(Class(Test1)); |
---|
| 1078 | std::cout << std::endl; |
---|
| 1079 | std::cout << "Mask with excluded Test1:\n"; |
---|
| 1080 | TestClassTreeMask(test13_19); |
---|
| 1081 | |
---|
| 1082 | std::cout << "11\n"; |
---|
| 1083 | |
---|
| 1084 | ClassTreeMask test13_20; |
---|
| 1085 | test13_20.exclude(Class(DebugLevel)); |
---|
| 1086 | std::cout << std::endl; |
---|
| 1087 | std::cout << "Mask with excluded DebugLevel:\n"; |
---|
| 1088 | TestClassTreeMask(test13_20); |
---|
| 1089 | |
---|
| 1090 | std::cout << "12\n"; |
---|
| 1091 | |
---|
| 1092 | ClassTreeMask test13_21; |
---|
| 1093 | test13_21.excludeSingle(Class(A2)); |
---|
| 1094 | std::cout << std::endl; |
---|
| 1095 | std::cout << "Mask with single-excluded A2:\n"; |
---|
| 1096 | TestClassTreeMask(test13_21); |
---|
| 1097 | |
---|
| 1098 | test13_21.exclude(Class(A2)); |
---|
| 1099 | std::cout << std::endl; |
---|
| 1100 | std::cout << "Mask with excluded A2:\n"; |
---|
| 1101 | TestClassTreeMask(test13_21); |
---|
| 1102 | |
---|
| 1103 | test13_21.includeSingle(Class(A2)); |
---|
| 1104 | std::cout << std::endl; |
---|
| 1105 | std::cout << "Previous mask with single-included A2:\n"; |
---|
| 1106 | TestClassTreeMask(test13_21); |
---|
| 1107 | |
---|
| 1108 | test13_21.includeSingle(Class(A2), false); |
---|
| 1109 | std::cout << std::endl; |
---|
| 1110 | std::cout << "Previous mask with single-included A2 without clean:\n"; |
---|
| 1111 | TestClassTreeMask(test13_21); |
---|
| 1112 | |
---|
| 1113 | std::cout << "13\n"; |
---|
| 1114 | */ |
---|
| 1115 | /* |
---|
| 1116 | std::cout << "Test 14\n"; |
---|
| 1117 | std::cout << "1\n"; |
---|
| 1118 | |
---|
| 1119 | SubclassIdentifier<A1> test14_1; |
---|
| 1120 | test14_1 = Class(A1B1C1); |
---|
| 1121 | std::cout << test14_1.getIdentifier()->getName() << std::endl; |
---|
| 1122 | |
---|
| 1123 | SubclassIdentifier<A1> test14_2 = Class(A1B1C2); |
---|
| 1124 | std::cout << test14_2.getIdentifier()->getName() << std::endl; |
---|
| 1125 | |
---|
| 1126 | SubclassIdentifier<Interface1> test14_3; |
---|
| 1127 | test14_3 = Class(A2B2C1); |
---|
| 1128 | std::cout << test14_3.getIdentifier()->getName() << std::endl; |
---|
| 1129 | |
---|
| 1130 | SubclassIdentifier<A1B2> test14_4; |
---|
| 1131 | test14_4 = Class(A1B2C1); |
---|
| 1132 | std::cout << test14_4.getIdentifier()->getName() << std::endl; |
---|
| 1133 | |
---|
| 1134 | SubclassIdentifier<BaseObject> test14_5 = Class(Test1); |
---|
| 1135 | std::cout << test14_5.getIdentifier()->getName() << std::endl; |
---|
| 1136 | |
---|
| 1137 | std::cout << "2\n"; |
---|
| 1138 | */ |
---|
| 1139 | /* |
---|
| 1140 | std::cout << "Test 15\n"; |
---|
| 1141 | std::cout << "1\n"; |
---|
| 1142 | |
---|
| 1143 | Level* test15_1 = new Level("levels/sample.oxw"); |
---|
| 1144 | Loader::open(test15_1); |
---|
| 1145 | |
---|
| 1146 | std::cout << "2\n"; |
---|
| 1147 | */ |
---|
[612] | 1148 | startRenderLoop(); |
---|
| 1149 | } |
---|
| 1150 | |
---|
| 1151 | /** |
---|
| 1152 | * @return singleton object |
---|
| 1153 | */ |
---|
| 1154 | Orxonox* Orxonox::getSingleton() |
---|
| 1155 | { |
---|
| 1156 | if (!singletonRef_) |
---|
| 1157 | singletonRef_ = new Orxonox(); |
---|
| 1158 | return singletonRef_; |
---|
| 1159 | } |
---|
| 1160 | |
---|
| 1161 | /** |
---|
| 1162 | * error kills orxonox |
---|
| 1163 | */ |
---|
| 1164 | void Orxonox::die(/* some error code */) |
---|
| 1165 | { |
---|
| 1166 | //TODO: destroy and destruct everything and print nice error msg |
---|
| 1167 | delete this; |
---|
| 1168 | } |
---|
| 1169 | |
---|
[715] | 1170 | void Orxonox::standaloneInit(std::string path) |
---|
[612] | 1171 | { |
---|
| 1172 | ogre_->setConfigPath(path); |
---|
| 1173 | ogre_->setup(); |
---|
| 1174 | root_ = ogre_->getRoot(); |
---|
| 1175 | if(!ogre_->load()) die(/* unable to load */); |
---|
| 1176 | |
---|
| 1177 | //defineResources(); |
---|
| 1178 | //setupRenderSystem(); |
---|
| 1179 | //createRenderWindow(); |
---|
| 1180 | //initializeResourceGroups(); |
---|
| 1181 | /*createScene(); |
---|
| 1182 | setupScene(); |
---|
| 1183 | setupInputSystem(); |
---|
| 1184 | createFrameListener(); |
---|
| 1185 | Factory::createClassHierarchy(); |
---|
| 1186 | startRenderLoop();*/ |
---|
| 1187 | } |
---|
| 1188 | |
---|
[715] | 1189 | void Orxonox::playableServer(std::string path) |
---|
[612] | 1190 | { |
---|
| 1191 | ogre_->setConfigPath(path); |
---|
| 1192 | ogre_->setup(); |
---|
| 1193 | root_ = ogre_->getRoot(); |
---|
| 1194 | defineResources(); |
---|
| 1195 | setupRenderSystem(); |
---|
| 1196 | createRenderWindow(); |
---|
| 1197 | initializeResourceGroups(); |
---|
[616] | 1198 | setupInputSystem(); |
---|
| 1199 | Factory::createClassHierarchy(); |
---|
[612] | 1200 | createScene(); |
---|
| 1201 | setupScene(); |
---|
| 1202 | createFrameListener(); |
---|
| 1203 | try{ |
---|
[873] | 1204 | // server_g = new network::Server(); //!< add port and bindadress |
---|
| 1205 | // server_g->open(); //!< open server and create listener thread |
---|
| 1206 | // if(ogre_ && ogre_->getRoot()) |
---|
| 1207 | // ogre_->getRoot()->addFrameListener(new network::ServerFrameListener()); // adds a framelistener for the server |
---|
[612] | 1208 | COUT(3) << "Info: network framelistener added" << std::endl; |
---|
| 1209 | } |
---|
[782] | 1210 | catch(...) |
---|
[612] | 1211 | { |
---|
| 1212 | COUT(1) << "Error: There was a problem initialising the server :(" << std::endl; |
---|
| 1213 | } |
---|
| 1214 | startRenderLoop(); |
---|
| 1215 | } |
---|
| 1216 | |
---|
| 1217 | void Orxonox::standalone(){ |
---|
| 1218 | |
---|
| 1219 | |
---|
| 1220 | |
---|
| 1221 | } |
---|
| 1222 | |
---|
[715] | 1223 | void Orxonox::serverInit(std::string path) |
---|
[612] | 1224 | { |
---|
| 1225 | COUT(2) << "initialising server" << std::endl; |
---|
| 1226 | ogre_->setConfigPath(path); |
---|
| 1227 | ogre_->setup(); |
---|
[873] | 1228 | // server_g = new network::Server(); // FIXME add some settings if wanted |
---|
[612] | 1229 | if(!ogre_->load()) die(/* unable to load */); |
---|
[665] | 1230 | // FIXME add network framelistener |
---|
[612] | 1231 | } |
---|
| 1232 | |
---|
[715] | 1233 | void Orxonox::clientInit(std::string path) |
---|
[612] | 1234 | { |
---|
| 1235 | COUT(2) << "initialising client" << std::endl; |
---|
| 1236 | ogre_->setConfigPath(path); |
---|
| 1237 | ogre_->setup(); |
---|
[873] | 1238 | // if(serverIp_.compare("")==0) |
---|
| 1239 | // client_g = new network::Client(); |
---|
| 1240 | // else |
---|
| 1241 | // client_g = new network::Client(serverIp_, 55556); |
---|
[612] | 1242 | if(!ogre_->load()) die(/* unable to load */); |
---|
[873] | 1243 | // ogre_->getRoot()->addFrameListener(new network::ClientFrameListener()); |
---|
[612] | 1244 | } |
---|
| 1245 | |
---|
| 1246 | void Orxonox::defineResources() |
---|
| 1247 | { |
---|
[715] | 1248 | std::string secName, typeName, archName; |
---|
[612] | 1249 | Ogre::ConfigFile cf; |
---|
| 1250 | #if OGRE_PLATFORM == OGRE_PLATFORM_APPLE |
---|
| 1251 | cf.load(macBundlePath() + "/Contents/Resources/resources.cfg"); |
---|
| 1252 | #else |
---|
| 1253 | cf.load(dataPath_ + "resources.cfg"); |
---|
| 1254 | #endif |
---|
| 1255 | |
---|
| 1256 | Ogre::ConfigFile::SectionIterator seci = cf.getSectionIterator(); |
---|
| 1257 | while (seci.hasMoreElements()) |
---|
| 1258 | { |
---|
| 1259 | secName = seci.peekNextKey(); |
---|
| 1260 | Ogre::ConfigFile::SettingsMultiMap *settings = seci.getNext(); |
---|
| 1261 | Ogre::ConfigFile::SettingsMultiMap::iterator i; |
---|
| 1262 | for (i = settings->begin(); i != settings->end(); ++i) |
---|
| 1263 | { |
---|
| 1264 | typeName = i->first; |
---|
| 1265 | archName = i->second; |
---|
| 1266 | #if OGRE_PLATFORM == OGRE_PLATFORM_APPLE |
---|
[715] | 1267 | Ogre::ResourceGroupManager::getSingleton().addResourceLocation( std::string(macBundlePath() + "/" + archName), typeName, secName); |
---|
[612] | 1268 | #else |
---|
[708] | 1269 | Ogre::ResourceGroupManager::getSingleton().addResourceLocation( archName, typeName, secName); |
---|
[612] | 1270 | #endif |
---|
| 1271 | } |
---|
| 1272 | } |
---|
| 1273 | } |
---|
| 1274 | |
---|
| 1275 | void Orxonox::setupRenderSystem() |
---|
| 1276 | { |
---|
| 1277 | if (!root_->restoreConfig() && !root_->showConfigDialog()) |
---|
[708] | 1278 | throw Ogre::Exception(52, "User canceled the config dialog!", "OrxApplication::setupRenderSystem()"); |
---|
[612] | 1279 | } |
---|
| 1280 | |
---|
| 1281 | void Orxonox::createRenderWindow() |
---|
| 1282 | { |
---|
| 1283 | root_->initialise(true, "OrxonoxV2"); |
---|
| 1284 | } |
---|
| 1285 | |
---|
| 1286 | void Orxonox::initializeResourceGroups() |
---|
| 1287 | { |
---|
[708] | 1288 | Ogre::TextureManager::getSingleton().setDefaultNumMipmaps(5); |
---|
| 1289 | Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups(); |
---|
[612] | 1290 | } |
---|
| 1291 | |
---|
| 1292 | /** |
---|
| 1293 | * |
---|
| 1294 | * @param |
---|
| 1295 | */ |
---|
| 1296 | void Orxonox::createScene(void) |
---|
| 1297 | { |
---|
| 1298 | // Init audio |
---|
[873] | 1299 | // auMan_ = new audio::AudioManager(); |
---|
[612] | 1300 | |
---|
[873] | 1301 | // bulletMgr_ = new BulletManager(); |
---|
[637] | 1302 | |
---|
[612] | 1303 | // load this file from config |
---|
[871] | 1304 | // loader_ = new loader::LevelLoader("sample.oxw"); |
---|
| 1305 | // loader_->loadLevel(); |
---|
| 1306 | Level* startlevel = new Level("levels/sample.oxw"); |
---|
| 1307 | Loader::open(startlevel); |
---|
[612] | 1308 | |
---|
[873] | 1309 | // Ogre::Overlay* hudOverlay = Ogre::OverlayManager::getSingleton().getByName("Orxonox/HUD1.2"); |
---|
| 1310 | // HUD* orxonoxHud; |
---|
| 1311 | // orxonoxHud = new HUD(); |
---|
| 1312 | // orxonoxHud->setEnergyValue(20); |
---|
| 1313 | // orxonoxHud->setEnergyDistr(20,20,60); |
---|
| 1314 | // hudOverlay->show(); |
---|
[612] | 1315 | |
---|
| 1316 | /* |
---|
| 1317 | auMan_->ambientAdd("a1"); |
---|
| 1318 | auMan_->ambientAdd("a2"); |
---|
| 1319 | auMan_->ambientAdd("a3"); |
---|
| 1320 | //auMan->ambientAdd("ambient1"); |
---|
| 1321 | auMan_->ambientStart();*/ |
---|
| 1322 | } |
---|
| 1323 | |
---|
| 1324 | |
---|
| 1325 | /** |
---|
| 1326 | * |
---|
| 1327 | */ |
---|
| 1328 | void Orxonox::setupScene() |
---|
| 1329 | { |
---|
| 1330 | // SceneManager *mgr = ogre_->getSceneManager(); |
---|
| 1331 | |
---|
| 1332 | |
---|
| 1333 | // SceneNode* node = (SceneNode*)mgr->getRootSceneNode()->getChild("OgreHeadNode"); |
---|
| 1334 | // SceneNode *node = mgr->getRootSceneNode()->createChildSceneNode("OgreHeadNode", Vector3(0,0,0)); |
---|
| 1335 | |
---|
| 1336 | |
---|
| 1337 | /* |
---|
| 1338 | particle::ParticleInterface *e = new particle::ParticleInterface(mgr,"engine","Orxonox/strahl"); |
---|
| 1339 | e->particleSystem_->setParameter("local_space","true"); |
---|
| 1340 | e->setPositionOfEmitter(0, Vector3(0,-10,0)); |
---|
| 1341 | e->setDirection(Vector3(0,0,-1)); |
---|
| 1342 | e->addToSceneNode(node); |
---|
| 1343 | */ |
---|
| 1344 | } |
---|
| 1345 | |
---|
| 1346 | |
---|
| 1347 | void Orxonox::setupInputSystem() |
---|
| 1348 | { |
---|
| 1349 | size_t windowHnd = 0; |
---|
| 1350 | std::ostringstream windowHndStr; |
---|
| 1351 | OIS::ParamList pl; |
---|
[663] | 1352 | |
---|
| 1353 | // fixes auto repeat problem |
---|
| 1354 | #if defined OIS_LINUX_PLATFORM |
---|
[715] | 1355 | pl.insert(std::make_pair(std::string("XAutoRepeatOn"), std::string("true"))); |
---|
[663] | 1356 | #endif |
---|
| 1357 | |
---|
[708] | 1358 | Ogre::RenderWindow *win = ogre_->getRoot()->getAutoCreatedWindow(); |
---|
[612] | 1359 | win->getCustomAttribute("WINDOW", &windowHnd); |
---|
| 1360 | windowHndStr << windowHnd; |
---|
[715] | 1361 | pl.insert(std::make_pair(std::string("WINDOW"), windowHndStr.str())); |
---|
[612] | 1362 | inputManager_ = OIS::InputManager::createInputSystem(pl); |
---|
| 1363 | |
---|
| 1364 | try |
---|
| 1365 | { |
---|
| 1366 | keyboard_ = static_cast<OIS::Keyboard*>(inputManager_->createInputObject(OIS::OISKeyboard, false)); |
---|
| 1367 | mouse_ = static_cast<OIS::Mouse*>(inputManager_->createInputObject(OIS::OISMouse, true)); |
---|
| 1368 | } |
---|
| 1369 | catch (const OIS::Exception &e) |
---|
| 1370 | { |
---|
| 1371 | throw new Ogre::Exception(42, e.eText, "OrxApplication::setupInputSystem"); |
---|
| 1372 | } |
---|
| 1373 | } |
---|
| 1374 | |
---|
[665] | 1375 | // FIXME we actually want to do this differently... |
---|
[612] | 1376 | void Orxonox::createFrameListener() |
---|
| 1377 | { |
---|
| 1378 | TickFrameListener* TickFL = new TickFrameListener(); |
---|
| 1379 | ogre_->getRoot()->addFrameListener(TickFL); |
---|
| 1380 | |
---|
| 1381 | TimerFrameListener* TimerFL = new TimerFrameListener(); |
---|
| 1382 | ogre_->getRoot()->addFrameListener(TimerFL); |
---|
| 1383 | |
---|
[665] | 1384 | //if(mode_!=CLIENT) // FIXME just a hack ------- remove this in future |
---|
[873] | 1385 | frameListener_ = new OrxListener(keyboard_/*, auMan_*/, mode_); |
---|
[612] | 1386 | ogre_->getRoot()->addFrameListener(frameListener_); |
---|
| 1387 | } |
---|
| 1388 | |
---|
| 1389 | void Orxonox::startRenderLoop() |
---|
| 1390 | { |
---|
[665] | 1391 | // FIXME |
---|
[612] | 1392 | // this is a hack!!! |
---|
| 1393 | // the call to reset the mouse clipping size should probably be somewhere |
---|
| 1394 | // else, however this works for the moment. |
---|
| 1395 | unsigned int width, height, depth; |
---|
| 1396 | int left, top; |
---|
| 1397 | ogre_->getRoot()->getAutoCreatedWindow()->getMetrics(width, height, depth, left, top); |
---|
| 1398 | |
---|
| 1399 | if(mode_!=CLIENT){ |
---|
| 1400 | const OIS::MouseState &ms = mouse_->getMouseState(); |
---|
| 1401 | ms.width = width; |
---|
| 1402 | ms.height = height; |
---|
| 1403 | } |
---|
| 1404 | ogre_->getRoot()->startRendering(); |
---|
| 1405 | } |
---|
| 1406 | } |
---|