src/bmpman/bmpman.cpp

   1 /*
   2  * Copyright (C) Volition, Inc. 1999.  All rights reserved.
   3  *
   4  * All source code herein is the property of Volition, Inc. You may not sell
   5  * or otherwise commercially exploit the source or things you created based on
   6  * the source.
   7  */
   8
   9 /*
  10  * $Logfile: /Freespace2/code/Bmpman/BmpMan.cpp $
  11  * $Revision$
  12  * $Date$
  13  * $Author$
  14  *
  15  * Code to load and manage all bitmaps for the game
  16  *
  17  * $Log$
  18  * Revision 1.11  2004/07/04 11:31:43  taylor
  19  * amd64 support, compiler warning fixes, don't use software rendering
  20  *
  21  * Revision 1.10  2003/05/28 06:02:04  taylor
  22  * fix transparency in green weapon blobs
  23  *
  24  * Revision 1.9  2002/06/09 04:41:15  relnev
  25  * added copyright header
  26  *
  27  * Revision 1.8  2002/06/05 04:03:32  relnev
  28  * finished cfilesystem.
  29  *
  30  * removed some old code.
  31  *
  32  * fixed mouse save off-by-one.
  33  *
  34  * sound cleanups.
  35  *
  36  * Revision 1.7  2002/06/03 09:25:37  relnev
  37  * implement mouse cursor and screen save/restore
  38  *
  39  * Revision 1.6  2002/05/30 23:07:08  relnev
  40  * shh
  41  *
  42  * Revision 1.5  2002/05/30 21:44:48  relnev
  43  * implemented some missing texture stuff.
  44  *
  45  * enable bitmap polys for opengl.
  46  *
  47  * work around greenness in bitmaps.
  48  *
  49  * Revision 1.4  2002/05/28 17:03:29  theoddone33
  50  * fs2 gets to the main game loop now
  51  *
  52  * Revision 1.3  2002/05/28 08:52:03  relnev
  53  * implemented two assembly stubs.
  54  *
  55  * cleaned up a few warnings.
  56  *
  57  * added a little demo hackery to make it progress a little farther.
  58  *
  59  * Revision 1.2  2002/05/07 03:16:43  theoddone33
  60  * The Great Newline Fix
  61  *
  62  * Revision 1.1.1.1  2002/05/03 03:28:08  root
  63  * Initial import.
  64  *
  65  *
  66  * 37    9/13/99 11:26p Andsager
  67  * Add debug code to check for poorly sized anis
  68  *
  69  * 36    9/05/99 11:19p Dave
  70  * Made d3d texture cache much more safe. Fixed training scoring bug where
  71  * it would backout scores without ever having applied them in the first
  72  * place.
  73  *
  74  * 35    8/20/99 2:09p Dave
  75  * PXO banner cycling.
  76  *
  77  * 34    8/10/99 6:54p Dave
  78  * Mad optimizations. Added paging to the nebula effect.
  79  *
  80  * 33    8/06/99 1:52p Dave
  81  * Bumped up MAX_BITMAPS for the demo.
  82  *
  83  * 32    8/02/99 1:49p Dave
  84  * Fixed low-mem animation problem. Whee!
  85  *
  86  * 31    7/16/99 1:49p Dave
  87  * 8 bit aabitmaps. yay.
  88  *
  89  * 30    7/13/99 1:15p Dave
  90  * 32 bit support. Whee!
  91  *
  92  * 29    6/29/99 10:35a Dave
  93  * Interface polygon bitmaps! Whee!
  94  *
  95  * 28    6/16/99 4:06p Dave
  96  * New pilot info popup. Added new draw-bitmap-as-poly function.
  97  *
  98  * 27    5/05/99 9:02p Dave
  99  * Fixed D3D aabitmap rendering. Spiffed up nebula effect a bit (added
 100  * rotations, tweaked values, made bitmap selection more random). Fixed
 101  * D3D beam weapon clipping problem. Added D3d frame dumping.
 102  *
 103  * 26    4/27/99 12:16a Dave
 104  * Fixed beam weapon muzzle glow problem. Fixed premature timeout on the
 105  * pxo server list screen. Fixed secondary firing for hosts on a
 106  * standalone. Fixed wacky multiplayer weapon "shuddering" problem.
 107  *
 108  * 25    4/09/99 2:21p Dave
 109  * Multiplayer beta stuff. CD checking.
 110  *
 111  * 24    4/08/99 10:42a Johnson
 112  * Don't try to swizzle a texture to transparent in Fred.
 113  *
 114  * 23    3/31/99 8:24p Dave
 115  * Beefed up all kinds of stuff, incluging beam weapons, nebula effects
 116  * and background nebulae. Added per-ship non-dimming pixel colors.
 117  *
 118  * 22    3/20/99 3:46p Dave
 119  * Added support for model-based background nebulae. Added 3 new
 120  * sexpressions.
 121  *
 122  * 21    2/11/99 3:08p Dave
 123  * PXO refresh button. Very preliminary squad war support.
 124  *
 125  * 20    2/08/99 5:07p Dave
 126  * FS2 chat server support. FS2 specific validated missions.
 127  *
 128  * 19    2/05/99 12:52p Dave
 129  * Fixed Glide nondarkening textures.
 130  *
 131  * 18    2/04/99 6:29p Dave
 132  * First full working rev of FS2 PXO support.  Fixed Glide lighting
 133  * problems.
 134  *
 135  * 17    2/03/99 11:44a Dave
 136  * Fixed d3d transparent textures.
 137  *
 138  * 16    1/15/99 11:29a Neilk
 139  * Fixed D3D screen/texture pixel formatting problem.
 140  *
 141  * 15    1/14/99 12:48a Dave
 142  * Todo list bug fixes. Made a pass at putting briefing icons back into
 143  * FRED. Sort of works :(
 144  *
 145  * 14    1/12/99 12:53a Dave
 146  * More work on beam weapons - made collision detection very efficient -
 147  * collide against all object types properly - made 3 movement types
 148  * smooth. Put in test code to check for possible non-darkening pixels on
 149  * object textures.
 150  *
 151  * 13    1/08/99 2:08p Dave
 152  * Fixed software rendering for pofview. Super early support for AWACS and
 153  * beam weapons.
 154  *
 155  * 12    1/06/99 2:24p Dave
 156  * Stubs and release build fixes.
 157  *
 158  * 11    12/14/98 4:01p Dave
 159  * Got multi_data stuff working well with new xfer stuff.
 160  *
 161  * 10    12/06/98 2:36p Dave
 162  * Drastically improved nebula fogging.
 163  *
 164  * 9     12/01/98 5:53p Dave
 165  * Simplified the way pixel data is swizzled. Fixed tga bitmaps to work
 166  * properly in D3D and Glide.
 167  *
 168  * 8     12/01/98 4:46p Dave
 169  * Put in targa bitmap support (16 bit).
 170  *
 171  * 7     12/01/98 10:32a Johnson
 172  * Fixed direct3d font problems. Fixed sun bitmap problem. Fixed direct3d
 173  * starfield problem.
 174  *
 175  * 6     12/01/98 8:06a Dave
 176  * Temporary checkin to fix some texture transparency problems in d3d.
 177  *
 178  * 5     11/30/98 5:31p Dave
 179  * Fixed up Fred support for software mode.
 180  *
 181  * 4     11/30/98 1:07p Dave
 182  * 16 bit conversion, first run.
 183  *
 184  * 3     10/22/98 6:14p Dave
 185  * Optimized some #includes in Anim folder. Put in the beginnings of
 186  * parse/localization support for externalized strings and tstrings.tbl
 187  *
 188  * 2     10/07/98 10:52a Dave
 189  * Initial checkin.
 190  *
 191  * 1     10/07/98 10:48a Dave
 192  *
 193  * 106   5/23/98 4:43p John
 194  * Took out debugging sleep
 195  *
 196  * 105   5/23/98 4:14p John
 197  * Added code to preload textures to video card for AGP.   Added in code
 198  * to page in some bitmaps that weren't getting paged in at level start.
 199  *
 200  * 104   5/20/98 12:59p John
 201  * Turned optimizations on for debug builds.   Also turning on automatic
 202  * function inlining.  Turned off the unreachable code warning.
 203  *
 204  * 103   5/20/98 10:20a Hoffoss
 205  * Fixed warning in the code.
 206  *
 207  * 102   5/19/98 3:45p John
 208  * fixed bug causing lowmem to drop half of the frames. Also halved fps
 209  * during lowmem.
 210  *
 211  * 101   5/14/98 3:38p John
 212  * Added in more non-darkening colors for Adam.  Had to fix some bugs in
 213  * BmpMan and Ani stuff to get this to work.
 214  *
 215  * 100   4/22/98 9:13p John
 216  * Added code to replace frames of animations in vram if so desired.
 217  *
 218  * 99    4/17/98 6:56a John
 219  * Fixed bug where RLE'd user bitmaps caused data to not get freed.
 220  * (Turned off RLE for use bitmaps).   Made lossy animations reduce
 221  * resolution by a factor of 2 in low memory conditions.
 222  *
 223  * 98    4/16/98 6:31p Hoffoss
 224  * Added function to get filename of a bitmap handle, which we don't have
 225  * yet and I need.
 226  *
 227  * 97    4/01/98 9:27p John
 228  * Fixed debug info in bmpman.
 229  *
 230  * 96    4/01/98 5:34p John
 231  * Made only the used POFs page in for a level.   Reduced some interp
 232  * arrays.    Made custom detail level work differently.
 233  *
 234  * 95    3/31/98 9:55a Lawrance
 235  * JOHN: get xparency working for user bitmaps
 236  *
 237  * 94    3/30/98 4:02p John
 238  * Made machines with < 32 MB of RAM use every other frame of certain
 239  * bitmaps.   Put in code to keep track of how much RAM we've malloc'd.
 240  *
 241  * 93    3/29/98 4:05p John
 242  * New paging code that loads everything necessary at level startup.
 243  *
 244  * 92    3/27/98 11:20a John
 245  * commented back in some debug code.
 246  *
 247  * 91    3/26/98 5:21p John
 248  * Added new code to preload all bitmaps at the start of a level.
 249  * Commented it out, though.
 250  *
 251  * 90    3/26/98 4:56p Jasen
 252  * AL: Allow find_block_of() to allocate a series of bitmaps from index 0
 253  *
 254  * 89    3/26/98 10:21a John
 255  * Made no palette-mapped bitmaps use 0,255,0 as transparent.
 256  *
 257  * 88    3/24/98 5:39p John
 258  * Added debug code to show bitmap fragmentation.  Made user bitmaps
 259  * allocate from top of array.
 260  *
 261  * 87    3/22/98 3:28p John
 262  * Added in stippled alpha for lower details.  Made medium detail use
 263  * engine glow.
 264  *
 265  * 86    3/11/98 1:55p John
 266  * Fixed warnings
 267  *
 268  * 85    3/06/98 4:09p John
 269  * Changed the way we do bitmap RLE'ing... this speds up HUD bitmaps by
 270  * about 2x
 271  *
 272  * 84    3/02/98 6:00p John
 273  * Moved MAX_BITMAPS into BmpMan.h so the stuff in the graphics code that
 274  * is dependent on it won't break if it changes.   Made ModelCache slots
 275  * be equal to MAX_OBJECTS which is what it is.
 276  *
 277  * 83    3/02/98 9:51a John
 278  * Added code to print the number of bitmap slots in use between levels.
 279  *
 280  * 82    2/16/98 3:54p John
 281  * Changed a bunch of mprintfs to catagorize to BmpInfo
 282  *
 283  * 81    2/13/98 5:00p John
 284  * Made user bitmaps not get wrote to level cache file.
 285  *
 286  * 80    2/06/98 8:25p John
 287  * Added code for new bitmaps since last frame
 288  *
 289  * 79    2/06/98 8:10p John
 290  * Added code to show amout of texture usage each frame.
 291  *
 292  * 78    2/05/98 9:21p John
 293  * Some new Direct3D code.   Added code to monitor a ton of stuff in the
 294  * game.
 295  *
 296  * 77    1/29/98 11:48a John
 297  * Added new counter measure rendering as model code.   Made weapons be
 298  * able to have impact explosion.
 299  *
 300  * 76    1/28/98 6:19p Dave
 301  * Reduced standalone memory usage ~8 megs. Put in support for handling
 302  * multiplayer submenu handling for endgame, etc.
 303  *
 304  * 75    1/17/98 12:55p John
 305  * Fixed bug that I just created that loaded all ani frames.
 306  *
 307  * 74    1/17/98 12:33p John
 308  * Made the game_busy function be called a constant amount of times per
 309  * level load, making the bar prediction easier.
 310  *
 311  * 73    1/17/98 12:14p John
 312  * Added loading... bar to freespace.
 313  *
 314  * 72    1/11/98 3:20p John
 315  * Made so that if no .clt exists, it will load all the bitmaps
 316  *
 317  * 71    1/11/98 3:06p John
 318  * Made bitmap loading stop when cache gets full.
 319  *
 320  * 70    1/11/98 2:45p John
 321  * Changed .lst to .clt
 322  *
 323  * 69    1/11/98 2:14p John
 324  * Changed a lot of stuff that had to do with bitmap loading.   Made cfile
 325  * not do callbacks, I put that in global code.   Made only bitmaps that
 326  * need to load for a level load.
 327  *
 328  * 67    1/09/98 4:07p John
 329  * Made all bitmap functions return a bitmap "Handle" not number.  This
 330  * helps to find bm_release errors.
 331  *
 332  * 66    1/09/98 1:38p John
 333  * Fixed some bugs from previous comment
 334  *
 335  * 65    1/09/98 1:32p John
 336  * Added some debugging code to track down a weird error.  Namely I fill
 337  * in the be structure with bogus values when someone frees it.
 338  *
 339  * 64    12/28/97 2:00p John
 340  * put in another assert checking for invalid lock/unlock sequencing
 341  *
 342  * 63    12/24/97 2:02p John
 343  * Changed palette translation to be a little faster for unoptimized
 344  * builds
 345  *
 346  * 62    12/18/97 8:59p Dave
 347  * Finished putting in basic support for weapon select and ship select in
 348  * multiplayer.
 349  *
 350  * 61    12/15/97 10:27p John
 351  * fixed bug where 2 bm_loads of same file both open the header.
 352  *
 353  * 60    12/08/97 2:17p John
 354  * fixed bug with bmpman and cf_callback.
 355  * made cf_callback in Freespace set small font back when done.
 356  *
 357  * 59    12/03/97 5:01p Lawrance
 358  * bump up MAX_BITMAPS to 1500.  People have reached 1000 bitmaps while
 359  * playing multiple missions.
 360  *
 361  * 58    12/02/97 3:59p John
 362  * Added first rev of thruster glow, along with variable levels of
 363  * translucency, which retquired some restructing of palman.
 364  *
 365  * 57    11/30/97 3:57p John
 366  * Made fixed 32-bpp translucency.  Made BmpMan always map translucent
 367  * color into 255 even if you aren't supposed to remap and make it's
 368  * palette black.
 369  *
 370  * 56    10/05/97 10:39a John
 371  * fixed bug with palette on unmapped bitmaps.  Made unmapped bitmaps get
 372  * marked with xparent.
 373  *
 374  * 55    9/23/97 11:46a Lawrance
 375  * fixed bug with rle'ing with spans get big
 376  *
 377  * 54    9/23/97 10:45a John
 378  * made so you can tell bitblt code to rle a bitmap by passing flag to
 379  * gr_set_bitmap
 380  *
 381  * 53    9/19/97 10:18a John
 382  * fixed bug with aa animations being re-rle'd every
 383  * frame.
 384  *
 385  *
 386  * 52    9/09/97 10:08a Sandeep
 387  * Fixed Compiler Level 4 warnings
 388  *
 389  * 51    9/08/97 2:02p John
 390  * fixed typo in nprintf
 391  *
 392  * 50    9/08/97 1:56p John
 393  * fixed some memory housekeeping bugs
 394  *
 395  * 49    9/03/97 4:19p John
 396  * changed bmpman to only accept ani and pcx's.  made passing .pcx or .ani
 397  * to bm_load functions not needed.   Made bmpman keep track of palettes
 398  * for bitmaps not mapped into game palettes.
 399  *
 400  * 48    8/29/97 7:35p Lawrance
 401  * check if .ani animation is already loaded in bm_load_animation()
 402  *
 403  * 47    8/25/97 11:14p Lawrance
 404  * added support for .ani files in bm_load_animation()
 405  *
 406  * 46    8/17/97 2:42p Lawrance
 407  * only flag PCX files as xparent if they have xparent pixels in them
 408  *
 409  * 45    8/15/97 9:57a Lawrance
 410  * support multiple xparent entries for PCX files
 411  *
 412  * 44    8/05/97 10:18a Lawrance
 413  * my_rand() being used temporarily instead of rand()
 414  *
 415  * 43    8/01/97 4:30p John
 416  *
 417  * 42    7/29/97 8:34a John
 418  * took out png stuff
 419  *
 420  * 41    7/18/97 3:27p Lawrance
 421  * have pcx files use (0,255,0) for transparency
 422  *
 423  * 40    7/16/97 3:07p John
 424  *
 425  * 39    7/10/97 8:34a John
 426  * Added code to read TGA files.
 427  *
 428  * 38    6/20/97 1:50p John
 429  * added rle code to bmpman.  made gr8_aabitmap use it.
 430  *
 431  * 37    6/18/97 12:07p John
 432  * fixed some color bugs
 433  *
 434  * 36    6/17/97 8:58p Lawrance
 435  * fixed bug with not nulling bm.data with USER bitmaps
 436  *
 437  * 35    6/12/97 2:44a Lawrance
 438  * changed bm_unlock() to take an index into bm_bitmaps().  Added
 439  * ref_count to bitmap_entry struct
 440  *
 441  * 34    5/20/97 10:36a John
 442  * Fixed problem with user bitmaps and direct3d caching.
 443  *
 444  * 33    5/14/97 1:59p John
 445  * fixed a palette bug with vclips.
 446  *
 447  * 32    3/24/97 4:43p John
 448  * speed up chunked collision detection by only checking cubes the vector
 449  * goes through.
 450  *
 451  * 31    3/24/97 3:25p John
 452  * Cleaned up and restructured model_collide code and fvi code.  In fvi
 453  * made code that finds uvs work..  Added bm_get_pixel to BmpMan.
 454  *
 455  * 30    3/11/97 2:49p Allender
 456  *
 457  * 29    2/18/97 9:43a Lawrance
 458  * added SDL_assert() in bm_release
 459  *
 460  * 28    1/22/97 4:29p John
 461  * maybe fixed bug with code that counts total bytes of texture ram used.
 462  *
 463  * 27    1/22/97 4:19p Lawrance
 464  * added flags to bm_create to allow transparency
 465  *
 466  * 26    1/21/97 5:24p John
 467  * fixed another bug with bm_release.
 468  *
 469  * 25    1/21/97 5:12p John
 470  * fixed bug with case
 471  *
 472  * 24    1/21/97 5:02p John
 473  * Added code for 8bpp user bitmaps.
 474  *
 475  * 23    1/09/97 11:35a John
 476  * Added some 2d functions to get/put screen images.
 477  *
 478  * 22    11/26/96 6:50p John
 479  * Added some more hicolor primitives.  Made windowed mode run as current
 480  * bpp, if bpp is 8,16,or 32.
 481  *
 482  * 21    11/26/96 9:44a Allender
 483  * Allow for use of different bitmap palettes
 484  *
 485  * 20    11/25/96 10:36a Allender
 486  * started working on 32 bpp support.  Added 15 bpp.
 487  *
 488  * 19    11/18/96 1:51p Allender
 489  * fix up manager code to reread bitmaps if needed in newer bit depth
 490  *
 491  * 18    11/15/96 4:24p Allender
 492  * more bmpman stuff -- only free bitmap slots when releasing copied
 493  * texture -- otherwise, only release the data for the bitmap
 494  *
 495  * 17    11/15/96 3:33p Allender
 496  * added support for converting to 16 bit textures when requested with
 497  * bm_load.  Added some other management functions
 498  *
 499  * 16    11/13/96 4:51p Allender
 500  * started overhaul of bitmap manager.  bm_load no longer actually load
 501  * the data, only the info for the bitmap.  Locking the bitmap now forces
 502  * load when no data present (or will if bpp changes)
 503  *
 504  * $NoKeywords: $
 505  */
 506
 507 #include <ctype.h>
 508 #include "pstypes.h"
 509 #include "pcxutils.h"
 510 #include "bmpman.h"
 511 #include "palman.h"
 512 #include "2d.h"
 513 #include "animplay.h"
 514 #include "timer.h"
 515 #include "systemvars.h"
 516 #include "key.h"
 517 #include "packunpack.h"
 518 #include "cfile.h"
 519 #include "grinternal.h"
 520 #include "tgautils.h"
 521 #include "ship.h"
 522
 523 #ifndef NDEBUG
 524 #define BMPMAN_NDEBUG
 525 #endif
 526
 527 // keep this defined to use per-ship nondarkening pixels
 528 #define BMPMAN_SPECIAL_NONDARK
 529
 530 int bm_inited = 0;
 531
 532 #define BM_TYPE_NONE            0
 533 #define BM_TYPE_PCX                     1
 534 #define BM_TYPE_USER            2
 535 #define BM_TYPE_ANI                     3               // in-house ANI format
 536 #define BM_TYPE_TGA                     4               // 16 bit targa
 537
 538 typedef union bm_extra_info     {
 539         struct {
 540                 // Stuff needed for animations
 541                 int             first_frame;                                                            // used for animations -- points to index of first frame
 542                 ubyte           num_frames;                                                                     // used for animation -- number of frames in the animation
 543                 ubyte           fps;                                                                                    // used for animation -- frames per second
 544         } ani;
 545         struct {
 546                 // Stuff needed for user bitmaps
 547                 void            *data;                                                                  // For user bitmaps, this is where the data comes from
 548                 ubyte           bpp;                                                                    // For user bitmaps, this is what format the data is
 549                 ubyte           flags;                                                                  // Flags passed to bm_create
 550         } user;
 551 } bm_extra_info;
 552
 553 typedef struct bitmap_entry     {
 554         // identification
 555         char            filename[MAX_FILENAME_LEN];                     // filename for this bitmap
 556
 557         uint            signature;                                                                      // a unique signature identifying the data
 558         uint            palette_checksum;                                                       // checksum used to be sure bitmap is in current palette
 559         int             handle;                                                                         // Handle = id*MAX_BITMAPS + bitmapnum
 560         int             last_used;                                                                      // When this bitmap was last used
 561
 562         ubyte           type;                                                                                   // PCX, USER, ANI, etc
 563         signed char     ref_count;                                                              // Number of locks on bitmap.  Can't unload unless ref_count is 0.
 564
 565         // Stuff to keep track of usage
 566         ubyte           preloaded;                                                                      // If set, then this was loaded from the lst file
 567         ubyte           used_flags;                                                                     // What flags it was accessed thru
 568
 569         // Bitmap info
 570         bitmap  bm;
 571
 572         // Data for animations and user bitmaps
 573         bm_extra_info   info;
 574
 575 #ifdef BMPMAN_NDEBUG
 576         // bookeeping
 577         ubyte           used_last_frame;                                                        // If set, then it was used last frame
 578         ubyte           used_this_frame;                                                        // If set, then it was used this frame
 579         int             data_size;                                                                      // How much data this bitmap uses
 580         int             used_count;                                                                     // How many times it was accessed
 581 #endif
 582 } bitmap_entry;
 583
 584 uint Bm_next_signature = 0x1234;
 585
 586 bitmap_entry bm_bitmaps[MAX_BITMAPS];
 587
 588 int bm_texture_ram = 0;
 589
 590 // Bm_max_ram - How much RAM bmpman can use for textures.
 591 // Set to <1 to make it use all it wants.
 592 int Bm_max_ram = 0;             //16*1024*1024;                 // Only use 16 MB for textures
 593
 594 int bm_next_handle = 1;
 595
 596 int Bm_paging = 0;
 597
 598 static int Bm_low_mem = 0;
 599
 600 // 16 bit pixel formats
 601 int Bm_pixel_format = BM_PIXEL_FORMAT_ARGB;
 602
 603 // get and put functions for 16 bit pixels - neat bit slinging, huh?
 604 #define BM_SET_R_ARGB(p, r)     { p[1] &= ~(0x7c); p[1] |= ((r & 0x1f) << 2); }
 605 #define BM_SET_G_ARGB(p, g)     { p[0] &= ~(0xe0); p[1] &= ~(0x03); p[0] |= ((g & 0x07) << 5); p[1] |= ((g & 0x18) >> 3); }
 606 #define BM_SET_B_ARGB(p, b)     { p[0] &= ~(0x1f); p[0] |= b & 0x1f; }
 607 #define BM_SET_A_ARGB(p, a)     { p[1] &= ~(0x80); p[1] |= ((a & 0x01) << 7); }
 608
 609 #define BM_SET_R_D3D(p, r)              { *p |= (ushort)(( (int)r / Gr_current_red->scale ) << Gr_current_red->shift); }
 610 #define BM_SET_G_D3D(p, g)              { *p |= (ushort)(( (int)g / Gr_current_green->scale ) << Gr_current_green->shift); }
 611 #define BM_SET_B_D3D(p, b)              { *p |= (ushort)(( (int)b / Gr_current_blue->scale ) << Gr_current_blue->shift); }
 612 #define BM_SET_A_D3D(p, a)              { if(a == 0){ *p = (ushort)Gr_current_green->mask; } }
 613
 614 #define BM_SET_R(p, r)  { switch(Bm_pixel_format){ case BM_PIXEL_FORMAT_ARGB: BM_SET_R_ARGB(((char*)p), r); break; case BM_PIXEL_FORMAT_D3D: BM_SET_R_D3D(p, r); break; default: Int3(); } }
 615 #define BM_SET_G(p, g)  { switch(Bm_pixel_format){ case BM_PIXEL_FORMAT_ARGB: BM_SET_G_ARGB(((char*)p), g); break; case BM_PIXEL_FORMAT_D3D: BM_SET_G_D3D(p, g); break; default: Int3(); } }
 616 #define BM_SET_B(p, b)  { switch(Bm_pixel_format){ case BM_PIXEL_FORMAT_ARGB: BM_SET_B_ARGB(((char*)p), b); break; case BM_PIXEL_FORMAT_D3D: BM_SET_B_D3D(p, b); break;  default: Int3(); } }
 617 #define BM_SET_A(p, a)  { switch(Bm_pixel_format){ case BM_PIXEL_FORMAT_ARGB: BM_SET_A_ARGB(((char*)p), a); break; case BM_PIXEL_FORMAT_D3D: BM_SET_A_D3D(p, a); break;  default: Int3(); } }
 618
 619 // ===========================================
 620 // Mode: 0 = High memory
 621 //       1 = Low memory ( every other frame of ani's)
 622 //       2 = Debug low memory ( only use first frame of each ani )
 623 void bm_set_low_mem( int mode )
 624 {
 625         SDL_assert( (mode >= 0)  && (mode<=2 ));
 626         Bm_low_mem = mode;
 627 }
 628
 629
 630 static int bm_get_next_handle()
 631 {
 632         int n = bm_next_handle;
 633         bm_next_handle++;
 634         if ( bm_next_handle > 30000 )   {
 635                 bm_next_handle = 1;
 636         }
 637         return n;
 638 }
 639
 640 // Frees a bitmaps data if it should, and
 641 // Returns true if bitmap n can free it's data.
 642 static void bm_free_data(int n)
 643 {
 644         bitmap_entry    *be;
 645         bitmap                  *bmp;
 646
 647         SDL_assert( n >= 0 && n < MAX_BITMAPS );
 648
 649         be = &bm_bitmaps[n];
 650         bmp = &be->bm;
 651
 652         // If there isn't a bitmap in this structure, don't
 653         // do anything but clear out the bitmap info
 654         if ( be->type==BM_TYPE_NONE)
 655                 goto SkipFree;
 656
 657         // If this bitmap doesn't have any data to free, skip
 658         // the freeing it part of this.
 659         if ( bmp->data == 0 )
 660                 goto SkipFree;
 661
 662         // Don't free up memory for user defined bitmaps, since
 663         // BmpMan isn't the one in charge of allocating/deallocing them.
 664         if ( ( be->type==BM_TYPE_USER ) )
 665                 goto SkipFree;
 666
 667         // Free up the data now!
 668
 669         //      mprintf(( "Bitmap %d freed %d bytes\n", n, bm_bitmaps[n].data_size ));
 670         #ifdef BMPMAN_NDEBUG
 671                 bm_texture_ram -= be->data_size;
 672         #endif
 673         free((void *)bmp->data);
 674
 675 SkipFree:
 676
 677         // Clear out & reset the bitmap data structure
 678         bmp->flags = 0;
 679         bmp->bpp = 0;
 680         bmp->data = 0;
 681         bmp->palette = NULL;
 682         #ifdef BMPMAN_NDEBUG
 683                 be->data_size = 0;
 684         #endif
 685         be->signature = Bm_next_signature++;
 686 }
 687
 688
 689 #ifdef BMPMAN_NDEBUG
 690
 691 int Bm_ram_freed = 0;
 692
 693 static void bm_free_some_ram( int n, int size )
 694 {
 695 /*
 696         if ( Bm_max_ram < 1 ) return;
 697         if ( bm_texture_ram + size < Bm_max_ram ) return;
 698
 699         int current_time = timer_get_milliseconds();
 700
 701         while( bm_texture_ram + size > Bm_max_ram )     {
 702                 Bm_ram_freed++;
 703
 704                 // Need to free some RAM up!
 705                 int i, oldest=-1, best_val=0;
 706                 for (i = 0; i < MAX_BITMAPS; i++)       {
 707                         if ( (bm_bitmaps[i].type != BM_TYPE_NONE) && (bm_bitmaps[i].first_frame!=bm_bitmaps[n].first_frame) && (bm_bitmaps[i].ref_count==0) && (bm_bitmaps[i].data_size>0) )    {
 708                                 int page_func = ( current_time-bm_bitmaps[i].last_used)*bm_bitmaps[i].data_size;
 709                                 if ( (oldest==-1) || (page_func>best_val) )     {
 710                                         oldest=i;
 711                                         best_val = page_func;
 712                                 }
 713                         }
 714                 }
 715
 716                 if ( oldest > -1 )      {
 717                         //mprintf(( "Freeing bitmap '%s'\n", bm_bitmaps[oldest].filename ));
 718                         for (i=0; i<bm_bitmaps[oldest].num_frames; i++ )        {
 719                                 bm_free_data(bm_bitmaps[oldest].first_frame+i);
 720                         }
 721                 } else {
 722                         //mprintf(( "Couldn't free enough! %d\n", bm_texture_ram ));
 723                         break;
 724                 }
 725         }
 726 */
 727 }
 728
 729 #endif
 730
 731 static void *bm_malloc( int n, int size )
 732 {
 733         SDL_assert( n >= 0 && n < MAX_BITMAPS );
 734 //      mprintf(( "Bitmap %d allocated %d bytes\n", n, size ));
 735         #ifdef BMPMAN_NDEBUG
 736         bm_free_some_ram( n, size );
 737         SDL_assert( bm_bitmaps[n].data_size == 0 );
 738         bm_bitmaps[n].data_size += size;
 739         bm_texture_ram += size;
 740         #endif
 741         return malloc(size);
 742 }
 743
 744 void bm_close()
 745 {
 746         int i;
 747         if ( bm_inited )        {
 748                 for (i=0; i<MAX_BITMAPS; i++ )  {
 749                         bm_free_data(i);                        // clears flags, bbp, data, etc
 750                 }
 751                 bm_inited = 0;
 752         }
 753 }
 754
 755
 756 void bm_init()
 757 {
 758         int i;
 759
 760         mprintf(( "Size of bitmap info = %d KB\n", sizeof( bm_bitmaps )/1024 ));
 761         mprintf(( "Size of bitmap extra info = %d bytes\n", sizeof( bm_extra_info ) ));
 762
 763         if (!bm_inited) {
 764                 bm_inited = 1;
 765                 atexit(bm_close);
 766         }
 767
 768         for (i=0; i<MAX_BITMAPS; i++ ) {
 769                 bm_bitmaps[i].filename[0] = '\0';
 770                 bm_bitmaps[i].type = BM_TYPE_NONE;
 771                 bm_bitmaps[i].info.user.data = NULL;
 772                 bm_bitmaps[i].bm.data = 0;
 773                 bm_bitmaps[i].bm.palette = NULL;
 774                 #ifdef BMPMAN_NDEBUG
 775                         bm_bitmaps[i].data_size = 0;
 776                         bm_bitmaps[i].used_count = 0;
 777                         bm_bitmaps[i].used_last_frame = 0;
 778                         bm_bitmaps[i].used_this_frame = 0;
 779                 #endif
 780                 bm_free_data(i);        // clears flags, bbp, data, etc
 781         }
 782
 783
 784 }
 785
 786 #ifdef BMPMAN_NDEBUG
 787
 788 // Returns number of bytes of bitmaps locked this frame
 789 // ntotal = number of bytes of bitmaps locked this frame
 790 // nnew = number of bytes of bitmaps locked this frame that weren't locked last frame
 791 void bm_get_frame_usage(int *ntotal, int *nnew)
 792 {
 793         int i;
 794
 795         *ntotal = 0;
 796         *nnew = 0;
 797
 798         for (i=0; i<MAX_BITMAPS; i++ ) {
 799                 if ( (bm_bitmaps[i].type != BM_TYPE_NONE) && (bm_bitmaps[i].used_this_frame))   {
 800                         if ( !bm_bitmaps[i].used_last_frame )   {
 801                                 *nnew += bm_bitmaps[i].bm.w*bm_bitmaps[i].bm.h;
 802                         }
 803                         *ntotal += bm_bitmaps[i].bm.w*bm_bitmaps[i].bm.h;
 804                 }
 805                 bm_bitmaps[i].used_last_frame = bm_bitmaps[i].used_this_frame;
 806                 bm_bitmaps[i].used_this_frame = 0;
 807         }
 808
 809 }
 810 #else
 811 void bm_get_frame_usage(int *ntotal, int *nnew)
 812 {
 813 }
 814 #endif
 815
 816 // given a loaded bitmap with valid info, calculate sections
 817 void bm_calc_sections(bitmap *be)
 818 {
 819         int idx;
 820
 821         if (gr_screen.use_sections) {
 822                 // number of x and y sections
 823                 be->sections.num_x = (ubyte)(be->w / MAX_BMAP_SECTION_SIZE);
 824                 if((be->sections.num_x * MAX_BMAP_SECTION_SIZE) < be->w){
 825                         be->sections.num_x++;
 826                 }
 827                 be->sections.num_y = (ubyte)(be->h / MAX_BMAP_SECTION_SIZE);
 828                 if((be->sections.num_y * MAX_BMAP_SECTION_SIZE) < be->h){
 829                         be->sections.num_y++;
 830                 }
 831
 832                 // calculate the offsets for each section
 833                 for(idx=0; idx<be->sections.num_x; idx++){
 834                         be->sections.sx[idx] = (ushort)(MAX_BMAP_SECTION_SIZE * idx);
 835                 }
 836                 for(idx=0; idx<be->sections.num_y; idx++){
 837                         be->sections.sy[idx] = (ushort)(MAX_BMAP_SECTION_SIZE * idx);
 838                 }
 839         } else {
 840                 be->sections.num_x = 1;
 841                 be->sections.num_y = 1;
 842
 843                 be->sections.sx[0] = 0;
 844                 be->sections.sy[0] = 0;
 845         }
 846 }
 847
 848 // Creates a bitmap that exists in RAM somewhere, instead
 849 // of coming from a disk file.  You pass in a pointer to a
 850 // block of 32 (or 8)-bit-per-pixel data.  Right now, the only
 851 // bpp you can pass in is 32 or 8.  On success, it returns the
 852 // bitmap number.  You cannot free that RAM until bm_release
 853 // is called on that bitmap.
 854 int bm_create( int bpp, int w, int h, void *data, int flags )
 855 {
 856         int i, n, first_slot = MAX_BITMAPS;
 857
 858         if (data == NULL) {
 859                 Int3();
 860                 return -1;
 861         }
 862
 863         // SDL_assert((bpp==32)||(bpp==8));
 864         if(bpp != 16){
 865                 SDL_assert(flags & BMP_AABITMAP);
 866         } else {
 867                 SDL_assert(bpp == 16);
 868         }
 869
 870         if ( !bm_inited ) bm_init();
 871
 872         for (i = MAX_BITMAPS-1; i >= 0; i-- ) {
 873                 if ( bm_bitmaps[i].type == BM_TYPE_NONE )       {
 874                         first_slot = i;
 875                         break;
 876                 }
 877         }
 878
 879         n = first_slot;
 880         SDL_assert( n > -1 );
 881
 882         // Out of bitmap slots
 883         if ( n == -1 ) return -1;
 884
 885         memset( &bm_bitmaps[n], 0, sizeof(bitmap_entry) );
 886
 887         sprintf( bm_bitmaps[n].filename, "TMP%dx%d", w, h );
 888         bm_bitmaps[n].type = BM_TYPE_USER;
 889         bm_bitmaps[n].palette_checksum = 0;
 890
 891         bm_bitmaps[n].bm.w = short(w);
 892         bm_bitmaps[n].bm.h = short(h);
 893         bm_bitmaps[n].bm.rowsize = short(w);
 894         bm_bitmaps[n].bm.bpp = (unsigned char)(bpp);
 895         bm_bitmaps[n].bm.flags = 0;
 896         bm_bitmaps[n].bm.flags |= flags;
 897         bm_bitmaps[n].bm.data = 0;
 898         bm_bitmaps[n].bm.palette = NULL;
 899
 900         bm_bitmaps[n].info.user.bpp = ubyte(bpp);
 901         bm_bitmaps[n].info.user.data = data;
 902         bm_bitmaps[n].info.user.flags = ubyte(flags);
 903
 904         bm_bitmaps[n].signature = Bm_next_signature++;
 905
 906         bm_bitmaps[n].handle = bm_get_next_handle()*MAX_BITMAPS + n;
 907         bm_bitmaps[n].last_used = -1;
 908
 909         // fill in section info
 910         bm_calc_sections(&bm_bitmaps[n].bm);
 911
 912         return bm_bitmaps[n].handle;
 913 }
 914
 915 // sub helper function. Given a raw filename and an extension, try and find the bitmap
 916 // returns -1 if it could not be found
 917 //          0 if it was found as a file
 918 //          1 if it already exists, fills in handle
 919 int Bm_ignore_duplicates = 0;
 920 int bm_load_sub(const char *real_filename, const char *ext, int *handle)
 921 {
 922         int i;
 923         char filename[MAX_FILENAME_LEN] = "";
 924
 925         strcpy( filename, real_filename );
 926         strcat( filename, ext );
 927         for (i=0; i<(int)strlen(filename); i++ ){
 928                 filename[i] = char(tolower(filename[i]));
 929         }
 930
 931         // try to find given filename to see if it has been loaded before
 932         if(!Bm_ignore_duplicates){
 933                 for (i = 0; i < MAX_BITMAPS; i++) {
 934                         if ( (bm_bitmaps[i].type != BM_TYPE_NONE) && !SDL_strcasecmp(filename, bm_bitmaps[i].filename) ) {
 935                                 nprintf (("BmpMan", "Found bitmap %s -- number %d\n", filename, i));
 936                                 *handle = bm_bitmaps[i].handle;
 937                                 return 1;
 938                         }
 939                 }
 940         }
 941
 942         // try and find the file
 943         /*
 944         CFILE *test = cfopen(filename, "rb");
 945         if(test != NULL){
 946                 cfclose(test);
 947                 return 0;
 948         }
 949         */
 950
 951         // could not be found
 952         return 0;
 953 }
 954
 955 // This loads a bitmap so we can draw with it later.
 956 // It returns a negative number if it couldn't load
 957 // the bitmap.   On success, it returns the bitmap
 958 // number.  Function doesn't acutally load the data, only
 959 // width, height, and possibly flags.
 960 int bm_load( const char * real_filename )
 961 {
 962         int i, n, first_slot = MAX_BITMAPS;
 963         int w, h, bpp;
 964         char filename[MAX_FILENAME_LEN];
 965         int tga = 0;
 966         int handle;
 967         int found = 0;
 968
 969         if ( !bm_inited ) bm_init();
 970
 971         // nice little trick for keeping standalone memory usage way low - always return a bogus bitmap
 972         if(Game_mode & GM_STANDALONE_SERVER){
 973                 strcpy(filename,"test128");
 974         }
 975
 976         // make sure no one passed an extension
 977         strcpy( filename, real_filename );
 978         char *p = strchr( filename, '.' );
 979         if ( p ) {
 980                 mprintf(( "Someone passed an extension to bm_load for file '%s'\n", real_filename ));
 981                 //Int3();
 982                 *p = 0;
 983         }
 984
 985         // try and find the pcx file
 986         switch(bm_load_sub(filename, ".pcx", &handle)){
 987         // error
 988         case -1:
 989                 break;
 990
 991         // found as a file
 992         case 0:
 993                 found = 1;
 994                 strcat(filename, ".pcx");
 995                 break;
 996
 997         // found as pre-existing
 998         case 1:
 999                 found = 1;
1000                 return handle;
1001         }
1002
1003         if(!found){
1004                 // try and find the tga file
1005                 switch(bm_load_sub(filename, ".tga", &handle)){
1006                 // error
1007                 case -1:
1008                         return -1;
1009                         break;
1010
1011                 // found as a file
1012                 case 0:
1013                         strcat(filename, ".tga");
1014                         tga = 1;
1015                         break;
1016
1017                 // found as pre-existing
1018                 case 1:
1019                         return handle;
1020                 }
1021         }
1022
1023         // if its a tga file
1024         if(tga){
1025                 int tga_error=targa_read_header( filename, &w, &h, &bpp, NULL );
1026                 if ( tga_error != TARGA_ERROR_NONE )    {
1027                         mprintf(( "Couldn't open '%s'\n", filename ));
1028                         return -1;
1029                 }
1030         }
1031         // if its a pcx file
1032         else {
1033                 int pcx_error=pcx_read_header( filename, &w, &h, NULL );
1034                 if ( pcx_error != PCX_ERROR_NONE )      {
1035                         mprintf(( "Couldn't open '%s'\n", filename ));
1036                         return -1;
1037                 }
1038         }
1039
1040         // Error( LOCATION, "Unknown bitmap type %s\n", filename );
1041
1042         // Find an open slot
1043         for (i = 0; i < MAX_BITMAPS; i++) {
1044                 if ( (bm_bitmaps[i].type == BM_TYPE_NONE) && (first_slot == MAX_BITMAPS) ){
1045                         first_slot = i;
1046                 }
1047         }
1048
1049         n = first_slot;
1050         SDL_assert( n < MAX_BITMAPS );
1051
1052         if ( n == MAX_BITMAPS ) return -1;
1053
1054         // ensure fields are cleared out from previous bitmap
1055 //      SDL_assert(bm_bitmaps[n].bm.data == 0);
1056 //      SDL_assert(bm_bitmaps[n].bm.palette == NULL);
1057 //      SDL_assert(bm_bitmaps[n].ref_count == 0 );
1058 //      SDL_assert(bm_bitmaps[n].user_data == NULL);
1059         memset( &bm_bitmaps[n], 0, sizeof(bitmap_entry) );
1060
1061         // Mark the slot as filled, because cf_read might load a new bitmap
1062         // into this slot.
1063         bm_bitmaps[n].type = tga ? (ubyte)BM_TYPE_TGA : (ubyte)BM_TYPE_PCX;
1064         bm_bitmaps[n].signature = Bm_next_signature++;
1065         SDL_assert ( strlen(filename) < MAX_FILENAME_LEN );
1066         strncpy(bm_bitmaps[n].filename, filename, MAX_FILENAME_LEN-1 );
1067         bm_bitmaps[n].bm.w = short(w);
1068         bm_bitmaps[n].bm.rowsize = short(w);
1069         bm_bitmaps[n].bm.h = short(h);
1070         bm_bitmaps[n].bm.bpp = 0;
1071         bm_bitmaps[n].bm.flags = 0;
1072         bm_bitmaps[n].bm.data = 0;
1073         bm_bitmaps[n].bm.palette = NULL;
1074
1075         bm_bitmaps[n].palette_checksum = 0;
1076         bm_bitmaps[n].handle = bm_get_next_handle()*MAX_BITMAPS + n;
1077         bm_bitmaps[n].last_used = -1;
1078
1079         // fill in section info
1080         bm_calc_sections(&bm_bitmaps[n].bm);
1081
1082         return bm_bitmaps[n].handle;
1083 }
1084
1085 // special load function. basically allows you to load a bitmap which already exists (by filename).
1086 // this is useful because in some cases we need to have a bitmap which is locked in screen format
1087 // _and_ texture format, such as pilot pics and squad logos
1088 int bm_load_duplicate(const char *filename)
1089 {
1090         int ret;
1091
1092         // ignore duplicates
1093         Bm_ignore_duplicates = 1;
1094
1095         // load
1096         ret = bm_load(filename);
1097
1098         // back to normal
1099         Bm_ignore_duplicates = 0;
1100
1101         return ret;
1102 }
1103
1104 DCF(bm_frag,"Shows BmpMan fragmentation")
1105 {
1106         if ( Dc_command )       {
1107
1108                 gr_clear();
1109
1110                 int x=0, y=0;
1111                 int xs=2, ys=2;
1112                 int w=4, h=4;
1113
1114                 for (int i=0; i<MAX_BITMAPS; i++ )      {
1115                         switch( bm_bitmaps[i].type )    {
1116                         case BM_TYPE_NONE:
1117                                 gr_set_color(128,128,128);
1118                                 break;
1119                         case BM_TYPE_PCX:
1120                                 gr_set_color(255,0,0);
1121                                 break;
1122                         case BM_TYPE_USER:
1123                                 gr_set_color(0,255,0);
1124                                 break;
1125                         case BM_TYPE_ANI:
1126                                 gr_set_color(0,0,255);
1127                                 break;
1128                         }
1129
1130                         gr_rect( x+xs, y+ys, w, h );
1131                         x += w+xs+xs;
1132                         if ( x > 639 )  {
1133                                 x = 0;
1134                                 y += h + ys + ys;
1135                         }
1136
1137                 }
1138
1139                 gr_flip();
1140                 key_getch();
1141         }
1142 }
1143
1144 static int find_block_of(int n)
1145 {
1146         int i, cnt, nstart;
1147
1148         cnt=0;
1149         nstart = 0;
1150         for (i=0; i<MAX_BITMAPS; i++ )  {
1151                 if ( bm_bitmaps[i].type == BM_TYPE_NONE )       {
1152                         if (cnt==0) nstart = i;
1153                         cnt++;
1154                 } else
1155                         cnt=0;
1156                 if ( cnt == n ) return nstart;
1157         }
1158
1159         // Error( LOCATION, "Couldn't find block of %d frames\n", n );
1160         return -1;
1161 }
1162
1163 // ------------------------------------------------------------------
1164 // bm_load_animation()
1165 //
1166 //      input:          filename                =>              filename of animation
1167 //                                      nframes         =>              OUTPUT parameter:       number of frames in the animation
1168 //                                      fps                     =>              OUTPUT/OPTIONAL parameter: intended fps for the animation
1169 //
1170 // returns:             bitmap number of first frame in the animation
1171 //
1172 int bm_load_animation( const char *real_filename, int *nframes, int *fps, int can_drop_frames)
1173 {
1174         int     i, n;
1175         anim    the_anim;
1176         CFILE   *fp;
1177         char filename[MAX_FILENAME_LEN];
1178
1179         if ( !bm_inited ) bm_init();
1180
1181         strcpy( filename, real_filename );
1182         char *p = strchr( filename, '.' );
1183         if ( p ) {
1184                 mprintf(( "Someone passed an extension to bm_load_animation for file '%s'\n", real_filename ));
1185                 //Int3();
1186                 *p = 0;
1187         }
1188         strcat( filename, ".ani" );
1189
1190         if ( (fp = cfopen(filename, "rb")) == NULL ) {
1191 //              Error(LOCATION,"Could not open filename %s in bm_load_ani()\n", filename);
1192                 return -1;
1193         }
1194
1195         int reduced = 0;
1196 #ifndef NDEBUG
1197         // for debug of ANI sizes
1198         strcpy(the_anim.name, real_filename);
1199 #endif
1200         anim_read_header(&the_anim, fp);
1201         if ( can_drop_frames )  {
1202                 if ( Bm_low_mem == 1 )  {
1203                         reduced = 1;
1204                         the_anim.total_frames = ( the_anim.total_frames+1)/2;
1205                 } else if ( Bm_low_mem == 2 )   {
1206                         the_anim.total_frames = 1;
1207                 }
1208         }
1209         cfclose(fp);
1210
1211         *nframes = the_anim.total_frames;
1212         if ( fps != NULL )      {
1213                 if ( reduced )  {
1214                         *fps = the_anim.fps / 2;
1215                 } else {
1216                         *fps = the_anim.fps;
1217                 }
1218         }
1219
1220         // first check to see if this ani already has it's frames loaded
1221         for (i = 0; i < MAX_BITMAPS; i++) {
1222                 if ( (bm_bitmaps[i].type == BM_TYPE_ANI) && !SDL_strcasecmp(filename, bm_bitmaps[i].filename) ) {
1223                         break;
1224                 }
1225         }
1226
1227         if ( i < MAX_BITMAPS ) {
1228                 // in low memory modes this can happen
1229                 if(!Bm_low_mem){
1230                         SDL_assert(bm_bitmaps[i].info.ani.num_frames == *nframes);
1231                 }
1232                 return bm_bitmaps[i].handle;
1233         }
1234
1235         n = find_block_of(*nframes);
1236         if(n < 0){
1237                 return -1;
1238         }
1239         // SDL_assert( n >= 0 );
1240
1241         int first_handle = bm_get_next_handle();
1242
1243         SDL_assert ( strlen(filename) < MAX_FILENAME_LEN );
1244         for ( i = 0; i < *nframes; i++ ) {
1245                 memset( &bm_bitmaps[n+i], 0, sizeof(bitmap_entry) );
1246                 bm_bitmaps[n+i].info.ani.first_frame = n;
1247                 bm_bitmaps[n+i].info.ani.num_frames = ubyte(the_anim.total_frames);
1248                 bm_bitmaps[n+i].info.ani.fps = ubyte(the_anim.fps);
1249                 bm_bitmaps[n+i].bm.w = short(the_anim.width);
1250                 bm_bitmaps[n+i].bm.rowsize = short(the_anim.width);
1251                 bm_bitmaps[n+i].bm.h = short(the_anim.height);
1252                 if ( reduced )  {
1253                         bm_bitmaps[n+i].bm.w /= 2;
1254                         bm_bitmaps[n+i].bm.rowsize /= 2;
1255                         bm_bitmaps[n+i].bm.h /= 2;
1256                 }
1257                 bm_bitmaps[n+i].bm.flags = 0;
1258                 bm_bitmaps[n+i].bm.bpp = 0;
1259                 bm_bitmaps[n+i].bm.data = 0;
1260                 bm_bitmaps[n+i].bm.palette = NULL;
1261                 bm_bitmaps[n+i].type = BM_TYPE_ANI;
1262                 bm_bitmaps[n+i].palette_checksum = 0;
1263                 bm_bitmaps[n+i].signature = Bm_next_signature++;
1264                 bm_bitmaps[n+i].handle = first_handle*MAX_BITMAPS + n+i;
1265                 bm_bitmaps[n+i].last_used = -1;
1266
1267                 // fill in section info
1268                 bm_calc_sections(&bm_bitmaps[n+i].bm);
1269
1270                 if ( i == 0 )   {
1271                         sprintf( bm_bitmaps[n+i].filename, "%s", filename );
1272                 } else {
1273                         sprintf( bm_bitmaps[n+i].filename, "%s[%d]", filename, i );
1274                 }
1275         }
1276
1277         return bm_bitmaps[n].handle;
1278 }
1279
1280 // Gets info.   w,h,or flags,nframes or fps can be NULL if you don't care.
1281 void bm_get_info( int handle, int *w, int * h, ubyte * flags, int *nframes, int *fps, bitmap_section_info **sections )
1282 {
1283         bitmap * bmp;
1284
1285         if ( !bm_inited ) return;
1286
1287         int bitmapnum = handle % MAX_BITMAPS;
1288         SDL_assert( bm_bitmaps[bitmapnum].handle == handle );           // INVALID BITMAP HANDLE!
1289
1290         if ( (bm_bitmaps[bitmapnum].type == BM_TYPE_NONE) || (bm_bitmaps[bitmapnum].handle != handle) ) {
1291                 if (w) *w = 0;
1292                 if (h) *h = 0;
1293                 if (flags) *flags = 0;
1294                 if (nframes) *nframes=0;
1295                 if (fps) *fps=0;
1296                 if (sections != NULL) *sections = NULL;
1297                 return;
1298         }
1299
1300         bmp = &(bm_bitmaps[bitmapnum].bm);
1301
1302         if (w) *w = bmp->w;
1303         if (h) *h = bmp->h;
1304         if (flags) *flags = bmp->flags;
1305         if ( bm_bitmaps[bitmapnum].type == BM_TYPE_ANI )        {
1306                 if (nframes) {
1307                         *nframes = bm_bitmaps[bitmapnum].info.ani.num_frames;
1308                 }
1309                 if (fps) {
1310                         *fps= bm_bitmaps[bitmapnum].info.ani.fps;
1311                 }
1312         } else {
1313                 if (nframes) {
1314                         *nframes = 1;
1315                 }
1316                 if (fps) {
1317                         *fps= 0;
1318                 }
1319         }
1320         if(sections != NULL){
1321                 *sections = &bm_bitmaps[bitmapnum].bm.sections;
1322         }
1323 }
1324
1325 uint bm_get_signature( int handle )
1326 {
1327         if ( !bm_inited ) bm_init();
1328
1329         int bitmapnum = handle % MAX_BITMAPS;
1330         SDL_assert( bm_bitmaps[bitmapnum].handle == handle );           // INVALID BITMAP HANDLE
1331
1332         return bm_bitmaps[bitmapnum].signature;
1333 }
1334
1335 extern int palman_is_nondarkening(int r,int g, int b);
1336 static void bm_convert_format( int bitmapnum, bitmap *bmp, ubyte bpp, ubyte flags )
1337 {
1338         int idx;
1339         int r, g, b, a;
1340
1341         if(Fred_running || Pofview_running || Is_standalone){
1342                 SDL_assert(bmp->bpp == 8);
1343
1344                 return;
1345         } else {
1346                 if(flags & BMP_AABITMAP){
1347                         SDL_assert(bmp->bpp == 8);
1348                 } else {
1349                         SDL_assert(bmp->bpp == 16);
1350                 }
1351         }
1352
1353         // maybe swizzle to be an xparent texture
1354         if(!(bmp->flags & BMP_TEX_XPARENT) && (flags & BMP_TEX_XPARENT)){
1355                 for(idx=0; idx<bmp->w*bmp->h; idx++){
1356
1357                         // if the pixel is transparent
1358                         if ( ((ushort*)bmp->data)[idx] == Gr_t_green.mask)      {
1359                                 switch(Bm_pixel_format){
1360                                 // 1555, all we need to do is zero the whole thing
1361                                 case BM_PIXEL_FORMAT_ARGB:
1362                                         ((ushort*)bmp->data)[idx] = 0;
1363                                         break;
1364                                 default:
1365                                         Int3();
1366                                 }
1367                         }
1368                 }
1369
1370                 bmp->flags |= BMP_TEX_XPARENT;
1371         }
1372 }
1373
1374 // basically, map the bitmap into the current palette. used to be done for all pcx's, now just for
1375 // Fred, since its the only thing that uses the software tmapper
1376 void bm_swizzle_8bit_for_fred(bitmap_entry *be, bitmap *bmp, ubyte *data, ubyte *palette)
1377 {
1378         int pcx_xparent_index = -1;
1379         int i;
1380         int r, g, b;
1381         ubyte palxlat[256];
1382
1383         for (i=0; i<256; i++ ) {
1384                 r = palette[i*3];
1385                 g = palette[i*3+1];
1386                 b = palette[i*3+2];
1387                 if ( g == 255 && r == 0 && b == 0 ) {
1388                         palxlat[i] = 255;
1389                         pcx_xparent_index = i;
1390                 } else {
1391                         palxlat[i] = (ubyte)(palette_find( r, g, b ));
1392                 }
1393         }
1394         for (i=0; i<bmp->w * bmp->h; i++ ) {
1395                 ubyte c = palxlat[data[i]];
1396                 data[i] = c;
1397         }
1398         be->palette_checksum = gr_palette_checksum;
1399 }
1400
1401 void bm_lock_pcx( int handle, int bitmapnum, bitmap_entry *be, bitmap *bmp, ubyte bpp, ubyte flags )
1402 {
1403         ubyte *data, *palette;
1404         ubyte pal[768];
1405         palette = NULL;
1406
1407         // Unload any existing data
1408         bm_free_data( bitmapnum );
1409
1410         // allocate bitmap data
1411         if(bpp == 8){
1412                 // SDL_assert(Fred_running || Pofview_running || Is_standalone);
1413                         data = (ubyte *)bm_malloc(bitmapnum, bmp->w * bmp->h );
1414                 #ifdef BMPMAN_NDEBUG
1415                         SDL_assert( be->data_size == bmp->w * bmp->h );
1416                 #endif
1417                 palette = pal;
1418                 bmp->data = (ptr_u)data;
1419                 bmp->bpp = 8;
1420                 bmp->palette = gr_palette;
1421                 memset( data, 0, bmp->w * bmp->h);
1422         } else {
1423                 data = (ubyte*)bm_malloc(bitmapnum, bmp->w * bmp->h * 2);
1424                 bmp->bpp = 16;
1425                 bmp->data = (ptr_u)data;
1426                 bmp->palette = NULL;
1427                 memset( data, 0, bmp->w * bmp->h * 2);
1428         }
1429
1430         SDL_assert( &be->bm == bmp );
1431         #ifdef BMPMAN_NDEBUG
1432                 SDL_assert( be->data_size > 0 );
1433         #endif
1434
1435         // some sanity checks on flags
1436         SDL_assert(!((flags & BMP_AABITMAP) && (flags & BMP_TEX_ANY)));                                         // no aabitmap textures
1437
1438         if(bpp == 8){
1439                 int pcx_error=pcx_read_bitmap_8bpp( be->filename, data, palette );
1440                 if ( pcx_error != PCX_ERROR_NONE )      {
1441                         // Error( LOCATION, "Couldn't open '%s'\n", be->filename );
1442                         //Error( LOCATION, "Couldn't open '%s'\n", filename );
1443                         //return -1;
1444                 }
1445
1446                 // now swizzle the thing into the proper format
1447                 if(Fred_running || Pofview_running){
1448                         bm_swizzle_8bit_for_fred(be, bmp, data, palette);
1449                 }
1450         } else {
1451                 int pcx_error;
1452
1453                 // load types
1454                 if(flags & BMP_AABITMAP){
1455                         pcx_error = pcx_read_bitmap_16bpp_aabitmap( be->filename, data );
1456                 } else {
1457                         pcx_error = pcx_read_bitmap_16bpp( be->filename, data );
1458                 }
1459                 if ( pcx_error != PCX_ERROR_NONE )      {
1460                         // Error( LOCATION, "Couldn't open '%s'\n", be->filename );
1461                         //Error( LOCATION, "Couldn't open '%s'\n", filename );
1462                         //return -1;
1463                 }
1464         }
1465
1466         #ifdef BMPMAN_NDEBUG
1467         SDL_assert( be->data_size > 0 );
1468         #endif
1469
1470         bmp->flags = 0;
1471         bm_convert_format( bitmapnum, bmp, bpp, flags );
1472 }
1473
1474 void bm_lock_ani( int handle, int bitmapnum, bitmap_entry *be, bitmap *bmp, ubyte bpp, ubyte flags )
1475 {
1476         anim                            *the_anim;
1477         anim_instance   *the_anim_instance;
1478         bitmap                  *bm;
1479         ubyte                           *frame_data;
1480         int                             size, i;
1481         int                             first_frame, nframes;
1482
1483         first_frame = be->info.ani.first_frame;
1484         nframes = bm_bitmaps[first_frame].info.ani.num_frames;
1485
1486         if ( (the_anim = anim_load(bm_bitmaps[first_frame].filename)) == NULL ) {
1487                 // Error(LOCATION, "Error opening %s in bm_lock\n", be->filename);
1488         }
1489
1490         if ( (the_anim_instance = init_anim_instance(the_anim, bpp)) == NULL ) {
1491                 // Error(LOCATION, "Error opening %s in bm_lock\n", be->filename);
1492                 anim_free(the_anim);
1493         }
1494
1495         int can_drop_frames = 0;
1496
1497         if ( the_anim->total_frames != bm_bitmaps[first_frame].info.ani.num_frames )    {
1498                 can_drop_frames = 1;
1499         }
1500         bm = &bm_bitmaps[first_frame].bm;
1501         if(bpp == 16){
1502                 size = bm->w * bm->h * 2;
1503         } else {
1504                 size = bm->w * bm->h;
1505         }
1506
1507         for ( i=0; i<nframes; i++ )     {
1508                 be = &bm_bitmaps[first_frame+i];
1509                 bm = &bm_bitmaps[first_frame+i].bm;
1510
1511                 // Unload any existing data
1512                 bm_free_data( first_frame+i );
1513
1514                 bm->flags = 0;
1515                 // briefing editor in Fred2 uses aabitmaps (ani's) - force to 8 bit
1516                 if(Fred_running || Is_standalone){
1517                         bm->bpp = 8;
1518                 } else {
1519                         bm->bpp = bpp;
1520                 }
1521                 bm->data = (ptr_u)bm_malloc(first_frame + i, size);
1522
1523                 frame_data = anim_get_next_raw_buffer(the_anim_instance, 0 ,flags & BMP_AABITMAP ? 1 : 0, bm->bpp);
1524
1525                 if ( frame_data == NULL ) {
1526                         // Error(LOCATION,"Fatal error locking .ani file: %s\n", be->filename);
1527                 }
1528
1529                 ubyte *dptr, *sptr;
1530
1531                 sptr = frame_data;
1532                 dptr = (ubyte *)bm->data;
1533
1534                 if ( (bm->w!=the_anim->width) || (bm->h!=the_anim->height) )    {
1535                         // Scale it down
1536                         // Int3();                      // not ready yet - should only be ingame
1537
1538                         // 8 bit
1539                         if(bpp == 8){
1540                                 int w,h;
1541                                 fix u, utmp, v, du, dv;
1542
1543                                 u = v = 0;
1544
1545                                 du = ( the_anim->width*F1_0 ) / bm->w;
1546                                 dv = ( the_anim->height*F1_0 ) / bm->h;
1547
1548                                 for (h = 0; h < bm->h; h++) {
1549                                         ubyte *drow = &dptr[bm->w * h];
1550                                         ubyte *srow = &sptr[f2i(v)*the_anim->width];
1551
1552                                         utmp = u;
1553
1554                                         for (w = 0; w < bm->w; w++) {
1555                                                 *drow++ = srow[f2i(utmp)];
1556                                                 utmp += du;
1557                                         }
1558                                         v += dv;
1559                                 }
1560                         }
1561                         // 16 bpp
1562                         else {
1563                                 int w,h;
1564                                 fix u, utmp, v, du, dv;
1565
1566                                 u = v = 0;
1567
1568                                 du = ( the_anim->width*F1_0 ) / bm->w;
1569                                 dv = ( the_anim->height*F1_0 ) / bm->h;
1570
1571                                 for (h = 0; h < bm->h; h++) {
1572                                         ushort *drow = &((ushort*)dptr)[bm->w * h];
1573                                         ushort *srow = &((ushort*)sptr)[f2i(v)*the_anim->width];
1574
1575                                         utmp = u;
1576
1577                                         for (w = 0; w < bm->w; w++) {
1578                                                 *drow++ = srow[f2i(utmp)];
1579                                                 utmp += du;
1580                                         }
1581                                         v += dv;
1582                                 }
1583                         }
1584                 } else {
1585                         // 1-to-1 mapping
1586                         memcpy(dptr, sptr, size);
1587                 }
1588
1589                 bm_convert_format( first_frame+i, bm, bpp, flags );
1590
1591                 // Skip a frame
1592                 if ( (i < nframes-1)  && can_drop_frames )      {
1593                         frame_data = anim_get_next_raw_buffer(the_anim_instance, 0, flags & BMP_AABITMAP ? 1 : 0, bm->bpp);
1594                 }
1595
1596                 //mprintf(( "Checksum = %d\n", be->palette_checksum ));
1597         }
1598
1599         free_anim_instance(the_anim_instance);
1600         anim_free(the_anim);
1601 }
1602
1603
1604 void bm_lock_user( int handle, int bitmapnum, bitmap_entry *be, bitmap *bmp, ubyte bpp, ubyte flags )
1605 {
1606         // int idx;
1607         // ushort bit_16;
1608
1609         // Unload any existing data
1610         bm_free_data( bitmapnum );
1611
1612         switch( be->info.user.bpp )     {
1613         case 16:                        // user 16 bit bitmap
1614                 bmp->bpp = bpp;
1615                 bmp->flags = be->info.user.flags;
1616                 bmp->data = (ptr_u)be->info.user.data;
1617                 break;
1618
1619         case 8:                 // Going from 8 bpp to something (probably only for aabitmaps)
1620                 /*
1621                 SDL_assert(flags & BMP_AABITMAP);
1622                 bmp->bpp = 16;
1623                 bmp->data = (uint)malloc(bmp->w * bmp->h * 2);
1624                 bmp->flags = be->info.user.flags;
1625                 bmp->palette = NULL;
1626
1627                 // go through and map the pixels
1628                 for(idx=0; idx<bmp->w * bmp->h; idx++){
1629                         bit_16 = (ushort)((ubyte*)be->info.user.data)[idx];
1630                         SDL_assert(bit_16 <= 255);
1631
1632                         // stuff the final result
1633                         memcpy((char*)bmp->data + (idx * 2), &bit_16, sizeof(ushort));
1634                 }
1635                 */
1636                 SDL_assert(flags & BMP_AABITMAP);
1637                 bmp->bpp = bpp;
1638                 bmp->flags = be->info.user.flags;
1639                 bmp->data = (ptr_u)be->info.user.data;
1640                 break;
1641
1642         // default:
1643                 // Error( LOCATION, "Unhandled user bitmap conversion from %d to %d bpp", be->info.user.bpp, bmp->bpp );
1644         }
1645
1646         bm_convert_format( bitmapnum, bmp, bpp, flags );
1647 }
1648
1649 void bm_lock_tga( int handle, int bitmapnum, bitmap_entry *be, bitmap *bmp, ubyte bpp, ubyte flags )
1650 {
1651         ubyte *data;
1652
1653         // Unload any existing data
1654         bm_free_data( bitmapnum );
1655
1656         if(Fred_running || Is_standalone){
1657                 SDL_assert(bpp == 8);
1658         } else {
1659                 SDL_assert(bpp == 16);
1660         }
1661
1662         // should never try to make an aabitmap out of a targa
1663         SDL_assert(!(flags & BMP_AABITMAP));
1664
1665         // allocate bitmap data
1666         if(bpp == 16){
1667                 data = (ubyte*)bm_malloc(bitmapnum, bmp->w * bmp->h * 2);
1668         } else {
1669                 data = (ubyte*)bm_malloc(bitmapnum, bmp->w * bmp->h);
1670         }
1671         bmp->bpp = bpp;
1672         bmp->data = (ptr_u)data;
1673         bmp->palette = NULL;
1674         if(bpp == 16){
1675                 memset( data, 0, bmp->w * bmp->h * 2);
1676         } else {
1677                 memset( data, 0, bmp->w * bmp->h );
1678         }
1679
1680         SDL_assert( &be->bm == bmp );
1681         #ifdef BMPMAN_NDEBUG
1682         SDL_assert( be->data_size > 0 );
1683         #endif
1684
1685         int tga_error=targa_read_bitmap( be->filename, data, NULL, (bpp == 16) ? 2 : 1);
1686         if ( tga_error != TARGA_ERROR_NONE )    {
1687                 // Error( LOCATION, "Couldn't open '%s'\n", be->filename );
1688                 //Error( LOCATION, "Couldn't open '%s'\n", filename );
1689                 //return -1;
1690         }
1691
1692         #ifdef BMPMAN_NDEBUG
1693         SDL_assert( be->data_size > 0 );
1694         #endif
1695
1696         bmp->flags = 0;
1697         bm_convert_format( bitmapnum, bmp, bpp, flags );
1698 }
1699
1700 MONITOR( NumBitmapPage );
1701 MONITOR( SizeBitmapPage );
1702
1703 // This locks down a bitmap and returns a pointer to a bitmap
1704 // that can be accessed until you call bm_unlock.   Only lock
1705 // a bitmap when you need it!  This will convert it into the
1706 // appropriate format also.
1707 bitmap * bm_lock( int handle, ubyte bpp, ubyte flags )
1708 {
1709         bitmap                  *bmp;
1710         bitmap_entry    *be;
1711
1712
1713         if ( !bm_inited ) bm_init();
1714
1715         int bitmapnum = handle % MAX_BITMAPS;
1716         SDL_assert( bm_bitmaps[bitmapnum].handle == handle );           // INVALID BITMAP HANDLE
1717
1718 //      flags &= (~BMP_RLE);
1719
1720         // if we're on a standalone server, aways for it to lock to 8 bits
1721         if(Is_standalone){
1722                 bpp = 8;
1723                 flags = 0;
1724         }
1725         // otherwise do it as normal
1726         else {
1727                 if(Fred_running || Pofview_running){
1728                         SDL_assert( bpp == 8 );
1729                         SDL_assert( (bm_bitmaps[bitmapnum].type == BM_TYPE_PCX) || (bm_bitmaps[bitmapnum].type == BM_TYPE_ANI) || (bm_bitmaps[bitmapnum].type == BM_TYPE_TGA));
1730                 } else {
1731                         if(flags & BMP_AABITMAP){
1732                                 SDL_assert( bpp == 8 );
1733                         } else {
1734                                 SDL_assert( bpp == 16 );
1735                         }
1736                 }
1737         }
1738
1739         be = &bm_bitmaps[bitmapnum];
1740         bmp = &be->bm;
1741
1742         // If you hit this assert, chances are that someone freed the
1743         // wrong bitmap and now someone is trying to use that bitmap.
1744         // See John.
1745         SDL_assert( be->type != BM_TYPE_NONE );
1746
1747         // Increment ref count for bitmap since lock was made on it.
1748         SDL_assert(be->ref_count >= 0);
1749         be->ref_count++;                                        // Lock it before we page in data; this prevents a callback from freeing this
1750                                                                                         // as it gets read in
1751
1752         // Mark this bitmap as used this frame
1753         #ifdef BMPMAN_NDEBUG
1754         if ( be->used_this_frame < 255 )        {
1755                 be->used_this_frame++;
1756         }
1757         #endif
1758
1759         // if bitmap hasn't been loaded yet, then load it from disk
1760         // reread the bitmap from disk under certain conditions
1761         int pal_changed = 0;
1762         int rle_changed = 0;
1763         int fake_xparent_changed = 0;
1764         if ( (bmp->data == 0) || (bpp != bmp->bpp) || pal_changed || rle_changed || fake_xparent_changed ) {
1765                 SDL_assert(be->ref_count == 1);
1766
1767                 if ( be->type != BM_TYPE_USER ) {
1768                         if ( bmp->data == 0 ) {
1769                                 nprintf (("BmpMan","Loading %s for the first time.\n", be->filename));
1770                         } else if ( bpp != bmp->bpp ) {
1771                                 nprintf (("BmpMan","Reloading %s from bitdepth %d to bitdepth %d\n", be->filename, bmp->bpp, bpp));
1772                         } else if ( pal_changed ) {
1773                                 nprintf (("BmpMan","Reloading %s to remap palette\n", be->filename));
1774                         } else if ( rle_changed )       {
1775                                 nprintf (("BmpMan","Reloading %s to change RLE.\n", be->filename));
1776                         } else if ( fake_xparent_changed )      {
1777                                 nprintf (("BmpMan","Reloading %s to change fake xparency.\n", be->filename));
1778                         }
1779                 }
1780
1781                 MONITOR_INC( NumBitmapPage, 1 );
1782                 MONITOR_INC( SizeBitmapPage, bmp->w*bmp->h );
1783
1784                 if ( !Bm_paging )       {
1785                         if ( be->type != BM_TYPE_USER ) {
1786                                 char flag_text[64];
1787                                 strcpy( flag_text, "--" );
1788                                 nprintf(( "Paging", "Loading %s (%dx%dx%dx%s)\n", be->filename, bmp->w, bmp->h, bpp, flag_text ));
1789                         }
1790                 }
1791
1792                 // select proper format
1793                 if(flags & BMP_AABITMAP){
1794                         BM_SELECT_ALPHA_TEX_FORMAT();
1795                 } else if(flags & BMP_TEX_ANY){
1796                         BM_SELECT_TEX_FORMAT();
1797                 } else {
1798                         BM_SELECT_SCREEN_FORMAT();
1799                 }
1800
1801                 switch ( be->type ) {
1802                 case BM_TYPE_PCX:
1803                         bm_lock_pcx( handle, bitmapnum, be, bmp, bpp, flags );
1804                         break;
1805
1806                 case BM_TYPE_ANI:
1807                         bm_lock_ani( handle, bitmapnum, be, bmp, bpp, flags );
1808                         break;
1809
1810                 case BM_TYPE_USER:
1811                         bm_lock_user( handle, bitmapnum, be, bmp, bpp, flags );
1812                         break;
1813
1814                 case BM_TYPE_TGA:
1815                         bm_lock_tga( handle, bitmapnum, be, bmp, bpp, flags );
1816                         break;
1817
1818                 default:
1819                         Warning(LOCATION, "Unsupported type in bm_lock -- %d\n", be->type );
1820                         return NULL;
1821                 }
1822
1823                 // always go back to screen format
1824                 BM_SELECT_SCREEN_FORMAT();
1825         }
1826
1827         if ( be->type == BM_TYPE_ANI ) {
1828                 int i,first = bm_bitmaps[bitmapnum].info.ani.first_frame;
1829
1830                 for ( i=0; i< bm_bitmaps[first].info.ani.num_frames; i++ )      {
1831                         // Mark all the bitmaps in this bitmap or animation as recently used
1832                         bm_bitmaps[first+i].last_used = timer_get_milliseconds();
1833
1834                         // Mark all the bitmaps in this bitmap or animation as used for the usage tracker.
1835                         #ifdef BMPMAN_NDEBUG
1836                                 bm_bitmaps[first+i].used_count++;
1837                         #endif
1838                         bm_bitmaps[first+i].used_flags = flags;
1839                 }
1840         } else {
1841                 // Mark all the bitmaps in this bitmap or animation as recently used
1842                 be->last_used = timer_get_milliseconds();
1843
1844                 // Mark all the bitmaps in this bitmap or animation as used for the usage tracker.
1845                 #ifdef BMPMAN_NDEBUG
1846                         be->used_count++;
1847                 #endif
1848                 be->used_flags = flags;
1849         }
1850
1851         return bmp;
1852 }
1853
1854 // Unlocks a bitmap
1855 //
1856 // Decrements the ref_count member of the bitmap_entry struct.  A bitmap can only be unloaded
1857 // when the ref_count is 0.
1858 //
1859 void bm_unlock( int handle )
1860 {
1861         bitmap_entry    *be;
1862         bitmap                  *bmp;
1863
1864         int bitmapnum = handle % MAX_BITMAPS;
1865         SDL_assert( bm_bitmaps[bitmapnum].handle == handle );   // INVALID BITMAP HANDLE
1866
1867         SDL_assert(bitmapnum >= 0 && bitmapnum < MAX_BITMAPS);
1868         if ( !bm_inited ) bm_init();
1869
1870         be = &bm_bitmaps[bitmapnum];
1871         bmp = &be->bm;
1872
1873         be->ref_count--;
1874         SDL_assert(be->ref_count >= 0);         // Trying to unlock data more times than lock was called!!!
1875
1876 }
1877
1878
1879 void bm_update()
1880 {
1881 }
1882
1883 char *bm_get_filename(int handle)
1884 {
1885         int n;
1886
1887         n = handle % MAX_BITMAPS;
1888         SDL_assert(bm_bitmaps[n].handle == handle);             // INVALID BITMAP HANDLE
1889         return bm_bitmaps[n].filename;
1890 }
1891
1892 void bm_get_palette(int handle, ubyte *pal, char *name)
1893 {
1894         char *filename;
1895         int w,h;
1896
1897         int n= handle % MAX_BITMAPS;
1898         SDL_assert( bm_bitmaps[n].handle == handle );           // INVALID BITMAP HANDLE
1899
1900         filename = bm_bitmaps[n].filename;
1901
1902         if (name)       {
1903                 strcpy( name, filename );
1904         }
1905
1906         int pcx_error=pcx_read_header( filename, &w, &h, pal );
1907         if ( pcx_error != PCX_ERROR_NONE ){
1908                 // Error(LOCATION, "Couldn't open '%s'\n", filename );
1909         }
1910 }
1911
1912 // --------------------------------------------------------------------------------------
1913 // bm_release()  - unloads the bitmap's data and entire slot, so bitmap 'n' won't be valid anymore
1914 //
1915 // parameters:          n               =>              index into bm_bitmaps ( index returned from bm_load() or bm_create() )
1916 //
1917 // returns:                     nothing
1918
1919 // opengl hack
1920 void opengl1_free_texture_with_handle(int handle);
1921 void bm_release(int handle)
1922 {
1923         bitmap_entry    *be;
1924
1925         int n = handle % MAX_BITMAPS;
1926
1927         SDL_assert(n >= 0 && n < MAX_BITMAPS);
1928         be = &bm_bitmaps[n];
1929
1930         if ( bm_bitmaps[n].type == BM_TYPE_NONE ) {
1931                 return; // Already been released?
1932         }
1933
1934         if ( bm_bitmaps[n].type != BM_TYPE_USER )       {
1935                 return;
1936         }
1937
1938         SDL_assert( be->handle == handle );             // INVALID BITMAP HANDLE
1939
1940         // If it is locked, cannot free it.
1941         if (be->ref_count != 0) {
1942                 nprintf(("BmpMan", "tried to unload %s that has a lock count of %d.. not unloading\n", be->filename, be->ref_count));
1943                 return;
1944         }
1945
1946 // until opengl mode gets a proper texture manager, this will have to do
1947 #ifdef PLAT_UNIX
1948         opengl1_free_texture_with_handle(handle);
1949 #endif
1950
1951         bm_free_data(n);
1952
1953         if ( bm_bitmaps[n].type == BM_TYPE_USER )       {
1954                 bm_bitmaps[n].info.user.data = NULL;
1955                 bm_bitmaps[n].info.user.bpp = 0;
1956         }
1957
1958
1959         bm_bitmaps[n].type = BM_TYPE_NONE;
1960
1961         // Fill in bogus structures!
1962
1963         // For debugging:
1964         strcpy( bm_bitmaps[n].filename, "IVE_BEEN_RELEASED!" );
1965         bm_bitmaps[n].signature = 0xDEADBEEF;                                                                   // a unique signature identifying the data
1966         bm_bitmaps[n].palette_checksum = 0xDEADBEEF;                                                    // checksum used to be sure bitmap is in current palette
1967
1968         // bookeeping
1969         #ifdef BMPMAN_NDEBUG
1970         bm_bitmaps[n].data_size = -1;                                                                   // How much data this bitmap uses
1971         #endif
1972         bm_bitmaps[n].ref_count = -1;                                                                   // Number of locks on bitmap.  Can't unload unless ref_count is 0.
1973
1974         // Bitmap info
1975         bm_bitmaps[n].bm.w = bm_bitmaps[n].bm.h = -1;
1976
1977         // Stuff needed for animations
1978         // Stuff needed for user bitmaps
1979         memset( &bm_bitmaps[n].info, 0, sizeof(bm_extra_info) );
1980
1981         bm_bitmaps[n].handle = -1;
1982 }
1983
1984
1985
1986
1987
1988
1989 // --------------------------------------------------------------------------------------
1990 // bm_unload()  - unloads the data, but not the bitmap info.
1991 //
1992 // parameters:          n               =>              index into bm_bitmaps ( index returned from bm_load() or bm_create() )
1993 //
1994 // returns:                     0               =>              unload failed
1995 //                                              1               =>              unload successful
1996 //
1997 int bm_unload( int handle )
1998 {
1999         bitmap_entry    *be;
2000         bitmap                  *bmp;
2001
2002         int n = handle % MAX_BITMAPS;
2003
2004         SDL_assert(n >= 0 && n < MAX_BITMAPS);
2005         be = &bm_bitmaps[n];
2006         bmp = &be->bm;
2007
2008         if ( be->type == BM_TYPE_NONE ) {
2009                 return 0;               // Already been released
2010         }
2011
2012         SDL_assert( be->handle == handle );             // INVALID BITMAP HANDLE!
2013
2014         // If it is locked, cannot free it.
2015         if (be->ref_count != 0) {
2016                 nprintf(("BmpMan", "tried to unload %s that has a lock count of %d.. not unloading\n", be->filename, be->ref_count));
2017                 return 0;
2018         }
2019
2020         nprintf(("BmpMan", "unloading %s.  %dx%dx%d\n", be->filename, bmp->w, bmp->h, bmp->bpp));
2021         bm_free_data(n);                // clears flags, bbp, data, etc
2022
2023         return 1;
2024 }
2025
2026
2027 // unload all used bitmaps
2028 void bm_unload_all()
2029 {
2030         int i;
2031
2032         for (i = 0; i < MAX_BITMAPS; i++)       {
2033                 if ( bm_bitmaps[i].type != BM_TYPE_NONE )       {
2034                         bm_unload(bm_bitmaps[i].handle);
2035                 }
2036         }
2037 }
2038
2039
2040 DCF(bmpman,"Shows/changes bitmap caching parameters and usage")
2041 {
2042         if ( Dc_command )       {
2043                 dc_get_arg(ARG_STRING);
2044                 if ( !strcmp( Dc_arg, "flush" ))        {
2045                         dc_printf( "Total RAM usage before flush: %d bytes\n", bm_texture_ram );
2046                         int i;
2047                         for (i = 0; i < MAX_BITMAPS; i++)       {
2048                                 if ( bm_bitmaps[i].type != BM_TYPE_NONE )       {
2049                                         bm_free_data(i);
2050                                 }
2051                         }
2052                         dc_printf( "Total RAM after flush: %d bytes\n", bm_texture_ram );
2053                 } else if ( !strcmp( Dc_arg, "ram" ))   {
2054                         dc_get_arg(ARG_INT);
2055                         Bm_max_ram = Dc_arg_int*1024*1024;
2056                 } else {
2057                         // print usage, not stats
2058                         Dc_help = 1;
2059                 }
2060         }
2061
2062         if ( Dc_help )  {
2063                 dc_printf( "Usage: BmpMan keyword\nWhere keyword can be in the following forms:\n" );
2064                 dc_printf( "BmpMan flush    Unloads all bitmaps.\n" );
2065                 dc_printf( "BmpMan ram x    Sets max mem usage to x MB. (Set to 0 to have no limit.)\n" );
2066                 dc_printf( "\nUse '? BmpMan' to see status of Bitmap manager.\n" );
2067                 Dc_status = 0;  // don't print status if help is printed.  Too messy.
2068         }
2069
2070         if ( Dc_status )        {
2071                 dc_printf( "Total RAM usage: %d bytes\n", bm_texture_ram );
2072
2073
2074                 if ( Bm_max_ram > 1024*1024 )
2075                         dc_printf( "Max RAM allowed: %.1f MB\n", i2fl(Bm_max_ram)/(1024.0f*1024.0f) );
2076                 else if ( Bm_max_ram > 1024 )
2077                         dc_printf( "Max RAM allowed: %.1f KB\n", i2fl(Bm_max_ram)/(1024.0f) );
2078                 else if ( Bm_max_ram > 0 )
2079                         dc_printf( "Max RAM allowed: %d bytes\n", Bm_max_ram );
2080                 else
2081                         dc_printf( "No RAM limit\n" );
2082
2083
2084         }
2085 }
2086
2087 // Marks a texture as being used for this level
2088 void bm_page_in_texture( int bitmapnum, int nframes )
2089 {
2090         int i;
2091         for (i=0; i<nframes;i++ )       {
2092                 int n = bitmapnum % MAX_BITMAPS;
2093
2094                 bm_bitmaps[n+i].preloaded = 1;
2095
2096                 bm_bitmaps[n+i].used_flags = BMP_TEX_OTHER;
2097         }
2098 }
2099
2100 // marks a texture as being a transparent textyre used for this level
2101 // Marks a texture as being used for this level
2102 // If num_frames is passed, assume this is an animation
2103 void bm_page_in_xparent_texture( int bitmapnum, int nframes)
2104 {
2105         int i;
2106         for (i=0; i<nframes;i++ )       {
2107                 int n = bitmapnum % MAX_BITMAPS;
2108
2109                 bm_bitmaps[n+i].preloaded = 3;
2110
2111                 // bm_bitmaps[n+i].used_flags = BMP_NO_PALETTE_MAP;
2112                 bm_bitmaps[n+i].used_flags = BMP_TEX_XPARENT;
2113         }
2114 }
2115
2116 // Marks an aabitmap as being used for this level
2117 void bm_page_in_aabitmap( int bitmapnum, int nframes )
2118 {
2119         int i;
2120
2121         for (i=0; i<nframes;i++ )       {
2122                 int n = bitmapnum % MAX_BITMAPS;
2123
2124                 bm_bitmaps[n+i].preloaded = 2;
2125
2126                 bm_bitmaps[n+i].used_flags = BMP_AABITMAP;
2127         }
2128 }
2129
2130
2131
2132 // Tell the bitmap manager to start keeping track of what bitmaps are used where.
2133 void bm_page_in_start()
2134 {
2135         int i;
2136
2137         Bm_paging = 1;
2138
2139         // Mark all as inited
2140         for (i = 0; i < MAX_BITMAPS; i++)       {
2141                 if ( bm_bitmaps[i].type != BM_TYPE_NONE )       {
2142                         bm_unload(bm_bitmaps[i].handle);
2143                 }
2144                 bm_bitmaps[i].preloaded = 0;
2145                 #ifdef BMPMAN_NDEBUG
2146                         bm_bitmaps[i].used_count = 0;
2147                 #endif
2148                 bm_bitmaps[i].used_flags = 0;
2149         }
2150
2151 }
2152
2153 void bm_page_in_stop()
2154 {
2155         int i;
2156         int ship_info_index;
2157
2158         nprintf(( "BmpInfo","BMPMAN: Loading all used bitmaps.\n" ));
2159
2160         // Load all the ones that are supposed to be loaded for this level.
2161         int n = 0;
2162
2163         #ifdef BMPMAN_NDEBUG
2164         Bm_ram_freed = 0;
2165         #endif
2166
2167         int d3d_preloading = 1;
2168
2169         gr_preload_init();
2170
2171         for (i = 0; i < MAX_BITMAPS; i++)       {
2172                 if ( bm_bitmaps[i].type != BM_TYPE_NONE )       {
2173                         if ( bm_bitmaps[i].preloaded )  {
2174 #ifdef BMPMAN_SPECIAL_NONDARK
2175                                 // if this is a texture, check to see if a ship uses it
2176                                 ship_info_index = ship_get_texture(bm_bitmaps[i].handle);
2177                                 // use the colors from this ship
2178                                 if((ship_info_index >= 0) && (Ship_info[ship_info_index].num_nondark_colors > 0)){
2179                                         // mprintf(("Using custom pixels for %s\n", Ship_info[ship_info_index].name));
2180                                         palman_set_nondarkening(Ship_info[ship_info_index].nondark_colors, Ship_info[ship_info_index].num_nondark_colors);
2181                                 }
2182                                 // use the colors from the default table
2183                                 else {
2184                                         // mprintf(("Using default pixels\n"));
2185                                         palman_set_nondarkening(Palman_non_darkening_default, Palman_num_nondarkening_default);
2186                                 }
2187 #endif
2188
2189                                 // if preloaded == 3, load it as an xparent texture
2190                                 if(bm_bitmaps[i].used_flags == BMP_AABITMAP){
2191                                         bm_lock( bm_bitmaps[i].handle, 8, bm_bitmaps[i].used_flags );
2192                                 } else {
2193                                         bm_lock( bm_bitmaps[i].handle, 16, bm_bitmaps[i].used_flags );
2194                                 }
2195                                 bm_unlock( bm_bitmaps[i].handle );
2196
2197                                 if ( d3d_preloading )   {
2198                                         if ( !gr_preload(bm_bitmaps[i].handle, (bm_bitmaps[i].preloaded==2) ) ) {
2199                                                 mprintf(( "Out of VRAM.  Done preloading.\n" ));
2200                                                 d3d_preloading = 0;
2201                                         }
2202                                 }
2203
2204                                 n++;
2205                                 #ifdef BMPMAN_NDEBUG
2206                                 if ( Bm_ram_freed )     {
2207                                         nprintf(( "BmpInfo","BMPMAN: Not enough cache memory to load all level bitmaps\n" ));
2208                                         break;
2209                                 }
2210                                 #endif
2211                         }
2212                 }
2213                 game_busy();
2214         }
2215         nprintf(( "BmpInfo","BMPMAN: Loaded %d bitmaps that are marked as used for this level.\n", n ));
2216
2217         int total_bitmaps = 0;
2218         for (i = 0; i < MAX_BITMAPS; i++)       {
2219                 if ( bm_bitmaps[i].type != BM_TYPE_NONE )       {
2220                         total_bitmaps++;
2221                 }
2222                 if ( bm_bitmaps[i].type == BM_TYPE_USER )       {
2223                         mprintf(( "User bitmap '%s'\n", bm_bitmaps[i].filename ));
2224                 }
2225         }
2226
2227         mprintf(( "Bmpman: %d/%d bitmap slots in use.\n", total_bitmaps, MAX_BITMAPS ));
2228         //mprintf(( "Bmpman: Usage went from %d KB to %d KB.\n", usage_before/1024, usage_after/1024 ));
2229
2230         Bm_paging = 0;
2231 }
2232
2233 int bm_get_cache_slot( int bitmap_id, int separate_ani_frames )
2234 {
2235         int n = bitmap_id % MAX_BITMAPS;
2236
2237         SDL_assert( bm_bitmaps[n].handle == bitmap_id );                // INVALID BITMAP HANDLE
2238
2239         bitmap_entry    *be = &bm_bitmaps[n];
2240
2241         if ( (!separate_ani_frames) && (be->type == BM_TYPE_ANI) )      {
2242                 return be->info.ani.first_frame;
2243         }
2244
2245         return n;
2246
2247 }
2248
2249 // convert a 24 bit value to a 16 bit value
2250 void bm_24_to_16(int bit_24, ushort *bit_16)
2251 {
2252         ubyte *pixel = (ubyte*)&bit_24;
2253         ubyte alpha = 1;
2254
2255         bm_set_components((ubyte*)bit_16, (ubyte*)&pixel[0], (ubyte*)&pixel[1], (ubyte*)&pixel[2], &alpha);
2256 }
2257
2258 void (*bm_set_components)(ubyte *pixel, ubyte *r, ubyte *g, ubyte *b, ubyte *a) = NULL;
2259
2260 void bm_set_components_argb_16_screen(ubyte *pixel, ubyte *rv, ubyte *gv, ubyte *bv, ubyte *av)
2261 {
2262         *((ushort*)pixel) |= (ushort)(( (int)*rv / Gr_current_red->scale ) << Gr_current_red->shift);
2263         *((ushort*)pixel) |= (ushort)(( (int)*gv / Gr_current_green->scale ) << Gr_current_green->shift);
2264         *((ushort*)pixel) |= (ushort)(( (int)*bv / Gr_current_blue->scale ) << Gr_current_blue->shift);
2265         if(*av == 0){
2266                 *((ushort*)pixel) = (ushort)Gr_current_green->mask;
2267         }
2268 }
2269
2270 void bm_set_components_argb_32_screen(ubyte *pixel, ubyte *rv, ubyte *gv, ubyte *bv, ubyte *av)
2271 {
2272         *((uint*)pixel) |= (uint)(( (int)*rv / Gr_current_red->scale ) << Gr_current_red->shift);
2273         *((uint*)pixel) |= (uint)(( (int)*gv / Gr_current_green->scale ) << Gr_current_green->shift);
2274         *((uint*)pixel) |= (uint)(( (int)*bv / Gr_current_blue->scale ) << Gr_current_blue->shift);
2275         if(*av == 0){
2276                 *((uint*)pixel) = (uint)Gr_current_green->mask;
2277         }
2278 }
2279
2280 void bm_set_components_argb_16_tex(ubyte *pixel, ubyte *rv, ubyte *gv, ubyte *bv, ubyte *av)
2281 {
2282         *((ushort*)pixel) |= (ushort)(( (int)*rv / Gr_current_red->scale ) << Gr_current_red->shift);
2283         *((ushort*)pixel) |= (ushort)(( (int)*gv / Gr_current_green->scale ) << Gr_current_green->shift);
2284         *((ushort*)pixel) |= (ushort)(( (int)*bv / Gr_current_blue->scale ) << Gr_current_blue->shift);
2285         *((ushort*)pixel) &= ~(Gr_current_alpha->mask);
2286         if(*av){
2287                 *((ushort*)pixel) |= (ushort)(Gr_current_alpha->mask);
2288         } else {
2289                 *((ushort*)pixel) = 0;
2290         }
2291 }
2292
2293 void bm_set_components_argb_32_tex(ubyte *pixel, ubyte *rv, ubyte *gv, ubyte *bv, ubyte *av)
2294 {
2295         *((ushort*)pixel) |= (ushort)(( (int)*rv / Gr_current_red->scale ) << Gr_current_red->shift);
2296         *((ushort*)pixel) |= (ushort)(( (int)*gv / Gr_current_green->scale ) << Gr_current_green->shift);
2297         *((ushort*)pixel) |= (ushort)(( (int)*bv / Gr_current_blue->scale ) << Gr_current_blue->shift);
2298         *((ushort*)pixel) &= ~(Gr_current_alpha->mask);
2299         if(*av){
2300                 *((ushort*)pixel) |= (ushort)(Gr_current_alpha->mask);
2301         } else {
2302                 *((ushort*)pixel) = 0;
2303         }
2304 }
2305
2306 // for selecting pixel formats
2307 void BM_SELECT_SCREEN_FORMAT()
2308 {
2309         Gr_current_red = &Gr_red;
2310         Gr_current_green = &Gr_green;
2311         Gr_current_blue = &Gr_blue;
2312         Gr_current_alpha = &Gr_alpha;
2313
2314         // setup pointers
2315         if ( gr_is_32bit() ) {
2316                 bm_set_components = bm_set_components_argb_32_screen;
2317         } else {
2318                 bm_set_components = bm_set_components_argb_16_screen;
2319         }
2320 }
2321
2322 void BM_SELECT_TEX_FORMAT()
2323 {
2324         Gr_current_red = &Gr_t_red;
2325         Gr_current_green = &Gr_t_green;
2326         Gr_current_blue = &Gr_t_blue;
2327         Gr_current_alpha = &Gr_t_alpha;
2328
2329         // setup pointers
2330         if ( gr_is_32bit() ) {
2331                 bm_set_components = bm_set_components_argb_32_tex;
2332         } else {
2333                 bm_set_components = bm_set_components_argb_16_tex;
2334         }
2335 }
2336
2337 void BM_SELECT_ALPHA_TEX_FORMAT()
2338 {
2339         Gr_current_red = &Gr_ta_red;
2340         Gr_current_green = &Gr_ta_green;
2341         Gr_current_blue = &Gr_ta_blue;
2342         Gr_current_alpha = &Gr_ta_alpha;
2343
2344         // setup pointers
2345         if ( gr_is_32bit() ) {
2346                 bm_set_components = bm_set_components_argb_32_tex;
2347         } else {
2348                 bm_set_components = bm_set_components_argb_16_tex;
2349         }
2350 }
2351
2352 // set the rgba components of a pixel, any of the parameters can be -1
2353 /*
2354 void bm_set_components(ubyte *pixel, ubyte *rv, ubyte *gv, ubyte *bv, ubyte *av)
2355 {
2356         int bit_32 = 0;
2357
2358         // pick a byte size - 32 bits only if 32 bit mode d3d and screen format
2359         if(D3D_32bit && (Gr_current_red == &Gr_red)){
2360                 bit_32 = 1;
2361         }
2362
2363         if(bit_32){
2364                 *((uint*)pixel) |= (uint)(( (int)*rv / Gr_current_red->scale ) << Gr_current_red->shift);
2365         } else {
2366                 *((ushort*)pixel) |= (ushort)(( (int)*rv / Gr_current_red->scale ) << Gr_current_red->shift);
2367         }
2368         if(bit_32){
2369                 *((uint*)pixel) |= (uint)(( (int)*gv / Gr_current_green->scale ) << Gr_current_green->shift);
2370         } else {
2371                 *((ushort*)pixel) |= (ushort)(( (int)*gv / Gr_current_green->scale ) << Gr_current_green->shift);
2372         }
2373         if(bit_32){
2374                 *((uint*)pixel) |= (uint)(( (int)*bv / Gr_current_blue->scale ) << Gr_current_blue->shift);
2375         } else {
2376                 *((ushort*)pixel) |= (ushort)(( (int)*bv / Gr_current_blue->scale ) << Gr_current_blue->shift);
2377         }
2378
2379         // NOTE - this is a semi-hack. For direct3d we don't use an alpha bit, so if *av == 0, we just set the whole pixel to be Gr_green.mask
2380         //        ergo, we need to do this _last_
2381         switch(Bm_pixel_format){
2382         // glide has an alpha channel so we have to unset ir or set it each time
2383         case BM_PIXEL_FORMAT_ARGB:
2384                 SDL_assert(!bit_32);
2385                 *((ushort*)pixel) &= ~(0x8000);
2386                 if(*av){
2387                         *((ushort*)pixel) |= 0x8000;
2388                 }
2389                 break;
2390
2391         // this d3d format has no alpha channel, so only make it "transparent", never make it "non-transparent"
2392         case BM_PIXEL_FORMAT_D3D:
2393                 SDL_assert(!bit_32);
2394                 if(*av == 0){
2395                         *((ushort*)pixel) = (ushort)Gr_current_green->mask;
2396                 }
2397                 break;
2398
2399         // nice 1555 texture format
2400         case BM_PIXEL_FORMAT_ARGB_D3D:
2401                 // if we're writing to normal texture format
2402                 if(Gr_current_red == &Gr_t_red){
2403                         SDL_assert(!bit_32);
2404                         *((ushort*)pixel) &= ~(Gr_current_alpha->mask);
2405                         if(*av){
2406                                 *((ushort*)pixel) |= (ushort)(Gr_current_alpha->mask);
2407                         } else {
2408                                 *((ushort*)pixel) = 0;
2409                         }
2410                 }
2411                 // otherwise if we're writing to screen format, still do it the green mask way
2412                 else {
2413                         if(*av == 0){
2414                                 if(bit_32){
2415                                         *((uint*)pixel) = (uint)Gr_current_green->mask;
2416                                 } else {
2417                                         *((ushort*)pixel) = (ushort)Gr_current_green->mask;
2418                                 }
2419                         }
2420                 }
2421                 break;
2422         }
2423 }
2424 */
2425
2426 // get the rgba components of a pixel, any of the parameters can be NULL
2427 void bm_get_components(ubyte *pixel, ubyte *r, ubyte *g, ubyte *b, ubyte *a)
2428 {
2429         int bit_32 = 0;
2430
2431         // pick a byte size - 32 bits only if 32 bit mode d3d and screen format
2432         if ( gr_is_32bit() && (Gr_current_red == &Gr_red) ) {
2433                 bit_32 = 1;
2434         }
2435
2436         if(r != NULL){
2437                 if(bit_32){
2438                         *r = ubyte(( (*((uint*)pixel) & Gr_current_red->mask)>>Gr_current_red->shift)*Gr_current_red->scale);
2439                 } else {
2440                         *r = ubyte(( ( ((ushort*)pixel)[0] & Gr_current_red->mask)>>Gr_current_red->shift)*Gr_current_red->scale);
2441                 }
2442         }
2443         if(g != NULL){
2444                 if(bit_32){
2445                         *g = ubyte(( (*((uint*)pixel) & Gr_current_green->mask) >>Gr_current_green->shift)*Gr_current_green->scale);
2446                 } else {
2447                         *g = ubyte(( ( ((ushort*)pixel)[0] & Gr_current_green->mask) >>Gr_current_green->shift)*Gr_current_green->scale);
2448                 }
2449         }
2450         if(b != NULL){
2451                 if(bit_32){
2452                         *b = ubyte(( (*((uint*)pixel) & Gr_current_blue->mask)>>Gr_current_blue->shift)*Gr_current_blue->scale);
2453                 } else {
2454                         *b = ubyte(( ( ((ushort*)pixel)[0] & Gr_current_blue->mask)>>Gr_current_blue->shift)*Gr_current_blue->scale);
2455                 }
2456         }
2457
2458         // get the alpha value
2459         if(a != NULL){
2460                 *a = 1;
2461
2462                 switch (Bm_pixel_format) {
2463                         // nice 1555 texture format mode
2464                         case BM_PIXEL_FORMAT_ARGB:
2465                                 // if we're writing to a normal texture, use nice alpha bits
2466                                 if(Gr_current_red == &Gr_t_red){
2467                                 SDL_assert(!bit_32);
2468
2469                                         if(!(*((ushort*)pixel) & Gr_current_alpha->mask)){
2470                                                 *a = 0;
2471                                         }
2472                                 }
2473                                 // otherwise do it as normal
2474                                 else {
2475                                         if(bit_32){
2476                                                 if(*((int*)pixel) == Gr_current_green->mask){
2477                                                         *a = 0;
2478                                                 }
2479                                         } else {
2480                                                 if(*((ushort*)pixel) == Gr_current_green->mask){
2481                                                         *a = 0;
2482                                                 }
2483                                         }
2484                                 }
2485                                 break;
2486
2487                         default:
2488                                 Int3();
2489                                 break;
2490                 }
2491         }
2492 }
2493
2494 // get filename
2495 void bm_get_filename(int bitmapnum, char *filename)
2496 {
2497         int n = bitmapnum % MAX_BITMAPS;
2498
2499         // return filename
2500         strcpy(filename, bm_bitmaps[n].filename);
2501 }
2502
2503 // given a bitmap and a section, return the size (w, h)
2504 void bm_get_section_size(int bitmapnum, int sx, int sy, int *w, int *h)
2505 {
2506         int bw, bh;
2507         bitmap_section_info *sections;
2508
2509         // bogus input?
2510         SDL_assert((w != NULL) && (h != NULL));
2511         if((w == NULL) || (h == NULL)){
2512                 return;
2513         }
2514
2515         // get bitmap info
2516         bm_get_info(bitmapnum, &bw, &bh, NULL, NULL, NULL, &sections);
2517
2518         // determine the width and height of this section
2519         if (gr_screen.use_sections) {
2520                 *w = sx < (sections->num_x - 1) ? MAX_BMAP_SECTION_SIZE : bw - sections->sx[sx];
2521                 *h = sy < (sections->num_y - 1) ? MAX_BMAP_SECTION_SIZE : bh - sections->sy[sy];
2522         } else {
2523                 *w = bw;
2524                 *h = bh;
2525         }
2526 }
2527