int Game_Init(void *parms = NULL, int num_parms = 0)
{
// this is called once after the initial window is created and
// before the main event loop is entered, do all your initialization
// here
// create IDirectDraw interface 7.0 object and test for error
if (FAILED(DirectDrawCreateEx(NULL, (void **)&lpdd, IID_IDirectDraw7, NULL)))
return(0);
// set cooperation to full screen
if (FAILED(lpdd->SetCooperativeLevel(main_window_handle,
DDSCL_FULLSCREEN | DDSCL_ALLOWMODEX |
DDSCL_EXCLUSIVE | DDSCL_ALLOWREBOOT)))
{
// error
return(0);
} // end if
// set display mode to 640x480x8
if (FAILED(lpdd->SetDisplayMode(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP,0,0)))
{
// error
return(0);
} // end if
// return success or failure or your own return code here
return(1);
} // end Game_Init
int InitDirectDraw()
{
DDSURFACEDESC2 ddsd;
DDSCAPS2 ddscaps;
HRESULT hRet;
// Create the main DirectDraw object.
hRet = DirectDrawCreateEx(NULL, (VOID**)&g_pDD, IID_IDirectDraw7, NULL);
if( hRet != DD_OK )
return -1;
// Get exclusive mode.
hRet = g_pDD->SetCooperativeLevel(g_hMainWnd, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
if( hRet != DD_OK )
return -2;
// Set the video mode to 640x480x16.
hRet = g_pDD->SetDisplayMode(640, 480, 16, 0, 0);
if( hRet != DD_OK )
return -3;
// Prepare to create the primary surface by initializing
// the fields of a DDSURFACEDESC2 structure.
ZeroMemory(&ddsd, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP |
DDSCAPS_COMPLEX;
ddsd.dwBackBufferCount = 1;
// Create the primary surface.
hRet = g_pDD->CreateSurface(&ddsd, &g_pDDSFront, NULL);
if( hRet != DD_OK )
return -1;
// Get a pointer to the back buffer.
ZeroMemory(&ddscaps, sizeof(ddscaps));
ddscaps.dwCaps = DDSCAPS_BACKBUFFER;
hRet = g_pDDSFront->GetAttachedSurface(&ddscaps, &g_pDDSBack);
if( hRet != DD_OK )
return -1;
return 0;
}
int Game_Init(void *parms = NULL, int num_parms = 0)
{
// this is called once after the initial window is created and
// before the main event loop is entered, do all your initialization
// here
// create IDirectDraw interface 7.0 object and test for error
if (FAILED(DirectDrawCreateEx(NULL, (void **)&lpdd, IID_IDirectDraw7, NULL)))
return(0);
// set cooperation to full screen
if (FAILED(lpdd->SetCooperativeLevel(main_window_handle,
DDSCL_FULLSCREEN | DDSCL_ALLOWMODEX |
DDSCL_EXCLUSIVE | DDSCL_ALLOWREBOOT)))
return(0);
// set display mode to 640x480x8
if (FAILED(lpdd->SetDisplayMode(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP,0,0)))
return(0);
// clear ddsd and set size
DDRAW_INIT_STRUCT(ddsd);
// enable valid fields
ddsd.dwFlags = DDSD_CAPS;
// request primary surface
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
// create the primary surface
if (FAILED(lpdd->CreateSurface(&ddsd, &lpddsprimary, NULL)))
return(0);
// load the 24-bit image
if (!Load_Bitmap_File(&bitmap,"bitmap24.bmp"))
return(0);
// return success or failure or your own return code here
return(1);
} // end Game_Init
int DDInit(void)
{
HRESULT hRet;
hWnd = Form1->Handle;
DDEnd();
hRet = DirectDrawCreateEx(NULL, (VOID**)&m_pDD, IID_IDirectDraw7, NULL);
if(DDError(hRet != DD_OK,"DDCreateEX")) return(false);
if (Form1->FullScreen)
{
hRet = m_pDD->SetCooperativeLevel(hWnd, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
hRet = m_pDD->SetDisplayMode(FScreen.Width, FScreen.Height, FScreen.Bpp,NULL,NULL);
}
else hRet = m_pDD->SetCooperativeLevel(hWnd, DDSCL_NORMAL);
if(DDError(hRet != DD_OK,"DDSetCoop")) return(false);
HRESULT hr;
DDSURFACEDESC2 ddsd;
ZeroMemory( &ddsd, sizeof( ddsd ) );
ddsd.dwSize = sizeof( ddsd );
ddsd.dwFlags = DDSD_CAPS;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
if(DDError(hr = m_pDD->CreateSurface(&ddsd, &m_pddsFrontBuffer, NULL)
,"CreateFrontSurface")) return(false);
// Create the backbuffer surface
ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_3DDEVICE;
ddsd.dwWidth = 1024;
ddsd.dwHeight = 768;
hr = m_pDD->CreateSurface(&ddsd, &m_pddsFrame, NULL);
if (hr)
{
ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_3DDEVICE;
ddsd.dwWidth = 460;
ddsd.dwHeight = 400;
hr = m_pDD->CreateSurface(&ddsd, &m_pddsFrame, NULL);
if(DDError(hr,"CreateBackSurface")) return(false);
tv.DisableAdvanced=1;
}
if (!Form1->FullScreen)
{
if(DDError(hr = m_pDD->CreateClipper(0, &pcClipper, NULL)
,"CreateClipper")) return(false);
if(DDError(hr = pcClipper->SetHWnd(0, hWnd)
,"SetClipperHwnd"))
{
pcClipper->Release();
return(false);
}
if(DDError(hr = m_pddsFrontBuffer->SetClipper(pcClipper)
,"SetClipperSurface"))
{
pcClipper->Release();
return(false);
}
}
return(true);
}
//-----------------------------------------------------------------------------
// Name: InitDD()
// Desc: Initializes Driect draw and anything that needs to be inited
//-----------------------------------------------------------------------------
int InitDD()
{// this function is where i do all the initialization
// for the game
// create dd object and test for error
ddReturnVal = DirectDrawCreateEx(NULL, (void **)&lpddObj, IID_IDirectDraw7, NULL);
if(DDFailedCheck(ddReturnVal, "DirectDrawCreateEx() failed", cpErrorBuf ))
{ MessageBox(main_window_handle, cpErrorBuf, "Init()", MB_ICONEXCLAMATION); return (0); }
/*
//set cooperation level to windowed mode normal
ddReturnVal = lpddObj->SetCooperativeLevel(main_window_handle, DDSCL_NORMAL);
if (DDFailedCheck(ddReturnVal, "SetCooperativeLevel() failed", cpErrorBuf ))
{ MessageBox(main_window_handle, cpErrorBuf, "Init()", MB_ICONEXCLAMATION); return(0); }
*/
//set cooperation level to full screen
ddReturnVal = lpddObj->SetCooperativeLevel(main_window_handle, DDSCL_ALLOWMODEX | DDSCL_FULLSCREEN |
DDSCL_EXCLUSIVE | DDSCL_ALLOWREBOOT);
if (DDFailedCheck(ddReturnVal, "SetCooperativeLevel() failed", cpErrorBuf ))
{ MessageBox(main_window_handle, cpErrorBuf, "Init()", MB_ICONEXCLAMATION); return(0); }
// set the display mode
ddReturnVal = lpddObj->SetDisplayMode(WINDOW_WIDTH,WINDOW_HEIGHT,BPP,0,0);
if (DDFailedCheck(ddReturnVal, "SetDisplayMode() failed", cpErrorBuf ))
{ MessageBox(main_window_handle, cpErrorBuf, "Init()", MB_ICONEXCLAMATION); return(0); }
// Create the primary surface first set the fields
memset(&ddsd,0,sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT; //set the flags to validate both capabilites field adn the backbuffer count field
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP | DDSCAPS_COMPLEX; //tell dd that u have a complex flippable surface
ddsd.dwBackBufferCount = 1; //set the back buffer count
//Createt the primary surface
ddReturnVal = lpddObj->CreateSurface(&ddsd,&lpddsPrimary,NULL);
if (DDFailedCheck(ddReturnVal, "SetCooperativeLevel() failed", cpErrorBuf ))
{ MessageBox(main_window_handle, cpErrorBuf, "Init()", MB_ICONEXCLAMATION); return(0); }
//Query for the backbuffer, use the ddscaps to indicate what you're requesting
ddscaps.dwCaps = DDSCAPS_BACKBUFFER;
//get the surface
ddReturnVal = lpddsPrimary->GetAttachedSurface(&ddscaps, &lpddsSecondary);
if (DDFailedCheck(ddReturnVal, "GetAttachedSurface() failed", cpErrorBuf ))
{ MessageBox(main_window_handle, cpErrorBuf, "Init()", MB_ICONEXCLAMATION); return(0); }
//Attach a clipper
RECT cliplist[1];
cliplist[0].top = 0; cliplist[0].left = 0;
cliplist[0].bottom = GetSystemMetrics(SM_CYSCREEN);
cliplist[0].right = GetSystemMetrics(SM_CXSCREEN);
AttachClipper(lpddsSecondary,1,cliplist);
AttachClipper(lpddsPrimary,main_window_handle);
//attack a color key
// set color key to TransparentColor
DDCOLORKEY color_key; // used to set color key
if(BPP == 16)
{
color_key.dwColorSpaceLowValue = BIULDCOLOR(TransColor.r,TransColor.g,TransColor.b);
color_key.dwColorSpaceHighValue = BIULDCOLOR(TransColor.r,TransColor.g,TransColor.b);
}
else
if(BPP == 32)
{
color_key.dwColorSpaceLowValue = _ARGB24BIT(0,TransColor.r,TransColor.g,TransColor.b);
color_key.dwColorSpaceHighValue = _ARGB24BIT(0,TransColor.r,TransColor.g,TransColor.b);
}
// now set the color key for source blitting
ddReturnVal = lpddsSecondary->SetColorKey(DDCKEY_SRCBLT, &color_key);
if (DDFailedCheck(ddReturnVal, "SetColorKey() failed", cpErrorBuf ))
{ MessageBox(main_window_handle, cpErrorBuf, "Init()", MB_ICONEXCLAMATION); return(0); }
//Fill in the wndRect struct
wndRect.top = 0;
wndRect.left = 0;
wndRect.bottom = WINDOW_HEIGHT;
wndRect.right = WINDOW_WIDTH;
return(1);
}
int Game_Init(void *parms = NULL, int num_parms = 0)
{
// this is called once after the initial window is created and
// before the main event loop is entered, do all your initialization
// here
// seed random number generator
srand(GetTickCount());
// create IDirectDraw interface 7.0 object and test for error
if (FAILED(DirectDrawCreateEx(NULL, (void **)&lpdd, IID_IDirectDraw7, NULL)))
return(0);
// set cooperation to full screen
if (FAILED(lpdd->SetCooperativeLevel(main_window_handle,
DDSCL_FULLSCREEN | DDSCL_ALLOWMODEX |
DDSCL_EXCLUSIVE | DDSCL_ALLOWREBOOT)))
return(0);
// set display mode to 640x480x8
if (FAILED(lpdd->SetDisplayMode(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP,0,0)))
return(0);
// clear ddsd and set size
DDRAW_INIT_STRUCT(ddsd);
// enable valid fields
ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
// set the backbuffer count field to 1, use 2 for triple buffering
ddsd.dwBackBufferCount = 1;
// request a complex, flippable
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_COMPLEX | DDSCAPS_FLIP;
// create the primary surface
if (FAILED(lpdd->CreateSurface(&ddsd, &lpddsprimary, NULL)))
return(0);
// now query for attached surface from the primary surface
// this line is needed by the call
ddsd.ddsCaps.dwCaps = DDSCAPS_BACKBUFFER;
// get the attached back buffer surface
if (FAILED(lpddsprimary->GetAttachedSurface(&ddsd.ddsCaps, &lpddsback)))
return(0);
// build up the palette data array
for (int color=1; color < 255; color++)
{
// fill with random RGB values
palette[color].peRed = rand()%256;
palette[color].peGreen = rand()%256;
palette[color].peBlue = rand()%256;
// set flags field to PC_NOCOLLAPSE
palette[color].peFlags = PC_NOCOLLAPSE;
} // end for color
// now fill in entry 0 and 255 with black and white
palette[0].peRed = 0;
palette[0].peGreen = 0;
palette[0].peBlue = 0;
palette[0].peFlags = PC_NOCOLLAPSE;
palette[255].peRed = 255;
palette[255].peGreen = 255;
palette[255].peBlue = 255;
palette[255].peFlags = PC_NOCOLLAPSE;
// create the palette object
if (FAILED(lpdd->CreatePalette(DDPCAPS_8BIT | DDPCAPS_ALLOW256 |
DDPCAPS_INITIALIZE,
palette,&lpddpal, NULL)))
return(0);
// finally attach the palette to the primary surface
if (FAILED(lpddsprimary->SetPalette(lpddpal)))
return(0);
// clear the surfaces out
DDraw_Fill_Surface(lpddsprimary, 0 );
DDraw_Fill_Surface(lpddsback, 0 );
// define points of asteroid
VERTEX2DF asteroid_vertices[8] = {33,-3, 9,-18, -12,-9, -21,-12, -9,6, -15,15, -3,27, 21,21};
// loop and initialize all asteroids
for (int curr_index = 0; curr_index < NUM_ASTEROIDS; curr_index++)
{
// initialize the asteroid
asteroids[curr_index].state = 1; // turn it on
asteroids[curr_index].num_verts = 8;
asteroids[curr_index].x0 = rand()%SCREEN_WIDTH; // position it
asteroids[curr_index].y0 = rand()%SCREEN_HEIGHT;
asteroids[curr_index].xv = -8 + rand()%17;
asteroids[curr_index].yv = -8 + rand()%17;
asteroids[curr_index].color = rand()%256;
asteroids[curr_index].vlist = new VERTEX2DF [asteroids[curr_index].num_verts];
for (int index = 0; index < asteroids[curr_index].num_verts; index++)
asteroids[curr_index].vlist[index] = asteroid_vertices[index];
} // end for curr_index
// create sin/cos lookup table
// generate the tables
for (int ang = 0; ang < 360; ang++)
{
// convert ang to radians
float theta = (float)ang*PI/(float)180;
// insert next entry into table
cos_look[ang] = cos(theta);
sin_look[ang] = sin(theta);
} // end for ang
// return success or failure or your own return code here
return(1);
} // end Game_Init
int Game_Init(void *parms = NULL, int num_parms = 0)
{
// this is called once after the initial window is created and
// before the main event loop is entered, do all your initialization
// here
// create IDirectDraw interface 7.0 object and test for error
if (FAILED(DirectDrawCreateEx(NULL, (void **)&lpdd, IID_IDirectDraw7, NULL)))
return(0);
// set cooperation to full screen
if (FAILED(lpdd->SetCooperativeLevel(main_window_handle,
DDSCL_FULLSCREEN | DDSCL_ALLOWMODEX |
DDSCL_EXCLUSIVE | DDSCL_ALLOWREBOOT)))
return(0);
// set display mode to 640x480x8
if (FAILED(lpdd->SetDisplayMode(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP,0,0)))
return(0);
// clear ddsd and set size
DDRAW_INIT_STRUCT(ddsd);
// enable valid fields
ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
// set the backbuffer count field to 1, use 2 for triple buffering
ddsd.dwBackBufferCount = 1;
// request a complex, flippable
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_COMPLEX | DDSCAPS_FLIP;
// create the primary surface
if (FAILED(lpdd->CreateSurface(&ddsd, &lpddsprimary, NULL)))
return(0);
// now query for attached surface from the primary surface
// this line is needed by the call
ddsd.ddsCaps.dwCaps = DDSCAPS_BACKBUFFER;
// get the attached back buffer surface
if (FAILED(lpddsprimary->GetAttachedSurface(&ddsd.ddsCaps, &lpddsback)))
return(0);
// build up the palette data array
for (int color=1; color < 255; color++)
{
// fill with random RGB values
palette[color].peRed = 0;
palette[color].peGreen = 0;
palette[color].peBlue = color;
// set flags field to PC_NOCOLLAPSE
palette[color].peFlags = PC_NOCOLLAPSE;
} // end for color
// now fill in entry 0 and 255 with black and white
palette[0].peRed = 0;
palette[0].peGreen = 0;
palette[0].peBlue = 0;
palette[0].peFlags = PC_NOCOLLAPSE;
palette[255].peRed = 255;
palette[255].peGreen = 255;
palette[255].peBlue = 255;
palette[255].peFlags = PC_NOCOLLAPSE;
// create the palette object
if (FAILED(lpdd->CreatePalette(DDPCAPS_8BIT | DDPCAPS_ALLOW256 |
DDPCAPS_INITIALIZE,
palette,&lpddpal, NULL)))
{
return(0);
}
// finally attach the palette to the primary surface
if (FAILED(lpddsprimary->SetPalette(lpddpal)))
return(0);
// return success or failure or your own return code here
return(1);
} // end Game_Init
int Game_Init(void *parms = NULL, int num_parms = 0)
{
// this is called once after the initial window is created and
// before the main event loop is entered, do all your initialization
// here
// create IDirectDraw interface 7.0 object and test for error
if (FAILED(DirectDrawCreateEx(NULL, (void **)&lpdd, IID_IDirectDraw7, NULL)))
return(0);
// set cooperation to full screen
if (FAILED(lpdd->SetCooperativeLevel(main_window_handle,
DDSCL_FULLSCREEN | DDSCL_ALLOWMODEX |
DDSCL_EXCLUSIVE | DDSCL_ALLOWREBOOT)))
return(0);
// set display mode to 640x480x8
if (FAILED(lpdd->SetDisplayMode(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP,0,0)))
return(0);
// we need a complex surface system with a primary and backbuffer
// clear ddsd and set size
DDRAW_INIT_STRUCT(ddsd);
// enable valid fields
ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
// set the backbuffer count field to 1, use 2 for triple buffering
ddsd.dwBackBufferCount = 1;
// request a complex, flippable
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_COMPLEX | DDSCAPS_FLIP;
// create the primary surface
if (FAILED(lpdd->CreateSurface(&ddsd, &lpddsprimary, NULL)))
return(0);
// now query for attached surface from the primary surface
// this line is needed by the call
ddsd.ddsCaps.dwCaps = DDSCAPS_BACKBUFFER;
// get the attached back buffer surface
if (FAILED(lpddsprimary->GetAttachedSurface(&ddsd.ddsCaps, &lpddsback)))
return(0);
// build up the palette data array
for (int color=1; color < 255; color++)
{
// fill with random RGB values
palette[color].peRed = rand()%256;
palette[color].peGreen = rand()%256;
palette[color].peBlue = rand()%256;
// set flags field to PC_NOCOLLAPSE
palette[color].peFlags = PC_NOCOLLAPSE;
} // end for color
// now fill in entry 0 and 255 with black and white
palette[0].peRed = 0;
palette[0].peGreen = 0;
palette[0].peBlue = 0;
palette[0].peFlags = PC_NOCOLLAPSE;
palette[255].peRed = 255;
palette[255].peGreen = 255;
palette[255].peBlue = 255;
palette[255].peFlags = PC_NOCOLLAPSE;
// create the palette object
if (FAILED(lpdd->CreatePalette(DDPCAPS_8BIT | DDPCAPS_ALLOW256 |
DDPCAPS_INITIALIZE,
palette,&lpddpal, NULL)))
return(0);
// finally attach the palette to the primary surface
if (FAILED(lpddsprimary->SetPalette(lpddpal)))
return(0);
// set clipper up on back buffer since that's where well clip
RECT screen_rect= {0,0,SCREEN_WIDTH-1,SCREEN_HEIGHT-1};
lpddclipper = DDraw_Attach_Clipper(lpddsback,1,&screen_rect);
// load the 8-bit image
if (!Load_Bitmap_File(&bitmap,"alley8.bmp"))
return(0);
// load it's palette into directdraw
if (FAILED(lpddpal->SetEntries(0,0,MAX_COLORS_PALETTE,bitmap.palette)))
return(0);
// clean the surfaces
DDraw_Fill_Surface(lpddsprimary,0);
DDraw_Fill_Surface(lpddsback,0);
// create the buffer to hold the background
lpddsbackground = DDraw_Create_Surface(640,480,0,-1);
// copy the background bitmap image to the background surface
// lock the surface
lpddsbackground->Lock(NULL,&ddsd, DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT,NULL);
// get video pointer to primary surfce
UCHAR *image_buffer = (UCHAR *)ddsd.lpSurface;
// test if memory is linear
if (ddsd.lPitch == SCREEN_WIDTH)
{
// copy memory from double buffer to primary buffer
memcpy((void *)image_buffer, (void *)bitmap.buffer, SCREEN_WIDTH*SCREEN_HEIGHT);
} // end if
else
{ // non-linear
// make copy of source and destination addresses
UCHAR *dest_ptr = image_buffer;
UCHAR *src_ptr = bitmap.buffer;
// memory is non-linear, copy line by line
for (int y=0; y < SCREEN_HEIGHT; y++)
{
// copy line
memcpy((void *)dest_ptr, (void *)src_ptr, SCREEN_WIDTH);
// advance pointers to next line
dest_ptr+=ddsd.lPitch;
src_ptr +=SCREEN_WIDTH;
} // end for
} // end else
// now unlock the primary surface
if (FAILED(lpddsbackground->Unlock(NULL)))
return(0);
// unload the bitmap file, we no longer need it
Unload_Bitmap_File(&bitmap);
// seed random number generator
srand(GetTickCount());
// initialize all the aliens (in real life do this in a loop or function)
// alien on level 1 of complex
aliens[0].x = rand()%SCREEN_WIDTH;
aliens[0].y = 116 - 72;
aliens[0].velocity = 2+rand()%4;
aliens[0].current_frame = 0;
aliens[0].counter = 0;
aliens[0].width = 72; // set real size
aliens[0].height = 80;
aliens[0].scale = ((float)(1+rand()%20))/10; // scale from 0.1 to 2.0
// fix up feet so they still contact floor
aliens[0].y+=(72 - aliens[0].scale*72);
// alien on level 2 of complex
aliens[1].x = rand()%SCREEN_WIDTH;
aliens[1].y = 246 - 72;
aliens[1].velocity = 2+rand()%4;
aliens[1].current_frame = 0;
aliens[1].counter = 0;
aliens[1].width = 72; // set real size
aliens[1].height = 80;
aliens[1].scale = ((float)(1+rand()%20))/10; // scale from 0.1 to 2.0
// fix up feet so they still contact floor
aliens[1].y+=(72 - aliens[1].scale*72);
// alien on level 3 of complex
aliens[2].x = rand()%SCREEN_WIDTH;
aliens[2].y = 382 - 72;
aliens[2].velocity = 2+rand()%4;
aliens[2].current_frame = 0;
aliens[2].counter = 0;
aliens[2].width = 72; // set real size
aliens[2].height = 80;
aliens[2].scale = ((float)(1+rand()%20))/10; // scale from 0.1 to 2.0
// fix up feet so they still contact floor
aliens[2].y+=(72 - aliens[2].scale*72);
// now load the bitmap containing the alien imagery
// then scan the images out into the surfaces of alien[0]
// and copy then into the other two, be careful of reference counts!
// load the 8-bit image
if (!Load_Bitmap_File(&bitmap,"dedsp0.bmp"))
return(0);
// create each surface and load bits
for (int index = 0; index < 3; index++)
{
// create surface to hold image
aliens[0].frames[index] = DDraw_Create_Surface(72,80,0);
// now load bits...
Scan_Image_Bitmap(&bitmap, // bitmap file to scan image data from
aliens[0].frames[index], // surface to hold data
index, 0); // cell to scan image from
} // end for index
// unload the bitmap file, we no longer need it
Unload_Bitmap_File(&bitmap);
// now for the tricky part. There is no need to create more surfaces with the same
// data, so I'm going to copy the surface pointers member for member to each alien
// however, be careful, since the reference counts do NOT go up, you still only need
// to release() each surface once!
for (index = 0; index < 3; index++)
aliens[1].frames[index] = aliens[2].frames[index] = aliens[0].frames[index];
// return success or failure or your own return code here
return(1);
} // end Game_Init
int Game_Init(void *parms = NULL, int num_parms = 0)
{
// this is called once after the initial window is created and
// before the main event loop is entered, do all your initialization
// here
int retval = 0;
colors16 = new WORD[65536];
// create IDirectDraw interface 7.0 object and test for error
if (FAILED(DirectDrawCreateEx(NULL, (void **)&lpdd, IID_IDirectDraw7, NULL)))
{
// something bad happened during initialization, buh-bye!
SendMessage(main_window_handle,WM_CLOSE,0,0);
g_ddStepFailure = DDSF_DDACCESS;
retval = 0;
}
else
{
// set cooperation to normal since this will be a windowed app
lpdd->SetCooperativeLevel( main_window_handle,
DDSCL_FULLSCREEN
| DDSCL_ALLOWMODEX
| DDSCL_EXCLUSIVE
| DDSCL_ALLOWREBOOT
| DDSCL_MULTITHREADED );
if (FAILED(lpdd->SetDisplayMode( screen_width,
screen_height,
screen_bpp,
0, // refresh rate (use default)
0 ) // flags..
)
)
{
SendMessage(main_window_handle,WM_CLOSE,0,0);
g_ddStepFailure = DDSF_SETDISPLAYMODE;
retval = 0;
}
else
{
{
// create direct draw surface..
memset(&ddsd,0,sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
ddsd.dwFlags = DDSD_CAPS;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
if (FAILED(lpdd->CreateSurface(&ddsd,
&lpddsprimary,
NULL)
)
)
{
SendMessage(main_window_handle,WM_CLOSE,0,0);
g_ddStepFailure = DDSF_SURFACECREATE;
retval = 0;
}
else
{
{
// now get the pixel format..
//
memset(&ddpixel,0,sizeof(ddpixel));
ddpixel.dwSize = sizeof(ddpixel);
lpddsprimary->GetPixelFormat(&ddpixel);
if (ddpixel.dwFlags & DDPF_RGB)
{
// RGB mode..
switch(ddpixel.dwRGBBitCount)
{
case 15:
{
// 5.5.5
g_rgb16bitmode = RGB16MODE_555;
makeColors555();
MessageBox(main_window_handle,
"5.5.5",
"bit mode detected...",
MB_OK | MB_ICONEXCLAMATION );
}
break;
case 16:
{
// 5.6.5
g_rgb16bitmode = RGB16MODE_565;
makeColors565();
MessageBox(main_window_handle,
"5.6.5",
"bit mode detected...",
MB_OK | MB_ICONEXCLAMATION );
}
break;
case 24:
{
// 8.8.8
}
break;
case 32:
{
// alpha(8) 8.8.8
}
break;
default:
{
}
break;
}
}
retval = 1;
}
}
}
}
}
// return success or failure or your own return code here
return(retval);
} // end Game_Init
static HRESULT CreateFullScreenDisplay(HWND hWnd, DWORD dwWidth, DWORD dwHeight, DWORD dwBPP)
{
RECT rc;
DWORD dwStyle;
// Set app window's style to WS_POPUP so that it can fit for full screen mode.
dwStyle = GetWindowLong(hWnd, GWL_STYLE);
dwStyle &= ~(WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX);
dwStyle |= WS_POPUP;
SetWindowLong(hWnd, GWL_STYLE, dwStyle);
// Adapt window size
SetRect(&rc, 0, 0, dwWidth, dwHeight);
AdjustWindowRectEx(&rc, GetWindowStyle(hWnd), GetMenu(hWnd) != NULL, GetWindowExStyle(hWnd));
// Set cooperative level
if (FAILED(lpdd->SetCooperativeLevel(hWnd, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN | DDSCL_ALLOWREBOOT)))
{
return E_FAIL;
}
// Set the display mode
if (FAILED(lpdd->SetDisplayMode(dwWidth, dwHeight, dwBPP, 0, 0)))
{
return E_FAIL;
}
// Create primary surface (with backbuffer attached)
DDSURFACEDESC2 ddsd;
DDRAW_INIT_STRUCT(ddsd);
ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT | DDSD_CKSRCBLT;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP |
DDSCAPS_COMPLEX | DDSCAPS_3DDEVICE;
ddsd.dwBackBufferCount = 1;
if (FAILED(lpdd->CreateSurface(&ddsd, &lpddsMain, NULL)))
{
return E_FAIL;
}
// Get a pointer to the back buffer
DDSCAPS2 ddscaps;
ZeroMemory(&ddscaps, sizeof(ddscaps));
ddscaps.dwCaps = DDSCAPS_BACKBUFFER;
if (FAILED(lpddsMain->GetAttachedSurface(&ddscaps, &lpddsBack)))
{
return E_FAIL;
}
//lpddsBack->AddRef();
// Set surface color key
DDCOLORKEY ddCK;
ddCK.dwColorSpaceLowValue = 0;
ddCK.dwColorSpaceHighValue = 0;
if (lpddsBack->SetColorKey(DDCKEY_SRCBLT, &ddCK))
{
return E_FAIL;
}
// Update window flag
SetClassLong(hWnd, GCL_HICONSM, NULL);
SendMessage(hWnd, WM_SETICON, ICON_SMALL, NULL);
UpdateWindow(hWnd);
return S_OK;
}
//////////////////////////////////////////////////////////////////////////////
//INITIALIZATION
//////////////////////////////////////////////////////////////////////////////
bool Prog_Init()
{
lpdd=LPDD_Create(hWndMain,DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN | DDSCL_ALLOWREBOOT);
//set the display mode
lpdd->SetDisplayMode(SCREENWIDTH,SCREENHEIGHT,SCREENBPP,0,0);
//create primary surface
DDSURFACEDESC2 ddsd;
memset(&ddsd,0,sizeof(DDSURFACEDESC2));
ddsd.dwSize=sizeof(DDSURFACEDESC2);
ddsd.dwFlags=DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
ddsd.dwBackBufferCount=1;
ddsd.ddsCaps.dwCaps=DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP | DDSCAPS_COMPLEX | DDSCAPS_3DDEVICE;
lpdd->CreateSurface(&ddsd,&lpddsPrime,NULL);
//create back buffer
DDSCAPS2 ddscaps;
memset(&ddscaps,0,sizeof(DDSCAPS2));
ddscaps.dwCaps=DDSCAPS_BACKBUFFER | DDSCAPS_3DDEVICE;
lpddsPrime->GetAttachedSurface(&ddscaps,&lpddsBack);
//create the texture surface
memset(&ddsd,0,sizeof(DDSURFACEDESC2));
ddsd.dwSize=sizeof(DDSURFACEDESC2);
ddsd.dwFlags=DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
ddsd.dwWidth=64;
ddsd.dwHeight=64;
ddsd.ddsCaps.dwCaps=DDSCAPS_TEXTURE;
lpdd->CreateSurface(&ddsd,&lpddsTex,NULL);
//used ddfuncs to load a bitmap onto the texture
LPDDS_ReloadFromFile(lpddsTex,"texture.bmp");
//get the idirect3d pointer
lpdd->QueryInterface(IID_IDirect3D7,(void**)&lpd3d);//ICKY COM STUFF!
//create the idirect3ddevice(hack method)
if(FAILED(lpd3d->CreateDevice(IID_IDirect3DTnLHalDevice,lpddsBack,&lpd3ddev)))//try tnl
if(FAILED(lpd3d->CreateDevice(IID_IDirect3DHALDevice,lpddsBack,&lpd3ddev)))//no tnl, try hal
if(FAILED(lpd3d->CreateDevice(IID_IDirect3DMMXDevice,lpddsBack,&lpd3ddev)))//no hal, try mmp
if(FAILED(lpd3d->CreateDevice(IID_IDirect3DRGBDevice,lpddsBack,&lpd3ddev)))//no mmx, resort to rgb
return(false);//problem, return false
//set up viewport
D3DVIEWPORT7 vp;
vp.dwX=0;
vp.dwY=0;
vp.dwWidth=SCREENWIDTH;
vp.dwHeight=SCREENHEIGHT;
vp.dvMinZ=0.0;
vp.dvMaxZ=1.0;
//set viewport for device
lpd3ddev->SetViewport(&vp);
//initialize the vertices(partially, anyway)
vert[0].color=D3DRGB(0.25,0.25,0.25);//set the color for this vertex
vert[0].specular=0;//zero for specular
vert[0].rhw=1.0;//rhw is 1.0
vert[0].tu=0.0;//0.0 for both texture coordinates
vert[0].tv=0.0;
vert[0].sz=0.5;//static z value
vert[1].color=D3DRGB(0.5,0.5,0.5);//set the color for this vertex
vert[1].specular=0;//zero for specular
vert[1].rhw=1.0;//rhw is 1.0
vert[1].tu=1.0;//0.0 for both texture coordinates
vert[1].tv=0.0;
vert[1].sz=0.5;//static z value
vert[2].color=D3DRGB(0.5,0.5,0.5);//set the color for this vertex
vert[2].specular=0;//zero for specular
vert[2].rhw=1.0;//rhw is 1.0
vert[2].tu=0.0;//0.0 for both texture coordinates
vert[2].tv=1.0;
vert[2].sz=0.5;//static z value
vert[3].color=D3DRGB(1.0,1.0,1.0);//set the color for this vertex
vert[3].specular=0;//zero for specular
vert[3].rhw=1.0;//rhw is 1.0
vert[3].tu=1.0;//0.0 for both texture coordinates
vert[3].tv=1.0;
vert[3].sz=0.5;//static z value
//set the texture
lpd3ddev->SetTexture(0,lpddsTex);
return(true);//return success
}
int Game_Init(void *parms = NULL, int num_parms = 0)
{
// this is called once after the initial window is created and
// before the main event loop is entered, do all your initialization
// here
// create IDirectDraw interface 7.0 object and test for error
if (FAILED(DirectDrawCreateEx(NULL, (void **)&lpdd, IID_IDirectDraw7, NULL)))
return(0);
// set cooperation to full screen
if (FAILED(lpdd->SetCooperativeLevel(main_window_handle,
DDSCL_FULLSCREEN | DDSCL_ALLOWMODEX |
DDSCL_EXCLUSIVE | DDSCL_ALLOWREBOOT)))
return(0);
// set display mode to 640x480x24
if (FAILED(lpdd->SetDisplayMode(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP,0,0)))
return(0);
// clear ddsd and set size
DDRAW_INIT_STRUCT(ddsd);
// enable valid fields
ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
ddsd.dwBackBufferCount = 1;
//
// request primary surface
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_COMPLEX | DDSCAPS_FLIP;
// create the primary surface
if (FAILED(lpdd->CreateSurface(&ddsd, &lpddsprimary, NULL)))
return(0);
ddsd.ddsCaps.dwCaps = DDSCAPS_BACKBUFFER;
if(FAILED(lpddsprimary->GetAttachedSurface(&ddsd.ddsCaps, &lpddsback))) return 0;
// 把主屏和缓冲屏都填充为黑色初始化
DDraw_Fill_Surface(lpddsprimary, _RGB32BIT(0, 0,0,0));
DDraw_Fill_Surface(lpddsback, _RGB32BIT(0, 0,0,0));
// load the 24-bit image
char* bmp_wc = "WarCraft24.bmp";
char* bmp_b8 = "bitmap8b.bmp";
char* bmp_b24 = "bitmap24.bmp";
char* bmp_b24e = "bitmap24_edit.bmp";
char* bmp_mo24 = "mosaic-600x.bmp";
char* bmp_ni24 = "nightelf-640x.bmp";
char* bmp_alley24 = "alley8_24bit.bmp";
// 载入背景图片
if (!Load_Bitmap_File(&bitmap, bmp_ni24))
return(0);
// 创建背景表面、但实际上不是直接用背景表面来显示的、而是拷贝去缓冲表面和人物动作混合
// 后才一次性打到显示表面
// 这里头两个参数是指在屏幕的高和宽、第二个是指表面建立的地点、0指在显存建立、其它表示在
// 系统内存建立、当然速度自然是在显存建立快了、最后一个参数是是否设置为色彩键、这里设定为-1
// 也就是不设定任何色彩过滤、因为这个是背景表面、所以不需要任何透明的色彩键
lpddsbackground = DDraw_Create_Surface(640,480,0,-1);
// 把bmp的内容拷贝至缓冲表面中
Bmp2Surface(lpddsbackground, SCREEN_WIDTH, SCREEN_HEIGHT);
// 从现在开始创建人物动作了
if (!Load_Bitmap_File(&bitmap, "Dedsp0_24bit.bmp"))
return(0);
// seed random number generator
// GetTickCount是一个系统启动至今的毫秒数、
// 配合srandg来产生一个随机数
srand(GetTickCount());
// initialize all the aliens
// alien on level 1 of complex
//
//系统在调用rand（）之前都会自动调用srand（），如果用户在rand（）之前曾调用过srand（）给参数seed指定了一个值，
//那么rand（）就会将seed的值作为产生伪随机数的初始值；
//而如果用户在rand（）前没有调用过srand（），那么rand（）就会自动调用srand（1），即系统默认将1作为伪随机数的初始值。
//所以前面要调用一次srand来确保以下调用rand()的值会产生不同
//
aliens[0].x = rand()%SCREEN_WIDTH;
aliens[0].y = 116 - 72;
aliens[0].velocity = 2+rand()%4;
aliens[0].current_frame = 0;
aliens[0].counter = 0;
// alien on level 2 of complex
aliens[1].x = rand()%SCREEN_WIDTH;
aliens[1].y = 246 - 72;
aliens[1].velocity = 2+rand()%4;
aliens[1].current_frame = 0;
aliens[1].counter = 0;
// alien on level 3 of complex
aliens[2].x = rand()%SCREEN_WIDTH;
aliens[2].y = 382 - 72;
aliens[2].velocity = 2+rand()%4;
aliens[2].current_frame = 0;
aliens[2].counter = 0;
// now load the bitmap containing the alien imagery
// then scan the images out into the surfaces of alien[0]
// and copy then into the other two, be careful of reference counts!
// 现在开始载入人物的动画帧图片了
if (!Load_Bitmap_File(&bitmap,"Dedsp0_24bit.bmp"))
return(0);
// create each surface and load bits
// 初始化异形0号的三个动作帧表面、
// 其实、所有的异形动作帧表面都一样的、所以没有必要为每个异形都创建相应的动作帧、
// 所以其它异形的动作帧都指向这个异形0号的动作帧就可以了
for (int index = 0; index < 3; index++)
{
// create surface to hold image
aliens[0].frames[index] = DDraw_Create_Surface(72,80,0);
// now load bits...
Scan_Image_Bitmap(&bitmap, // bitmap file to scan image data from
aliens[0].frames[index], // surface to hold data
index, 0); // cell to scan image from
} // end for index
// unload the bitmap file, we no longer need it
Unload_Bitmap_File(&bitmap);
// now for the tricky part. There is no need to create more surfaces with the same
// data, so I'm going to copy the surface pointers member for member to each alien
// however, be careful, since the reference counts do NOT go up, you still only need
// to release() each surface once!
for (index = 0; index < 3; index++)
aliens[1].frames[index] = aliens[2].frames[index] = aliens[0].frames[index];
// return success or failure or your own return code here
return(1);
} // end Game_Init
int DD_Init(int width, int height, int bpp)
{
// this function initializes directdraw
int index; // looping variable
// create object and test for error
if (DirectDrawCreateEx(NULL, (void **)&lpdd, IID_IDirectDraw7, NULL)!=DD_OK)
return(0);
// set cooperation level to windowed mode normal
if (lpdd->SetCooperativeLevel(main_window_handle,
DDSCL_ALLOWMODEX | DDSCL_FULLSCREEN |
DDSCL_EXCLUSIVE | DDSCL_ALLOWREBOOT)!=DD_OK)
return(0);
// set the display mode
if (lpdd->SetDisplayMode(width,height,bpp,0,0)!=DD_OK)
return(0);
// set globals
screen_height = height;
screen_width = width;
screen_bpp = bpp;
// Create the primary surface
memset(&ddsd,0,sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
// we need to let dd know that we want a complex
// flippable surface structure, set flags for that
ddsd.ddsCaps.dwCaps =
DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP | DDSCAPS_COMPLEX;
// set the backbuffer count to 1
ddsd.dwBackBufferCount = 1;
// create the primary surface
lpdd->CreateSurface(&ddsd,&lpddsprimary,NULL);
// query for the backbuffer i.e the secondary surface
ddscaps.dwCaps = DDSCAPS_BACKBUFFER;
lpddsprimary->GetAttachedSurface(&ddscaps,&lpddsback);
// create and attach palette
// create palette data
// clear all entries defensive programming
memset(palette,0,256*sizeof(PALETTEENTRY));
// create a R,G,B,GR gradient palette
for (index=0; index < 256; index++)
{
// set each entry
if (index < 64)
palette[index].peRed = index*4;
else // shades of green
if (index >= 64 && index < 128)
palette[index].peGreen = (index-64)*4;
else // shades of blue
if (index >= 128 && index < 192)
palette[index].peBlue = (index-128)*4;
else // shades of grey
if (index >= 192 && index < 256)
palette[index].peRed = palette[index].peGreen =
palette[index].peBlue = (index-192)*4;
// set flags
palette[index].peFlags = PC_NOCOLLAPSE;
} // end for index
// now create the palette object
if (lpdd->CreatePalette(DDPCAPS_8BIT | DDPCAPS_INITIALIZE | DDPCAPS_ALLOW256,
palette,&lpddpal,NULL)!=DD_OK)
return(0);
// attach the palette to the primary
if (lpddsprimary->SetPalette(lpddpal)!=DD_OK)
return(0);
// clear out both primary and secondary surfaces
DD_Fill_Surface(lpddsprimary,0);
DD_Fill_Surface(lpddsback,0);
// attach a clipper to the screen
RECT screen_rect = {0,0,screen_width,screen_height};
lpddclipper = DD_Attach_Clipper(lpddsback,1,&screen_rect);
// return success
return(1);
} // end DD_Init
/**
* vdraw_ddraw_init(): Initialize the DirectDraw video subsystem.
* @return 0 on success; non-zero on error.
*/
int vdraw_ddraw_init(void)
{
DDSURFACEDESC2 ddsd;
vdraw_ddraw_end();
mdp_render_t *rendMode = get_mdp_render_t();
const int scale = rendMode->scale;
// Determine the window size using the scaling factor.
if (scale <= 0)
return -1;
const int w = 320 * scale;
const int h = 240 * scale;
if (vdraw_get_fullscreen())
{
Res_X = w;
Res_Y = h;
}
// Return value.
int rval;
// Initialize DirectDraw.
// TODO: Initialize DirectDraw on the monitor with most of Gens/GS onscreen.
LPDIRECTDRAW lpDD_Init;
rval = DirectDrawCreate(NULL, &lpDD_Init, NULL);
if (FAILED(rval))
{
LOG_MSG(video, LOG_MSG_LEVEL_ERROR,
"DirectDrawCreate() failed: 0x%08X", rval);
return -2;
}
rval = lpDD_Init->QueryInterface(IID_IDirectDraw7, (LPVOID*)&lpDD);
if (FAILED(rval))
{
if (lpDD_Init)
lpDD_Init->Release();
LOG_MSG(video, LOG_MSG_LEVEL_ERROR,
"lpDD_Init->QueryInterface(IID_IDirectDraw4) failed: 0x%08X", rval);
LOG_MSG(video, LOG_MSG_LEVEL_ERROR,
"This can usually be fixed by upgrading DirectX.");
return -3;
}
// Free the DirectDraw initialization object.
lpDD_Init->Release();
// Set the cooperative level.
vdraw_ddraw_set_cooperative_level();
// TODO: 15-bit color override. ("Force 555" or "Force 565" in the config file.)
memset(&ddsd, 0, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
// TODO: Figure out what FS_No_Res_Change is for.
// TODO: Figure out if this is correct.
if (vdraw_get_fullscreen() /* && !FS_No_Res_Change*/)
{
// Use the color depth setting.
// NOTE: "15-bit" color requires 16-bit to be specified.
rval = lpDD->SetDisplayMode(Res_X, Res_Y, (bppOut == 15 ? 16 : bppOut), 0, 0);
if (FAILED(rval))
{
vdraw_ddraw_free_all(false);
LOG_MSG(video, LOG_MSG_LEVEL_ERROR,
"lpDD->SetDisplayMode() failed: 0x%08X", rval);
// If render mode is set to Normal, try using Double instead.
if (rendMode_FS == RenderMgr::begin() && rendMode_FS != RenderMgr::end())
{
LOG_MSG(video, LOG_MSG_LEVEL_ERROR,
"Renderer is set to Normal; attempting to use Double instead.");
rendMode_FS++;
vdraw_set_renderer(rendMode_FS);
vdraw_text_write("Normal rendering failed. Using Double.", 1500);
Sync_Gens_Window_GraphicsMenu();
}
return -4;
}
}
#if 0
// Check the current color depth.
unsigned char newBpp;
lpDD->GetDisplayMode(&ddsd);
switch (ddsd.ddpfPixelFormat.dwGBitMask)
{
case 0x03E0:
// 15-bit color.
newBpp = 15;
break;
case 0x07E0:
// 16-bit color.
newBpp = 16;
break;
case 0x00FF00:
default:
// 32-bit color.
newBpp = 32;
break;
}
if (newBpp != bppOut)
vdraw_set_bpp(newBpp, false);
#endif
// Clear ddsd.
memset(&ddsd, 0x00, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
if (vdraw_get_fullscreen() && Video.VSync_FS)
{
ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP | DDSCAPS_COMPLEX;
ddsd.dwBackBufferCount = 2;
}
else
{
ddsd.dwFlags = DDSD_CAPS;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
}
// Create the primary surface.
rval = lpDD->CreateSurface(&ddsd, &lpDDS_Primary, NULL);
if (FAILED(rval))
{
vdraw_ddraw_free_all(false);
LOG_MSG(video, LOG_MSG_LEVEL_ERROR,
"lpDD->CreateSurface(&lpDDS_Primary) failed: 0x%08X", rval);
return -5;
}
if (vdraw_get_fullscreen())
{
if (Video.VSync_FS)
{
ddsd.ddsCaps.dwCaps = DDSCAPS_BACKBUFFER;
rval = lpDDS_Primary->GetAttachedSurface(&ddsd.ddsCaps, &lpDDS_Flip);
if (FAILED(rval))
{
vdraw_ddraw_free_all(false);
LOG_MSG(video, LOG_MSG_LEVEL_ERROR,
"lpDDS_Primary->GetAttachSurface() failed: 0x%08X", rval);
return -6;
}
lpDDS_Blit = lpDDS_Flip;
}
else
{
lpDDS_Blit = lpDDS_Primary;
}
}
else
{
rval = lpDD->CreateClipper(0, &lpDDC_Clipper, NULL);
if (FAILED(rval))
{
vdraw_ddraw_free_all(false);
LOG_MSG(video, LOG_MSG_LEVEL_ERROR,
"lpDD->CreateClipper() failed: 0x%08X", rval);
return -7;
}
rval = lpDDC_Clipper->SetHWnd(0, gens_window);
if (FAILED(rval))
{
vdraw_ddraw_free_all(false);
LOG_MSG(video, LOG_MSG_LEVEL_ERROR,
"lpDDC_Clipper->SetHWnd() failed: 0x%08X", rval);
return -8;
}
rval = lpDDS_Primary->SetClipper(lpDDC_Clipper);
if (FAILED(rval))
{
vdraw_ddraw_free_all(false);
LOG_MSG(video, LOG_MSG_LEVEL_ERROR,
"lpDDC_Primary->SetClipper() failed: 0x%08X", rval);
return -9;
}
}
// Clear ddsd again.
memset(&ddsd, 0, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;
// Determine the width and height.
// NOTE: For DirectDraw, the actual 336 width is used.
if (vdraw_ddraw_is_hw_render())
{
// Normal render mode. 320x240 [336x240]
ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_SYSTEMMEMORY;
ddsd.dwWidth = 336;
ddsd.dwHeight = 240;
}
else
{
// Larger than 1x.
ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_VIDEOMEMORY;
ddsd.dwWidth = w;
ddsd.dwHeight = h;
}
// Set the pixel format.
ddsd.dwFlags |= DDSD_PIXELFORMAT;
ddsd.ddpfPixelFormat.dwSize = sizeof(ddsd.ddpfPixelFormat);
ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB;
ddsd.ddpfPixelFormat.dwFourCC = 0; // RGB
ddsd.ddpfPixelFormat.dwRGBAlphaBitMask = 0;
// Bits per component.
switch (bppOut)
{
case 15:
// 15-bit color. (555)
ddsd.ddpfPixelFormat.dwRGBBitCount = 16;
ddsd.ddpfPixelFormat.dwRBitMask = 0x7C00;
ddsd.ddpfPixelFormat.dwGBitMask = 0x03E0;
ddsd.ddpfPixelFormat.dwBBitMask = 0x001F;
break;
case 16:
// 16-bit color. (555)
ddsd.ddpfPixelFormat.dwRGBBitCount = 16;
ddsd.ddpfPixelFormat.dwRBitMask = 0xF800;
ddsd.ddpfPixelFormat.dwGBitMask = 0x07E0;
ddsd.ddpfPixelFormat.dwBBitMask = 0x001F;
break;
case 32:
default:
// 32-bit color.
ddsd.ddpfPixelFormat.dwRGBBitCount = 32;
ddsd.ddpfPixelFormat.dwRBitMask = 0xFF0000;
ddsd.ddpfPixelFormat.dwGBitMask = 0x00FF00;
ddsd.ddpfPixelFormat.dwBBitMask = 0x0000FF;
break;
}
// Create the back surface.
rval = lpDD->CreateSurface(&ddsd, &lpDDS_Back, NULL);
if (FAILED(rval))
{
// Failed to create the back surface.
// If we attempted to create it in video memory, try system memory instead.
if (ddsd.ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY)
{
LOG_MSG(video, LOG_MSG_LEVEL_ERROR,
"lpDD->CreateSurface(&lpDDS_Back, DDSCAPS_VIDEOMEMORY) failed: 0x%08X", rval);
LOG_MSG(video, LOG_MSG_LEVEL_ERROR,
"Attempting to use DDSCAPS_SYSTEMMEMORY instead.");
ddsd.ddsCaps.dwCaps &= ~DDSCAPS_VIDEOMEMORY;
ddsd.ddsCaps.dwCaps |= DDSCAPS_SYSTEMMEMORY;
rval = lpDD->CreateSurface(&ddsd, &lpDDS_Back, NULL);
if (FAILED(rval))
{
// Failed to create the back surface in system memory.
vdraw_ddraw_free_all(false);
LOG_MSG(video, LOG_MSG_LEVEL_ERROR,
"lpDD->CreateSurface(&lpDDS_Back, DDSCAPS_SYSTEMMEMORY) failed: 0x%08X", rval);
return -10;
}
}
else
{
vdraw_ddraw_free_all(false);
LOG_MSG(video, LOG_MSG_LEVEL_ERROR,
"lpDD->CreateSurface(&lpDDS_Back, DDSCAPS_SYSTEMMEMORY) failed: 0x%08X", rval);
return -11;
}
}
// TODO: Check if this is right.
// I think this might be causing the frame counter flicker in full screen mode.
//if (!vdraw_get_fullscreen() || (rendMode >= 1 && (/*FS_No_Res_Change ||*/ Res_X != 640 || Res_Y != 480)))
if (!vdraw_get_fullscreen() || !vdraw_ddraw_is_hw_render())
lpDDS_Blit = lpDDS_Back;
if (vdraw_ddraw_is_hw_render())
{
// Normal rendering mode uses MD_Screen directly.
memset(&ddsd, 0, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
// TODO: This causes issues if the selected color depth isn't the
// same as the desktop color depth. This only affects windowed mode,
// since in fullscreen, the desktop color depth is changed.
rval = lpDDS_Back->GetSurfaceDesc(&ddsd);
if (FAILED(rval))
{
vdraw_ddraw_free_all(false);
LOG_MSG(video, LOG_MSG_LEVEL_ERROR,
"lpDDS_Back->GetSurfaceDesc() failed: 0x%08X", rval);
return -12;
}
ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_PITCH | DDSD_LPSURFACE | DDSD_PIXELFORMAT;
ddsd.dwWidth = 336;
ddsd.dwHeight = 240;
if (ddsd.ddpfPixelFormat.dwRGBBitCount > 16)
{
// 32-bit color.
ddsd.lpSurface = MD_Screen.u32;
ddsd.lPitch = 336 * 4;
}
else
{
// 15-bit or 16-bit color.
ddsd.lpSurface = MD_Screen.u16;
ddsd.lPitch = 336 * 2;
}
rval = lpDDS_Back->SetSurfaceDesc(&ddsd, 0);
if (FAILED(rval))
{
vdraw_ddraw_free_all(false);
LOG_MSG(video, LOG_MSG_LEVEL_ERROR,
"lpDDS_Back->SetSurfaceDesc() failed: 0x%08X", rval);
return -13;
}
}
// Initialize the destination rectangle.
vdraw_ddraw_adjust_RectDest();
// Reset the render mode.
vdraw_reset_renderer(false);
// Synchronize menus.
Sync_Gens_Window();
// vdraw_ddraw initialized.
return 0;
}
//-----------------------------------------------------------------------------
// Name: dx_Initialise (...)
// Desc: Initialise et configure DirectX (DirectDraw)
//-----------------------------------------------------------------------------
bool dx_Initialise (uint8 pNombreSurfaces,
HWND pFenetre,
uint16 pResolutionX,
uint16 pResolutionY,
uint16 pBitsParPixel,
uint16 pFrequence,
bool pPleinEcran,
bool pTailleFenetre,
void (*pRestaure)())
{
// InitialiseDX a déjà été appelé
if (DirectDraw7 != NULL) {
return dx_Finalise (ERR_NO_UTILISATEUR);
}
dx_InitVars ();
// Initialise toutes les variables
Fenetre = pFenetre;
NombreSurfaces = pNombreSurfaces;
ResolutionX = pResolutionX;
ResolutionY = pResolutionY;
BitsParPixel = pBitsParPixel;
Frequence = pFrequence;
PleinEcran = pPleinEcran;
TailleFenetre = pTailleFenetre;
Restaure = pRestaure;
Surfaces = new LPDIRECTDRAWSURFACE7[NombreSurfaces];
// Initialisation de directdraw
ErrDd = DirectDrawCreateEx (0,(LPVOID*)&DirectDraw7,IID_IDirectDraw7,0);
if (ErrDd != DD_OK) return dx_Finalise (ERR_NO_CREATION);
ModeCoop = PleinEcran ? COOP_PLEIN_ECRAN : COOP_FENETRE;
// Utilisation de la résolution active ou donnée
if (ResolutionX == 0 || ResolutionY == 0 ||
BitsParPixel == 0 || Frequence == 0)
{
DDSURFACEDESC2 ModeActif;
ZeroMemory (&ModeActif, sizeof(ModeActif));
ModeActif.dwSize = sizeof(ModeActif);
ErrDd = DirectDraw7->GetDisplayMode (&ModeActif);
if (ErrDd != DD_OK) return dx_Finalise (ERR_NO_MODE_ACTIF);
if (ResolutionX == 0) ResolutionX = ModeActif.dwWidth;
if (ResolutionY == 0) ResolutionY = ModeActif.dwHeight;
if (BitsParPixel == 0) BitsParPixel = ModeActif.
ddpfPixelFormat.dwRGBBitCount;
if (Frequence == 0) Frequence = ModeActif.dwRefreshRate;
}
// Sélection du mode de coopération
ErrDd = DirectDraw7->SetCooperativeLevel (Fenetre, ModeCoop);
if (ErrDd != DD_OK) return dx_Finalise (ERR_NO_COOPERATION);
ErrDd = DirectDraw7->SetDisplayMode (ResolutionX,
ResolutionY,BitsParPixel,0,0);
if (ErrDd != DD_OK) return dx_Finalise (ERR_NO_MODE_AFFICHAGE);
// Création des surfaces d'affichage
SurfaceDesc.dwFlags = DDSD_CAPS;
SurfaceDesc.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
if (PleinEcran)
{ // Surface avec backbuffer
SurfaceDesc.dwFlags |= DDSD_BACKBUFFERCOUNT;
SurfaceDesc.ddsCaps.dwCaps |= DDSCAPS_FLIP | DDSCAPS_COMPLEX;
SurfaceDesc.dwBackBufferCount = 1;
}
ErrDd = DirectDraw7->CreateSurface (&SurfaceDesc,&SurfacePrimaire,NULL);
if (ErrDd != DD_OK) return dx_Finalise (ERR_NO_PRIMAIRE);
if (PleinEcran)
{
SurfaceCaps.dwCaps = DDSCAPS_BACKBUFFER;
ErrDd = SurfacePrimaire->GetAttachedSurface (&SurfaceCaps,&SurfaceBack);
if (ErrDd != DD_OK) return dx_Finalise (ERR_NO_BACKBUFFER);
}
else
{
// Surface avec clipper pour dessiner que dans la fenêtre
ErrDd = DirectDraw7->CreateClipper (0, &SurfaceClipper, NULL);
if (ErrDd != DD_OK) return dx_Finalise (ERR_NO_CLIPPER);
// Coordonnées de la fenêtre dans le clipper
ErrDd = SurfaceClipper->SetHWnd (0, Fenetre);
if (ErrDd != DD_OK) return dx_Finalise (ERR_NO_CLIPPER_HWND);
// Attache le clipper à la surface primaire
ErrDd = SurfacePrimaire->SetClipper (SurfaceClipper);
if (ErrDd != DD_OK) return dx_Finalise (ERR_NO_CLIPPER_PRIMAIRE);
ZeroMemory (&SurfaceDesc, sizeof(SurfaceDesc));
SurfaceDesc.dwSize = sizeof(SurfaceDesc);
SurfaceDesc.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;
SurfaceDesc.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
SurfaceDesc.dwWidth = ResolutionX;
SurfaceDesc.dwHeight = ResolutionY;
// Création du backbuffer séparément
ErrDd = DirectDraw7->CreateSurface (&SurfaceDesc,&SurfaceBack,NULL);
if (ErrDd != DD_OK) return dx_Finalise (ERR_NO_BACKBUFFER);
}
if (PleinEcran) ShowCursor (false);
return true;
}