misc/tools/fft-normalmap-to-heightmap.c

   1 /*
   2  *  FFT based normalmap to heightmap converter
   3  *  Copyright (C) 2010  Rudolf Polzer
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2 of the License, or
   8  *  (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 #undef C99
  21 #if __STDC_VERSION__ >= 199901L
  22 #define C99
  23 #endif
  24
  25 #ifdef C99
  26 #include <complex.h>
  27 #endif
  28
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <math.h>
  33
  34 #include <fftw3.h>
  35
  36 #define TWO_PI (4*atan2(1,1) * 2)
  37
  38 void nmap_to_hmap(unsigned char *map, const unsigned char *refmap, int w, int h, double scale, double offset)
  39 {
  40         int x, y;
  41         double nx, ny, nz;
  42         double v, vmin, vmax;
  43 #ifndef C99
  44         double save;
  45 #endif
  46
  47         fftw_complex *imgspace1 = fftw_malloc(w*h * sizeof(fftw_complex));
  48         fftw_complex *imgspace2 = fftw_malloc(w*h * sizeof(fftw_complex));
  49         fftw_complex *freqspace1 = fftw_malloc(w*h * sizeof(fftw_complex));
  50         fftw_complex *freqspace2 = fftw_malloc(w*h * sizeof(fftw_complex));
  51         fftw_plan i12f1 = fftw_plan_dft_2d(w, h, imgspace1, freqspace1, FFTW_FORWARD, FFTW_ESTIMATE);
  52         fftw_plan i22f2 = fftw_plan_dft_2d(w, h, imgspace2, freqspace2, FFTW_FORWARD, FFTW_ESTIMATE);
  53         fftw_plan f12i1 = fftw_plan_dft_2d(w, h, freqspace1, imgspace1, FFTW_BACKWARD, FFTW_ESTIMATE);
  54
  55         for(y = 0; y < h; ++y)
  56         for(x = 0; x < w; ++x)
  57         {
  58                 /*
  59                  * unnormalized normals:
  60                  * n_x = -dh/dx
  61                  * n_y = -dh/dy
  62                  * n_z = -dh/dh = -1
  63                  * BUT: darkplaces uses inverted normals, n_y actually is dh/dy by image pixel coordinates
  64                  */
  65                 nx = ((int)map[(w*y+x)*4+2] - 127.5) / 128;
  66                 ny = ((int)map[(w*y+x)*4+1] - 127.5) / 128;
  67                 nz = ((int)map[(w*y+x)*4+0] - 127.5) / 128;
  68
  69                 /* reconstruct the derivatives from here */
  70 #ifdef C99
  71                 imgspace1[(w*y+x)] =  nx / nz * w; /* = dz/dx */
  72                 imgspace2[(w*y+x)] = -ny / nz * h; /* = dz/dy */
  73 #else
  74                 imgspace1[(w*y+x)][0] =  nx / nz; /* = dz/dx */
  75                 imgspace1[(w*y+x)][1] = 0;
  76                 imgspace2[(w*y+x)][0] = -ny / nz; /* = dz/dy */
  77                 imgspace2[(w*y+x)][1] = 0;
  78 #endif
  79         }
  80
  81         /* see http://www.gamedev.net/community/forums/topic.asp?topic_id=561430 */
  82
  83         fftw_execute(i12f1);
  84         fftw_execute(i22f2);
  85
  86         for(y = 0; y < h; ++y)
  87         for(x = 0; x < w; ++x)
  88         {
  89                 int fx = x;
  90                 int fy = y;
  91                 if(fx > w/2)
  92                         fx -= w;
  93                 if(fy > h/2)
  94                         fy -= h;
  95 #ifdef C99
  96                 if(fx||fy)
  97                         freqspace1[(w*y+x)] = I * (fx * freqspace1[(w*y+x)] + fy * freqspace2[(w*y+x)]) / (fx*fx + fy*fy) / TWO_PI;
  98                 else
  99                         freqspace1[(w*y+x)] = 0;
 100 #else
 101                 if(fx||fy)
 102                 {
 103                         save = freqspace1[(w*y+x)][0];
 104                         freqspace1[(w*y+x)][0] = -(fx * freqspace1[(w*y+x)][1] + fy * freqspace2[(w*y+x)][1]) / (fx*fx + fy*fy) / TWO_PI;
 105                         freqspace1[(w*y+x)][1] =  (fx * save + fy * freqspace2[(w*y+x)][0]) / (fx*fx + fy*fy) / TWO_PI;
 106                 }
 107                 else
 108                 {
 109                         freqspace1[(w*y+x)][0] = 0;
 110                         freqspace1[(w*y+x)][1] = 0;
 111                 }
 112 #endif
 113         }
 114
 115         fftw_execute(f12i1);
 116
 117         if(refmap)
 118         {
 119                 // refmap: a reference map to define the heights
 120                 // alpha = weight, color = value
 121                 // if more than one color value is used, colors are also matched
 122
 123                 // we do linear regression, basically
 124                 // f'(x, y) = f(x, y) * scale + offset
 125                 // sum((f(x, y) * scale + offset - ref_y(x, y))^2 * ref_a(x, y)) minimize
 126
 127                 // diff by offset:
 128                 // sum(-2*ref_y(x,y)*ref_a(x,y) + 2*scale*f(x,y)*ref_a(x,y) + 2*offset*ref_a(x,y)) = 0
 129                 // diff by scale:
 130                 // sum(-2*f(x,y)*ref_a(x,y) + 2*scale*f(x,y)^2*ref_a(x,y) + 2*offset*f(x,y)*ref_a(x,y)) = 0
 131                 // ->
 132                 // offset = (sfa*sfya - sffa*sya) / (sfa*sfa-sa*sffa)
 133                 // scale  = (sfa*sya - sa*sfya) / (sfa*sfa-sa*sffa)
 134
 135                 double f, a;
 136                 double o, s;
 137                 double sa, sfa, sffa, sfva, sva;
 138                 double mi, ma;
 139                 sa = sfa = sffa = sfva = sva = 0;
 140                 mi = 1;
 141                 ma = -1;
 142                 for(y = 0; y < h; ++y)
 143                 for(x = 0; x < w; ++x)
 144                 {
 145                         a = (int)refmap[(w*y+x)*4+0];
 146                         v = (map[(w*y+x)*4+0]*0.114 + map[(w*y+x)*4+1]*0.587 + map[(w*y+x)*4+2]*0.299);
 147                         v = (v - 128.0) / 127.0; // value 0 is forbidden, 1 -> -1, 255 -> 1
 148 #ifdef C99
 149                         f = creal(imgspace1[(w*y+x)]);
 150 #else
 151                         f = imgspace1[(w*y+x)][0];
 152 #endif
 153                         if(a <= 0)
 154                                 continue;
 155                         if(y < mi)
 156                                 mi = y;
 157                         if(y > ma)
 158                                 ma = y;
 159                         sa += a;
 160                         sfa += f*a;
 161                         sffa += f*f*a;
 162                         sfva += f*v*a;
 163                         sva += v*a;
 164                 }
 165                 sfa /= (w*h);
 166                 sffa /= (w*h);
 167                 sffa /= (w*h);
 168                 sfva /= (w*h);
 169                 if(mi < ma)
 170                 {
 171                         o = (sfa*sfva - sffa*sva) / (sfa*sfa-sa*sffa);
 172                         s = (sfa*sva - sa*sfva) / (sfa*sfa-sa*sffa);
 173                 }
 174                 else // all values of v are equal, so we cannot get scale; we can still get offset
 175                 {
 176                         o = ((sva - sfa) / sa);
 177                         s = 1;
 178                 }
 179                 // now apply user-given offset and scale to these values
 180                 // (x * s + o) * scale + offset
 181                 // x * s * scale + o * scale + offset
 182                 offset += o * scale;
 183                 scale *= s;
 184         }
 185         else if(scale == 0)
 186         {
 187 #ifdef C99
 188                 vmin = vmax = creal(imgspace1[0]);
 189 #else
 190                 vmin = vmax = imgspace1[0][0];
 191 #endif
 192                 for(y = 0; y < h; ++y)
 193                 for(x = 0; x < w; ++x)
 194                 {
 195 #ifdef C99
 196                         v = creal(imgspace1[(w*y+x)]);
 197 #else
 198                         v = imgspace1[(w*y+x)][0];
 199 #endif
 200                         if(v < vmin)
 201                                 vmin = v;
 202                         if(v > vmax)
 203                                 vmax = v;
 204                 }
 205
 206                 vmin /= (w*h);
 207                 vmax /= (w*h);
 208
 209                 /*
 210                  * map vmin to -1
 211                  * map vmax to +1
 212                  */
 213                 scale = 2 / (vmax - vmin);
 214                 offset = -(vmax + vmin) / (vmax - vmin);
 215
 216                 printf("Autocomputed scale: %f\nAutocomputed offset: %f\n", scale, offset);
 217         }
 218
 219         scale /= (w*h);
 220
 221         for(y = 0; y < h; ++y)
 222         for(x = 0; x < w; ++x)
 223         {
 224 #ifdef C99
 225                 v = creal(imgspace1[(w*y+x)]);
 226 #else
 227                 v = imgspace1[(w*y+x)][0];
 228 #endif
 229                 v = v * scale + offset;
 230                 if(v < -1)
 231                         v = -1;
 232                 if(v > 1)
 233                         v = 1;
 234                 map[(w*y+x)*4+3] = floor(128.5 + 127 * v);
 235         }
 236
 237         fftw_destroy_plan(i12f1);
 238         fftw_destroy_plan(i22f2);
 239         fftw_destroy_plan(f12i1);
 240
 241         fftw_free(freqspace2);
 242         fftw_free(freqspace1);
 243         fftw_free(imgspace2);
 244         fftw_free(imgspace1);
 245 }
 246
 247 void hmap_to_nmap(unsigned char *map, int w, int h, int src_chan, double scale)
 248 {
 249         int x, y;
 250         double nx, ny, nz;
 251         double v;
 252 #ifndef C99
 253         double save;
 254 #endif
 255
 256         fftw_complex *imgspace1 = fftw_malloc(w*h * sizeof(fftw_complex));
 257         fftw_complex *imgspace2 = fftw_malloc(w*h * sizeof(fftw_complex));
 258         fftw_complex *freqspace1 = fftw_malloc(w*h * sizeof(fftw_complex));
 259         fftw_complex *freqspace2 = fftw_malloc(w*h * sizeof(fftw_complex));
 260         fftw_plan i12f1 = fftw_plan_dft_2d(w, h, imgspace1, freqspace1, FFTW_FORWARD, FFTW_ESTIMATE);
 261         fftw_plan f12i1 = fftw_plan_dft_2d(w, h, freqspace1, imgspace1, FFTW_BACKWARD, FFTW_ESTIMATE);
 262         fftw_plan f22i2 = fftw_plan_dft_2d(w, h, freqspace2, imgspace2, FFTW_BACKWARD, FFTW_ESTIMATE);
 263
 264         for(y = 0; y < h; ++y)
 265         for(x = 0; x < w; ++x)
 266         {
 267                 switch(src_chan)
 268                 {
 269                         case 0:
 270                         case 1:
 271                         case 2:
 272                         case 3:
 273                                 v = map[(w*y+x)*4+src_chan];
 274                                 break;
 275                         case 4:
 276                                 v = (map[(w*y+x)*4+0] + map[(w*y+x)*4+1] + map[(w*y+x)*4+2]) / 3;
 277                                 break;
 278                         default:
 279                         case 5:
 280                                 v = (map[(w*y+x)*4+0]*0.114 + map[(w*y+x)*4+1]*0.587 + map[(w*y+x)*4+2]*0.299);
 281                                 break;
 282                 }
 283 #ifdef C99
 284                 imgspace1[(w*y+x)] = (v - 128.0) / 127.0;
 285 #else
 286                 imgspace1[(w*y+x)][0] = (v - 128.0) / 127.0;
 287                 imgspace1[(w*y+x)][1] = 0;
 288 #endif
 289                 map[(w*y+x)*4+3] = floor(v + 0.5);
 290         }
 291
 292         /* see http://www.gamedev.net/community/forums/topic.asp?topic_id=561430 */
 293
 294         fftw_execute(i12f1);
 295
 296         for(y = 0; y < h; ++y)
 297         for(x = 0; x < w; ++x)
 298         {
 299                 int fx = x;
 300                 int fy = y;
 301                 if(fx > w/2)
 302                         fx -= w;
 303                 if(fy > h/2)
 304                         fy -= h;
 305 #ifdef C99
 306                 /* a lowpass to prevent the worst */
 307                 freqspace1[(w*y+x)] *= 1 - pow(abs(fx) / (double)(w/2), 1);
 308                 freqspace1[(w*y+x)] *= 1 - pow(abs(fy) / (double)(h/2), 1);
 309
 310                 freqspace2[(w*y+x)] = TWO_PI*I * fy * freqspace1[(w*y+x)]; /* y derivative */
 311                 freqspace1[(w*y+x)] = TWO_PI*I * fx * freqspace1[(w*y+x)]; /* x derivative */
 312 #else
 313                 /* a lowpass to prevent the worst */
 314                 freqspace1[(w*y+x)][0] *= 1 - pow(abs(fx) / (double)(w/2), 1);
 315                 freqspace1[(w*y+x)][1] *= 1 - pow(abs(fx) / (double)(w/2), 1);
 316                 freqspace1[(w*y+x)][0] *= 1 - pow(abs(fy) / (double)(h/2), 1);
 317                 freqspace1[(w*y+x)][1] *= 1 - pow(abs(fy) / (double)(h/2), 1);
 318
 319                 freqspace2[(w*y+x)][0] = -TWO_PI * fy * freqspace1[(w*y+x)][1]; /* y derivative */
 320                 freqspace2[(w*y+x)][1] =  TWO_PI * fy * freqspace1[(w*y+x)][0];
 321                 save = freqspace1[(w*y+x)][0];
 322                 freqspace1[(w*y+x)][0] = -TWO_PI * fx * freqspace1[(w*y+x)][1]; /* x derivative */
 323                 freqspace1[(w*y+x)][1] =  TWO_PI * fx * save;
 324 #endif
 325         }
 326
 327         fftw_execute(f12i1);
 328         fftw_execute(f22i2);
 329
 330         scale /= (w*h);
 331
 332         for(y = 0; y < h; ++y)
 333         for(x = 0; x < w; ++x)
 334         {
 335 #ifdef C99
 336                 nx = creal(imgspace1[(w*y+x)]);
 337                 ny = creal(imgspace2[(w*y+x)]);
 338 #else
 339                 nx = imgspace1[(w*y+x)][0];
 340                 ny = imgspace2[(w*y+x)][0];
 341 #endif
 342                 nx /= w;
 343                 ny /= h;
 344                 nz = -1 / scale;
 345                 v = -sqrt(nx*nx + ny*ny + nz*nz);
 346                 nx /= v;
 347                 ny /= v;
 348                 nz /= v;
 349                 ny = -ny; /* DP inverted normals */
 350                 map[(w*y+x)*4+2] = floor(128 + 127.5 * nx);
 351                 map[(w*y+x)*4+1] = floor(128 + 127.5 * ny);
 352                 map[(w*y+x)*4+0] = floor(128 + 127.5 * nz);
 353         }
 354
 355         fftw_destroy_plan(i12f1);
 356         fftw_destroy_plan(f12i1);
 357         fftw_destroy_plan(f22i2);
 358
 359         fftw_free(freqspace2);
 360         fftw_free(freqspace1);
 361         fftw_free(imgspace2);
 362         fftw_free(imgspace1);
 363 }
 364
 365 void hmap_to_nmap_local(unsigned char *map, int w, int h, int src_chan, double scale)
 366 {
 367         int x, y;
 368         double nx, ny, nz;
 369         double v;
 370         int i, j;
 371         double *img_reduced = malloc(w*h * sizeof(double));
 372         static const double filter[3][3] = { /* filter to derive one component */
 373                 { -1, 0, 1 },
 374                 { -2, 0, 2 },
 375                 { -1, 0, 1 }
 376         };
 377         static const double filter_mult = 0.125;
 378
 379         for(y = 0; y < h; ++y)
 380         for(x = 0; x < w; ++x)
 381         {
 382                 switch(src_chan)
 383                 {
 384                         case 0:
 385                         case 1:
 386                         case 2:
 387                         case 3:
 388                                 v = map[(w*y+x)*4+src_chan];
 389                                 break;
 390                         case 4:
 391                                 v = (map[(w*y+x)*4+0] + map[(w*y+x)*4+1] + map[(w*y+x)*4+2]) / 3;
 392                                 break;
 393                         default:
 394                         case 5:
 395                                 v = (map[(w*y+x)*4+0]*0.114 + map[(w*y+x)*4+1]*0.587 + map[(w*y+x)*4+2]*0.299);
 396                                 break;
 397                 }
 398                 img_reduced[(w*y+x)] = (v - 128.0) / 127.0;
 399                 map[(w*y+x)*4+3] = floor(v + 0.5);
 400         }
 401
 402         for(y = 0; y < h; ++y)
 403         for(x = 0; x < w; ++x)
 404         {
 405                 nz = -1 / (scale * filter_mult);
 406                 nx = ny = 0;
 407
 408                 for(i = -(int)(sizeof(filter) / sizeof(*filter)) / 2; i <= (int)(sizeof(filter) / sizeof(*filter)) / 2; ++i)
 409                         for(j = -(int)(sizeof(*filter) / sizeof(**filter)) / 2; j <= (int)(sizeof(*filter) / sizeof(**filter)) / 2; ++j)
 410                         {
 411                                 nx += img_reduced[w*((y+i+h)%h)+(x+j+w)%w] * filter[i+(sizeof(filter) / sizeof(*filter)) / 2][j+(sizeof(*filter) / sizeof(**filter)) / 2];
 412                                 ny += img_reduced[w*((y+j+h)%h)+(x+i+w)%w] * filter[i+(sizeof(filter) / sizeof(*filter)) / 2][j+(sizeof(*filter) / sizeof(**filter)) / 2];
 413                         }
 414
 415                 v = -sqrt(nx*nx + ny*ny + nz*nz);
 416                 nx /= v;
 417                 ny /= v;
 418                 nz /= v;
 419                 ny = -ny; /* DP inverted normals */
 420                 map[(w*y+x)*4+2] = floor(128 + 127.5 * nx);
 421                 map[(w*y+x)*4+1] = floor(128 + 127.5 * ny);
 422                 map[(w*y+x)*4+0] = floor(128 + 127.5 * nz);
 423         }
 424
 425         free(img_reduced);
 426 }
 427
 428 unsigned char *FS_LoadFile(const char *fn, int *len)
 429 {
 430         unsigned char *buf = NULL;
 431         int n;
 432         FILE *f = fopen(fn, "rb");
 433         *len = 0;
 434         if(!f)
 435                 return NULL;
 436         for(;;)
 437         {
 438                 buf = realloc(buf, *len + 65536);
 439                 if(!buf)
 440                 {
 441                         fclose(f);
 442                         free(buf);
 443                         *len = 0;
 444                         return NULL;
 445                 }
 446                 n = fread(buf + *len, 1, 65536, f);
 447                 if(n < 0)
 448                 {
 449                         fclose(f);
 450                         free(buf);
 451                         *len = 0;
 452                         return NULL;
 453                 }
 454                 *len += n;
 455                 if(n < 65536)
 456                         break;
 457         }
 458         return buf;
 459 }
 460
 461 int FS_WriteFile(const char *fn, unsigned char *data, int len)
 462 {
 463         FILE *f = fopen(fn, "wb");
 464         if(!f)
 465                 return 0;
 466         if(fwrite(data, len, 1, f) != 1)
 467         {
 468                 fclose(f);
 469                 return 0;
 470         }
 471         if(fclose(f))
 472                 return 0;
 473         return 1;
 474 }
 475
 476 /* START stuff that originates from image.c in DarkPlaces */
 477 int image_width, image_height;
 478
 479 typedef struct _TargaHeader
 480 {
 481         unsigned char   id_length, colormap_type, image_type;
 482         unsigned short  colormap_index, colormap_length;
 483         unsigned char   colormap_size;
 484         unsigned short  x_origin, y_origin, width, height;
 485         unsigned char   pixel_size, attributes;
 486 }
 487 TargaHeader;
 488
 489 void PrintTargaHeader(TargaHeader *t)
 490 {
 491         printf("TargaHeader:\nuint8 id_length = %i;\nuint8 colormap_type = %i;\nuint8 image_type = %i;\nuint16 colormap_index = %i;\nuint16 colormap_length = %i;\nuint8 colormap_size = %i;\nuint16 x_origin = %i;\nuint16 y_origin = %i;\nuint16 width = %i;\nuint16 height = %i;\nuint8 pixel_size = %i;\nuint8 attributes = %i;\n", t->id_length, t->colormap_type, t->image_type, t->colormap_index, t->colormap_length, t->colormap_size, t->x_origin, t->y_origin, t->width, t->height, t->pixel_size, t->attributes);
 492 }
 493
 494 unsigned char *LoadTGA_BGRA (const unsigned char *f, int filesize)
 495 {
 496         int x, y, pix_inc, row_inci, runlen, alphabits;
 497         unsigned char *image_buffer;
 498         unsigned int *pixbufi;
 499         const unsigned char *fin, *enddata;
 500         TargaHeader targa_header;
 501         unsigned int palettei[256];
 502         union
 503         {
 504                 unsigned int i;
 505                 unsigned char b[4];
 506         }
 507         bgra;
 508
 509         if (filesize < 19)
 510                 return NULL;
 511
 512         enddata = f + filesize;
 513
 514         targa_header.id_length = f[0];
 515         targa_header.colormap_type = f[1];
 516         targa_header.image_type = f[2];
 517
 518         targa_header.colormap_index = f[3] + f[4] * 256;
 519         targa_header.colormap_length = f[5] + f[6] * 256;
 520         targa_header.colormap_size = f[7];
 521         targa_header.x_origin = f[8] + f[9] * 256;
 522         targa_header.y_origin = f[10] + f[11] * 256;
 523         targa_header.width = image_width = f[12] + f[13] * 256;
 524         targa_header.height = image_height = f[14] + f[15] * 256;
 525         targa_header.pixel_size = f[16];
 526         targa_header.attributes = f[17];
 527
 528         if (image_width > 32768 || image_height > 32768 || image_width <= 0 || image_height <= 0)
 529         {
 530                 printf("LoadTGA: invalid size\n");
 531                 PrintTargaHeader(&targa_header);
 532                 return NULL;
 533         }
 534
 535         /* advance to end of header */
 536         fin = f + 18;
 537
 538         /* skip TARGA image comment (usually 0 bytes) */
 539         fin += targa_header.id_length;
 540
 541         /* read/skip the colormap if present (note: according to the TARGA spec it */
 542         /* can be present even on 1color or greyscale images, just not used by */
 543         /* the image data) */
 544         if (targa_header.colormap_type)
 545         {
 546                 if (targa_header.colormap_length > 256)
 547                 {
 548                         printf("LoadTGA: only up to 256 colormap_length supported\n");
 549                         PrintTargaHeader(&targa_header);
 550                         return NULL;
 551                 }
 552                 if (targa_header.colormap_index)
 553                 {
 554                         printf("LoadTGA: colormap_index not supported\n");
 555                         PrintTargaHeader(&targa_header);
 556                         return NULL;
 557                 }
 558                 if (targa_header.colormap_size == 24)
 559                 {
 560                         for (x = 0;x < targa_header.colormap_length;x++)
 561                         {
 562                                 bgra.b[0] = *fin++;
 563                                 bgra.b[1] = *fin++;
 564                                 bgra.b[2] = *fin++;
 565                                 bgra.b[3] = 255;
 566                                 palettei[x] = bgra.i;
 567                         }
 568                 }
 569                 else if (targa_header.colormap_size == 32)
 570                 {
 571                         memcpy(palettei, fin, targa_header.colormap_length*4);
 572                         fin += targa_header.colormap_length * 4;
 573                 }
 574                 else
 575                 {
 576                         printf("LoadTGA: Only 32 and 24 bit colormap_size supported\n");
 577                         PrintTargaHeader(&targa_header);
 578                         return NULL;
 579                 }
 580         }
 581
 582         /* check our pixel_size restrictions according to image_type */
 583         switch (targa_header.image_type & ~8)
 584         {
 585         case 2:
 586                 if (targa_header.pixel_size != 24 && targa_header.pixel_size != 32)
 587                 {
 588                         printf("LoadTGA: only 24bit and 32bit pixel sizes supported for type 2 and type 10 images\n");
 589                         PrintTargaHeader(&targa_header);
 590                         return NULL;
 591                 }
 592                 break;
 593         case 3:
 594                 /* set up a palette to make the loader easier */
 595                 for (x = 0;x < 256;x++)
 596                 {
 597                         bgra.b[0] = bgra.b[1] = bgra.b[2] = x;
 598                         bgra.b[3] = 255;
 599                         palettei[x] = bgra.i;
 600                 }
 601                 /* fall through to colormap case */
 602         case 1:
 603                 if (targa_header.pixel_size != 8)
 604                 {
 605                         printf("LoadTGA: only 8bit pixel size for type 1, 3, 9, and 11 images supported\n");
 606                         PrintTargaHeader(&targa_header);
 607                         return NULL;
 608                 }
 609                 break;
 610         default:
 611                 printf("LoadTGA: Only type 1, 2, 3, 9, 10, and 11 targa RGB images supported, image_type = %i\n", targa_header.image_type);
 612                 PrintTargaHeader(&targa_header);
 613                 return NULL;
 614         }
 615
 616         if (targa_header.attributes & 0x10)
 617         {
 618                 printf("LoadTGA: origin must be in top left or bottom left, top right and bottom right are not supported\n");
 619                 return NULL;
 620         }
 621
 622         /* number of attribute bits per pixel, we only support 0 or 8 */
 623         alphabits = targa_header.attributes & 0x0F;
 624         if (alphabits != 8 && alphabits != 0)
 625         {
 626                 printf("LoadTGA: only 0 or 8 attribute (alpha) bits supported\n");
 627                 return NULL;
 628         }
 629
 630         image_buffer = (unsigned char *)malloc(image_width * image_height * 4);
 631         if (!image_buffer)
 632         {
 633                 printf("LoadTGA: not enough memory for %i by %i image\n", image_width, image_height);
 634                 return NULL;
 635         }
 636
 637         /* If bit 5 of attributes isn't set, the image has been stored from bottom to top */
 638         if ((targa_header.attributes & 0x20) == 0)
 639         {
 640                 pixbufi = (unsigned int*)image_buffer + (image_height - 1)*image_width;
 641                 row_inci = -image_width*2;
 642         }
 643         else
 644         {
 645                 pixbufi = (unsigned int*)image_buffer;
 646                 row_inci = 0;
 647         }
 648
 649         x = 0;
 650         y = 0;
 651         pix_inc = 1;
 652         if ((targa_header.image_type & ~8) == 2)
 653                 pix_inc = (targa_header.pixel_size + 7) / 8;
 654         switch (targa_header.image_type)
 655         {
 656         case 1: /* colormapped, uncompressed */
 657         case 3: /* greyscale, uncompressed */
 658                 if (fin + image_width * image_height * pix_inc > enddata)
 659                         break;
 660                 for (y = 0;y < image_height;y++, pixbufi += row_inci)
 661                         for (x = 0;x < image_width;x++)
 662                                 *pixbufi++ = palettei[*fin++];
 663                 break;
 664         case 2:
 665                 /* BGR or BGRA, uncompressed */
 666                 if (fin + image_width * image_height * pix_inc > enddata)
 667                         break;
 668                 if (targa_header.pixel_size == 32 && alphabits)
 669                 {
 670                         for (y = 0;y < image_height;y++)
 671                                 memcpy(pixbufi + y * (image_width + row_inci), fin + y * image_width * pix_inc, image_width*4);
 672                 }
 673                 else
 674                 {
 675                         for (y = 0;y < image_height;y++, pixbufi += row_inci)
 676                         {
 677                                 for (x = 0;x < image_width;x++, fin += pix_inc)
 678                                 {
 679                                         bgra.b[0] = fin[0];
 680                                         bgra.b[1] = fin[1];
 681                                         bgra.b[2] = fin[2];
 682                                         bgra.b[3] = 255;
 683                                         *pixbufi++ = bgra.i;
 684                                 }
 685                         }
 686                 }
 687                 break;
 688         case 9: /* colormapped, RLE */
 689         case 11: /* greyscale, RLE */
 690                 for (y = 0;y < image_height;y++, pixbufi += row_inci)
 691                 {
 692                         for (x = 0;x < image_width;)
 693                         {
 694                                 if (fin >= enddata)
 695                                         break; /* error - truncated file */
 696                                 runlen = *fin++;
 697                                 if (runlen & 0x80)
 698                                 {
 699                                         /* RLE - all pixels the same color */
 700                                         runlen += 1 - 0x80;
 701                                         if (fin + pix_inc > enddata)
 702                                                 break; /* error - truncated file */
 703                                         if (x + runlen > image_width)
 704                                                 break; /* error - line exceeds width */
 705                                         bgra.i = palettei[*fin++];
 706                                         for (;runlen--;x++)
 707                                                 *pixbufi++ = bgra.i;
 708                                 }
 709                                 else
 710                                 {
 711                                         /* uncompressed - all pixels different color */
 712                                         runlen++;
 713                                         if (fin + pix_inc * runlen > enddata)
 714                                                 break; /* error - truncated file */
 715                                         if (x + runlen > image_width)
 716                                                 break; /* error - line exceeds width */
 717                                         for (;runlen--;x++)
 718                                                 *pixbufi++ = palettei[*fin++];
 719                                 }
 720                         }
 721
 722                         if (x != image_width)
 723                         {
 724                                 /* pixbufi is useless now */
 725                                 printf("LoadTGA: corrupt file\n");
 726                                 break;
 727                         }
 728                 }
 729                 break;
 730         case 10:
 731                 /* BGR or BGRA, RLE */
 732                 if (targa_header.pixel_size == 32 && alphabits)
 733                 {
 734                         for (y = 0;y < image_height;y++, pixbufi += row_inci)
 735                         {
 736                                 for (x = 0;x < image_width;)
 737                                 {
 738                                         if (fin >= enddata)
 739                                                 break; /* error - truncated file */
 740                                         runlen = *fin++;
 741                                         if (runlen & 0x80)
 742                                         {
 743                                                 /* RLE - all pixels the same color */
 744                                                 runlen += 1 - 0x80;
 745                                                 if (fin + pix_inc > enddata)
 746                                                         break; /* error - truncated file */
 747                                                 if (x + runlen > image_width)
 748                                                         break; /* error - line exceeds width */
 749                                                 bgra.b[0] = fin[0];
 750                                                 bgra.b[1] = fin[1];
 751                                                 bgra.b[2] = fin[2];
 752                                                 bgra.b[3] = fin[3];
 753                                                 fin += pix_inc;
 754                                                 for (;runlen--;x++)
 755                                                         *pixbufi++ = bgra.i;
 756                                         }
 757                                         else
 758                                         {
 759                                                 /* uncompressed - all pixels different color */
 760                                                 runlen++;
 761                                                 if (fin + pix_inc * runlen > enddata)
 762                                                         break; /* error - truncated file */
 763                                                 if (x + runlen > image_width)
 764                                                         break; /* error - line exceeds width */
 765                                                 for (;runlen--;x++)
 766                                                 {
 767                                                         bgra.b[0] = fin[0];
 768                                                         bgra.b[1] = fin[1];
 769                                                         bgra.b[2] = fin[2];
 770                                                         bgra.b[3] = fin[3];
 771                                                         fin += pix_inc;
 772                                                         *pixbufi++ = bgra.i;
 773                                                 }
 774                                         }
 775                                 }
 776
 777                                 if (x != image_width)
 778                                 {
 779                                         /* pixbufi is useless now */
 780                                         printf("LoadTGA: corrupt file\n");
 781                                         break;
 782                                 }
 783                         }
 784                 }
 785                 else
 786                 {
 787                         for (y = 0;y < image_height;y++, pixbufi += row_inci)
 788                         {
 789                                 for (x = 0;x < image_width;)
 790                                 {
 791                                         if (fin >= enddata)
 792                                                 break; /* error - truncated file */
 793                                         runlen = *fin++;
 794                                         if (runlen & 0x80)
 795                                         {
 796                                                 /* RLE - all pixels the same color */
 797                                                 runlen += 1 - 0x80;
 798                                                 if (fin + pix_inc > enddata)
 799                                                         break; /* error - truncated file */
 800                                                 if (x + runlen > image_width)
 801                                                         break; /* error - line exceeds width */
 802                                                 bgra.b[0] = fin[0];
 803                                                 bgra.b[1] = fin[1];
 804                                                 bgra.b[2] = fin[2];
 805                                                 bgra.b[3] = 255;
 806                                                 fin += pix_inc;
 807                                                 for (;runlen--;x++)
 808                                                         *pixbufi++ = bgra.i;
 809                                         }
 810                                         else
 811                                         {
 812                                                 /* uncompressed - all pixels different color */
 813                                                 runlen++;
 814                                                 if (fin + pix_inc * runlen > enddata)
 815                                                         break; /* error - truncated file */
 816                                                 if (x + runlen > image_width)
 817                                                         break; /* error - line exceeds width */
 818                                                 for (;runlen--;x++)
 819                                                 {
 820                                                         bgra.b[0] = fin[0];
 821                                                         bgra.b[1] = fin[1];
 822                                                         bgra.b[2] = fin[2];
 823                                                         bgra.b[3] = 255;
 824                                                         fin += pix_inc;
 825                                                         *pixbufi++ = bgra.i;
 826                                                 }
 827                                         }
 828                                 }
 829
 830                                 if (x != image_width)
 831                                 {
 832                                         /* pixbufi is useless now */
 833                                         printf("LoadTGA: corrupt file\n");
 834                                         break;
 835                                 }
 836                         }
 837                 }
 838                 break;
 839         default:
 840                 /* unknown image_type */
 841                 break;
 842         }
 843
 844         return image_buffer;
 845 }
 846
 847 int Image_WriteTGABGRA (const char *filename, int width, int height, const unsigned char *data)
 848 {
 849         int y;
 850         unsigned char *buffer, *out;
 851         const unsigned char *in, *end;
 852         int ret;
 853
 854         buffer = (unsigned char *)malloc(width*height*4 + 18);
 855
 856         memset (buffer, 0, 18);
 857         buffer[2] = 2;          /* uncompressed type */
 858         buffer[12] = (width >> 0) & 0xFF;
 859         buffer[13] = (width >> 8) & 0xFF;
 860         buffer[14] = (height >> 0) & 0xFF;
 861         buffer[15] = (height >> 8) & 0xFF;
 862
 863         for (y = 3;y < width*height*4;y += 4)
 864                 if (data[y] < 255)
 865                         break;
 866
 867         if (y < width*height*4)
 868         {
 869                 /* save the alpha channel */
 870                 buffer[16] = 32;        /* pixel size */
 871                 buffer[17] = 8; /* 8 bits of alpha */
 872
 873                 /* flip upside down */
 874                 out = buffer + 18;
 875                 for (y = height - 1;y >= 0;y--)
 876                 {
 877                         memcpy(out, data + y * width * 4, width * 4);
 878                         out += width*4;
 879                 }
 880         }
 881         else
 882         {
 883                 /* save only the color channels */
 884                 buffer[16] = 24;        /* pixel size */
 885                 buffer[17] = 0; /* 8 bits of alpha */
 886
 887                 /* truncate bgra to bgr and flip upside down */
 888                 out = buffer + 18;
 889                 for (y = height - 1;y >= 0;y--)
 890                 {
 891                         in = data + y * width * 4;
 892                         end = in + width * 4;
 893                         for (;in < end;in += 4)
 894                         {
 895                                 *out++ = in[0];
 896                                 *out++ = in[1];
 897                                 *out++ = in[2];
 898                         }
 899                 }
 900         }
 901         ret = FS_WriteFile (filename, buffer, out - buffer);
 902
 903         free(buffer);
 904
 905         return ret;
 906 }
 907 /* START stuff that originates from image.c in DarkPlaces */
 908
 909 int usage(const char *me)
 910 {
 911         printf("Usage: %s <infile_norm.tga> <outfile_normandheight.tga> [<scale> [<offset> [<infile_ref.tga>]]] (get heightmap from normalmap)\n", me);
 912         printf("or:    %s <infile_height.tga> <outfile_normandheight.tga> -1 [<scale>] (read from B, Diff)\n", me);
 913         printf("or:    %s <infile_height.tga> <outfile_normandheight.tga> -2 [<scale>] (read from G, Diff)\n", me);
 914         printf("or:    %s <infile_height.tga> <outfile_normandheight.tga> -3 [<scale>] (read from R, Diff)\n", me);
 915         printf("or:    %s <infile_height.tga> <outfile_normandheight.tga> -4 [<scale>] (read from A, Diff)\n", me);
 916         printf("or:    %s <infile_height.tga> <outfile_normandheight.tga> -5 [<scale>] (read from (R+G+B)/3, Diff)\n", me);
 917         printf("or:    %s <infile_height.tga> <outfile_normandheight.tga> -6 [<scale>] (read from Y, Diff)\n", me);
 918         printf("or:    %s <infile_height.tga> <outfile_normandheight.tga> -7 [<scale>] (read from B, FFT)\n", me);
 919         printf("or:    %s <infile_height.tga> <outfile_normandheight.tga> -8 [<scale>] (read from G, FFT)\n", me);
 920         printf("or:    %s <infile_height.tga> <outfile_normandheight.tga> -9 [<scale>] (read from R, FFT)\n", me);
 921         printf("or:    %s <infile_height.tga> <outfile_normandheight.tga> -10 [<scale>] (read from A, FFT)\n", me);
 922         printf("or:    %s <infile_height.tga> <outfile_normandheight.tga> -11 [<scale>] (read from (R+G+B)/3, FFT)\n", me);
 923         printf("or:    %s <infile_height.tga> <outfile_normandheight.tga> -12 [<scale>] (read from Y, FFT)\n", me);
 924         return 1;
 925 }
 926
 927 int main(int argc, char **argv)
 928 {
 929         const char *infile, *outfile, *reffile;
 930         double scale, offset;
 931         int nmaplen, w, h;
 932         unsigned char *nmapdata, *nmap, *refmap;
 933
 934         if(argc > 1)
 935                 infile = argv[1];
 936         else
 937                 return usage(*argv);
 938
 939         if(argc > 2)
 940                 outfile = argv[2];
 941         else
 942                 return usage(*argv);
 943
 944         if(argc > 3)
 945                 scale = atof(argv[3]);
 946         else
 947                 scale = 0;
 948
 949         if(argc > 4)
 950                 offset = atof(argv[4]);
 951         else
 952                 offset = (scale<0) ? 1 : 0;
 953
 954         if(argc > 5)
 955                 reffile = argv[5];
 956         else
 957                 reffile = NULL;
 958
 959         nmapdata = FS_LoadFile(infile, &nmaplen);
 960         if(!nmapdata)
 961         {
 962                 printf("FS_LoadFile failed\n");
 963                 return 2;
 964         }
 965         nmap = LoadTGA_BGRA(nmapdata, nmaplen);
 966         free(nmapdata);
 967         if(!nmap)
 968         {
 969                 printf("LoadTGA_BGRA failed\n");
 970                 return 2;
 971         }
 972         w = image_width;
 973         h = image_height;
 974
 975         if(reffile)
 976         {
 977                 nmapdata = FS_LoadFile(infile, &nmaplen);
 978                 if(!nmapdata)
 979                 {
 980                         printf("FS_LoadFile failed\n");
 981                         return 2;
 982                 }
 983                 refmap = LoadTGA_BGRA(nmapdata, nmaplen);
 984                 free(nmapdata);
 985                 if(!refmap)
 986                 {
 987                         printf("LoadTGA_BGRA failed\n");
 988                         return 2;
 989                 }
 990                 if(image_width != w || image_height != h)
 991                 {
 992                         printf("reference map must have same size as input normalmap\n");
 993                         return 2;
 994                 }
 995         }
 996
 997         if(scale < -6)
 998                 hmap_to_nmap(nmap, image_width, image_height, -scale-7, offset);
 999         else if(scale < 0)
1000                 hmap_to_nmap_local(nmap, image_width, image_height, -scale-1, offset);
1001         else
1002                 nmap_to_hmap(nmap, refmap, image_width, image_height, scale, offset);
1003         if(!Image_WriteTGABGRA(outfile, image_width, image_height, nmap))
1004         {
1005                 printf("Image_WriteTGABGRA failed\n");
1006                 free(nmap);
1007                 return 2;
1008         }
1009         free(nmap);
1010         return 0;
1011 }