You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1076 lines
34 KiB
1076 lines
34 KiB
/*****************************************************************************\
|
|
Snes9x - Portable Super Nintendo Entertainment System (TM) emulator.
|
|
This file is licensed under the Snes9x License.
|
|
For further information, consult the LICENSE file in the root directory.
|
|
\*****************************************************************************/
|
|
|
|
#include <math.h>
|
|
#include "snes9x.h"
|
|
#include "memmap.h"
|
|
#include "sar.h"
|
|
|
|
static int16 C4SinTable[512] =
|
|
{
|
|
0, 402, 804, 1206, 1607, 2009, 2410, 2811,
|
|
3211, 3611, 4011, 4409, 4808, 5205, 5602, 5997,
|
|
6392, 6786, 7179, 7571, 7961, 8351, 8739, 9126,
|
|
9512, 9896, 10278, 10659, 11039, 11416, 11793, 12167,
|
|
12539, 12910, 13278, 13645, 14010, 14372, 14732, 15090,
|
|
15446, 15800, 16151, 16499, 16846, 17189, 17530, 17869,
|
|
18204, 18537, 18868, 19195, 19519, 19841, 20159, 20475,
|
|
20787, 21097, 21403, 21706, 22005, 22301, 22594, 22884,
|
|
23170, 23453, 23732, 24007, 24279, 24547, 24812, 25073,
|
|
25330, 25583, 25832, 26077, 26319, 26557, 26790, 27020,
|
|
27245, 27466, 27684, 27897, 28106, 28310, 28511, 28707,
|
|
28898, 29086, 29269, 29447, 29621, 29791, 29956, 30117,
|
|
30273, 30425, 30572, 30714, 30852, 30985, 31114, 31237,
|
|
31357, 31471, 31581, 31685, 31785, 31881, 31971, 32057,
|
|
32138, 32214, 32285, 32351, 32413, 32469, 32521, 32568,
|
|
32610, 32647, 32679, 32706, 32728, 32745, 32758, 32765,
|
|
32767, 32765, 32758, 32745, 32728, 32706, 32679, 32647,
|
|
32610, 32568, 32521, 32469, 32413, 32351, 32285, 32214,
|
|
32138, 32057, 31971, 31881, 31785, 31685, 31581, 31471,
|
|
31357, 31237, 31114, 30985, 30852, 30714, 30572, 30425,
|
|
30273, 30117, 29956, 29791, 29621, 29447, 29269, 29086,
|
|
28898, 28707, 28511, 28310, 28106, 27897, 27684, 27466,
|
|
27245, 27020, 26790, 26557, 26319, 26077, 25832, 25583,
|
|
25330, 25073, 24812, 24547, 24279, 24007, 23732, 23453,
|
|
23170, 22884, 22594, 22301, 22005, 21706, 21403, 21097,
|
|
20787, 20475, 20159, 19841, 19519, 19195, 18868, 18537,
|
|
18204, 17869, 17530, 17189, 16846, 16499, 16151, 15800,
|
|
15446, 15090, 14732, 14372, 14010, 13645, 13278, 12910,
|
|
12539, 12167, 11793, 11416, 11039, 10659, 10278, 9896,
|
|
9512, 9126, 8739, 8351, 7961, 7571, 7179, 6786,
|
|
6392, 5997, 5602, 5205, 4808, 4409, 4011, 3611,
|
|
3211, 2811, 2410, 2009, 1607, 1206, 804, 402,
|
|
0, -402, -804, -1206, -1607, -2009, -2410, -2811,
|
|
-3211, -3611, -4011, -4409, -4808, -5205, -5602, -5997,
|
|
-6392, -6786, -7179, -7571, -7961, -8351, -8739, -9126,
|
|
-9512, -9896, -10278, -10659, -11039, -11416, -11793, -12167,
|
|
-12539, -12910, -13278, -13645, -14010, -14372, -14732, -15090,
|
|
-15446, -15800, -16151, -16499, -16846, -17189, -17530, -17869,
|
|
-18204, -18537, -18868, -19195, -19519, -19841, -20159, -20475,
|
|
-20787, -21097, -21403, -21706, -22005, -22301, -22594, -22884,
|
|
-23170, -23453, -23732, -24007, -24279, -24547, -24812, -25073,
|
|
-25330, -25583, -25832, -26077, -26319, -26557, -26790, -27020,
|
|
-27245, -27466, -27684, -27897, -28106, -28310, -28511, -28707,
|
|
-28898, -29086, -29269, -29447, -29621, -29791, -29956, -30117,
|
|
-30273, -30425, -30572, -30714, -30852, -30985, -31114, -31237,
|
|
-31357, -31471, -31581, -31685, -31785, -31881, -31971, -32057,
|
|
-32138, -32214, -32285, -32351, -32413, -32469, -32521, -32568,
|
|
-32610, -32647, -32679, -32706, -32728, -32745, -32758, -32765,
|
|
-32767, -32765, -32758, -32745, -32728, -32706, -32679, -32647,
|
|
-32610, -32568, -32521, -32469, -32413, -32351, -32285, -32214,
|
|
-32138, -32057, -31971, -31881, -31785, -31685, -31581, -31471,
|
|
-31357, -31237, -31114, -30985, -30852, -30714, -30572, -30425,
|
|
-30273, -30117, -29956, -29791, -29621, -29447, -29269, -29086,
|
|
-28898, -28707, -28511, -28310, -28106, -27897, -27684, -27466,
|
|
-27245, -27020, -26790, -26557, -26319, -26077, -25832, -25583,
|
|
-25330, -25073, -24812, -24547, -24279, -24007, -23732, -23453,
|
|
-23170, -22884, -22594, -22301, -22005, -21706, -21403, -21097,
|
|
-20787, -20475, -20159, -19841, -19519, -19195, -18868, -18537,
|
|
-18204, -17869, -17530, -17189, -16846, -16499, -16151, -15800,
|
|
-15446, -15090, -14732, -14372, -14010, -13645, -13278, -12910,
|
|
-12539, -12167, -11793, -11416, -11039, -10659, -10278, -9896,
|
|
-9512, -9126, -8739, -8351, -7961, -7571, -7179, -6786,
|
|
-6392, -5997, -5602, -5205, -4808, -4409, -4011, -3611,
|
|
-3211, -2811, -2410, -2009, -1607, -1206, -804, -402
|
|
};
|
|
|
|
static int16 C4CosTable[512] =
|
|
{
|
|
32767, 32765, 32758, 32745, 32728, 32706, 32679, 32647,
|
|
32610, 32568, 32521, 32469, 32413, 32351, 32285, 32214,
|
|
32138, 32057, 31971, 31881, 31785, 31685, 31581, 31471,
|
|
31357, 31237, 31114, 30985, 30852, 30714, 30572, 30425,
|
|
30273, 30117, 29956, 29791, 29621, 29447, 29269, 29086,
|
|
28898, 28707, 28511, 28310, 28106, 27897, 27684, 27466,
|
|
27245, 27020, 26790, 26557, 26319, 26077, 25832, 25583,
|
|
25330, 25073, 24812, 24547, 24279, 24007, 23732, 23453,
|
|
23170, 22884, 22594, 22301, 22005, 21706, 21403, 21097,
|
|
20787, 20475, 20159, 19841, 19519, 19195, 18868, 18537,
|
|
18204, 17869, 17530, 17189, 16846, 16499, 16151, 15800,
|
|
15446, 15090, 14732, 14372, 14010, 13645, 13278, 12910,
|
|
12539, 12167, 11793, 11416, 11039, 10659, 10278, 9896,
|
|
9512, 9126, 8739, 8351, 7961, 7571, 7179, 6786,
|
|
6392, 5997, 5602, 5205, 4808, 4409, 4011, 3611,
|
|
3211, 2811, 2410, 2009, 1607, 1206, 804, 402,
|
|
0, -402, -804, -1206, -1607, -2009, -2410, -2811,
|
|
-3211, -3611, -4011, -4409, -4808, -5205, -5602, -5997,
|
|
-6392, -6786, -7179, -7571, -7961, -8351, -8739, -9126,
|
|
-9512, -9896, -10278, -10659, -11039, -11416, -11793, -12167,
|
|
-12539, -12910, -13278, -13645, -14010, -14372, -14732, -15090,
|
|
-15446, -15800, -16151, -16499, -16846, -17189, -17530, -17869,
|
|
-18204, -18537, -18868, -19195, -19519, -19841, -20159, -20475,
|
|
-20787, -21097, -21403, -21706, -22005, -22301, -22594, -22884,
|
|
-23170, -23453, -23732, -24007, -24279, -24547, -24812, -25073,
|
|
-25330, -25583, -25832, -26077, -26319, -26557, -26790, -27020,
|
|
-27245, -27466, -27684, -27897, -28106, -28310, -28511, -28707,
|
|
-28898, -29086, -29269, -29447, -29621, -29791, -29956, -30117,
|
|
-30273, -30425, -30572, -30714, -30852, -30985, -31114, -31237,
|
|
-31357, -31471, -31581, -31685, -31785, -31881, -31971, -32057,
|
|
-32138, -32214, -32285, -32351, -32413, -32469, -32521, -32568,
|
|
-32610, -32647, -32679, -32706, -32728, -32745, -32758, -32765,
|
|
-32767, -32765, -32758, -32745, -32728, -32706, -32679, -32647,
|
|
-32610, -32568, -32521, -32469, -32413, -32351, -32285, -32214,
|
|
-32138, -32057, -31971, -31881, -31785, -31685, -31581, -31471,
|
|
-31357, -31237, -31114, -30985, -30852, -30714, -30572, -30425,
|
|
-30273, -30117, -29956, -29791, -29621, -29447, -29269, -29086,
|
|
-28898, -28707, -28511, -28310, -28106, -27897, -27684, -27466,
|
|
-27245, -27020, -26790, -26557, -26319, -26077, -25832, -25583,
|
|
-25330, -25073, -24812, -24547, -24279, -24007, -23732, -23453,
|
|
-23170, -22884, -22594, -22301, -22005, -21706, -21403, -21097,
|
|
-20787, -20475, -20159, -19841, -19519, -19195, -18868, -18537,
|
|
-18204, -17869, -17530, -17189, -16846, -16499, -16151, -15800,
|
|
-15446, -15090, -14732, -14372, -14010, -13645, -13278, -12910,
|
|
-12539, -12167, -11793, -11416, -11039, -10659, -10278, -9896,
|
|
-9512, -9126, -8739, -8351, -7961, -7571, -7179, -6786,
|
|
-6392, -5997, -5602, -5205, -4808, -4409, -4011, -3611,
|
|
-3211, -2811, -2410, -2009, -1607, -1206, -804, -402,
|
|
0, 402, 804, 1206, 1607, 2009, 2410, 2811,
|
|
3211, 3611, 4011, 4409, 4808, 5205, 5602, 5997,
|
|
6392, 6786, 7179, 7571, 7961, 8351, 8739, 9126,
|
|
9512, 9896, 10278, 10659, 11039, 11416, 11793, 12167,
|
|
12539, 12910, 13278, 13645, 14010, 14372, 14732, 15090,
|
|
15446, 15800, 16151, 16499, 16846, 17189, 17530, 17869,
|
|
18204, 18537, 18868, 19195, 19519, 19841, 20159, 20475,
|
|
20787, 21097, 21403, 21706, 22005, 22301, 22594, 22884,
|
|
23170, 23453, 23732, 24007, 24279, 24547, 24812, 25073,
|
|
25330, 25583, 25832, 26077, 26319, 26557, 26790, 27020,
|
|
27245, 27466, 27684, 27897, 28106, 28310, 28511, 28707,
|
|
28898, 29086, 29269, 29447, 29621, 29791, 29956, 30117,
|
|
30273, 30425, 30572, 30714, 30852, 30985, 31114, 31237,
|
|
31357, 31471, 31581, 31685, 31785, 31881, 31971, 32057,
|
|
32138, 32214, 32285, 32351, 32413, 32469, 32521, 32568,
|
|
32610, 32647, 32679, 32706, 32728, 32745, 32758, 32765
|
|
};
|
|
|
|
static uint8 C4TestPattern[12 * 4] =
|
|
{
|
|
0x00, 0x00, 0x00, 0xff,
|
|
0xff, 0xff, 0x00, 0xff,
|
|
0x00, 0x00, 0x00, 0xff,
|
|
0xff, 0xff, 0x00, 0x00,
|
|
0xff, 0xff, 0x00, 0x00,
|
|
0x80, 0xff, 0xff, 0x7f,
|
|
0x00, 0x80, 0x00, 0xff,
|
|
0x7f, 0x00, 0xff, 0x7f,
|
|
0xff, 0x7f, 0xff, 0xff,
|
|
0x00, 0x00, 0x01, 0xff,
|
|
0xff, 0xfe, 0x00, 0x01,
|
|
0x00, 0xff, 0xfe, 0x00
|
|
};
|
|
|
|
static void C4ConvOAM (void);
|
|
static void C4DoScaleRotate (int);
|
|
static void C4DrawLine (int32, int32, int16, int32, int32, int16, uint8);
|
|
static void C4DrawWireFrame (void);
|
|
static void C4TransformLines (void);
|
|
static void C4BitPlaneWave (void);
|
|
static void C4SprDisintegrate (void);
|
|
static void C4ProcessSprites (void);
|
|
|
|
|
|
static void C4ConvOAM (void)
|
|
{
|
|
uint8 *OAMptr = Memory.C4RAM + (Memory.C4RAM[0x626] << 2);
|
|
for (uint8 *i = Memory.C4RAM + 0x1fd; i > OAMptr; i -= 4)
|
|
*i = 0xe0; // Clear OAM-to-be
|
|
|
|
uint8 *OAMptr2;
|
|
uint16 globalX, globalY;
|
|
int16 SprX, SprY;
|
|
uint8 SprName, SprAttr;
|
|
uint8 SprCount;
|
|
|
|
globalX = READ_WORD(Memory.C4RAM + 0x0621);
|
|
globalY = READ_WORD(Memory.C4RAM + 0x0623);
|
|
OAMptr2 = Memory.C4RAM + 0x200 + (Memory.C4RAM[0x626] >> 2);
|
|
|
|
#ifdef DEBUGGER
|
|
if (Memory.C4RAM[0x625] != 0)
|
|
printf("$6625=%02x, expected 00\n", Memory.C4RAM[0x625]);
|
|
if ((Memory.C4RAM[0x626] >> 2) != Memory.C4RAM[0x629])
|
|
printf("$6629=%02x, expected %02x\n", Memory.C4RAM[0x629], (Memory.C4RAM[0x626] >> 2));
|
|
if (((uint16) Memory.C4RAM[0x626] << 2) != READ_WORD(Memory.C4RAM + 0x627))
|
|
printf("$6627=%04x, expected %04x\n", READ_WORD(Memory.C4RAM + 0x627), ((uint16) Memory.C4RAM[0x626] << 2));
|
|
#endif
|
|
|
|
if (Memory.C4RAM[0x0620] != 0)
|
|
{
|
|
SprCount = 128 - Memory.C4RAM[0x626];
|
|
|
|
uint8 offset = (Memory.C4RAM[0x626] & 3) * 2;
|
|
uint8 *srcptr = Memory.C4RAM + 0x220;
|
|
|
|
for (int i = Memory.C4RAM[0x0620]; i > 0 && SprCount > 0; i--, srcptr += 16)
|
|
{
|
|
SprX = READ_WORD(srcptr) - globalX;
|
|
SprY = READ_WORD(srcptr + 2) - globalY;
|
|
SprName = srcptr[5];
|
|
SprAttr = srcptr[4] | srcptr[0x06]; // XXX: mask bits?
|
|
|
|
uint8 *sprptr = C4GetMemPointer(READ_3WORD(srcptr + 7));
|
|
if (*sprptr != 0)
|
|
{
|
|
int16 X, Y;
|
|
|
|
for (int SprCnt = *sprptr++; SprCnt > 0 && SprCount > 0; SprCnt--, sprptr += 4)
|
|
{
|
|
X = (int8) sprptr[1];
|
|
if (SprAttr & 0x40)
|
|
X = -X - ((sprptr[0] & 0x20) ? 16 : 8); // flip X
|
|
X += SprX;
|
|
|
|
if (X >= -16 && X <= 272)
|
|
{
|
|
Y = (int8) sprptr[2];
|
|
if (SprAttr & 0x80)
|
|
Y = -Y - ((sprptr[0] & 0x20) ? 16 : 8);
|
|
Y += SprY;
|
|
|
|
if (Y >= -16 && Y <= 224)
|
|
{
|
|
OAMptr[0] = X & 0xff;
|
|
OAMptr[1] = (uint8) Y;
|
|
OAMptr[2] = SprName + sprptr[3];
|
|
OAMptr[3] = SprAttr ^ (sprptr[0] & 0xc0); // XXX: Carry from SprName addition?
|
|
|
|
*OAMptr2 &= ~(3 << offset);
|
|
if (X & 0x100)
|
|
*OAMptr2 |= 1 << offset;
|
|
if (sprptr[0] & 0x20)
|
|
*OAMptr2 |= 2 << offset;
|
|
|
|
OAMptr += 4;
|
|
SprCount--;
|
|
|
|
offset = (offset + 2) & 6;
|
|
if (offset == 0)
|
|
OAMptr2++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
if (SprCount > 0)
|
|
{
|
|
// XXX: Should we be testing -16<=SprX<=272 and -16<=SprY<=224?
|
|
OAMptr[0] = (uint8) SprX;
|
|
OAMptr[1] = (uint8) SprY;
|
|
OAMptr[2] = SprName;
|
|
OAMptr[3] = SprAttr;
|
|
|
|
*OAMptr2 &= ~(3 << offset);
|
|
if (SprX & 0x100)
|
|
*OAMptr2 |= 3 << offset;
|
|
else
|
|
*OAMptr2 |= 2 << offset;
|
|
|
|
OAMptr += 4;
|
|
SprCount--;
|
|
|
|
offset = (offset + 2) & 6;
|
|
if (offset == 0)
|
|
OAMptr2++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void C4DoScaleRotate (int row_padding)
|
|
{
|
|
int16 A, B, C, D;
|
|
|
|
// Calculate matrix
|
|
int32 XScale = READ_WORD(Memory.C4RAM + 0x1f8f);
|
|
if (XScale & 0x8000)
|
|
XScale = 0x7fff;
|
|
|
|
int32 YScale = READ_WORD(Memory.C4RAM + 0x1f92);
|
|
if (YScale & 0x8000)
|
|
YScale = 0x7fff;
|
|
|
|
if (READ_WORD(Memory.C4RAM + 0x1f80) == 0) // no rotation
|
|
{
|
|
// XXX: only do this for C and D?
|
|
// XXX: and then only when YScale is 0x1000?
|
|
A = (int16) XScale;
|
|
B = 0;
|
|
C = 0;
|
|
D = (int16) YScale;
|
|
}
|
|
else
|
|
if (READ_WORD(Memory.C4RAM + 0x1f80) == 128) // 90 degree rotation
|
|
{
|
|
// XXX: Really do this?
|
|
A = 0;
|
|
B = (int16) (-YScale);
|
|
C = (int16) XScale;
|
|
D = 0;
|
|
}
|
|
else
|
|
if (READ_WORD(Memory.C4RAM + 0x1f80) == 256) // 180 degree rotation
|
|
{
|
|
// XXX: Really do this?
|
|
A = (int16) (-XScale);
|
|
B = 0;
|
|
C = 0;
|
|
D = (int16) (-YScale);
|
|
}
|
|
else
|
|
if (READ_WORD(Memory.C4RAM + 0x1f80) == 384) // 270 degree rotation
|
|
{
|
|
// XXX: Really do this?
|
|
A = 0;
|
|
B = (int16) YScale;
|
|
C = (int16) (-XScale);
|
|
D = 0;
|
|
}
|
|
else
|
|
{
|
|
A = (int16) SAR(C4CosTable[READ_WORD(Memory.C4RAM + 0x1f80) & 0x1ff] * XScale, 15);
|
|
B = (int16) (-SAR(C4SinTable[READ_WORD(Memory.C4RAM + 0x1f80) & 0x1ff] * YScale, 15));
|
|
C = (int16) SAR(C4SinTable[READ_WORD(Memory.C4RAM + 0x1f80) & 0x1ff] * XScale, 15);
|
|
D = (int16) SAR(C4CosTable[READ_WORD(Memory.C4RAM + 0x1f80) & 0x1ff] * YScale, 15);
|
|
}
|
|
|
|
// Calculate Pixel Resolution
|
|
uint8 w = Memory.C4RAM[0x1f89] & ~7;
|
|
uint8 h = Memory.C4RAM[0x1f8c] & ~7;
|
|
|
|
//printf("%dx%d XScale=%04x YScale=%04x angle=%03x\n", w, h, XScale, YScale, READ_WORD(Memory.C4RAM + 0x1f80) & 0x1ff);
|
|
//printf("Matrix: [%10g %10g] [%04x %04x]\n", A / 4096.0, B / 4096.0, A & 0xffff, B & 0xffff);
|
|
//printf(" [%10g %10g] [%04x %04x]\n", C / 4096.0, D / 4096.0, C & 0xffff, D & 0xffff);
|
|
|
|
// Clear the output RAM
|
|
memset(Memory.C4RAM, 0, (w + row_padding / 4) * h / 2);
|
|
|
|
int32 Cx = (int16) READ_WORD(Memory.C4RAM + 0x1f83);
|
|
int32 Cy = (int16) READ_WORD(Memory.C4RAM + 0x1f86);
|
|
|
|
#ifdef DEBUGGER
|
|
if (Memory.C4RAM[0x1f97] != 0)
|
|
printf("$7f97=%02x, expected 00\n", Memory.C4RAM[0x1f97]);
|
|
if ((Cx & ~1) != w / 2 || (Cy & ~1) != h / 2)
|
|
printf("Center is not middle of image! (%d, %d) != (%d, %d)\n", Cx, Cy, w / 2, h / 2);
|
|
#endif
|
|
|
|
// Calculate start position (i.e. (Ox, Oy) = (0, 0))
|
|
// The low 12 bits are fractional, so (Cx<<12) gives us the Cx we want in the function.
|
|
// We do Cx*A etc normally because the matrix parameters already have the fractional parts.
|
|
int32 LineX = (Cx << 12) - Cx * A - Cx * B;
|
|
int32 LineY = (Cy << 12) - Cy * C - Cy * D;
|
|
|
|
// Start loop
|
|
uint32 X, Y;
|
|
uint8 byte;
|
|
int outidx = 0;
|
|
uint8 bit = 0x80;
|
|
|
|
for (int y = 0; y < h; y++)
|
|
{
|
|
X = LineX;
|
|
Y = LineY;
|
|
|
|
for (int x = 0; x < w; x++)
|
|
{
|
|
if ((X >> 12) >= w || (Y >> 12) >= h)
|
|
byte = 0;
|
|
else
|
|
{
|
|
uint32 addr = (Y >> 12) * w + (X >> 12);
|
|
byte = Memory.C4RAM[0x600 + (addr >> 1)];
|
|
if (addr & 1)
|
|
byte >>= 4;
|
|
}
|
|
|
|
// De-bitplanify
|
|
if (byte & 1)
|
|
Memory.C4RAM[outidx] |= bit;
|
|
if (byte & 2)
|
|
Memory.C4RAM[outidx + 1] |= bit;
|
|
if (byte & 4)
|
|
Memory.C4RAM[outidx + 16] |= bit;
|
|
if (byte & 8)
|
|
Memory.C4RAM[outidx + 17] |= bit;
|
|
|
|
bit >>= 1;
|
|
if (bit == 0)
|
|
{
|
|
bit = 0x80;
|
|
outidx += 32;
|
|
}
|
|
|
|
X += A; // Add 1 to output x => add an A and a C
|
|
Y += C;
|
|
}
|
|
|
|
outidx += 2 + row_padding;
|
|
if (outidx & 0x10)
|
|
outidx &= ~0x10;
|
|
else
|
|
outidx -= w * 4 + row_padding;
|
|
|
|
LineX += B; // Add 1 to output y => add a B and a D
|
|
LineY += D;
|
|
}
|
|
}
|
|
|
|
static void C4DrawLine (int32 X1, int32 Y1, int16 Z1, int32 X2, int32 Y2, int16 Z2, uint8 Color)
|
|
{
|
|
// Transform coordinates
|
|
C4WFXVal = (int16) X1;
|
|
C4WFYVal = (int16) Y1;
|
|
C4WFZVal = Z1;
|
|
C4WFScale = Memory.C4RAM[0x1f90];
|
|
C4WFX2Val = Memory.C4RAM[0x1f86];
|
|
C4WFY2Val = Memory.C4RAM[0x1f87];
|
|
C4WFDist = Memory.C4RAM[0x1f88];
|
|
C4TransfWireFrame2();
|
|
X1 = (C4WFXVal + 48) << 8;
|
|
Y1 = (C4WFYVal + 48) << 8;
|
|
|
|
C4WFXVal = (int16) X2;
|
|
C4WFYVal = (int16) Y2;
|
|
C4WFZVal = Z2;
|
|
C4TransfWireFrame2();
|
|
X2 = (C4WFXVal + 48) << 8;
|
|
Y2 = (C4WFYVal + 48) << 8;
|
|
|
|
// Get line info
|
|
C4WFXVal = (int16) (X1 >> 8);
|
|
C4WFYVal = (int16) (Y1 >> 8);
|
|
C4WFX2Val = (int16) (X2 >> 8);
|
|
C4WFY2Val = (int16) (Y2 >> 8);
|
|
C4CalcWireFrame();
|
|
X2 = (int16) C4WFXVal;
|
|
Y2 = (int16) C4WFYVal;
|
|
|
|
// Render line
|
|
for (int i = C4WFDist ? C4WFDist : 1; i > 0; i--)
|
|
{
|
|
if (X1 > 0xff && Y1 > 0xff && X1 < 0x6000 && Y1 < 0x6000)
|
|
{
|
|
uint16 addr = (((Y1 >> 8) >> 3) << 8) - (((Y1 >> 8) >> 3) << 6) + (((X1 >> 8) >> 3) << 4) + ((Y1 >> 8) & 7) * 2;
|
|
uint8 bit = 0x80 >> ((X1 >> 8) & 7);
|
|
|
|
Memory.C4RAM[addr + 0x300] &= ~bit;
|
|
Memory.C4RAM[addr + 0x301] &= ~bit;
|
|
if (Color & 1)
|
|
Memory.C4RAM[addr + 0x300] |= bit;
|
|
if (Color & 2)
|
|
Memory.C4RAM[addr + 0x301] |= bit;
|
|
}
|
|
|
|
X1 += X2;
|
|
Y1 += Y2;
|
|
}
|
|
}
|
|
|
|
static void C4DrawWireFrame (void)
|
|
{
|
|
uint8 *line = C4GetMemPointer(READ_3WORD(Memory.C4RAM + 0x1f80));
|
|
uint8 *point1, *point2;
|
|
int16 X1, Y1, Z1;
|
|
int16 X2, Y2, Z2;
|
|
uint8 Color;
|
|
|
|
#ifdef DEBUGGER
|
|
if (READ_3WORD(Memory.C4RAM + 0x1f8f) & 0xff00ff)
|
|
printf("wireframe: Unexpected value in $7f8f: %06x\n", READ_3WORD(Memory.C4RAM + 0x1f8f));
|
|
if (READ_3WORD(Memory.C4RAM + 0x1fa4) != 0x001000)
|
|
printf("wireframe: Unexpected value in $7fa4: %06x\n", READ_3WORD(Memory.C4RAM + 0x1fa4));
|
|
#endif
|
|
|
|
for (int i = Memory.C4RAM[0x0295]; i > 0; i--, line += 5)
|
|
{
|
|
if (line[0] == 0xff && line[1] == 0xff)
|
|
{
|
|
uint8 *tmp = line - 5;
|
|
while (tmp[2] == 0xff && tmp[3] == 0xff)
|
|
tmp -= 5;
|
|
point1 = C4GetMemPointer((Memory.C4RAM[0x1f82] << 16) | (tmp[2] << 8) | tmp[3]);
|
|
}
|
|
else
|
|
point1 = C4GetMemPointer((Memory.C4RAM[0x1f82] << 16) | (line[0] << 8) | line[1]);
|
|
|
|
point2 = C4GetMemPointer((Memory.C4RAM[0x1f82] << 16) | (line[2] << 8) | line[3]);
|
|
|
|
X1 = (point1[0] << 8) | point1[1];
|
|
Y1 = (point1[2] << 8) | point1[3];
|
|
Z1 = (point1[4] << 8) | point1[5];
|
|
X2 = (point2[0] << 8) | point2[1];
|
|
Y2 = (point2[2] << 8) | point2[3];
|
|
Z2 = (point2[4] << 8) | point2[5];
|
|
|
|
Color = line[4];
|
|
|
|
C4DrawLine(X1, Y1, Z1, X2, Y2, Z2, Color);
|
|
}
|
|
}
|
|
|
|
static void C4TransformLines (void)
|
|
{
|
|
C4WFX2Val = Memory.C4RAM[0x1f83];
|
|
C4WFY2Val = Memory.C4RAM[0x1f86];
|
|
C4WFDist = Memory.C4RAM[0x1f89];
|
|
C4WFScale = Memory.C4RAM[0x1f8c];
|
|
|
|
#ifdef DEBUGGER
|
|
if (Memory.C4RAM[0x1f8a] != 0x90)
|
|
printf("lines: $7f8a = %02x, expected 90\n", READ_WORD(Memory.C4RAM + 0x1f8a));
|
|
#endif
|
|
|
|
// Transform vertices
|
|
uint8 *ptr = Memory.C4RAM;
|
|
|
|
for (int i = READ_WORD(Memory.C4RAM + 0x1f80); i > 0; i--, ptr += 0x10)
|
|
{
|
|
C4WFXVal = READ_WORD(ptr + 1);
|
|
C4WFYVal = READ_WORD(ptr + 5);
|
|
C4WFZVal = READ_WORD(ptr + 9);
|
|
C4TransfWireFrame();
|
|
|
|
// Displace
|
|
WRITE_WORD(ptr + 1, C4WFXVal + 0x80);
|
|
WRITE_WORD(ptr + 5, C4WFYVal + 0x50);
|
|
}
|
|
|
|
WRITE_WORD(Memory.C4RAM + 0x600, 23);
|
|
WRITE_WORD(Memory.C4RAM + 0x602, 0x60);
|
|
WRITE_WORD(Memory.C4RAM + 0x605, 0x40);
|
|
WRITE_WORD(Memory.C4RAM + 0x600 + 8, 23);
|
|
WRITE_WORD(Memory.C4RAM + 0x602 + 8, 0x60);
|
|
WRITE_WORD(Memory.C4RAM + 0x605 + 8, 0x40);
|
|
|
|
ptr = Memory.C4RAM + 0xb02;
|
|
uint8 *ptr2 = Memory.C4RAM;
|
|
|
|
for (int i = READ_WORD(Memory.C4RAM + 0xb00); i > 0; i--, ptr += 2, ptr2 += 8)
|
|
{
|
|
C4WFXVal = READ_WORD(Memory.C4RAM + (ptr[0] << 4) + 1);
|
|
C4WFYVal = READ_WORD(Memory.C4RAM + (ptr[0] << 4) + 5);
|
|
C4WFX2Val = READ_WORD(Memory.C4RAM + (ptr[1] << 4) + 1);
|
|
C4WFY2Val = READ_WORD(Memory.C4RAM + (ptr[1] << 4) + 5);
|
|
C4CalcWireFrame();
|
|
|
|
WRITE_WORD(ptr2 + 0x600, C4WFDist ? C4WFDist : 1);
|
|
WRITE_WORD(ptr2 + 0x602, C4WFXVal);
|
|
WRITE_WORD(ptr2 + 0x605, C4WFYVal);
|
|
}
|
|
}
|
|
|
|
static void C4BitPlaneWave (void)
|
|
{
|
|
static uint16 bmpdata[] =
|
|
{
|
|
0x0000, 0x0002, 0x0004, 0x0006, 0x0008, 0x000A, 0x000C, 0x000E,
|
|
0x0200, 0x0202, 0x0204, 0x0206, 0x0208, 0x020A, 0x020C, 0x020E,
|
|
0x0400, 0x0402, 0x0404, 0x0406, 0x0408, 0x040A, 0x040C, 0x040E,
|
|
0x0600, 0x0602, 0x0604, 0x0606, 0x0608, 0x060A, 0x060C, 0x060E,
|
|
0x0800, 0x0802, 0x0804, 0x0806, 0x0808, 0x080A, 0x080C, 0x080E
|
|
};
|
|
|
|
uint8 *dst = Memory.C4RAM;
|
|
uint32 waveptr = Memory.C4RAM[0x1f83];
|
|
uint16 mask1 = 0xc0c0;
|
|
uint16 mask2 = 0x3f3f;
|
|
|
|
#ifdef DEBUGGER
|
|
if (READ_3WORD(Memory.C4RAM + 0x1f80) != Memory.C4RAM[waveptr + 0xb00])
|
|
printf("$7f80=%06x, expected %02x\n", READ_3WORD(Memory.C4RAM + 0x1f80), Memory.C4RAM[waveptr + 0xb00]);
|
|
#endif
|
|
|
|
for (int j = 0; j < 0x10; j++)
|
|
{
|
|
do
|
|
{
|
|
int16 height = -((int8) Memory.C4RAM[waveptr + 0xb00]) - 16;
|
|
|
|
for (int i = 0; i < 40; i++)
|
|
{
|
|
uint16 tmp = READ_WORD(dst + bmpdata[i]) & mask2;
|
|
if (height >= 0)
|
|
{
|
|
if (height < 8)
|
|
tmp |= mask1 & READ_WORD(Memory.C4RAM + 0xa00 + height * 2);
|
|
else
|
|
tmp |= mask1 & 0xff00;
|
|
}
|
|
|
|
WRITE_WORD(dst + bmpdata[i], tmp);
|
|
|
|
height++;
|
|
}
|
|
|
|
waveptr = (waveptr + 1) & 0x7f;
|
|
mask1 = (mask1 >> 2) | (mask1 << 6);
|
|
mask2 = (mask2 >> 2) | (mask2 << 6);
|
|
}
|
|
while (mask1 != 0xc0c0);
|
|
|
|
dst += 16;
|
|
|
|
do
|
|
{
|
|
int16 height = -((int8) Memory.C4RAM[waveptr + 0xb00]) - 16;
|
|
|
|
for (int i = 0; i < 40; i++)
|
|
{
|
|
uint16 tmp = READ_WORD(dst + bmpdata[i]) & mask2;
|
|
if (height >= 0)
|
|
{
|
|
if (height < 8)
|
|
tmp |= mask1 & READ_WORD(Memory.C4RAM + 0xa10 + height * 2);
|
|
else
|
|
tmp |= mask1 & 0xff00;
|
|
}
|
|
|
|
WRITE_WORD(dst + bmpdata[i], tmp);
|
|
|
|
height++;
|
|
}
|
|
|
|
waveptr = (waveptr + 1) & 0x7f;
|
|
mask1 = (mask1 >> 2) | (mask1 << 6);
|
|
mask2 = (mask2 >> 2) | (mask2 << 6);
|
|
}
|
|
while (mask1 != 0xc0c0);
|
|
|
|
dst += 16;
|
|
}
|
|
}
|
|
|
|
static void C4SprDisintegrate (void)
|
|
{
|
|
uint8 *src;
|
|
uint8 width, height;
|
|
uint32 StartX, StartY;
|
|
int32 scaleX, scaleY;
|
|
int32 Cx, Cy;
|
|
|
|
width = Memory.C4RAM[0x1f89];
|
|
height = Memory.C4RAM[0x1f8c];
|
|
Cx = (int16) READ_WORD(Memory.C4RAM + 0x1f80);
|
|
Cy = (int16) READ_WORD(Memory.C4RAM + 0x1f83);
|
|
|
|
#ifdef DEBUGGER
|
|
if ((Cx & ~1) != width / 2 || (Cy & ~1) != height / 2)
|
|
printf("Center is not middle of image for disintegrate! (%d, %d) != (%d, %d)\n", Cx, Cy, width / 2, height / 2);
|
|
#endif
|
|
|
|
scaleX = (int16) READ_WORD(Memory.C4RAM + 0x1f86);
|
|
scaleY = (int16) READ_WORD(Memory.C4RAM + 0x1f8f);
|
|
StartX = -Cx * scaleX + (Cx << 8);
|
|
StartY = -Cy * scaleY + (Cy << 8);
|
|
|
|
src = Memory.C4RAM + 0x600;
|
|
|
|
memset(Memory.C4RAM, 0, width * height / 2);
|
|
|
|
for (uint32 y = StartY, i = 0; i < height; i++, y += scaleY)
|
|
{
|
|
for (uint32 x = StartX, j = 0; j < width; j++, x += scaleX)
|
|
{
|
|
if ((x >> 8) < width && (y >> 8) < height && (y >> 8) * width + (x >> 8) < 0x2000)
|
|
{
|
|
uint8 pixel = (j & 1) ? (*src >> 4) : *src;
|
|
int idx = (y >> 11) * width * 4 + (x >> 11) * 32 + ((y >> 8) & 7) * 2;
|
|
uint8 mask = 0x80 >> ((x >> 8) & 7);
|
|
|
|
if (pixel & 1)
|
|
Memory.C4RAM[idx] |= mask;
|
|
if (pixel & 2)
|
|
Memory.C4RAM[idx + 1] |= mask;
|
|
if (pixel & 4)
|
|
Memory.C4RAM[idx + 16] |= mask;
|
|
if (pixel & 8)
|
|
Memory.C4RAM[idx + 17] |= mask;
|
|
}
|
|
|
|
if (j & 1)
|
|
src++;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void C4ProcessSprites (void)
|
|
{
|
|
switch (Memory.C4RAM[0x1f4d])
|
|
{
|
|
case 0x00: // Build OAM
|
|
#ifdef DEBUGGER
|
|
//printf("00 00 Build OAM!\n");
|
|
#endif
|
|
C4ConvOAM();
|
|
break;
|
|
|
|
case 0x03: // Scale/Rotate
|
|
#ifdef DEBUGGER
|
|
//printf("00 03 Scale/Rotate!\n");
|
|
#endif
|
|
C4DoScaleRotate(0);
|
|
break;
|
|
|
|
case 0x05: // Transform Lines
|
|
#ifdef DEBUGGER
|
|
//printf("00 05 Transform Lines!\n");
|
|
#endif
|
|
C4TransformLines();
|
|
break;
|
|
|
|
case 0x07: // Scale/Rotate
|
|
#ifdef DEBUGGER
|
|
//printf("00 07 Scale/Rotate!\n");
|
|
#endif
|
|
C4DoScaleRotate(64);
|
|
break;
|
|
|
|
case 0x08: // Draw wireframe
|
|
#ifdef DEBUGGER
|
|
//printf("00 08 Draw wireframe!\n");
|
|
#endif
|
|
C4DrawWireFrame();
|
|
break;
|
|
|
|
case 0x0b: // Disintegrate
|
|
#ifdef DEBUGGER
|
|
//printf("00 0b Disintegrate!\n");
|
|
#endif
|
|
C4SprDisintegrate();
|
|
break;
|
|
|
|
case 0x0c: // Wave
|
|
#ifdef DEBUGGER
|
|
//printf("00 0b Wave!\n");
|
|
#endif
|
|
C4BitPlaneWave();
|
|
break;
|
|
|
|
default:
|
|
#ifdef DEBUGGER
|
|
printf("Unknown C4 sprite command (%02x)\n", Memory.C4RAM[0x1f4d]);
|
|
#endif
|
|
break;
|
|
}
|
|
}
|
|
|
|
void S9xInitC4 (void)
|
|
{
|
|
// Stupid zsnes code, we can't do the logical thing without breaking savestates
|
|
// Memory.C4RAM = &Memory.FillRAM [0x6000];
|
|
memset(Memory.C4RAM, 0, 0x2000);
|
|
}
|
|
|
|
uint8 S9xGetC4 (uint16 Address)
|
|
{
|
|
if (Address == 0x7f5e)
|
|
return (0);
|
|
|
|
return (Memory.C4RAM[Address - 0x6000]);
|
|
}
|
|
|
|
void S9xSetC4 (uint8 byte, uint16 Address)
|
|
{
|
|
Memory.C4RAM[Address - 0x6000] = byte;
|
|
|
|
if (Address == 0x7f4f)
|
|
{
|
|
if (Memory.C4RAM[0x1f4d] == 0x0e && byte < 0x40 && (byte & 3) == 0)
|
|
{
|
|
#ifdef DEBUGGER
|
|
printf("Test command %02x 0e used!\n", byte);
|
|
#endif
|
|
Memory.C4RAM[0x1f80] = byte >> 2;
|
|
}
|
|
else
|
|
{
|
|
switch (byte)
|
|
{
|
|
case 0x00: // Sprite
|
|
#ifdef DEBUGGER
|
|
//printf("00 Sprite!\n");
|
|
#endif
|
|
C4ProcessSprites();
|
|
break;
|
|
|
|
case 0x01: // Draw wireframe
|
|
#ifdef DEBUGGER
|
|
//printf("01 Draw wireframe!\n");
|
|
if (Memory.C4RAM[0x1f4d] != 8)
|
|
printf("$7f4d=%02x, expected 08 for command 01 %02x\n", Memory.C4RAM[0x1f4d], Memory.C4RAM[0x1f4d]);
|
|
#endif
|
|
memset(Memory.C4RAM + 0x300, 0, 16 * 12 * 3 * 4);
|
|
C4DrawWireFrame();
|
|
break;
|
|
|
|
case 0x05: // Propulsion (?)
|
|
{
|
|
#ifdef DEBUGGER
|
|
//printf("05 Propulsion (?)!\n");
|
|
if (Memory.C4RAM[0x1f4d] != 2)
|
|
printf("$7f4d=%02x, expected 02 for command 05 %02x\n", Memory.C4RAM[0x1f4d], Memory.C4RAM[0x1f4d]);
|
|
#endif
|
|
int32 tmp = 0x10000;
|
|
if (READ_WORD(Memory.C4RAM + 0x1f83))
|
|
tmp = SAR((tmp / READ_WORD(Memory.C4RAM + 0x1f83)) * READ_WORD(Memory.C4RAM + 0x1f81), 8);
|
|
|
|
WRITE_WORD(Memory.C4RAM + 0x1f80, (uint16) tmp);
|
|
break;
|
|
}
|
|
|
|
case 0x0d: // Set vector length
|
|
#ifdef DEBUGGER
|
|
//printf("0d Set vector length!\n");
|
|
if (Memory.C4RAM[0x1f4d] != 2)
|
|
printf("$7f4d=%02x, expected 02 for command 0d %02x\n", Memory.C4RAM[0x1f4d], Memory.C4RAM[0x1f4d]);
|
|
#endif
|
|
C41FXVal = READ_WORD(Memory.C4RAM + 0x1f80);
|
|
C41FYVal = READ_WORD(Memory.C4RAM + 0x1f83);
|
|
C41FDistVal = READ_WORD(Memory.C4RAM + 0x1f86);
|
|
C4Op0D();
|
|
WRITE_WORD(Memory.C4RAM + 0x1f89, C41FXVal);
|
|
WRITE_WORD(Memory.C4RAM + 0x1f8c, C41FYVal);
|
|
break;
|
|
|
|
case 0x10: // Polar to rectangluar
|
|
{
|
|
#ifdef DEBUGGER
|
|
//printf("10 Polar->Rect!\n");
|
|
if (Memory.C4RAM[0x1f4d] != 2)
|
|
printf("$7f4d=%02x, expected 02 for command 10 %02x\n", Memory.C4RAM[0x1f4d], Memory.C4RAM[0x1f4d]);
|
|
#endif
|
|
int32 tmp;
|
|
int32 r1;
|
|
r1 = READ_WORD(Memory.C4RAM + 0x1f83);
|
|
if (r1 & 0x8000)
|
|
r1 |= ~0x7fff;
|
|
else
|
|
r1 &= 0x7fff;
|
|
|
|
tmp = SAR(r1 * C4CosTable[READ_WORD(Memory.C4RAM + 0x1f80) & 0x1ff] * 2, 16);
|
|
WRITE_3WORD(Memory.C4RAM + 0x1f86, tmp);
|
|
tmp = SAR(r1 * C4SinTable[READ_WORD(Memory.C4RAM + 0x1f80) & 0x1ff] * 2, 16);
|
|
WRITE_3WORD(Memory.C4RAM + 0x1f89, (tmp - SAR(tmp, 6)));
|
|
break;
|
|
}
|
|
|
|
case 0x13: // Polar to rectangluar
|
|
{
|
|
#ifdef DEBUGGER
|
|
//printf("13 Polar->Rect!\n");
|
|
if (Memory.C4RAM[0x1f4d] != 2)
|
|
printf("$7f4d=%02x, expected 02 for command 13 %02x\n", Memory.C4RAM[0x1f4d], Memory.C4RAM[0x1f4d]);
|
|
#endif
|
|
int32 tmp;
|
|
tmp = SAR((int32) READ_WORD(Memory.C4RAM + 0x1f83) * C4CosTable[READ_WORD(Memory.C4RAM + 0x1f80) & 0x1ff] * 2, 8);
|
|
WRITE_3WORD(Memory.C4RAM + 0x1f86, tmp);
|
|
tmp = SAR((int32) READ_WORD(Memory.C4RAM + 0x1f83) * C4SinTable[READ_WORD(Memory.C4RAM + 0x1f80) & 0x1ff] * 2, 8);
|
|
WRITE_3WORD(Memory.C4RAM + 0x1f89, tmp);
|
|
break;
|
|
}
|
|
|
|
case 0x15: // Pythagorean
|
|
#ifdef DEBUGGER
|
|
//printf("15 Pythagorean!\n");
|
|
if (Memory.C4RAM[0x1f4d] != 2)
|
|
printf("$7f4d=%02x, expected 02 for command 15 %02x\n", Memory.C4RAM[0x1f4d], Memory.C4RAM[0x1f4d]);
|
|
#endif
|
|
C41FXVal = READ_WORD(Memory.C4RAM + 0x1f80);
|
|
C41FYVal = READ_WORD(Memory.C4RAM + 0x1f83);
|
|
//C4Op15(); // optimized to:
|
|
C41FDist = (int16) sqrt((double) C41FXVal * C41FXVal + (double) C41FYVal * C41FYVal);
|
|
WRITE_WORD(Memory.C4RAM + 0x1f80, C41FDist);
|
|
break;
|
|
|
|
case 0x1f: // atan
|
|
#ifdef DEBUGGER
|
|
//printf("1f atan!\n");
|
|
if (Memory.C4RAM[0x1f4d] != 2)
|
|
printf("$7f4d=%02x, expected 02 for command 1f %02x\n", Memory.C4RAM[0x1f4d], Memory.C4RAM[0x1f4d]);
|
|
#endif
|
|
C41FXVal = READ_WORD(Memory.C4RAM + 0x1f80);
|
|
C41FYVal = READ_WORD(Memory.C4RAM + 0x1f83);
|
|
C4Op1F();
|
|
WRITE_WORD(Memory.C4RAM + 0x1f86, C41FAngleRes);
|
|
break;
|
|
|
|
case 0x22: // Trapezoid
|
|
{
|
|
#ifdef DEBUGGER
|
|
//printf("22 Trapezoid!\n");
|
|
if (Memory.C4RAM[0x1f4d] != 2)
|
|
printf("$7f4d=%02x, expected 02 for command 22 %02x\n", Memory.C4RAM[0x1f4d], Memory.C4RAM[0x1f4d]);
|
|
#endif
|
|
int16 angle1 = READ_WORD(Memory.C4RAM + 0x1f8c) & 0x1ff;
|
|
int16 angle2 = READ_WORD(Memory.C4RAM + 0x1f8f) & 0x1ff;
|
|
|
|
#ifdef DEBUGGER
|
|
if (C4CosTable[angle1] == 0)
|
|
fprintf(stderr, "22 Trapezoid: Invalid tangent! angle1=%d\n", angle1);
|
|
if (C4CosTable[angle2] == 0)
|
|
fprintf(stderr, "22 Trapezoid: Invalid tangent! angle2=%d\n", angle2);
|
|
#endif
|
|
|
|
int32 tan1 = (C4CosTable[angle1] != 0) ? ((((int32) C4SinTable[angle1]) << 16) / C4CosTable[angle1]) : 0x80000000;
|
|
int32 tan2 = (C4CosTable[angle2] != 0) ? ((((int32) C4SinTable[angle2]) << 16) / C4CosTable[angle2]) : 0x80000000;
|
|
|
|
int16 y = READ_WORD(Memory.C4RAM + 0x1f83) - READ_WORD(Memory.C4RAM + 0x1f89);
|
|
int16 left, right;
|
|
|
|
for (int j = 0; j < 225; j++)
|
|
{
|
|
if (y >= 0)
|
|
{
|
|
left = SAR((int32) tan1 * y, 16) - READ_WORD(Memory.C4RAM + 0x1f80) + READ_WORD(Memory.C4RAM + 0x1f86);
|
|
right = SAR((int32) tan2 * y, 16) - READ_WORD(Memory.C4RAM + 0x1f80) + READ_WORD(Memory.C4RAM + 0x1f86) + READ_WORD(Memory.C4RAM + 0x1f93);
|
|
|
|
if (left < 0 && right < 0)
|
|
{
|
|
left = 1;
|
|
right = 0;
|
|
}
|
|
else
|
|
if (left < 0)
|
|
left = 0;
|
|
else
|
|
if (right < 0)
|
|
right = 0;
|
|
|
|
if (left > 255 && right > 255)
|
|
{
|
|
left = 255;
|
|
right = 254;
|
|
}
|
|
else
|
|
if (left > 255)
|
|
left = 255;
|
|
else
|
|
if (right > 255)
|
|
right = 255;
|
|
}
|
|
else
|
|
{
|
|
left = 1;
|
|
right = 0;
|
|
}
|
|
|
|
Memory.C4RAM[j + 0x800] = (uint8) left;
|
|
Memory.C4RAM[j + 0x900] = (uint8) right;
|
|
|
|
y++;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case 0x25: // Multiply
|
|
{
|
|
#ifdef DEBUGGER
|
|
//printf("25 Multiply!\n");
|
|
if (Memory.C4RAM[0x1f4d] != 2)
|
|
printf("$7f4d=%02x, expected 02 for command 25 %02x\n", Memory.C4RAM[0x1f4d], Memory.C4RAM[0x1f4d]);
|
|
#endif
|
|
int32 foo = READ_3WORD(Memory.C4RAM + 0x1f80);
|
|
int32 bar = READ_3WORD(Memory.C4RAM + 0x1f83);
|
|
foo *= bar;
|
|
WRITE_3WORD(Memory.C4RAM + 0x1f80, foo);
|
|
break;
|
|
}
|
|
|
|
case 0x2d: // Transform Coords
|
|
#ifdef DEBUGGER
|
|
//printf("2d Transform Coords!\n");
|
|
if (Memory.C4RAM[0x1f4d] != 2)
|
|
printf("$7f4d=%02x, expected 02 for command 2d %02x\n", Memory.C4RAM[0x1f4d], Memory.C4RAM[0x1f4d]);
|
|
if (READ_3WORD(Memory.C4RAM + 0x1f8f) & 0xff00ff)
|
|
printf("2d transform coords: Unexpected value in $7f8f: %06x\n", READ_3WORD(Memory.C4RAM + 0x1f8f));
|
|
if (READ_3WORD(Memory.C4RAM + 0x1f8c) != 0x001000)
|
|
printf("0d transform coords: Unexpected value in $7f8c: %06x\n", READ_3WORD(Memory.C4RAM + 0x1f8c));
|
|
#endif
|
|
C4WFXVal = READ_WORD(Memory.C4RAM + 0x1f81);
|
|
C4WFYVal = READ_WORD(Memory.C4RAM + 0x1f84);
|
|
C4WFZVal = READ_WORD(Memory.C4RAM + 0x1f87);
|
|
C4WFX2Val = Memory.C4RAM[0x1f89];
|
|
C4WFY2Val = Memory.C4RAM[0x1f8a];
|
|
C4WFDist = Memory.C4RAM[0x1f8b];
|
|
C4WFScale = READ_WORD(Memory.C4RAM + 0x1f90);
|
|
C4TransfWireFrame2();
|
|
WRITE_WORD(Memory.C4RAM + 0x1f80, C4WFXVal);
|
|
WRITE_WORD(Memory.C4RAM + 0x1f83, C4WFYVal);
|
|
break;
|
|
|
|
case 0x40: // Sum
|
|
{
|
|
#ifdef DEBUGGER
|
|
//printf("40 Sum!\n");
|
|
if (Memory.C4RAM[0x1f4d] != 0x0e)
|
|
printf("$7f4d=%02x, expected 0e for command 40 %02x\n", Memory.C4RAM[0x1f4d], Memory.C4RAM[0x1f4d]);
|
|
#endif
|
|
uint16 sum = 0;
|
|
for (int i = 0; i < 0x800; sum += Memory.C4RAM[i++]) ;
|
|
WRITE_WORD(Memory.C4RAM + 0x1f80, sum);
|
|
break;
|
|
}
|
|
|
|
case 0x54: // Square
|
|
{
|
|
#ifdef DEBUGGER
|
|
//printf("54 Square!\n");
|
|
if (Memory.C4RAM[0x1f4d] != 0x0e)
|
|
printf("$7f4d=%02x, expected 0e for command 54 %02x\n", Memory.C4RAM[0x1f4d], Memory.C4RAM[0x1f4d]);
|
|
#endif
|
|
int64 a = (int64)READ_3WORD(Memory.C4RAM + 0x1f80);
|
|
a |= 0xffffffffff000000 * ((a >> 23) & 1);
|
|
//printf("%08X%08X\n", (uint32) (a>>32), (uint32) (a&0xFFFFFFFF));
|
|
a *= a;
|
|
//printf("%08X%08X\n", (uint32) (a>>32), (uint32) (a&0xFFFFFFFF));
|
|
WRITE_3WORD(Memory.C4RAM + 0x1f83, a);
|
|
WRITE_3WORD(Memory.C4RAM + 0x1f86, (a >> 24));
|
|
break;
|
|
}
|
|
|
|
case 0x5c: // Immediate Reg
|
|
#ifdef DEBUGGER
|
|
//printf("5c Immediate Reg!\n");
|
|
if (Memory.C4RAM[0x1f4d] != 0x0e)
|
|
printf("$7f4d=%02x, expected 0e for command 5c %02x\n", Memory.C4RAM[0x1f4d], Memory.C4RAM[0x1f4d]);
|
|
#endif
|
|
for (int i = 0; i < 12 * 4; i++)
|
|
Memory.C4RAM[i] = C4TestPattern[i];
|
|
break;
|
|
|
|
case 0x89: // Immediate ROM
|
|
#ifdef DEBUGGER
|
|
//printf("89 Immediate ROM!\n");
|
|
if (Memory.C4RAM[0x1f4d] != 0x0e)
|
|
printf("$7f4d=%02x, expected 0e for command 89 %02x\n", Memory.C4RAM[0x1f4d], Memory.C4RAM[0x1f4d]);
|
|
#endif
|
|
Memory.C4RAM[0x1f80] = 0x36;
|
|
Memory.C4RAM[0x1f81] = 0x43;
|
|
Memory.C4RAM[0x1f82] = 0x05;
|
|
break;
|
|
|
|
default:
|
|
#ifdef DEBUGGER
|
|
printf("Unknown C4 command (%02x)\n", byte);
|
|
#endif
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
if (Address == 0x7f47)
|
|
{
|
|
#ifdef DEBUGGER
|
|
//printf("C4 load memory %06x => %04x, %04x bytes\n", READ_3WORD(Memory.C4RAM + 0x1f40), READ_WORD(Memory.C4RAM + 0x1f45), READ_WORD(Memory.C4RAM + 0x1f43));
|
|
if (byte != 0)
|
|
printf("C4 load: non-0 written to $7f47! Wrote %02x\n", byte);
|
|
if (READ_WORD(Memory.C4RAM + 0x1f45) < 0x6000 || (READ_WORD(Memory.C4RAM + 0x1f45) + READ_WORD(Memory.C4RAM + 0x1f43)) > 0x6c00)
|
|
printf("C4 load: Dest unusual! It's %04x\n", READ_WORD(Memory.C4RAM + 0x1f45));
|
|
#endif
|
|
memmove(Memory.C4RAM + (READ_WORD(Memory.C4RAM + 0x1f45) & 0x1fff), C4GetMemPointer(READ_3WORD(Memory.C4RAM + 0x1f40)), READ_WORD(Memory.C4RAM + 0x1f43));
|
|
}
|
|
}
|