build dumpmine.c for editor
[btb/d2x.git] / 2d / bitmap.c
1 /* $Id: bitmap.c,v 1.7 2004-08-28 23:17:45 schaffner Exp $ */
2 /*
3 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
4 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
5 END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
6 ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
7 IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
8 SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
9 FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
10 CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
11 AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.
12 COPYRIGHT 1993-1998 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
13 */
14
15 /*
16  *
17  * Graphical routines for manipulating grs_bitmaps.
18  *
19  */
20
21 #ifdef HAVE_CONFIG_H
22 #include <conf.h>
23 #endif
24
25 #include <stdlib.h>
26 #include <stdio.h>
27
28 #include "u_mem.h"
29
30
31 #include "gr.h"
32 #include "grdef.h"
33 #include "u_dpmi.h"
34 #include "error.h"
35
36 #if defined(POLY_ACC)
37 #include "poly_acc.h"
38 #endif
39
40 #ifdef OGL
41 #include "ogl_init.h"
42 #endif
43
44 void gr_set_bitmap_data (grs_bitmap *bm, unsigned char *data)
45 {
46 #ifdef OGL
47 //      if (bm->bm_data!=data)
48                 ogl_freebmtexture(bm);
49 #endif
50         bm->bm_data = data;
51 #ifdef D1XD3D
52         Assert (bm->iMagic == BM_MAGIC_NUMBER);
53         Win32_SetTextureBits (bm, data, bm->bm_flags & BM_FLAG_RLE);
54 #endif
55 }
56
57 grs_bitmap *gr_create_bitmap(int w, int h )
58 {
59         return gr_create_bitmap_raw (w, h, d_malloc( MAX_BMP_SIZE(w, h) ));
60 }
61
62 grs_bitmap *gr_create_bitmap_raw(int w, int h, unsigned char * raw_data )
63 {
64     grs_bitmap *new;
65
66     new = (grs_bitmap *)d_malloc( sizeof(grs_bitmap) );
67         gr_init_bitmap (new, 0, 0, 0, w, h, w, raw_data);
68
69     return new;
70 }
71
72
73 #if defined(POLY_ACC)
74 //
75 //  Creates a bitmap of the requested size and type.
76 //    w, and h are in pixels.
77 //    type is a BM_... and is used to set the rowsize.
78 //    if data is NULL, memory is allocated, otherwise data is used for bm_data.
79 //
80 //  This function is used only by the polygon accelerator code to handle the mixture of 15bit and
81 //  8bit bitmaps.
82 //
83 grs_bitmap *gr_create_bitmap2(int w, int h, int type, void *data )
84 {
85         grs_bitmap *new;
86
87         new = (grs_bitmap *)malloc( sizeof(grs_bitmap) );
88         new->bm_x = 0;
89         new->bm_y = 0;
90         new->bm_w = w;
91         new->bm_h = h;
92         new->bm_flags = 0;
93     new->bm_type = type;
94     switch(type)
95     {
96         case BM_LINEAR:     new->bm_rowsize = w;            break;
97         case BM_LINEAR15:   new->bm_rowsize = w*PA_BPP;     break;
98         default: Int3();    // unsupported type.
99     }
100     if(data)
101         new->bm_data = data;
102     else
103         new->bm_data = malloc(new->bm_rowsize * new->bm_h);
104         new->bm_handle = 0;
105
106         return new;
107 }
108 #endif
109
110 void gr_init_bitmap( grs_bitmap *bm, int mode, int x, int y, int w, int h, int bytesperline, unsigned char * data ) // TODO: virtualize
111 {
112 #ifdef D1XD3D
113         Assert (bm->iMagic != BM_MAGIC_NUMBER || bm->pvSurface == NULL);
114 #endif
115
116         bm->bm_x = x;
117         bm->bm_y = y;
118         bm->bm_w = w;
119         bm->bm_h = h;
120         bm->bm_flags = 0;
121         bm->bm_type = mode;
122         bm->bm_rowsize = bytesperline;
123
124         bm->bm_data = NULL;
125 #ifdef D1XD3D
126         bm->iMagic = BM_MAGIC_NUMBER;
127         bm->pvSurface = NULL;
128 #endif
129
130 #ifdef D1XD3D
131         Win32_CreateTexture (bm);
132 #endif
133 #ifdef OGL
134         bm->bm_parent=NULL;bm->gltexture=NULL;
135 #endif
136
137 //      if (data != 0)
138                 gr_set_bitmap_data (bm, data);
139 /*
140         else
141                 gr_set_bitmap_data (bm, d_malloc( MAX_BMP_SIZE(w, h) ));
142 */
143
144 #ifdef BITMAP_SELECTOR
145         bm->bm_selector = 0;
146 #endif
147 }
148
149 void gr_init_bitmap_alloc( grs_bitmap *bm, int mode, int x, int y, int w, int h, int bytesperline)
150 {
151         gr_init_bitmap(bm, mode, x, y, w, h, bytesperline, 0);
152         gr_set_bitmap_data(bm, d_malloc( MAX_BMP_SIZE(w, h) ));
153 }
154
155 void gr_init_bitmap_data (grs_bitmap *bm) // TODO: virtulize
156 {
157         bm->bm_data = NULL;
158 #ifdef D1XD3D
159         Assert (bm->iMagic != BM_MAGIC_NUMBER);
160         bm->iMagic = BM_MAGIC_NUMBER;
161         bm->pvSurface = NULL;
162 #endif
163 #ifdef OGL
164 //      ogl_freebmtexture(bm);//not what we want here.
165         bm->bm_parent=NULL;bm->gltexture=NULL;
166 #endif
167 }
168
169 grs_bitmap *gr_create_sub_bitmap(grs_bitmap *bm, int x, int y, int w, int h )
170 {
171     grs_bitmap *new;
172
173     new = (grs_bitmap *)d_malloc( sizeof(grs_bitmap) );
174         gr_init_sub_bitmap (new, bm, x, y, w, h);
175
176         return new;
177 }
178
179 void gr_free_bitmap(grs_bitmap *bm )
180 {
181         gr_free_bitmap_data (bm);
182         if (bm!=NULL)
183                 d_free(bm);
184 }
185
186 void gr_free_sub_bitmap(grs_bitmap *bm )
187 {
188         if (bm!=NULL)
189         {
190 #ifdef D1XD3D
191                 bm->iMagic = 0;
192 #endif
193                 d_free(bm);
194         }
195 }
196
197
198 void gr_free_bitmap_data (grs_bitmap *bm) // TODO: virtulize
199 {
200 #ifdef D1XD3D
201         Assert (bm->iMagic == BM_MAGIC_NUMBER);
202
203         Win32_FreeTexture (bm);
204         bm->iMagic = 0;
205         if (bm->bm_data == BM_D3D_RENDER)
206                 bm->bm_data = NULL;
207 #endif
208 #ifdef OGL
209         ogl_freebmtexture(bm);
210 #endif
211         if (bm->bm_data != NULL)
212                 d_free (bm->bm_data);
213         bm->bm_data = NULL;
214 }
215
216 void gr_init_sub_bitmap (grs_bitmap *bm, grs_bitmap *bmParent, int x, int y, int w, int h )     // TODO: virtualize
217 {
218         bm->bm_x = x + bmParent->bm_x;
219         bm->bm_y = y + bmParent->bm_y;
220         bm->bm_w = w;
221         bm->bm_h = h;
222         bm->bm_flags = bmParent->bm_flags;
223         bm->bm_type = bmParent->bm_type;
224         bm->bm_rowsize = bmParent->bm_rowsize;
225
226 #ifdef OGL
227         bm->gltexture=bmParent->gltexture;
228         bm->bm_parent=bmParent;
229 #endif
230 #ifdef D1XD3D
231         Assert (bmParent->iMagic == BM_MAGIC_NUMBER);
232         bm->iMagic = BM_MAGIC_NUMBER;
233         bm->pvSurface = bmParent->pvSurface;
234         if (bm->bm_type == BM_DIRECTX)
235         {
236                 bm->bm_data = bmParent->bm_data;
237         }
238         else
239 #endif
240         {
241                 bm->bm_data = bmParent->bm_data+(unsigned int)((y*bmParent->bm_rowsize)+x);
242         }
243
244 }
245
246 void decode_data_asm(ubyte *data, int num_pixels, ubyte * colormap, int * count );
247
248 #if !defined(NO_ASM) && defined(__WATCOMC__)
249
250 #pragma aux decode_data_asm parm [esi] [ecx] [edi] [ebx] modify exact [esi edi eax ebx ecx] = \
251 "again_ddn:"                                                    \
252         "xor    eax,eax"                                \
253         "mov    al,[esi]"                       \
254         "inc    dword ptr [ebx+eax*4]"          \
255         "mov    al,[edi+eax]"           \
256         "mov    [esi],al"                       \
257         "inc    esi"                                    \
258         "dec    ecx"                                    \
259         "jne    again_ddn"
260
261 #elif !defined(NO_ASM) && defined(__GNUC__)
262
263 inline void decode_data_asm(ubyte *data, int num_pixels, ubyte * colormap, int * count ) {
264         int dummy[4];
265    __asm__ __volatile__ (
266     "xorl   %%eax,%%eax;"
267 "0:;"
268     "movb   (%%esi), %%al;"
269     "incl   (%%ebx, %%eax, 4);"
270     "movb   (%%edi, %%eax), %%al;"
271     "movb   %%al, (%%esi);"
272     "incl   %%esi;"
273     "decl   %%ecx;"
274     "jne    0b"
275     : "=S" (dummy[0]), "=c" (dummy[1]), "=D" (dummy[2]), "=b" (dummy[3])
276         : "0" (data), "1" (num_pixels), "2" (colormap), "3" (count)
277         : "%eax");
278 }
279
280 #elif !defined(NO_ASM) && defined(_MSC_VER)
281
282 __inline void decode_data_asm(ubyte *data, int num_pixels, ubyte * colormap, int * count )
283 {
284   __asm {
285         mov esi,[data]
286         mov ecx,[num_pixels]
287         mov edi,[colormap]
288         mov ebx,[count]
289 again_ddn:
290         xor eax,eax
291         mov al,[esi]
292         inc dword ptr [ebx+eax*4]
293         mov al,[edi+eax]
294         mov [esi],al
295         inc esi
296         dec ecx
297         jne again_ddn
298   }
299 }
300
301 #else // NO_ASM or unknown compiler
302
303 void decode_data_asm(ubyte *data, int num_pixels, ubyte *colormap, int *count)
304 {
305         int i;
306         ubyte mapped;
307
308         for (i = 0; i < num_pixels; i++) {
309                 count[*data]++;
310                 mapped = *data;
311                 *data = colormap[mapped];
312                 data++;
313         }
314 }
315
316 #endif
317
318 void gr_set_bitmap_flags (grs_bitmap *pbm, int flags)
319 {
320 #ifdef D1XD3D
321         Assert (pbm->iMagic == BM_MAGIC_NUMBER);
322
323         if (pbm->pvSurface)
324         {
325                 if ((flags & BM_FLAG_TRANSPARENT) != (pbm->bm_flags & BM_FLAG_TRANSPARENT))
326                 {
327                         Win32_SetTransparent (pbm->pvSurface, flags & BM_FLAG_TRANSPARENT);
328                 }
329         }
330 #endif
331         pbm->bm_flags = flags;
332 }
333
334 void gr_set_transparent (grs_bitmap *pbm, int bTransparent)
335 {
336         if (bTransparent)
337         {
338                 gr_set_bitmap_flags (pbm, pbm->bm_flags | BM_FLAG_TRANSPARENT);
339         }
340         else
341         {
342                 gr_set_bitmap_flags (pbm, pbm->bm_flags & ~BM_FLAG_TRANSPARENT);
343         }
344 }
345
346 void gr_set_super_transparent (grs_bitmap *pbm, int bTransparent)
347 {
348         if (bTransparent)
349         {
350                 gr_set_bitmap_flags (pbm, pbm->bm_flags & ~BM_FLAG_SUPER_TRANSPARENT);
351         }
352         else
353         {
354                 gr_set_bitmap_flags (pbm, pbm->bm_flags | BM_FLAG_SUPER_TRANSPARENT);
355         }
356 }
357
358 void build_colormap_good( ubyte * palette, ubyte * colormap, int * freq )
359 {
360         int i, r, g, b;
361
362         for (i=0; i<256; i++ )  {
363                 r = *palette++;
364                 g = *palette++;
365                 b = *palette++;
366                 *colormap++ = gr_find_closest_color( r, g, b );
367                 *freq++ = 0;
368         }
369 }
370
371 void gr_remap_bitmap( grs_bitmap * bmp, ubyte * palette, int transparent_color, int super_transparent_color )
372 {
373         ubyte colormap[256];
374         int freq[256];
375
376         if (bmp->bm_type != BM_LINEAR)
377                 return;  //can't do it
378
379         // This should be build_colormap_asm, but we're not using invert table, so...
380         build_colormap_good( palette, colormap, freq );
381
382         if ( (super_transparent_color>=0) && (super_transparent_color<=255))
383                 colormap[super_transparent_color] = 254;
384
385         if ( (transparent_color>=0) && (transparent_color<=255))
386                 colormap[transparent_color] = TRANSPARENCY_COLOR;
387
388         decode_data_asm(bmp->bm_data, bmp->bm_w * bmp->bm_h, colormap, freq );
389
390         if ( (transparent_color>=0) && (transparent_color<=255) && (freq[transparent_color]>0) )
391                 gr_set_transparent (bmp, 1);
392
393         if ( (super_transparent_color>=0) && (super_transparent_color<=255) && (freq[super_transparent_color]>0) )
394                 gr_set_super_transparent (bmp, 0);
395 }
396
397 void gr_remap_bitmap_good( grs_bitmap * bmp, ubyte * palette, int transparent_color, int super_transparent_color )
398 {
399         ubyte colormap[256];
400         int freq[256];
401         build_colormap_good( palette, colormap, freq );
402
403         if ( (super_transparent_color>=0) && (super_transparent_color<=255))
404                 colormap[super_transparent_color] = 254;
405
406         if ( (transparent_color>=0) && (transparent_color<=255))
407                 colormap[transparent_color] = TRANSPARENCY_COLOR;
408
409         if (bmp->bm_w == bmp->bm_rowsize)
410                 decode_data_asm(bmp->bm_data, bmp->bm_w * bmp->bm_h, colormap, freq );
411         else {
412                 int y;
413                 ubyte *p = bmp->bm_data;
414                 for (y=0;y<bmp->bm_h;y++,p+=bmp->bm_rowsize)
415                         decode_data_asm(p, bmp->bm_w, colormap, freq );
416         }
417
418         if ( (transparent_color>=0) && (transparent_color<=255) && (freq[transparent_color]>0) )
419                 gr_set_transparent (bmp, 1);
420
421         if ( (super_transparent_color>=0) && (super_transparent_color<=255) && (freq[super_transparent_color]>0) )
422                 gr_set_super_transparent (bmp, 1);
423 }
424
425 #ifdef BITMAP_SELECTOR
426 int gr_bitmap_assign_selector( grs_bitmap * bmp )
427 {
428         if (!dpmi_allocate_selector( bmp->bm_data, bmp->bm_w*bmp->bm_h, &bmp->bm_selector )) {
429                 bmp->bm_selector = 0;
430                 return 1;
431         }
432         return 0;
433 }
434 #endif
435
436 void gr_bitmap_check_transparency( grs_bitmap * bmp )
437 {
438         int x, y;
439         ubyte * data;
440
441         data = bmp->bm_data;
442
443         for (y=0; y<bmp->bm_h; y++ )    {
444                 for (x=0; x<bmp->bm_w; x++ )    {
445                         if (*data++ == TRANSPARENCY_COLOR )     {
446                                 gr_set_transparent (bmp, 1);
447                                 return;
448                         }
449                 }
450                 data += bmp->bm_rowsize - bmp->bm_w;
451         }
452
453         bmp->bm_flags = 0;
454
455 }