how do i load a sprite from a 24bit image file onto a 32bit surface? also if i set the bits per pixel to 32 when creating the full screen mode does that set all surfaces to 32bpp?

Normally, the only difference between a 32bpp and 24bpp surface is that the extra 8 bits is for the alpha ( transparency ) channel. You can set the alpha channel to maximum (255) unless you are planning to use alpha blending elsewhere. As for creating surfaces in 32BPP mode, if you don''t specify a pixel format ( presuming you''re using DirectX ) when creating the surface, the pixel format defaults to the pixel format of the primary ( display )surface. In this case it would be 32bpp. I hope this helps. If you do a display mode switch after surfaces are allocated, remember to reallocate/restore them.

himh

In your pic you have only r,g,b triples ranging from 0 to 256 thats the same for 16,24 and 32-bit modes.The color is than mixed according to the r,g,b-values.The difference between 24 and 32 bit mode is just a difference in resolution.In 32 bit the resulting color can be mixed more precise as in 16-bit-mode.
I am not sure what you mean with your second question:
If you only draw the bitmap onto a 2d-surface requesting a 32-bit-mode from windows is all you need to do.
If you texture-map a poly with the image you´ll have to request the 32-bit-mode and upload the texture with the correct attributes(Depends on the Api you´re using).
HTH,XBTC!

well here is what im trying to do. my program loads a background image and displays an image that is loaded from a 24bit file onto a 32bpp surface but when i run it the colors are all screwed up and i dont know why also how do flood fill the background buffer lpddsbackground with the black color instead of an image file



// INCLUDES ///////////////////////////////////////////////
#define WIN32_LEAN_AND_MEAN
#define INITGUID

#include (windows.h) // include important windows stuff
#include (windowsx.h)
#include (mmsystem.h)
#include (iostream.h) // include important C/C++ stuff
#include (conio.h)
#include (malloc.h)
#include (memory.h)
#include (io.h)
#include (ddraw.h) // directX includes

// defines for windows
#define WINDOW_CLASS_NAME "WINXCLASS" // class name

#define WWIDTH 640 // size of window
#define WHEIGHT 480
#define BPP 32
#define BITMAP_ID 0x4D42 // universal id for a bitmap
#define MAXCOLORS 256
// MACROS /////////////////////////////////////////////////

// these read the keyboard asynchronously
#define KEYDOWN(vk_code) ((GetAsyncKeyState(vk_code) & 0x8000) ? 1 : 0)
#define KEYUP(vk_code) ((GetAsyncKeyState(vk_code) & 0x8000) ? 0 : 1)
#define DDRAW_INIT_STRUCT(ddstruct) { memset(&ddstruct,0,sizeof(ddstruct)); ddstruct.dwSize=sizeof(ddstruct); }
// this builds a 16 bit color value in 5.6.5 format (green dominate mode)
#define RGB16BIT(r,g,b) ((b%32) + ((g%64) << 6) + ((r%32) << 11))
// this builds a 32 bit color value in A.8.8.8 format (8-bit alpha mode)
#define RGB32BIT(a,r,g,b) ((b) + ((g) << 8) + ((r) << 16) + ((a) << 24))


// TYPES //////////////////////////////////////////////////

typedef unsigned short USHORT;
typedef unsigned char UCHAR;

typedef struct BITMAP_FILE_TAG
{
BITMAPFILEHEADER bitmapfileheader;
BITMAPINFOHEADER bitmapinfoheader;
PALETTEENTRY palette[256];
UCHAR *buffer;
} BITMAPFILE, *BITMAPFILEPTR;

typedef struct BITMAPOBJTYP
{
int x,y;
LPDIRECTDRAWSURFACE4 image;
} BITMAPOBJ, *BITMAPOBJPTR;

////////// directdraw objects/////////////
LPDIRECTDRAW lpdd1 = NULL;
LPDIRECTDRAW4 lpdd4 = NULL;
LPDIRECTDRAWSURFACE4 lpddsprimary = NULL;
LPDIRECTDRAWSURFACE4 lpddsback = NULL;
DDSURFACEDESC2 ddsd;
DDSCAPS2 ddscaps;
BITMAPFILE bitmap;
BITMAPOBJ sprite;
LPDIRECTDRAWSURFACE4 lpddsbackground = NULL;// this will hold the background image


int gwidth = -1;
int gheight = -1;

