Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: orxonox.OLD/orxonox/trunk/src/world.cc @ 3471

Last change on this file since 3471 was 3462, checked in by patrick, 20 years ago

orxonox/trunk: cleaning up old stuff in world.cc and its relatives. task
finished for now. there are some serious thoughts that i will have to do
about this class. im not happy with:

  1. the separation mainloop and level-data, this are two very diffrent things.
  2. command-node and the hole command structure has to be redesigned
  3. there are some diffrencies in naming: timeSlice(), tick(), update()

they are all the same…

  1. separation between graphics engine an world itself, display/draw

processes are very different

  1. currently there is a limit of one camera in the world due to the

code. there could arise the need for more camreas…
so loooong…

File size: 22.1 KB
Line 
1
2/*
3   orxonox - the future of 3D-vertical-scrollers
4
5   Copyright (C) 2004 orx
6
7   This program is free software; you can redistribute it and/or modify
8   it under the terms of the GNU General Public License as published by
9   the Free Software Foundation; either version 2, or (at your option)
10   any later version.
11
12   ### File Specific:
13   main-programmer: Patrick Boenzli
14   co-programmer: Christian Meyer
15*/
16
17#include "world.h"
18#include "world_entity.h"
19#include "collision.h"
20#include "track_manager.h"
21#include "player.h"
22#include "command_node.h"
23#include "camera.h"
24#include "environment.h"
25#include "p_node.h"
26#include "null_parent.h"
27#include "helper_parent.h"
28#include "glmenu_imagescreen.h"
29#include "skysphere.h"
30#include "light.h"
31#include "sfont/fontset.h"
32
33using namespace std;
34
35
36/**
37    \brief create a new World
38   
39    This creates a new empty world!
40*/
41World::World (char* name)
42{
43  this->setClassName ("World");
44  this->worldName = name;
45  this->debugWorldNr = -1;
46  this->entities = new tList<WorldEntity>();
47}
48
49/**
50   \brief creates a new World...
51   \param worldID with this ID
52*/
53World::World (int worldID)
54{
55  this->debugWorldNr = worldID;
56  this->worldName = NULL;
57  this->entities = new tList<WorldEntity>();
58}
59
60/**
61    \brief remove the World from memory
62   
63    delete everything explicitly, that isn't contained in the parenting tree!
64    things contained in the tree are deleted automaticaly
65*/
66World::~World ()
67{
68  printf("World::~World() - deleting current world\n");
69  CommandNode* cn = Orxonox::getInstance()->getLocalInput();
70  cn->unbind(this->localPlayer);
71  cn->reset();
72
73  this->localCamera->destroy();
74  this->nullParent->destroy(); 
75  delete this->skySphere;
76
77  //delete this->trackManager;
78
79  /*
80  WorldEntity* entity = entities->enumerate(); 
81  while( entity != NULL )
82    {
83      entity->destroy();
84      entity = entities->nextElement();
85    }
86  this->entities->destroy();
87  */
88
89  /* FIX the parent list has to be cleared - not possible if we got the old list also*/
90
91
92  //delete this->entities;
93  //delete this->localCamera;
94  /* this->localPlayer hasn't to be deleted explicitly, it is
95     contained in entities*/
96}
97
98
99/**
100   \brief loads the World by initializing all resources, and set their default values.
101*/
102ErrorMessage World::load()
103{
104  //  BezierCurve* tmpCurve = new BezierCurve();
105  if(this->debugWorldNr != -1)
106    {
107      // initializing Font
108      testFont = new FontSet();
109      testFont->buildFont("../data/pictures/font.tga");
110
111      // initializing the TrackManager
112      trackManager = TrackManager::getInstance();
113      trackManager->addPoint(Vector(0,-5,0));
114      trackManager->addPoint(Vector(10,0,5));
115      trackManager->addPoint(Vector(20,0,-5));
116      trackManager->addPoint(Vector(30,0,5));
117      trackManager->addPoint(Vector(40,0,5));
118      trackManager->setDuration(2);
119      trackManager->setSavePoint();
120      trackManager->addPoint(Vector(50,10,10));
121      trackManager->addPoint(Vector(60,0, 10));
122      trackManager->addPoint(Vector(70,0, 10));
123      trackManager->addPoint(Vector(80,0,-10));
124      trackManager->addPoint(Vector(90,0,-10));
125      trackManager->setDuration(5);
126      trackManager->setSavePoint();
127      trackManager->addPoint(Vector(110,0,5));
128      trackManager->addPoint(Vector(120,0, 10));
129      trackManager->addPoint(Vector(130,0, 10));
130      trackManager->addPoint(Vector(140,0,-10));
131      trackManager->addPoint(Vector(150,0,-10));
132      trackManager->setDuration(3);
133      int fork11, fork12, fork13, fork14;
134      trackManager->fork(4, &fork11, &fork12, &fork13, &fork14);
135      trackManager->workOn(fork11);
136      trackManager->addPoint(Vector(170, 0, -15));
137      trackManager->addPoint(Vector(180, 0, -15));
138      trackManager->setDuration(3);
139      trackManager->workOn(fork12);
140      trackManager->addPoint(Vector(170, 0, 10));
141      trackManager->addPoint(Vector(180, 0, 10));
142      trackManager->addPoint(Vector(190,2,5));
143      trackManager->addPoint(Vector(200,2,5));
144      trackManager->setDuration(7);
145      int fork21, fork22;
146      trackManager->fork(2, &fork21, &fork22);
147      trackManager->workOn(fork21);
148      trackManager->addPoint(Vector(220, 10,-10));
149      trackManager->addPoint(Vector(230, 0,-10));
150      trackManager->addPoint(Vector(240, 0, 2));
151      trackManager->addPoint(Vector(250, 0, 0));
152      trackManager->addPoint(Vector(260, 0, 5));
153      trackManager->setDuration(3);
154      trackManager->join(2, fork12, fork11);
155      trackManager->workOn(fork22);
156      trackManager->addPoint(Vector(220, -10,10));
157      trackManager->addPoint(Vector(230, 0, 10));
158      trackManager->addPoint(Vector(240, 0, 10));
159      trackManager->addPoint(Vector(250, 0, 5));
160      trackManager->setDuration(6);
161      trackManager->workOn(fork13);
162      trackManager->addPoint(Vector(200,-10,5));
163      trackManager->addPoint(Vector(250,-10,5));
164      trackManager->setDuration(3);
165      trackManager->workOn(fork14);
166      trackManager->addPoint(Vector(200,15,0));
167      trackManager->addPoint(Vector(210,0,10));
168      trackManager->setDuration(1);
169      trackManager->join(4, fork21, fork22, fork13, fork14);
170      trackManager->workOn(10);
171      trackManager->addPoint(Vector(250,-10,5));
172      trackManager->addPoint(Vector(260,-10,5));
173      trackManager->finalize();
174     
175      /*monitor progress*/
176      this->glmis->step();
177
178      /*
179        tmpCurve->addNode(Vector(10,  -1,  -1));
180        tmpCurve->addNode(Vector(10,  -2,   2));
181        tmpCurve->addNode(Vector(10,   3,   3));
182        tmpCurve->addNode(Vector(10,   4,  -4), 0);
183        tmpCurve->addNode(Vector(10,  -1,  -1));
184        tmpCurve->addNode(Vector(10,  -2,   2));
185        tmpCurve->addNode(Vector(10,   3,   3));
186        tmpCurve->addNode(Vector(10,   4,  -4), 0);
187        tmpCurve->debug();
188      */
189      switch(this->debugWorldNr)
190        {
191          /*
192            this loads the hard-coded debug world. this only for simplicity and will be
193            removed by a reald world-loader, which interprets a world-file.
194            if you want to add an own debug world, just add a case DEBUG_WORLD_[nr] and
195            make whatever you want...
196           */
197        case DEBUG_WORLD_0:
198          {
199            this->nullParent = NullParent::getInstance ();
200            this->nullParent->setName ("NullParent");
201
202            // !\todo old track-system has to be removed
203
204            //create helper for player
205            HelperParent* hp = new HelperParent ();
206            /* the player has to be added to this helper */
207
208            // create a player
209            WorldEntity* myPlayer = new Player ();
210            myPlayer->setName ("player");
211            this->spawn (myPlayer);
212            this->localPlayer = myPlayer;
213            /*monitor progress*/
214            this->glmis->step();           
215
216            // bind input
217            Orxonox *orx = Orxonox::getInstance ();
218            orx->getLocalInput()->bind (myPlayer);
219           
220            // bind camera
221            this->localCamera = new Camera(this);
222            this->localCamera->setName ("camera");
223            this->localCamera->bind (myPlayer);
224            this->localPlayer->addChild (this->localCamera);
225
226            // Create SkySphere
227            skySphere = new Skysphere("../data/pictures/sky-replace.jpg");
228
229            /*monitor progress*/
230            this->glmis->step();
231
232            Vector* es = new Vector (50, 2, 0);
233            Quaternion* qs = new Quaternion ();
234            WorldEntity* env = new Environment();
235            env->setName ("env");
236            this->spawn(env, es, qs);
237           
238            /*monitor progress*/
239            this->glmis->step();
240
241            trackManager->setBindSlave(env);
242
243            break;
244          }
245        case DEBUG_WORLD_1:
246          {
247            /*
248            this->testCurve = new UPointCurve();
249            this->testCurve->addNode(Vector( 0, 0, 0));
250            this->testCurve->addNode(Vector(10, 0, 5));
251            this->testCurve->addNode(Vector(20, -5,-5));
252            this->testCurve->addNode(Vector(30, 5, 10));
253            this->testCurve->addNode(Vector(40, 0,-10));
254            this->testCurve->addNode(Vector(50, 0,-10));
255            */
256
257            this->nullParent = NullParent::getInstance ();
258            this->nullParent->setName ("NullParent");
259
260
261
262            // create a player
263            WorldEntity* myPlayer = new Player();
264            myPlayer->setName ("player");
265            this->spawn(myPlayer);
266            this->localPlayer = myPlayer;           
267           
268            // bind input
269            Orxonox *orx = Orxonox::getInstance();
270            orx->getLocalInput()->bind (myPlayer);
271           
272            // bind camera
273            this->localCamera = new Camera (this);
274            this->localCamera->setName ("camera");
275            this->localCamera->bind (myPlayer); 
276            this->localPlayer->addChild (this->localCamera);
277
278            // Create SkySphere
279            skySphere = new Skysphere("../data/pictures/sky-replace.jpg");
280
281            break;
282
283
284          }
285        default:
286          printf("World::load() - no world with ID %i found", this->debugWorldNr );
287        }
288    }
289  else if(this->worldName != NULL)
290    {
291
292    }
293
294  // initialize debug coord system
295  objectList = glGenLists(1);
296  glNewList (objectList, GL_COMPILE);
297  glLoadIdentity();
298  glColor3f(1.0,0,0);
299  glBegin(GL_QUADS);
300
301  int sizeX = 100;
302  int sizeZ = 80;
303  float length = 1000;
304  float width = 200;
305  float widthX = float (length /sizeX);
306  float widthZ = float (width /sizeZ);
307 
308  float height [sizeX][sizeZ];
309  Vector normal_vectors[sizeX][sizeZ];
310 
311 
312  for ( int i = 0; i<sizeX-1; i+=1)
313    for (int j = 0; j<sizeZ-1;j+=1)
314      //height[i][j] = rand()/20046 + (j-25)*(j-25)/30;
315#ifdef __WIN32__
316      height[i][j]=(sin((float)j/3)*rand()*i/182400)*.5;
317#else
318      height[i][j]=(sin((float)j/3)*rand()*(long)i/6282450500.0)*.5;
319#endif
320
321  //Die Huegel ein wenig glaetten
322  for (int h=1; h<2;h++)
323    for (int i=1;i<sizeX-2 ;i+=1 )
324      for(int j=1;j<sizeZ-2;j+=1)
325        height[i][j]=(height[i+1][j]+height[i][j+1]+height[i-1][j]+height[i][j-1])/4;
326 
327  //Berechnung von normalen Vektoren
328  for(int i=1;i<sizeX-2;i+=1)
329    for(int j=1;j<sizeZ-2 ;j+=1)
330      {
331        Vector v1 = Vector (widthX*(1),      height[i][j],      widthZ*(j) );
332        Vector v2 = Vector (widthX*(i-1),    height[i-1][j],    widthZ*(j));
333        Vector v3 = Vector (widthX*(i),      height[i][j+1],    widthZ*(j+1));
334        Vector v4 = Vector (widthX*(i+1),    height[i+1][j],    widthZ*(j));
335        Vector v5 = Vector (widthX*(i),      height[i][j-1],    widthZ*(j-1));
336       
337        Vector c1 = v2 - v1;
338        Vector c2 = v3 - v1;
339        Vector c3=  v4 - v1;
340        Vector c4 = v5 - v1;
341        Vector zero = Vector (0,0,0);
342        normal_vectors[i][j]=c1.cross(v3-v5)+c2.cross(v4-v2)+c3.cross(v5-v3)+c4.cross(v2-v4);
343        normal_vectors[i][j].normalize();
344      }
345
346  int snowheight=3;
347  for ( int i = 0; i<sizeX; i+=1)
348    for (int j = 0; j<sizeZ;j+=1)
349      {   
350        Vector v1 = Vector (widthX*(i),      height[i][j]-20,       widthZ*(j)  -width/2);
351        Vector v2 = Vector (widthX*(i+1),    height[i+1][j]-20,     widthZ*(j)  -width/2);
352        Vector v3 = Vector (widthX*(i+1),    height[i+1][j+1]-20,   widthZ*(j+1)-width/2);
353        Vector v4 = Vector (widthX*(i),      height[i][j+1]-20,     widthZ*(j+1)-width/2);
354        float a[3];
355        if(height[i][j]<snowheight){
356          a[0]=0;
357          a[1]=1.0-height[i][j]/10-.3;
358          a[2]=0;
359          glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
360        }
361        else{
362            a[0]=1.0;
363            a[1]=1.0;
364            a[2]=1.0;
365            glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
366           
367        }
368        glNormal3f(normal_vectors[i][j].x, normal_vectors[i][j].y, normal_vectors[i][j].z);
369        glVertex3f(v1.x, v1.y, v1.z);
370        if(height[i+1][j]<snowheight){
371          a[0]=0;
372          a[1] =1.0-height[i+1][j]/10-.3;
373          a[2]=0;
374          glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
375        }
376        else{
377          a[0]=1.0;
378          a[1]=1.0;
379          a[2]=1.0;
380          glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
381         
382        }
383        glNormal3f(normal_vectors[i+1][j].x, normal_vectors[i+1][j].y, normal_vectors[i+1][j].z);
384        glVertex3f(v2.x, v2.y, v2.z);
385        if(height[i+1][j+1]<snowheight){
386          a[0]=0;
387          a[1] =1.0-height[i+1][j+1]/10-.3;
388          a[2]=0;
389          glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
390        }
391        else{
392          a[0]=1.0;
393          a[1]=1.0;
394          a[2]=1.0;
395          glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
396         
397         
398        }
399        glNormal3f(normal_vectors[i+1][j+1].x, normal_vectors[i+1][j+1].y, normal_vectors[i+1][j+1].z);
400        glVertex3f(v3.x, v3.y, v3.z);
401        if(height[i][j+1]<snowheight){
402          a[0]=0;
403          a[1] =1.0-height[i+1][j+1]/10-.3;
404          a[2]=0;
405          glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
406        }
407        else{
408          a[0]=1.0;
409          a[1]=1.0;
410          a[2]=1.0;
411          glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
412        }
413        glNormal3f(normal_vectors[i][j+1].x, normal_vectors[i][j+1].y, normal_vectors[i][j+1].z);
414        glVertex3f(v4.x, v4.y, v4.z);
415       
416      }
417  glEnd();
418  /* 
419  glBegin(GL_LINES);
420  for( float x = -128.0; x < 128.0; x += 25.0)
421    {
422      for( float y = -128.0; y < 128.0; y += 25.0)
423        {
424          glColor3f(1,0,0);
425          glVertex3f(x,y,-128.0);
426          glVertex3f(x,y,0.0);
427          glColor3f(0.5,0,0);
428          glVertex3f(x,y,0.0);
429          glVertex3f(x,y,128.0);
430        }
431    }
432  for( float y = -128.0; y < 128.0; y += 25.0)
433    {
434      for( float z = -128.0; z < 128.0; z += 25.0)
435        {
436          glColor3f(0,1,0);
437          glVertex3f(-128.0,y,z);
438          glVertex3f(0.0,y,z);
439          glColor3f(0,0.5,0);
440          glVertex3f(0.0,y,z);
441          glVertex3f(128.0,y,z);
442        }
443    }
444  for( float x = -128.0; x < 128.0; x += 25.0)
445    {
446      for( float z = -128.0; z < 128.0; z += 25.0)
447        {
448          glColor3f(0,0,1);
449          glVertex3f(x,-128.0,z);
450          glVertex3f(x,0.0,z);
451          glColor3f(0,0,0.5);
452          glVertex3f(x,0.0,z);
453          glVertex3f(x,128.0,z);
454        }
455     
456    }
457  */ 
458  /*
459  glBegin(GL_LINE_STRIP);
460  glColor3f(1.0, 5.0, 1.0);
461  for( int i = 0; i <= 30; i++)
462    {
463      glEvalCoord1f ((GLfloat) i/30.0);
464    }
465  glEnd();
466  */
467
468  trackManager->drawGraph(.01);
469  trackManager->debug(2);
470  /* 
471  glBegin(GL_LINES);
472  float i;
473  for(i = 0.0; i<1; i+=.01)
474    {
475      printf("%f, %f, %f\n",tmpCurve->calcPos(i).x, tmpCurve->calcPos(i).y, tmpCurve->calcPos(i).z);
476      glVertex3f(tmpCurve->calcPos(i).x, tmpCurve->calcPos(i).y, tmpCurve->calcPos(i).z);
477    }
478  glEnd();
479  */
480  glEndList();
481  // LIGHT initialisation
482  light = Light::getInstance();
483  light->addLight(0);
484  light->setAttenuation(QUADRATIC, 1.0);
485  light->setAttenuation(CONSTANT, 2.0);
486  light->setAttenuation(QUADRATIC, 1.0);
487  light->setPosition(10.0, 10.0, 50.0);
488  light->setDiffuseColor(1,1,1);
489  //  light->addLight(1);
490  //  light->setPosition(20, 10, -20);
491  //  light->setDiffuseColor(0,0,0);
492  light->debug();
493
494
495}
496
497/**
498   \brief initializes a new World
499*/
500ErrorMessage World::init()
501{
502  this->bPause = false;
503  CommandNode* cn = Orxonox::getInstance()->getLocalInput();
504  cn->addToWorld(this);
505  cn->enable(true);
506
507  //glMap1f (GL_MAP1_VERTEX_3, 0.0, 1.0, 3, 4, &ctrlpoints[0][0]);
508  //glEnable (GL_MAP1_VERTEX_3);
509 
510  //theNurb = gluNewNurbsRenderer ();
511  //gluNurbsProperty (theNurb, GLU_NURBS_MODE, GLU_NURBS_TESSELLATOR);
512  //gluNurbsProperty (theNurb, GLU_NURBS_VERTEX, vertexCallback );
513
514}
515
516
517/**
518   \brief starts the World
519*/
520ErrorMessage World::start()
521{
522  printf("World::start() - starting current World: nr %i\n", this->debugWorldNr);
523  this->bQuitOrxonox = false;
524  this->bQuitCurrentGame = false;
525  this->mainLoop();
526}
527
528/**
529   \brief stops the world.
530
531   This happens, when the player decides to end the Level.
532*/
533ErrorMessage World::stop()
534{
535  printf("World::stop() - got stop signal\n");
536  this->bQuitCurrentGame = true;
537}
538
539/**
540   \brief pauses the Game
541*/
542ErrorMessage World::pause()
543{
544  this->isPaused = true;
545}
546
547/**
548   \brief ends the pause Phase
549*/
550ErrorMessage World::resume()
551{
552  this->isPaused = false;
553}
554
555/**
556   \brief destroys the World
557*/
558ErrorMessage World::destroy()
559{
560  delete trackManager;
561}
562
563/**
564   \brief shows the loading screen
565*/
566void World::displayLoadScreen ()
567{
568  printf ("World::displayLoadScreen - start\n"); 
569 
570  //GLMenuImageScreen*
571  this->glmis = GLMenuImageScreen::getInstance();
572  this->glmis->init();
573  this->glmis->setMaximum(10);
574  this->glmis->draw();
575 
576  printf ("World::displayLoadScreen - end\n"); 
577}
578
579/**
580   \brief removes the loadscreen, and changes over to the game
581
582   \todo take out the delay
583*/
584void World::releaseLoadScreen ()
585{
586  printf ("World::releaseLoadScreen - start\n"); 
587  this->glmis->setValue(this->glmis->getMaximum());
588  SDL_Delay(500);
589  printf ("World::releaseLoadScreen - end\n"); 
590}
591
592
593/**
594    \brief checks for collisions
595   
596    This method runs through all WorldEntities known to the world and checks for collisions
597    between them. In case of collisions the collide() method of the corresponding entities
598    is called.
599*/
600void World::collide ()
601{
602  /*
603  List *a, *b;
604  WorldEntity *aobj, *bobj;
605   
606  a = entities;
607 
608  while( a != NULL)
609    {
610      aobj = a->nextElement();
611      if( aobj->bCollide && aobj->collisioncluster != NULL)
612        {
613          b = a->nextElement();
614          while( b != NULL )
615            {
616              bobj = b->nextElement();
617              if( bobj->bCollide && bobj->collisioncluster != NULL )
618                {
619                  unsigned long ahitflg, bhitflg;
620                  if( check_collision ( &aobj->place, aobj->collisioncluster,
621                                        &ahitflg, &bobj->place, bobj->collisioncluster,
622                                        &bhitflg) );
623                  {
624                    aobj->collide (bobj, ahitflg, bhitflg);
625                    bobj->collide (aobj, bhitflg, ahitflg);
626                  }
627                }
628              b = b->nextElement();
629            }
630        }
631      a = a->enumerate();
632    }
633  */
634}
635
636/**
637    \brief runs through all entities calling their draw() methods
638*/
639void World::draw ()
640{
641  /* draw entities */
642  WorldEntity* entity;
643  entity = this->entities->enumerate();
644  while( entity != NULL ) 
645    { 
646      if( entity->bDraw ) entity->draw();
647      entity = this->entities->nextElement();
648    } 
649 
650  glCallList (objectList);
651  //! \todo skysphere is a WorldEntity and should be inside of the world-entity-list.
652  skySphere->draw();
653
654  testFont->printText(0, 0, 1, "orxonox_" PACKAGE_VERSION);
655
656}
657
658
659/**
660   \brief function to put your own debug stuff into it. it can display informations about
661   the current class/procedure
662*/
663void World::debug()
664{
665  printf ("World::debug() - starting debug\n");
666  PNode* p1 = NullParent::getInstance ();
667  PNode* p2 = new PNode (new Vector(2, 2, 2), p1);
668  PNode* p3 = new PNode (new Vector(4, 4, 4), p1);
669  PNode* p4 = new PNode (new Vector(6, 6, 6), p2);
670
671  p1->debug ();
672  p2->debug ();
673  p3->debug ();
674  p4->debug ();
675
676  p1->shiftCoor (new Vector(-1, -1, -1));
677
678  printf("World::debug() - shift\n");
679  p1->debug ();
680  p2->debug ();
681  p3->debug ();
682  p4->debug ();
683 
684  p1->update (1);
685
686  printf ("World::debug() - update\n");
687  p1->debug ();
688  p2->debug ();
689  p3->debug ();
690  p4->debug ();
691
692  p2->shiftCoor (new Vector(-1, -1, -1));
693  p1->update (2);
694
695  p1->debug ();
696  p2->debug ();
697  p3->debug ();
698  p4->debug ();
699
700  p2->setAbsCoor (new Vector(1,2,3));
701
702
703 p1->update (2);
704
705  p1->debug ();
706  p2->debug ();
707  p3->debug ();
708  p4->debug ();
709
710  p1->destroy ();
711 
712 
713  /*
714  WorldEntity* entity;
715  printf("counting all entities\n");
716  printf("World::debug() - enumerate()\n");
717  entity = entities->enumerate(); 
718  while( entity != NULL )
719    {
720      if( entity->bDraw ) printf("got an entity\n");
721      entity = entities->nextElement();
722    }
723  */
724}
725
726
727/**
728  \brief main loop of the world: executing all world relevant function
729
730  in this loop we synchronize (if networked), handle input events, give the heart-beat to
731  all other member-entities of the world (tick to player, enemies etc.), checking for
732  collisions drawing everything to the screen.
733*/
734void World::mainLoop()
735{
736  this->lastFrame = SDL_GetTicks ();
737  printf("World::mainLoop() - Entering main loop\n");
738  while( !this->bQuitOrxonox && !this->bQuitCurrentGame) /* \todo implement pause */
739    {
740      // Network
741      this->synchronize ();
742      // Process input
743      this->handleInput ();
744      if( this->bQuitCurrentGame || this->bQuitOrxonox)
745        {
746          printf("World::mainLoop() - leaving loop earlier...\n");
747          break;
748        }
749      // Process time
750      this->timeSlice ();
751      // Process collision
752      this->collide ();
753      // Draw
754      this->display ();
755 
756      for( int i = 0; i < 5000000; i++) {}
757      /* \todo this is to slow down the program for openGl Software emulator computers, reimplement*/
758    }
759  printf("World::mainLoop() - Exiting the main loop\n");
760}
761
762
763/**
764   \brief synchronize local data with remote data
765*/
766void World::synchronize ()
767{
768  // Get remote input
769  // Update synchronizables
770}
771
772
773/**
774   \brief run all input processing
775
776   the command node is the central input event dispatcher. the node uses the even-queue from
777   sdl and has its own event-passing-queue.
778*/
779void World::handleInput ()
780{
781  // localinput
782  CommandNode* cn = Orxonox::getInstance()->getLocalInput();
783  cn->process();
784  // remoteinput
785}
786
787
788/**
789   \brief advance the timeline
790
791   this calculates the time used to process one frame (with all input handling, drawing, etc)
792   the time is mesured in ms and passed to all world-entities and other classes that need
793   a heart-beat.
794*/
795void World::timeSlice ()
796{
797  Uint32 currentFrame = SDL_GetTicks();
798  if(!this->bPause)
799    {
800      Uint32 dt = currentFrame - this->lastFrame;
801     
802      if(dt > 0)
803        {
804          float fps = 1000/dt;
805          printf("fps = %f\n", fps);
806        }
807      else
808        {
809          /* the frame-rate is limited to 100 frames per second, all other things are for
810             nothing.
811          */
812          printf("fps = 1000 - frame rate is adjusted\n");
813          SDL_Delay(10);
814          dt = 10;
815        }
816      //this->timeSlice (dt);
817     
818      /* function to let all entities tick (iterate through list) */
819      WorldEntity* entity;
820      float seconds = dt / 1000.0;     
821      this->nullParent->update (seconds);
822      entity = entities->enumerate(); 
823      while( entity != NULL) 
824        { 
825          entity->tick (seconds);
826          entity = entities->nextElement();
827        }
828      skySphere->updatePosition(localCamera->absCoordinate);
829     
830      /* update tick the rest */
831      this->localCamera->timeSlice(dt);
832      this->trackManager->tick(dt);
833    }
834  this->lastFrame = currentFrame;
835}
836
837
838/**
839   \brief render the current frame
840   
841   clear all buffers and draw the world
842*/
843void World::display ()
844{
845  // clear buffer
846  glClear( GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
847  // set camera
848  this->localCamera->apply ();
849  // draw world
850  this->draw();
851  // draw HUD
852  /* \todo draw HUD */
853  // flip buffers
854  SDL_GL_SwapBuffers();
855  //SDL_Surface* screen = Orxonox::getInstance()->getScreen ();
856  //SDL_Flip (screen);
857}
858
859
860/**
861   \brief add and spawn a new entity to this world
862   \param entity to be added
863*/
864void World::spawn(WorldEntity* entity)
865{
866  if( this->nullParent != NULL && entity->parent == NULL)
867    this->nullParent->addChild (entity);
868
869  this->entities->add (entity);
870
871  entity->postSpawn ();
872}
873
874
875/**
876   \brief add and spawn a new entity to this world
877   \param entity to be added
878   \param absCoor At what coordinates to add this entity.
879   \param absDir In which direction should it look.
880*/
881void World::spawn(WorldEntity* entity, Vector* absCoor, Quaternion* absDir)
882{
883  entity->setAbsCoor (absCoor);
884  entity->setAbsDir (absDir);
885 
886  if( this->nullParent != NULL && entity->parent == NULL)
887    this->nullParent->addChild (entity);
888
889  this->entities->add (entity);
890
891  entity->postSpawn ();
892}
893
894
895
896/**
897  \brief commands that the world must catch
898  \returns false if not used by the world
899*/
900bool World::command(Command* cmd)
901{
902  return false;
903}
904
Note: See TracBrowser for help on using the repository browser.