B, G, R, A
[xonotic/xonotic.git] / 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, 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(scale == 0)
118         {
119 #ifdef C99
120                 vmin = vmax = creal(imgspace1[0]);
121 #else
122                 vmin = vmax = imgspace1[0][0];
123 #endif
124                 for(y = 0; y < h; ++y)
125                 for(x = 0; x < w; ++x)
126                 {
127 #ifdef C99
128                         v = creal(imgspace1[(w*y+x)]);
129 #else
130                         v = imgspace1[(w*y+x)][0];
131 #endif
132                         if(v < vmin)
133                                 vmin = v;
134                         if(v > vmax)
135                                 vmax = v;
136                 }
137
138                 vmin /= (w*h);
139                 vmax /= (w*h);
140
141                 /*
142                  * map vmin to -1
143                  * map vmax to +1
144                  */
145                 scale = 2 / (vmax - vmin);
146                 offset = -(vmax + vmin) / (vmax - vmin);
147
148                 printf("Autocomputed scale: %f\nAutocomputed offset: %f\n", scale, offset);
149         }
150
151         scale /= (w*h);
152
153         for(y = 0; y < h; ++y)
154         for(x = 0; x < w; ++x)
155         {
156 #ifdef C99
157                 v = creal(imgspace1[(w*y+x)]);
158 #else
159                 v = imgspace1[(w*y+x)][0];
160 #endif
161                 v = v * scale + offset;
162                 if(v < -1)
163                         v = -1;
164                 if(v > 1)
165                         v = 1;
166                 map[(w*y+x)*4+3] = floor(128.5 + 127 * v);
167         }
168
169         fftw_destroy_plan(i12f1);
170         fftw_destroy_plan(i22f2);
171         fftw_destroy_plan(f12i1);
172
173         fftw_free(freqspace2);
174         fftw_free(freqspace1);
175         fftw_free(imgspace2);
176         fftw_free(imgspace1);
177 }
178
179 void hmap_to_nmap(unsigned char *map, int w, int h, int src_chan, double scale)
180 {
181         int x, y;
182         double nx, ny, nz;
183         double v;
184 #ifndef C99
185         double save;
186 #endif
187
188         fftw_complex *imgspace1 = fftw_malloc(w*h * sizeof(fftw_complex));
189         fftw_complex *imgspace2 = fftw_malloc(w*h * sizeof(fftw_complex));
190         fftw_complex *freqspace1 = fftw_malloc(w*h * sizeof(fftw_complex));
191         fftw_complex *freqspace2 = fftw_malloc(w*h * sizeof(fftw_complex));
192         fftw_plan i12f1 = fftw_plan_dft_2d(w, h, imgspace1, freqspace1, FFTW_FORWARD, FFTW_ESTIMATE);
193         fftw_plan f12i1 = fftw_plan_dft_2d(w, h, freqspace1, imgspace1, FFTW_BACKWARD, FFTW_ESTIMATE);
194         fftw_plan f22i2 = fftw_plan_dft_2d(w, h, freqspace2, imgspace2, FFTW_BACKWARD, FFTW_ESTIMATE);
195
196         for(y = 0; y < h; ++y)
197         for(x = 0; x < w; ++x)
198         {
199                 switch(src_chan)
200                 {
201                         case 0:
202                         case 1:
203                         case 2:
204                         case 3:
205                                 v = map[(w*y+x)*4+src_chan];
206                                 break;
207                         case 4:
208                                 v = (map[(w*y+x)*4+0] + map[(w*y+x)*4+1] + map[(w*y+x)*4+2]) / 3;
209                                 break;
210                         default:
211                         case 5:
212                                 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);
213                                 break;
214                 }
215 #ifdef C99
216                 imgspace1[(w*y+x)] = (v - 128.0) / 127.0;
217 #else
218                 imgspace1[(w*y+x)][0] = (v - 128.0) / 127.0;
219                 imgspace1[(w*y+x)][1] = 0;
220 #endif
221                 map[(w*y+x)*4+3] = floor(v + 0.5);
222         }
223
224         /* see http://www.gamedev.net/community/forums/topic.asp?topic_id=561430 */
225
226         fftw_execute(i12f1);
227         
228         for(y = 0; y < h; ++y)
229         for(x = 0; x < w; ++x)
230         {
231                 int fx = x;
232                 int fy = y;
233                 if(fx > w/2)
234                         fx -= w;
235                 if(fy > h/2)
236                         fy -= h;
237 #ifdef C99
238                 /* a lowpass to prevent the worst */
239                 freqspace1[(w*y+x)] *= 1 - pow(abs(fx) / (double)(w/2), 1);
240                 freqspace1[(w*y+x)] *= 1 - pow(abs(fy) / (double)(h/2), 1);
241
242                 freqspace2[(w*y+x)] = TWO_PI*I * fy * freqspace1[(w*y+x)]; /* y derivative */
243                 freqspace1[(w*y+x)] = TWO_PI*I * fx * freqspace1[(w*y+x)]; /* x derivative */
244 #else
245                 /* a lowpass to prevent the worst */
246                 freqspace1[(w*y+x)][0] *= 1 - pow(abs(fx) / (double)(w/2), 1);
247                 freqspace1[(w*y+x)][1] *= 1 - pow(abs(fx) / (double)(w/2), 1);
248                 freqspace1[(w*y+x)][0] *= 1 - pow(abs(fy) / (double)(h/2), 1);
249                 freqspace1[(w*y+x)][1] *= 1 - pow(abs(fy) / (double)(h/2), 1);
250
251                 freqspace2[(w*y+x)][0] = -TWO_PI * fy * freqspace1[(w*y+x)][1]; /* y derivative */
252                 freqspace2[(w*y+x)][1] =  TWO_PI * fy * freqspace1[(w*y+x)][0];
253                 save = freqspace1[(w*y+x)][0];
254                 freqspace1[(w*y+x)][0] = -TWO_PI * fx * freqspace1[(w*y+x)][1]; /* x derivative */
255                 freqspace1[(w*y+x)][1] =  TWO_PI * fx * save;
256 #endif
257         }
258
259         fftw_execute(f12i1);
260         fftw_execute(f22i2);
261
262         scale /= (w*h);
263
264         for(y = 0; y < h; ++y)
265         for(x = 0; x < w; ++x)
266         {
267 #ifdef C99
268                 nx = creal(imgspace1[(w*y+x)]);
269                 ny = creal(imgspace2[(w*y+x)]);
270 #else
271                 nx = imgspace1[(w*y+x)][0];
272                 ny = imgspace2[(w*y+x)][0];
273 #endif
274                 nx /= w;
275                 ny /= h;
276                 nz = -1 / scale;
277                 v = -sqrt(nx*nx + ny*ny + nz*nz);
278                 nx /= v;
279                 ny /= v;
280                 nz /= v;
281                 ny = -ny; /* DP inverted normals */
282                 map[(w*y+x)*4+2] = floor(128 + 127.5 * nx);
283                 map[(w*y+x)*4+1] = floor(128 + 127.5 * ny);
284                 map[(w*y+x)*4+0] = floor(128 + 127.5 * nz);
285         }
286
287         fftw_destroy_plan(i12f1);
288         fftw_destroy_plan(f12i1);
289         fftw_destroy_plan(f22i2);
290
291         fftw_free(freqspace2);
292         fftw_free(freqspace1);
293         fftw_free(imgspace2);
294         fftw_free(imgspace1);
295 }
296
297 void hmap_to_nmap_local(unsigned char *map, int w, int h, int src_chan, double scale)
298 {
299         int x, y;
300         double nx, ny, nz;
301         double v;
302         int i, j;
303         double *img_reduced = malloc(w*h * sizeof(double));
304         static const double filter[3][3] = { /* filter to derive one component */
305                 { -1, 0, 1 },
306                 { -2, 0, 2 },
307                 { -1, 0, 1 }
308         };
309         static const double filter_mult = 0.125;
310
311         for(y = 0; y < h; ++y)
312         for(x = 0; x < w; ++x)
313         {
314                 switch(src_chan)
315                 {
316                         case 0:
317                         case 1:
318                         case 2:
319                         case 3:
320                                 v = map[(w*y+x)*4+src_chan];
321                                 break;
322                         case 4:
323                                 v = (map[(w*y+x)*4+0] + map[(w*y+x)*4+1] + map[(w*y+x)*4+2]) / 3;
324                                 break;
325                         default:
326                         case 5:
327                                 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);
328                                 break;
329                 }
330                 img_reduced[(w*y+x)] = (v - 128.0) / 127.0;
331                 map[(w*y+x)*4+3] = floor(v + 0.5);
332         }
333
334         for(y = 0; y < h; ++y)
335         for(x = 0; x < w; ++x)
336         {
337                 nz = -1 / (scale * filter_mult);
338                 nx = ny = 0;
339
340                 for(i = -(int)(sizeof(filter) / sizeof(*filter)) / 2; i <= (int)(sizeof(filter) / sizeof(*filter)) / 2; ++i)
341                         for(j = -(int)(sizeof(*filter) / sizeof(**filter)) / 2; j <= (int)(sizeof(*filter) / sizeof(**filter)) / 2; ++j)
342                         {
343                                 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];
344                                 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];
345                         }
346
347                 v = -sqrt(nx*nx + ny*ny + nz*nz);
348                 nx /= v;
349                 ny /= v;
350                 nz /= v;
351                 ny = -ny; /* DP inverted normals */
352                 map[(w*y+x)*4+2] = floor(128 + 127.5 * nx);
353                 map[(w*y+x)*4+1] = floor(128 + 127.5 * ny);
354                 map[(w*y+x)*4+0] = floor(128 + 127.5 * nz);
355         }
356
357         free(img_reduced);
358 }
359
360 unsigned char *FS_LoadFile(const char *fn, int *len)
361 {
362         unsigned char *buf = NULL;
363         int n;
364         FILE *f = fopen(fn, "rb");
365         *len = 0;
366         if(!f)
367                 return NULL;
368         for(;;)
369         {
370                 buf = realloc(buf, *len + 65536);
371                 if(!buf)
372                 {
373                         fclose(f);
374                         free(buf);
375                         *len = 0;
376                         return NULL;
377                 }
378                 n = fread(buf + *len, 1, 65536, f);
379                 if(n < 0)
380                 {
381                         fclose(f);
382                         free(buf);
383                         *len = 0;
384                         return NULL;
385                 }
386                 *len += n;
387                 if(n < 65536)
388                         break;
389         }
390         return buf;
391 }
392
393 int FS_WriteFile(const char *fn, unsigned char *data, int len)
394 {
395         FILE *f = fopen(fn, "wb");
396         if(!f)
397                 return 0;
398         if(fwrite(data, len, 1, f) != 1)
399         {
400                 fclose(f);
401                 return 0;
402         }
403         if(fclose(f))
404                 return 0;
405         return 1;
406 }
407
408 /* START stuff that originates from image.c in DarkPlaces */
409 int image_width, image_height;
410
411 typedef struct _TargaHeader
412 {
413         unsigned char   id_length, colormap_type, image_type;
414         unsigned short  colormap_index, colormap_length;
415         unsigned char   colormap_size;
416         unsigned short  x_origin, y_origin, width, height;
417         unsigned char   pixel_size, attributes;
418 }
419 TargaHeader;
420
421 void PrintTargaHeader(TargaHeader *t)
422 {
423         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);
424 }
425
426 unsigned char *LoadTGA_BGRA (const unsigned char *f, int filesize)
427 {
428         int x, y, pix_inc, row_inci, runlen, alphabits;
429         unsigned char *image_buffer;
430         unsigned int *pixbufi;
431         const unsigned char *fin, *enddata;
432         TargaHeader targa_header;
433         unsigned int palettei[256];
434         union
435         {
436                 unsigned int i;
437                 unsigned char b[4];
438         }
439         bgra;
440
441         if (filesize < 19)
442                 return NULL;
443
444         enddata = f + filesize;
445
446         targa_header.id_length = f[0];
447         targa_header.colormap_type = f[1];
448         targa_header.image_type = f[2];
449
450         targa_header.colormap_index = f[3] + f[4] * 256;
451         targa_header.colormap_length = f[5] + f[6] * 256;
452         targa_header.colormap_size = f[7];
453         targa_header.x_origin = f[8] + f[9] * 256;
454         targa_header.y_origin = f[10] + f[11] * 256;
455         targa_header.width = image_width = f[12] + f[13] * 256;
456         targa_header.height = image_height = f[14] + f[15] * 256;
457         targa_header.pixel_size = f[16];
458         targa_header.attributes = f[17];
459
460         if (image_width > 32768 || image_height > 32768 || image_width <= 0 || image_height <= 0)
461         {
462                 printf("LoadTGA: invalid size\n");
463                 PrintTargaHeader(&targa_header);
464                 return NULL;
465         }
466
467         /* advance to end of header */
468         fin = f + 18;
469
470         /* skip TARGA image comment (usually 0 bytes) */
471         fin += targa_header.id_length;
472
473         /* read/skip the colormap if present (note: according to the TARGA spec it */
474         /* can be present even on 1color or greyscale images, just not used by */
475         /* the image data) */
476         if (targa_header.colormap_type)
477         {
478                 if (targa_header.colormap_length > 256)
479                 {
480                         printf("LoadTGA: only up to 256 colormap_length supported\n");
481                         PrintTargaHeader(&targa_header);
482                         return NULL;
483                 }
484                 if (targa_header.colormap_index)
485                 {
486                         printf("LoadTGA: colormap_index not supported\n");
487                         PrintTargaHeader(&targa_header);
488                         return NULL;
489                 }
490                 if (targa_header.colormap_size == 24)
491                 {
492                         for (x = 0;x < targa_header.colormap_length;x++)
493                         {
494                                 bgra.b[0] = *fin++;
495                                 bgra.b[1] = *fin++;
496                                 bgra.b[2] = *fin++;
497                                 bgra.b[3] = 255;
498                                 palettei[x] = bgra.i;
499                         }
500                 }
501                 else if (targa_header.colormap_size == 32)
502                 {
503                         memcpy(palettei, fin, targa_header.colormap_length*4);
504                         fin += targa_header.colormap_length * 4;
505                 }
506                 else
507                 {
508                         printf("LoadTGA: Only 32 and 24 bit colormap_size supported\n");
509                         PrintTargaHeader(&targa_header);
510                         return NULL;
511                 }
512         }
513
514         /* check our pixel_size restrictions according to image_type */
515         switch (targa_header.image_type & ~8)
516         {
517         case 2:
518                 if (targa_header.pixel_size != 24 && targa_header.pixel_size != 32)
519                 {
520                         printf("LoadTGA: only 24bit and 32bit pixel sizes supported for type 2 and type 10 images\n");
521                         PrintTargaHeader(&targa_header);
522                         return NULL;
523                 }
524                 break;
525         case 3:
526                 /* set up a palette to make the loader easier */
527                 for (x = 0;x < 256;x++)
528                 {
529                         bgra.b[0] = bgra.b[1] = bgra.b[2] = x;
530                         bgra.b[3] = 255;
531                         palettei[x] = bgra.i;
532                 }
533                 /* fall through to colormap case */
534         case 1:
535                 if (targa_header.pixel_size != 8)
536                 {
537                         printf("LoadTGA: only 8bit pixel size for type 1, 3, 9, and 11 images supported\n");
538                         PrintTargaHeader(&targa_header);
539                         return NULL;
540                 }
541                 break;
542         default:
543                 printf("LoadTGA: Only type 1, 2, 3, 9, 10, and 11 targa RGB images supported, image_type = %i\n", targa_header.image_type);
544                 PrintTargaHeader(&targa_header);
545                 return NULL;
546         }
547
548         if (targa_header.attributes & 0x10)
549         {
550                 printf("LoadTGA: origin must be in top left or bottom left, top right and bottom right are not supported\n");
551                 return NULL;
552         }
553
554         /* number of attribute bits per pixel, we only support 0 or 8 */
555         alphabits = targa_header.attributes & 0x0F;
556         if (alphabits != 8 && alphabits != 0)
557         {
558                 printf("LoadTGA: only 0 or 8 attribute (alpha) bits supported\n");
559                 return NULL;
560         }
561
562         image_buffer = (unsigned char *)malloc(image_width * image_height * 4);
563         if (!image_buffer)
564         {
565                 printf("LoadTGA: not enough memory for %i by %i image\n", image_width, image_height);
566                 return NULL;
567         }
568
569         /* If bit 5 of attributes isn't set, the image has been stored from bottom to top */
570         if ((targa_header.attributes & 0x20) == 0)
571         {
572                 pixbufi = (unsigned int*)image_buffer + (image_height - 1)*image_width;
573                 row_inci = -image_width*2;
574         }
575         else
576         {
577                 pixbufi = (unsigned int*)image_buffer;
578                 row_inci = 0;
579         }
580
581         x = 0;
582         y = 0;
583         pix_inc = 1;
584         if ((targa_header.image_type & ~8) == 2)
585                 pix_inc = (targa_header.pixel_size + 7) / 8;
586         switch (targa_header.image_type)
587         {
588         case 1: /* colormapped, uncompressed */
589         case 3: /* greyscale, uncompressed */
590                 if (fin + image_width * image_height * pix_inc > enddata)
591                         break;
592                 for (y = 0;y < image_height;y++, pixbufi += row_inci)
593                         for (x = 0;x < image_width;x++)
594                                 *pixbufi++ = palettei[*fin++];
595                 break;
596         case 2:
597                 /* BGR or BGRA, uncompressed */
598                 if (fin + image_width * image_height * pix_inc > enddata)
599                         break;
600                 if (targa_header.pixel_size == 32 && alphabits)
601                 {
602                         for (y = 0;y < image_height;y++)
603                                 memcpy(pixbufi + y * (image_width + row_inci), fin + y * image_width * pix_inc, image_width*4);
604                 }
605                 else
606                 {
607                         for (y = 0;y < image_height;y++, pixbufi += row_inci)
608                         {
609                                 for (x = 0;x < image_width;x++, fin += pix_inc)
610                                 {
611                                         bgra.b[0] = fin[0];
612                                         bgra.b[1] = fin[1];
613                                         bgra.b[2] = fin[2];
614                                         bgra.b[3] = 255;
615                                         *pixbufi++ = bgra.i;
616                                 }
617                         }
618                 }
619                 break;
620         case 9: /* colormapped, RLE */
621         case 11: /* greyscale, RLE */
622                 for (y = 0;y < image_height;y++, pixbufi += row_inci)
623                 {
624                         for (x = 0;x < image_width;)
625                         {
626                                 if (fin >= enddata)
627                                         break; /* error - truncated file */
628                                 runlen = *fin++;
629                                 if (runlen & 0x80)
630                                 {
631                                         /* RLE - all pixels the same color */
632                                         runlen += 1 - 0x80;
633                                         if (fin + pix_inc > enddata)
634                                                 break; /* error - truncated file */
635                                         if (x + runlen > image_width)
636                                                 break; /* error - line exceeds width */
637                                         bgra.i = palettei[*fin++];
638                                         for (;runlen--;x++)
639                                                 *pixbufi++ = bgra.i;
640                                 }
641                                 else
642                                 {
643                                         /* uncompressed - all pixels different color */
644                                         runlen++;
645                                         if (fin + pix_inc * runlen > enddata)
646                                                 break; /* error - truncated file */
647                                         if (x + runlen > image_width)
648                                                 break; /* error - line exceeds width */
649                                         for (;runlen--;x++)
650                                                 *pixbufi++ = palettei[*fin++];
651                                 }
652                         }
653
654                         if (x != image_width)
655                         {
656                                 /* pixbufi is useless now */
657                                 printf("LoadTGA: corrupt file\n");
658                                 break;
659                         }
660                 }
661                 break;
662         case 10:
663                 /* BGR or BGRA, RLE */
664                 if (targa_header.pixel_size == 32 && alphabits)
665                 {
666                         for (y = 0;y < image_height;y++, pixbufi += row_inci)
667                         {
668                                 for (x = 0;x < image_width;)
669                                 {
670                                         if (fin >= enddata)
671                                                 break; /* error - truncated file */
672                                         runlen = *fin++;
673                                         if (runlen & 0x80)
674                                         {
675                                                 /* RLE - all pixels the same color */
676                                                 runlen += 1 - 0x80;
677                                                 if (fin + pix_inc > enddata)
678                                                         break; /* error - truncated file */
679                                                 if (x + runlen > image_width)
680                                                         break; /* error - line exceeds width */
681                                                 bgra.b[0] = fin[0];
682                                                 bgra.b[1] = fin[1];
683                                                 bgra.b[2] = fin[2];
684                                                 bgra.b[3] = fin[3];
685                                                 fin += pix_inc;
686                                                 for (;runlen--;x++)
687                                                         *pixbufi++ = bgra.i;
688                                         }
689                                         else
690                                         {
691                                                 /* uncompressed - all pixels different color */
692                                                 runlen++;
693                                                 if (fin + pix_inc * runlen > enddata)
694                                                         break; /* error - truncated file */
695                                                 if (x + runlen > image_width)
696                                                         break; /* error - line exceeds width */
697                                                 for (;runlen--;x++)
698                                                 {
699                                                         bgra.b[0] = fin[0];
700                                                         bgra.b[1] = fin[1];
701                                                         bgra.b[2] = fin[2];
702                                                         bgra.b[3] = fin[3];
703                                                         fin += pix_inc;
704                                                         *pixbufi++ = bgra.i;
705                                                 }
706                                         }
707                                 }
708
709                                 if (x != image_width)
710                                 {
711                                         /* pixbufi is useless now */
712                                         printf("LoadTGA: corrupt file\n");
713                                         break;
714                                 }
715                         }
716                 }
717                 else
718                 {
719                         for (y = 0;y < image_height;y++, pixbufi += row_inci)
720                         {
721                                 for (x = 0;x < image_width;)
722                                 {
723                                         if (fin >= enddata)
724                                                 break; /* error - truncated file */
725                                         runlen = *fin++;
726                                         if (runlen & 0x80)
727                                         {
728                                                 /* RLE - all pixels the same color */
729                                                 runlen += 1 - 0x80;
730                                                 if (fin + pix_inc > enddata)
731                                                         break; /* error - truncated file */
732                                                 if (x + runlen > image_width)
733                                                         break; /* error - line exceeds width */
734                                                 bgra.b[0] = fin[0];
735                                                 bgra.b[1] = fin[1];
736                                                 bgra.b[2] = fin[2];
737                                                 bgra.b[3] = 255;
738                                                 fin += pix_inc;
739                                                 for (;runlen--;x++)
740                                                         *pixbufi++ = bgra.i;
741                                         }
742                                         else
743                                         {
744                                                 /* uncompressed - all pixels different color */
745                                                 runlen++;
746                                                 if (fin + pix_inc * runlen > enddata)
747                                                         break; /* error - truncated file */
748                                                 if (x + runlen > image_width)
749                                                         break; /* error - line exceeds width */
750                                                 for (;runlen--;x++)
751                                                 {
752                                                         bgra.b[0] = fin[0];
753                                                         bgra.b[1] = fin[1];
754                                                         bgra.b[2] = fin[2];
755                                                         bgra.b[3] = 255;
756                                                         fin += pix_inc;
757                                                         *pixbufi++ = bgra.i;
758                                                 }
759                                         }
760                                 }
761
762                                 if (x != image_width)
763                                 {
764                                         /* pixbufi is useless now */
765                                         printf("LoadTGA: corrupt file\n");
766                                         break;
767                                 }
768                         }
769                 }
770                 break;
771         default:
772                 /* unknown image_type */
773                 break;
774         }
775
776         return image_buffer;
777 }
778
779 int Image_WriteTGABGRA (const char *filename, int width, int height, const unsigned char *data)
780 {
781         int y;
782         unsigned char *buffer, *out;
783         const unsigned char *in, *end;
784         int ret;
785
786         buffer = (unsigned char *)malloc(width*height*4 + 18);
787
788         memset (buffer, 0, 18);
789         buffer[2] = 2;          /* uncompressed type */
790         buffer[12] = (width >> 0) & 0xFF;
791         buffer[13] = (width >> 8) & 0xFF;
792         buffer[14] = (height >> 0) & 0xFF;
793         buffer[15] = (height >> 8) & 0xFF;
794
795         for (y = 3;y < width*height*4;y += 4)
796                 if (data[y] < 255)
797                         break;
798
799         if (y < width*height*4)
800         {
801                 /* save the alpha channel */
802                 buffer[16] = 32;        /* pixel size */
803                 buffer[17] = 8; /* 8 bits of alpha */
804
805                 /* flip upside down */
806                 out = buffer + 18;
807                 for (y = height - 1;y >= 0;y--)
808                 {
809                         memcpy(out, data + y * width * 4, width * 4);
810                         out += width*4;
811                 }
812         }
813         else
814         {
815                 /* save only the color channels */
816                 buffer[16] = 24;        /* pixel size */
817                 buffer[17] = 0; /* 8 bits of alpha */
818
819                 /* truncate bgra to bgr and flip upside down */
820                 out = buffer + 18;
821                 for (y = height - 1;y >= 0;y--)
822                 {
823                         in = data + y * width * 4;
824                         end = in + width * 4;
825                         for (;in < end;in += 4)
826                         {
827                                 *out++ = in[0];
828                                 *out++ = in[1];
829                                 *out++ = in[2];
830                         }
831                 }
832         }
833         ret = FS_WriteFile (filename, buffer, out - buffer);
834
835         free(buffer);
836
837         return ret;
838 }
839 /* START stuff that originates from image.c in DarkPlaces */
840
841 int usage(const char *me)
842 {
843         printf("Usage: %s <infile_norm.tga> <outfile_normandheight.tga> [<scale> [<offset>]] (get heightmap from normalmap)\n", me);
844         printf("or:    %s <infile_height.tga> <outfile_normandheight.tga> -1 [<scale>] (read from B, Diff)\n", me);
845         printf("or:    %s <infile_height.tga> <outfile_normandheight.tga> -2 [<scale>] (read from G, Diff)\n", me);
846         printf("or:    %s <infile_height.tga> <outfile_normandheight.tga> -3 [<scale>] (read from R, Diff)\n", me);
847         printf("or:    %s <infile_height.tga> <outfile_normandheight.tga> -4 [<scale>] (read from A, Diff)\n", me);
848         printf("or:    %s <infile_height.tga> <outfile_normandheight.tga> -5 [<scale>] (read from (R+G+B)/3, Diff)\n", me);
849         printf("or:    %s <infile_height.tga> <outfile_normandheight.tga> -6 [<scale>] (read from Y, Diff)\n", me);
850         printf("or:    %s <infile_height.tga> <outfile_normandheight.tga> -7 [<scale>] (read from B, FFT)\n", me);
851         printf("or:    %s <infile_height.tga> <outfile_normandheight.tga> -8 [<scale>] (read from G, FFT)\n", me);
852         printf("or:    %s <infile_height.tga> <outfile_normandheight.tga> -9 [<scale>] (read from R, FFT)\n", me);
853         printf("or:    %s <infile_height.tga> <outfile_normandheight.tga> -10 [<scale>] (read from A, FFT)\n", me);
854         printf("or:    %s <infile_height.tga> <outfile_normandheight.tga> -11 [<scale>] (read from (R+G+B)/3, FFT)\n", me);
855         printf("or:    %s <infile_height.tga> <outfile_normandheight.tga> -12 [<scale>] (read from Y, FFT)\n", me);
856         return 1;
857 }
858
859 int main(int argc, char **argv)
860 {
861         const char *infile, *outfile;
862         double scale, offset;
863         int nmaplen;
864         unsigned char *nmapdata, *nmap;
865
866         if(argc > 1)
867                 infile = argv[1];
868         else
869                 return usage(*argv);
870
871         if(argc > 2)
872                 outfile = argv[2];
873         else
874                 return usage(*argv);
875         
876         if(argc > 3)
877                 scale = atof(argv[3]);
878         else
879                 scale = 0;
880
881         if(argc > 4)
882                 offset = atof(argv[4]);
883         else
884                 offset = 0;
885
886         nmapdata = FS_LoadFile(infile, &nmaplen);
887         if(!nmapdata)
888         {
889                 printf("FS_LoadFile failed\n");
890                 return 2;
891         }
892         nmap = LoadTGA_BGRA(nmapdata, nmaplen);
893         free(nmapdata);
894         if(!nmap)
895         {
896                 printf("LoadTGA_BGRA failed\n");
897                 return 2;
898         }
899         if(scale < -6)
900                 hmap_to_nmap(nmap, image_width, image_height, -scale-7, offset);
901         else if(scale < 0)
902                 hmap_to_nmap_local(nmap, image_width, image_height, -scale-1, offset);
903         else
904                 nmap_to_hmap(nmap, image_width, image_height, scale, offset);
905         if(!Image_WriteTGABGRA(outfile, image_width, image_height, nmap))
906         {
907                 printf("Image_WriteTGABGRA failed\n");
908                 free(nmap);
909                 return 2;
910         }
911         free(nmap);
912         return 0;
913 }