// GLOBALS ////////////////////////////////////////////////

HWND main_window_handle = NULL; // save the window handle
HINSTANCE main_instance = NULL; // save the instance
char buffer[80]; // used to print text
int window_closed = 0; // tracks if window is closed

// PROTOTYPES /////////////////////////////////////////////

int Game_Init(void *parms=NULL, int num_parms = 0);
int Game_Shutdown(void *parms=NULL, int num_parms = 0);
int Game_Main(void *parms=NULL, int num_parms = 0);
int loadbitmap(BITMAPFILEPTR bitmap, char *filename);
int unloadbitmap(BITMAPFILEPTR bitmap);
int flipbitmap(UCHAR *image, int bytes_per_line, int height);
LPDIRECTDRAWSURFACE4 createsurface(int width,int height, int memflags);
int DDraw_Fill_Surface(LPDIRECTDRAWSURFACE4 lpdds,int color);
int Scan_Image_Bitmap(BITMAPFILEPTR bitmap, LPDIRECTDRAWSURFACE4 lpdds, int cx,int cy);

int DDraw_Draw_Surface(LPDIRECTDRAWSURFACE4 source, int x, int y,
int width, int height, LPDIRECTDRAWSURFACE4 dest,
int transparent);
// FUNCTIONS //////////////////////////////////////////////
int loadbitmap(BITMAPFILEPTR bitmap, char *filename)
{
// this function opens a bitmap file and loads the data into bitmap

int file_handle, // the file handle
index; // looping index

UCHAR *temp_buffer = NULL; // used to convert 24 bit images to 16 bit
OFSTRUCT file_data; // the file data information

// open the file if it exists
if ((file_handle = OpenFile(filename,&file_data,OF_READ))==-1)
return(0);

// now load the bitmap file header
_lread(file_handle, &bitmap->bitmapfileheader,sizeof(BITMAPFILEHEADER));

// test if this is a bitmap file
if (bitmap->bitmapfileheader.bfType!=BITMAP_ID)
{
// close the file
_lclose(file_handle);

// return error
return(0);
} // end if

// now we know this is a bitmap, so read in all the sections

// first the bitmap infoheader

// now load the bitmap file header
_lread(file_handle, &bitmap->bitmapinfoheader,sizeof(BITMAPINFOHEADER));

// now load the color palette if there is one
if (bitmap->bitmapinfoheader.biBitCount == 8)
{
_lread(file_handle, &bitmap->palette,MAXCOLORS*sizeof(PALETTEENTRY));

// now set all the flags in the palette correctly and fix the reversed
// BGR RGBQUAD data format
for (index=0; index < MAXCOLORS; index++)
{
// reverse the red and green fields
int temp_color = bitmap->palette[index].peRed;
bitmap->palette[index].peRed = bitmap->palette[index].peBlue;
bitmap->palette[index].peBlue = temp_color;

// always set the flags word to this
bitmap->palette[index].peFlags = PC_NOCOLLAPSE;
} // end for index

} // end if

// finally the image data itself
_lseek(file_handle,-(int)(bitmap->bitmapinfoheader.biSizeImage),SEEK_END);

// now read in the image, if the image is 8 or 16 bit then simply read it
// but if its 24 bit then read it into a temporary area and then convert
// it to a 16 bit image

if (bitmap->bitmapinfoheader.biBitCount==8 // bitmap->bitmapinfoheader.biBitCount==16 //
bitmap->bitmapinfoheader.biBitCount==24)
{
// delete the last image if there was one
if (bitmap->buffer)
free(bitmap->buffer);

// allocate the memory for the image
if (!(bitmap->buffer = (UCHAR *)malloc(bitmap->bitmapinfoheader.biSizeImage)))
{
// close the file
_lclose(file_handle);

// return error
return(0);
} // end if

// now read it in
_lread(file_handle,bitmap->buffer,bitmap->bitmapinfoheader.biSizeImage);

} // end if
else
{
// serious problem
return(0);

} // end else


// close the file
_lclose(file_handle);

// flip the bitmap
flipbitmap(bitmap->buffer,
bitmap->bitmapinfoheader.biWidth*(bitmap->bitmapinfoheader.biBitCount/8),
bitmap->bitmapinfoheader.biHeight);

// return success
return(1);

} // end Load_Bitmap_File


