Remove -Wno-unused-but-set-variable
[xonotic/netradiant.git] / tools / quake3 / q3data / images.c
1 /*
2    Copyright (C) 1999-2006 Id Software, Inc. and contributors.
3    For a list of contributors, see the accompanying CONTRIBUTORS file.
4
5    This file is part of GtkRadiant.
6
7    GtkRadiant is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 2 of the License, or
10    (at your option) any later version.
11
12    GtkRadiant is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with GtkRadiant; if not, write to the Free Software
19    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
20  */
21
22 #include "q3data.h"
23
24 byte            *byteimage, *lbmpalette;
25 int byteimagewidth, byteimageheight;
26
27
28 char mip_prefix[1024];              // directory to dump the textures in
29
30 qboolean colormap_issued;
31 byte colormap_palette[768];
32
33 /*
34    ==============
35    Cmd_Grab
36
37    $grab filename x y width height
38    ==============
39  */
40 void Cmd_Grab( void ){
41         int xl,yl,w,h,y;
42         byte            *cropped;
43         char savename[1024];
44         char dest[1024];
45
46         GetToken( qfalse );
47
48         if ( token[0] == '/' || token[0] == '\\' ) {
49                 sprintf( savename, "%s%s.pcx", writedir, token + 1 );
50         }
51         else{
52                 sprintf( savename, "%spics/%s.pcx", writedir, token );
53         }
54
55         if ( g_release ) {
56                 if ( token[0] == '/' || token[0] == '\\' ) {
57                         sprintf( dest, "%s.pcx", token + 1 );
58                 }
59                 else{
60                         sprintf( dest, "pics/%s.pcx", token );
61                 }
62
63                 ReleaseFile( dest );
64                 return;
65         }
66
67         GetToken( qfalse );
68         xl = atoi( token );
69         GetToken( qfalse );
70         yl = atoi( token );
71         GetToken( qfalse );
72         w = atoi( token );
73         GetToken( qfalse );
74         h = atoi( token );
75
76         if ( xl < 0 || yl < 0 || w < 0 || h < 0 || xl + w > byteimagewidth || yl + h > byteimageheight ) {
77                 Error( "GrabPic: Bad size: %i, %i, %i, %i",xl,yl,w,h );
78         }
79
80         // crop it to the proper size
81         cropped = malloc( w * h );
82         for ( y = 0 ; y < h ; y++ )
83         {
84                 memcpy( cropped + y * w, byteimage + ( y + yl ) * byteimagewidth + xl, w );
85         }
86
87         // save off the new image
88         printf( "saving %s\n", savename );
89         CreatePath( savename );
90         WritePCXfile( savename, cropped, w, h, lbmpalette );
91
92         free( cropped );
93 }
94
95 /*
96    ==============
97    Cmd_Raw
98
99    $grab filename x y width height
100    ==============
101  */
102 void Cmd_Raw( void ){
103         int xl,yl,w,h,y;
104         byte            *cropped;
105         char savename[1024];
106         char dest[1024];
107
108         GetToken( qfalse );
109
110         sprintf( savename, "%s%s.lmp", writedir, token );
111
112         if ( g_release ) {
113                 sprintf( dest, "%s.lmp", token );
114                 ReleaseFile( dest );
115                 return;
116         }
117
118         GetToken( qfalse );
119         xl = atoi( token );
120         GetToken( qfalse );
121         yl = atoi( token );
122         GetToken( qfalse );
123         w = atoi( token );
124         GetToken( qfalse );
125         h = atoi( token );
126
127         if ( xl < 0 || yl < 0 || w < 0 || h < 0 || xl + w > byteimagewidth || yl + h > byteimageheight ) {
128                 Error( "GrabPic: Bad size: %i, %i, %i, %i",xl,yl,w,h );
129         }
130
131         // crop it to the proper size
132         cropped = malloc( w * h );
133         for ( y = 0 ; y < h ; y++ )
134         {
135                 memcpy( cropped + y * w, byteimage + ( y + yl ) * byteimagewidth + xl, w );
136         }
137
138         // save off the new image
139         printf( "saving %s\n", savename );
140         CreatePath( savename );
141
142         SaveFile( savename, cropped, w * h );
143
144         free( cropped );
145 }
146
147 /*
148    =============================================================================
149
150    COLORMAP GRABBING
151
152    =============================================================================
153  */
154
155 /*
156    ===============
157    BestColor
158    ===============
159  */
160 byte BestColor( int r, int g, int b, int start, int stop ){
161         int i;
162         int dr, dg, db;
163         int bestdistortion, distortion;
164         int bestcolor;
165         byte    *pal;
166
167 //
168 // let any color go to 0 as a last resort
169 //
170         bestdistortion = 256 * 256 * 4;
171         bestcolor = 0;
172
173         pal = colormap_palette + start * 3;
174         for ( i = start ; i <= stop ; i++ )
175         {
176                 dr = r - (int)pal[0];
177                 dg = g - (int)pal[1];
178                 db = b - (int)pal[2];
179                 pal += 3;
180                 distortion = dr * dr + dg * dg + db * db;
181                 if ( distortion < bestdistortion ) {
182                         if ( !distortion ) {
183                                 return i;       // perfect match
184
185                         }
186                         bestdistortion = distortion;
187                         bestcolor = i;
188                 }
189         }
190
191         return bestcolor;
192 }
193
194
195 /*
196    ==============
197    Cmd_Colormap
198
199    $colormap filename
200
201    the brightes colormap is first in the table (FIXME: reverse this now?)
202
203    64 rows of 256 : lightmaps
204    256 rows of 256 : translucency table
205    ==============
206  */
207 void Cmd_Colormap( void ){
208         int levels, brights;
209         int l, c;
210         float frac, red, green, blue;
211         float range;
212         byte    *cropped, *lump_p;
213         char savename[1024];
214         char dest[1024];
215
216         colormap_issued = qtrue;
217         if ( !g_release ) {
218                 memcpy( colormap_palette, lbmpalette, 768 );
219         }
220
221         if ( !TokenAvailable() ) { // just setting colormap_issued
222                 return;
223         }
224
225         GetToken( qfalse );
226         sprintf( savename, "%spics/%s.pcx", writedir, token );
227
228         if ( g_release ) {
229                 sprintf( dest, "pics/%s.pcx", token );
230                 ReleaseFile( dest );
231                 return;
232         }
233
234         range = 2;
235         levels = 64;
236         brights = 1;    // ignore 255 (transparent)
237
238         cropped = malloc( ( levels + 256 ) * 256 );
239         lump_p = cropped;
240
241 // shaded levels
242         for ( l = 0; l < levels; l++ )
243         {
244                 frac = range - range * (float)l / ( levels - 1 );
245                 for ( c = 0 ; c < 256 - brights ; c++ )
246                 {
247                         red = lbmpalette[c * 3];
248                         green = lbmpalette[c * 3 + 1];
249                         blue = lbmpalette[c * 3 + 2];
250
251                         red = (int)( red * frac + 0.5 );
252                         green = (int)( green * frac + 0.5 );
253                         blue = (int)( blue * frac + 0.5 );
254
255 //
256 // note: 254 instead of 255 because 255 is the transparent color, and we
257 // don't want anything remapping to that
258 // don't use color 0, because NT can't remap that (or 255)
259 //
260                         *lump_p++ = BestColor( red,green,blue, 1, 254 );
261                 }
262
263                 // fullbrights allways stay the same
264                 for ( ; c < 256 ; c++ )
265                         *lump_p++ = c;
266         }
267
268 // 66% transparancy table
269         for ( l = 0; l < 255; l++ )
270         {
271                 for ( c = 0 ; c < 255 ; c++ )
272                 {
273                         red = lbmpalette[c * 3] * 0.33 + lbmpalette[l * 3] * 0.66;
274                         green = lbmpalette[c * 3 + 1] * 0.33 + lbmpalette[l * 3 + 1] * 0.66;
275                         blue = lbmpalette[c * 3 + 2] * 0.33 + lbmpalette[l * 3 + 2] * 0.66;
276
277                         *lump_p++ = BestColor( red,green,blue, 1, 254 );
278                 }
279                 *lump_p++ = 255;
280         }
281         for ( c = 0 ; c < 256 ; c++ )
282                 *lump_p++ = 255;
283
284         // save off the new image
285         printf( "saving %s\n", savename );
286         CreatePath( savename );
287         WritePCXfile( savename, cropped, 256, levels + 256, lbmpalette );
288
289         free( cropped );
290 }
291
292 /*
293    =============================================================================
294
295    MIPTEX GRABBING
296
297    =============================================================================
298  */
299
300 byte pixdata[256];
301
302 int d_red, d_green, d_blue;
303
304 byte palmap[32][32][32];
305 qboolean palmap_built;
306
307 /*
308    =============
309    FindColor
310    =============
311  */
312 int FindColor( int r, int g, int b ){
313         int bestcolor;
314
315         if ( r > 255 ) {
316                 r = 255;
317         }
318         if ( r < 0 ) {
319                 r = 0;
320         }
321         if ( g > 255 ) {
322                 g = 255;
323         }
324         if ( g < 0 ) {
325                 g = 0;
326         }
327         if ( b > 255 ) {
328                 b = 255;
329         }
330         if ( b < 0 ) {
331                 b = 0;
332         }
333 #ifndef TABLECOLORS
334         bestcolor = BestColor( r, g, b, 0, 254 );
335 #else
336         bestcolor = palmap[r >> 3][g >> 3][b >> 3];
337 #endif
338
339         return bestcolor;
340 }
341
342
343 void BuildPalmap( void ){
344 #ifdef TABLECOLORS
345         int r, g, b;
346         int bestcolor;
347
348         if ( palmap_built ) {
349                 return;
350         }
351         palmap_built = qtrue;
352
353         for ( r = 4 ; r < 256 ; r += 8 )
354         {
355                 for ( g = 4 ; g < 256 ; g += 8 )
356                 {
357                         for ( b = 4 ; b < 256 ; b += 8 )
358                         {
359                                 bestcolor = BestColor( r, g, b, 1, 254 );
360                                 palmap[r >> 3][g >> 3][b >> 3] = bestcolor;
361                         }
362                 }
363         }
364 #endif
365
366         if ( !colormap_issued ) {
367                 Error( "You must issue a $colormap command first" );
368         }
369
370 }
371
372 /*
373    =============
374    AveragePixels
375    =============
376  */
377 byte AveragePixels( int count ){
378         int r,g,b;
379         int i;
380         int vis;
381         int pix;
382         int bestcolor;
383         byte    *pal;
384
385         vis = 0;
386         r = g = b = 0;
387         for ( i = 0 ; i < count ; i++ )
388         {
389                 pix = pixdata[i];
390
391                 r += lbmpalette[pix * 3];
392                 g += lbmpalette[pix * 3 + 1];
393                 b += lbmpalette[pix * 3 + 2];
394                 vis++;
395         }
396
397         r /= vis;
398         g /= vis;
399         b /= vis;
400
401         // error diffusion
402         r += d_red;
403         g += d_green;
404         b += d_blue;
405
406 //
407 // find the best color
408 //
409         bestcolor = FindColor( r, g, b );
410
411         // error diffusion
412         pal = colormap_palette + bestcolor * 3;
413         d_red = r - (int)pal[0];
414         d_green = g - (int)pal[1];
415         d_blue = b - (int)pal[2];
416
417         return bestcolor;
418 }
419
420
421
422 /*
423    =============================================================================
424
425    ENVIRONMENT MAP GRABBING
426
427    Creates six pcx files from tga files without any palette edge seams
428    also copies the tga files for GL rendering.
429    =============================================================================
430  */
431
432 // 3dstudio environment map suffixes
433 char    *suf[6] = {"rt", "ft", "lf", "bk", "up", "dn"};
434
435 /*
436    =================
437    Cmd_Environment
438    =================
439  */
440 void Cmd_Environment( void ){
441         char name[1024];
442         int i, x, y;
443         byte image[256 * 256];
444         byte    *tga;
445
446         GetToken( qfalse );
447
448         if ( g_release ) {
449                 for ( i = 0 ; i < 6 ; i++ )
450                 {
451                         sprintf( name, "env/%s%s.pcx", token, suf[i] );
452                         ReleaseFile( name );
453                         sprintf( name, "env/%s%s.tga", token, suf[i] );
454                         ReleaseFile( name );
455                 }
456                 return;
457         }
458         // get the palette
459         BuildPalmap();
460
461         sprintf( name, "%senv/", gamedir );
462         CreatePath( name );
463
464         // convert the images
465         for ( i = 0 ; i < 6 ; i++ )
466         {
467                 sprintf( name, "%senv/%s%s.tga", gamedir, token, suf[i] );
468                 printf( "loading %s...\n", name );
469                 LoadTGA( name, &tga, NULL, NULL );
470
471                 for ( y = 0 ; y < 256 ; y++ )
472                 {
473                         for ( x = 0 ; x < 256 ; x++ )
474                         {
475                                 image[y * 256 + x] = FindColor( tga[( y * 256 + x ) * 4 + 0],tga[( y * 256 + x ) * 4 + 1],tga[( y * 256 + x ) * 4 + 2] );
476                         }
477                 }
478                 free( tga );
479                 sprintf( name, "%senv/%s%s.pcx", writedir, token, suf[i] );
480                 if ( FileTime( name ) != -1 ) {
481                         printf( "%s already exists, not overwriting.\n", name );
482                 }
483                 else{
484                         WritePCXfile( name, image, 256, 256, colormap_palette );
485                 }
486         }
487 }