2d/bitmap.c

   1 /*
   2 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
   3 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
   4 END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
   5 ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
   6 IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
   7 SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
   8 FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
   9 CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
  10 AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.
  11 COPYRIGHT 1993-1998 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
  12 */
  13
  14 #ifdef HAVE_CONFIG_H
  15 #include <conf.h>
  16 #endif
  17
  18 #include <stdlib.h>
  19 #include <stdio.h>
  20
  21 #include "u_mem.h"
  22
  23
  24 #include "gr.h"
  25 #include "grdef.h"
  26 #include "u_dpmi.h"
  27 #include "bitmap.h"
  28 #include "error.h"
  29
  30 #ifdef OGL
  31 #include "ogl_init.h"
  32 #endif
  33
  34 void build_colormap_good( ubyte * palette, ubyte * colormap, int * freq );
  35
  36 void gr_set_bitmap_data (grs_bitmap *bm, unsigned char *data)
  37 {
  38 #ifdef OGL
  39 //      if (bm->bm_data!=data)
  40                 ogl_freebmtexture(bm);
  41 #endif
  42         bm->bm_data = data;
  43 #ifdef D1XD3D
  44         Assert (bm->iMagic == BM_MAGIC_NUMBER);
  45         Win32_SetTextureBits (bm, data, bm->bm_flags & BM_FLAG_RLE);
  46 #endif
  47 }
  48
  49 void gr_init_bitmap( grs_bitmap *bm, int mode, int x, int y, int w, int h, int bytesperline, unsigned char * data ) // TODO: virtualize
  50 {
  51 #ifdef D1XD3D
  52         Assert (bm->iMagic != BM_MAGIC_NUMBER || bm->pvSurface == NULL);
  53 #endif
  54
  55         bm->bm_x = x;
  56         bm->bm_y = y;
  57         bm->bm_w = w;
  58         bm->bm_h = h;
  59         bm->bm_flags = 0;
  60         bm->bm_type = mode;
  61         bm->bm_rowsize = bytesperline;
  62
  63         bm->bm_data = NULL;
  64 #ifdef D1XD3D
  65         bm->iMagic = BM_MAGIC_NUMBER;
  66         bm->pvSurface = NULL;
  67 #endif
  68
  69 #ifdef D1XD3D
  70         Win32_CreateTexture (bm);
  71 #endif
  72 #ifdef OGL
  73         bm->bm_parent=NULL;bm->gltexture=NULL;
  74 #endif
  75
  76 //      if (data != 0)
  77                 gr_set_bitmap_data (bm, data);
  78 /*
  79         else
  80                 gr_set_bitmap_data (bm, d_malloc (w * h));
  81 */
  82
  83 #ifdef BITMAP_SELECTOR
  84         bm->bm_selector = 0;
  85 #endif
  86 }
  87
  88 void gr_init_bitmap_alloc( grs_bitmap *bm, int mode, int x, int y, int w, int h, int bytesperline)
  89 {
  90         gr_init_bitmap(bm, mode, x, y, w, h, bytesperline, 0);
  91         gr_set_bitmap_data(bm, d_malloc(w * h));
  92 }
  93
  94 void gr_init_bitmap_data (grs_bitmap *bm) // TODO: virtulize
  95 {
  96         bm->bm_data = NULL;
  97 #ifdef D1XD3D
  98         Assert (bm->iMagic != BM_MAGIC_NUMBER);
  99         bm->iMagic = BM_MAGIC_NUMBER;
 100         bm->pvSurface = NULL;
 101 #endif
 102 #ifdef OGL
 103 //      ogl_freebmtexture(bm);//not what we want here.
 104         bm->bm_parent=NULL;bm->gltexture=NULL;
 105 #endif
 106 }
 107
 108 void gr_free_bitmap(grs_bitmap *bm )
 109 {
 110         gr_free_bitmap_data (bm);
 111         if (bm!=NULL)
 112                 d_free(bm);
 113 }
 114
 115 void gr_free_bitmap_data (grs_bitmap *bm) // TODO: virtulize
 116 {
 117 #ifdef D1XD3D
 118         Assert (bm->iMagic == BM_MAGIC_NUMBER);
 119
 120         Win32_FreeTexture (bm);
 121         bm->iMagic = 0;
 122         if (bm->bm_data == BM_D3D_RENDER)
 123                 bm->bm_data = NULL;
 124 #endif
 125 #ifdef OGL
 126         ogl_freebmtexture(bm);
 127 #endif
 128         if (bm->bm_data != NULL)
 129                 d_free (bm->bm_data);
 130         bm->bm_data = NULL;
 131 }
 132
 133 void gr_init_sub_bitmap (grs_bitmap *bm, grs_bitmap *bmParent, int x, int y, int w, int h )     // TODO: virtualize
 134 {
 135         bm->bm_x = x + bmParent->bm_x;
 136         bm->bm_y = y + bmParent->bm_y;
 137         bm->bm_w = w;
 138         bm->bm_h = h;
 139         bm->bm_flags = bmParent->bm_flags;
 140         bm->bm_type = bmParent->bm_type;
 141         bm->bm_rowsize = bmParent->bm_rowsize;
 142
 143 #ifdef OGL
 144         bm->gltexture=bmParent->gltexture;
 145         bm->bm_parent=bmParent;
 146 #endif
 147 #ifdef D1XD3D
 148         Assert (bmParent->iMagic == BM_MAGIC_NUMBER);
 149         bm->iMagic = BM_MAGIC_NUMBER;
 150         bm->pvSurface = bmParent->pvSurface;
 151         if (bm->bm_type == BM_DIRECTX)
 152         {
 153                 bm->bm_data = bmParent->bm_data;
 154         }
 155         else
 156 #endif
 157         {
 158                 bm->bm_data = bmParent->bm_data+(unsigned int)((y*bmParent->bm_rowsize)+x);
 159         }
 160
 161 }
 162
 163 void gr_free_sub_bitmap(grs_bitmap *bm )
 164 {
 165         if (bm!=NULL)
 166         {
 167 #ifdef D1XD3D
 168                 bm->iMagic = 0;
 169 #endif
 170                 d_free(bm);
 171         }
 172 }
 173
 174
 175 grs_bitmap *gr_create_bitmap(int w, int h )
 176 {
 177         return gr_create_bitmap_raw (w, h, d_malloc(w * h));
 178 }
 179
 180 grs_bitmap *gr_create_bitmap_raw(int w, int h, unsigned char * raw_data )
 181 {
 182     grs_bitmap *new;
 183
 184     new = (grs_bitmap *)d_malloc( sizeof(grs_bitmap) );
 185         gr_init_bitmap (new, 0, 0, 0, w, h, w, raw_data);
 186
 187     return new;
 188 }
 189
 190
 191 grs_bitmap *gr_create_sub_bitmap(grs_bitmap *bm, int x, int y, int w, int h )
 192 {
 193     grs_bitmap *new;
 194
 195     new = (grs_bitmap *)d_malloc( sizeof(grs_bitmap) );
 196         gr_init_sub_bitmap (new, bm, x, y, w, h);
 197
 198         return new;
 199 }
 200
 201 void gr_set_bitmap_flags (grs_bitmap *pbm, int flags)
 202 {
 203 #ifdef D1XD3D
 204         Assert (pbm->iMagic == BM_MAGIC_NUMBER);
 205
 206         if (pbm->pvSurface)
 207         {
 208                 if ((flags & BM_FLAG_TRANSPARENT) != (pbm->bm_flags & BM_FLAG_TRANSPARENT))
 209                 {
 210                         Win32_SetTransparent (pbm->pvSurface, flags & BM_FLAG_TRANSPARENT);
 211                 }
 212         }
 213 #endif
 214         pbm->bm_flags = flags;
 215 }
 216
 217 void gr_set_transparent (grs_bitmap *pbm, int bTransparent)
 218 {
 219         if (bTransparent)
 220         {
 221                 gr_set_bitmap_flags (pbm, pbm->bm_flags | BM_FLAG_TRANSPARENT);
 222         }
 223         else
 224         {
 225                 gr_set_bitmap_flags (pbm, pbm->bm_flags & ~BM_FLAG_TRANSPARENT);
 226         }
 227 }
 228
 229 void gr_set_super_transparent (grs_bitmap *pbm, int bTransparent)
 230 {
 231         if (bTransparent)
 232         {
 233                 gr_set_bitmap_flags (pbm, pbm->bm_flags & ~BM_FLAG_SUPER_TRANSPARENT);
 234         }
 235         else
 236         {
 237                 gr_set_bitmap_flags (pbm, pbm->bm_flags | BM_FLAG_SUPER_TRANSPARENT);
 238         }
 239 }
 240
 241 void gr_remap_bitmap( grs_bitmap * bmp, ubyte * palette, int transparent_color, int super_transparent_color )
 242 {
 243         ubyte colormap[256];
 244         int freq[256];
 245
 246         // This should be build_colormap_asm, but we're not using invert table, so...
 247         build_colormap_good( palette, colormap, freq );
 248
 249         if ( (super_transparent_color>=0) && (super_transparent_color<=255))
 250                 colormap[super_transparent_color] = 254;
 251
 252         if ( (transparent_color>=0) && (transparent_color<=255))
 253                 colormap[transparent_color] = 255;
 254
 255         decode_data_asm(bmp->bm_data, bmp->bm_w * bmp->bm_h, colormap, freq );
 256
 257         if ( (transparent_color>=0) && (transparent_color<=255) && (freq[transparent_color]>0) )
 258                 gr_set_transparent (bmp, 1);
 259
 260         if ( (super_transparent_color>=0) && (super_transparent_color<=255) && (freq[super_transparent_color]>0) )
 261                 gr_set_super_transparent (bmp, 0);
 262 }
 263
 264 void build_colormap_good( ubyte * palette, ubyte * colormap, int * freq )
 265 {
 266         int i, r, g, b;
 267
 268         for (i=0; i<256; i++ )  {
 269                 r = *palette++;
 270                 g = *palette++;
 271                 b = *palette++;
 272                 *colormap++ = gr_find_closest_color( r, g, b );
 273                 *freq++ = 0;
 274         }
 275 }
 276
 277
 278 void gr_remap_bitmap_good( grs_bitmap * bmp, ubyte * palette, int transparent_color, int super_transparent_color )
 279 {
 280         ubyte colormap[256];
 281         int freq[256];
 282
 283         build_colormap_good( palette, colormap, freq );
 284
 285         if ( (super_transparent_color>=0) && (super_transparent_color<=255))
 286                 colormap[super_transparent_color] = 254;
 287
 288         if ( (transparent_color>=0) && (transparent_color<=255))
 289                 colormap[transparent_color] = 255;
 290
 291         decode_data_asm(bmp->bm_data, bmp->bm_w * bmp->bm_h, colormap, freq );
 292
 293         if ( (transparent_color>=0) && (transparent_color<=255) && (freq[transparent_color]>0) )
 294                 gr_set_transparent (bmp, 1);
 295
 296         if ( (super_transparent_color>=0) && (super_transparent_color<=255) && (freq[super_transparent_color]>0) )
 297                 gr_set_super_transparent (bmp, 1);
 298 }
 299
 300 #ifdef BITMAP_SELECTOR
 301 int gr_bitmap_assign_selector( grs_bitmap * bmp )
 302 {
 303         if (!dpmi_allocate_selector( bmp->bm_data, bmp->bm_w*bmp->bm_h, &bmp->bm_selector )) {
 304                 bmp->bm_selector = 0;
 305                 return 1;
 306         }
 307         return 0;
 308 }
 309 #endif
 310
 311 void gr_bitmap_check_transparency( grs_bitmap * bmp )
 312 {
 313         int x, y;
 314         ubyte * data;
 315
 316         data = bmp->bm_data;
 317
 318         for (y=0; y<bmp->bm_h; y++ )    {
 319                 for (x=0; x<bmp->bm_w; x++ )    {
 320                         if (*data++ == 255 )    {
 321                                 gr_set_transparent (bmp, 1);
 322                                 return;
 323                         }
 324                 }
 325                 data += bmp->bm_rowsize - bmp->bm_w;
 326         }
 327
 328         bmp->bm_flags = 0;
 329
 330 }