int ninjakd2_vh_start(void)
{
int i;
if ((bg_dirtybuffer = malloc(1024)) == 0)
{
return 1;
}
if ((bitmap_bg = osd_new_bitmap (Machine->drv->screen_width*2,Machine->drv->screen_height*2,Machine->scrbitmap->depth)) == 0)
{
free (bg_dirtybuffer);
return 1;
}
if ((bitmap_sp = osd_new_bitmap (Machine->drv->screen_width,Machine->drv->screen_height,Machine->scrbitmap->depth)) == 0)
{
free (bg_dirtybuffer);
free (bitmap_bg);
return 1;
}
memset(bg_dirtybuffer,1,1024);
/* chars, background tiles, sprites */
memset(palette_used_colors,PALETTE_COLOR_USED,Machine->drv->total_colors * sizeof(unsigned char));
for (i = 0;i < GFX_COLOR_CODES(1);i++)
{
palette_used_colors[COLORTABLE_START(1,i)+15] = PALETTE_COLOR_TRANSPARENT;
palette_used_colors[COLORTABLE_START(2,i)+15] = PALETTE_COLOR_TRANSPARENT;
}
return 0;
}
int klax_vh_start(void)
{
static struct atarigen_modesc klax_modesc =
{
256, /* maximum number of MO's */
8, /* number of bytes per MO entry */
2, /* number of bytes between MO words */
0, /* ignore an entry if this word == 0xffff */
0, 0, 0xff, /* link = (data[linkword] >> linkshift) & linkmask */
0 /* render in reverse link order */
};
/* allocate dirty buffers */
if (!playfielddirty)
playfielddirty = (unsigned char *)gp2x_malloc (atarigen_playfieldram_size / 2);
if (!playfielddirty)
{
klax_vh_stop ();
return 1;
}
fast_memset (playfielddirty, 1, atarigen_playfieldram_size / 2);
/* allocate bitmaps */
if (!playfieldbitmap)
playfieldbitmap = osd_new_bitmap (XDIM, YDIM, Machine->scrbitmap->depth);
if (!playfieldbitmap)
{
klax_vh_stop ();
return 1;
}
/* initialize the displaylist system */
return atarigen_init_display_list (&klax_modesc);
}
/***************************************************************************
Start the video hardware emulation.
***************************************************************************/
int leprechn_vh_start(void)
{
screen_width = Machine->drv->screen_width;
if ((rawbitmap = malloc(screen_width*Machine->drv->screen_height)) == 0)
{
return 1;
}
if ((tmpbitmap = osd_new_bitmap(screen_width,Machine->drv->screen_height,Machine->scrbitmap->depth)) == 0)
{
free(rawbitmap);
return 1;
}
pending = 0;
return 0;
}
/* Return a osd_bitmap pointer or 0 in case of error. */
struct osd_bitmap *osd_create_display(int width,int height,int attributes, int visible_width, int visible_height,
int visible_width_offset, int visible_height_offset )
{
int i;
game_width = width;
game_height = height;
if (attributes & VIDEO_TYPE_VECTOR) {
visible_game_width = width;
visible_game_height = height;
visible_game_width_offset = 0;
visible_game_height_offset = 0;
} else {
visible_game_width = visible_width;
visible_game_height = visible_height;
visible_game_width_offset = visible_width_offset;
visible_game_height_offset = visible_height_offset;
}
/* Offset alignment */
{
int alignment;
alignment= visible_game_width_offset % 4;
if (alignment) {
visible_game_width_offset-=alignment;
visible_game_width+=alignment;
}
alignment= visible_game_width % 4;
if (alignment) {
visible_game_width+=(4-alignment);
}
alignment= visible_game_height_offset % 4;
if (alignment) {
visible_game_height_offset-=alignment;
visible_game_height+=alignment;
}
alignment= visible_game_height % 4;
if (alignment) {
visible_game_height+=(4-alignment);
}
}
if (Machine->orientation & ORIENTATION_SWAP_XY)
{
int temp;
temp = game_width;
game_width = game_height;
game_height = temp;
temp = visible_game_width;
visible_game_width = visible_game_height;
visible_game_height = temp;
temp = visible_game_width_offset;
visible_game_width_offset = visible_game_height_offset;
visible_game_height_offset = temp;
}
if (Machine->orientation & ORIENTATION_FLIP_X) /* offset by other side */
visible_game_width_offset = game_width-visible_game_width-visible_game_width_offset;
if (Machine->orientation & ORIENTATION_FLIP_Y)
visible_game_height_offset = game_height-visible_game_height-visible_game_height_offset;
gp2x_adjust_display();
frame_buffer=1;
scrbitmap = osd_new_bitmap(width,height,8);
frame_buffer=0;
if (!scrbitmap) return 0;
for (i = 0;i < 256;i++)
{
dirtycolor[i] = 1;
}
dirtypalette = 1;
return scrbitmap;
}
int atarisys2_vh_start(void)
{
static struct atarigen_modesc atarisys2_modesc =
{
256, /* maximum number of MO's */
8, /* number of bytes per MO entry */
2, /* number of bytes between MO words */
3, /* ignore an entry if this word == 0xffff */
3, 3, 0xff, /* link = (data[linkword] >> linkshift) & linkmask */
0 /* render in reverse link order */
};
/* allocate banked memory */
alpharam = (unsigned char *)gp2x_malloc (0x8000);
if (!alpharam)
{
atarisys2_vh_stop ();
return 1;
}
fast_memset(alpharam,0,0x8000);
spriteram = alpharam + alpharam_size;
playfieldram = alpharam + 0x4000;
/* reset the videoram banking */
videoram = alpharam;
videobank = 0;
/* allocate dirty buffers */
if (!playfielddirty)
playfielddirty = (unsigned char *)gp2x_malloc (playfieldram_size / 2);
if (!playfielddirty)
{
atarisys2_vh_stop ();
return 1;
}
/* allocate bitmaps */
if (!playfieldbitmap)
playfieldbitmap = osd_new_bitmap (128*8, 64*8, Machine->scrbitmap->depth);
if (!playfieldbitmap)
{
atarisys2_vh_stop ();
return 1;
}
/*
* if we are palette reducing, do the simple thing by marking everything used except for
* the transparent sprite and alpha colors; this should give some leeway for machines
* that can't give up all 256 colors
*/
if (palette_used_colors)
{
int i;
fast_memset (palette_used_colors, PALETTE_COLOR_USED, Machine->drv->total_colors * sizeof(unsigned char));
for (i = 0; i < 4; i++)
palette_used_colors[0 + i * 16] = PALETTE_COLOR_TRANSPARENT;
for (i = 0; i < 8; i++)
palette_used_colors[64 + i * 4] = PALETTE_COLOR_TRANSPARENT;
}
/* initialize the displaylist system */
return atarigen_init_display_list (&atarisys2_modesc);
}
/***************************************************************************
Start the video hardware emulation.
***************************************************************************/
int lwings_vh_start(void)
{
int i;
if (generic_vh_start() != 0)
return 1;
if ((dirtybuffer2 = (unsigned char *)gp2x_malloc(lwings_backgroundram_size)) == 0)
{
generic_vh_stop();
return 1;
}
fast_memset(dirtybuffer2,1,lwings_backgroundram_size);
if ((dirtybuffer4 = (unsigned char *)gp2x_malloc(lwings_backgroundram_size)) == 0)
{
generic_vh_stop();
return 1;
}
fast_memset(dirtybuffer4,1,lwings_backgroundram_size);
/* the background area is twice as tall as the screen */
if ((tmpbitmap2 = osd_new_bitmap(2*Machine->drv->screen_width,
2*Machine->drv->screen_height,Machine->scrbitmap->depth)) == 0)
{
gp2x_free(dirtybuffer2);
generic_vh_stop();
return 1;
}
#define COLORTABLE_START(gfxn,color_code) Machine->drv->gfxdecodeinfo[gfxn].color_codes_start + \
color_code * Machine->gfx[gfxn]->color_granularity
#define GFX_COLOR_CODES(gfxn) Machine->gfx[gfxn]->total_colors
#define GFX_ELEM_COLORS(gfxn) Machine->gfx[gfxn]->color_granularity
fast_memset(palette_used_colors,PALETTE_COLOR_UNUSED,Machine->drv->total_colors * sizeof(unsigned char));
/* chars */
for (i = 0;i < GFX_COLOR_CODES(0);i++)
{
fast_memset(&palette_used_colors[COLORTABLE_START(0,i)],
PALETTE_COLOR_USED,
GFX_ELEM_COLORS(0));
palette_used_colors[COLORTABLE_START(0,i) + GFX_ELEM_COLORS(0)-1] = PALETTE_COLOR_TRANSPARENT;
}
/* bg tiles */
for (i = 0;i < GFX_COLOR_CODES(1);i++)
{
fast_memset(&palette_used_colors[COLORTABLE_START(1,i)],
PALETTE_COLOR_USED,
GFX_ELEM_COLORS(1));
}
/* sprites */
for (i = 0;i < GFX_COLOR_CODES(2);i++)
{
fast_memset(&palette_used_colors[COLORTABLE_START(2,i)],
PALETTE_COLOR_USED,
GFX_ELEM_COLORS(2));
}
return 0;
}
/*
Create a display screen, or window, large enough to accomodate a bitmap
of the given dimensions.
Return a osd_bitmap pointer or 0 in case of error.
*/
static struct osd_bitmap *GDI_create_display(int width, int height, int depth, int attributes)
{
unsigned int i;
RECT Rect;
HMENU hMenu;
LOGPALETTE LogPalette;
char TitleBuf[256];
This.m_nDepth = depth;
if (attributes & VIDEO_TYPE_VECTOR)
{
if (This.m_bVectorDouble == TRUE)
{
width *= 2;
height *= 2;
}
/* padding to a DWORD value */
width -= width % 4;
height -= height % 4;
AdjustVisibleRect(0, 0, width - 1, height - 1);
}
else
{
AdjustVisibleRect(Machine->drv->visible_area.min_x,
Machine->drv->visible_area.min_y,
Machine->drv->visible_area.max_x,
Machine->drv->visible_area.max_y);
}
This.m_nClientWidth = This.m_VisibleRect.m_Width;
This.m_nClientHeight = This.m_VisibleRect.m_Height;
if ((attributes & VIDEO_PIXEL_ASPECT_RATIO_MASK) == VIDEO_PIXEL_ASPECT_RATIO_1_2)
{
if (Machine->orientation & ORIENTATION_SWAP_XY)
This.m_nClientWidth *= 2;
else
This.m_nClientHeight *= 2;
This.m_bDouble = FALSE;
}
if (This.m_bDouble == TRUE)
{
This.m_nClientWidth *= 2;
This.m_nClientHeight *= 2;
}
if (This.m_bUseDirty == TRUE)
{
if (Machine->orientation & ORIENTATION_SWAP_XY)
InitDirty(height, width, NO_DIRTY);
else
InitDirty(width, height, NO_DIRTY);
}
/* osd_create_bitmap will swap width and height if neccesary. */
This.m_pMAMEBitmap = osd_new_bitmap(width, height, This.m_nDepth);
This.m_pTempBitmap = osd_new_bitmap(width, height, This.m_nDepth);
/* Palette */
if (This.m_nDepth == 8)
{
LogPalette.palVersion = 0x0300;
LogPalette.palNumEntries = 1;
This.m_hPalette = CreatePalette(&LogPalette);
ResizePalette(This.m_hPalette, OSD_NUMPENS);
}
/* Create BitmapInfo */
This.m_pInfo = (BITMAPINFO*)malloc(sizeof(BITMAPINFOHEADER) +
sizeof(RGBQUAD) * OSD_NUMPENS);
This.m_pInfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
This.m_pInfo->bmiHeader.biWidth = (This.m_pMAMEBitmap->line[1] - This.m_pMAMEBitmap->line[0]) / (This.m_nDepth / 8);
This.m_pInfo->bmiHeader.biHeight = -(int)(This.m_VisibleRect.m_Height); /* Negative means "top down" */
This.m_pInfo->bmiHeader.biPlanes = 1;
This.m_pInfo->bmiHeader.biBitCount = This.m_nDepth;
This.m_pInfo->bmiHeader.biCompression = BI_RGB;
This.m_pInfo->bmiHeader.biSizeImage = 0;
This.m_pInfo->bmiHeader.biXPelsPerMeter = 0;
This.m_pInfo->bmiHeader.biYPelsPerMeter = 0;
This.m_pInfo->bmiHeader.biClrUsed = 0;
This.m_pInfo->bmiHeader.biClrImportant = 0;
if (This.m_nDepth == 8)
{
/* Map image values to palette index */
for (i = 0; i < OSD_NUMPENS; i++)
((WORD*)(This.m_pInfo->bmiColors))[i] = i;
}
/*
Modify the main window to suit our needs.
*/
hMenu = LoadMenu(GetModuleHandle(NULL), MAKEINTRESOURCE(IDR_MAIN_MENU));
SetMenu(MAME32App.m_hWnd, hMenu);
SetWindowLong(MAME32App.m_hWnd, GWL_STYLE, WS_OVERLAPPEDWINDOW & ~WS_THICKFRAME | WS_BORDER);
sprintf(TitleBuf, "%s - %s", Machine->gamedrv->description, MAME32App.m_Name);
SetWindowText(MAME32App.m_hWnd, TitleBuf);
StatusCreate();
This.m_ClientRect.left = 0;
This.m_ClientRect.top = 0;
This.m_ClientRect.right = This.m_nClientWidth;
This.m_ClientRect.bottom = This.m_nClientHeight;
/* Calculate size of window based on desired client area. */
Rect.left = This.m_ClientRect.left;
Rect.top = This.m_ClientRect.top;
Rect.right = This.m_ClientRect.right;
Rect.bottom = This.m_ClientRect.bottom + GetStatusHeight();
AdjustWindowRect(&Rect, WS_OVERLAPPEDWINDOW & ~WS_THICKFRAME | WS_BORDER, hMenu != NULL);
This.m_nWindowWidth = RECT_WIDTH(Rect);
This.m_nWindowHeight = RECT_HEIGHT(Rect);
SetWindowPos(MAME32App.m_hWnd,
HWND_NOTOPMOST,
0, 0,
This.m_nWindowWidth,
This.m_nWindowHeight,
SWP_NOMOVE);
This.m_hWndAbout = CreateDialog(GetModuleHandle(NULL),
MAKEINTRESOURCE(IDD_ABOUT),
MAME32App.m_hWnd,
AboutDialogProc);
ShowWindow(MAME32App.m_hWnd, SW_SHOW);
SetForegroundWindow(MAME32App.m_hWnd);
set_ui_visarea(This.m_VisibleRect.m_Left,
This.m_VisibleRect.m_Top,
This.m_VisibleRect.m_Left + This.m_VisibleRect.m_Width - 1,
This.m_VisibleRect.m_Top + This.m_VisibleRect.m_Height - 1);
return This.m_pMAMEBitmap;
}
