FIFE  2008.0
 All Classes Namespaces Functions Variables Enumerations Enumerator Pages
renderbackendopengl.cpp
1 /***************************************************************************
2  * Copyright (C) 2005-2008 by the FIFE team *
3  * http://www.fifengine.de *
4  * This file is part of FIFE. *
5  * *
6  * FIFE is free software; you can redistribute it and/or *
7  * modify it under the terms of the GNU Lesser General Public *
8  * License as published by the Free Software Foundation; either *
9  * version 2.1 of the License, or (at your option) any later version. *
10  * *
11  * This library is distributed in the hope that it will be useful, *
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of *
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
14  * Lesser General Public License for more details. *
15  * *
16  * You should have received a copy of the GNU Lesser General Public *
17  * License along with this library; if not, write to the *
18  * Free Software Foundation, Inc., *
19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA *
20  ***************************************************************************/
21 
22 // Standard C++ library includes
23 
24 // Platform specific includes
25 
26 // 3rd party library includes
27 #include <SDL.h>
28 
29 // FIFE includes
30 #include "util/base/exception.h"
31 #include "util/log/logger.h"
32 #include "video/devicecaps.h"
33 
34 #include "fife_opengl.h"
35 #include "glimage.h"
36 #include "renderbackendopengl.h"
37 #include "SDL_image.h"
38 
39 
40 namespace FIFE {
41  static Logger _log(LM_VIDEO);
42 
43  RenderBackendOpenGL::RenderBackendOpenGL(const SDL_Color& colorkey) : RenderBackend(colorkey) {
44  // Get the pixelformat we want.
45  SDL_Surface* testsurface = SDL_CreateRGBSurface(SDL_SWSURFACE | SDL_SRCALPHA, 1, 1, 32,
46  RMASK, GMASK, BMASK ,AMASK);
47 
48  m_rgba_format = *(testsurface->format);
49  SDL_FreeSurface(testsurface);
50  m_lightmodel = 0;
51  m_light_enabled = false;
52  m_stencil_enabled = false;
53  m_alpha_enabled = false;
54  m_sten_ref = 0;
55  m_sten_buf = 0;
56  m_sten_op = 0;
57  m_sten_func = 0;
58  m_blend_src = GL_SRC_ALPHA;
59  m_blend_dst = GL_ONE_MINUS_SRC_ALPHA;
60  }
61 
62  const std::string& RenderBackendOpenGL::getName() const {
63  static std::string backend_name = "OpenGL";
64  return backend_name;
65  }
66 
67  RenderBackendOpenGL::~RenderBackendOpenGL() {
68  }
69 
70 
71  void RenderBackendOpenGL::init(const std::string& driver) {
72 
73  //note: driver has no affect on the opengl renderer so do nothing with it here.
74 
75  Uint32 flags = SDL_INIT_VIDEO;
76  if (SDL_InitSubSystem(flags) < 0)
77  throw SDLException(SDL_GetError());
78  SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
79  SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
80 
81  SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL); // temporary hack
82 
83  }
84 
86  GLDisable flag(GL_SCISSOR_TEST);
87  glClear(GL_COLOR_BUFFER_BIT);
88  }
89 
90  Image* RenderBackendOpenGL::createMainScreen(const ScreenMode& mode, const std::string& title, const std::string& icon){
91  if(icon != "") {
92  SDL_Surface *img = IMG_Load(icon.c_str());
93  if(img != NULL) {
94  SDL_WM_SetIcon(img, 0);
95  }
96  }
97 
98  Image *image = setScreenMode(mode);
99 
100  SDL_WM_SetCaption(title.c_str(), 0);
101 
102  return image;
103  }
104 
105  Image* RenderBackendOpenGL::setScreenMode(const ScreenMode& mode) {
106  uint16_t width = mode.getWidth();
107  uint16_t height = mode.getHeight();
108  uint16_t bitsPerPixel = mode.getBPP();
109  bool fs = mode.isFullScreen();
110  uint32_t flags = mode.getSDLFlags();
111 
112  SDL_Surface* screen = NULL;
113 
114  if (bitsPerPixel != 0) {
115  uint16_t bpp = SDL_VideoModeOK(width, height, bitsPerPixel, flags);
116  if (!bpp){
117  throw SDLException("Selected video mode not supported!");
118  }
119  }
120 
121  screen = SDL_SetVideoMode(width, height, bitsPerPixel, flags);
122  if( !screen ) {
123  throw SDLException("Unable to set video mode selected!");
124  }
125 
126  FL_LOG(_log, LMsg("RenderBackendOpenGL")
127  << "Videomode " << width << "x" << height
128  << " at " << int(bitsPerPixel) << " bpp");
129 
130  //update the screen mode with the actual flags used
131  m_screenMode = ScreenMode(width,
132  height,
133  bitsPerPixel,
134  screen->flags);
135 
136 
137  if (!screen) {
138  throw SDLException(SDL_GetError());
139  }
140 
141  glViewport(0, 0, width, height);
142  glMatrixMode(GL_PROJECTION);
143  gluOrtho2D(0, width, height, 0);
144  glMatrixMode(GL_MODELVIEW);
145 
146  glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
147 
148  glEnable(GL_TEXTURE_2D);
149  glEnable(GL_BLEND);
150  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
151 
152  glEnable(GL_SCISSOR_TEST);
153 
154  glPointSize(1.0);
155  glLineWidth(1.0);
156  delete m_screen;
157  delete m_screen;
158  m_screen = new GLImage(screen);
159  return m_screen;
160  }
161 
162 
164  }
165 
167  SDL_GL_SwapBuffers();
168  }
169 
170  Image* RenderBackendOpenGL::createImage(SDL_Surface* surface) {
171  // Given an abritary surface, we must convert it to the format GLImage will understand.
172  // It's easiest to let SDL do this for us.
173 
174  // Uh. Gotta love this :-)
175  // Check for colorkey too?
176  // Leave out the loss/shift checks?
177  if( m_rgba_format.BitsPerPixel == surface->format->BitsPerPixel
178  && m_rgba_format.Rmask == surface->format->Rmask
179  && m_rgba_format.Gmask == surface->format->Gmask
180  && m_rgba_format.Bmask == surface->format->Bmask
181  && m_rgba_format.Amask == surface->format->Amask
182  && m_rgba_format.Rshift == surface->format->Rshift
183  && m_rgba_format.Gshift == surface->format->Gshift
184  && m_rgba_format.Bshift == surface->format->Bshift
185  && m_rgba_format.Ashift == surface->format->Ashift
186  && m_rgba_format.Rloss == surface->format->Rloss
187  && m_rgba_format.Gloss == surface->format->Gloss
188  && m_rgba_format.Bloss == surface->format->Bloss
189  && m_rgba_format.Aloss == surface->format->Aloss
190  && surface->flags & SDL_SRCALPHA ) {
191 
192  return new GLImage(surface);
193  }
194 
195  SDL_Surface* conv = SDL_ConvertSurface(surface, &m_rgba_format, SDL_SWSURFACE | SDL_SRCALPHA);
196  GLImage* image = new GLImage(conv);
197  SDL_FreeSurface( surface );
198  return image;
199  }
200 
201  Image* RenderBackendOpenGL::createImage(const uint8_t* data, unsigned int width, unsigned int height) {
202  return new GLImage(data, width, height);
203  }
204 
205  void RenderBackendOpenGL::setLightingModel(unsigned int lighting) {
206  if (m_lightmodel != lighting) {
207  if (m_lightmodel == 1) {
208  disableLighting();
209  glDisable(GL_COLOR_MATERIAL);
210  } else if (lighting == 1) {
211  enableLighting();
212  glEnable(GL_LIGHT0);
213  glColorMaterial(GL_FRONT, GL_DIFFUSE);
214  glEnable(GL_COLOR_MATERIAL);
215  }
216  m_lightmodel = lighting;
217  }
218  }
219 
221  return m_lightmodel;
222  }
223 
225  if (m_lightmodel == 1 && !m_light_enabled) {
226  glEnable(GL_LIGHTING);
227  m_light_enabled = true;
228  }
229  }
230 
232  if (m_lightmodel == 1 && m_light_enabled) {
233  glDisable(GL_LIGHTING);
234  m_light_enabled = false;
235  }
236  }
237 
238  void RenderBackendOpenGL::setLighting(float red, float green, float blue, float alpha) {
239  if (m_lightmodel == 1) {
240  GLfloat lightDiffuse[] = {red, green, blue, alpha};
241  glLightfv(GL_LIGHT0, GL_DIFFUSE, lightDiffuse);
242  } else if(m_lightmodel == 2) {
243  m_lred = red;
244  m_lgreen = green;
245  m_lblue = blue;
246  m_lalpha = alpha;
247  }
248  }
249 
251  if (m_lightmodel == 1) {
252  setLighting(1.0, 1.0, 1.0, 1.0);
253  } else if (m_lightmodel == 2 && m_lalpha > 0.01) {
254  uint16_t width = getScreenWidth();
255  uint16_t height = getScreenHeight();
256  Point p = Point(0,0);
257  setStencilTest(0, 0, 5);
258  fillRectangle(p, width, height, m_lred*255, m_lgreen*255, m_lblue*255, m_lalpha*255);
260  }
261  }
262 
264  if (!m_stencil_enabled) {
265  glEnable(GL_STENCIL_TEST);
266  m_stencil_enabled = true;
267  }
268  }
269 
271  if (m_stencil_enabled) {
272  glDisable(GL_STENCIL_TEST);
273  m_stencil_enabled = false;
274  }
275  }
276 
277  void RenderBackendOpenGL::setStencilTest(uint8_t stencil_ref, unsigned int stencil_op, unsigned int stencil_func) {
279  if(m_sten_op != stencil_op) {
280  GLenum op;
281  m_sten_op = stencil_op;
282  switch(stencil_op) {
283  default :
284  case 0 : op = GL_KEEP; break;
285  case 1 : op = GL_ZERO; break;
286  case 2 : op = GL_REPLACE; break;
287  case 3 : op = GL_INCR; break;
288  case 4 : op = GL_DECR; break;
289  case 5 : op = GL_INVERT; break;
290  }
291  glStencilOp(GL_KEEP, GL_KEEP, op);
292  }
293 
294  if(m_sten_ref != stencil_ref || m_sten_func != stencil_func) {
295  GLenum func;
296  m_sten_ref = stencil_ref;
297  m_sten_func = stencil_func;
298  switch(stencil_func) {
299  default :
300  case 0 : func = GL_NEVER; break;
301  case 1 : func = GL_LESS; break;
302  case 2 : func = GL_LEQUAL; break;
303  case 3 : func = GL_GREATER; break;
304  case 4 : func = GL_GEQUAL; break;
305  case 5 : func = GL_EQUAL; break;
306  case 6 : func = GL_NOTEQUAL; break;
307  case 7 : func = GL_ALWAYS; break;
308  }
309  glStencilFunc(func, stencil_ref, 0xff);
310  }
311  }
312 
313  void RenderBackendOpenGL::resetStencilBuffer(uint8_t buffer) {
314  if (buffer != m_sten_buf) {
315  m_sten_buf = buffer;
316  glClearStencil(buffer);
317  }
318  GLDisable flag(GL_SCISSOR_TEST);
319  glClear(GL_STENCIL_BUFFER_BIT);
320  }
321 
323  return m_sten_ref;
324  }
325 
327  if (!m_alpha_enabled) {
328  glEnable(GL_ALPHA_TEST);
329  m_alpha_enabled = true;
330  }
331  }
332 
334  if (m_alpha_enabled) {
335  glDisable(GL_ALPHA_TEST);
336  m_alpha_enabled = false;
337  }
338  }
339 
340  void RenderBackendOpenGL::setAlphaTest(float ref_alpha) {
341  enableAlphaTest();
342  glAlphaFunc(GL_GREATER, ref_alpha);
343  }
344 
345  void RenderBackendOpenGL::changeBlending(int src, int dst) {
346  GLenum src_fact;
347  GLenum dst_fact;
348 
349  switch(src) {
350  case 0 : src_fact = GL_ZERO; break;
351  case 1 : src_fact = GL_ONE; break;
352  case 2 : src_fact = GL_DST_COLOR; break;
353  case 3 : src_fact = GL_ONE_MINUS_DST_COLOR; break;
354  case 4 : src_fact = GL_SRC_ALPHA; break;
355  case 5 : src_fact = GL_ONE_MINUS_SRC_ALPHA; break;
356  case 6 : src_fact = GL_DST_ALPHA; break;
357  case 7 : src_fact = GL_ONE_MINUS_DST_ALPHA; break;
358 
359  default : src_fact = GL_DST_COLOR; break;
360  }
361 
362  switch(dst) {
363  case 0 : dst_fact = GL_ZERO; break;
364  case 1 : dst_fact = GL_ONE; break;
365  case 2 : dst_fact = GL_SRC_COLOR; break;
366  case 3 : dst_fact = GL_ONE_MINUS_SRC_COLOR; break;
367  case 4 : dst_fact = GL_SRC_ALPHA; break;
368  case 5 : dst_fact = GL_ONE_MINUS_SRC_ALPHA; break;
369  case 6 : dst_fact = GL_DST_ALPHA; break;
370  case 7 : dst_fact = GL_ONE_MINUS_DST_ALPHA; break;
371 
372  default : dst_fact = GL_SRC_ALPHA; break;
373  }
374 
375  if (m_blend_src != src_fact || m_blend_dst != dst_fact) {
376  m_blend_src = src_fact;
377  m_blend_dst = dst_fact;
378  glBlendFunc(src_fact, dst_fact);
379  }
380  }
381 
382  bool RenderBackendOpenGL::putPixel(int x, int y, int r, int g, int b, int a) {
383  if ((x < 0) || (x >= (int)getWidth()) || (y < 0) || (y >= (int)getHeight())) {
384  return false;
385  }
386 
387  glColor4ub(r, g, b, a);
388 
389  glBegin(GL_POINTS);
390  glVertex2i(x, y);
391  glEnd();
392  return true;
393  }
394 
395  void RenderBackendOpenGL::drawLine(const Point& p1, const Point& p2, int r, int g, int b, int a) {
396  glColor4ub(r, g, b, a);
397 
398  glBegin(GL_LINES);
399  glVertex2f(p1.x+0.5f, p1.y+0.5f);
400  glVertex2f(p2.x+0.5f, p2.y+0.5f);
401  glEnd();
402 
403  glBegin(GL_POINTS);
404  glVertex2f(p2.x+0.5f, p2.y+0.5f);
405  glEnd();
406  }
407 
408  void RenderBackendOpenGL::drawTriangle(const Point& p1, const Point& p2, const Point& p3, int r, int g, int b, int a) {
409  glColor4ub(r, g, b, a);
410 
411  glBegin(GL_TRIANGLES);
412  glVertex2f(p1.x, p1.y);
413  glVertex2f(p2.x, p2.y);
414  glVertex2f(p3.x, p3.y);
415  glEnd();
416  }
417 
418  void RenderBackendOpenGL::drawRectangle(const Point& p, uint16_t w, uint16_t h, uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
419  glColor4ub(r, g, b, a);
420 
421  glBegin(GL_LINE_LOOP);
422  glVertex2f(p.x, p.y);
423  glVertex2f(p.x+w, p.y);
424  glVertex2f(p.x+w, p.y+h);
425  glVertex2f(p.x, p.y+h);
426  glEnd();
427  }
428 
429  void RenderBackendOpenGL::fillRectangle(const Point& p, uint16_t w, uint16_t h, uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
430  glColor4ub(r, g, b, a);
431 
432  glBegin(GL_QUADS);
433  glVertex2f(p.x, p.y);
434  glVertex2f(p.x+w, p.y);
435  glVertex2f(p.x+w, p.y+h);
436  glVertex2f(p.x, p.y+h);
437  glEnd();
438  }
439 
440  void RenderBackendOpenGL::drawQuad(const Point& p1, const Point& p2, const Point& p3, const Point& p4, int r, int g, int b, int a) {
441  glColor4ub(r, g, b, a);
442 
443  glBegin(GL_QUADS);
444  glVertex2f(p1.x, p1.y);
445  glVertex2f(p2.x, p2.y);
446  glVertex2f(p3.x, p3.y);
447  glVertex2f(p4.x, p4.y);
448  glEnd();
449  }
450 
451  void RenderBackendOpenGL::drawVertex(const Point& p, const uint8_t size, int r, int g, int b, int a){
452  GLfloat width;
453  glGetFloatv(GL_LINE_WIDTH, &width);
454  glLineWidth(1.0);
455 
456  glColor4ub(r, g, b, a);
457 
458  glBegin(GL_LINE_LOOP);
459  glVertex2f(p.x-size, p.y+size);
460  glVertex2f(p.x+size, p.y+size);
461  glVertex2f(p.x+size, p.y-size);
462  glVertex2f(p.x-size, p.y-size);
463  glEnd();
464 
465  glLineWidth(width);
466  }
467 
468  void RenderBackendOpenGL::drawLightPrimitive(const Point& p, uint8_t intensity, float radius, int subdivisions, float xstretch, float ystretch, uint8_t red, uint8_t green, uint8_t blue) {
469  glBegin(GL_TRIANGLE_FAN);
470  glColor4ub(red, green, blue, intensity);
471  glVertex2f(p.x, p.y);
472  if (m_lightmodel == 2) {
473  glColor4ub(0, 0, 0, intensity);
474  } else {
475  glColor4ub(0, 0, 0, 255);
476  }
477  for(float angle=0; angle<=Mathf::twoPi(); angle+=(Mathf::twoPi()/subdivisions)){
478  glVertex2f( radius*Mathf::Cos(angle)*xstretch + p.x,
479  radius*Mathf::Sin(angle)*ystretch + p.y);
480  }
481  glVertex2f(p.x+radius*xstretch, p.y);
482  glEnd();
483  }
484 }