src/graphics/texture.c

   1 /************************************************************************
   2 * texture.c
   3 * voxelands - 3d voxel world sandbox game
   4 * Copyright (C) Lisa 'darkrose' Milne 2016 <lisa@ltmnet.com>
   5 *
   6 * This program is free software: you can redistribute it and/or modify
   7 * it under the terms of the GNU General Public License as published by
   8 * the Free Software Foundation, either version 3 of the License, or
   9 * (at your option) any later version.
  10 *
  11 * This program is distributed in the hope that it will be useful, but
  12 * WITHOUT ANY WARRANTY; without even the implied warranty of
  13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  14 * See the GNU General Public License for more details.
  15 *
  16 * You should have received a copy of the GNU General Public License
  17 * along with this program.  If not, see <http://www.gnu.org/licenses/>
  18 ************************************************************************/
  19
  20 #include "common.h"
  21 #include "graphics.h"
  22 #include "list.h"
  23
  24 #include <string.h>
  25
  26 static texture_t *textures = NULL;
  27 static int tex_ids = 0;
  28
  29 /* generate the hardware texture */
  30 int tex_generate(texture_t *tex)
  31 {
  32         int b = 0;
  33         int t = 0;
  34         int m = 0;
  35         GLenum e;
  36         if (!tex)
  37                 return 1;
  38
  39         /* delete the old texture, if it exists */
  40         if (tex->state) {
  41                 glDeleteTextures(1, &tex->glid);
  42                 e = glGetError();
  43                 if (e != GL_NO_ERROR) {
  44                         char* es = opengl_error_string(e);
  45                         vlprintf(CN_ERROR "%s",es);
  46                         return 1;
  47                 }
  48         }
  49
  50         /* create a new texture */
  51         glGenTextures(1, &tex->glid);
  52         e = glGetError();
  53         if (e != GL_NO_ERROR) {
  54                 char* es = opengl_error_string(e);
  55                 vlprintf(CN_ERROR "%s",es);
  56                 return 1;
  57         }
  58
  59         glBindTexture(GL_TEXTURE_2D, tex->glid);
  60         e = glGetError();
  61         if (e != GL_NO_ERROR) {
  62                 char* es = opengl_error_string(e);
  63                 vlprintf(CN_ERROR "%s",es);
  64                 return 1;
  65         }
  66
  67         b = opengl_has_bilinear();
  68         t = opengl_has_trilinear();
  69         m = opengl_has_mipmap();
  70
  71         /* draw the pixels to the texture */
  72         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, tex->px->w, tex->px->h , 0, GL_RGBA, GL_UNSIGNED_BYTE, tex->px->pixels);
  73         e = glGetError();
  74         if (e != GL_NO_ERROR) {
  75                 char* es = opengl_error_string(e);
  76                 vlprintf(CN_ERROR "%s",es);
  77                 return 1;
  78         }
  79
  80         if (m) {
  81                 /* shouldn't ever need this, but there's an ATI/AMD bug that this fixes */
  82                 glEnable(GL_TEXTURE_2D);
  83                 glGenerateMipmap(GL_TEXTURE_2D);
  84                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  85                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  86         }
  87
  88         if (t) {
  89                 glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  90                 if (m) {
  91                         glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_LINEAR);
  92                 }else{
  93                         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  94                 }
  95         }else if (b) {
  96                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  97                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  98         }else{
  99                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 100                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 101         }
 102
 103         if (opengl_has_anisotropic()) {
 104                 float ma = opengl_max_anisotropic();
 105                 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, ma);
 106         }
 107
 108         e = glGetError();
 109         if (e != GL_NO_ERROR) {
 110                 char* es = opengl_error_string(e);
 111                 vlprintf(CN_ERROR "%s",es);
 112                 return 1;
 113         }
 114
 115         tex->state = 1;
 116
 117         return 0;
 118 }
 119
 120 /* add a new image to the cache */
 121 texture_t *tex_create()
 122 {
 123         texture_t *tex = malloc(sizeof(texture_t));
 124         if (tex == NULL)
 125                 return NULL;
 126
 127         tex->w = 0;
 128         tex->h = 0;
 129         tex->xf = 0;
 130         tex->yf = 0;
 131         tex->name[0] = 0;
 132         tex->px = NULL;
 133         tex->id = tex_ids++;
 134         tex->glid = 0;
 135         tex->state = 0;
 136
 137         textures = list_push(&textures,tex);
 138
 139         return tex;
 140 }
 141
 142 /* free a texture */
 143 void tex_free(texture_t *tex)
 144 {
 145         if (!tex)
 146                 return;
 147         textures = list_remove(&textures,tex);
 148         if (tex->glid)
 149                 glDeleteTextures(1, &tex->glid);
 150         free(tex);
 151 }
 152
 153 /* load an image to a texture */
 154 texture_t *tex_from_image(char* type, char* file)
 155 {
 156         texture_t *t;
 157         /* get the image */
 158         image_t *p;
 159
 160         t = textures;
 161         while (t) {
 162                 if (!strcmp(t->name,file))
 163                         break;
 164                 t = t->next;
 165         }
 166
 167         if (t)
 168                 return t;
 169
 170         p = image_load(type,file);
 171         if (!p)
 172                 return NULL;
 173
 174         /* and make a texture out of it */
 175         t = tex_from_pixels(p);
 176         if (t)
 177                 strncpy(t->name,file,100);
 178
 179         return t;
 180 }
 181
 182 /* create a texture from pixel data */
 183 texture_t *tex_from_pixels(image_t *px)
 184 {
 185         texture_t *tex;
 186         if (!px)
 187                 return NULL;
 188
 189         tex = tex_create();
 190         if (tex == NULL)
 191                 return NULL;
 192
 193         tex->w = px->w;
 194         tex->h = px->h ;
 195         tex->px = px;
 196         tex->xf = 1.0/(GLfloat)px->w;
 197         tex->yf = 1.0/(GLfloat)px->h;
 198
 199         if (!tex_generate(tex))
 200                 return tex;
 201
 202         tex_free(tex);
 203
 204         return NULL;
 205 }
 206
 207 /* update a texture from pixel data */
 208 texture_t *tex_update_pixels(texture_t *tex, image_t *px)
 209 {
 210         if (!tex)
 211                 return tex_from_pixels(px);
 212
 213         tex->w = px->w;
 214         tex->h = px->h ;
 215         tex->px = px;
 216         tex->xf = 1.0/(GLfloat)px->w;
 217         tex->yf = 1.0/(GLfloat)px->h;
 218
 219         if (!tex_generate(tex))
 220                 return tex;
 221
 222         tex_free(tex);
 223
 224         return NULL;
 225 }
 226
 227 /* create a transparent texture */
 228 texture_t *tex_from_rgba(int x, int y, uint8_t r, uint8_t g, uint8_t b, uint8_t a)
 229 {
 230         char n[100];
 231         texture_t *t;
 232         image_t *p;
 233         int size;
 234         int i;
 235
 236         snprintf(n,100,"rgba-%u-%u-%u-%u-%d-%d",(uint32_t)r,(uint32_t)g,(uint32_t)b,(uint32_t)a,x,y);
 237         t = textures;
 238         while (t) {
 239                 if (!strcmp(t->name,n))
 240                         break;
 241                 t = t->next;
 242         }
 243
 244         if (t)
 245                 return t;
 246
 247         p = malloc(sizeof(image_t));
 248         if (!p)
 249                 return NULL;
 250
 251         p->w = x;
 252         p->h = y;
 253
 254         size = x*y*4;
 255
 256         p->pixels = malloc(sizeof(uint8_t)*size);
 257         if (!p->pixels) {
 258                 free(p);
 259                 return NULL;
 260         }
 261
 262         i = 0;
 263         while (i<size) {
 264                 p->pixels[i++] = r;
 265                 p->pixels[i++] = g;
 266                 p->pixels[i++] = b;
 267                 p->pixels[i++] = a;
 268         }
 269
 270         t = tex_from_pixels(p);
 271         strcpy(t->name,n);
 272
 273         return t;
 274 }