mirror of
https://github.com/holub/mame
synced 2025-05-18 19:49:35 +03:00
Removing no longer needed SNES HLE code [R. Belmont]
This commit is contained in:
R. Belmont
parent
b219fb7b69
commit
ed6bd9cd5f
5
.gitattributes
vendored
5
.gitattributes
vendored
@ -3538,11 +3538,6 @@ src/mame/machine/snes7110.c svneol=native#text/plain
|
||||
src/mame/machine/snesbsx.c svneol=native#text/plain
|
||||
src/mame/machine/snescx4.c svneol=native#text/plain
|
||||
src/mame/machine/snescx4.h svneol=native#text/plain
|
||||
src/mame/machine/snesdsp1.c svneol=native#text/plain
|
||||
src/mame/machine/snesdsp2.c svneol=native#text/plain
|
||||
src/mame/machine/snesdsp3.c svneol=native#text/plain
|
||||
src/mame/machine/snesdsp4.c svneol=native#text/plain
|
||||
src/mame/machine/snesdsp4.h svneol=native#text/plain
|
||||
src/mame/machine/snesobc1.c svneol=native#text/plain
|
||||
src/mame/machine/snesrtc.c svneol=native#text/plain
|
||||
src/mame/machine/snessdd1.c svneol=native#text/plain
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,412 +0,0 @@
|
||||
/***************************************************************************
|
||||
|
||||
snesdsp2.c
|
||||
|
||||
File to handle emulation of the SNES "DSP-2" add-on chip.
|
||||
|
||||
Original C++ code by byuu, based on research by Overload.
|
||||
Byuu's code is released under GNU General Public License
|
||||
version 2 as published by the Free Software Foundation.
|
||||
The implementation below is released under the MAME license
|
||||
for use in MAME, MESS and derivatives by permission of the
|
||||
author
|
||||
|
||||
***************************************************************************/
|
||||
|
||||
struct _snes_dsp2_state
|
||||
{
|
||||
int waiting_for_command;
|
||||
int command;
|
||||
int in_count, in_index;
|
||||
int out_count, out_index;
|
||||
|
||||
UINT8 parameters[512];
|
||||
UINT8 output[512];
|
||||
|
||||
UINT8 op05transparent;
|
||||
int op05haslen;
|
||||
int op05len;
|
||||
int op06haslen;
|
||||
int op06len;
|
||||
UINT16 op09word1;
|
||||
UINT16 op09word2;
|
||||
int op0dhaslen;
|
||||
int op0doutlen;
|
||||
int op0dinlen;
|
||||
};
|
||||
|
||||
static struct _snes_dsp2_state dsp2_state;
|
||||
|
||||
|
||||
static void dsp2_register_save(running_machine *machine);
|
||||
|
||||
//convert bitmap to bitplane tile
|
||||
static void dsp2_op01( void )
|
||||
{
|
||||
//op01 size is always 32 bytes input and output
|
||||
//the hardware does strange things if you vary the size
|
||||
|
||||
unsigned char c0, c1, c2, c3;
|
||||
unsigned char *p1 = dsp2_state.parameters;
|
||||
unsigned char *p2a = dsp2_state.output;
|
||||
unsigned char *p2b = dsp2_state.output + 16; //halfway
|
||||
int j;
|
||||
|
||||
//process 8 blocks of 4 bytes each
|
||||
for (j = 0; j < 8; j++)
|
||||
{
|
||||
c0 = *p1++;
|
||||
c1 = *p1++;
|
||||
c2 = *p1++;
|
||||
c3 = *p1++;
|
||||
|
||||
*p2a++ = (c0 & 0x10) << 3 |
|
||||
(c0 & 0x01) << 6 |
|
||||
(c1 & 0x10) << 1 |
|
||||
(c1 & 0x01) << 4 |
|
||||
(c2 & 0x10) >> 1 |
|
||||
(c2 & 0x01) << 2 |
|
||||
(c3 & 0x10) >> 3 |
|
||||
(c3 & 0x01);
|
||||
|
||||
*p2a++ = (c0 & 0x20) << 2 |
|
||||
(c0 & 0x02) << 5 |
|
||||
(c1 & 0x20) |
|
||||
(c1 & 0x02) << 3 |
|
||||
(c2 & 0x20) >> 2 |
|
||||
(c2 & 0x02) << 1 |
|
||||
(c3 & 0x20) >> 4 |
|
||||
(c3 & 0x02) >> 1;
|
||||
|
||||
*p2b++ = (c0 & 0x40) << 1 |
|
||||
(c0 & 0x04) << 4 |
|
||||
(c1 & 0x40) >> 1 |
|
||||
(c1 & 0x04) << 2 |
|
||||
(c2 & 0x40) >> 3 |
|
||||
(c2 & 0x04) |
|
||||
(c3 & 0x40) >> 5 |
|
||||
(c3 & 0x04) >> 2;
|
||||
|
||||
*p2b++ = (c0 & 0x80) |
|
||||
(c0 & 0x08) << 3 |
|
||||
(c1 & 0x80) >> 2 |
|
||||
(c1 & 0x08) << 1 |
|
||||
(c2 & 0x80) >> 4 |
|
||||
(c2 & 0x08) >> 1 |
|
||||
(c3 & 0x80) >> 6 |
|
||||
(c3 & 0x08) >> 3;
|
||||
}
|
||||
}
|
||||
|
||||
//set transparent color
|
||||
static void dsp2_op03( void )
|
||||
{
|
||||
dsp2_state.op05transparent = dsp2_state.parameters[0];
|
||||
}
|
||||
|
||||
//replace bitmap using transparent color
|
||||
static void dsp2_op05( void )
|
||||
{
|
||||
UINT8 color;
|
||||
// Overlay bitmap with transparency.
|
||||
// Input:
|
||||
//
|
||||
// Bitmap 1: i[0] <=> i[size-1]
|
||||
// Bitmap 2: i[size] <=> i[2*size-1]
|
||||
//
|
||||
// Output:
|
||||
//
|
||||
// Bitmap 3: o[0] <=> o[size-1]
|
||||
//
|
||||
// Processing:
|
||||
//
|
||||
// Process all 4-bit pixels (nibbles) in the bitmap
|
||||
//
|
||||
// if ( BM2_pixel == transparent_color )
|
||||
// pixelout = BM1_pixel
|
||||
// else
|
||||
// pixelout = BM2_pixel
|
||||
|
||||
// The max size bitmap is limited to 255 because the size parameter is a byte
|
||||
// I think size=0 is an error. The behavior of the chip on size=0 is to
|
||||
// return the last value written to DR if you read DR on Op05 with
|
||||
// size = 0. I don't think it's worth implementing this quirk unless it's
|
||||
// proven necessary.
|
||||
|
||||
unsigned char c1, c2;
|
||||
unsigned char *p1 = dsp2_state.parameters;
|
||||
unsigned char *p2 = dsp2_state.parameters + dsp2_state.op05len;
|
||||
unsigned char *p3 = dsp2_state.output;
|
||||
int n;
|
||||
|
||||
color = dsp2_state.op05transparent & 0x0f;
|
||||
|
||||
for (n = 0; n < dsp2_state.op05len; n++)
|
||||
{
|
||||
c1 = *p1++;
|
||||
c2 = *p2++;
|
||||
*p3++ = (((c2 >> 4) == color) ? c1 & 0xf0 : c2 & 0xf0) |
|
||||
(((c2 & 0x0f) == color) ? c1 & 0x0f : c2 & 0x0f);
|
||||
}
|
||||
}
|
||||
|
||||
//reverse bitmap
|
||||
static void dsp2_op06( void )
|
||||
{
|
||||
// Input:
|
||||
// size
|
||||
// bitmap
|
||||
int i, j;
|
||||
for (i = 0, j = dsp2_state.op06len - 1; i < dsp2_state.op06len; i++, j--)
|
||||
{
|
||||
dsp2_state.output[j] = (dsp2_state.parameters[i] << 4) | (dsp2_state.parameters[i] >> 4);
|
||||
}
|
||||
}
|
||||
|
||||
//multiply
|
||||
static void dsp2_op09( void )
|
||||
{
|
||||
UINT32 r = 0;
|
||||
dsp2_state.out_count = 4;
|
||||
|
||||
dsp2_state.op09word1 = dsp2_state.parameters[0] | (dsp2_state.parameters[1] << 8);
|
||||
dsp2_state.op09word2 = dsp2_state.parameters[2] | (dsp2_state.parameters[3] << 8);
|
||||
|
||||
r = dsp2_state.op09word1 * dsp2_state.op09word2;
|
||||
dsp2_state.output[0] = r;
|
||||
dsp2_state.output[1] = r >> 8;
|
||||
dsp2_state.output[2] = r >> 16;
|
||||
dsp2_state.output[3] = r >> 24;
|
||||
}
|
||||
|
||||
//scale bitmap
|
||||
static void dsp2_op0d( void )
|
||||
{
|
||||
// Bit accurate hardware algorithm - uses fixed point math
|
||||
// This should match the DSP2 Op0D output exactly
|
||||
// I wouldn't recommend using this unless you're doing hardware debug.
|
||||
// In some situations it has small visual artifacts that
|
||||
// are not readily apparent on a TV screen but show up clearly
|
||||
// on a monitor. Use Overload's scaling instead.
|
||||
// This is for hardware verification testing.
|
||||
//
|
||||
// One note: the HW can do odd byte scaling but since we divide
|
||||
// by two to get the count of bytes this won't work well for
|
||||
// odd byte scaling (in any of the current algorithm implementations).
|
||||
// So far I haven't seen Dungeon Master use it.
|
||||
// If it does we can adjust the parameters and code to work with it
|
||||
|
||||
UINT32 multiplier; // Any size int >= 32-bits
|
||||
UINT32 pixloc; // match size of multiplier
|
||||
int i, j;
|
||||
UINT8 pixelarray[512];
|
||||
if (dsp2_state.op0dinlen <= dsp2_state.op0doutlen)
|
||||
{
|
||||
multiplier = 0x10000; // In our self defined fixed point 0x10000 == 1
|
||||
}
|
||||
else
|
||||
{
|
||||
multiplier = (dsp2_state.op0dinlen << 17) / ((dsp2_state.op0doutlen << 1) + 1);
|
||||
}
|
||||
|
||||
pixloc = 0;
|
||||
for (i = 0; i < dsp2_state.op0doutlen * 2; i++)
|
||||
{
|
||||
j = pixloc >> 16;
|
||||
|
||||
if (j & 1)
|
||||
pixelarray[i] = (dsp2_state.parameters[j >> 1] & 0x0f);
|
||||
else
|
||||
pixelarray[i] = (dsp2_state.parameters[j >> 1] & 0xf0) >> 4;
|
||||
|
||||
pixloc += multiplier;
|
||||
}
|
||||
|
||||
for (i = 0; i < dsp2_state.op0doutlen; i++)
|
||||
{
|
||||
dsp2_state.output[i] = (pixelarray[i << 1] << 4) | pixelarray[(i << 1) + 1];
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void dsp2_init( running_machine *machine )
|
||||
{
|
||||
dsp2_state.waiting_for_command = 1;
|
||||
dsp2_state.in_count = 0;
|
||||
dsp2_state.in_index = 0;
|
||||
dsp2_state.out_count = 0;
|
||||
dsp2_state.out_index = 0;
|
||||
|
||||
memset(dsp2_state.parameters, 0 , ARRAY_LENGTH(dsp2_state.parameters));
|
||||
memset(dsp2_state.output, 0 , ARRAY_LENGTH(dsp2_state.output));
|
||||
|
||||
dsp2_state.op05transparent = 0;
|
||||
dsp2_state.op05haslen = 0;
|
||||
dsp2_state.op05len = 0;
|
||||
dsp2_state.op06haslen = 0;
|
||||
dsp2_state.op06len = 0;
|
||||
dsp2_state.op09word1 = 0;
|
||||
dsp2_state.op09word2 = 0;
|
||||
dsp2_state.op0dhaslen = 0;
|
||||
dsp2_state.op0doutlen = 0;
|
||||
dsp2_state.op0dinlen = 0;
|
||||
|
||||
dsp2_register_save(machine);
|
||||
}
|
||||
|
||||
static UINT8 dsp2_dr_read( void )
|
||||
{
|
||||
UINT8 r = 0xff;
|
||||
if (dsp2_state.out_count)
|
||||
{
|
||||
r = dsp2_state.output[dsp2_state.out_index++];
|
||||
dsp2_state.out_index &= 511;
|
||||
if (dsp2_state.out_count == dsp2_state.out_index)
|
||||
dsp2_state.out_count = 0;
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
static void dsp2_dr_write(UINT8 data)
|
||||
{
|
||||
if (dsp2_state.waiting_for_command)
|
||||
{
|
||||
dsp2_state.command = data;
|
||||
dsp2_state.in_index = 0;
|
||||
dsp2_state.waiting_for_command = 0;
|
||||
|
||||
switch (data)
|
||||
{
|
||||
case 0x01: dsp2_state.in_count = 32; break;
|
||||
case 0x03: dsp2_state.in_count = 1; break;
|
||||
case 0x05: dsp2_state.in_count = 1; break;
|
||||
case 0x06: dsp2_state.in_count = 1; break;
|
||||
case 0x07: break;
|
||||
case 0x08: break;
|
||||
case 0x09: dsp2_state.in_count = 4; break;
|
||||
case 0x0d: dsp2_state.in_count = 2; break;
|
||||
case 0x0f: dsp2_state.in_count = 0; break;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
dsp2_state.parameters[dsp2_state.in_index++] = data;
|
||||
dsp2_state.in_index &= 511;
|
||||
}
|
||||
|
||||
if (dsp2_state.in_count == dsp2_state.in_index)
|
||||
{
|
||||
dsp2_state.waiting_for_command = 1;
|
||||
dsp2_state.out_index = 0;
|
||||
switch (dsp2_state.command)
|
||||
{
|
||||
case 0x01:
|
||||
dsp2_state.out_count = 32;
|
||||
dsp2_op01();
|
||||
break;
|
||||
|
||||
case 0x03:
|
||||
dsp2_op03();
|
||||
break;
|
||||
|
||||
case 0x05:
|
||||
if (dsp2_state.op05haslen)
|
||||
{
|
||||
dsp2_state.op05haslen = 0;
|
||||
dsp2_state.out_count = dsp2_state.op05len;
|
||||
dsp2_op05();
|
||||
}
|
||||
else
|
||||
{
|
||||
dsp2_state.op05len = dsp2_state.parameters[0];
|
||||
dsp2_state.in_index = 0;
|
||||
dsp2_state.in_count = dsp2_state.op05len * 2;
|
||||
dsp2_state.op05haslen = 1;
|
||||
if (data)
|
||||
dsp2_state.waiting_for_command = 0;
|
||||
}
|
||||
break;
|
||||
|
||||
case 0x06:
|
||||
if (dsp2_state.op06haslen)
|
||||
{
|
||||
dsp2_state.op06haslen = 0;
|
||||
dsp2_state.out_count = dsp2_state.op06len;
|
||||
dsp2_op06();
|
||||
}
|
||||
else
|
||||
{
|
||||
dsp2_state.op06len = dsp2_state.parameters[0];
|
||||
dsp2_state.in_index = 0;
|
||||
dsp2_state.in_count = dsp2_state.op06len;
|
||||
dsp2_state.op06haslen = 1;
|
||||
if (data)
|
||||
dsp2_state.waiting_for_command = 0;
|
||||
}
|
||||
break;
|
||||
|
||||
case 0x07: break;
|
||||
case 0x08: break;
|
||||
|
||||
case 0x09:
|
||||
dsp2_op09();
|
||||
break;
|
||||
|
||||
case 0x0d:
|
||||
if (dsp2_state.op0dhaslen)
|
||||
{
|
||||
dsp2_state.op0dhaslen = 0;
|
||||
dsp2_state.out_count = dsp2_state.op0doutlen;
|
||||
dsp2_op0d();
|
||||
}
|
||||
else
|
||||
{
|
||||
dsp2_state.op0dinlen = dsp2_state.parameters[0];
|
||||
dsp2_state.op0doutlen = dsp2_state.parameters[1];
|
||||
dsp2_state.in_index = 0;
|
||||
dsp2_state.in_count = (dsp2_state.op0dinlen + 1) >> 1;
|
||||
dsp2_state.op0dhaslen = 1;
|
||||
if (data)
|
||||
dsp2_state.waiting_for_command = 0;
|
||||
}
|
||||
break;
|
||||
|
||||
case 0x0f:
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static UINT8 dsp2_sr_read( void )
|
||||
{
|
||||
return 0x00;
|
||||
}
|
||||
|
||||
static void dsp2_sr_write( UINT8 data )
|
||||
{
|
||||
// do nothing
|
||||
}
|
||||
|
||||
static void dsp2_register_save( running_machine *machine )
|
||||
{
|
||||
state_save_register_global(machine, dsp2_state.waiting_for_command);
|
||||
state_save_register_global(machine, dsp2_state.command);
|
||||
state_save_register_global(machine, dsp2_state.in_count);
|
||||
state_save_register_global(machine, dsp2_state.in_index);
|
||||
state_save_register_global(machine, dsp2_state.out_count);
|
||||
state_save_register_global(machine, dsp2_state.out_index);
|
||||
|
||||
state_save_register_global_array(machine, dsp2_state.parameters);
|
||||
state_save_register_global_array(machine, dsp2_state.output);
|
||||
|
||||
state_save_register_global(machine, dsp2_state.op05transparent);
|
||||
state_save_register_global(machine, dsp2_state.op05haslen);
|
||||
state_save_register_global(machine, dsp2_state.op05len);
|
||||
state_save_register_global(machine, dsp2_state.op06haslen);
|
||||
state_save_register_global(machine, dsp2_state.op06len);
|
||||
state_save_register_global(machine, dsp2_state.op09word1);
|
||||
state_save_register_global(machine, dsp2_state.op09word2);
|
||||
state_save_register_global(machine, dsp2_state.op0dhaslen);
|
||||
state_save_register_global(machine, dsp2_state.op0doutlen);
|
||||
state_save_register_global(machine, dsp2_state.op0dinlen);
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -1,100 +0,0 @@
|
||||
#ifndef SNESDSP4_H
|
||||
#define SNESDSP4_H
|
||||
|
||||
#define FALSE 0
|
||||
#define TRUE 1
|
||||
|
||||
|
||||
struct dsp4_t
|
||||
{
|
||||
UINT8 waiting4command;
|
||||
UINT8 half_command;
|
||||
UINT16 command;
|
||||
UINT32 in_count;
|
||||
UINT32 in_index;
|
||||
UINT32 out_count;
|
||||
UINT32 out_index;
|
||||
UINT8 parameters[512];
|
||||
UINT8 output[512];
|
||||
};
|
||||
|
||||
struct dsp4_vars_t
|
||||
{
|
||||
// op control
|
||||
INT8 Logic; // controls op flow
|
||||
|
||||
|
||||
// projection format
|
||||
INT16 lcv; // loop-control variable
|
||||
INT16 distance; // z-position into virtual world
|
||||
INT16 raster; // current raster line
|
||||
INT16 segments; // number of raster lines drawn
|
||||
|
||||
// 1.15.16 or 1.15.0 [sign, INTeger, fraction]
|
||||
INT32 world_x; // line of x-projection in world
|
||||
INT32 world_y; // line of y-projection in world
|
||||
INT32 world_dx; // projection line x-delta
|
||||
INT32 world_dy; // projection line y-delta
|
||||
INT16 world_ddx; // x-delta increment
|
||||
INT16 world_ddy; // y-delta increment
|
||||
INT32 world_xenv; // world x-shaping factor
|
||||
INT16 world_yofs; // world y-vertical scroll
|
||||
|
||||
INT16 view_x1; // current viewer-x
|
||||
INT16 view_y1; // current viewer-y
|
||||
INT16 view_x2; // future viewer-x
|
||||
INT16 view_y2; // future viewer-y
|
||||
INT16 view_dx; // view x-delta factor
|
||||
INT16 view_dy; // view y-delta factor
|
||||
INT16 view_xofs1; // current viewer x-vertical scroll
|
||||
INT16 view_yofs1; // current viewer y-vertical scroll
|
||||
INT16 view_xofs2; // future viewer x-vertical scroll
|
||||
INT16 view_yofs2; // future viewer y-vertical scroll
|
||||
INT16 view_yofsenv; // y-scroll shaping factor
|
||||
INT16 view_turnoff_x; // road turnoff data
|
||||
INT16 view_turnoff_dx; // road turnoff delta factor
|
||||
|
||||
|
||||
// drawing area
|
||||
|
||||
INT16 viewport_cx; // x-center of viewport window
|
||||
INT16 viewport_cy; // y-center of render window
|
||||
INT16 viewport_left; // x-left of viewport
|
||||
INT16 viewport_right; // x-right of viewport
|
||||
INT16 viewport_top; // y-top of viewport
|
||||
INT16 viewport_bottom; // y-bottom of viewport
|
||||
|
||||
|
||||
// sprite structure
|
||||
|
||||
INT16 sprite_x; // projected x-pos of sprite
|
||||
INT16 sprite_y; // projected y-pos of sprite
|
||||
INT16 sprite_attr; // obj attributes
|
||||
UINT8 sprite_size; // sprite size: 8x8 or 16x16
|
||||
INT16 sprite_clipy; // visible line to clip pixels off
|
||||
INT16 sprite_count;
|
||||
|
||||
// generic projection variables designed for
|
||||
// two solid polygons + two polygon sides
|
||||
|
||||
INT16 poly_clipLf[2][2]; // left clip boundary
|
||||
INT16 poly_clipRt[2][2]; // right clip boundary
|
||||
INT16 poly_ptr[2][2]; // HDMA structure pointers
|
||||
INT16 poly_raster[2][2]; // current raster line below horizon
|
||||
INT16 poly_top[2][2]; // top clip boundary
|
||||
INT16 poly_bottom[2][2]; // bottom clip boundary
|
||||
INT16 poly_cx[2][2]; // center for left/right points
|
||||
INT16 poly_start[2]; // current projection points
|
||||
INT16 poly_plane[2]; // previous z-plane distance
|
||||
|
||||
|
||||
// OAM
|
||||
INT16 OAM_attr[16]; // OAM (size,MSB) data
|
||||
INT16 OAM_index; // index into OAM table
|
||||
INT16 OAM_bits; // offset into OAM table
|
||||
|
||||
INT16 OAM_RowMax; // maximum number of tiles per 8 aligned pixels (row)
|
||||
INT16 OAM_Row[32]; // current number of tiles per row
|
||||
};
|
||||
|
||||
#endif
|
||||
Loading…
Reference in New Issue
Block a user