Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

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

Last change on this file since 5386 was 5347, checked in by bensch, 19 years ago

orxonox/trunk: building Graphics as a lib names libORXgraphics.a

File size: 15.4 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
22#include "render_2d.h"
23#include "text_engine.h"
24#include "light.h"
25#include "shader.h"
26#include "debug.h"
27
28#include "ini_parser.h"
29#include "substring.h"
30#include "text.h"
31
32using namespace std;
33
34/**
35 *  standard constructor
36 */
37GraphicsEngine::GraphicsEngine ()
38{
39  this->setClassID(CL_GRAPHICS_ENGINE, "GraphicsEngine");
40  this->setName("GraphicsEngine");
41
42  this->isInit = false;
43
44  this->bDisplayFPS = false;
45  this->minFPS = 9999;
46  this->maxFPS = 0;
47
48  this->geTextCFPS = NULL;
49  this->geTextMaxFPS = NULL;
50  this->geTextMinFPS = NULL;
51
52  this->fullscreenFlag = 0;
53  this->videoFlags = 0;
54  this->screen = NULL;
55
56
57  // Hardware
58  this->hwRenderer = NULL;
59  this->hwVendor = NULL;
60  this->hwVersion = NULL;
61  this->hwExtensions = NULL;
62
63  // initialize the TextEngine
64  TextEngine::getInstance();
65}
66
67/**
68 *  The Pointer to this GraphicsEngine
69*/
70GraphicsEngine* GraphicsEngine::singletonRef = NULL;
71
72/**
73 *  destructs the graphicsEngine.
74*/
75GraphicsEngine::~GraphicsEngine ()
76{
77  // delete what has to be deleted here
78  delete this->geTextCFPS;
79  delete this->geTextMaxFPS;
80  delete this->geTextMinFPS;
81
82  delete[] this->hwRenderer;
83  delete[] this->hwVendor;
84  delete[] this->hwVersion;
85  delete this->hwExtensions;
86
87  //TextEngine
88  delete TextEngine::getInstance();
89  // render 2D
90  delete Render2D::getInstance();
91
92  SDL_QuitSubSystem(SDL_INIT_VIDEO);
93//   if (this->screen != NULL)
94//     SDL_FreeSurface(this->screen);
95
96  GraphicsEngine::singletonRef = NULL;
97}
98
99/**
100 * initializes the GraphicsEngine with default settings.
101 */
102int GraphicsEngine::init()
103{
104  if (this->isInit)
105    return -1;
106  this->initVideo(640, 480, 16);
107}
108
109/**
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");
119  if (strchr(fullscreen, '1') || strcasestr(fullscreen, "true"))
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");
124  if (strchr(textures, '1') || strcasestr(textures, "true"))
125    this->texturesEnabled = true;
126  else
127    this->texturesEnabled = false;
128
129  // searching for a usefull resolution
130  SubString resolution(iniParser->getVar(CONFIG_NAME_RESOLUTION, CONFIG_SECTION_VIDEO, "640x480"), 'x');
131  //resolution.debug();
132
133  this->initVideo(atoi(resolution.getString(0)), atoi(resolution.getString(1)), 16);
134}
135
136
137
138/**
139 *  initializes the Video for openGL.
140 *
141 * This has to be done only once when starting orxonox.
142 */
143int GraphicsEngine::initVideo(unsigned int resX, unsigned int resY, unsigned int bbp)
144{
145  if (this->isInit)
146    return -1;
147  //   initialize SDL_VIDEO
148  if (SDL_InitSubSystem(SDL_INIT_VIDEO) == -1)
149  {
150    PRINTF(1)("could not initialize SDL Video\n");
151      //      return -1;
152  }
153  // initialize SDL_GL-settings
154  this->setGLattribs();
155
156  // setting the Video Flags.
157  this->videoFlags = SDL_OPENGL | SDL_HWPALETTE | SDL_RESIZABLE | SDL_DOUBLEBUF | SDL_GL_DOUBLEBUFFER;
158
159  /* query SDL for information about our video hardware */
160  const SDL_VideoInfo* videoInfo = SDL_GetVideoInfo ();
161  if( videoInfo == NULL)
162    {
163      PRINTF(1)("Failed getting Video Info :%s\n", SDL_GetError());
164      SDL_Quit ();
165    }
166  if( videoInfo->hw_available)
167    this->videoFlags |= SDL_HWSURFACE;
168  else
169    this->videoFlags |= SDL_SWSURFACE;
170  /*
171  if(VideoInfo -> blit_hw)
172    VideoFlags |= SDL_HWACCEL;
173  */
174    // setting up the Resolution
175  this->setResolution(resX, resY, bbp);
176
177  // GRABBING ALL GL-extensions
178  this->grabHardwareSettings();
179
180  // Enable default GL stuff
181  glEnable(GL_DEPTH_TEST);
182
183  Render2D::getInstance();
184
185  this->isInit = true;
186}
187
188/**
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{
195  SDL_Surface* iconSurf = SDL_LoadBMP(icon);
196  if (iconSurf != NULL)
197  {
198    Uint32 colorkey = SDL_MapRGB(iconSurf->format, 0, 0, 0);
199    SDL_SetColorKey(iconSurf, SDL_SRCCOLORKEY, colorkey);
200    SDL_WM_SetIcon(iconSurf,NULL);
201    SDL_FreeSurface(iconSurf);
202  }
203
204  SDL_WM_SetCaption (windowName, icon);
205
206}
207
208
209/**
210 *  Sets the GL-attributes
211 */
212int GraphicsEngine::setGLattribs()
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
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);
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
231/**
232 * grabs the Hardware Specifics
233 * checks for all the different HW-types
234 */
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));
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
279}
280
281/**
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
286 */
287int GraphicsEngine::setResolution(int width, int height, int bpp)
288{
289  this->resolutionX = width;
290  this->resolutionY = height;
291  this->bitsPerPixel = bpp;
292
293  if (this->screen != NULL)
294    SDL_FreeSurface(screen);
295  if((this->screen = SDL_SetVideoMode(this->resolutionX, this->resolutionY, this->bitsPerPixel, this->videoFlags | this->fullscreenFlag)) == NULL)
296    {
297      PRINTF(1)("Could not SDL_SetVideoMode(%d, %d, %d, %d): %s\n", this->resolutionX, this->resolutionY, this->bitsPerPixel, this->videoFlags, SDL_GetError());
298      //    SDL_Quit();
299      //    return -1;
300    }
301    glMatrixMode(GL_PROJECTION_MATRIX);
302    glLoadIdentity();
303    glViewport(0,0,width,height);                                                   // Reset The Current Viewport
304}
305
306/**
307 *  sets Fullscreen mode
308 * @param fullscreen true if fullscreen, false if windowed
309*/
310void GraphicsEngine::setFullscreen(bool fullscreen)
311{
312  if (fullscreen)
313    fullscreenFlag = SDL_FULLSCREEN;
314  else
315    fullscreenFlag = 0;
316  this->setResolution(this->resolutionX, this->resolutionY, this->bitsPerPixel);
317}
318
319/**
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
325 */
326void GraphicsEngine::setBackgroundColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
327{
328  glClearColor(red, green, blue, alpha);
329}
330
331/**
332 *  Signalhandler, for when the resolution has changed
333 * @param resizeInfo SDL information about the size of the new screen size
334 */
335int GraphicsEngine::resolutionChanged(const SDL_ResizeEvent& resizeInfo)
336{
337  this->setResolution(resizeInfo.w, resizeInfo.h, this->bitsPerPixel);
338}
339
340/**
341 * if Textures should be enabled
342*/
343bool GraphicsEngine::texturesEnabled = true;
344
345/**
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);
382   else
383     SDL_WM_GrabInput(SDL_GRAB_OFF);
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/**
400 *  entering 2D Mode
401
402   this is a GL-Projection-mode, that is orthogonal, for placing the font in fron of everything else
403*/
404void GraphicsEngine::enter2DMode()
405{
406  //GraphicsEngine::storeMatrices();
407  SDL_Surface *screen = SDL_GetVideoSurface();
408
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
416
417  glViewport(0, 0, screen->w, screen->h);
418
419  glMatrixMode(GL_PROJECTION);
420  glPushMatrix();
421  glLoadIdentity();
422
423  glOrtho(0.0, (GLdouble)screen->w, (GLdouble)screen->h, 0.0, 0.0, 1.0);
424
425  glMatrixMode(GL_MODELVIEW);
426  glPushMatrix();
427  glLoadIdentity();
428
429  glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
430}
431
432/**
433 *  leaves the 2DMode again also @see Font::enter2DMode()
434 */
435void GraphicsEngine::leave2DMode()
436{
437  glMatrixMode(GL_PROJECTION);
438  glPopMatrix();
439
440  glMatrixMode(GL_MODELVIEW);
441  glPopMatrix();
442
443  glPopAttrib();
444}
445
446/**
447 *  stores the GL_matrices
448 */
449void GraphicsEngine::storeMatrices()
450{
451  glGetDoublev(GL_PROJECTION_MATRIX, GraphicsEngine::projMat);
452  glGetDoublev(GL_MODELVIEW_MATRIX, GraphicsEngine::modMat);
453  glGetIntegerv(GL_VIEWPORT, GraphicsEngine::viewPort);
454}
455
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};
462
463
464
465/**
466 *  outputs all the Fullscreen modes.
467 */
468void GraphicsEngine::listModes()
469{
470  /* Get available fullscreen/hardware modes */
471  this->videoModes=SDL_ListModes(NULL, SDL_FULLSCREEN|SDL_HWSURFACE);
472
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  }
478
479  /* Check if our resolution is restricted */
480  if(this->videoModes == (SDL_Rect **)-1){
481    PRINTF(2)("All resolutions available.\n");
482  }
483  else{
484    /* Print valid modes */
485    PRINT(0)("Available Resoulution Modes are\n");
486    for(int i = 0; this->videoModes[i]; ++i)
487      PRINT(4)(" |  %d x %d\n", this->videoModes[i]->w, this->videoModes[i]->h);
488  }
489}
490
491/**
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/**
506 * updates everything that is to be updated in the GraphicsEngine
507 */
508void GraphicsEngine::update(float dt)
509{
510  NullElement2D::getInstance()->update2D(dt);
511}
512
513
514/**
515 *  ticks the Text
516 * @param dt the time passed
517 */
518void GraphicsEngine::tick(float dt)
519{
520  if( unlikely(this->bDisplayFPS))
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;
525
526#ifndef NO_TEXT
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);
536#endif /* NO_TEXT */
537
538
539  }
540  Render2D::getInstance()->tick(dt);
541}
542
543
544void GraphicsEngine::draw() const
545{
546  GraphicsEngine::storeMatrices();
547  Shader::suspendShader();
548  Render2D::getInstance()->draw(E2D_ALL_LAYERS);
549  Shader::restoreShader();
550  LightManager::getInstance()->draw();
551}
552
553/**
554 * displays the Frames per second
555 * @param display if the text should be displayed
556*/
557void GraphicsEngine::displayFPS(bool display)
558{
559#ifndef NO_TEXT
560  if( display )
561{
562  if (this->geTextCFPS == NULL)
563  {
564    this->geTextCFPS = new Text("fonts/arial_black.ttf", 15, TEXT_RENDER_DYNAMIC);
565    this->geTextCFPS->setName("curFPS");
566    this->geTextCFPS->setAlignment(TEXT_ALIGN_LEFT);
567    this->geTextCFPS->setAbsCoor2D(5, 15);
568  }
569  if (this->geTextMaxFPS == NULL)
570  {
571    this->geTextMaxFPS = new Text("fonts/arial_black.ttf", 15, TEXT_RENDER_DYNAMIC);
572    this->geTextMaxFPS->setName("MaxFPS");
573    this->geTextMaxFPS->setAlignment(TEXT_ALIGN_LEFT);
574    this->geTextMaxFPS->setAbsCoor2D(5, 40);
575  }
576  if (this->geTextMinFPS == NULL)
577  {
578    this->geTextMinFPS = new Text("fonts/arial_black.ttf", 15, TEXT_RENDER_DYNAMIC);
579    this->geTextMinFPS->setName("MinFPS");
580    this->geTextMinFPS->setAlignment(TEXT_ALIGN_LEFT);
581    this->geTextMinFPS->setAbsCoor2D(5, 65);
582  }
583}
584else
585{
586  delete this->geTextCFPS;
587  this->geTextCFPS = NULL;
588  delete this->geTextMaxFPS;
589  this->geTextMaxFPS = NULL;
590  delete this->geTextMinFPS;
591  this->geTextMinFPS = NULL;
592}
593  this->bDisplayFPS = display;
594#else
595  this->bDisplayFPS = false;
596#endif /* NO_TEXT */
597}
598
599
600/**
601  processes the events for the GraphicsEngine class
602* @param the event to handle
603 */
604void GraphicsEngine::process(const Event &event)
605{
606  switch (event.type)
607  {
608    case EV_VIDEO_RESIZE:
609      this->resolutionChanged(event.resize);
610      break;
611  }
612
613}
Note: See TracBrowser for help on using the repository browser.