a1842c04f9
With LCD driver all calculation will be performed on RGB888 and the hardware/OS can display from our 24bit framebuffer. It is not yet as performance optimized as the existing drivers but should be good enough.The vast number of small changes is due to the fact that fb_data can be a struct type now, while most of the code expected a scalar type. lcd-as-memframe ASM code does not work with 24bit currently so the with 24bit it enforces the generic C code. All plugins are ported over. Except for rockpaint. It uses so much memory that it wouldnt fit into the 512k plugin buffer anymore (patches welcome). Change-Id: Ibb1964545028ce0d8ff9833ccc3ab66be3ee0754
683 lines
20 KiB
C
683 lines
20 KiB
C
/***************************************************************************
|
|
* __________ __ ___.
|
|
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
|
|
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
|
|
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
|
|
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
|
|
* \/ \/ \/ \/ \/
|
|
* $Id$
|
|
*
|
|
* Pacbox - a Pacman Emulator for Rockbox
|
|
*
|
|
* Based on PIE - Pacman Instructional Emulator
|
|
*
|
|
* Copyright (c) 1997-2003,2004 Alessandro Scotti
|
|
* http://www.ascotti.org/
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
|
|
* KIND, either express or implied.
|
|
*
|
|
****************************************************************************/
|
|
|
|
#include "pacbox.h"
|
|
#include "arcade.h"
|
|
#include "hardware.h"
|
|
#include "wsg3.h"
|
|
#include <string.h>
|
|
#include "plugin.h"
|
|
|
|
#ifndef HAVE_LCD_COLOR
|
|
/* Convert RGB888 to 2-bit greyscale - logic taken from bmp2rb.c */
|
|
static fb_data rgb_to_gray(unsigned int r, unsigned int g, unsigned int b)
|
|
{
|
|
int brightness = ( 2*r + 4*g + b );
|
|
if( r == 0 && g == 0 && b == 0 )
|
|
return 3;
|
|
|
|
brightness = (brightness/450);
|
|
if( brightness > 2 ) return 0;
|
|
else return 2-brightness;
|
|
}
|
|
#endif
|
|
|
|
static unsigned char color_data_[256] = {
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0b, 0x01,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0b, 0x03,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0b, 0x05,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0b, 0x07,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x01, 0x09,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x0f, 0x00, 0x0e, 0x00, 0x01, 0x0c, 0x0f,
|
|
0x00, 0x0e, 0x00, 0x0b, 0x00, 0x0c, 0x0b, 0x0e,
|
|
0x00, 0x0c, 0x0f, 0x01, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x01, 0x02, 0x0f, 0x00, 0x07, 0x0c, 0x02,
|
|
0x00, 0x09, 0x06, 0x0f, 0x00, 0x0d, 0x0c, 0x0f,
|
|
0x00, 0x05, 0x03, 0x09, 0x00, 0x0f, 0x0b, 0x00,
|
|
0x00, 0x0e, 0x00, 0x0b, 0x00, 0x0e, 0x00, 0x0b,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0e, 0x01,
|
|
0x00, 0x0f, 0x0b, 0x0e, 0x00, 0x0e, 0x00, 0x0f,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
|
|
};
|
|
|
|
static unsigned char palette_data_[0x20] = {
|
|
0x00, 0x07, 0x66, 0xef, 0x00, 0xf8, 0xea, 0x6f,
|
|
0x00, 0x3f, 0x00, 0xc9, 0x38, 0xaa, 0xaf, 0xf6,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
|
|
};
|
|
|
|
enum {
|
|
Normal = 0x00,
|
|
FlipY = 0x01,
|
|
FlipX = 0x02,
|
|
FlipXY = 0x03
|
|
};
|
|
|
|
// Namco 3-channel Wave Sound Generator wave data (8 waveforms with 32 4-bit entries each)
|
|
static unsigned char default_sound_prom[] =
|
|
{
|
|
0x07, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0D, 0x0E,
|
|
0x0E, 0x0E, 0x0D, 0x0D, 0x0C, 0x0B, 0x0A, 0x09,
|
|
0x07, 0x05, 0x04, 0x03, 0x02, 0x01, 0x01, 0x00,
|
|
0x00, 0x00, 0x01, 0x01, 0x02, 0x03, 0x04, 0x05,
|
|
0x07, 0x0C, 0x0E, 0x0E, 0x0D, 0x0B, 0x09, 0x0A,
|
|
0x0B, 0x0B, 0x0A, 0x09, 0x06, 0x04, 0x03, 0x05,
|
|
0x07, 0x09, 0x0B, 0x0A, 0x08, 0x05, 0x04, 0x03,
|
|
0x03, 0x04, 0x05, 0x03, 0x01, 0x00, 0x00, 0x02,
|
|
0x07, 0x0A, 0x0C, 0x0D, 0x0E, 0x0D, 0x0C, 0x0A,
|
|
0x07, 0x04, 0x02, 0x01, 0x00, 0x01, 0x02, 0x04,
|
|
0x07, 0x0B, 0x0D, 0x0E, 0x0D, 0x0B, 0x07, 0x03,
|
|
0x01, 0x00, 0x01, 0x03, 0x07, 0x0E, 0x07, 0x00,
|
|
0x07, 0x0D, 0x0B, 0x08, 0x0B, 0x0D, 0x09, 0x06,
|
|
0x0B, 0x0E, 0x0C, 0x07, 0x09, 0x0A, 0x06, 0x02,
|
|
0x07, 0x0C, 0x08, 0x04, 0x05, 0x07, 0x02, 0x00,
|
|
0x03, 0x08, 0x05, 0x01, 0x03, 0x06, 0x03, 0x01,
|
|
0x00, 0x08, 0x0F, 0x07, 0x01, 0x08, 0x0E, 0x07,
|
|
0x02, 0x08, 0x0D, 0x07, 0x03, 0x08, 0x0C, 0x07,
|
|
0x04, 0x08, 0x0B, 0x07, 0x05, 0x08, 0x0A, 0x07,
|
|
0x06, 0x08, 0x09, 0x07, 0x07, 0x08, 0x08, 0x07,
|
|
0x07, 0x08, 0x06, 0x09, 0x05, 0x0A, 0x04, 0x0B,
|
|
0x03, 0x0C, 0x02, 0x0D, 0x01, 0x0E, 0x00, 0x0F,
|
|
0x00, 0x0F, 0x01, 0x0E, 0x02, 0x0D, 0x03, 0x0C,
|
|
0x04, 0x0B, 0x05, 0x0A, 0x06, 0x09, 0x07, 0x08,
|
|
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
|
|
0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
|
|
0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08,
|
|
0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00,
|
|
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
|
|
0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
|
|
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
|
|
0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
|
|
};
|
|
|
|
/* Putting this in IRAM actually slows down the iPods, but is good for
|
|
the Coldfire
|
|
*/
|
|
#ifdef CPU_COLDFIRE
|
|
fb_data palette[256] IBSS_ATTR; /* Color palette */
|
|
#else
|
|
fb_data palette[256]; /* Color palette */
|
|
#endif
|
|
|
|
|
|
void init_PacmanMachine(int dip)
|
|
{
|
|
int i;
|
|
|
|
/* Initialize the CPU and the RAM */
|
|
z80_reset();
|
|
rb->memset( &ram_[0x4000], 0xFF, 0x1000 );
|
|
|
|
/* Initialize the WSG3 */
|
|
wsg3_init(SoundClock);
|
|
|
|
/* Set the sound PROM to the default values for the original Namco chip */
|
|
wsg3_set_sound_prom(default_sound_prom);
|
|
|
|
/* Initialize parameters */
|
|
port1_ = 0xFF;
|
|
port2_ = 0xFF;
|
|
coin_counter_ = 0;
|
|
|
|
/* Reset the machine */
|
|
reset_PacmanMachine();
|
|
|
|
/* Set the DIP switches to a default configuration */
|
|
setDipSwitches( dip );
|
|
|
|
/* Initialize the video character translation tables: video memory has a
|
|
very peculiar arrangement in Pacman so we precompute a few tables to
|
|
move around faster */
|
|
|
|
for( i=0x000; i<0x400; i++ ) {
|
|
int x, y;
|
|
|
|
if( i < 0x040 ) {
|
|
x = 29 - (i & 0x1F);
|
|
y = 34 + (i >> 5);
|
|
}
|
|
else if( i >= 0x3C0 ) {
|
|
x = 29 - (i & 0x1F);
|
|
y = ((i-0x3C0) >> 5);
|
|
}
|
|
else {
|
|
x = 27 - ((i-0x40) >> 5);
|
|
y = 2 + ((i-0x40) & 0x1F);
|
|
}
|
|
if( (y >= 0) && (y < 36) && (x >= 0) && (x < 28) )
|
|
vchar_to_i_[i] = y*28 + x;
|
|
else
|
|
vchar_to_i_[i] = 0x3FF;
|
|
}
|
|
}
|
|
|
|
void reset_PacmanMachine(void)
|
|
{
|
|
int i;
|
|
|
|
z80_reset();
|
|
output_devices_ = 0;
|
|
interrupt_vector_ = 0;
|
|
|
|
rb->memset( ram_+0x4000, 0, 0x1000 );
|
|
rb->memset( color_mem_, 0, sizeof(color_mem_) );
|
|
rb->memset( video_mem_, 0, sizeof(video_mem_) );
|
|
rb->memset( dirty_, 0, sizeof(dirty_) );
|
|
|
|
for( i=0; i<8; i++ ) {
|
|
sprites_[i].color = 0;
|
|
sprites_[i].x = ScreenWidth;
|
|
}
|
|
}
|
|
|
|
/*
|
|
Run the machine for one frame.
|
|
*/
|
|
int run(void)
|
|
{
|
|
/* Run until the CPU has executed the number of cycles per frame
|
|
(the function returns the number of "extra" cycles spent by the
|
|
last instruction but that is not really important here) */
|
|
|
|
unsigned extraCycles = z80_run( CpuCyclesPerFrame );
|
|
|
|
/* Reset the CPU cycle counter to make sure it doesn't overflow,
|
|
also take into account the extra cycles from the previous run */
|
|
|
|
setCycles( extraCycles );
|
|
|
|
/* If interrupts are enabled, force a CPU interrupt with the vector
|
|
set by the program */
|
|
|
|
if( output_devices_ & InterruptEnabled ) {
|
|
z80_interrupt( interrupt_vector_ );
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/** Returns the status of the coin lockout door. */
|
|
static unsigned char getCoinLockout(void) {
|
|
return output_devices_ & CoinLockout ? 1 : 0;
|
|
}
|
|
|
|
static void decodeCharByte( unsigned char b, unsigned char * charbuf, int charx, int chary, int charwidth )
|
|
{
|
|
int i;
|
|
|
|
for( i=3; i>=0; i-- ) {
|
|
charbuf[charx+(chary+i)*charwidth] = (b & 1) | ((b >> 3) & 2);
|
|
b >>= 1;
|
|
}
|
|
}
|
|
|
|
static void decodeCharLine( unsigned char * src, unsigned char * charbuf, int charx, int chary, int charwidth )
|
|
{
|
|
int x;
|
|
|
|
for( x=7; x>=0; x-- ) {
|
|
decodeCharByte( *src++, charbuf, x+charx, chary, charwidth );
|
|
}
|
|
}
|
|
|
|
static void decodeCharSet( unsigned char * mem, unsigned char * charset )
|
|
{
|
|
int i;
|
|
|
|
for( i=0; i<256; i++ ) {
|
|
unsigned char * src = mem + 16*i;
|
|
unsigned char * dst = charset + 64*i;
|
|
|
|
decodeCharLine( src, dst, 0, 4, 8 );
|
|
decodeCharLine( src+8, dst, 0, 0, 8 );
|
|
}
|
|
}
|
|
|
|
static void decodeSprites( unsigned char * mem, unsigned char * sprite_data )
|
|
{
|
|
int i;
|
|
|
|
for( i=0; i<64; i++ ) {
|
|
unsigned char * src = mem + i*64;
|
|
unsigned char * dst = sprite_data + 256*i;
|
|
|
|
decodeCharLine( src , dst, 8, 12, 16 );
|
|
decodeCharLine( src+ 8, dst, 8, 0, 16 );
|
|
decodeCharLine( src+16, dst, 8, 4, 16 );
|
|
decodeCharLine( src+24, dst, 8, 8, 16 );
|
|
decodeCharLine( src+32, dst, 0, 12, 16 );
|
|
decodeCharLine( src+40, dst, 0, 0, 16 );
|
|
decodeCharLine( src+48, dst, 0, 4, 16 );
|
|
decodeCharLine( src+56, dst, 0, 8, 16 );
|
|
}
|
|
}
|
|
|
|
/*
|
|
Decode one byte from the encoded color palette.
|
|
|
|
An encoded palette byte contains RGB information bit-packed as follows:
|
|
|
|
bit: 7 6 5 4 3 2 1 0
|
|
color: b b g g g r r r
|
|
*/
|
|
static unsigned decodePaletteByte( unsigned char value )
|
|
{
|
|
unsigned bit0, bit1, bit2;
|
|
unsigned red, green, blue;
|
|
|
|
bit0 = (value >> 0) & 0x01;
|
|
bit1 = (value >> 1) & 0x01;
|
|
bit2 = (value >> 2) & 0x01;
|
|
red = 0x21 * bit0 + 0x47 * bit1 + 0x97 * bit2;
|
|
|
|
bit0 = (value >> 3) & 0x01;
|
|
bit1 = (value >> 4) & 0x01;
|
|
bit2 = (value >> 5) & 0x01;
|
|
green = 0x21 * bit0 + 0x47 * bit1 + 0x97 * bit2;
|
|
|
|
bit0 = 0;
|
|
bit1 = (value >> 6) & 0x01;
|
|
bit2 = (value >> 7) & 0x01;
|
|
blue = 0x21 * bit0 + 0x47 * bit1 + 0x97 * bit2;
|
|
|
|
return (blue << 16 ) | (green << 8) | red;
|
|
}
|
|
|
|
void decodeROMs(void)
|
|
{
|
|
unsigned decoded_palette[0x20];
|
|
unsigned c;
|
|
|
|
int i;
|
|
|
|
decodeCharSet( charset_rom_, charmap_ );
|
|
decodeSprites( spriteset_rom_, spritemap_ );
|
|
|
|
for( i=0x00; i<0x20; i++ ) {
|
|
decoded_palette[i] = decodePaletteByte( palette_data_[i] );
|
|
}
|
|
for( i=0; i<256; i++ ) {
|
|
c = decoded_palette[ color_data_[i] & 0x0F ];
|
|
#ifdef HAVE_LCD_COLOR
|
|
palette[i] = FB_RGBPACK((unsigned char) (c),
|
|
(unsigned char) (c >> 8),
|
|
(unsigned char) (c >> 16));
|
|
#else
|
|
palette[i] = rgb_to_gray((unsigned char) (c),
|
|
(unsigned char) (c >> 8),
|
|
(unsigned char) (c >> 16) );
|
|
#endif
|
|
}
|
|
|
|
#if defined(HAVE_LCD_MODES) && (HAVE_LCD_MODES & LCD_MODE_PAL256)
|
|
rb->lcd_pal256_update_pal(palette);
|
|
#endif
|
|
}
|
|
|
|
static void getDeviceInfo( enum InputDevice device, unsigned char * mask, unsigned char ** port )
|
|
{
|
|
static unsigned char MaskInfo[] = {
|
|
0x01 , // Joy1_Up
|
|
0x02 , // Joy1_Left
|
|
0x04 , // Joy1_Right
|
|
0x08 , // Joy1_Down
|
|
0x10 , // Switch_RackAdvance
|
|
0x20 , // CoinSlot_1
|
|
0x40 , // CoinSlot_2
|
|
0x80 , // Switch_AddCredit
|
|
0x01 , // Joy2_Up
|
|
0x02 , // Joy2_Left
|
|
0x04 , // Joy2_Right
|
|
0x08 , // Joy2_Down
|
|
0x10 , // Switch_Test
|
|
0x20 , // Key_OnePlayer
|
|
0x40 , // Key_TwoPlayers
|
|
0x80 // Switch_CocktailMode
|
|
};
|
|
|
|
*mask = MaskInfo[device];
|
|
|
|
switch( device ) {
|
|
case Joy1_Up:
|
|
case Joy1_Left:
|
|
case Joy1_Right:
|
|
case Joy1_Down:
|
|
case Switch_RackAdvance:
|
|
case CoinSlot_1:
|
|
case CoinSlot_2:
|
|
case Switch_AddCredit:
|
|
*port = &port1_;
|
|
break;
|
|
case Joy2_Up:
|
|
case Joy2_Left:
|
|
case Joy2_Right:
|
|
case Joy2_Down:
|
|
case Switch_Test:
|
|
case Key_OnePlayer:
|
|
case Key_TwoPlayers:
|
|
case Switch_CocktailMode:
|
|
*port = &port2_;
|
|
break;
|
|
default:
|
|
*port = 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
static enum InputDeviceMode getDeviceMode( enum InputDevice device )
|
|
{
|
|
unsigned char mask;
|
|
unsigned char * port;
|
|
|
|
getDeviceInfo( device, &mask, &port );
|
|
|
|
return (*port & mask) == 0 ? DeviceOn : DeviceOff;
|
|
}
|
|
|
|
/*
|
|
Fire an input event, telling the emulator for example
|
|
that the joystick has been released from the down position.
|
|
*/
|
|
void setDeviceMode( enum InputDevice device, enum InputDeviceMode mode )
|
|
{
|
|
if( (getCoinLockout() == 0) && ((device == CoinSlot_1)||(device == CoinSlot_2)||(device == Switch_AddCredit)) ) {
|
|
// Coin slots are locked, ignore command and exit
|
|
return;
|
|
}
|
|
|
|
unsigned char mask;
|
|
unsigned char * port;
|
|
|
|
getDeviceInfo( device, &mask, &port );
|
|
|
|
if( mode == DeviceOn )
|
|
*port &= ~mask;
|
|
else if( mode == DeviceOff )
|
|
*port |= mask;
|
|
else if( mode == DeviceToggle )
|
|
*port ^= mask;
|
|
}
|
|
|
|
void setDipSwitches( unsigned value ) {
|
|
dip_switches_ = (unsigned char) value;
|
|
|
|
setDeviceMode( Switch_RackAdvance, value & DipRackAdvance_Auto ? DeviceOn : DeviceOff );
|
|
setDeviceMode( Switch_Test, value & DipMode_Test ? DeviceOn : DeviceOff );
|
|
setDeviceMode( Switch_CocktailMode, value & DipCabinet_Cocktail ? DeviceOn : DeviceOff );
|
|
}
|
|
|
|
unsigned getDipSwitches(void) {
|
|
unsigned result = dip_switches_;
|
|
|
|
if( getDeviceMode(Switch_RackAdvance) == DeviceOn ) result |= DipRackAdvance_Auto;
|
|
if( getDeviceMode(Switch_Test) == DeviceOn ) result |= DipMode_Test;
|
|
if( getDeviceMode(Switch_CocktailMode) == DeviceOn ) result |= DipCabinet_Cocktail;
|
|
|
|
return result;
|
|
}
|
|
|
|
#if defined (CPU_COLDFIRE)
|
|
extern void drawChar( unsigned char * buffer, int index, int ox, int oy, int color );
|
|
#else
|
|
static inline void drawChar( unsigned char * buffer, int index, int ox, int oy, int color )
|
|
{
|
|
int x,y;
|
|
|
|
/* Make the index point to the character offset into the character table */
|
|
unsigned char * chrmap = charmap_ + index*64;
|
|
buffer += ox + oy*224; /* Make the buffer point to the character position*/
|
|
color = (color & 0x3F)*4;
|
|
|
|
if( color == 0 )
|
|
{
|
|
for( y=7; y>=0; y-- )
|
|
{
|
|
rb->memset( buffer, 0, 8 );
|
|
buffer += ScreenWidth;
|
|
};
|
|
return;
|
|
};
|
|
|
|
if( output_devices_ & FlipScreen ) {
|
|
// Flip character
|
|
buffer += 7*ScreenWidth;
|
|
for( y=7; y>=0; y-- ) {
|
|
for( x=7; x>=0; x-- ) {
|
|
*buffer++ = (*chrmap++) + color;
|
|
}
|
|
buffer -= ScreenWidth + 8; // Go to the next line
|
|
}
|
|
}
|
|
else {
|
|
for( y=7; y>=0; y-- ) {
|
|
for( x=7; x>=0; x-- ) {
|
|
*buffer++ = (*chrmap++) + color;
|
|
}
|
|
buffer += ScreenWidth - 8; // Go to the next line
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
static inline void drawSprite( unsigned char * buffer, int index )
|
|
{
|
|
struct PacmanSprite ps = sprites_[index];
|
|
int x,y;
|
|
char * s, * s2;
|
|
|
|
// Exit now if sprite not visible at all
|
|
if( (ps.color == 0) || (ps.x >= ScreenWidth) || (ps.y < 16) || (ps.y >= (ScreenHeight-32)) ) {
|
|
return;
|
|
}
|
|
|
|
// Clip the sprite coordinates to cut the parts that fall off the screen
|
|
int start_x = (ps.x < 0) ? 0 : ps.x;
|
|
int end_x = (ps.x < (ScreenWidth-16)) ? ps.x+15 : ScreenWidth-1;
|
|
|
|
// Prepare variables for drawing
|
|
int color = (ps.color & 0x3F)*4;
|
|
unsigned char * spritemap_base = spritemap_ + ((ps.n & 0x3F)*256);
|
|
|
|
buffer += ScreenWidth*ps.y;
|
|
|
|
dirty_[(start_x >> 3) + (ps.y >> 3)*28] = 1;
|
|
dirty_[(start_x >> 3) + 1 + (ps.y >> 3)*28] = 1;
|
|
dirty_[(end_x >> 3) + (ps.y >> 3)*28] = 1;
|
|
dirty_[(start_x >> 3) + ((ps.y >> 3)+1)*28] = 1;
|
|
dirty_[(start_x >> 3) + 1 + ((ps.y >> 3)+1)*28] = 1;
|
|
dirty_[(end_x >> 3) + ((ps.y >> 3)+1)*28] = 1;
|
|
dirty_[(start_x >> 3) + ((ps.y+15) >> 3)*28] = 1;
|
|
dirty_[(start_x >> 3) + 1 + ((ps.y+15) >> 3)*28] = 1;
|
|
dirty_[(end_x >> 3) + ((ps.y+15) >> 3)*28] = 1;
|
|
|
|
// Draw the 16x16 sprite
|
|
if( ps.mode == 0 ) { // Normal
|
|
s2 = spritemap_base + start_x-ps.x;
|
|
// Draw the 16x16 sprite
|
|
for( y=15; y>=0; y-- ) {
|
|
s = s2;
|
|
for( x=start_x; x<=end_x; x++, s++ ) {
|
|
if( *s ) {
|
|
buffer[x] = color + *s;
|
|
}
|
|
}
|
|
buffer += ScreenWidth;
|
|
s2 += 16;
|
|
}
|
|
} else if( ps.mode == 1 ) { // Flip Y
|
|
s2 = spritemap_base + start_x-ps.x + 240;
|
|
for( y=15; y>=0; y-- ) {
|
|
s = s2;
|
|
for( x=start_x; x<=end_x; x++, s++ ) {
|
|
if( *s ) {
|
|
buffer[x] = color + *s;
|
|
}
|
|
}
|
|
buffer += ScreenWidth;
|
|
s2 -= 16;
|
|
}
|
|
} else if( ps.mode == 2 ) { // Flip X
|
|
s2 = spritemap_base + 15 + ps.x-start_x;
|
|
for( y=15; y>=-0; y-- ) {
|
|
s = s2;
|
|
for( x=start_x; x<=end_x; x++, s-- ) {
|
|
if( *s ) {
|
|
buffer[x] = color + *s;
|
|
}
|
|
}
|
|
buffer += ScreenWidth;
|
|
s2 += 16;
|
|
}
|
|
} else { // Flip X and Y
|
|
s2 = spritemap_base + 255 + ps.x-start_x;
|
|
for( y=15; y>=0; y-- ) {
|
|
s = s2;
|
|
for( x=start_x; x<=end_x; x++, s-- ) {
|
|
if( *s ) {
|
|
buffer[x] = color + *s;
|
|
}
|
|
}
|
|
buffer += ScreenWidth;
|
|
s2 -= 16;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
Draw the video into the specified buffer.
|
|
*/
|
|
bool renderBackground( unsigned char * buffer )
|
|
{
|
|
unsigned char * video = video_mem_;
|
|
unsigned char * color = color_mem_;
|
|
unsigned char * dirty = dirty_;
|
|
int x,y;
|
|
bool changed=false;
|
|
|
|
// Draw the background first...
|
|
if( output_devices_ & FlipScreen ) {
|
|
for( y=ScreenHeight-CharHeight; y>=0; y-=CharHeight ) {
|
|
for( x=ScreenWidth-CharWidth; x>=0; x-=CharWidth ) {
|
|
if (*dirty) {
|
|
drawChar( buffer, *video++, x, y, *color++ );
|
|
*(dirty++)=0;
|
|
changed=true;
|
|
} else {
|
|
dirty++;
|
|
video++;
|
|
color++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
for( y=0; y<ScreenHeight; y+=CharHeight ) {
|
|
for( x=0; x<ScreenWidth; x+=CharWidth ) {
|
|
if (*dirty) {
|
|
drawChar( buffer, *video++, x, y, *color++ );
|
|
*(dirty++)=0;
|
|
changed=true;
|
|
} else {
|
|
dirty++;
|
|
video++;
|
|
color++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return changed;
|
|
}
|
|
|
|
void renderSprites( unsigned char * buffer )
|
|
{
|
|
int i;
|
|
|
|
// ...then add the sprites
|
|
for( i=7; i>=0; i-- ) {
|
|
drawSprite( buffer, i );
|
|
}
|
|
}
|
|
|
|
void playSound( int16_t * buf, int len )
|
|
{
|
|
/* Clear the buffer */
|
|
memset( buf, 0, sizeof (int16_t)*len);
|
|
|
|
/* Exit now if sound is disabled */
|
|
if( (output_devices_ & SoundEnabled) == 0 )
|
|
return;
|
|
|
|
/* Let the chip play the sound */
|
|
wsg3_play_sound( buf, len );
|
|
}
|
|
|
|
/* Enables/disables the speed hack. */
|
|
/* rockbox: not used
|
|
int setSpeedHack( int enabled )
|
|
{
|
|
int result = 0;
|
|
|
|
if( enabled ) {
|
|
if( (ram_[0x180B] == 0xBE) && (ram_[0x1FFD] == 0x00) ) {
|
|
// Patch the ROM to activate the speed hack
|
|
ram_[0x180B] = 0x01; // Activate speed hack
|
|
ram_[0x1FFD] = 0xBD; // Fix ROM checksum
|
|
|
|
result = 1;
|
|
}
|
|
}
|
|
else {
|
|
if( (ram_[0x180B] == 0x01) && (ram_[0x1FFD] == 0xBD) ) {
|
|
// Restore the patched ROM locations
|
|
ram_[0x180B] = 0xBE;
|
|
ram_[0x1FFD] = 0x00;
|
|
|
|
result = 1;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
*/
|