Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

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

Last change on this file since 6774 was 6772, checked in by bensch, 19 years ago

orxonox/trunk: merged the branche network back
merged with command
svn merge https://svn.orxonox.net/orxonox/branches/network . -r6755:HEAD

absolutely no conficts

File size: 17.7 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 "resource_manager.h"
20#include "event_handler.h"
21#include "state.h"
22
23#include "world_entity.h"
24
25#include "render_2d.h"
26#include "text_engine.h"
27#include "light.h"
28#include "shader.h"
29#include "debug.h"
30
31#include "parser/ini_parser/ini_parser.h"
32#include "substring.h"
33#include "text.h"
34
35#include "globals.h"
36#include "texture.h"
37
38#include "effects/graphics_effect.h"
39#include "effects/fog_effect.h"
40
41#include "shell_command.h"
42
43#ifdef __WIN32__
44 #include "class_list.h"
45 #include "static_model.h"
46#endif
47using namespace std;
48
49SHELL_COMMAND(wireframe, GraphicsEngine, wireframe);
50
51/**
52 *  standard constructor
53 */
54GraphicsEngine::GraphicsEngine ()
55{
56  this->setClassID(CL_GRAPHICS_ENGINE, "GraphicsEngine");
57  this->setName("GraphicsEngine");
58
59  this->isInit = false;
60
61  this->bDisplayFPS = false;
62  this->minFPS = 9999;
63  this->maxFPS = 0;
64
65  this->geTextCFPS = NULL;
66  this->geTextMaxFPS = NULL;
67  this->geTextMinFPS = NULL;
68
69  this->fullscreenFlag = 0;
70  this->videoFlags = 0;
71  this->screen = NULL;
72
73
74  // Hardware
75  this->hwRenderer = NULL;
76  this->hwVendor = NULL;
77  this->hwVersion = NULL;
78  this->hwExtensions = NULL;
79
80  // initialize the TextEngine
81  TextEngine::getInstance();
82}
83
84/**
85 *  The Pointer to this GraphicsEngine
86*/
87GraphicsEngine* GraphicsEngine::singletonRef = NULL;
88
89/**
90 *  destructs the graphicsEngine.
91*/
92GraphicsEngine::~GraphicsEngine ()
93{
94  // delete what has to be deleted here
95  delete this->geTextCFPS;
96  delete this->geTextMaxFPS;
97  delete this->geTextMinFPS;
98
99  delete[] this->hwRenderer;
100  delete[] this->hwVendor;
101  delete[] this->hwVersion;
102  delete this->hwExtensions;
103
104  //TextEngine
105  delete TextEngine::getInstance();
106  // render 2D
107  delete Render2D::getInstance();
108
109  SDL_QuitSubSystem(SDL_INIT_VIDEO);
110//   if (this->screen != NULL)
111//     SDL_FreeSurface(this->screen);
112
113  GraphicsEngine::singletonRef = NULL;
114}
115
116/**
117 * initializes the GraphicsEngine with default settings.
118 */
119int GraphicsEngine::init()
120{
121  if (this->isInit)
122    return -1;
123  this->initVideo(640, 480, 16);
124}
125
126/**
127 * loads the GraphicsEngine's settings from a given ini-file and section
128 * @param iniParser the iniParser to load from
129 * @param section the Section in the ini-file to load from
130 * @returns nothing usefull
131 */
132int GraphicsEngine::initFromIniFile(IniParser* iniParser)
133{
134  // looking if we are in fullscreen-mode
135  const char* fullscreen = iniParser->getVar(CONFIG_NAME_FULLSCREEN, CONFIG_SECTION_VIDEO, "0");
136  if (strchr(fullscreen, '1') || !strcasecmp(fullscreen, "true"))
137    this->fullscreenFlag = SDL_FULLSCREEN;
138
139  // looking if we are in fullscreen-mode
140  const char* textures = iniParser->getVar(CONFIG_NAME_TEXTURES, CONFIG_SECTION_VIDEO_ADVANCED, "0");
141  if (strchr(textures, '1') || !strcasecmp(textures, "true"))
142    Texture::setTextureEnableState( true);
143  else
144    Texture::setTextureEnableState(false);
145
146  // searching for a usefull resolution
147  SubString resolution(iniParser->getVar(CONFIG_NAME_RESOLUTION, CONFIG_SECTION_VIDEO, "640x480"), 'x');
148  //resolution.debug();
149
150  this->initVideo(atoi(resolution.getString(0)), atoi(resolution.getString(1)), 16);
151
152  GraphicsEffect* fe = new FogEffect(NULL);
153  this->loadGraphicsEffect(fe);
154  fe->activate();
155  PRINTF(0)("--------------------------------------------------------------\n");
156}
157
158
159
160/**
161 *  initializes the Video for openGL.
162 *
163 * This has to be done only once when starting orxonox.
164 */
165int GraphicsEngine::initVideo(unsigned int resX, unsigned int resY, unsigned int bbp)
166{
167  if (this->isInit)
168    return -1;
169  //   initialize SDL_VIDEO
170  if (SDL_InitSubSystem(SDL_INIT_VIDEO) == -1)
171  {
172    PRINTF(1)("could not initialize SDL Video\n");
173      //      return -1;
174  }
175  // initialize SDL_GL-settings
176  this->setGLattribs();
177
178  // setting the Video Flags.
179  this->videoFlags = SDL_OPENGL | SDL_HWPALETTE | SDL_RESIZABLE | SDL_DOUBLEBUF | SDL_GL_DOUBLEBUFFER;
180
181  /* query SDL for information about our video hardware */
182  const SDL_VideoInfo* videoInfo = SDL_GetVideoInfo ();
183  if( videoInfo == NULL)
184    {
185      PRINTF(1)("Failed getting Video Info :%s\n", SDL_GetError());
186      SDL_Quit ();
187    }
188  if( videoInfo->hw_available)
189    this->videoFlags |= SDL_HWSURFACE;
190  else
191    this->videoFlags |= SDL_SWSURFACE;
192  /*
193  if(VideoInfo -> blit_hw)
194    VideoFlags |= SDL_HWACCEL;
195  */
196    // setting up the Resolution
197  this->setResolution(resX, resY, bbp);
198
199  // GRABBING ALL GL-extensions
200  this->grabHardwareSettings();
201
202  // Enable default GL stuff
203  glEnable(GL_DEPTH_TEST);
204
205  Render2D::getInstance();
206
207  this->isInit = true;
208}
209
210/**
211 * sets the Window Captions and the Name of the icon.
212 * @param windowName The name of the Window
213 * @param icon The name of the Icon on the Disc
214 */
215void GraphicsEngine::setWindowName(const char* windowName, const char* icon)
216{
217  SDL_Surface* iconSurf = SDL_LoadBMP(icon);
218  if (iconSurf != NULL)
219  {
220    Uint32 colorkey = SDL_MapRGB(iconSurf->format, 0, 0, 0);
221    SDL_SetColorKey(iconSurf, SDL_SRCCOLORKEY, colorkey);
222    SDL_WM_SetIcon(iconSurf,NULL);
223    SDL_FreeSurface(iconSurf);
224  }
225
226  SDL_WM_SetCaption (windowName, icon);
227}
228
229
230/**
231 *  Sets the GL-attributes
232 */
233int GraphicsEngine::setGLattribs()
234{
235  // Set video mode
236  // TO DO: parse arguments for settings
237  //SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5);
238  //SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 5);
239  //SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5);
240  //SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);
241
242
243  SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
244  SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, 16);
245  SDL_GL_SetAttribute( SDL_GL_STENCIL_SIZE, 0);
246  SDL_GL_SetAttribute( SDL_GL_ACCUM_RED_SIZE, 0);
247  SDL_GL_SetAttribute( SDL_GL_ACCUM_GREEN_SIZE, 0);
248  SDL_GL_SetAttribute( SDL_GL_ACCUM_BLUE_SIZE, 0);
249  SDL_GL_SetAttribute( SDL_GL_ACCUM_ALPHA_SIZE, 0);
250}
251
252/**
253 * grabs the Hardware Specifics
254 * checks for all the different HW-types
255 */
256void GraphicsEngine::grabHardwareSettings()
257{
258  const char* renderer = (const char*) glGetString(GL_RENDERER);
259  const char* vendor   = (const char*) glGetString(GL_VENDOR);
260  const char* version  = (const char*) glGetString(GL_VERSION);
261  const char* extensions = (const char*) glGetString(GL_EXTENSIONS);
262
263//  printf("%s %s %s\n %s", renderer, vendor, version, extensions);
264
265  if (this->hwRenderer == NULL && renderer != NULL)
266  {
267    this->hwRenderer = new char[strlen(renderer)+1];
268    strcpy(this->hwRenderer, renderer);
269  }
270  if (this->hwVendor == NULL && vendor != NULL)
271  {
272    this->hwVendor = new char[strlen(vendor)+1];
273    strcpy(this->hwVendor, vendor);
274  }
275  if (this->hwVersion == NULL && version != NULL)
276  {
277    this->hwVersion = new char[strlen(version)+11];
278    strcpy(this->hwVersion, version);
279  }
280
281  if (this->hwExtensions == NULL && extensions != NULL)
282    this->hwExtensions = new SubString((char*)glGetString(GL_EXTENSIONS), " \n\t,");
283
284  PRINT(4)("Running on : vendor: %s,  renderer: %s,  version:%s\n", vendor, renderer, version);
285  PRINT(4)("Extensions:\n");
286  if (this->hwExtensions != NULL)
287    for (unsigned int i = 0; i < this->hwExtensions->getCount(); i++)
288      PRINT(4)("%d: %s\n", i, this->hwExtensions->getString(i));
289
290
291  // inizializing GLEW
292  GLenum err = glewInit();
293  if (GLEW_OK != err)
294  {
295    /* Problem: glewInit failed, something is seriously wrong. */
296    PRINTF(1)("%s\n", glewGetErrorString(err));
297  }
298  PRINTF(4)("Status: Using GLEW %s\n", glewGetString(GLEW_VERSION));
299}
300
301
302/**
303 *  sets the Resolution of the Screen to display the Graphics to.
304 * @param width The width of the window
305 * @param height The height of the window
306 * @param bpp bits per pixel
307 */
308int GraphicsEngine::setResolution(int width, int height, int bpp)
309{
310  this->resolutionX = width;
311  this->resolutionY = height;
312  this->bitsPerPixel = bpp;
313  State::setResolution( width, height);
314
315  if (this->screen != NULL)
316    SDL_FreeSurface(screen);
317  if((this->screen = SDL_SetVideoMode(this->resolutionX, this->resolutionY, this->bitsPerPixel, this->videoFlags | this->fullscreenFlag)) == NULL)
318    {
319      PRINTF(1)("Could not SDL_SetVideoMode(%d, %d, %d, %d): %s\n", this->resolutionX, this->resolutionY, this->bitsPerPixel, this->videoFlags, SDL_GetError());
320      //    SDL_Quit();
321      //    return -1;
322    }
323    glMatrixMode(GL_PROJECTION_MATRIX);
324    glLoadIdentity();
325    glViewport(0, 0, width, height);                     // Reset The Current Viewport
326
327#ifdef __WIN32__
328    // REBUILDING TEXTURES (ON WINDOWS CONTEXT SWITCH)
329    const std::list<BaseObject*>* texList = ClassList::getList(CL_TEXTURE);
330    if (texList != NULL)
331    {
332      std::list<BaseObject*>::const_iterator reTex;
333      for (reTex = texList->begin(); reTex != texList->end(); reTex++)
334        dynamic_cast<Texture*>(*reTex)->rebuild();
335    }
336    // REBUILDING MODELS
337    const std::list<BaseObject*>* modelList = ClassList::getList(CL_STATIC_MODEL);
338    if (texList != NULL)
339    {
340      std::list<BaseObject*>::const_iterator reModel;
341      for (reModel = modelList->begin(); reModel != modelList->end(); reModel++)
342        dynamic_cast<StaticModel*>(*reModel)->rebuild();
343    }
344#endif /* __WIN32__ */
345}
346
347/**
348 *  sets Fullscreen mode
349 * @param fullscreen true if fullscreen, false if windowed
350*/
351void GraphicsEngine::setFullscreen(bool fullscreen)
352{
353  if (fullscreen)
354    this->fullscreenFlag = SDL_FULLSCREEN;
355  else
356    this->fullscreenFlag = 0;
357  this->setResolution(this->resolutionX, this->resolutionY, this->bitsPerPixel);
358}
359
360/**
361 *  sets the background color
362 * @param red the red part of the background
363 * @param blue the blue part of the background
364 * @param green the green part of the background
365 * @param alpha the alpha part of the background
366 */
367void GraphicsEngine::setBackgroundColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
368{
369  glClearColor(red, green, blue, alpha);
370}
371
372/**
373 *  Signalhandler, for when the resolution has changed
374 * @param resizeInfo SDL information about the size of the new screen size
375 */
376int GraphicsEngine::resolutionChanged(const SDL_ResizeEvent& resizeInfo)
377{
378  this->setResolution(resizeInfo.w, resizeInfo.h, this->bitsPerPixel);
379}
380
381/**
382 *
383 * @param show if The mouse-cursor should be visible
384 */
385void GraphicsEngine::showMouse(bool show)
386{
387  if (show)
388    SDL_ShowCursor(SDL_ENABLE);
389  else
390    SDL_ShowCursor(SDL_DISABLE);
391}
392
393/**
394 *
395 * @returns The Visinility of the mouse-cursor (true if visible, false if it is invisible)
396 */
397bool GraphicsEngine::isMouseVisible()
398{
399  if (SDL_ShowCursor(SDL_QUERY) == SDL_ENABLE)
400    return true;
401  else
402    return false;
403}
404
405/**
406 *
407 * @param steal If the Winodow-Managers Events should be stolen to this app
408 * (steals the mouse, and all WM-clicks)
409 *
410 * This only happens, if the HARD-Debug-level is set to 0,1,2, because otherwise a Segfault could
411 * result in the loss of System-controll
412 */
413void GraphicsEngine::stealWMEvents(bool steal)
414{
415#if DEBUG < 3
416   if (steal)
417     SDL_WM_GrabInput(SDL_GRAB_ON);
418   else
419     SDL_WM_GrabInput(SDL_GRAB_OFF);
420#endif
421}
422
423/**
424 *
425 * @returns true if Events are stolen from the WM, false if not.
426 */
427bool GraphicsEngine::isStealingEvents()
428{
429   if (SDL_WM_GrabInput(SDL_GRAB_QUERY) == SDL_GRAB_ON)
430     return true;
431   else
432     return false;
433};
434
435/**
436 *  entering 2D Mode
437
438   this is a GL-Projection-mode, that is orthogonal, for placing the font in fron of everything else
439*/
440void GraphicsEngine::enter2DMode()
441{
442  //GraphicsEngine::storeMatrices();
443  SDL_Surface *screen = SDL_GetVideoSurface();
444
445  /* Note, there may be other things you need to change,
446     depending on how you have your OpenGL state set up.
447  */
448  glPushAttrib(GL_ENABLE_BIT);
449  glDisable(GL_DEPTH_TEST);
450  glDisable(GL_CULL_FACE);
451  glDisable(GL_LIGHTING);  // will be set back when leaving 2D-mode
452
453  glViewport(0, 0, screen->w, screen->h);
454
455  glMatrixMode(GL_PROJECTION);
456  glPushMatrix();
457  glLoadIdentity();
458
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  glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
466}
467
468/**
469 *  leaves the 2DMode again also @see Font::enter2DMode()
470 */
471void GraphicsEngine::leave2DMode()
472{
473  glMatrixMode(GL_PROJECTION);
474  glPopMatrix();
475
476  glMatrixMode(GL_MODELVIEW);
477  glPopMatrix();
478
479  glPopAttrib();
480}
481
482void GraphicsEngine::wireframe()
483{
484  glPolygonMode(GL_FRONT, GL_LINE);
485}
486
487/**
488 *  stores the GL_matrices
489 */
490void GraphicsEngine::storeMatrices()
491{
492  glGetDoublev(GL_PROJECTION_MATRIX, GraphicsEngine::projMat);
493  glGetDoublev(GL_MODELVIEW_MATRIX, GraphicsEngine::modMat);
494  glGetIntegerv(GL_VIEWPORT, GraphicsEngine::viewPort);
495}
496
497//! the stored ModelView Matrix.
498GLdouble GraphicsEngine::modMat[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
499//! the stored Projection Matrix
500GLdouble GraphicsEngine::projMat[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
501//! The ViewPort
502GLint GraphicsEngine::viewPort[4] = {0,0,0,0};
503
504
505
506/**
507 *  outputs all the Fullscreen modes.
508 */
509void GraphicsEngine::listModes()
510{
511  /* Get available fullscreen/hardware modes */
512  this->videoModes=SDL_ListModes(NULL, SDL_FULLSCREEN|SDL_HWSURFACE);
513
514  /* Check is there are any modes available */
515  if(this->videoModes == (SDL_Rect **)0){
516    PRINTF(1)("No modes available!\n");
517    exit(-1);
518  }
519
520  /* Check if our resolution is restricted */
521  if(this->videoModes == (SDL_Rect **)-1){
522    PRINTF(2)("All resolutions available.\n");
523  }
524  else{
525    /* Print valid modes */
526    PRINT(0)("Available Resoulution Modes are\n");
527    for(int i = 0; this->videoModes[i]; ++i)
528      PRINT(4)(" |  %d x %d\n", this->videoModes[i]->w, this->videoModes[i]->h);
529  }
530}
531
532/**
533 * checks wether a certain extension is availiable
534 * @param extension the Extension to check for (ex. GL_ARB_texture_env_dot3)
535 * @return true if it is, false otherwise
536 */
537bool GraphicsEngine::hwSupportsEXT(const char* extension)
538{
539  if (this->hwExtensions != NULL)
540    for (unsigned int i = 0; i < this->hwExtensions->getCount(); i++)
541      if (!strcmp(extension, this->hwExtensions->getString(i)))
542        return true;
543  return false;
544}
545
546/**
547 * updates everything that is to be updated in the GraphicsEngine
548 */
549void GraphicsEngine::update(float dt)
550{
551  Render2D::getInstance()->update(dt);
552}
553
554
555/**
556 *  ticks the Text
557 * @param dt the time passed
558 */
559void GraphicsEngine::tick(float dt)
560{
561  if( unlikely(this->bDisplayFPS))
562  {
563    this->currentFPS = 1.0/dt;
564    if( unlikely(this->currentFPS > this->maxFPS)) this->maxFPS = this->currentFPS;
565    if( unlikely(this->currentFPS < this->minFPS)) this->minFPS = this->currentFPS;
566
567#ifndef NO_TEXT
568      char tmpChar1[20];
569      sprintf(tmpChar1, "Current:  %4.0f", this->currentFPS);
570      this->geTextCFPS->setText(tmpChar1);
571      char tmpChar2[20];
572      sprintf(tmpChar2, "Max:    %4.0f", this->maxFPS);
573      this->geTextMaxFPS->setText(tmpChar2);
574      char tmpChar3[20];
575      sprintf(tmpChar3, "Min:    %4.0f", this->minFPS);
576      this->geTextMinFPS->setText(tmpChar3);
577#endif /* NO_TEXT */
578
579
580  }
581  Render2D::getInstance()->tick(dt);
582}
583
584
585void GraphicsEngine::draw() const
586{
587  LightManager::getInstance()->draw();
588  GraphicsEngine::storeMatrices();
589  Shader::suspendShader();
590
591  Render2D::getInstance()->draw(E2D_LAYER_ALL);
592  Shader::restoreShader();
593}
594
595void GraphicsEngine::draw(const std::list<WorldEntity*>& drawList ) const
596{
597  std::list<WorldEntity*>::const_iterator entity;
598  for (entity = drawList.begin(); entity != drawList.end(); entity++)
599    if ((*entity)->isVisible())
600      (*entity)->draw();
601}
602
603
604/**
605 * 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}
635else
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  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}
664
665
666/**
667 * loads a GraphicsEffect into the engine
668 * @param effect the GraphicsEffect to add
669 */
670bool GraphicsEngine::loadGraphicsEffect(GraphicsEffect* effect)
671{
672  list<GraphicsEffect*>::iterator it;
673  for (it = this->graphicsEffects.begin(); it != this->graphicsEffects.end(); it++)
674    if( (*it) == effect)
675      return false;
676
677  this->graphicsEffects.push_back(effect);
678
679  return true;
680}
681
682
683/**
684 * unloads a GraphicsEffect from the engine
685 * @param effect the GraphicsEffect to remove
686 */
687bool GraphicsEngine::unloadGraphicsEffect(GraphicsEffect* effect)
688{
689  list<GraphicsEffect*>::iterator it;
690  for (it = this->graphicsEffects.begin(); it != this->graphicsEffects.end(); it++)
691  {
692    if( (*it) == effect)
693    {
694      this->graphicsEffects.erase(it);
695      return true;
696    }
697  }
698
699  return false;
700}
701
Note: See TracBrowser for help on using the repository browser.