src/client/image.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <assert.h>
   4
   5 #include "main.h"
   6 #include "list.h"
   7 #include "storage.h"
   8
   9 #include "interface.h"
  10 #include "image.h"
  11
  12 static list_t *listStorage;
  13
  14 static bool_t isImageDataInit = FALSE;
  15
  16 bool_t image_is_inicialized()
  17 {
  18         return isImageDataInit;
  19 }
  20
  21 /*
  22  * Initialization of global list of images
  23  */
  24 void image_init()
  25 {
  26         assert(interface_is_inicialized() == TRUE);
  27
  28         debug("Initializing image database");
  29
  30         listStorage = storage_new();
  31         isImageDataInit = TRUE;
  32 }
  33
  34 static SDL_Surface *loadImage(const char *filename, int alpha)
  35 {
  36         SDL_Surface *tmp;
  37         SDL_Surface *ret;
  38
  39         char str[STR_PATH_SIZE];
  40
  41         if (isFillPath(filename)) {
  42                 strcpy(str, filename);
  43         } else {
  44                 sprintf(str, PATH_IMAGE "%s", filename);
  45         }
  46
  47         accessExistFile(str);
  48
  49         if ((tmp = IMG_Load(str)) == NULL) {
  50                 error("SDL: %s", SDL_GetError());
  51                 return NULL;
  52         }
  53
  54         if ((ret = (alpha) ? SDL_DisplayFormatAlpha(tmp) : SDL_DisplayFormat(tmp)) == NULL) {
  55                 error("SDL: %s", SDL_GetError());
  56                 SDL_FreeSurface(tmp);
  57                 return NULL;
  58         }
  59
  60         SDL_FreeSurface(tmp);
  61         return ret;
  62 }
  63
  64
  65 image_t *image_new_sdl(SDL_Surface *surface)
  66 {
  67         image_t *new;
  68
  69         assert(surface != NULL);
  70
  71         new = malloc(sizeof(image_t));
  72         new->image = surface;
  73         new->w = surface->w;
  74         new->h = surface->h;
  75
  76         return new;
  77 }
  78
  79 #ifdef SUPPORT_OPENGL
  80 /*
  81  * returns closest bigger power of 2 to i
  82  */
  83 unsigned int closestpoweroftwo(unsigned int i)
  84 {
  85         int p;
  86         p=0;
  87         while (i) {
  88                 i = i >> 1;
  89                 p++;
  90         }
  91         return 1 << (p - 0);
  92 }
  93
  94 /* convert from SDL_Surface to image_t
  95  * WARNING: image_new is indestructive to surface, caller is responsible for freeing surface
  96  * surface is not needed for image_t after execution of image_new
  97  */
  98
  99 image_t *image_new_opengl(SDL_Surface *surface)
 100 {
 101         image_t *new;
 102         Uint32 rmask, gmask, bmask, amask;
 103         SDL_Surface *sdl_rgba_surface;
 104         unsigned int bpp;
 105
 106         /* it is unoptimal to blit to buffer surface before actual loading to opengl texture but it is safer and simpler to implement */
 107         /* it is unoptimal to always use RGBA texture */
 108
 109         /* we set properties of our buffer sdl_rgba_surface */
 110         rmask = 0x000000ff;
 111         gmask = 0x0000ff00;
 112         bmask = 0x00ff0000;
 113         amask = 0xff000000;
 114         bpp = 32;               /* bits per pixel */
 115
 116         assert(surface != NULL);
 117
 118         new = malloc(sizeof(image_t));
 119         new->w = surface->w;
 120         new->h = surface->h;
 121
 122         /* because some older hw is really slow when using textures with width and height which is not a power of two */
 123         new->tw = closestpoweroftwo(new->w);
 124         new->th = closestpoweroftwo(new->h);
 125
 126         sdl_rgba_surface = SDL_CreateRGBSurface(SDL_SWSURFACE, new->tw, new->th, bpp,  rmask, gmask, bmask, amask);
 127
 128         SDL_SetAlpha(surface, 0, SDL_ALPHA_OPAQUE);     /* we unset SDL_SRCALPHA to preserve alpha channel of original image */
 129         SDL_BlitSurface(surface, 0, sdl_rgba_surface, 0);
 130
 131         SDL_LockSurface(sdl_rgba_surface);              /* we ensure that we can read pixels from sdl_rgba_surface */
 132
 133         GLuint tid;
 134         glGenTextures(1, &tid);                         /* we ask for free texture id */
 135         glBindTexture(GL_TEXTURE_2D, tid);
 136         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);       /* scale linearly when image bigger than texture */
 137         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);       /* scale linearly when image smalled than texture */
 138         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, new->tw, new->th, 0, GL_RGBA, GL_UNSIGNED_BYTE, sdl_rgba_surface->pixels);
 139         SDL_UnlockSurface(sdl_rgba_surface);
 140         SDL_FreeSurface(sdl_rgba_surface);
 141
 142         new->tex_id = tid;
 143
 144         SDL_FreeSurface(surface);
 145
 146         return new;
 147 }
 148 #endif /* SUPPORT_OPENGL */
 149
 150 image_t *image_new(SDL_Surface *surface)
 151 {
 152 #ifdef SUPPORT_OPENGL
 153         if (interface_is_use_open_gl()) {
 154                 return image_new_opengl(surface);
 155         } else {
 156                 return image_new_sdl(surface);
 157         }
 158 #else /* SUPPORT_OPENGL */
 159         return image_new_sdl(surface);
 160 #endif /* SUPPORT_OPENGL */
 161 }
 162
 163 void image_destroy(image_t *p)
 164 {
 165         assert(p != NULL);
 166
 167 #ifndef SUPPORT_OPENGL
 168         SDL_FreeSurface((SDL_Surface *) p->image);
 169 #else /* SUPPORT_OPENGL */
 170         if (interface_is_use_open_gl()) {
 171                 glDeleteTextures(1, &p->tex_id);
 172         } else {
 173                 SDL_FreeSurface((SDL_Surface *) p->image);
 174         }
 175 #endif /* SUPPORT_OPENGL */
 176
 177         free(p);
 178 }
 179
 180 /*
 181  * Adds an image to the global image list
 182  * *file - name of the image file
 183  * *name - name of the image (is used for searching in the list)
 184  * alpha - [0] without alpha channel; [1] with alpha channel
 185  */
 186 image_t *image_add(char *file, int alpha, char *name, char *group)
 187 {
 188         SDL_Surface *surface;
 189         image_t *new;
 190
 191         assert(file != NULL);
 192         assert(name != NULL);
 193         assert(group != NULL);
 194
 195         surface = loadImage(file, alpha);
 196         new = image_new(surface);
 197
 198         storage_add(listStorage, group, name, new);
 199
 200         debug("Loading image [%s]", file);
 201
 202         return new;
 203 }
 204
 205 /*
 206  * Returns pointer to image with name *name in the global image list
 207  */
 208 image_t *image_get(char *group, char *name)
 209 {
 210         assert(group != NULL);
 211         assert(name != NULL);
 212
 213         return storage_get(listStorage, group, name);
 214 }
 215
 216 void image_del(char *group, char *name)
 217 {
 218         assert(group != NULL);
 219         assert(name != NULL);
 220
 221         storage_del(listStorage, group, name, image_destroy);
 222 }
 223
 224 void image_del_all_image_in_group(char *group)
 225 {
 226         assert(group != NULL);
 227
 228         storage_del_all(listStorage, group, image_destroy);
 229 }
 230
 231 void image_draw_sdl(image_t *p, int x, int y, int px, int py, int w, int h)
 232 {
 233         static SDL_Surface *screen = NULL;
 234         SDL_Rect dst_rect, src_rect;
 235
 236         if (screen == NULL) {
 237                 screen = interface_get_screen();
 238         }
 239
 240         dst_rect.x = x;
 241         dst_rect.y = y;
 242
 243         src_rect.x = px;
 244         src_rect.y = py;
 245         src_rect.w = w;
 246         src_rect.h = h;
 247
 248         SDL_BlitSurface(p->image, &src_rect, screen, &dst_rect);
 249 }
 250
 251 #ifdef SUPPORT_OPENGL
 252 /*
 253  * Draws image on screen at [x,y], with width w and height h, top-left corner on image is at [px,py]
 254  */
 255 void image_draw_opengl(image_t *image, int x,int y, int px, int py, int w, int h)
 256 {
 257         /* x - coordinate of left border; xx - coordinate of right border
 258          * y - coordinate of top border; yy - coordinate of bottom border
 259          * t - texture space; d - screen space
 260          */
 261         float t_x, t_y, t_xx, t_yy;
 262         float d_x, d_y, d_xx, d_yy;
 263
 264         /* screen space */
 265         d_x = x;
 266         d_y = y;
 267         d_xx = x+w;
 268         d_yy = y+h;
 269
 270         /* texture space (remember that texture space is from 0.0  to 1.0) */
 271         t_x = px / (float) image->tw;
 272         t_y = py / (float) image->th;
 273         t_xx = (px+w) / (float) image->tw;
 274         t_yy = (py+h) / (float) image->th;
 275
 276         glBindTexture(GL_TEXTURE_2D, image->tex_id);
 277
 278         /*
 279          * 2--4
 280          * |\ |
 281          * | \|
 282          * 1--3
 283          */
 284         glBegin(GL_TRIANGLE_STRIP);
 285                 /* 1 */
 286                 glTexCoord2f(t_x,t_yy);
 287                 glVertex2f(d_x, d_yy);
 288                 /* 2 */
 289                 glTexCoord2f(t_x, t_y);
 290                 glVertex2f(d_x, d_y);
 291                 /* 3 */
 292                 glTexCoord2f(t_xx, t_yy);
 293                 glVertex2f(d_xx, d_yy);
 294                 /* 4 */
 295                 glTexCoord2f(t_xx,t_y);
 296                 glVertex2f(d_xx, d_y);
 297         glEnd();
 298 }
 299 #endif /* SUPPORT_OPENGL */
 300
 301 void image_draw(image_t *image, int x,int y, int px, int py, int w, int h)
 302 {
 303 #ifdef SUPPORT_OPENGL
 304         if (interface_is_use_open_gl()) {
 305                 image_draw_opengl(image, x, y, px, py, w, h);
 306         } else {
 307                 image_draw_sdl(image, x, y, px, py, w, h);
 308         }
 309 #else /* SUPPORT_OPENGL */
 310         image_draw_sdl(image, x, y, px, py, w, h);
 311 #endif /* SUPPORT_OPENGL */
 312 }
 313
 314 /*
 315  * Frees global image list
 316  */
 317 void image_quit()
 318 {
 319         debug("Shutting down image database");
 320
 321         storage_destroy(listStorage, image_destroy);
 322         isImageDataInit = FALSE;
 323 }