Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: orxonox.OLD/branches/water/src/lib/graphics/graphics_engine.cc @ 8156

Last change on this file since 8156 was 7919, checked in by bensch, 19 years ago

orxonox/trunk: merged the gui branche back
merged with command:
https://svn.orxonox.net/orxonox/branches/gui
no conflicts

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