int unloadbitmap(BITMAPFILEPTR bitmap)
{
// this function releases all memory associated with "bitmap"
if (bitmap->buffer)
{
// release memory
free(bitmap->buffer);

// reset pointer
bitmap->buffer = NULL;

} // end if

// return success
return(1);

} // end Unload_Bitmap_File


int flipbitmap(UCHAR *image, int bytes_per_line, int height)
{
// this function is used to flip bottom-up .BMP images

UCHAR *buffer; // used to perform the image processing
int index; // looping index

// allocate the temporary buffer
if (!(buffer = (UCHAR *)malloc(bytes_per_line*height)))
return(0);

// copy image to work area
memcpy(buffer,image,bytes_per_line*height);

// flip vertically
for (index=0; index < height; index++)
memcpy(ℑ[((height-1) - index)*bytes_per_line],
&buffer[index*bytes_per_line], bytes_per_line);

// release the memory
free(buffer);

// return success
return(1);

} // end Flip_Bitmap


int DDraw_Fill_Surface(LPDIRECTDRAWSURFACE4 lpdds,int color)
{
DDBLTFX ddbltfx; // this contains the DDBLTFX structure

// clear out the structure and set the size field
DDRAW_INIT_STRUCT(ddbltfx);

// set the dwfillcolor field to the desired color
ddbltfx.dwFillColor = color;

// ready to blt to surface
lpdds->Blt(NULL, // ptr to dest rectangle
NULL, // ptr to source surface, NA
NULL, // ptr to source rectangle, NA
DDBLT_COLORFILL / DDBLT_WAIT, // fill and wait
&ddbltfx); // ptr to DDBLTFX structure

// return success
return(1);
} // end DDraw_Fill_Surface

///////////////////////////////////////////////////////////////

int DDraw_Draw_Surface(LPDIRECTDRAWSURFACE4 source, // source surface to draw
int x, int y, // position to draw at
int width, int height, // size of source surface
LPDIRECTDRAWSURFACE4 dest, // surface to draw the surface on
int transparent = 1) // transparency flag
{
// draw a bob at the x,y defined in the BOB
// on the destination surface defined in dest

RECT dest_rect, // the destination rectangle
source_rect; // the source rectangle

// fill in the destination rect
dest_rect.left = x;
dest_rect.top = y;
dest_rect.right = x+width-1;
dest_rect.bottom = y+height-1;

// fill in the source rect
source_rect.left = 0;
source_rect.top = 0;
source_rect.right = width-1;
source_rect.bottom = height-1;

// test transparency flag

if (transparent)
{
// enable color key blit
// blt to destination surface
if (FAILED(dest->Blt(&dest_rect, source,
&source_rect,(DDBLT_WAIT / DDBLT_KEYSRC),
NULL)))
return(0);

} // end if
else
{
// perform blit without color key
// blt to destination surface
if (FAILED(dest->Blt(&dest_rect, source,
&source_rect,(DDBLT_WAIT),
NULL)))
return(0);

} // end if

// return success
return(1);

} // end DDraw_Draw_Surface

///////////////////////////////////////////////////////////////

int Scan_Image_Bitmap(BITMAPFILEPTR bitmap, // bitmap file to scan image data from
LPDIRECTDRAWSURFACE4 lpdds, // surface to hold data
int cx, int cy) // cell to scan image from
{
// this function extracts a bitmap out of a bitmap file

UCHAR *source_ptr, // working pointers
*dest_ptr;

DDSURFACEDESC2 ddsd; // direct draw surface description

// get the addr to destination surface memory

// set size of the structure
ddsd.dwSize = sizeof(ddsd);

// lock the display surface
lpdds->Lock(NULL,
&ddsd,
DDLOCK_WAIT / DDLOCK_SURFACEMEMORYPTR,
NULL);

// compute position to start scanning bits from
cx = cx*(ddsd.dwWidth+1) + 1;
cy = cy*(ddsd.dwHeight+1) + 1;

gwidth = ddsd.dwWidth;
gheight = ddsd.dwHeight;

// extract bitmap data
source_ptr = bitmap->buffer + cy*bitmap->bitmapinfoheader.biWidth+cx;

// assign a pointer to the memory surface for manipulation
dest_ptr = (UCHAR *)ddsd.lpSurface;

// iterate thru each scanline and copy bitmap
for (int index_y=0; index_y < ddsd.dwHeight; index_y++)
{
// copy next line of data to destination
memcpy(dest_ptr, source_ptr, ddsd.dwWidth);

// advance pointers
dest_ptr += (ddsd.dwWidth);
source_ptr += bitmap->bitmapinfoheader.biWidth;
} // end for index_y

// unlock the surface
lpdds->Unlock(NULL);

// return success
return(1);

} // end Scan_Image_Bitmap


