gfx.c

   1 /*
   2   Pacman Arena
   3   Copyright (C) 2003 Nuno Subtil
   4
   5   This program is free software; you can redistribute it and/or
   6   modify it under the terms of the GNU General Public License
   7   as published by the Free Software Foundation; either version 2
   8   of the License, or (at your option) any later version.
   9
  10   This program is distributed in the hope that it will be useful,
  11   but WITHOUT ANY WARRANTY; without even the implied warranty of
  12   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13   GNU General Public License for more details.
  14
  15   You should have received a copy of the GNU General Public License
  16   along with this program; if not, write to the Free Software
  17   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18 */
  19
  20 static const char cvsid[] =
  21   "$Id: gfx.c,v 1.11 2003/11/22 17:32:09 nsubtil Exp $";
  22
  23 #ifdef _WIN32
  24 #include <windows.h>
  25 #endif
  26
  27 #include <GL/gl.h>
  28 #include <GL/glu.h>
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32
  33 #include "linked-lists.h"
  34 #include "file.h"
  35 #include "gfx.h"
  36
  37 struct image_rgba32 *images = NULL;
  38
  39 /*
  40   lê um ficheiro TGA não-comprimido de 32bpp
  41   XXX - código horripilante
  42 */
  43 struct image_rgba32 *gfx_read_targa(char *fname)
  44 {
  45         FILE *fp;
  46         struct raw_targa tga;
  47         int c;
  48         unsigned char *buf, sb;
  49         struct image_rgba32 *bmp;
  50
  51         bmp = (struct image_rgba32 *)malloc(sizeof(struct image_rgba32));
  52         if(bmp == NULL)
  53         {
  54                 perror("malloc()");
  55                 exit(1);
  56         }
  57         memset(bmp, 0, sizeof(struct image_rgba32));
  58         memset(&tga, 0, sizeof(struct raw_targa));
  59
  60         if((fp=file_open(fname)) == NULL) return NULL;
  61         fread(&tga.id_len, sizeof(tga.id_len), 1, fp);
  62         fread(&tga.cl_map, sizeof(tga.cl_map), 1, fp);
  63
  64         if(tga.cl_map==1)
  65         {
  66                 fprintf(stderr, "read_targa(): color mapped images not supported\n");
  67                 fclose(fp);
  68                 return NULL;
  69         }
  70
  71         fseek(fp, 12, SEEK_SET);
  72         fread(&tga.width, sizeof(tga.width), 1, fp);
  73         fread(&tga.height, sizeof(tga.height), 1, fp);
  74         fread(&tga.bpp, sizeof(tga.bpp), 1, fp);
  75         fseek(fp, tga.id_len+1, SEEK_CUR);
  76 /*
  77     bmp->x = tga.width;
  78     bmp->y = tga.height;
  79     bmp->bpp = (tga.bpp == 24 ? 32 : tga.bpp);
  80 */
  81
  82         bmp->width = tga.width;
  83         bmp->height = tga.height;
  84
  85         bmp->data=malloc(bmp->width*bmp->height*32/8);
  86 /*  bmp->data_32 = bmp->data;
  87     bmp->data_16 = bmp->data;
  88     bmp->data_8 = bmp->data;*/
  89
  90         if(bmp->data==NULL)
  91         {
  92                 perror("malloc()");
  93                 exit(1);
  94         }
  95         buf=(unsigned char *)bmp->data;
  96
  97         if(tga.bpp==32 || tga.bpp==16)
  98         {
  99                 int r;
 100
 101                 r = ftell(fp);
 102                 r = fread(bmp->data, 1, 32/8*bmp->width*bmp->height, fp);
 103                 fclose(fp);
 104         }
 105         else
 106                 for(c=0;c<bmp->width*bmp->height;c++)
 107                 {
 108                         fread(&buf[c*4], 3, 1, fp);
 109                         buf[c*4+3]=0;
 110                 }
 111 /*
 112   if(bmp->bpp==24)
 113   {
 114   bmp->bpp=32;
 115   }
 116 */
 117
 118         /*
 119           for(c=0;c<bmp->x*bmp->y;c++)
 120           {
 121           switch(bmp->bpp)
 122           {
 123           case 32:
 124           case 24:
 125           sb = bmp->data_32[c] & 0xFF000000;
 126           bmp->data_32[c] = bmp->data_32[c] ^ (sb << 24) + bmp->data_32[c] & 0xFFFFFF;
 127           bmp->data_32[c] |= (bmp->data_32[c] & 0xFF) << 24;
 128           bmp->data_32[c] = bmp->data_32[c] ^ (bmp->data_32[c] & 0xFF) + bmp->data_32[c] & 0xFFFFFF00;
 129           bmp->data_32[c] |= sb;
 130           break;
 131           }
 132           }
 133         */
 134
 135         for(c=0;c<bmp->width*bmp->height;c++)
 136         {
 137                 switch(32)
 138                 {
 139                 case 32:
 140                         sb=buf[c*4];
 141                         buf[c*4]=buf[c*4+2];
 142                         buf[c*4+2]=sb;
 143                         break;
 144                 case 24:
 145                         sb=buf[c*3];
 146                         buf[c*3]=buf[c*3+2];
 147                         buf[c*3+2]=sb;
 148                         break;
 149                 }
 150         }
 151
 152         bmp->name = strdup(fname);
 153         bmp->id = -1;
 154         bmp->filtered = 0;
 155         bmp->next = NULL;
 156
 157         return bmp;
 158 }
 159
 160 /*
 161   procura um bitmap já carregado
 162 */
 163 struct image_rgba32 *gfx_find(char *name)
 164 {
 165         struct image_rgba32 *cur;
 166
 167         cur = images;
 168         while(cur)
 169         {
 170                 if(strcmp(cur->name, name) == 0)
 171                         return cur;
 172
 173                 cur = cur->next;
 174         }
 175
 176         return NULL;
 177 }
 178
 179 /*
 180   devolve um bitmap, carregando do ficheiro se necessário
 181 */
 182 struct image_rgba32 *gfx_get(char *name)
 183 {
 184         struct image_rgba32 *ret;
 185
 186         ret = gfx_find(name);
 187         if(ret == NULL)
 188         {
 189                 ret = gfx_read_targa(name);
 190                 if (!ret) {
 191                         printf("Unable to load graphic %s\n", name);
 192                         exit(1);
 193                 }
 194                 LLIST_ADD(struct image_rgba32, images, ret);
 195         }
 196
 197         return ret;
 198 }
 199
 200 /*
 201   altera o canal alpha da textura para a intensidade da cor em cada pixel
 202 */
 203 void gfx_alpha_from_intensity(char *name)
 204 {
 205         int x, y;
 206         struct image_rgba32 *img;
 207
 208         img = gfx_get(name);
 209         if(img == NULL)
 210                 return;
 211
 212         for(x = 0; x < img->width; x++)
 213                 for(y = 0; y < img->height; y++)
 214                 {
 215                         unsigned char *ptr;
 216
 217                         ptr = (unsigned char *)((unsigned long)img->data + (x + y * img->width) * 4);
 218
 219                         ptr[2] = (ptr[0] + ptr[1] + ptr[2]) / 3;
 220                 }
 221 }
 222
 223 /*
 224   altera o canal alpha da textura para transparente em pixels de uma determinada cor
 225 */
 226 void gfx_alpha_from_key(char *name, unsigned char r, unsigned char g, unsigned char b)
 227 {
 228         int c;
 229         struct image_rgba32 *img;
 230         unsigned char *ptr;
 231
 232         img = gfx_get(name);
 233         if(img == NULL)
 234                 return;
 235
 236         ptr = (unsigned char *)img->data;
 237
 238         for(c = 0; c < img->width * img->height; c++)
 239         {
 240                 if(ptr[0] == r && ptr[1] == g && ptr[2] == b)
 241                         ptr[3] = 0;
 242                 else
 243                         ptr[3] = 0xff;
 244
 245                 ptr += 4;
 246         }
 247 }
 248
 249 /*
 250   adiciona uma textura à lista
 251 */
 252 void gfx_add(struct image_rgba32 *new)
 253 {
 254         if(gfx_find(new->name))
 255         {
 256                 printf("gfx_add: bitmap repetido: %s\n", new->name);
 257                 return;
 258         }
 259
 260         LLIST_ADD(struct image_rgba32, images, new);
 261 }
 262
 263 /*
 264   carrega uma textura na placa gráfica
 265 */
 266 GLuint gfx_upload_texture(char *name)
 267 {
 268         struct image_rgba32 *texture;
 269         GLuint id;
 270
 271         texture = gfx_get(name);
 272         if(texture == NULL)
 273         {
 274                 printf("gfx_upload_texture: %s não existe\n", name);
 275                 return -1;
 276         }
 277
 278         texture->filtered = 1;
 279
 280         glGenTextures(1, &id);
 281         glBindTexture(GL_TEXTURE_2D, id);
 282
 283         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
 284         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 285         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 286         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
 287
 288         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 289
 290         gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA, texture->width, texture->height, GL_RGBA, GL_UNSIGNED_BYTE, texture->data);
 291
 292         texture->id = id;
 293         return id;
 294 }
 295
 296 /*
 297   carrega uma textura sem filtragem & afins
 298 */
 299 GLuint gfx_upload_texture_nofilter(char *name)
 300 {
 301         struct image_rgba32 *texture;
 302         GLuint id;
 303
 304         texture = gfx_get(name);
 305         if(texture == NULL)
 306         {
 307                 printf("gfx_upload_texture_no_filter: %s não existe\n", name);
 308                 return -1;
 309         }
 310
 311         texture->filtered = 0;
 312
 313         glGenTextures(1, &id);
 314         glBindTexture(GL_TEXTURE_2D, id);
 315
 316         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 317         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 318         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
 319         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 320
 321         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, texture->width, texture->height,
 322                      0, GL_RGBA, GL_UNSIGNED_BYTE, texture->data);
 323
 324         texture->id = id;
 325         return id;
 326 }
 327
 328 /*
 329   liberta todas as texturas na placa gráfica
 330 */
 331 void gfx_unload_all(void)
 332 {
 333         struct image_rgba32 *cur;
 334
 335         cur = images;
 336
 337         while(cur)
 338         {
 339                 if(cur->id != (GLuint)-1)
 340                 {
 341                         glDeleteTextures(1, &cur->id);
 342                         cur->id = -1;
 343                 }
 344
 345                 cur = cur->next;
 346         }
 347 }
 348
 349 /*
 350   envia todas as texturas para a placa gráfica
 351 */
 352 void gfx_reload_all(void)
 353 {
 354         struct image_rgba32 *cur;
 355
 356         cur = images;
 357         while(cur)
 358         {
 359                 if(cur->filtered)
 360                         gfx_upload_texture(cur->name);
 361                 else
 362                         gfx_upload_texture_nofilter(cur->name);
 363
 364                 cur = cur->next;
 365         }
 366 }
 367