FIFE  6e1afdbeda11afe9ac53e6023a4be96ef88f1dc6
glimage.cpp
Go to the documentation of this file.
1 /***************************************************************************
2  * Copyright (C) 2005-2017 by the FIFE team *
3  * http://www.fifengine.net *
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 #include <cassert>
24 #include <iostream>
25 // 3rd party library includes
26 
27 // FIFE includes
28 // These includes are split up in two parts, separated by one empty line
29 // First block: files included from the FIFE root src directory
30 // Second block: files included from the same folder
31 #include "util/structures/rect.h"
32 #include "video/imagemanager.h"
33 #include "video/sdl/sdlimage.h"
34 #include "video/renderbackend.h"
36 
37 #include "glimage.h"
38 
39 namespace FIFE {
41  Image(loader),
42  m_compressed(false),
43  m_texId(0) {
44 
45  resetGlimage();
46  }
47 
48  GLImage::GLImage(const std::string& name, IResourceLoader* loader):
49  Image(name, loader),
50  m_compressed(false),
51  m_texId(0) {
52 
53  resetGlimage();
54  }
55 
56  GLImage::GLImage(SDL_Surface* surface):
57  Image(surface),
58  m_compressed(false),
59  m_texId(0) {
60 
61  resetGlimage();
62  }
63 
64  GLImage::GLImage(const std::string& name, SDL_Surface* surface):
65  Image(name, surface),
66  m_compressed(false),
67  m_texId(0) {
68 
69  resetGlimage();
70  }
71 
72  GLImage::GLImage(const uint8_t* data, uint32_t width, uint32_t height):
73  Image(data, width, height),
74  m_compressed(false),
75  m_texId(0) {
76 
77  assert(m_surface);
78  resetGlimage();
79  }
80 
81  GLImage::GLImage(const std::string& name, const uint8_t* data, uint32_t width, uint32_t height):
82  Image(name, data, width, height),
83  m_compressed(false),
84  m_texId(0) {
85 
86  assert(m_surface);
87  resetGlimage();
88  }
89 
91  cleanup();
92  }
93 
95  resetGlimage();
96  }
97 
98  void GLImage::setSurface(SDL_Surface* surface) {
99  reset(surface);
100  resetGlimage();
101  }
102 
104  cleanup();
105 
106  m_chunk_size_w = 0;
107  m_chunk_size_h = 0;
108 
110  }
111 
113  if (m_texId) {
114  if(!m_shared) {
115  glDeleteTextures(1, &m_texId);
116  }
117  m_texId = 0;
118  m_compressed = false;
119  }
120 
121  m_tex_coords[0] = m_tex_coords[1] =
122  m_tex_coords[2] = m_tex_coords[3] = 0.0f;
123  }
124 
125  void GLImage::render(const Rect& rect, uint8_t alpha, uint8_t const* rgb) {
126  // completely transparent so dont bother rendering
127  if (0 == alpha) {
128  return;
129  }
131  SDL_Surface* target = rb->getRenderTargetSurface();
132  assert(target != m_surface); // can't draw on the source surface
133 
134  // not on the screen. dont render
135  if (rect.right() < 0 || rect.x > static_cast<int32_t>(target->w) ||
136  rect.bottom() < 0 || rect.y > static_cast<int32_t>(target->h)) {
137  return;
138  }
139  if (!m_texId) {
141  } else if (m_shared) {
142  validateShared();
143  }
144 
145  rb->addImageToArray(m_texId, rect, m_tex_coords, alpha, rgb);
146  }
147 
148  void GLImage::render(const Rect& rect, const ImagePtr& overlay, uint8_t alpha, uint8_t const* rgb) {
149  // completely transparent so dont bother rendering
150  if (0 == alpha) {
151  return;
152  }
154  SDL_Surface* target = rb->getRenderTargetSurface();
155  assert(target != m_surface); // can't draw on the source surface
156 
157  // not on the screen. dont render
158  if (rect.right() < 0 || rect.x > static_cast<int32_t>(target->w) ||
159  rect.bottom() < 0 || rect.y > static_cast<int32_t>(target->h)) {
160  return;
161  }
162  if (!m_texId) {
164  } else if (m_shared) {
165  validateShared();
166  }
167 
168  GLImage* img = static_cast<GLImage*>(overlay.get());
169  img->forceLoadInternal();
170 
171  static_cast<RenderBackendOpenGL*>(rb)->addImageToArray(rect, m_texId, m_tex_coords, img->getTexId(), img->getTexCoords(), alpha, rgb);
172  //rb->addImageToArray(rect, m_texId, m_tex_coords, img->getTexId(), img->getTexCoords(), alpha, rgb);
173  }
174 
175  void GLImage::renderZ(const Rect& rect, float vertexZ, uint8_t alpha, uint8_t const* rgb) {
176  // completely transparent so dont bother rendering
177  if (0 == alpha) {
178  return;
179  }
181  SDL_Surface* target = rb->getRenderTargetSurface();
182  assert(target != m_surface); // can't draw on the source surface
183 
184  // not on the screen. dont render
185  if (rect.right() < 0 || rect.x > static_cast<int32_t>(target->w) ||
186  rect.bottom() < 0 || rect.y > static_cast<int32_t>(target->h)) {
187  return;
188  }
189  if (!m_texId) {
191  } else if (m_shared) {
192  validateShared();
193  }
194  static_cast<RenderBackendOpenGL*>(rb)->addImageToArrayZ(m_texId, rect, vertexZ, m_tex_coords, alpha, rgb);
195  //rb->addImageToArray(m_texId, rect, m_tex_coords, alpha, rgb);
196  }
197 
198  void GLImage::renderZ(const Rect& rect, float vertexZ, const ImagePtr& overlay, uint8_t alpha, uint8_t const* rgb) {
199  // completely transparent so dont bother rendering
200  if (0 == alpha) {
201  return;
202  }
204  SDL_Surface* target = rb->getRenderTargetSurface();
205  assert(target != m_surface); // can't draw on the source surface
206 
207  // not on the screen. dont render
208  if (rect.right() < 0 || rect.x > static_cast<int32_t>(target->w) ||
209  rect.bottom() < 0 || rect.y > static_cast<int32_t>(target->h)) {
210  return;
211  }
212 
213  if (!m_texId) {
215  } else if (m_shared) {
216  validateShared();
217  }
218 
219  GLImage* img = static_cast<GLImage*>(overlay.get());
220  img->forceLoadInternal();
221 
222  static_cast<RenderBackendOpenGL*>(rb)->addImageToArrayZ(rect, vertexZ, m_texId, m_tex_coords, img->getTexId(), img->getTexCoords(), alpha, rgb);
223  //rb->addImageToArray(rect, m_texId, m_tex_coords, img->getTexId(), img->getTexCoords(), alpha, rgb);
224  }
225 
227  if (m_shared) {
228  // First make sure we loaded big image to opengl
229  validateShared();
230  return;
231  }
232  // ultimate possibility to load the image
233  // is used e.g. in case a cursor or gui image is freed even if there is a reference
234  if (!m_surface) {
236  load();
237  }
238  }
239  const uint32_t width = m_surface->w;
240  const uint32_t height = m_surface->h;
241 
242  // With OpenGL 2.0 or GL_ARB_texture_non_power_of_two we don't really need to care
243  // about non power of 2 textures
244  if(GLEW_ARB_texture_non_power_of_two && RenderBackend::instance()->isNPOTEnabled()) {
245  m_chunk_size_w = width;
246  m_chunk_size_h = height;
247  }
248  else {
249  //calculate the nearest larger power of 2
250  m_chunk_size_w = nextPow2(width);
251  m_chunk_size_h = nextPow2(height);
252  }
253 
254  // used to calculate the fill ratio for given chunk
255  m_tex_coords[0] = m_tex_coords[1] = 0.0f;
256  m_tex_coords[2] = static_cast<float>(m_surface->w%m_chunk_size_w) / static_cast<float>(m_chunk_size_w);
257  m_tex_coords[3] = static_cast<float>(m_surface->h%m_chunk_size_h) / static_cast<float>(m_chunk_size_h);
258 
259  if (m_tex_coords[2] == 0.0f){
260  m_tex_coords[2] = 1.0f;
261  }
262 
263  if (m_tex_coords[3] == 0.0f){
264  m_tex_coords[3] = 1.0f;
265  }
266 
267  uint8_t* data = static_cast<uint8_t*>(m_surface->pixels);
268  int32_t pitch = m_surface->pitch;
269 
270  assert(!m_texId);
271 
272  // get texture id from opengl
273  glGenTextures(1, &m_texId);
274  // set focus on that texture
275  static_cast<RenderBackendOpenGL*>(RenderBackend::instance())->bindTexture(m_texId);
276  // set filters for texture
277  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
278  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
279  bool mipmapping = RenderBackend::instance()->isMipmappingEnabled();
280  if (mipmapping) {
281  glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE);
282  }
283  // without mipmapping, trilinear and bilinear filters are the same
284  switch (RenderBackend::instance()->getTextureFiltering()) {
285  case TEXTURE_FILTER_NONE:
286  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
287  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, mipmapping ? GL_NEAREST_MIPMAP_NEAREST : GL_NEAREST);
288  break;
290  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
291  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, mipmapping ? GL_LINEAR_MIPMAP_NEAREST : GL_LINEAR);
292  break;
294  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
295  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, mipmapping ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR);
296  break;
298  // currently trilinear anisotropic
299  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, static_cast<GLint>(RenderBackend::instance()->getMaxAnisotropy()));
300  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
301  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, mipmapping ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR);
302  break;
303  default:
304  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
305  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, mipmapping ? GL_NEAREST_MIPMAP_NEAREST : GL_NEAREST);
306  break;
307  }
308 
309  GLint internalFormat = GL_RGBA8;
310  if(GLEW_ARB_texture_compression && RenderBackend::instance()->isImageCompressingEnabled()) {
311  internalFormat = GL_COMPRESSED_RGBA;
312  m_compressed = true;
313  } else {
314  m_compressed = false;
315  }
316 
317  bool monochrome = RenderBackend::instance()->isMonochromeEnabled();
318  SDL_Surface* target = RenderBackend::instance()->getRenderTargetSurface();
319  int32_t bpp_target = RenderBackend::instance()->getPixelFormat().BitsPerPixel;
320  int32_t bpp_source = m_surface->format->BitsPerPixel;
321  // create 16 bit texture, RGBA_4444
322  if (bpp_target == 16 && bpp_source == 32) {
323  uint16_t* oglbuffer = new uint16_t[m_chunk_size_w * m_chunk_size_h];
324  memset(oglbuffer, 0x00, m_chunk_size_w*m_chunk_size_h*sizeof(uint16_t));
325 
326  for (uint32_t y = 0; y < height; ++y) {
327  for (uint32_t x = 0; x < width; ++x) {
328  uint32_t pos = (y * pitch) + (x * 4);
329 
330  uint8_t r = data[pos + 0];
331  uint8_t g = data[pos + 1];
332  uint8_t b = data[pos + 2];
333  uint8_t a = data[pos + 3];
334 
336  // only set alpha to zero if colorkey feature is enabled
337  if (r == m_colorkey.r && g == m_colorkey.g && b == m_colorkey.b) {
338  a = 0;
339  }
340  }
341  // if monochrome rendering is enabled, then the colors are converted to grayscale
342  if (monochrome) {
343  uint8_t lum = static_cast<uint8_t>(r*0.3 + g*0.59 + b*0.11);
344  r = lum;
345  g = lum;
346  b = lum;
347  }
348  oglbuffer[(y*m_chunk_size_w) + x] = ((r >> 4) << 12) |
349  ((g >> 4) << 8) |
350  ((b >> 4) << 4) |
351  ((a >> 4) << 0);
352  }
353  }
354  // in case of compression we let OpenGL handle it
355  if (!m_compressed) {
356  internalFormat = GL_RGBA4;
357  }
358 
359  // transfer data from sdl buffer
360  glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, m_chunk_size_w, m_chunk_size_h,
361  0, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, oglbuffer);
362 
363  delete[] oglbuffer;
364  return;
365  }
366 
367  if(GLEW_ARB_texture_non_power_of_two && RenderBackend::instance()->isNPOTEnabled()) {
368  if(RenderBackend::instance()->isColorKeyEnabled()) {
369  uint8_t* oglbuffer = new uint8_t[width * height * 4];
370  memcpy(oglbuffer, data, width * height * 4 * sizeof(uint8_t));
371 
372  for (uint32_t y = 0; y < height; ++y) {
373  for (uint32_t x = 0; x < width * 4; x += 4) {
374  uint32_t gid = x + y * pitch;
375 
376  uint8_t r = oglbuffer[gid + 0];
377  uint8_t g = oglbuffer[gid + 1];
378  uint8_t b = oglbuffer[gid + 2];
379 
380  // set alpha to zero
381  if (r == m_colorkey.r && g == m_colorkey.g && b == m_colorkey.b) {
382  oglbuffer[gid + 3] = 0;
383  }
384  // if monochrome rendering is enabled, then the colors are converted to grayscale
385  if (monochrome) {
386  uint8_t lum = static_cast<uint8_t>(r*0.3 + g*0.59 + b*0.11);
387  oglbuffer[gid + 0] = lum;
388  oglbuffer[gid + 1] = lum;
389  oglbuffer[gid + 2] = lum;
390  }
391  }
392  }
393 
394  // transfer data from sdl buffer
395  glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, m_chunk_size_w, m_chunk_size_h,
396  0, GL_RGBA, GL_UNSIGNED_BYTE, oglbuffer);
397 
398  delete [] oglbuffer;
399  } else if (monochrome) {
400  uint8_t* oglbuffer = new uint8_t[width * height * 4];
401  memcpy(oglbuffer, data, width * height * 4 * sizeof(uint8_t));
402 
403  for (uint32_t y = 0; y < height; ++y) {
404  for (uint32_t x = 0; x < width * 4; x += 4) {
405  uint32_t gid = x + y * pitch;
406  // if monochrome rendering is enabled, then the colors are converted to grayscale
407  uint8_t lum = static_cast<uint8_t>(oglbuffer[gid + 0]*0.3 + oglbuffer[gid + 1]*0.59 + oglbuffer[gid + 2]*0.11);
408  oglbuffer[gid + 0] = lum;
409  oglbuffer[gid + 1] = lum;
410  oglbuffer[gid + 2] = lum;
411  }
412  }
413 
414  // transfer data from sdl buffer
415  glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, m_chunk_size_w, m_chunk_size_h,
416  0, GL_RGBA, GL_UNSIGNED_BYTE, oglbuffer);
417 
418  delete [] oglbuffer;
419  } else {
420  // transfer data directly from sdl buffer
421  glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, m_chunk_size_w, m_chunk_size_h,
422  0, GL_RGBA, GL_UNSIGNED_BYTE, data);
423  }
424  // Non power of 2 textures are not supported, we need to pad the size of texture to nearest power of 2
425  } else {
426  uint32_t* oglbuffer = new uint32_t[m_chunk_size_w * m_chunk_size_h];
427  memset(oglbuffer, 0x00, m_chunk_size_w*m_chunk_size_h*sizeof(uint32_t));
428 
429  for (uint32_t y = 0; y < height; ++y) {
430  for (uint32_t x = 0; x < width; ++x) {
431  uint32_t pos = (y * pitch) + (x * 4);
432 
433  uint8_t a = data[pos + 3];
434  uint8_t b = data[pos + 2];
435  uint8_t g = data[pos + 1];
436  uint8_t r = data[pos + 0];
437 
439  // only set alpha to zero if colorkey feature is enabled
440  if (r == m_colorkey.r && g == m_colorkey.g && b == m_colorkey.b) {
441  a = 0;
442  }
443  }
444  // if monochrome rendering is enabled, then the colors are converted to grayscale
445  if (monochrome) {
446  uint8_t lum = static_cast<uint8_t>(r*0.3 + g*0.59 + b*0.11);
447  r = lum;
448  g = lum;
449  b = lum;
450  }
451 
452  oglbuffer[(y*m_chunk_size_w) + x] = r | (g << 8) | (b << 16) | (a<<24);
453  }
454  }
455 
456  // transfer data from sdl buffer
457  glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, m_chunk_size_w, m_chunk_size_h,
458  0, GL_RGBA, GL_UNSIGNED_BYTE, static_cast<GLvoid*>(oglbuffer));
459 
460  delete[] oglbuffer;
461  }
462  }
463 
464  void GLImage::generateGLSharedTexture(const GLImage* shared, const Rect& region) {
465  uint32_t width = shared->getWidth();
466  uint32_t height = shared->getHeight();
467 
468  if(!GLEW_ARB_texture_non_power_of_two || !RenderBackend::instance()->isNPOTEnabled()) {
469  width = nextPow2(width);
470  height = nextPow2(height);
471  }
472 
473  if (RenderBackend::instance()->getTextureFiltering() != TEXTURE_FILTER_NONE || RenderBackend::instance()->isMipmappingEnabled()) {
474  // half pixel correction
475  m_tex_coords[0] = (static_cast<GLfloat>(region.x)+0.5) / static_cast<GLfloat>(width);
476  m_tex_coords[1] = (static_cast<GLfloat>(region.y)+0.5) / static_cast<GLfloat>(height);
477  m_tex_coords[2] = (static_cast<GLfloat>(region.x + region.w)-0.5) / static_cast<GLfloat>(width);
478  m_tex_coords[3] = (static_cast<GLfloat>(region.y + region.h)-0.5) / static_cast<GLfloat>(height);
479  } else {
480  m_tex_coords[0] = static_cast<GLfloat>(region.x) / static_cast<GLfloat>(width);
481  m_tex_coords[1] = static_cast<GLfloat>(region.y) / static_cast<GLfloat>(height);
482  m_tex_coords[2] = static_cast<GLfloat>(region.x + region.w) / static_cast<GLfloat>(width);
483  m_tex_coords[3] = static_cast<GLfloat>(region.y + region.h) / static_cast<GLfloat>(height);
484  }
485  }
486 
487  void GLImage::useSharedImage(const ImagePtr& shared, const Rect& region){
488  GLImage* img = static_cast<GLImage*>(shared.get());
489 
490  m_shared_img = img;
491  m_texId = img->m_texId;
492  m_shared = true;
493  m_subimagerect = region;
494  m_atlas_img = shared;
498 
499  if(m_texId) {
500  generateGLSharedTexture(img, region);
501  }
502 
504  }
505 
507  if (m_texId == 0) {
509  } else if (m_shared) {
510  validateShared();
511  }
512  }
513 
515  // if image is valid we can return
517  return;
518  }
519 
521  m_shared_img->load();
523  } else if (!m_shared_img->m_texId) {
525  }
526 
531  }
532 
533  void GLImage::copySubimage(uint32_t xoffset, uint32_t yoffset, const ImagePtr& img) {
534  Image::copySubimage(xoffset, yoffset, img);
535 
536  if(m_texId) {
537  static_cast<RenderBackendOpenGL*>(RenderBackend::instance())->bindTexture(m_texId);
538  glTexSubImage2D(GL_TEXTURE_2D, 0, xoffset, yoffset, img->getWidth(), img->getHeight(),
539  GL_RGBA, GL_UNSIGNED_BYTE, img->getSurface()->pixels);
540  }
541  }
542 
543  void GLImage::load() {
544  if (m_shared) {
545  // check atlas image
546  // if it does not exist, it is generated.
547  if (!ImageManager::instance()->exists(m_atlas_name)) {
549  GLImage* img = static_cast<GLImage*>(newAtlas.get());
550  m_atlas_img = newAtlas;
551  m_shared_img = img;
552  }
553  validateShared();
554  // check if texture ids and surfaces are identical
559  if (m_texId) {
561  }
562  }
564  } else {
565  Image::load();
566  }
567  }
568 
569  void GLImage::free() {
570  // save the image offsets
571  int32_t xshift = m_xshift;
572  int32_t yshift = m_yshift;
573  setSurface(NULL);
574  m_xshift = xshift;
575  m_yshift = yshift;
577  }
578 
579  GLuint GLImage::getTexId() const {
580  return m_texId;
581  }
582 
583  const GLfloat* GLImage::getTexCoords() const {
584  return m_tex_coords;
585  }
586 }
virtual ImagePtr create(IResourceLoader *loader=0)
Creates a blank Image but does not load it immediately.
void reset(SDL_Surface *surface)
Resets the image to default values (including the x and y shift values), frees the current surface an...
Definition: image.cpp:110
virtual void addImageToArray(uint32_t id, const Rect &rec, float const *st, uint8_t alpha, uint8_t const *rgba)=0
Add the Image data to the array.
Abstract interface for all the renderbackends.
T * get() const
allows direct access to underlying pointer
Definition: sharedptr.h:155
virtual void invalidate()
Invalidates the Image causing it to be reset or re-loaded.
Definition: glimage.cpp:94
void generateGLTexture()
Generates the GL Texture for use when rendering.
Definition: glimage.cpp:226
virtual ResourceState getState()
Definition: resource.h:70
virtual void load()
Definition: glimage.cpp:543
virtual void load()
Definition: image.cpp:124
uint32_t m_chunk_size_w
Definition: glimage.h:121
Base Class for Images.
Definition: image.h:48
int32_t m_xshift
Definition: image.h:162
SDL_Surface * m_surface
Definition: image.h:160
T h
Height of the rectangle.
Definition: rect.h:93
T x
The X Coordinate.
Definition: rect.h:84
GLfloat m_tex_coords[4]
Definition: glimage.h:85
virtual void setSurface(SDL_Surface *surface)
This frees the current suface and replaces it with the surface passed in the parameter (which can be ...
Definition: glimage.cpp:98
unsigned nextPow2(unsigned x)
Returns the next higher power of 2 based on the passed argument.
Definition: fife_math.h:293
void resetGlimage()
Resets GLImage variables.
Definition: glimage.cpp:103
GLImage(IResourceLoader *loader=0)
Definition: glimage.cpp:40
GLuint getTexId() const
Definition: glimage.cpp:579
std::string m_atlas_name
Definition: glimage.h:130
const GLfloat * getTexCoords() const
Definition: glimage.cpp:583
virtual void copySubimage(uint32_t xoffset, uint32_t yoffset, const ImagePtr &img)
Copies given image into this one with respect to given offsets.
Definition: glimage.cpp:533
virtual void useSharedImage(const ImagePtr &shared, const Rect &region)
After this call all image data will be taken from the given image and its subregion.
Definition: glimage.cpp:487
SDL_Color m_colorkey
Definition: glimage.h:124
static RenderBackend * instance()
Definition: singleton.h:84
bool isMipmappingEnabled() const
uint32_t getHeight() const
Definition: image.cpp:160
bool isColorKeyEnabled() const
Gets whether the colorkey feature is in use.
unsigned char uint8_t
Definition: core.h:38
GLuint m_texId
Holds texture ids that are used to access textures in GL rendering context.
Definition: glimage.h:105
T bottom() const
The Y coordinate of the bottom edge.
Definition: rect.h:173
SDL_Surface * getSurface()
Definition: image.h:96
virtual void copySubimage(uint32_t xoffset, uint32_t yoffset, const ImagePtr &img)
Copies given image into this one with respect to given offsets.
Definition: image.cpp:315
const SDL_Color & getColorKey() const
Gets the global colorkey setting.
virtual ~GLImage()
Definition: glimage.cpp:90
void generateGLSharedTexture(const GLImage *shared, const Rect &region)
Definition: glimage.cpp:464
virtual const std::string & getName()
Definition: resource.h:66
uint32_t getWidth() const
Definition: image.cpp:151
ResourceState m_state
Definition: resource.h:81
unsigned short uint16_t
Definition: core.h:39
T y
The Y Coordinate.
Definition: rect.h:87
Rect m_subimagerect
Definition: image.h:177
bool isMonochromeEnabled() const
GLImage * m_shared_img
Definition: glimage.h:126
T right() const
The X coordinate of the right edge.
Definition: rect.h:168
virtual void setState(const ResourceState &state)
Definition: resource.h:71
virtual void forceLoadInternal()
Forces to load the image into internal memory of GPU.
Definition: glimage.cpp:506
void cleanup()
Frees allocated memory and calls resetGlImage.
Definition: glimage.cpp:112
bool m_compressed
Definition: glimage.h:88
SDL_Surface * getRenderTargetSurface()
Returns currently attached render surface.
uint32_t m_chunk_size_h
Definition: glimage.h:122
virtual void free()
Definition: glimage.cpp:569
bool m_shared
Definition: image.h:175
Implements an Image using OpenGL.
Definition: glimage.h:55
const SDL_PixelFormat & getPixelFormat() const
Gets the current screen rgba format.
virtual void render(const Rect &rect, uint8_t alpha=255, uint8_t const *rgb=0)
Renders itself to the current render target (main screen or attached destination image) at the rectan...
Definition: glimage.cpp:125
unsigned int uint32_t
Definition: core.h:40
ImagePtr m_atlas_img
Definition: glimage.h:128
T w
Width of the rectangle.
Definition: rect.h:90
virtual void renderZ(const Rect &rect, float vertexZ, uint8_t alpha=255, uint8_t const *rgb=0)
Definition: glimage.cpp:175
The main class of the OpenGL-based renderer.
int32_t m_yshift
Definition: image.h:164
void validateShared()
Definition: glimage.cpp:514