LPDIRECTDRAWSURFACE4 createsurface(int width,int height, int memflags)
{
DDSURFACEDESC2 ddsd;
LPDIRECTDRAWSURFACE4 lpdds;
DDRAW_INIT_STRUCT(ddsd);

ddsd.dwFlags = DDSD_CAPS / DDSD_WIDTH / DDSD_HEIGHT;

ddsd.dwWidth = width;
ddsd.dwHeight = height;
ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN / memflags;
if (FAILED(lpdd4->CreateSurface(&ddsd,&lpdds,NULL)))
return (NULL);
DDCOLORKEY colorkey;
colorkey.dwColorSpaceLowValue =0;
colorkey.dwColorSpaceHighValue =0;
lpdds->SetColorKey(DDCKEY_SRCBLT, &colorkey);

return (lpdds);
}

LRESULT CALLBACK WindowProc(HWND hwnd,
UINT msg,
WPARAM wparam,
LPARAM lparam)
{
// this is the main message handler of the system
PAINTSTRUCT ps; // used in WM_PAINT
HDC hdc; // handle to a device context
// what is the message
switch(msg)
{
case WM_CREATE:
{
// do initialization stuff here
return(0);
} break;

case WM_PAINT:
{
// start painting
hdc = BeginPaint(hwnd,&ps);

// end painting
EndPaint(hwnd,&ps);
return(0);
} break;

case WM_DESTROY:
{
// kill the application
PostQuitMessage(0);
return(0);
} break;

default:break;

} // end switch

// process any messages that we didn''t take care of
return (DefWindowProc(hwnd, msg, wparam, lparam));

} // end WinProc

// WINMAIN ////////////////////////////////////////////////

int WINAPI WinMain( HINSTANCE hinstance,
HINSTANCE hprevinstance,
LPSTR lpcmdline,
int ncmdshow)
{

WNDCLASSEX winclass; // this will hold the class we create
HWND hwnd; // generic window handle
MSG msg; // generic message
HDC hdc; // generic dc
PAINTSTRUCT ps; // generic paintstruct

// first fill in the window class stucture
winclass.cbSize = sizeof(WNDCLASSEX);
winclass.style = CS_DBLCLKS / CS_OWNDC /
CS_HREDRAW / CS_VREDRAW;
winclass.lpfnWndProc = WindowProc;
winclass.cbClsExtra = 0;
winclass.cbWndExtra = 0;
winclass.hInstance = hinstance;
winclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
winclass.hCursor = LoadCursor(NULL, IDC_ARROW);
winclass.hbrBackground = GetStockObject(BLACK_BRUSH);
winclass.lpszMenuName = NULL;
winclass.lpszClassName = WINDOW_CLASS_NAME;
winclass.hIconSm = LoadIcon(NULL, IDI_APPLICATION);

// register the window class
if (!RegisterClassEx(&winclass))
return(0);

// create the window
if (!(hwnd = CreateWindowEx(NULL,WINDOW_CLASS_NAME, // class
"WinX Game Console", // title
WS_POPUP / WS_VISIBLE,
0,0, // x,y
WWIDTH, // width
WHEIGHT, // height
NULL, // handle to parent
NULL, // handle to menu
hinstance,// instance
NULL))) // creation parms
return(0);

// save the window handle and instance in a global
main_window_handle = hwnd;
main_instance = hinstance;

// perform all game console specific initialization
Game_Init();

// enter main event loop
while(1)
{
if (PeekMessage(&msg,NULL,0,0,PM_REMOVE))
{
// test if this is a quit
if (msg.message == WM_QUIT)
break;

// translate any accelerator keys
TranslateMessage(&msg);

// send the message to the window proc
DispatchMessage(&msg);
} // end if

// main game processing goes here
Game_Main();

} // end while

// shutdown game and release all resources
Game_Shutdown();

// return to Windows like this
return(msg.wParam);

} // end WinMain

