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