Debian Codegraph @

engine/core/video/image.cpp

raw
1 /***************************************************************************
2 * Copyright (C) 2005-2019 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 #include <sstream>
26
27 // 3rd party library includes
28 #include <SDL.h>
29
30 // FIFE includes
31 // These includes are split up in two parts, separated by one empty line
32 // First block: files included from the FIFE root src directory
33 // Second block: files included from the same folder
34 #include "util/resource/resource.h"
35 #include "loaders/native/video/imageloader.h"
36
37 #include "image.h"
38
39 namespace FIFE {
40
41 Image::Image(IResourceLoader* loader):
42 IResource(createUniqueImageName(), loader),
43 m_surface(NULL),
44 m_xshift(0),
45 m_yshift(0),
46 m_shared(false){
47 }
48
49 Image::Image(const std::string& name, IResourceLoader* loader):
50 IResource(name, loader),
51 m_surface(NULL),
52 m_xshift(0),
53 m_yshift(0),
54 m_shared(false){
55 }
56
57 Image::Image(SDL_Surface* surface):
58 IResource(createUniqueImageName()),
59 m_surface(NULL),
60 m_xshift(0),
61 m_yshift(0),
62 m_shared(false){
63 reset(surface);
64 }
65
66 Image::Image(const std::string& name, SDL_Surface* surface):
67 IResource(name),
68 m_surface(NULL),
69 m_xshift(0),
70 m_yshift(0),
71 m_shared(false){
72 reset(surface);
73 }
74
75 //@todo make a private function to handle this
76 Image::Image(const uint8_t* data, uint32_t width, uint32_t height):
77 IResource(createUniqueImageName()),
78 m_surface(NULL),
79 m_xshift(0),
80 m_yshift(0),
81 m_shared(false){
82 SDL_Surface* surface = SDL_CreateRGBSurface(0, width,height, 32,
83 RMASK, GMASK, BMASK ,AMASK);
84 SDL_LockSurface(surface);
85
86 uint32_t size = width * height * 4;
87 uint8_t* pixeldata = static_cast<uint8_t*>(surface->pixels);
88 std::copy(data, data + size, pixeldata);
89 SDL_UnlockSurface(surface);
90 reset(surface);
91 }
92
93 Image::Image(const std::string& name, const uint8_t* data, uint32_t width, uint32_t height):
94 IResource(name),
95 m_surface(NULL),
96 m_xshift(0),
97 m_yshift(0),
98 m_shared(false) {
99 SDL_Surface* surface = SDL_CreateRGBSurface(0, width,height, 32,
100 RMASK, GMASK, BMASK ,AMASK);
101 SDL_LockSurface(surface);
102
103 uint32_t size = width * height * 4;
104 uint8_t* pixeldata = static_cast<uint8_t*>(surface->pixels);
105 std::copy(data, data + size, pixeldata);
106 SDL_UnlockSurface(surface);
107 reset(surface);
108 }
109
110 void Image::reset(SDL_Surface* surface) {
111 if( m_surface && !m_shared) {
112 SDL_FreeSurface(m_surface);
113 }
114
115 m_xshift = 0;
116 m_yshift = 0;
117 m_surface = surface;
118 }
119
120 Image::~Image() {
121 reset(NULL);
122 }
123
124 void Image::load() {
125 if (m_loader){
126 m_loader->load(this);
127 }
128 else {
129 ImageLoader loader;
130 loader.load(this);
131 }
132 m_state = IResource::RES_LOADED;
133 }
134
135 void Image::free() {
136 // save the image offsets
137 int32_t xshift = m_xshift;
138 int32_t yshift = m_yshift;
139 reset(NULL);
140 m_xshift = xshift;
141 m_yshift = yshift;
142 m_state = IResource::RES_NOT_LOADED;
143 }
144
145 SDL_Surface* Image::detachSurface() {
146 SDL_Surface* srf = m_surface;
147 m_surface = NULL;
148 return srf;
149 }
150
151 uint32_t Image::getWidth() const {
152 if (m_shared) {
153 return m_subimagerect.w;
154 } else if (!m_surface) {
155 return 0;
156 }
157 return m_surface->w;
158 }
159
160 uint32_t Image::getHeight() const {
161 if (m_shared) {
162 return m_subimagerect.h;
163 } else if (!m_surface) {
164 return 0;
165 }
166 return m_surface->h;
167 }
168
169 size_t Image::getSize() {
170 if (!m_surface || m_shared) {
171 return 0;
172 }
173 return m_surface->h * m_surface->pitch;
174 }
175
176 Rect Image::getArea() const {
177 Rect r(0, 0, getWidth(), getHeight());
178 return r;
179 }
180
181 void Image::getPixelRGBA(int32_t x, int32_t y, uint8_t* r, uint8_t* g, uint8_t* b, uint8_t* a) {
182 Uint8 *p;
183
184 assert(m_surface);
185
186 int32_t bpp = m_surface->format->BytesPerPixel;
187
188 if(!isSharedImage()) {
189 if ((x < 0) || (x >= m_surface->w) || (y < 0) || (y >= m_surface->h)) {
190 r = g = b = a = 0;
191 return;
192 }
193 p = (Uint8*)m_surface->pixels + y * m_surface->pitch + x * bpp;
194 } else {
195 if ((x < 0) || ((x + m_subimagerect.x) >= m_surface->w) || (y < 0) || ((y + m_subimagerect.y) >= m_surface->h)) {
196 r = g = b = a = 0;
197 return;
198 }
199 p = (Uint8*)m_surface->pixels + (y + m_subimagerect.y) * m_surface->pitch + (x + m_subimagerect.x) * bpp;
200 }
201
202 uint32_t pixel = 0;
203 switch(bpp) {
204 case 1:
205 pixel = *p;
206 break;
207
208 case 2:
209 pixel = *(Uint16 *)p;
210 break;
211
212 case 3:
213 if (SDL_BYTEORDER == SDL_BIG_ENDIAN) {
214 pixel = p[0] << 16 | p[1] << 8 | p[2];
215 } else {
216 pixel = p[0] | p[1] << 8 | p[2] << 16;
217 }
218 break;
219
220 case 4:
221 pixel = *(Uint32 *)p;
222 break;
223 }
224 SDL_GetRGBA(pixel, m_surface->format, r, g, b, a);
225 }
226
227 void Image::saveImage(const std::string& filename) {
228 saveAsPng(filename, *m_surface);
229 }
230
231 void Image::saveAsPng(const std::string& filename, const SDL_Surface& surface) {
232 FILE *fp;
233 png_structp pngptr;
234 png_infop infoptr;
235 int32_t colortype;
236 png_bytep *rowpointers = NULL;
237
238 fp = fopen(filename.c_str(), "wb");
239
240 if (fp == NULL) {
241 return;
242 }
243
244 //create the png file
245 pngptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,
246 NULL, NULL, NULL);
247 if (pngptr == NULL) {
248 fclose(fp);
249 return;
250 }
251
252 //create information struct
253 infoptr = png_create_info_struct(pngptr);
254 if (infoptr == NULL) {
255 fclose(fp);
256 png_destroy_write_struct(&pngptr, (png_infopp)NULL);
257 return;
258 }
259
260 if (setjmp(png_jmpbuf(pngptr))) {
261 png_destroy_write_struct(&pngptr, &infoptr);
262 fclose(fp);
263 return;
264 }
265
266 //initialize io
267 png_init_io(pngptr, fp);
268
269 // lock the surface for access (we strip it off of const but we promise not to modify it, just read)
270 SDL_LockSurface(const_cast<SDL_Surface*>(&surface));
271
272 colortype = PNG_COLOR_TYPE_RGB;
273 if(surface.format->palette){
274 colortype |= PNG_COLOR_TYPE_PALETTE;
275 }
276 else if (surface.format->Amask){
277 colortype |= PNG_COLOR_TYPE_RGB_ALPHA;
278 }
279 else{}
280
281 png_set_IHDR(pngptr, infoptr, surface.w, surface.h, 8, colortype,
282 PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
283
284 png_write_info(pngptr, infoptr);
285 png_set_packing(pngptr);
286
287 rowpointers = new png_bytep[surface.h];
288 for (int32_t i = 0; i < surface.h; i++) {
289 rowpointers[i] = (png_bytep)(Uint8 *)surface.pixels + i*surface.pitch;
290 }
291 //write the image
292 png_write_image(pngptr, rowpointers);
293 png_write_end(pngptr, infoptr);
294
295 SDL_UnlockSurface(const_cast<SDL_Surface*>(&surface));
296 delete [] rowpointers;
297 png_destroy_write_struct(&pngptr, &infoptr);
298 fclose(fp);
299 }
300
301 std::string Image::createUniqueImageName() {
302 // automated counting for name generation, in case the user doesn't provide a name
303 static uint32_t uniqueNumber = 0;
304 static std::string baseName = "image";
305
306 std::ostringstream oss;
307 oss << uniqueNumber << "_" << baseName;
308
309 const std::string name = oss.str();
310 ++uniqueNumber;
311
312 return name;
313 }
314
315 void Image::copySubimage(uint32_t xoffset, uint32_t yoffset, const ImagePtr& srcimg){
316 if (!srcimg->m_surface) {
317 return;
318 } else if (!m_surface) {
319 m_surface = SDL_CreateRGBSurface(0, srcimg->getWidth(),
320 srcimg->getHeight(), 32, RMASK, GMASK, BMASK ,AMASK);
321 }
322 // disable blending
323 SDL_SetSurfaceBlendMode(srcimg->m_surface, SDL_BLENDMODE_NONE);
324 if(this->isSharedImage()) {
325 Rect const& rect = this->getSubImageRect();
326 SDL_Rect dstrect = {
327 static_cast<Sint16>(rect.x + xoffset),
328 static_cast<Sint16>(rect.y + yoffset),
329 static_cast<Uint16>(srcimg->getWidth()),
330 static_cast<Uint16>(srcimg->getHeight()) };
331 if(srcimg->isSharedImage()) {
332 Rect const& rect = srcimg->getSubImageRect();
333 SDL_Rect srcrect = {
334 static_cast<Sint16>(rect.x),
335 static_cast<Sint16>(rect.y),
336 static_cast<Uint16>(rect.w),
337 static_cast<Uint16>(rect.h) };
338 SDL_BlitSurface(srcimg->m_surface, &srcrect, m_surface, &dstrect);
339 } else {
340 SDL_BlitSurface(srcimg->m_surface, NULL, m_surface, &dstrect);
341 }
342 } else {
343 SDL_Rect dstrect = {
344 static_cast<Sint16>(xoffset),
345 static_cast<Sint16>(yoffset),
346 static_cast<Uint16>(srcimg->getWidth()),
347 static_cast<Uint16>(srcimg->getHeight()) };
348 if(srcimg->isSharedImage()) {
349 Rect const& rect = srcimg->getSubImageRect();
350 SDL_Rect srcrect = {
351 static_cast<Sint16>(rect.x),
352 static_cast<Sint16>(rect.y),
353 static_cast<Uint16>(rect.w),
354 static_cast<Uint16>(rect.h) };
355 SDL_BlitSurface(srcimg->m_surface, &srcrect, m_surface, &dstrect);
356 } else {
357 SDL_BlitSurface(srcimg->m_surface, NULL, m_surface, &dstrect);
358 }
359 }
360 // enable blending
361 SDL_SetSurfaceBlendMode(srcimg->m_surface, SDL_BLENDMODE_BLEND);
362 }
363
364 bool Image::putPixel(SDL_Surface* surface, int32_t x, int32_t y, uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
365 if ((x < 0) || (x >= surface->w) || (y < 0) || (y >= surface->h)) {
366 return false;
367 }
368
369 int32_t bpp = surface->format->BytesPerPixel;
370 SDL_LockSurface(surface);
371 Uint8* p = (Uint8*)surface->pixels + y * surface->pitch + x * bpp;
372 Uint32 pixel = SDL_MapRGBA(surface->format, r, g, b, a);
373 switch(bpp)
374 {
375 case 1:
376 *p = pixel;
377 break;
378
379 case 2:
380 *(Uint16 *)p = pixel;
381 break;
382
383 case 3:
384 if(SDL_BYTEORDER == SDL_BIG_ENDIAN) {
385 p[0] = (pixel >> 16) & 0xff;
386 p[1] = (pixel >> 8) & 0xff;
387 p[2] = pixel & 0xff;
388 }
389 else {
390 p[0] = pixel & 0xff;
391 p[1] = (pixel >> 8) & 0xff;
392 p[2] = (pixel >> 16) & 0xff;
393 }
394 break;
395
396 case 4:
397 *(Uint32 *)p = pixel;
398 break;
399 }
400 SDL_UnlockSurface(surface);
401 return true;
402 }
403 }