// WINX GAME PROGRAMMING CONSOLE FUNCTIONS ////////////////
int Game_Init(void *parms, int num_parms)
{


// first create base IDirectDraw interface
if (FAILED(DirectDrawCreate(NULL, &lpdd1, NULL)))
return(0);

// now query for IDirectDraw4
if (FAILED(lpdd1->QueryInterface(IID_IDirectDraw4,
(LPVOID *)&lpdd4)))
return(0);

// set cooperation to full screen
if (FAILED(lpdd4->SetCooperativeLevel(main_window_handle,
DDSCL_FULLSCREEN / DDSCL_ALLOWMODEX /
DDSCL_EXCLUSIVE / DDSCL_ALLOWREBOOT)))
return(0);

// set display mode
if (FAILED(lpdd4->SetDisplayMode(WWIDTH,WHEIGHT,BPP,0,0)))
return(0);

DDRAW_INIT_STRUCT(ddsd);

ddsd.dwFlags = DDSD_CAPS / DDSD_BACKBUFFERCOUNT;
ddsd.dwBackBufferCount=1;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE / DDSCAPS_COMPLEX / DDSCAPS_FLIP;
//create primary surface
if (FAILED(lpdd4->CreateSurface(&ddsd, &lpddsprimary, NULL)))
return 0;
ddsd.ddsCaps.dwCaps = DDSCAPS_BACKBUFFER;

if (FAILED(lpddsprimary->GetAttachedSurface(&ddsd.ddsCaps, &lpddsback)))
return 0;

if (!loadbitmap(&bitmap,"bground.bmp"))
return(0);

DDraw_Fill_Surface(lpddsprimary,0);
DDraw_Fill_Surface(lpddsback,0);

lpddsbackground = createsurface(640,480,DDSCAPS_VIDEOMEMORY);

//lock the primary surface
lpddsbackground->Lock(NULL,&ddsd, DDLOCK_SURFACEMEMORYPTR / DDLOCK_WAIT,NULL);

UCHAR *image_buffer = (UCHAR *)ddsd.lpSurface;

if (ddsd.lPitch == WWIDTH)
{
memcpy((void *)image_buffer,(void *)bitmap.buffer, WWIDTH*WHEIGHT);
}
else
{
UCHAR *destptr = image_buffer;
UCHAR *srcptr = bitmap.buffer;
for (int y=0; y {
memcpy((void *)destptr, (void *)srcptr, WWIDTH);
destptr += ddsd.lPitch;
srcptr += WWIDTH;
}
}

if (FAILED(lpddsbackground->Unlock(NULL)))
return(0);
unloadbitmap(&bitmap);

sprite.x = 200;
sprite.y = 100;

if (!loadbitmap(&bitmap,"ground.bmp"))
return 0;

sprite.image = createsurface(64,64,DDSCAPS_VIDEOMEMORY);
Scan_Image_Bitmap(&bitmap,sprite.image,1,0);

// unload the bitmap file, we no longer need it
unloadbitmap(&bitmap);

// return success or failure or your own return code here

return 1;
} // end Game_Init

///////////////////////////////////////////////////////////

int Game_Main(void *parms, int num_parms)
{

// make sure this isn''t executed again
if (window_closed)
return(0);

// for now test if user is hitting ESC and send WM_CLOSE
if (KEYDOWN(VK_ESCAPE))
{
PostMessage(main_window_handle,WM_CLOSE,0,0);
window_closed = 1;
} // end if
DDraw_Draw_Surface(lpddsbackground,0,0, WWIDTH,WHEIGHT, lpddsback,0);


DDraw_Draw_Surface(sprite.image,sprite.x,sprite.y,64,64,lpddsback);

while (FAILED(lpddsprimary->Flip(NULL, DDFLIP_WAIT)));


return 1;
} // end Game_Main

///////////////////////////////////////////////////////////


int Game_Shutdown(void *parms, int num_parms)
{

if (lpddsbackground)
{
lpddsbackground->Release();
lpddsbackground = NULL;
}



// now the primary surface
if (lpddsprimary)
{
lpddsprimary->Release();
lpddsprimary = NULL;
} // end if
// release the directdraw object
if (lpdd4!=NULL)
lpdd4->Release();
return 1;
} // end Game_Shutdown

Sorry if you wouldn´t use Direct-Draw I could help you....

well i tried those changes but the colors are still screwed up
i also added code in the loadbitmap function to convert the file to 32bpp but im not sure if that is correct
this is what it looks like
also does this function seem to long load in a bitmap file?

int loadbitmap(BITMAPFILEPTR bitmap, char *filename)
{
// this function opens a bitmap file and loads the data into bitmap

int file_handle, // the file handle
index; // looping index

UCHAR *temp_buffer = NULL; // used to convert 24 bit images to 16 bit
OFSTRUCT file_data; // the file data information

// open the file if it exists
if ((file_handle = OpenFile(filename,&file_data,OF_READ))==-1)
return(0);

// now load the bitmap file header
_lread(file_handle, &bitmap->bitmapfileheader,sizeof(BITMAPFILEHEADER));

// test if this is a bitmap file
if (bitmap->bitmapfileheader.bfType!=BITMAP_ID)
{
// close the file
_lclose(file_handle);

// return error
return(0);
} // end if

// now we know this is a bitmap, so read in all the sections

// first the bitmap infoheader

// now load the bitmap file header
_lread(file_handle, &bitmap->bitmapinfoheader,sizeof(BITMAPINFOHEADER));

// now load the color palette if there is one
if (bitmap->bitmapinfoheader.biBitCount == 8)
{
_lread(file_handle, &bitmap->palette,MAXCOLORS*sizeof(PALETTEENTRY));

// now set all the flags in the palette correctly and fix the reversed
// BGR RGBQUAD data format
for (index=0; index < MAXCOLORS; index++)
{
// reverse the red and green fields
int temp_color = bitmap->palette[index].peRed;
bitmap->palette[index].peRed = bitmap->palette[index].peBlue;
bitmap->palette[index].peBlue = temp_color;

// always set the flags word to this
bitmap->palette[index].peFlags = PC_NOCOLLAPSE;
} // end for index

} // end if

// finally the image data itself
_lseek(file_handle,-(int)(bitmap->bitmapinfoheader.biSizeImage),SEEK_END);

// now read in the image, if the image is 8 or 16 bit then simply read it
// but if its 24 bit then read it into a temporary area and then convert
// it to a 16 bit image

if (bitmap->bitmapinfoheader.biBitCount==8 // bitmap->bitmapinfoheader.biBitCount==16)
{
// delete the last image if there was one
if (bitmap->buffer)
free(bitmap->buffer);

// allocate the memory for the image
if (!(bitmap->buffer = (UCHAR *)malloc(bitmap->bitmapinfoheader.biSizeImage)))
{
// close the file
_lclose(file_handle);

// return error
return(0);
} // end if

// now read it in
_lread(file_handle,bitmap->buffer,bitmap->bitmapinfoheader.biSizeImage);

} // end if
else
{
if (!(temp_buffer = (UCHAR *)malloc(bitmap->bitmapinfoheader.biSizeImage)))
{
_lclose(file_handle);
// serious problem
return(0);

} // end else


// allocate final 16 bit storage buffer
if (!(bitmap->buffer=(UCHAR *)malloc(2*bitmap->bitmapinfoheader.biWidth*bitmap->bitmapinfoheader.biHeight)))
{
// close the file
_lclose(file_handle);

// release working buffer
free(temp_buffer);

// return error
return(0);
} // end if

// now read it in
_lread(file_handle,temp_buffer,bitmap->bitmapinfoheader.biSizeImage);

// now convert each 24 bit RGB value into a 16 bit value
for (index=0; indexbitmapinfoheader.biWidth*bitmap->bitmapinfoheader.biHeight; index++)
{
// extract RGB components (in BGR order), note the scaling
UCHAR blue = (temp_buffer[index*3 + 0]),
green = (temp_buffer[index*3 + 1]),
red = (temp_buffer[index*3 + 2]);

// build up 16 bit color word
DWORD color = RGB32BIT(0,red,green,blue);

// write color to buffer
((USHORT *)bitmap->buffer)[index] = color;

} // end for index

// finally write out the correct number of bits
bitmap->bitmapinfoheader.biBitCount=16;

} // end if
// close the file
_lclose(file_handle);

// flip the bitmap
flipbitmap(bitmap->buffer,
bitmap->bitmapinfoheader.biWidth*(bitmap->bitmapinfoheader.biBitCount/8),
bitmap->bitmapinfoheader.biHeight);

// return success
return(1);

} // end Load_Bitmap_File