Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

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

Last change on this file since 5594 was 5509, checked in by bensch, 19 years ago

orxonox/trunk: proto_world_entity-stuff

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