Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: orxonox.OLD/trunk/src/lib/graphics/graphics_engine.cc @ 8914

Last change on this file since 8914 was 8740, checked in by bensch, 18 years ago

orxonox/trunk: now the elements are draw correctly

File size: 17.8 KB
Line 
1/*
2   orxonox - the future of 3D-vertical-scrollers
3
4   Copyright (C) 2004 orx
5
6   This program is free software; you can redistribute it and/or modify
7   it under the terms of the GNU General Public License as published by
8   the Free Software Foundation; either version 2, or (at your option)
9   any later version.
10
11   ### File Specific:
12   main-programmer: Benjamin Grauer
13   co-programmer: ...
14*/
15
16#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_GRAPHICS
17
18#include "graphics_engine.h"
19#include "util/loading/resource_manager.h"
20#include "state.h"
21
22#include "world_entity.h"
23
24#include "render_2d.h"
25#include "text_engine.h"
26#include "light.h"
27#include "shader.h"
28#include "debug.h"
29
30#include "util/preferences.h"
31#include "substring.h"
32#include "text.h"
33
34#include "globals.h"
35#include "texture.h"
36
37#include "effects/graphics_effect.h"
38#include "effects/fog_effect.h"
39#include "effects/lense_flare.h"
40
41#include "shell_command.h"
42
43
44#include "parser/tinyxml/tinyxml.h"
45#include "util/loading/load_param.h"
46#include "util/loading/factory.h"
47#include "class_list.h"
48
49#ifdef __WIN32__
50 #include "static_model.h"
51#endif
52using namespace std;
53
54SHELL_COMMAND(wireframe, GraphicsEngine, wireframe);
55
56
57/**
58 * @brief standard constructor
59 */
60GraphicsEngine::GraphicsEngine ()
61{
62  this->setClassID(CL_GRAPHICS_ENGINE, "GraphicsEngine");
63  this->setName("GraphicsEngine");
64
65  this->isInit = false;
66
67  this->bDisplayFPS = false;
68  this->bAntialiasing = false;
69  this->minFPS = 9999;
70  this->maxFPS = 0;
71
72  this->geTextCFPS = NULL;
73  this->geTextMaxFPS = NULL;
74  this->geTextMinFPS = NULL;
75
76  this->fullscreenFlag = 0;
77  this->videoFlags = 0;
78  this->screen = NULL;
79
80  // initialize the Modules
81  TextEngine::getInstance();
82  this->graphicsEffects = NULL;
83
84}
85
86/**
87 * @brief The Pointer to this GraphicsEngine
88 */
89GraphicsEngine* GraphicsEngine::singletonRef = NULL;
90
91/**
92 * @brief destructs the graphicsEngine.
93*/
94GraphicsEngine::~GraphicsEngine ()
95{
96  // delete what has to be deleted here
97  this->displayFPS( false );
98
99  //TextEngine
100  delete TextEngine::getInstance();
101  // render 2D
102  delete Render2D::getInstance();
103
104  SDL_QuitSubSystem(SDL_INIT_VIDEO);
105  //   if (this->screen != NULL)
106  //     SDL_FreeSurface(this->screen);
107
108  GraphicsEngine::singletonRef = NULL;
109}
110
111
112/**
113 * @brief loads the GraphicsEngine Specific Parameters.
114 * @param root: the XML-Element to load the Data From
115 */
116void GraphicsEngine::loadParams(const TiXmlElement* root)
117{
118  LoadParamXML(root, "GraphicsEffect", this, GraphicsEngine, loadGraphicsEffects)
119  .describe("loads a graphics effect");
120}
121
122
123
124
125/**
126 * @param root The XML-element to load GraphicsEffects from
127 */
128void GraphicsEngine::loadGraphicsEffects(const TiXmlElement* root)
129{
130  LOAD_PARAM_START_CYCLE(root, element);
131  {
132    PRINTF(4)("element is: %s\n", element->Value());
133    Factory::fabricate(element);
134  }
135  LOAD_PARAM_END_CYCLE(element);
136}
137
138
139
140/**
141 * @brief initializes the GraphicsEngine with default settings.
142 */
143int GraphicsEngine::init()
144{
145  if (this->isInit)
146    return -1;
147  this->initVideo(640, 480, 16);
148  return 1;
149}
150
151/**
152 * @brief loads the GraphicsEngine's settings from a given ini-file and section
153 * @returns nothing usefull
154 */
155int GraphicsEngine::initFromPreferences()
156{
157  // looking if we are in fullscreen-mode
158  MultiType fullscreen = Preferences::getInstance()->getString(CONFIG_SECTION_VIDEO, CONFIG_NAME_FULLSCREEN, "0");
159
160  if (fullscreen.getBool())
161    this->fullscreenFlag = SDL_FULLSCREEN;
162
163  // looking if we are in fullscreen-mode
164  MultiType textures = Preferences::getInstance()->getString(CONFIG_SECTION_VIDEO_ADVANCED, CONFIG_NAME_TEXTURES, "1");
165  Texture::setTextureEnableState(textures.getBool());
166
167  // searching for a usefull resolution
168  SubString resolution(Preferences::getInstance()->getString(CONFIG_SECTION_VIDEO, CONFIG_NAME_RESOLUTION, "640x480").c_str(), 'x'); ///FIXME
169  //resolution.debug();
170  MultiType x = resolution.getString(0), y = resolution.getString(1);
171  return this->initVideo(x.getInt(), y.getInt(), 16);
172
173  //   GraphicsEffect* fe = new FogEffect(NULL);
174  //   this->loadGraphicsEffect(fe);
175  //   fe->activate();
176  //   PRINTF(0)("--------------------------------------------------------------\n");
177
178  //LenseFlare* ge = new LenseFlare();
179  //this->loadGraphicsEffect(ge);
180
181  //ge->addFlare("pictures/lense_flare/sun.png"); //sun
182  //ge->addFlare("pictures/lense_flare/lens2.png"); //first halo
183  //ge->addFlare("pictures/lense_flare/lens1.png"); //small birst
184  //ge->addFlare("pictures/lense_flare/lens3.png"); //second halo
185  //ge->addFlare("pictures/lense_flare/lens4.png");
186  //ge->addFlare("pictures/lense_flare/lens1.png");
187  //ge->addFlare("pictures/lense_flare/lens3.png");
188
189  //ge->activate();
190}
191
192
193
194/**
195 * @brief initializes the Video for openGL.
196 *
197 * This has to be done only once when starting orxonox.
198 */
199int GraphicsEngine::initVideo(unsigned int resX, unsigned int resY, unsigned int bbp)
200{
201  if (this->isInit)
202    return -1;
203  //   initialize SDL_VIDEO
204  if (SDL_InitSubSystem(SDL_INIT_VIDEO) == -1)
205  {
206    PRINTF(1)("could not initialize SDL Video\n");
207    return -1;
208  }
209  // initialize SDL_GL-settings
210  this->setGLattribs();
211
212  // setting the Video Flags.
213  this->videoFlags = SDL_OPENGL | SDL_HWPALETTE | SDL_RESIZABLE ;
214
215  /* query SDL for information about our video hardware */
216  const SDL_VideoInfo* videoInfo = SDL_GetVideoInfo ();
217  if( videoInfo == NULL)
218  {
219    PRINTF(1)("Failed getting Video Info :%s\n", SDL_GetError());
220    SDL_Quit ();
221  }
222  if( videoInfo->hw_available)
223    this->videoFlags |= SDL_HWSURFACE;
224  else
225    this->videoFlags |= SDL_SWSURFACE;
226  /*
227  if(VideoInfo -> blit_hw)
228    VideoFlags |= SDL_HWACCEL;
229  */
230  // setting up the Resolution
231  this->setResolution(resX, resY, bbp);
232
233  // GRABBING ALL GL-extensions
234  this->grabHardwareSettings();
235
236  // Enable default GL stuff
237  glEnable(GL_DEPTH_TEST);
238
239  Render2D::getInstance();
240
241  this->isInit = true;
242  return 1;
243}
244
245/**
246 * @brief sets the Window Captions and the Name of the icon.
247 * @param windowName The name of the Window
248 * @param icon The name of the Icon on the Disc
249 */
250void GraphicsEngine::setWindowName(const std::string& windowName, const std::string& icon)
251{
252  SDL_Surface* iconSurf = SDL_LoadBMP(icon.c_str());
253  if (iconSurf != NULL)
254  {
255    Uint32 colorkey = SDL_MapRGB(iconSurf->format, 0, 0, 0);
256    SDL_SetColorKey(iconSurf, SDL_SRCCOLORKEY, colorkey);
257    SDL_WM_SetIcon(iconSurf, NULL);
258    SDL_FreeSurface(iconSurf);
259  }
260
261  SDL_WM_SetCaption (windowName.c_str(), icon.c_str());
262}
263
264
265/**
266 * @brief Sets the GL-attributes
267 */
268void GraphicsEngine::setGLattribs()
269{
270  // Set video mode
271  // TO DO: parse arguments for settings
272  //SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5);
273  //SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 5);
274  //SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5);
275  //SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);
276
277
278  SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
279  SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, 16);
280  SDL_GL_SetAttribute( SDL_GL_STENCIL_SIZE, 0);
281  SDL_GL_SetAttribute( SDL_GL_ACCUM_RED_SIZE, 0);
282  SDL_GL_SetAttribute( SDL_GL_ACCUM_GREEN_SIZE, 0);
283  SDL_GL_SetAttribute( SDL_GL_ACCUM_BLUE_SIZE, 0);
284  SDL_GL_SetAttribute( SDL_GL_ACCUM_ALPHA_SIZE, 0);
285
286  SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5);      //Use at least 5 bits of Red
287  SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 5);    //Use at least 5 bits of Green
288  SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5);     //Use at least 5 bits of Blue
289  SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);   //Use at least 16 bits for the depth buffer
290  SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);  //Enable double buffering
291
292  // enable antialiasing?
293  if( this->bAntialiasing)
294  {
295    SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES,4);
296    SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS,1);
297  }
298
299  glEnable(GL_CULL_FACE);
300  glCullFace(GL_FRONT);
301}
302
303/**
304 * @brief grabs the Hardware Specifics
305 *
306 * checks for all the different HW-types
307 */
308void GraphicsEngine::grabHardwareSettings()
309{
310  const char* renderer = (const char*) glGetString(GL_RENDERER);
311  const char* vendor   = (const char*) glGetString(GL_VENDOR);
312  const char* version  = (const char*) glGetString(GL_VERSION);
313  const char* extensions = (const char*) glGetString(GL_EXTENSIONS);
314
315  //  printf("%s %s %s\n %s", renderer, vendor, version, extensions);
316
317  if (renderer != NULL)
318  {
319    this->hwRenderer == renderer;
320  }
321  if (vendor != NULL)
322  {
323    this->hwVendor == vendor;
324  }
325  if (version != NULL)
326  {
327    this->hwVersion == version;
328  }
329
330  if (extensions != NULL)
331    this->hwExtensions.split(extensions, " \n\t,");
332
333  PRINT(4)("Running on : vendor: %s,  renderer: %s,  version:%s\n", vendor, renderer, version);
334  PRINT(4)("Extensions:\n");
335  for (unsigned int i = 0; i < this->hwExtensions.size(); i++)
336    PRINT(4)("%d: %s\n", i, this->hwExtensions[i].c_str());
337
338
339  // inizializing GLEW
340  GLenum err = glewInit();
341  if (GLEW_OK != err)
342  {
343    /* Problem: glewInit failed, something is seriously wrong. */
344    PRINTF(1)("%s\n", glewGetErrorString(err));
345  }
346  PRINTF(4)("Status: Using GLEW %s\n", glewGetString(GLEW_VERSION));
347}
348
349
350/**
351 * @brief sets the Resolution of the Screen to display the Graphics to.
352 * @param width The width of the window
353 * @param height The height of the window
354 * @param bpp bits per pixel
355 */
356int GraphicsEngine::setResolution(int width, int height, int bpp)
357{
358  this->resolutionX = width;
359  this->resolutionY = height;
360  this->bitsPerPixel = bpp;
361  State::setResolution( width, height);
362
363  if (this->screen != NULL)
364    SDL_FreeSurface(screen);
365  if((this->screen = SDL_SetVideoMode(this->resolutionX, this->resolutionY, this->bitsPerPixel, this->videoFlags | this->fullscreenFlag)) == NULL)
366  {
367    PRINTF(1)("Could not SDL_SetVideoMode(%d, %d, %d, %d): %s\n", this->resolutionX, this->resolutionY, this->bitsPerPixel, this->videoFlags, SDL_GetError());
368    //    SDL_Quit();
369    //    return -1;
370    return -1;
371  }
372  glViewport(0, 0, width, height);                     // Reset The Current Viewport
373
374#ifdef __WIN32__
375  // REBUILDING TEXTURES (ON WINDOWS CONTEXT SWITCH)
376  const std::list<BaseObject*>* texList = ClassList::getList(CL_TEXTURE);
377  if (texList != NULL)
378  {
379    std::list<BaseObject*>::const_iterator reTex;
380    for (reTex = texList->begin(); reTex != texList->end(); reTex++)
381      dynamic_cast<Texture*>(*reTex)->rebuild();
382  }
383  // REBUILDING MODELS
384  const std::list<BaseObject*>* modelList = ClassList::getList(CL_STATIC_MODEL);
385  if (texList != NULL)
386  {
387    std::list<BaseObject*>::const_iterator reModel;
388    for (reModel = modelList->begin(); reModel != modelList->end(); reModel++)
389      dynamic_cast<StaticModel*>(*reModel)->rebuild();
390  }
391#endif /* __WIN32__ */
392  return 1;
393}
394
395/**
396 * @brief sets Fullscreen mode
397 * @param fullscreen true if fullscreen, false if windowed
398*/
399void GraphicsEngine::setFullscreen(bool fullscreen)
400{
401  if (fullscreen)
402    this->fullscreenFlag = SDL_FULLSCREEN;
403  else
404    this->fullscreenFlag = 0;
405  this->setResolution(this->resolutionX, this->resolutionY, this->bitsPerPixel);
406}
407
408void GraphicsEngine::toggleFullscreen()
409{
410  if (this->fullscreenFlag == SDL_FULLSCREEN)
411    this->fullscreenFlag = 0;
412  else
413    this->fullscreenFlag = SDL_FULLSCREEN;
414  this->setResolution(this->resolutionX, this->resolutionY, this->bitsPerPixel);
415}
416
417
418/**
419 * @brief sets the background color
420 * @param red the red part of the background
421 * @param blue the blue part of the background
422 * @param green the green part of the background
423 * @param alpha the alpha part of the background
424 */
425void GraphicsEngine::setBackgroundColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
426{
427  glClearColor(red, green, blue, alpha);
428}
429
430/**
431 * @brief Signalhandler, for when the resolution has changed
432 * @param resizeInfo SDL information about the size of the new screen size
433 */
434void GraphicsEngine::resolutionChanged(const SDL_ResizeEvent& resizeInfo)
435{
436  this->setResolution(resizeInfo.w, resizeInfo.h, this->bitsPerPixel);
437}
438
439/**
440 * @brief entering 2D Mode
441 * this is a GL-Projection-mode, that is orthogonal, for placing the font in fron of everything else
442 */
443void GraphicsEngine::enter2DMode()
444{
445  //GraphicsEngine::storeMatrices();
446  SDL_Surface *screen = SDL_GetVideoSurface();
447
448  /* Note, there may be other things you need to change,
449     depending on how you have your OpenGL state set up.
450  */
451  glPushAttrib(GL_ENABLE_BIT);
452  glDisable(GL_DEPTH_TEST);
453  glDisable(GL_CULL_FACE);
454  glDisable(GL_LIGHTING);  // will be set back when leaving 2D-mode
455
456  glMatrixMode(GL_PROJECTION);
457  glPushMatrix();
458  glLoadIdentity();
459  glOrtho(0.0, (GLdouble)screen->w, (GLdouble)screen->h, 0.0, 0.0, 1.0);
460
461  glMatrixMode(GL_MODELVIEW);
462  glPushMatrix();
463  glLoadIdentity();
464}
465
466/**
467 * @brief leaves the 2DMode again also @see Font::enter2DMode()
468 */
469void GraphicsEngine::leave2DMode()
470{
471
472  glMatrixMode(GL_MODELVIEW);
473  glPopMatrix();
474
475  glMatrixMode(GL_PROJECTION);
476  glPopMatrix();
477
478  glPopAttrib();
479}
480
481/**
482 * @brief changes to wireframe-mode.
483 */
484void GraphicsEngine::wireframe()
485{
486  glPolygonMode(GL_FRONT, GL_LINE);
487}
488
489/**
490 * @brief stores the GL_matrices
491 */
492void GraphicsEngine::storeMatrices()
493{
494  glGetDoublev(GL_PROJECTION_MATRIX, GraphicsEngine::projMat);
495  glGetDoublev(GL_MODELVIEW_MATRIX, GraphicsEngine::modMat);
496  glGetIntegerv(GL_VIEWPORT, GraphicsEngine::viewPort);
497}
498
499//! the stored ModelView Matrix.
500GLdouble GraphicsEngine::modMat[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
501//! the stored Projection Matrix
502GLdouble GraphicsEngine::projMat[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
503//! The ViewPort
504GLint GraphicsEngine::viewPort[4] = {0,0,0,0};
505
506
507
508/**
509 * @brief outputs all the Fullscreen modes.
510 */
511void GraphicsEngine::listModes()
512{
513  /* Get available fullscreen/hardware modes */
514  this->videoModes=SDL_ListModes(NULL, SDL_FULLSCREEN|SDL_HWSURFACE);
515
516  /* Check is there are any modes available */
517  if(this->videoModes == (SDL_Rect **)0)
518  {
519    PRINTF(1)("No modes available!\n");
520    exit(-1);
521  }
522
523  /* Check if our resolution is restricted */
524  if(this->videoModes == (SDL_Rect **)-1)
525  {
526    PRINTF(2)("All resolutions available.\n");
527  }
528  else
529  {
530    /* Print valid modes */
531    PRINT(0)("Available Resoulution Modes are\n");
532    for(int i = 0; this->videoModes[i]; ++i)
533      PRINT(4)(" |  %d x %d\n", this->videoModes[i]->w, this->videoModes[i]->h);
534  }
535}
536
537/**
538 * @brief checks wether a certain extension is availiable
539 * @param extension the Extension to check for (ex. GL_ARB_texture_env_dot3)
540 * @return true if it is, false otherwise
541 */
542bool GraphicsEngine::hwSupportsEXT(const std::string& extension)
543{
544  for (unsigned int i = 0; i < this->hwExtensions.size(); i++)
545    if ( this->hwExtensions.getString(i) == extension)
546      return true;
547  return false;
548}
549
550/**
551 * @brief updates everything that is to be updated in the GraphicsEngine
552 */
553void GraphicsEngine::update(float dt)
554{
555  Render2D::getInstance()->update(dt);
556}
557
558
559/**
560 * @brief ticks the Text
561 * @param dt the time passed
562 */
563void GraphicsEngine::tick(float dt)
564{
565  if( unlikely(this->bDisplayFPS))
566  {
567    this->currentFPS = 1.0/dt;
568    if( unlikely(this->currentFPS > this->maxFPS)) this->maxFPS = this->currentFPS;
569    if( unlikely(this->currentFPS < this->minFPS)) this->minFPS = this->currentFPS;
570
571#ifndef NO_TEXT
572    char tmpChar1[20];
573    sprintf(tmpChar1, "Current:  %4.0f", this->currentFPS);
574    this->geTextCFPS->setText(tmpChar1);
575    char tmpChar2[20];
576    sprintf(tmpChar2, "Max:    %4.0f", this->maxFPS);
577    this->geTextMaxFPS->setText(tmpChar2);
578    char tmpChar3[20];
579    sprintf(tmpChar3, "Min:    %4.0f", this->minFPS);
580    this->geTextMinFPS->setText(tmpChar3);
581#endif /* NO_TEXT */
582
583  }
584
585  Render2D::getInstance()->tick(dt);
586
587  // tick the graphics effects
588  if (this->graphicsEffects != NULL || (this->graphicsEffects = ClassList::getList(CL_GRAPHICS_EFFECT)) != NULL)
589  {
590    std::list<BaseObject*>::const_iterator it;
591    for (it = this->graphicsEffects->begin(); it != this->graphicsEffects->end(); it++)
592      dynamic_cast<GraphicsEffect*>(*it)->tick(dt);
593  }
594}
595
596/**
597 * @brief draws all Elements that should be displayed on the Background.
598 */
599void GraphicsEngine::drawBackgroundElements() const
600{
601  GraphicsEngine::storeMatrices();
602
603  Render2D::getInstance()->draw(E2D_LAYER_BELOW_ALL, E2D_LAYER_BELOW_ALL);
604}
605
606void GraphicsEngine::draw() const
607{
608  //  LightManager::getInstance()->draw();
609
610  if (this->graphicsEffects != NULL)
611  {
612    //draw the graphics effects
613    list<BaseObject*>::const_iterator it;
614    for (it = this->graphicsEffects->begin(); it != this->graphicsEffects->end(); it++)
615      dynamic_cast<GraphicsEffect*>(*it)->draw();
616  }
617  Shader::suspendShader();
618  Render2D::getInstance()->draw(E2D_LAYER_BOTTOM, E2D_LAYER_ABOVE_ALL);
619  Shader::restoreShader();
620}
621
622
623/**
624 * @brief displays the Frames per second
625 * @param display if the text should be displayed
626*/
627void GraphicsEngine::displayFPS(bool display)
628{
629#ifndef NO_TEXT
630  if( display )
631  {
632    if (this->geTextCFPS == NULL)
633    {
634      this->geTextCFPS = new Text("fonts/arial_black.ttf", 15);
635      this->geTextCFPS->setName("curFPS");
636      this->geTextCFPS->setAlignment(TEXT_ALIGN_LEFT);
637      this->geTextCFPS->setAbsCoor2D(5, 0);
638    }
639    if (this->geTextMaxFPS == NULL)
640    {
641      this->geTextMaxFPS = new Text("fonts/arial_black.ttf", 15);
642      this->geTextMaxFPS->setName("MaxFPS");
643      this->geTextMaxFPS->setAlignment(TEXT_ALIGN_LEFT);
644      this->geTextMaxFPS->setAbsCoor2D(5, 20);
645    }
646    if (this->geTextMinFPS == NULL)
647    {
648      this->geTextMinFPS = new Text("fonts/arial_black.ttf", 15);
649      this->geTextMinFPS->setName("MinFPS");
650      this->geTextMinFPS->setAlignment(TEXT_ALIGN_LEFT);
651      this->geTextMinFPS->setAbsCoor2D(5, 40);
652    }
653  }
654  else
655  {
656    delete this->geTextCFPS;
657    this->geTextCFPS = NULL;
658    delete this->geTextMaxFPS;
659    this->geTextMaxFPS = NULL;
660    delete this->geTextMinFPS;
661    this->geTextMinFPS = NULL;
662  }
663  this->bDisplayFPS = display;
664#else
665  this->bDisplayFPS = false;
666#endif /* NO_TEXT */
667}
668
669
670/**
671 * @brief processes the events for the GraphicsEngine class
672 * @param the event to handle
673 */
674void GraphicsEngine::process(const Event &event)
675{
676  switch (event.type)
677  {
678    case EV_VIDEO_RESIZE:
679      this->resolutionChanged(event.resize);
680      break;
681  }
682}
Note: See TracBrowser for help on using the repository browser.