namespace GarboDev
{
partial class Renderer
{
#region Sprite Drawing
private void DrawSpritesNormal(int priority)
{
byte[] palette = this.memory.PaletteRam;
byte[] vram = this.memory.VideoRam;
// OBJ must be enabled in this.dispCnt
if ((this.dispCnt & (1 << 12)) == 0) return;
byte blendMaskType = (byte)(1 << 4);
for (int oamNum = 127; oamNum >= 0; oamNum--)
{
ushort attr2 = this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(oamNum * 8) + 4);
if (((attr2 >> 10) & 3) != priority) continue;
ushort attr0 = this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(oamNum * 8) + 0);
ushort attr1 = this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(oamNum * 8) + 2);
int x = attr1 & 0x1FF;
int y = attr0 & 0xFF;
bool semiTransparent = false;
switch ((attr0 >> 10) & 3)
{
case 1:
// Semi-transparent
semiTransparent = true;
break;
case 2:
// Obj window
continue;
case 3:
continue;
}
if ((this.dispCnt & 0x7) >= 3 && (attr2 & 0x3FF) < 0x200) continue;
int width = -1, height = -1;
switch ((attr0 >> 14) & 3)
{
case 0:
// Square
switch ((attr1 >> 14) & 3)
{
case 0: width = 8; height = 8; break;
case 1: width = 16; height = 16; break;
case 2: width = 32; height = 32; break;
case 3: width = 64; height = 64; break;
}
break;
case 1:
// Horizontal Rectangle
switch ((attr1 >> 14) & 3)
{
case 0: width = 16; height = 8; break;
case 1: width = 32; height = 8; break;
case 2: width = 32; height = 16; break;
case 3: width = 64; height = 32; break;
}
break;
case 2:
// Vertical Rectangle
switch ((attr1 >> 14) & 3)
{
case 0: width = 8; height = 16; break;
case 1: width = 8; height = 32; break;
case 2: width = 16; height = 32; break;
case 3: width = 32; height = 64; break;
}
break;
}
// Check double size flag here
int rwidth = width, rheight = height;
if ((attr0 & (1 << 8)) != 0)
{
// Rot-scale on
if ((attr0 & (1 << 9)) != 0)
{
rwidth *= 2;
rheight *= 2;
}
}
else
{
// Invalid sprite
if ((attr0 & (1 << 9)) != 0)
width = -1;
}
if (width == -1)
{
// Invalid sprite
continue;
}
// Y clipping
if (y > ((y + rheight) & 0xff))
{
if (this.curLine >= ((y + rheight) & 0xff) && !(y < this.curLine)) continue;
}
else
{
if (this.curLine < y || this.curLine >= ((y + rheight) & 0xff)) continue;
}
int scale = 1;
if ((attr0 & (1 << 13)) != 0) scale = 2;
int spritey = this.curLine - y;
if (spritey < 0) spritey += 256;
if (semiTransparent)
{
if ((attr0 & (1 << 8)) == 0)
{
if ((attr1 & (1 << 13)) != 0) spritey = (height - 1) - spritey;
int baseSprite;
if ((this.dispCnt & (1 << 6)) != 0)
{
// 1 dimensional
baseSprite = (attr2 & 0x3FF) + ((spritey / 8) * (width / 8)) * scale;
}
else
{
// 2 dimensional
baseSprite = (attr2 & 0x3FF) + ((spritey / 8) * 0x20);
}
int baseInc = scale;
if ((attr1 & (1 << 12)) != 0)
{
baseSprite += ((width / 8) * scale) - scale;
baseInc = -baseInc;
}
if ((attr0 & (1 << 13)) != 0)
{
// 256 colors
for (int i = x; i < x + width; i++)
{
if ((i & 0x1ff) < 240 && true)
{
int tx = (i - x) & 7;
if ((attr1 & (1 << 12)) != 0) tx = 7 - tx;
int curIdx = baseSprite * 32 + ((spritey & 7) * 8) + tx;
int lookup = vram[0x10000 + curIdx];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[0x200 + lookup * 2] | (palette[0x200 + lookup * 2 + 1] << 8)));
if ((this.blend[i & 0x1ff] & this.blendTarget) != 0 && this.blend[i & 0x1ff] != blendMaskType)
{
uint r = ((pixelColor & 0xFF) * this.blendA) >> 4;
uint g = (((pixelColor >> 8) & 0xFF) * this.blendA) >> 4;
uint b = (((pixelColor >> 16) & 0xFF) * this.blendA) >> 4;
uint sourceValue = this.scanline[(i & 0x1ff)];
r += ((sourceValue & 0xFF) * this.blendB) >> 4;
g += (((sourceValue >> 8) & 0xFF) * this.blendB) >> 4;
b += (((sourceValue >> 16) & 0xFF) * this.blendB) >> 4;
if (r > 0xff) r = 0xff;
if (g > 0xff) g = 0xff;
if (b > 0xff) b = 0xff;
pixelColor = r | (g << 8) | (b << 16);
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
if (((i - x) & 7) == 7) baseSprite += baseInc;
}
}
else
{
// 16 colors
int palIdx = 0x200 + (((attr2 >> 12) & 0xF) * 16 * 2);
for (int i = x; i < x + width; i++)
{
if ((i & 0x1ff) < 240 && true)
{
int tx = (i - x) & 7;
if ((attr1 & (1 << 12)) != 0) tx = 7 - tx;
int curIdx = baseSprite * 32 + ((spritey & 7) * 4) + (tx / 2);
int lookup = vram[0x10000 + curIdx];
if ((tx & 1) == 0)
{
lookup &= 0xf;
}
else
{
lookup >>= 4;
}
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[palIdx + lookup * 2] | (palette[palIdx + lookup * 2 + 1] << 8)));
if ((this.blend[i & 0x1ff] & this.blendTarget) != 0 && this.blend[i & 0x1ff] != blendMaskType)
{
uint r = ((pixelColor & 0xFF) * this.blendA) >> 4;
uint g = (((pixelColor >> 8) & 0xFF) * this.blendA) >> 4;
uint b = (((pixelColor >> 16) & 0xFF) * this.blendA) >> 4;
uint sourceValue = this.scanline[(i & 0x1ff)];
r += ((sourceValue & 0xFF) * this.blendB) >> 4;
g += (((sourceValue >> 8) & 0xFF) * this.blendB) >> 4;
b += (((sourceValue >> 16) & 0xFF) * this.blendB) >> 4;
if (r > 0xff) r = 0xff;
if (g > 0xff) g = 0xff;
if (b > 0xff) b = 0xff;
pixelColor = r | (g << 8) | (b << 16);
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
if (((i - x) & 7) == 7) baseSprite += baseInc;
}
}
}
else
{
int rotScaleParam = (attr1 >> 9) & 0x1F;
short dx = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x6);
short dmx = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0xE);
short dy = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x16);
short dmy = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x1E);
int cx = rwidth / 2;
int cy = rheight / 2;
int baseSprite = attr2 & 0x3FF;
int pitch;
if ((this.dispCnt & (1 << 6)) != 0)
{
// 1 dimensional
pitch = (width / 8) * scale;
}
else
{
// 2 dimensional
pitch = 0x20;
}
int rx = (int)((dmx * (spritey - cy)) - (cx * dx) + (width << 7));
int ry = (int)((dmy * (spritey - cy)) - (cx * dy) + (height << 7));
// Draw a rot/scale sprite
if ((attr0 & (1 << 13)) != 0)
{
// 256 colors
for (int i = x; i < x + rwidth; i++)
{
int tx = rx >> 8;
int ty = ry >> 8;
if ((i & 0x1ff) < 240 && tx >= 0 && tx < width && ty >= 0 && ty < height
&& true)
{
int curIdx = (baseSprite + ((ty / 8) * pitch) + ((tx / 8) * scale)) * 32 + ((ty & 7) * 8) + (tx & 7);
int lookup = vram[0x10000 + curIdx];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[0x200 + lookup * 2] | (palette[0x200 + lookup * 2 + 1] << 8)));
if ((this.blend[i & 0x1ff] & this.blendTarget) != 0 && this.blend[i & 0x1ff] != blendMaskType)
{
uint r = ((pixelColor & 0xFF) * this.blendA) >> 4;
uint g = (((pixelColor >> 8) & 0xFF) * this.blendA) >> 4;
uint b = (((pixelColor >> 16) & 0xFF) * this.blendA) >> 4;
uint sourceValue = this.scanline[(i & 0x1ff)];
r += ((sourceValue & 0xFF) * this.blendB) >> 4;
g += (((sourceValue >> 8) & 0xFF) * this.blendB) >> 4;
b += (((sourceValue >> 16) & 0xFF) * this.blendB) >> 4;
if (r > 0xff) r = 0xff;
if (g > 0xff) g = 0xff;
if (b > 0xff) b = 0xff;
pixelColor = r | (g << 8) | (b << 16);
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
rx += dx;
ry += dy;
}
}
else
{
// 16 colors
int palIdx = 0x200 + (((attr2 >> 12) & 0xF) * 16 * 2);
for (int i = x; i < x + rwidth; i++)
{
int tx = rx >> 8;
int ty = ry >> 8;
if ((i & 0x1ff) < 240 && tx >= 0 && tx < width && ty >= 0 && ty < height
&& true)
{
int curIdx = (baseSprite + ((ty / 8) * pitch) + ((tx / 8) * scale)) * 32 + ((ty & 7) * 4) + ((tx & 7) / 2);
int lookup = vram[0x10000 + curIdx];
if ((tx & 1) == 0)
{
lookup &= 0xf;
}
else
{
lookup >>= 4;
}
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[palIdx + lookup * 2] | (palette[palIdx + lookup * 2 + 1] << 8)));
if ((this.blend[i & 0x1ff] & this.blendTarget) != 0 && this.blend[i & 0x1ff] != blendMaskType)
{
uint r = ((pixelColor & 0xFF) * this.blendA) >> 4;
uint g = (((pixelColor >> 8) & 0xFF) * this.blendA) >> 4;
uint b = (((pixelColor >> 16) & 0xFF) * this.blendA) >> 4;
uint sourceValue = this.scanline[(i & 0x1ff)];
r += ((sourceValue & 0xFF) * this.blendB) >> 4;
g += (((sourceValue >> 8) & 0xFF) * this.blendB) >> 4;
b += (((sourceValue >> 16) & 0xFF) * this.blendB) >> 4;
if (r > 0xff) r = 0xff;
if (g > 0xff) g = 0xff;
if (b > 0xff) b = 0xff;
pixelColor = r | (g << 8) | (b << 16);
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
rx += dx;
ry += dy;
}
}
}
}
else
{
if ((attr0 & (1 << 8)) == 0)
{
if ((attr1 & (1 << 13)) != 0) spritey = (height - 1) - spritey;
int baseSprite;
if ((this.dispCnt & (1 << 6)) != 0)
{
// 1 dimensional
baseSprite = (attr2 & 0x3FF) + ((spritey / 8) * (width / 8)) * scale;
}
else
{
// 2 dimensional
baseSprite = (attr2 & 0x3FF) + ((spritey / 8) * 0x20);
}
int baseInc = scale;
if ((attr1 & (1 << 12)) != 0)
{
baseSprite += ((width / 8) * scale) - scale;
baseInc = -baseInc;
}
if ((attr0 & (1 << 13)) != 0)
{
// 256 colors
for (int i = x; i < x + width; i++)
{
if ((i & 0x1ff) < 240 && true)
{
int tx = (i - x) & 7;
if ((attr1 & (1 << 12)) != 0) tx = 7 - tx;
int curIdx = baseSprite * 32 + ((spritey & 7) * 8) + tx;
int lookup = vram[0x10000 + curIdx];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[0x200 + lookup * 2] | (palette[0x200 + lookup * 2 + 1] << 8)));
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
if (((i - x) & 7) == 7) baseSprite += baseInc;
}
}
else
{
// 16 colors
int palIdx = 0x200 + (((attr2 >> 12) & 0xF) * 16 * 2);
for (int i = x; i < x + width; i++)
{
if ((i & 0x1ff) < 240 && true)
{
int tx = (i - x) & 7;
if ((attr1 & (1 << 12)) != 0) tx = 7 - tx;
int curIdx = baseSprite * 32 + ((spritey & 7) * 4) + (tx / 2);
int lookup = vram[0x10000 + curIdx];
if ((tx & 1) == 0)
{
lookup &= 0xf;
}
else
{
lookup >>= 4;
}
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[palIdx + lookup * 2] | (palette[palIdx + lookup * 2 + 1] << 8)));
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
if (((i - x) & 7) == 7) baseSprite += baseInc;
}
}
}
else
{
int rotScaleParam = (attr1 >> 9) & 0x1F;
short dx = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x6);
short dmx = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0xE);
short dy = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x16);
short dmy = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x1E);
int cx = rwidth / 2;
int cy = rheight / 2;
int baseSprite = attr2 & 0x3FF;
int pitch;
if ((this.dispCnt & (1 << 6)) != 0)
{
// 1 dimensional
pitch = (width / 8) * scale;
}
else
{
// 2 dimensional
pitch = 0x20;
}
int rx = (int)((dmx * (spritey - cy)) - (cx * dx) + (width << 7));
int ry = (int)((dmy * (spritey - cy)) - (cx * dy) + (height << 7));
// Draw a rot/scale sprite
if ((attr0 & (1 << 13)) != 0)
{
// 256 colors
for (int i = x; i < x + rwidth; i++)
{
int tx = rx >> 8;
int ty = ry >> 8;
if ((i & 0x1ff) < 240 && tx >= 0 && tx < width && ty >= 0 && ty < height
&& true)
{
int curIdx = (baseSprite + ((ty / 8) * pitch) + ((tx / 8) * scale)) * 32 + ((ty & 7) * 8) + (tx & 7);
int lookup = vram[0x10000 + curIdx];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[0x200 + lookup * 2] | (palette[0x200 + lookup * 2 + 1] << 8)));
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
rx += dx;
ry += dy;
}
}
else
{
// 16 colors
int palIdx = 0x200 + (((attr2 >> 12) & 0xF) * 16 * 2);
for (int i = x; i < x + rwidth; i++)
{
int tx = rx >> 8;
int ty = ry >> 8;
if ((i & 0x1ff) < 240 && tx >= 0 && tx < width && ty >= 0 && ty < height
&& true)
{
int curIdx = (baseSprite + ((ty / 8) * pitch) + ((tx / 8) * scale)) * 32 + ((ty & 7) * 4) + ((tx & 7) / 2);
int lookup = vram[0x10000 + curIdx];
if ((tx & 1) == 0)
{
lookup &= 0xf;
}
else
{
lookup >>= 4;
}
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[palIdx + lookup * 2] | (palette[palIdx + lookup * 2 + 1] << 8)));
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
rx += dx;
ry += dy;
}
}
}
}
}
}
private void DrawSpritesBlend(int priority)
{
byte[] palette = this.memory.PaletteRam;
byte[] vram = this.memory.VideoRam;
// OBJ must be enabled in this.dispCnt
if ((this.dispCnt & (1 << 12)) == 0) return;
byte blendMaskType = (byte)(1 << 4);
for (int oamNum = 127; oamNum >= 0; oamNum--)
{
ushort attr2 = this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(oamNum * 8) + 4);
if (((attr2 >> 10) & 3) != priority) continue;
ushort attr0 = this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(oamNum * 8) + 0);
ushort attr1 = this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(oamNum * 8) + 2);
int x = attr1 & 0x1FF;
int y = attr0 & 0xFF;
bool semiTransparent = false;
switch ((attr0 >> 10) & 3)
{
case 1:
// Semi-transparent
semiTransparent = true;
break;
case 2:
// Obj window
continue;
case 3:
continue;
}
if ((this.dispCnt & 0x7) >= 3 && (attr2 & 0x3FF) < 0x200) continue;
int width = -1, height = -1;
switch ((attr0 >> 14) & 3)
{
case 0:
// Square
switch ((attr1 >> 14) & 3)
{
case 0: width = 8; height = 8; break;
case 1: width = 16; height = 16; break;
case 2: width = 32; height = 32; break;
case 3: width = 64; height = 64; break;
}
break;
case 1:
// Horizontal Rectangle
switch ((attr1 >> 14) & 3)
{
case 0: width = 16; height = 8; break;
case 1: width = 32; height = 8; break;
case 2: width = 32; height = 16; break;
case 3: width = 64; height = 32; break;
}
break;
case 2:
// Vertical Rectangle
switch ((attr1 >> 14) & 3)
{
case 0: width = 8; height = 16; break;
case 1: width = 8; height = 32; break;
case 2: width = 16; height = 32; break;
case 3: width = 32; height = 64; break;
}
break;
}
// Check double size flag here
int rwidth = width, rheight = height;
if ((attr0 & (1 << 8)) != 0)
{
// Rot-scale on
if ((attr0 & (1 << 9)) != 0)
{
rwidth *= 2;
rheight *= 2;
}
}
else
{
// Invalid sprite
if ((attr0 & (1 << 9)) != 0)
width = -1;
}
if (width == -1)
{
// Invalid sprite
continue;
}
// Y clipping
if (y > ((y + rheight) & 0xff))
{
if (this.curLine >= ((y + rheight) & 0xff) && !(y < this.curLine)) continue;
}
else
{
if (this.curLine < y || this.curLine >= ((y + rheight) & 0xff)) continue;
}
int scale = 1;
if ((attr0 & (1 << 13)) != 0) scale = 2;
int spritey = this.curLine - y;
if (spritey < 0) spritey += 256;
if (semiTransparent)
{
if ((attr0 & (1 << 8)) == 0)
{
if ((attr1 & (1 << 13)) != 0) spritey = (height - 1) - spritey;
int baseSprite;
if ((this.dispCnt & (1 << 6)) != 0)
{
// 1 dimensional
baseSprite = (attr2 & 0x3FF) + ((spritey / 8) * (width / 8)) * scale;
}
else
{
// 2 dimensional
baseSprite = (attr2 & 0x3FF) + ((spritey / 8) * 0x20);
}
int baseInc = scale;
if ((attr1 & (1 << 12)) != 0)
{
baseSprite += ((width / 8) * scale) - scale;
baseInc = -baseInc;
}
if ((attr0 & (1 << 13)) != 0)
{
// 256 colors
for (int i = x; i < x + width; i++)
{
if ((i & 0x1ff) < 240 && true)
{
int tx = (i - x) & 7;
if ((attr1 & (1 << 12)) != 0) tx = 7 - tx;
int curIdx = baseSprite * 32 + ((spritey & 7) * 8) + tx;
int lookup = vram[0x10000 + curIdx];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[0x200 + lookup * 2] | (palette[0x200 + lookup * 2 + 1] << 8)));
if ((this.blend[i & 0x1ff] & this.blendTarget) != 0 && this.blend[i & 0x1ff] != blendMaskType)
{
uint r = ((pixelColor & 0xFF) * this.blendA) >> 4;
uint g = (((pixelColor >> 8) & 0xFF) * this.blendA) >> 4;
uint b = (((pixelColor >> 16) & 0xFF) * this.blendA) >> 4;
uint sourceValue = this.scanline[(i & 0x1ff)];
r += ((sourceValue & 0xFF) * this.blendB) >> 4;
g += (((sourceValue >> 8) & 0xFF) * this.blendB) >> 4;
b += (((sourceValue >> 16) & 0xFF) * this.blendB) >> 4;
if (r > 0xff) r = 0xff;
if (g > 0xff) g = 0xff;
if (b > 0xff) b = 0xff;
pixelColor = r | (g << 8) | (b << 16);
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
if (((i - x) & 7) == 7) baseSprite += baseInc;
}
}
else
{
// 16 colors
int palIdx = 0x200 + (((attr2 >> 12) & 0xF) * 16 * 2);
for (int i = x; i < x + width; i++)
{
if ((i & 0x1ff) < 240 && true)
{
int tx = (i - x) & 7;
if ((attr1 & (1 << 12)) != 0) tx = 7 - tx;
int curIdx = baseSprite * 32 + ((spritey & 7) * 4) + (tx / 2);
int lookup = vram[0x10000 + curIdx];
if ((tx & 1) == 0)
{
lookup &= 0xf;
}
else
{
lookup >>= 4;
}
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[palIdx + lookup * 2] | (palette[palIdx + lookup * 2 + 1] << 8)));
if ((this.blend[i & 0x1ff] & this.blendTarget) != 0 && this.blend[i & 0x1ff] != blendMaskType)
{
uint r = ((pixelColor & 0xFF) * this.blendA) >> 4;
uint g = (((pixelColor >> 8) & 0xFF) * this.blendA) >> 4;
uint b = (((pixelColor >> 16) & 0xFF) * this.blendA) >> 4;
uint sourceValue = this.scanline[(i & 0x1ff)];
r += ((sourceValue & 0xFF) * this.blendB) >> 4;
g += (((sourceValue >> 8) & 0xFF) * this.blendB) >> 4;
b += (((sourceValue >> 16) & 0xFF) * this.blendB) >> 4;
if (r > 0xff) r = 0xff;
if (g > 0xff) g = 0xff;
if (b > 0xff) b = 0xff;
pixelColor = r | (g << 8) | (b << 16);
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
if (((i - x) & 7) == 7) baseSprite += baseInc;
}
}
}
else
{
int rotScaleParam = (attr1 >> 9) & 0x1F;
short dx = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x6);
short dmx = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0xE);
short dy = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x16);
short dmy = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x1E);
int cx = rwidth / 2;
int cy = rheight / 2;
int baseSprite = attr2 & 0x3FF;
int pitch;
if ((this.dispCnt & (1 << 6)) != 0)
{
// 1 dimensional
pitch = (width / 8) * scale;
}
else
{
// 2 dimensional
pitch = 0x20;
}
int rx = (int)((dmx * (spritey - cy)) - (cx * dx) + (width << 7));
int ry = (int)((dmy * (spritey - cy)) - (cx * dy) + (height << 7));
// Draw a rot/scale sprite
if ((attr0 & (1 << 13)) != 0)
{
// 256 colors
for (int i = x; i < x + rwidth; i++)
{
int tx = rx >> 8;
int ty = ry >> 8;
if ((i & 0x1ff) < 240 && tx >= 0 && tx < width && ty >= 0 && ty < height
&& true)
{
int curIdx = (baseSprite + ((ty / 8) * pitch) + ((tx / 8) * scale)) * 32 + ((ty & 7) * 8) + (tx & 7);
int lookup = vram[0x10000 + curIdx];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[0x200 + lookup * 2] | (palette[0x200 + lookup * 2 + 1] << 8)));
if ((this.blend[i & 0x1ff] & this.blendTarget) != 0 && this.blend[i & 0x1ff] != blendMaskType)
{
uint r = ((pixelColor & 0xFF) * this.blendA) >> 4;
uint g = (((pixelColor >> 8) & 0xFF) * this.blendA) >> 4;
uint b = (((pixelColor >> 16) & 0xFF) * this.blendA) >> 4;
uint sourceValue = this.scanline[(i & 0x1ff)];
r += ((sourceValue & 0xFF) * this.blendB) >> 4;
g += (((sourceValue >> 8) & 0xFF) * this.blendB) >> 4;
b += (((sourceValue >> 16) & 0xFF) * this.blendB) >> 4;
if (r > 0xff) r = 0xff;
if (g > 0xff) g = 0xff;
if (b > 0xff) b = 0xff;
pixelColor = r | (g << 8) | (b << 16);
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
rx += dx;
ry += dy;
}
}
else
{
// 16 colors
int palIdx = 0x200 + (((attr2 >> 12) & 0xF) * 16 * 2);
for (int i = x; i < x + rwidth; i++)
{
int tx = rx >> 8;
int ty = ry >> 8;
if ((i & 0x1ff) < 240 && tx >= 0 && tx < width && ty >= 0 && ty < height
&& true)
{
int curIdx = (baseSprite + ((ty / 8) * pitch) + ((tx / 8) * scale)) * 32 + ((ty & 7) * 4) + ((tx & 7) / 2);
int lookup = vram[0x10000 + curIdx];
if ((tx & 1) == 0)
{
lookup &= 0xf;
}
else
{
lookup >>= 4;
}
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[palIdx + lookup * 2] | (palette[palIdx + lookup * 2 + 1] << 8)));
if ((this.blend[i & 0x1ff] & this.blendTarget) != 0 && this.blend[i & 0x1ff] != blendMaskType)
{
uint r = ((pixelColor & 0xFF) * this.blendA) >> 4;
uint g = (((pixelColor >> 8) & 0xFF) * this.blendA) >> 4;
uint b = (((pixelColor >> 16) & 0xFF) * this.blendA) >> 4;
uint sourceValue = this.scanline[(i & 0x1ff)];
r += ((sourceValue & 0xFF) * this.blendB) >> 4;
g += (((sourceValue >> 8) & 0xFF) * this.blendB) >> 4;
b += (((sourceValue >> 16) & 0xFF) * this.blendB) >> 4;
if (r > 0xff) r = 0xff;
if (g > 0xff) g = 0xff;
if (b > 0xff) b = 0xff;
pixelColor = r | (g << 8) | (b << 16);
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
rx += dx;
ry += dy;
}
}
}
}
else
{
if ((attr0 & (1 << 8)) == 0)
{
if ((attr1 & (1 << 13)) != 0) spritey = (height - 1) - spritey;
int baseSprite;
if ((this.dispCnt & (1 << 6)) != 0)
{
// 1 dimensional
baseSprite = (attr2 & 0x3FF) + ((spritey / 8) * (width / 8)) * scale;
}
else
{
// 2 dimensional
baseSprite = (attr2 & 0x3FF) + ((spritey / 8) * 0x20);
}
int baseInc = scale;
if ((attr1 & (1 << 12)) != 0)
{
baseSprite += ((width / 8) * scale) - scale;
baseInc = -baseInc;
}
if ((attr0 & (1 << 13)) != 0)
{
// 256 colors
for (int i = x; i < x + width; i++)
{
if ((i & 0x1ff) < 240 && true)
{
int tx = (i - x) & 7;
if ((attr1 & (1 << 12)) != 0) tx = 7 - tx;
int curIdx = baseSprite * 32 + ((spritey & 7) * 8) + tx;
int lookup = vram[0x10000 + curIdx];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[0x200 + lookup * 2] | (palette[0x200 + lookup * 2 + 1] << 8)));
if ((this.blend[i & 0x1ff] & this.blendTarget) != 0 && this.blend[i & 0x1ff] != blendMaskType)
{
uint r = ((pixelColor & 0xFF) * this.blendA) >> 4;
uint g = (((pixelColor >> 8) & 0xFF) * this.blendA) >> 4;
uint b = (((pixelColor >> 16) & 0xFF) * this.blendA) >> 4;
uint sourceValue = this.scanline[(i & 0x1ff)];
r += ((sourceValue & 0xFF) * this.blendB) >> 4;
g += (((sourceValue >> 8) & 0xFF) * this.blendB) >> 4;
b += (((sourceValue >> 16) & 0xFF) * this.blendB) >> 4;
if (r > 0xff) r = 0xff;
if (g > 0xff) g = 0xff;
if (b > 0xff) b = 0xff;
pixelColor = r | (g << 8) | (b << 16);
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
if (((i - x) & 7) == 7) baseSprite += baseInc;
}
}
else
{
// 16 colors
int palIdx = 0x200 + (((attr2 >> 12) & 0xF) * 16 * 2);
for (int i = x; i < x + width; i++)
{
if ((i & 0x1ff) < 240 && true)
{
int tx = (i - x) & 7;
if ((attr1 & (1 << 12)) != 0) tx = 7 - tx;
int curIdx = baseSprite * 32 + ((spritey & 7) * 4) + (tx / 2);
int lookup = vram[0x10000 + curIdx];
if ((tx & 1) == 0)
{
lookup &= 0xf;
}
else
{
lookup >>= 4;
}
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[palIdx + lookup * 2] | (palette[palIdx + lookup * 2 + 1] << 8)));
if ((this.blend[i & 0x1ff] & this.blendTarget) != 0 && this.blend[i & 0x1ff] != blendMaskType)
{
uint r = ((pixelColor & 0xFF) * this.blendA) >> 4;
uint g = (((pixelColor >> 8) & 0xFF) * this.blendA) >> 4;
uint b = (((pixelColor >> 16) & 0xFF) * this.blendA) >> 4;
uint sourceValue = this.scanline[(i & 0x1ff)];
r += ((sourceValue & 0xFF) * this.blendB) >> 4;
g += (((sourceValue >> 8) & 0xFF) * this.blendB) >> 4;
b += (((sourceValue >> 16) & 0xFF) * this.blendB) >> 4;
if (r > 0xff) r = 0xff;
if (g > 0xff) g = 0xff;
if (b > 0xff) b = 0xff;
pixelColor = r | (g << 8) | (b << 16);
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
if (((i - x) & 7) == 7) baseSprite += baseInc;
}
}
}
else
{
int rotScaleParam = (attr1 >> 9) & 0x1F;
short dx = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x6);
short dmx = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0xE);
short dy = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x16);
short dmy = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x1E);
int cx = rwidth / 2;
int cy = rheight / 2;
int baseSprite = attr2 & 0x3FF;
int pitch;
if ((this.dispCnt & (1 << 6)) != 0)
{
// 1 dimensional
pitch = (width / 8) * scale;
}
else
{
// 2 dimensional
pitch = 0x20;
}
int rx = (int)((dmx * (spritey - cy)) - (cx * dx) + (width << 7));
int ry = (int)((dmy * (spritey - cy)) - (cx * dy) + (height << 7));
// Draw a rot/scale sprite
if ((attr0 & (1 << 13)) != 0)
{
// 256 colors
for (int i = x; i < x + rwidth; i++)
{
int tx = rx >> 8;
int ty = ry >> 8;
if ((i & 0x1ff) < 240 && tx >= 0 && tx < width && ty >= 0 && ty < height
&& true)
{
int curIdx = (baseSprite + ((ty / 8) * pitch) + ((tx / 8) * scale)) * 32 + ((ty & 7) * 8) + (tx & 7);
int lookup = vram[0x10000 + curIdx];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[0x200 + lookup * 2] | (palette[0x200 + lookup * 2 + 1] << 8)));
if ((this.blend[i & 0x1ff] & this.blendTarget) != 0 && this.blend[i & 0x1ff] != blendMaskType)
{
uint r = ((pixelColor & 0xFF) * this.blendA) >> 4;
uint g = (((pixelColor >> 8) & 0xFF) * this.blendA) >> 4;
uint b = (((pixelColor >> 16) & 0xFF) * this.blendA) >> 4;
uint sourceValue = this.scanline[(i & 0x1ff)];
r += ((sourceValue & 0xFF) * this.blendB) >> 4;
g += (((sourceValue >> 8) & 0xFF) * this.blendB) >> 4;
b += (((sourceValue >> 16) & 0xFF) * this.blendB) >> 4;
if (r > 0xff) r = 0xff;
if (g > 0xff) g = 0xff;
if (b > 0xff) b = 0xff;
pixelColor = r | (g << 8) | (b << 16);
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
rx += dx;
ry += dy;
}
}
else
{
// 16 colors
int palIdx = 0x200 + (((attr2 >> 12) & 0xF) * 16 * 2);
for (int i = x; i < x + rwidth; i++)
{
int tx = rx >> 8;
int ty = ry >> 8;
if ((i & 0x1ff) < 240 && tx >= 0 && tx < width && ty >= 0 && ty < height
&& true)
{
int curIdx = (baseSprite + ((ty / 8) * pitch) + ((tx / 8) * scale)) * 32 + ((ty & 7) * 4) + ((tx & 7) / 2);
int lookup = vram[0x10000 + curIdx];
if ((tx & 1) == 0)
{
lookup &= 0xf;
}
else
{
lookup >>= 4;
}
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[palIdx + lookup * 2] | (palette[palIdx + lookup * 2 + 1] << 8)));
if ((this.blend[i & 0x1ff] & this.blendTarget) != 0 && this.blend[i & 0x1ff] != blendMaskType)
{
uint r = ((pixelColor & 0xFF) * this.blendA) >> 4;
uint g = (((pixelColor >> 8) & 0xFF) * this.blendA) >> 4;
uint b = (((pixelColor >> 16) & 0xFF) * this.blendA) >> 4;
uint sourceValue = this.scanline[(i & 0x1ff)];
r += ((sourceValue & 0xFF) * this.blendB) >> 4;
g += (((sourceValue >> 8) & 0xFF) * this.blendB) >> 4;
b += (((sourceValue >> 16) & 0xFF) * this.blendB) >> 4;
if (r > 0xff) r = 0xff;
if (g > 0xff) g = 0xff;
if (b > 0xff) b = 0xff;
pixelColor = r | (g << 8) | (b << 16);
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
rx += dx;
ry += dy;
}
}
}
}
}
}
private void DrawSpritesBrightInc(int priority)
{
byte[] palette = this.memory.PaletteRam;
byte[] vram = this.memory.VideoRam;
// OBJ must be enabled in this.dispCnt
if ((this.dispCnt & (1 << 12)) == 0) return;
byte blendMaskType = (byte)(1 << 4);
for (int oamNum = 127; oamNum >= 0; oamNum--)
{
ushort attr2 = this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(oamNum * 8) + 4);
if (((attr2 >> 10) & 3) != priority) continue;
ushort attr0 = this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(oamNum * 8) + 0);
ushort attr1 = this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(oamNum * 8) + 2);
int x = attr1 & 0x1FF;
int y = attr0 & 0xFF;
bool semiTransparent = false;
switch ((attr0 >> 10) & 3)
{
case 1:
// Semi-transparent
semiTransparent = true;
break;
case 2:
// Obj window
continue;
case 3:
continue;
}
if ((this.dispCnt & 0x7) >= 3 && (attr2 & 0x3FF) < 0x200) continue;
int width = -1, height = -1;
switch ((attr0 >> 14) & 3)
{
case 0:
// Square
switch ((attr1 >> 14) & 3)
{
case 0: width = 8; height = 8; break;
case 1: width = 16; height = 16; break;
case 2: width = 32; height = 32; break;
case 3: width = 64; height = 64; break;
}
break;
case 1:
// Horizontal Rectangle
switch ((attr1 >> 14) & 3)
{
case 0: width = 16; height = 8; break;
case 1: width = 32; height = 8; break;
case 2: width = 32; height = 16; break;
case 3: width = 64; height = 32; break;
}
break;
case 2:
// Vertical Rectangle
switch ((attr1 >> 14) & 3)
{
case 0: width = 8; height = 16; break;
case 1: width = 8; height = 32; break;
case 2: width = 16; height = 32; break;
case 3: width = 32; height = 64; break;
}
break;
}
// Check double size flag here
int rwidth = width, rheight = height;
if ((attr0 & (1 << 8)) != 0)
{
// Rot-scale on
if ((attr0 & (1 << 9)) != 0)
{
rwidth *= 2;
rheight *= 2;
}
}
else
{
// Invalid sprite
if ((attr0 & (1 << 9)) != 0)
width = -1;
}
if (width == -1)
{
// Invalid sprite
continue;
}
// Y clipping
if (y > ((y + rheight) & 0xff))
{
if (this.curLine >= ((y + rheight) & 0xff) && !(y < this.curLine)) continue;
}
else
{
if (this.curLine < y || this.curLine >= ((y + rheight) & 0xff)) continue;
}
int scale = 1;
if ((attr0 & (1 << 13)) != 0) scale = 2;
int spritey = this.curLine - y;
if (spritey < 0) spritey += 256;
if (semiTransparent)
{
if ((attr0 & (1 << 8)) == 0)
{
if ((attr1 & (1 << 13)) != 0) spritey = (height - 1) - spritey;
int baseSprite;
if ((this.dispCnt & (1 << 6)) != 0)
{
// 1 dimensional
baseSprite = (attr2 & 0x3FF) + ((spritey / 8) * (width / 8)) * scale;
}
else
{
// 2 dimensional
baseSprite = (attr2 & 0x3FF) + ((spritey / 8) * 0x20);
}
int baseInc = scale;
if ((attr1 & (1 << 12)) != 0)
{
baseSprite += ((width / 8) * scale) - scale;
baseInc = -baseInc;
}
if ((attr0 & (1 << 13)) != 0)
{
// 256 colors
for (int i = x; i < x + width; i++)
{
if ((i & 0x1ff) < 240 && true)
{
int tx = (i - x) & 7;
if ((attr1 & (1 << 12)) != 0) tx = 7 - tx;
int curIdx = baseSprite * 32 + ((spritey & 7) * 8) + tx;
int lookup = vram[0x10000 + curIdx];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[0x200 + lookup * 2] | (palette[0x200 + lookup * 2 + 1] << 8)));
if ((this.blend[i & 0x1ff] & this.blendTarget) != 0 && this.blend[i & 0x1ff] != blendMaskType)
{
uint r = ((pixelColor & 0xFF) * this.blendA) >> 4;
uint g = (((pixelColor >> 8) & 0xFF) * this.blendA) >> 4;
uint b = (((pixelColor >> 16) & 0xFF) * this.blendA) >> 4;
uint sourceValue = this.scanline[(i & 0x1ff)];
r += ((sourceValue & 0xFF) * this.blendB) >> 4;
g += (((sourceValue >> 8) & 0xFF) * this.blendB) >> 4;
b += (((sourceValue >> 16) & 0xFF) * this.blendB) >> 4;
if (r > 0xff) r = 0xff;
if (g > 0xff) g = 0xff;
if (b > 0xff) b = 0xff;
pixelColor = r | (g << 8) | (b << 16);
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
if (((i - x) & 7) == 7) baseSprite += baseInc;
}
}
else
{
// 16 colors
int palIdx = 0x200 + (((attr2 >> 12) & 0xF) * 16 * 2);
for (int i = x; i < x + width; i++)
{
if ((i & 0x1ff) < 240 && true)
{
int tx = (i - x) & 7;
if ((attr1 & (1 << 12)) != 0) tx = 7 - tx;
int curIdx = baseSprite * 32 + ((spritey & 7) * 4) + (tx / 2);
int lookup = vram[0x10000 + curIdx];
if ((tx & 1) == 0)
{
lookup &= 0xf;
}
else
{
lookup >>= 4;
}
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[palIdx + lookup * 2] | (palette[palIdx + lookup * 2 + 1] << 8)));
if ((this.blend[i & 0x1ff] & this.blendTarget) != 0 && this.blend[i & 0x1ff] != blendMaskType)
{
uint r = ((pixelColor & 0xFF) * this.blendA) >> 4;
uint g = (((pixelColor >> 8) & 0xFF) * this.blendA) >> 4;
uint b = (((pixelColor >> 16) & 0xFF) * this.blendA) >> 4;
uint sourceValue = this.scanline[(i & 0x1ff)];
r += ((sourceValue & 0xFF) * this.blendB) >> 4;
g += (((sourceValue >> 8) & 0xFF) * this.blendB) >> 4;
b += (((sourceValue >> 16) & 0xFF) * this.blendB) >> 4;
if (r > 0xff) r = 0xff;
if (g > 0xff) g = 0xff;
if (b > 0xff) b = 0xff;
pixelColor = r | (g << 8) | (b << 16);
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
if (((i - x) & 7) == 7) baseSprite += baseInc;
}
}
}
else
{
int rotScaleParam = (attr1 >> 9) & 0x1F;
short dx = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x6);
short dmx = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0xE);
short dy = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x16);
short dmy = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x1E);
int cx = rwidth / 2;
int cy = rheight / 2;
int baseSprite = attr2 & 0x3FF;
int pitch;
if ((this.dispCnt & (1 << 6)) != 0)
{
// 1 dimensional
pitch = (width / 8) * scale;
}
else
{
// 2 dimensional
pitch = 0x20;
}
int rx = (int)((dmx * (spritey - cy)) - (cx * dx) + (width << 7));
int ry = (int)((dmy * (spritey - cy)) - (cx * dy) + (height << 7));
// Draw a rot/scale sprite
if ((attr0 & (1 << 13)) != 0)
{
// 256 colors
for (int i = x; i < x + rwidth; i++)
{
int tx = rx >> 8;
int ty = ry >> 8;
if ((i & 0x1ff) < 240 && tx >= 0 && tx < width && ty >= 0 && ty < height
&& true)
{
int curIdx = (baseSprite + ((ty / 8) * pitch) + ((tx / 8) * scale)) * 32 + ((ty & 7) * 8) + (tx & 7);
int lookup = vram[0x10000 + curIdx];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[0x200 + lookup * 2] | (palette[0x200 + lookup * 2 + 1] << 8)));
if ((this.blend[i & 0x1ff] & this.blendTarget) != 0 && this.blend[i & 0x1ff] != blendMaskType)
{
uint r = ((pixelColor & 0xFF) * this.blendA) >> 4;
uint g = (((pixelColor >> 8) & 0xFF) * this.blendA) >> 4;
uint b = (((pixelColor >> 16) & 0xFF) * this.blendA) >> 4;
uint sourceValue = this.scanline[(i & 0x1ff)];
r += ((sourceValue & 0xFF) * this.blendB) >> 4;
g += (((sourceValue >> 8) & 0xFF) * this.blendB) >> 4;
b += (((sourceValue >> 16) & 0xFF) * this.blendB) >> 4;
if (r > 0xff) r = 0xff;
if (g > 0xff) g = 0xff;
if (b > 0xff) b = 0xff;
pixelColor = r | (g << 8) | (b << 16);
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
rx += dx;
ry += dy;
}
}
else
{
// 16 colors
int palIdx = 0x200 + (((attr2 >> 12) & 0xF) * 16 * 2);
for (int i = x; i < x + rwidth; i++)
{
int tx = rx >> 8;
int ty = ry >> 8;
if ((i & 0x1ff) < 240 && tx >= 0 && tx < width && ty >= 0 && ty < height
&& true)
{
int curIdx = (baseSprite + ((ty / 8) * pitch) + ((tx / 8) * scale)) * 32 + ((ty & 7) * 4) + ((tx & 7) / 2);
int lookup = vram[0x10000 + curIdx];
if ((tx & 1) == 0)
{
lookup &= 0xf;
}
else
{
lookup >>= 4;
}
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[palIdx + lookup * 2] | (palette[palIdx + lookup * 2 + 1] << 8)));
if ((this.blend[i & 0x1ff] & this.blendTarget) != 0 && this.blend[i & 0x1ff] != blendMaskType)
{
uint r = ((pixelColor & 0xFF) * this.blendA) >> 4;
uint g = (((pixelColor >> 8) & 0xFF) * this.blendA) >> 4;
uint b = (((pixelColor >> 16) & 0xFF) * this.blendA) >> 4;
uint sourceValue = this.scanline[(i & 0x1ff)];
r += ((sourceValue & 0xFF) * this.blendB) >> 4;
g += (((sourceValue >> 8) & 0xFF) * this.blendB) >> 4;
b += (((sourceValue >> 16) & 0xFF) * this.blendB) >> 4;
if (r > 0xff) r = 0xff;
if (g > 0xff) g = 0xff;
if (b > 0xff) b = 0xff;
pixelColor = r | (g << 8) | (b << 16);
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
rx += dx;
ry += dy;
}
}
}
}
else
{
if ((attr0 & (1 << 8)) == 0)
{
if ((attr1 & (1 << 13)) != 0) spritey = (height - 1) - spritey;
int baseSprite;
if ((this.dispCnt & (1 << 6)) != 0)
{
// 1 dimensional
baseSprite = (attr2 & 0x3FF) + ((spritey / 8) * (width / 8)) * scale;
}
else
{
// 2 dimensional
baseSprite = (attr2 & 0x3FF) + ((spritey / 8) * 0x20);
}
int baseInc = scale;
if ((attr1 & (1 << 12)) != 0)
{
baseSprite += ((width / 8) * scale) - scale;
baseInc = -baseInc;
}
if ((attr0 & (1 << 13)) != 0)
{
// 256 colors
for (int i = x; i < x + width; i++)
{
if ((i & 0x1ff) < 240 && true)
{
int tx = (i - x) & 7;
if ((attr1 & (1 << 12)) != 0) tx = 7 - tx;
int curIdx = baseSprite * 32 + ((spritey & 7) * 8) + tx;
int lookup = vram[0x10000 + curIdx];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[0x200 + lookup * 2] | (palette[0x200 + lookup * 2 + 1] << 8)));
uint r = pixelColor & 0xFF;
uint g = (pixelColor >> 8) & 0xFF;
uint b = (pixelColor >> 16) & 0xFF;
r = r + (((0xFF - r) * this.blendY) >> 4);
g = g + (((0xFF - g) * this.blendY) >> 4);
b = b + (((0xFF - b) * this.blendY) >> 4);
pixelColor = r | (g << 8) | (b << 16);
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
if (((i - x) & 7) == 7) baseSprite += baseInc;
}
}
else
{
// 16 colors
int palIdx = 0x200 + (((attr2 >> 12) & 0xF) * 16 * 2);
for (int i = x; i < x + width; i++)
{
if ((i & 0x1ff) < 240 && true)
{
int tx = (i - x) & 7;
if ((attr1 & (1 << 12)) != 0) tx = 7 - tx;
int curIdx = baseSprite * 32 + ((spritey & 7) * 4) + (tx / 2);
int lookup = vram[0x10000 + curIdx];
if ((tx & 1) == 0)
{
lookup &= 0xf;
}
else
{
lookup >>= 4;
}
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[palIdx + lookup * 2] | (palette[palIdx + lookup * 2 + 1] << 8)));
uint r = pixelColor & 0xFF;
uint g = (pixelColor >> 8) & 0xFF;
uint b = (pixelColor >> 16) & 0xFF;
r = r + (((0xFF - r) * this.blendY) >> 4);
g = g + (((0xFF - g) * this.blendY) >> 4);
b = b + (((0xFF - b) * this.blendY) >> 4);
pixelColor = r | (g << 8) | (b << 16);
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
if (((i - x) & 7) == 7) baseSprite += baseInc;
}
}
}
else
{
int rotScaleParam = (attr1 >> 9) & 0x1F;
short dx = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x6);
short dmx = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0xE);
short dy = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x16);
short dmy = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x1E);
int cx = rwidth / 2;
int cy = rheight / 2;
int baseSprite = attr2 & 0x3FF;
int pitch;
if ((this.dispCnt & (1 << 6)) != 0)
{
// 1 dimensional
pitch = (width / 8) * scale;
}
else
{
// 2 dimensional
pitch = 0x20;
}
int rx = (int)((dmx * (spritey - cy)) - (cx * dx) + (width << 7));
int ry = (int)((dmy * (spritey - cy)) - (cx * dy) + (height << 7));
// Draw a rot/scale sprite
if ((attr0 & (1 << 13)) != 0)
{
// 256 colors
for (int i = x; i < x + rwidth; i++)
{
int tx = rx >> 8;
int ty = ry >> 8;
if ((i & 0x1ff) < 240 && tx >= 0 && tx < width && ty >= 0 && ty < height
&& true)
{
int curIdx = (baseSprite + ((ty / 8) * pitch) + ((tx / 8) * scale)) * 32 + ((ty & 7) * 8) + (tx & 7);
int lookup = vram[0x10000 + curIdx];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[0x200 + lookup * 2] | (palette[0x200 + lookup * 2 + 1] << 8)));
uint r = pixelColor & 0xFF;
uint g = (pixelColor >> 8) & 0xFF;
uint b = (pixelColor >> 16) & 0xFF;
r = r + (((0xFF - r) * this.blendY) >> 4);
g = g + (((0xFF - g) * this.blendY) >> 4);
b = b + (((0xFF - b) * this.blendY) >> 4);
pixelColor = r | (g << 8) | (b << 16);
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
rx += dx;
ry += dy;
}
}
else
{
// 16 colors
int palIdx = 0x200 + (((attr2 >> 12) & 0xF) * 16 * 2);
for (int i = x; i < x + rwidth; i++)
{
int tx = rx >> 8;
int ty = ry >> 8;
if ((i & 0x1ff) < 240 && tx >= 0 && tx < width && ty >= 0 && ty < height
&& true)
{
int curIdx = (baseSprite + ((ty / 8) * pitch) + ((tx / 8) * scale)) * 32 + ((ty & 7) * 4) + ((tx & 7) / 2);
int lookup = vram[0x10000 + curIdx];
if ((tx & 1) == 0)
{
lookup &= 0xf;
}
else
{
lookup >>= 4;
}
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[palIdx + lookup * 2] | (palette[palIdx + lookup * 2 + 1] << 8)));
uint r = pixelColor & 0xFF;
uint g = (pixelColor >> 8) & 0xFF;
uint b = (pixelColor >> 16) & 0xFF;
r = r + (((0xFF - r) * this.blendY) >> 4);
g = g + (((0xFF - g) * this.blendY) >> 4);
b = b + (((0xFF - b) * this.blendY) >> 4);
pixelColor = r | (g << 8) | (b << 16);
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
rx += dx;
ry += dy;
}
}
}
}
}
}
private void DrawSpritesBrightDec(int priority)
{
byte[] palette = this.memory.PaletteRam;
byte[] vram = this.memory.VideoRam;
// OBJ must be enabled in this.dispCnt
if ((this.dispCnt & (1 << 12)) == 0) return;
byte blendMaskType = (byte)(1 << 4);
for (int oamNum = 127; oamNum >= 0; oamNum--)
{
ushort attr2 = this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(oamNum * 8) + 4);
if (((attr2 >> 10) & 3) != priority) continue;
ushort attr0 = this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(oamNum * 8) + 0);
ushort attr1 = this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(oamNum * 8) + 2);
int x = attr1 & 0x1FF;
int y = attr0 & 0xFF;
bool semiTransparent = false;
switch ((attr0 >> 10) & 3)
{
case 1:
// Semi-transparent
semiTransparent = true;
break;
case 2:
// Obj window
continue;
case 3:
continue;
}
if ((this.dispCnt & 0x7) >= 3 && (attr2 & 0x3FF) < 0x200) continue;
int width = -1, height = -1;
switch ((attr0 >> 14) & 3)
{
case 0:
// Square
switch ((attr1 >> 14) & 3)
{
case 0: width = 8; height = 8; break;
case 1: width = 16; height = 16; break;
case 2: width = 32; height = 32; break;
case 3: width = 64; height = 64; break;
}
break;
case 1:
// Horizontal Rectangle
switch ((attr1 >> 14) & 3)
{
case 0: width = 16; height = 8; break;
case 1: width = 32; height = 8; break;
case 2: width = 32; height = 16; break;
case 3: width = 64; height = 32; break;
}
break;
case 2:
// Vertical Rectangle
switch ((attr1 >> 14) & 3)
{
case 0: width = 8; height = 16; break;
case 1: width = 8; height = 32; break;
case 2: width = 16; height = 32; break;
case 3: width = 32; height = 64; break;
}
break;
}
// Check double size flag here
int rwidth = width, rheight = height;
if ((attr0 & (1 << 8)) != 0)
{
// Rot-scale on
if ((attr0 & (1 << 9)) != 0)
{
rwidth *= 2;
rheight *= 2;
}
}
else
{
// Invalid sprite
if ((attr0 & (1 << 9)) != 0)
width = -1;
}
if (width == -1)
{
// Invalid sprite
continue;
}
// Y clipping
if (y > ((y + rheight) & 0xff))
{
if (this.curLine >= ((y + rheight) & 0xff) && !(y < this.curLine)) continue;
}
else
{
if (this.curLine < y || this.curLine >= ((y + rheight) & 0xff)) continue;
}
int scale = 1;
if ((attr0 & (1 << 13)) != 0) scale = 2;
int spritey = this.curLine - y;
if (spritey < 0) spritey += 256;
if (semiTransparent)
{
if ((attr0 & (1 << 8)) == 0)
{
if ((attr1 & (1 << 13)) != 0) spritey = (height - 1) - spritey;
int baseSprite;
if ((this.dispCnt & (1 << 6)) != 0)
{
// 1 dimensional
baseSprite = (attr2 & 0x3FF) + ((spritey / 8) * (width / 8)) * scale;
}
else
{
// 2 dimensional
baseSprite = (attr2 & 0x3FF) + ((spritey / 8) * 0x20);
}
int baseInc = scale;
if ((attr1 & (1 << 12)) != 0)
{
baseSprite += ((width / 8) * scale) - scale;
baseInc = -baseInc;
}
if ((attr0 & (1 << 13)) != 0)
{
// 256 colors
for (int i = x; i < x + width; i++)
{
if ((i & 0x1ff) < 240 && true)
{
int tx = (i - x) & 7;
if ((attr1 & (1 << 12)) != 0) tx = 7 - tx;
int curIdx = baseSprite * 32 + ((spritey & 7) * 8) + tx;
int lookup = vram[0x10000 + curIdx];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[0x200 + lookup * 2] | (palette[0x200 + lookup * 2 + 1] << 8)));
if ((this.blend[i & 0x1ff] & this.blendTarget) != 0 && this.blend[i & 0x1ff] != blendMaskType)
{
uint r = ((pixelColor & 0xFF) * this.blendA) >> 4;
uint g = (((pixelColor >> 8) & 0xFF) * this.blendA) >> 4;
uint b = (((pixelColor >> 16) & 0xFF) * this.blendA) >> 4;
uint sourceValue = this.scanline[(i & 0x1ff)];
r += ((sourceValue & 0xFF) * this.blendB) >> 4;
g += (((sourceValue >> 8) & 0xFF) * this.blendB) >> 4;
b += (((sourceValue >> 16) & 0xFF) * this.blendB) >> 4;
if (r > 0xff) r = 0xff;
if (g > 0xff) g = 0xff;
if (b > 0xff) b = 0xff;
pixelColor = r | (g << 8) | (b << 16);
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
if (((i - x) & 7) == 7) baseSprite += baseInc;
}
}
else
{
// 16 colors
int palIdx = 0x200 + (((attr2 >> 12) & 0xF) * 16 * 2);
for (int i = x; i < x + width; i++)
{
if ((i & 0x1ff) < 240 && true)
{
int tx = (i - x) & 7;
if ((attr1 & (1 << 12)) != 0) tx = 7 - tx;
int curIdx = baseSprite * 32 + ((spritey & 7) * 4) + (tx / 2);
int lookup = vram[0x10000 + curIdx];
if ((tx & 1) == 0)
{
lookup &= 0xf;
}
else
{
lookup >>= 4;
}
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[palIdx + lookup * 2] | (palette[palIdx + lookup * 2 + 1] << 8)));
if ((this.blend[i & 0x1ff] & this.blendTarget) != 0 && this.blend[i & 0x1ff] != blendMaskType)
{
uint r = ((pixelColor & 0xFF) * this.blendA) >> 4;
uint g = (((pixelColor >> 8) & 0xFF) * this.blendA) >> 4;
uint b = (((pixelColor >> 16) & 0xFF) * this.blendA) >> 4;
uint sourceValue = this.scanline[(i & 0x1ff)];
r += ((sourceValue & 0xFF) * this.blendB) >> 4;
g += (((sourceValue >> 8) & 0xFF) * this.blendB) >> 4;
b += (((sourceValue >> 16) & 0xFF) * this.blendB) >> 4;
if (r > 0xff) r = 0xff;
if (g > 0xff) g = 0xff;
if (b > 0xff) b = 0xff;
pixelColor = r | (g << 8) | (b << 16);
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
if (((i - x) & 7) == 7) baseSprite += baseInc;
}
}
}
else
{
int rotScaleParam = (attr1 >> 9) & 0x1F;
short dx = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x6);
short dmx = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0xE);
short dy = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x16);
short dmy = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x1E);
int cx = rwidth / 2;
int cy = rheight / 2;
int baseSprite = attr2 & 0x3FF;
int pitch;
if ((this.dispCnt & (1 << 6)) != 0)
{
// 1 dimensional
pitch = (width / 8) * scale;
}
else
{
// 2 dimensional
pitch = 0x20;
}
int rx = (int)((dmx * (spritey - cy)) - (cx * dx) + (width << 7));
int ry = (int)((dmy * (spritey - cy)) - (cx * dy) + (height << 7));
// Draw a rot/scale sprite
if ((attr0 & (1 << 13)) != 0)
{
// 256 colors
for (int i = x; i < x + rwidth; i++)
{
int tx = rx >> 8;
int ty = ry >> 8;
if ((i & 0x1ff) < 240 && tx >= 0 && tx < width && ty >= 0 && ty < height
&& true)
{
int curIdx = (baseSprite + ((ty / 8) * pitch) + ((tx / 8) * scale)) * 32 + ((ty & 7) * 8) + (tx & 7);
int lookup = vram[0x10000 + curIdx];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[0x200 + lookup * 2] | (palette[0x200 + lookup * 2 + 1] << 8)));
if ((this.blend[i & 0x1ff] & this.blendTarget) != 0 && this.blend[i & 0x1ff] != blendMaskType)
{
uint r = ((pixelColor & 0xFF) * this.blendA) >> 4;
uint g = (((pixelColor >> 8) & 0xFF) * this.blendA) >> 4;
uint b = (((pixelColor >> 16) & 0xFF) * this.blendA) >> 4;
uint sourceValue = this.scanline[(i & 0x1ff)];
r += ((sourceValue & 0xFF) * this.blendB) >> 4;
g += (((sourceValue >> 8) & 0xFF) * this.blendB) >> 4;
b += (((sourceValue >> 16) & 0xFF) * this.blendB) >> 4;
if (r > 0xff) r = 0xff;
if (g > 0xff) g = 0xff;
if (b > 0xff) b = 0xff;
pixelColor = r | (g << 8) | (b << 16);
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
rx += dx;
ry += dy;
}
}
else
{
// 16 colors
int palIdx = 0x200 + (((attr2 >> 12) & 0xF) * 16 * 2);
for (int i = x; i < x + rwidth; i++)
{
int tx = rx >> 8;
int ty = ry >> 8;
if ((i & 0x1ff) < 240 && tx >= 0 && tx < width && ty >= 0 && ty < height
&& true)
{
int curIdx = (baseSprite + ((ty / 8) * pitch) + ((tx / 8) * scale)) * 32 + ((ty & 7) * 4) + ((tx & 7) / 2);
int lookup = vram[0x10000 + curIdx];
if ((tx & 1) == 0)
{
lookup &= 0xf;
}
else
{
lookup >>= 4;
}
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[palIdx + lookup * 2] | (palette[palIdx + lookup * 2 + 1] << 8)));
if ((this.blend[i & 0x1ff] & this.blendTarget) != 0 && this.blend[i & 0x1ff] != blendMaskType)
{
uint r = ((pixelColor & 0xFF) * this.blendA) >> 4;
uint g = (((pixelColor >> 8) & 0xFF) * this.blendA) >> 4;
uint b = (((pixelColor >> 16) & 0xFF) * this.blendA) >> 4;
uint sourceValue = this.scanline[(i & 0x1ff)];
r += ((sourceValue & 0xFF) * this.blendB) >> 4;
g += (((sourceValue >> 8) & 0xFF) * this.blendB) >> 4;
b += (((sourceValue >> 16) & 0xFF) * this.blendB) >> 4;
if (r > 0xff) r = 0xff;
if (g > 0xff) g = 0xff;
if (b > 0xff) b = 0xff;
pixelColor = r | (g << 8) | (b << 16);
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
rx += dx;
ry += dy;
}
}
}
}
else
{
if ((attr0 & (1 << 8)) == 0)
{
if ((attr1 & (1 << 13)) != 0) spritey = (height - 1) - spritey;
int baseSprite;
if ((this.dispCnt & (1 << 6)) != 0)
{
// 1 dimensional
baseSprite = (attr2 & 0x3FF) + ((spritey / 8) * (width / 8)) * scale;
}
else
{
// 2 dimensional
baseSprite = (attr2 & 0x3FF) + ((spritey / 8) * 0x20);
}
int baseInc = scale;
if ((attr1 & (1 << 12)) != 0)
{
baseSprite += ((width / 8) * scale) - scale;
baseInc = -baseInc;
}
if ((attr0 & (1 << 13)) != 0)
{
// 256 colors
for (int i = x; i < x + width; i++)
{
if ((i & 0x1ff) < 240 && true)
{
int tx = (i - x) & 7;
if ((attr1 & (1 << 12)) != 0) tx = 7 - tx;
int curIdx = baseSprite * 32 + ((spritey & 7) * 8) + tx;
int lookup = vram[0x10000 + curIdx];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[0x200 + lookup * 2] | (palette[0x200 + lookup * 2 + 1] << 8)));
uint r = pixelColor & 0xFF;
uint g = (pixelColor >> 8) & 0xFF;
uint b = (pixelColor >> 16) & 0xFF;
r = r - ((r * this.blendY) >> 4);
g = g - ((g * this.blendY) >> 4);
b = b - ((b * this.blendY) >> 4);
pixelColor = r | (g << 8) | (b << 16);
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
if (((i - x) & 7) == 7) baseSprite += baseInc;
}
}
else
{
// 16 colors
int palIdx = 0x200 + (((attr2 >> 12) & 0xF) * 16 * 2);
for (int i = x; i < x + width; i++)
{
if ((i & 0x1ff) < 240 && true)
{
int tx = (i - x) & 7;
if ((attr1 & (1 << 12)) != 0) tx = 7 - tx;
int curIdx = baseSprite * 32 + ((spritey & 7) * 4) + (tx / 2);
int lookup = vram[0x10000 + curIdx];
if ((tx & 1) == 0)
{
lookup &= 0xf;
}
else
{
lookup >>= 4;
}
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[palIdx + lookup * 2] | (palette[palIdx + lookup * 2 + 1] << 8)));
uint r = pixelColor & 0xFF;
uint g = (pixelColor >> 8) & 0xFF;
uint b = (pixelColor >> 16) & 0xFF;
r = r - ((r * this.blendY) >> 4);
g = g - ((g * this.blendY) >> 4);
b = b - ((b * this.blendY) >> 4);
pixelColor = r | (g << 8) | (b << 16);
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
if (((i - x) & 7) == 7) baseSprite += baseInc;
}
}
}
else
{
int rotScaleParam = (attr1 >> 9) & 0x1F;
short dx = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x6);
short dmx = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0xE);
short dy = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x16);
short dmy = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x1E);
int cx = rwidth / 2;
int cy = rheight / 2;
int baseSprite = attr2 & 0x3FF;
int pitch;
if ((this.dispCnt & (1 << 6)) != 0)
{
// 1 dimensional
pitch = (width / 8) * scale;
}
else
{
// 2 dimensional
pitch = 0x20;
}
int rx = (int)((dmx * (spritey - cy)) - (cx * dx) + (width << 7));
int ry = (int)((dmy * (spritey - cy)) - (cx * dy) + (height << 7));
// Draw a rot/scale sprite
if ((attr0 & (1 << 13)) != 0)
{
// 256 colors
for (int i = x; i < x + rwidth; i++)
{
int tx = rx >> 8;
int ty = ry >> 8;
if ((i & 0x1ff) < 240 && tx >= 0 && tx < width && ty >= 0 && ty < height
&& true)
{
int curIdx = (baseSprite + ((ty / 8) * pitch) + ((tx / 8) * scale)) * 32 + ((ty & 7) * 8) + (tx & 7);
int lookup = vram[0x10000 + curIdx];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[0x200 + lookup * 2] | (palette[0x200 + lookup * 2 + 1] << 8)));
uint r = pixelColor & 0xFF;
uint g = (pixelColor >> 8) & 0xFF;
uint b = (pixelColor >> 16) & 0xFF;
r = r - ((r * this.blendY) >> 4);
g = g - ((g * this.blendY) >> 4);
b = b - ((b * this.blendY) >> 4);
pixelColor = r | (g << 8) | (b << 16);
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
rx += dx;
ry += dy;
}
}
else
{
// 16 colors
int palIdx = 0x200 + (((attr2 >> 12) & 0xF) * 16 * 2);
for (int i = x; i < x + rwidth; i++)
{
int tx = rx >> 8;
int ty = ry >> 8;
if ((i & 0x1ff) < 240 && tx >= 0 && tx < width && ty >= 0 && ty < height
&& true)
{
int curIdx = (baseSprite + ((ty / 8) * pitch) + ((tx / 8) * scale)) * 32 + ((ty & 7) * 4) + ((tx & 7) / 2);
int lookup = vram[0x10000 + curIdx];
if ((tx & 1) == 0)
{
lookup &= 0xf;
}
else
{
lookup >>= 4;
}
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[palIdx + lookup * 2] | (palette[palIdx + lookup * 2 + 1] << 8)));
uint r = pixelColor & 0xFF;
uint g = (pixelColor >> 8) & 0xFF;
uint b = (pixelColor >> 16) & 0xFF;
r = r - ((r * this.blendY) >> 4);
g = g - ((g * this.blendY) >> 4);
b = b - ((b * this.blendY) >> 4);
pixelColor = r | (g << 8) | (b << 16);
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
rx += dx;
ry += dy;
}
}
}
}
}
}
private void DrawSpritesWindow(int priority)
{
byte[] palette = this.memory.PaletteRam;
byte[] vram = this.memory.VideoRam;
// OBJ must be enabled in this.dispCnt
if ((this.dispCnt & (1 << 12)) == 0) return;
byte blendMaskType = (byte)(1 << 4);
for (int oamNum = 127; oamNum >= 0; oamNum--)
{
ushort attr2 = this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(oamNum * 8) + 4);
if (((attr2 >> 10) & 3) != priority) continue;
ushort attr0 = this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(oamNum * 8) + 0);
ushort attr1 = this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(oamNum * 8) + 2);
int x = attr1 & 0x1FF;
int y = attr0 & 0xFF;
bool semiTransparent = false;
switch ((attr0 >> 10) & 3)
{
case 1:
// Semi-transparent
semiTransparent = true;
break;
case 2:
// Obj window
continue;
case 3:
continue;
}
if ((this.dispCnt & 0x7) >= 3 && (attr2 & 0x3FF) < 0x200) continue;
int width = -1, height = -1;
switch ((attr0 >> 14) & 3)
{
case 0:
// Square
switch ((attr1 >> 14) & 3)
{
case 0: width = 8; height = 8; break;
case 1: width = 16; height = 16; break;
case 2: width = 32; height = 32; break;
case 3: width = 64; height = 64; break;
}
break;
case 1:
// Horizontal Rectangle
switch ((attr1 >> 14) & 3)
{
case 0: width = 16; height = 8; break;
case 1: width = 32; height = 8; break;
case 2: width = 32; height = 16; break;
case 3: width = 64; height = 32; break;
}
break;
case 2:
// Vertical Rectangle
switch ((attr1 >> 14) & 3)
{
case 0: width = 8; height = 16; break;
case 1: width = 8; height = 32; break;
case 2: width = 16; height = 32; break;
case 3: width = 32; height = 64; break;
}
break;
}
// Check double size flag here
int rwidth = width, rheight = height;
if ((attr0 & (1 << 8)) != 0)
{
// Rot-scale on
if ((attr0 & (1 << 9)) != 0)
{
rwidth *= 2;
rheight *= 2;
}
}
else
{
// Invalid sprite
if ((attr0 & (1 << 9)) != 0)
width = -1;
}
if (width == -1)
{
// Invalid sprite
continue;
}
// Y clipping
if (y > ((y + rheight) & 0xff))
{
if (this.curLine >= ((y + rheight) & 0xff) && !(y < this.curLine)) continue;
}
else
{
if (this.curLine < y || this.curLine >= ((y + rheight) & 0xff)) continue;
}
int scale = 1;
if ((attr0 & (1 << 13)) != 0) scale = 2;
int spritey = this.curLine - y;
if (spritey < 0) spritey += 256;
if (semiTransparent)
{
if ((attr0 & (1 << 8)) == 0)
{
if ((attr1 & (1 << 13)) != 0) spritey = (height - 1) - spritey;
int baseSprite;
if ((this.dispCnt & (1 << 6)) != 0)
{
// 1 dimensional
baseSprite = (attr2 & 0x3FF) + ((spritey / 8) * (width / 8)) * scale;
}
else
{
// 2 dimensional
baseSprite = (attr2 & 0x3FF) + ((spritey / 8) * 0x20);
}
int baseInc = scale;
if ((attr1 & (1 << 12)) != 0)
{
baseSprite += ((width / 8) * scale) - scale;
baseInc = -baseInc;
}
if ((attr0 & (1 << 13)) != 0)
{
// 256 colors
for (int i = x; i < x + width; i++)
{
if ((i & 0x1ff) < 240 && (this.windowCover[i & 0x1ff] & (1 << 4)) != 0)
{
int tx = (i - x) & 7;
if ((attr1 & (1 << 12)) != 0) tx = 7 - tx;
int curIdx = baseSprite * 32 + ((spritey & 7) * 8) + tx;
int lookup = vram[0x10000 + curIdx];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[0x200 + lookup * 2] | (palette[0x200 + lookup * 2 + 1] << 8)));
if ((this.windowCover[i & 0x1ff] & (1 << 5)) != 0)
{
if ((this.blend[i & 0x1ff] & this.blendTarget) != 0 && this.blend[i & 0x1ff] != blendMaskType)
{
uint r = ((pixelColor & 0xFF) * this.blendA) >> 4;
uint g = (((pixelColor >> 8) & 0xFF) * this.blendA) >> 4;
uint b = (((pixelColor >> 16) & 0xFF) * this.blendA) >> 4;
uint sourceValue = this.scanline[(i & 0x1ff)];
r += ((sourceValue & 0xFF) * this.blendB) >> 4;
g += (((sourceValue >> 8) & 0xFF) * this.blendB) >> 4;
b += (((sourceValue >> 16) & 0xFF) * this.blendB) >> 4;
if (r > 0xff) r = 0xff;
if (g > 0xff) g = 0xff;
if (b > 0xff) b = 0xff;
pixelColor = r | (g << 8) | (b << 16);
}
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
if (((i - x) & 7) == 7) baseSprite += baseInc;
}
}
else
{
// 16 colors
int palIdx = 0x200 + (((attr2 >> 12) & 0xF) * 16 * 2);
for (int i = x; i < x + width; i++)
{
if ((i & 0x1ff) < 240 && (this.windowCover[i & 0x1ff] & (1 << 4)) != 0)
{
int tx = (i - x) & 7;
if ((attr1 & (1 << 12)) != 0) tx = 7 - tx;
int curIdx = baseSprite * 32 + ((spritey & 7) * 4) + (tx / 2);
int lookup = vram[0x10000 + curIdx];
if ((tx & 1) == 0)
{
lookup &= 0xf;
}
else
{
lookup >>= 4;
}
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[palIdx + lookup * 2] | (palette[palIdx + lookup * 2 + 1] << 8)));
if ((this.windowCover[i & 0x1ff] & (1 << 5)) != 0)
{
if ((this.blend[i & 0x1ff] & this.blendTarget) != 0 && this.blend[i & 0x1ff] != blendMaskType)
{
uint r = ((pixelColor & 0xFF) * this.blendA) >> 4;
uint g = (((pixelColor >> 8) & 0xFF) * this.blendA) >> 4;
uint b = (((pixelColor >> 16) & 0xFF) * this.blendA) >> 4;
uint sourceValue = this.scanline[(i & 0x1ff)];
r += ((sourceValue & 0xFF) * this.blendB) >> 4;
g += (((sourceValue >> 8) & 0xFF) * this.blendB) >> 4;
b += (((sourceValue >> 16) & 0xFF) * this.blendB) >> 4;
if (r > 0xff) r = 0xff;
if (g > 0xff) g = 0xff;
if (b > 0xff) b = 0xff;
pixelColor = r | (g << 8) | (b << 16);
}
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
if (((i - x) & 7) == 7) baseSprite += baseInc;
}
}
}
else
{
int rotScaleParam = (attr1 >> 9) & 0x1F;
short dx = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x6);
short dmx = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0xE);
short dy = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x16);
short dmy = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x1E);
int cx = rwidth / 2;
int cy = rheight / 2;
int baseSprite = attr2 & 0x3FF;
int pitch;
if ((this.dispCnt & (1 << 6)) != 0)
{
// 1 dimensional
pitch = (width / 8) * scale;
}
else
{
// 2 dimensional
pitch = 0x20;
}
int rx = (int)((dmx * (spritey - cy)) - (cx * dx) + (width << 7));
int ry = (int)((dmy * (spritey - cy)) - (cx * dy) + (height << 7));
// Draw a rot/scale sprite
if ((attr0 & (1 << 13)) != 0)
{
// 256 colors
for (int i = x; i < x + rwidth; i++)
{
int tx = rx >> 8;
int ty = ry >> 8;
if ((i & 0x1ff) < 240 && tx >= 0 && tx < width && ty >= 0 && ty < height
&& (this.windowCover[i & 0x1ff] & (1 << 4)) != 0)
{
int curIdx = (baseSprite + ((ty / 8) * pitch) + ((tx / 8) * scale)) * 32 + ((ty & 7) * 8) + (tx & 7);
int lookup = vram[0x10000 + curIdx];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[0x200 + lookup * 2] | (palette[0x200 + lookup * 2 + 1] << 8)));
if ((this.windowCover[i & 0x1ff] & (1 << 5)) != 0)
{
if ((this.blend[i & 0x1ff] & this.blendTarget) != 0 && this.blend[i & 0x1ff] != blendMaskType)
{
uint r = ((pixelColor & 0xFF) * this.blendA) >> 4;
uint g = (((pixelColor >> 8) & 0xFF) * this.blendA) >> 4;
uint b = (((pixelColor >> 16) & 0xFF) * this.blendA) >> 4;
uint sourceValue = this.scanline[(i & 0x1ff)];
r += ((sourceValue & 0xFF) * this.blendB) >> 4;
g += (((sourceValue >> 8) & 0xFF) * this.blendB) >> 4;
b += (((sourceValue >> 16) & 0xFF) * this.blendB) >> 4;
if (r > 0xff) r = 0xff;
if (g > 0xff) g = 0xff;
if (b > 0xff) b = 0xff;
pixelColor = r | (g << 8) | (b << 16);
}
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
rx += dx;
ry += dy;
}
}
else
{
// 16 colors
int palIdx = 0x200 + (((attr2 >> 12) & 0xF) * 16 * 2);
for (int i = x; i < x + rwidth; i++)
{
int tx = rx >> 8;
int ty = ry >> 8;
if ((i & 0x1ff) < 240 && tx >= 0 && tx < width && ty >= 0 && ty < height
&& (this.windowCover[i & 0x1ff] & (1 << 4)) != 0)
{
int curIdx = (baseSprite + ((ty / 8) * pitch) + ((tx / 8) * scale)) * 32 + ((ty & 7) * 4) + ((tx & 7) / 2);
int lookup = vram[0x10000 + curIdx];
if ((tx & 1) == 0)
{
lookup &= 0xf;
}
else
{
lookup >>= 4;
}
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[palIdx + lookup * 2] | (palette[palIdx + lookup * 2 + 1] << 8)));
if ((this.windowCover[i & 0x1ff] & (1 << 5)) != 0)
{
if ((this.blend[i & 0x1ff] & this.blendTarget) != 0 && this.blend[i & 0x1ff] != blendMaskType)
{
uint r = ((pixelColor & 0xFF) * this.blendA) >> 4;
uint g = (((pixelColor >> 8) & 0xFF) * this.blendA) >> 4;
uint b = (((pixelColor >> 16) & 0xFF) * this.blendA) >> 4;
uint sourceValue = this.scanline[(i & 0x1ff)];
r += ((sourceValue & 0xFF) * this.blendB) >> 4;
g += (((sourceValue >> 8) & 0xFF) * this.blendB) >> 4;
b += (((sourceValue >> 16) & 0xFF) * this.blendB) >> 4;
if (r > 0xff) r = 0xff;
if (g > 0xff) g = 0xff;
if (b > 0xff) b = 0xff;
pixelColor = r | (g << 8) | (b << 16);
}
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
rx += dx;
ry += dy;
}
}
}
}
else
{
if ((attr0 & (1 << 8)) == 0)
{
if ((attr1 & (1 << 13)) != 0) spritey = (height - 1) - spritey;
int baseSprite;
if ((this.dispCnt & (1 << 6)) != 0)
{
// 1 dimensional
baseSprite = (attr2 & 0x3FF) + ((spritey / 8) * (width / 8)) * scale;
}
else
{
// 2 dimensional
baseSprite = (attr2 & 0x3FF) + ((spritey / 8) * 0x20);
}
int baseInc = scale;
if ((attr1 & (1 << 12)) != 0)
{
baseSprite += ((width / 8) * scale) - scale;
baseInc = -baseInc;
}
if ((attr0 & (1 << 13)) != 0)
{
// 256 colors
for (int i = x; i < x + width; i++)
{
if ((i & 0x1ff) < 240 && (this.windowCover[i & 0x1ff] & (1 << 4)) != 0)
{
int tx = (i - x) & 7;
if ((attr1 & (1 << 12)) != 0) tx = 7 - tx;
int curIdx = baseSprite * 32 + ((spritey & 7) * 8) + tx;
int lookup = vram[0x10000 + curIdx];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[0x200 + lookup * 2] | (palette[0x200 + lookup * 2 + 1] << 8)));
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
if (((i - x) & 7) == 7) baseSprite += baseInc;
}
}
else
{
// 16 colors
int palIdx = 0x200 + (((attr2 >> 12) & 0xF) * 16 * 2);
for (int i = x; i < x + width; i++)
{
if ((i & 0x1ff) < 240 && (this.windowCover[i & 0x1ff] & (1 << 4)) != 0)
{
int tx = (i - x) & 7;
if ((attr1 & (1 << 12)) != 0) tx = 7 - tx;
int curIdx = baseSprite * 32 + ((spritey & 7) * 4) + (tx / 2);
int lookup = vram[0x10000 + curIdx];
if ((tx & 1) == 0)
{
lookup &= 0xf;
}
else
{
lookup >>= 4;
}
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[palIdx + lookup * 2] | (palette[palIdx + lookup * 2 + 1] << 8)));
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
if (((i - x) & 7) == 7) baseSprite += baseInc;
}
}
}
else
{
int rotScaleParam = (attr1 >> 9) & 0x1F;
short dx = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x6);
short dmx = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0xE);
short dy = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x16);
short dmy = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x1E);
int cx = rwidth / 2;
int cy = rheight / 2;
int baseSprite = attr2 & 0x3FF;
int pitch;
if ((this.dispCnt & (1 << 6)) != 0)
{
// 1 dimensional
pitch = (width / 8) * scale;
}
else
{
// 2 dimensional
pitch = 0x20;
}
int rx = (int)((dmx * (spritey - cy)) - (cx * dx) + (width << 7));
int ry = (int)((dmy * (spritey - cy)) - (cx * dy) + (height << 7));
// Draw a rot/scale sprite
if ((attr0 & (1 << 13)) != 0)
{
// 256 colors
for (int i = x; i < x + rwidth; i++)
{
int tx = rx >> 8;
int ty = ry >> 8;
if ((i & 0x1ff) < 240 && tx >= 0 && tx < width && ty >= 0 && ty < height
&& (this.windowCover[i & 0x1ff] & (1 << 4)) != 0)
{
int curIdx = (baseSprite + ((ty / 8) * pitch) + ((tx / 8) * scale)) * 32 + ((ty & 7) * 8) + (tx & 7);
int lookup = vram[0x10000 + curIdx];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[0x200 + lookup * 2] | (palette[0x200 + lookup * 2 + 1] << 8)));
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
rx += dx;
ry += dy;
}
}
else
{
// 16 colors
int palIdx = 0x200 + (((attr2 >> 12) & 0xF) * 16 * 2);
for (int i = x; i < x + rwidth; i++)
{
int tx = rx >> 8;
int ty = ry >> 8;
if ((i & 0x1ff) < 240 && tx >= 0 && tx < width && ty >= 0 && ty < height
&& (this.windowCover[i & 0x1ff] & (1 << 4)) != 0)
{
int curIdx = (baseSprite + ((ty / 8) * pitch) + ((tx / 8) * scale)) * 32 + ((ty & 7) * 4) + ((tx & 7) / 2);
int lookup = vram[0x10000 + curIdx];
if ((tx & 1) == 0)
{
lookup &= 0xf;
}
else
{
lookup >>= 4;
}
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[palIdx + lookup * 2] | (palette[palIdx + lookup * 2 + 1] << 8)));
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
rx += dx;
ry += dy;
}
}
}
}
}
}
private void DrawSpritesWindowBlend(int priority)
{
byte[] palette = this.memory.PaletteRam;
byte[] vram = this.memory.VideoRam;
// OBJ must be enabled in this.dispCnt
if ((this.dispCnt & (1 << 12)) == 0) return;
byte blendMaskType = (byte)(1 << 4);
for (int oamNum = 127; oamNum >= 0; oamNum--)
{
ushort attr2 = this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(oamNum * 8) + 4);
if (((attr2 >> 10) & 3) != priority) continue;
ushort attr0 = this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(oamNum * 8) + 0);
ushort attr1 = this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(oamNum * 8) + 2);
int x = attr1 & 0x1FF;
int y = attr0 & 0xFF;
bool semiTransparent = false;
switch ((attr0 >> 10) & 3)
{
case 1:
// Semi-transparent
semiTransparent = true;
break;
case 2:
// Obj window
continue;
case 3:
continue;
}
if ((this.dispCnt & 0x7) >= 3 && (attr2 & 0x3FF) < 0x200) continue;
int width = -1, height = -1;
switch ((attr0 >> 14) & 3)
{
case 0:
// Square
switch ((attr1 >> 14) & 3)
{
case 0: width = 8; height = 8; break;
case 1: width = 16; height = 16; break;
case 2: width = 32; height = 32; break;
case 3: width = 64; height = 64; break;
}
break;
case 1:
// Horizontal Rectangle
switch ((attr1 >> 14) & 3)
{
case 0: width = 16; height = 8; break;
case 1: width = 32; height = 8; break;
case 2: width = 32; height = 16; break;
case 3: width = 64; height = 32; break;
}
break;
case 2:
// Vertical Rectangle
switch ((attr1 >> 14) & 3)
{
case 0: width = 8; height = 16; break;
case 1: width = 8; height = 32; break;
case 2: width = 16; height = 32; break;
case 3: width = 32; height = 64; break;
}
break;
}
// Check double size flag here
int rwidth = width, rheight = height;
if ((attr0 & (1 << 8)) != 0)
{
// Rot-scale on
if ((attr0 & (1 << 9)) != 0)
{
rwidth *= 2;
rheight *= 2;
}
}
else
{
// Invalid sprite
if ((attr0 & (1 << 9)) != 0)
width = -1;
}
if (width == -1)
{
// Invalid sprite
continue;
}
// Y clipping
if (y > ((y + rheight) & 0xff))
{
if (this.curLine >= ((y + rheight) & 0xff) && !(y < this.curLine)) continue;
}
else
{
if (this.curLine < y || this.curLine >= ((y + rheight) & 0xff)) continue;
}
int scale = 1;
if ((attr0 & (1 << 13)) != 0) scale = 2;
int spritey = this.curLine - y;
if (spritey < 0) spritey += 256;
if (semiTransparent)
{
if ((attr0 & (1 << 8)) == 0)
{
if ((attr1 & (1 << 13)) != 0) spritey = (height - 1) - spritey;
int baseSprite;
if ((this.dispCnt & (1 << 6)) != 0)
{
// 1 dimensional
baseSprite = (attr2 & 0x3FF) + ((spritey / 8) * (width / 8)) * scale;
}
else
{
// 2 dimensional
baseSprite = (attr2 & 0x3FF) + ((spritey / 8) * 0x20);
}
int baseInc = scale;
if ((attr1 & (1 << 12)) != 0)
{
baseSprite += ((width / 8) * scale) - scale;
baseInc = -baseInc;
}
if ((attr0 & (1 << 13)) != 0)
{
// 256 colors
for (int i = x; i < x + width; i++)
{
if ((i & 0x1ff) < 240 && (this.windowCover[i & 0x1ff] & (1 << 4)) != 0)
{
int tx = (i - x) & 7;
if ((attr1 & (1 << 12)) != 0) tx = 7 - tx;
int curIdx = baseSprite * 32 + ((spritey & 7) * 8) + tx;
int lookup = vram[0x10000 + curIdx];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[0x200 + lookup * 2] | (palette[0x200 + lookup * 2 + 1] << 8)));
if ((this.windowCover[i & 0x1ff] & (1 << 5)) != 0)
{
if ((this.blend[i & 0x1ff] & this.blendTarget) != 0 && this.blend[i & 0x1ff] != blendMaskType)
{
uint r = ((pixelColor & 0xFF) * this.blendA) >> 4;
uint g = (((pixelColor >> 8) & 0xFF) * this.blendA) >> 4;
uint b = (((pixelColor >> 16) & 0xFF) * this.blendA) >> 4;
uint sourceValue = this.scanline[(i & 0x1ff)];
r += ((sourceValue & 0xFF) * this.blendB) >> 4;
g += (((sourceValue >> 8) & 0xFF) * this.blendB) >> 4;
b += (((sourceValue >> 16) & 0xFF) * this.blendB) >> 4;
if (r > 0xff) r = 0xff;
if (g > 0xff) g = 0xff;
if (b > 0xff) b = 0xff;
pixelColor = r | (g << 8) | (b << 16);
}
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
if (((i - x) & 7) == 7) baseSprite += baseInc;
}
}
else
{
// 16 colors
int palIdx = 0x200 + (((attr2 >> 12) & 0xF) * 16 * 2);
for (int i = x; i < x + width; i++)
{
if ((i & 0x1ff) < 240 && (this.windowCover[i & 0x1ff] & (1 << 4)) != 0)
{
int tx = (i - x) & 7;
if ((attr1 & (1 << 12)) != 0) tx = 7 - tx;
int curIdx = baseSprite * 32 + ((spritey & 7) * 4) + (tx / 2);
int lookup = vram[0x10000 + curIdx];
if ((tx & 1) == 0)
{
lookup &= 0xf;
}
else
{
lookup >>= 4;
}
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[palIdx + lookup * 2] | (palette[palIdx + lookup * 2 + 1] << 8)));
if ((this.windowCover[i & 0x1ff] & (1 << 5)) != 0)
{
if ((this.blend[i & 0x1ff] & this.blendTarget) != 0 && this.blend[i & 0x1ff] != blendMaskType)
{
uint r = ((pixelColor & 0xFF) * this.blendA) >> 4;
uint g = (((pixelColor >> 8) & 0xFF) * this.blendA) >> 4;
uint b = (((pixelColor >> 16) & 0xFF) * this.blendA) >> 4;
uint sourceValue = this.scanline[(i & 0x1ff)];
r += ((sourceValue & 0xFF) * this.blendB) >> 4;
g += (((sourceValue >> 8) & 0xFF) * this.blendB) >> 4;
b += (((sourceValue >> 16) & 0xFF) * this.blendB) >> 4;
if (r > 0xff) r = 0xff;
if (g > 0xff) g = 0xff;
if (b > 0xff) b = 0xff;
pixelColor = r | (g << 8) | (b << 16);
}
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
if (((i - x) & 7) == 7) baseSprite += baseInc;
}
}
}
else
{
int rotScaleParam = (attr1 >> 9) & 0x1F;
short dx = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x6);
short dmx = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0xE);
short dy = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x16);
short dmy = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x1E);
int cx = rwidth / 2;
int cy = rheight / 2;
int baseSprite = attr2 & 0x3FF;
int pitch;
if ((this.dispCnt & (1 << 6)) != 0)
{
// 1 dimensional
pitch = (width / 8) * scale;
}
else
{
// 2 dimensional
pitch = 0x20;
}
int rx = (int)((dmx * (spritey - cy)) - (cx * dx) + (width << 7));
int ry = (int)((dmy * (spritey - cy)) - (cx * dy) + (height << 7));
// Draw a rot/scale sprite
if ((attr0 & (1 << 13)) != 0)
{
// 256 colors
for (int i = x; i < x + rwidth; i++)
{
int tx = rx >> 8;
int ty = ry >> 8;
if ((i & 0x1ff) < 240 && tx >= 0 && tx < width && ty >= 0 && ty < height
&& (this.windowCover[i & 0x1ff] & (1 << 4)) != 0)
{
int curIdx = (baseSprite + ((ty / 8) * pitch) + ((tx / 8) * scale)) * 32 + ((ty & 7) * 8) + (tx & 7);
int lookup = vram[0x10000 + curIdx];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[0x200 + lookup * 2] | (palette[0x200 + lookup * 2 + 1] << 8)));
if ((this.windowCover[i & 0x1ff] & (1 << 5)) != 0)
{
if ((this.blend[i & 0x1ff] & this.blendTarget) != 0 && this.blend[i & 0x1ff] != blendMaskType)
{
uint r = ((pixelColor & 0xFF) * this.blendA) >> 4;
uint g = (((pixelColor >> 8) & 0xFF) * this.blendA) >> 4;
uint b = (((pixelColor >> 16) & 0xFF) * this.blendA) >> 4;
uint sourceValue = this.scanline[(i & 0x1ff)];
r += ((sourceValue & 0xFF) * this.blendB) >> 4;
g += (((sourceValue >> 8) & 0xFF) * this.blendB) >> 4;
b += (((sourceValue >> 16) & 0xFF) * this.blendB) >> 4;
if (r > 0xff) r = 0xff;
if (g > 0xff) g = 0xff;
if (b > 0xff) b = 0xff;
pixelColor = r | (g << 8) | (b << 16);
}
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
rx += dx;
ry += dy;
}
}
else
{
// 16 colors
int palIdx = 0x200 + (((attr2 >> 12) & 0xF) * 16 * 2);
for (int i = x; i < x + rwidth; i++)
{
int tx = rx >> 8;
int ty = ry >> 8;
if ((i & 0x1ff) < 240 && tx >= 0 && tx < width && ty >= 0 && ty < height
&& (this.windowCover[i & 0x1ff] & (1 << 4)) != 0)
{
int curIdx = (baseSprite + ((ty / 8) * pitch) + ((tx / 8) * scale)) * 32 + ((ty & 7) * 4) + ((tx & 7) / 2);
int lookup = vram[0x10000 + curIdx];
if ((tx & 1) == 0)
{
lookup &= 0xf;
}
else
{
lookup >>= 4;
}
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[palIdx + lookup * 2] | (palette[palIdx + lookup * 2 + 1] << 8)));
if ((this.windowCover[i & 0x1ff] & (1 << 5)) != 0)
{
if ((this.blend[i & 0x1ff] & this.blendTarget) != 0 && this.blend[i & 0x1ff] != blendMaskType)
{
uint r = ((pixelColor & 0xFF) * this.blendA) >> 4;
uint g = (((pixelColor >> 8) & 0xFF) * this.blendA) >> 4;
uint b = (((pixelColor >> 16) & 0xFF) * this.blendA) >> 4;
uint sourceValue = this.scanline[(i & 0x1ff)];
r += ((sourceValue & 0xFF) * this.blendB) >> 4;
g += (((sourceValue >> 8) & 0xFF) * this.blendB) >> 4;
b += (((sourceValue >> 16) & 0xFF) * this.blendB) >> 4;
if (r > 0xff) r = 0xff;
if (g > 0xff) g = 0xff;
if (b > 0xff) b = 0xff;
pixelColor = r | (g << 8) | (b << 16);
}
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
rx += dx;
ry += dy;
}
}
}
}
else
{
if ((attr0 & (1 << 8)) == 0)
{
if ((attr1 & (1 << 13)) != 0) spritey = (height - 1) - spritey;
int baseSprite;
if ((this.dispCnt & (1 << 6)) != 0)
{
// 1 dimensional
baseSprite = (attr2 & 0x3FF) + ((spritey / 8) * (width / 8)) * scale;
}
else
{
// 2 dimensional
baseSprite = (attr2 & 0x3FF) + ((spritey / 8) * 0x20);
}
int baseInc = scale;
if ((attr1 & (1 << 12)) != 0)
{
baseSprite += ((width / 8) * scale) - scale;
baseInc = -baseInc;
}
if ((attr0 & (1 << 13)) != 0)
{
// 256 colors
for (int i = x; i < x + width; i++)
{
if ((i & 0x1ff) < 240 && (this.windowCover[i & 0x1ff] & (1 << 4)) != 0)
{
int tx = (i - x) & 7;
if ((attr1 & (1 << 12)) != 0) tx = 7 - tx;
int curIdx = baseSprite * 32 + ((spritey & 7) * 8) + tx;
int lookup = vram[0x10000 + curIdx];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[0x200 + lookup * 2] | (palette[0x200 + lookup * 2 + 1] << 8)));
if ((this.windowCover[i & 0x1ff] & (1 << 5)) != 0)
{
if ((this.blend[i & 0x1ff] & this.blendTarget) != 0 && this.blend[i & 0x1ff] != blendMaskType)
{
uint r = ((pixelColor & 0xFF) * this.blendA) >> 4;
uint g = (((pixelColor >> 8) & 0xFF) * this.blendA) >> 4;
uint b = (((pixelColor >> 16) & 0xFF) * this.blendA) >> 4;
uint sourceValue = this.scanline[(i & 0x1ff)];
r += ((sourceValue & 0xFF) * this.blendB) >> 4;
g += (((sourceValue >> 8) & 0xFF) * this.blendB) >> 4;
b += (((sourceValue >> 16) & 0xFF) * this.blendB) >> 4;
if (r > 0xff) r = 0xff;
if (g > 0xff) g = 0xff;
if (b > 0xff) b = 0xff;
pixelColor = r | (g << 8) | (b << 16);
}
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
if (((i - x) & 7) == 7) baseSprite += baseInc;
}
}
else
{
// 16 colors
int palIdx = 0x200 + (((attr2 >> 12) & 0xF) * 16 * 2);
for (int i = x; i < x + width; i++)
{
if ((i & 0x1ff) < 240 && (this.windowCover[i & 0x1ff] & (1 << 4)) != 0)
{
int tx = (i - x) & 7;
if ((attr1 & (1 << 12)) != 0) tx = 7 - tx;
int curIdx = baseSprite * 32 + ((spritey & 7) * 4) + (tx / 2);
int lookup = vram[0x10000 + curIdx];
if ((tx & 1) == 0)
{
lookup &= 0xf;
}
else
{
lookup >>= 4;
}
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[palIdx + lookup * 2] | (palette[palIdx + lookup * 2 + 1] << 8)));
if ((this.windowCover[i & 0x1ff] & (1 << 5)) != 0)
{
if ((this.blend[i & 0x1ff] & this.blendTarget) != 0 && this.blend[i & 0x1ff] != blendMaskType)
{
uint r = ((pixelColor & 0xFF) * this.blendA) >> 4;
uint g = (((pixelColor >> 8) & 0xFF) * this.blendA) >> 4;
uint b = (((pixelColor >> 16) & 0xFF) * this.blendA) >> 4;
uint sourceValue = this.scanline[(i & 0x1ff)];
r += ((sourceValue & 0xFF) * this.blendB) >> 4;
g += (((sourceValue >> 8) & 0xFF) * this.blendB) >> 4;
b += (((sourceValue >> 16) & 0xFF) * this.blendB) >> 4;
if (r > 0xff) r = 0xff;
if (g > 0xff) g = 0xff;
if (b > 0xff) b = 0xff;
pixelColor = r | (g << 8) | (b << 16);
}
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
if (((i - x) & 7) == 7) baseSprite += baseInc;
}
}
}
else
{
int rotScaleParam = (attr1 >> 9) & 0x1F;
short dx = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x6);
short dmx = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0xE);
short dy = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x16);
short dmy = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x1E);
int cx = rwidth / 2;
int cy = rheight / 2;
int baseSprite = attr2 & 0x3FF;
int pitch;
if ((this.dispCnt & (1 << 6)) != 0)
{
// 1 dimensional
pitch = (width / 8) * scale;
}
else
{
// 2 dimensional
pitch = 0x20;
}
int rx = (int)((dmx * (spritey - cy)) - (cx * dx) + (width << 7));
int ry = (int)((dmy * (spritey - cy)) - (cx * dy) + (height << 7));
// Draw a rot/scale sprite
if ((attr0 & (1 << 13)) != 0)
{
// 256 colors
for (int i = x; i < x + rwidth; i++)
{
int tx = rx >> 8;
int ty = ry >> 8;
if ((i & 0x1ff) < 240 && tx >= 0 && tx < width && ty >= 0 && ty < height
&& (this.windowCover[i & 0x1ff] & (1 << 4)) != 0)
{
int curIdx = (baseSprite + ((ty / 8) * pitch) + ((tx / 8) * scale)) * 32 + ((ty & 7) * 8) + (tx & 7);
int lookup = vram[0x10000 + curIdx];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[0x200 + lookup * 2] | (palette[0x200 + lookup * 2 + 1] << 8)));
if ((this.windowCover[i & 0x1ff] & (1 << 5)) != 0)
{
if ((this.blend[i & 0x1ff] & this.blendTarget) != 0 && this.blend[i & 0x1ff] != blendMaskType)
{
uint r = ((pixelColor & 0xFF) * this.blendA) >> 4;
uint g = (((pixelColor >> 8) & 0xFF) * this.blendA) >> 4;
uint b = (((pixelColor >> 16) & 0xFF) * this.blendA) >> 4;
uint sourceValue = this.scanline[(i & 0x1ff)];
r += ((sourceValue & 0xFF) * this.blendB) >> 4;
g += (((sourceValue >> 8) & 0xFF) * this.blendB) >> 4;
b += (((sourceValue >> 16) & 0xFF) * this.blendB) >> 4;
if (r > 0xff) r = 0xff;
if (g > 0xff) g = 0xff;
if (b > 0xff) b = 0xff;
pixelColor = r | (g << 8) | (b << 16);
}
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
rx += dx;
ry += dy;
}
}
else
{
// 16 colors
int palIdx = 0x200 + (((attr2 >> 12) & 0xF) * 16 * 2);
for (int i = x; i < x + rwidth; i++)
{
int tx = rx >> 8;
int ty = ry >> 8;
if ((i & 0x1ff) < 240 && tx >= 0 && tx < width && ty >= 0 && ty < height
&& (this.windowCover[i & 0x1ff] & (1 << 4)) != 0)
{
int curIdx = (baseSprite + ((ty / 8) * pitch) + ((tx / 8) * scale)) * 32 + ((ty & 7) * 4) + ((tx & 7) / 2);
int lookup = vram[0x10000 + curIdx];
if ((tx & 1) == 0)
{
lookup &= 0xf;
}
else
{
lookup >>= 4;
}
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[palIdx + lookup * 2] | (palette[palIdx + lookup * 2 + 1] << 8)));
if ((this.windowCover[i & 0x1ff] & (1 << 5)) != 0)
{
if ((this.blend[i & 0x1ff] & this.blendTarget) != 0 && this.blend[i & 0x1ff] != blendMaskType)
{
uint r = ((pixelColor & 0xFF) * this.blendA) >> 4;
uint g = (((pixelColor >> 8) & 0xFF) * this.blendA) >> 4;
uint b = (((pixelColor >> 16) & 0xFF) * this.blendA) >> 4;
uint sourceValue = this.scanline[(i & 0x1ff)];
r += ((sourceValue & 0xFF) * this.blendB) >> 4;
g += (((sourceValue >> 8) & 0xFF) * this.blendB) >> 4;
b += (((sourceValue >> 16) & 0xFF) * this.blendB) >> 4;
if (r > 0xff) r = 0xff;
if (g > 0xff) g = 0xff;
if (b > 0xff) b = 0xff;
pixelColor = r | (g << 8) | (b << 16);
}
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
rx += dx;
ry += dy;
}
}
}
}
}
}
private void DrawSpritesWindowBrightInc(int priority)
{
byte[] palette = this.memory.PaletteRam;
byte[] vram = this.memory.VideoRam;
// OBJ must be enabled in this.dispCnt
if ((this.dispCnt & (1 << 12)) == 0) return;
byte blendMaskType = (byte)(1 << 4);
for (int oamNum = 127; oamNum >= 0; oamNum--)
{
ushort attr2 = this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(oamNum * 8) + 4);
if (((attr2 >> 10) & 3) != priority) continue;
ushort attr0 = this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(oamNum * 8) + 0);
ushort attr1 = this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(oamNum * 8) + 2);
int x = attr1 & 0x1FF;
int y = attr0 & 0xFF;
bool semiTransparent = false;
switch ((attr0 >> 10) & 3)
{
case 1:
// Semi-transparent
semiTransparent = true;
break;
case 2:
// Obj window
continue;
case 3:
continue;
}
if ((this.dispCnt & 0x7) >= 3 && (attr2 & 0x3FF) < 0x200) continue;
int width = -1, height = -1;
switch ((attr0 >> 14) & 3)
{
case 0:
// Square
switch ((attr1 >> 14) & 3)
{
case 0: width = 8; height = 8; break;
case 1: width = 16; height = 16; break;
case 2: width = 32; height = 32; break;
case 3: width = 64; height = 64; break;
}
break;
case 1:
// Horizontal Rectangle
switch ((attr1 >> 14) & 3)
{
case 0: width = 16; height = 8; break;
case 1: width = 32; height = 8; break;
case 2: width = 32; height = 16; break;
case 3: width = 64; height = 32; break;
}
break;
case 2:
// Vertical Rectangle
switch ((attr1 >> 14) & 3)
{
case 0: width = 8; height = 16; break;
case 1: width = 8; height = 32; break;
case 2: width = 16; height = 32; break;
case 3: width = 32; height = 64; break;
}
break;
}
// Check double size flag here
int rwidth = width, rheight = height;
if ((attr0 & (1 << 8)) != 0)
{
// Rot-scale on
if ((attr0 & (1 << 9)) != 0)
{
rwidth *= 2;
rheight *= 2;
}
}
else
{
// Invalid sprite
if ((attr0 & (1 << 9)) != 0)
width = -1;
}
if (width == -1)
{
// Invalid sprite
continue;
}
// Y clipping
if (y > ((y + rheight) & 0xff))
{
if (this.curLine >= ((y + rheight) & 0xff) && !(y < this.curLine)) continue;
}
else
{
if (this.curLine < y || this.curLine >= ((y + rheight) & 0xff)) continue;
}
int scale = 1;
if ((attr0 & (1 << 13)) != 0) scale = 2;
int spritey = this.curLine - y;
if (spritey < 0) spritey += 256;
if (semiTransparent)
{
if ((attr0 & (1 << 8)) == 0)
{
if ((attr1 & (1 << 13)) != 0) spritey = (height - 1) - spritey;
int baseSprite;
if ((this.dispCnt & (1 << 6)) != 0)
{
// 1 dimensional
baseSprite = (attr2 & 0x3FF) + ((spritey / 8) * (width / 8)) * scale;
}
else
{
// 2 dimensional
baseSprite = (attr2 & 0x3FF) + ((spritey / 8) * 0x20);
}
int baseInc = scale;
if ((attr1 & (1 << 12)) != 0)
{
baseSprite += ((width / 8) * scale) - scale;
baseInc = -baseInc;
}
if ((attr0 & (1 << 13)) != 0)
{
// 256 colors
for (int i = x; i < x + width; i++)
{
if ((i & 0x1ff) < 240 && (this.windowCover[i & 0x1ff] & (1 << 4)) != 0)
{
int tx = (i - x) & 7;
if ((attr1 & (1 << 12)) != 0) tx = 7 - tx;
int curIdx = baseSprite * 32 + ((spritey & 7) * 8) + tx;
int lookup = vram[0x10000 + curIdx];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[0x200 + lookup * 2] | (palette[0x200 + lookup * 2 + 1] << 8)));
if ((this.windowCover[i & 0x1ff] & (1 << 5)) != 0)
{
if ((this.blend[i & 0x1ff] & this.blendTarget) != 0 && this.blend[i & 0x1ff] != blendMaskType)
{
uint r = ((pixelColor & 0xFF) * this.blendA) >> 4;
uint g = (((pixelColor >> 8) & 0xFF) * this.blendA) >> 4;
uint b = (((pixelColor >> 16) & 0xFF) * this.blendA) >> 4;
uint sourceValue = this.scanline[(i & 0x1ff)];
r += ((sourceValue & 0xFF) * this.blendB) >> 4;
g += (((sourceValue >> 8) & 0xFF) * this.blendB) >> 4;
b += (((sourceValue >> 16) & 0xFF) * this.blendB) >> 4;
if (r > 0xff) r = 0xff;
if (g > 0xff) g = 0xff;
if (b > 0xff) b = 0xff;
pixelColor = r | (g << 8) | (b << 16);
}
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
if (((i - x) & 7) == 7) baseSprite += baseInc;
}
}
else
{
// 16 colors
int palIdx = 0x200 + (((attr2 >> 12) & 0xF) * 16 * 2);
for (int i = x; i < x + width; i++)
{
if ((i & 0x1ff) < 240 && (this.windowCover[i & 0x1ff] & (1 << 4)) != 0)
{
int tx = (i - x) & 7;
if ((attr1 & (1 << 12)) != 0) tx = 7 - tx;
int curIdx = baseSprite * 32 + ((spritey & 7) * 4) + (tx / 2);
int lookup = vram[0x10000 + curIdx];
if ((tx & 1) == 0)
{
lookup &= 0xf;
}
else
{
lookup >>= 4;
}
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[palIdx + lookup * 2] | (palette[palIdx + lookup * 2 + 1] << 8)));
if ((this.windowCover[i & 0x1ff] & (1 << 5)) != 0)
{
if ((this.blend[i & 0x1ff] & this.blendTarget) != 0 && this.blend[i & 0x1ff] != blendMaskType)
{
uint r = ((pixelColor & 0xFF) * this.blendA) >> 4;
uint g = (((pixelColor >> 8) & 0xFF) * this.blendA) >> 4;
uint b = (((pixelColor >> 16) & 0xFF) * this.blendA) >> 4;
uint sourceValue = this.scanline[(i & 0x1ff)];
r += ((sourceValue & 0xFF) * this.blendB) >> 4;
g += (((sourceValue >> 8) & 0xFF) * this.blendB) >> 4;
b += (((sourceValue >> 16) & 0xFF) * this.blendB) >> 4;
if (r > 0xff) r = 0xff;
if (g > 0xff) g = 0xff;
if (b > 0xff) b = 0xff;
pixelColor = r | (g << 8) | (b << 16);
}
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
if (((i - x) & 7) == 7) baseSprite += baseInc;
}
}
}
else
{
int rotScaleParam = (attr1 >> 9) & 0x1F;
short dx = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x6);
short dmx = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0xE);
short dy = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x16);
short dmy = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x1E);
int cx = rwidth / 2;
int cy = rheight / 2;
int baseSprite = attr2 & 0x3FF;
int pitch;
if ((this.dispCnt & (1 << 6)) != 0)
{
// 1 dimensional
pitch = (width / 8) * scale;
}
else
{
// 2 dimensional
pitch = 0x20;
}
int rx = (int)((dmx * (spritey - cy)) - (cx * dx) + (width << 7));
int ry = (int)((dmy * (spritey - cy)) - (cx * dy) + (height << 7));
// Draw a rot/scale sprite
if ((attr0 & (1 << 13)) != 0)
{
// 256 colors
for (int i = x; i < x + rwidth; i++)
{
int tx = rx >> 8;
int ty = ry >> 8;
if ((i & 0x1ff) < 240 && tx >= 0 && tx < width && ty >= 0 && ty < height
&& (this.windowCover[i & 0x1ff] & (1 << 4)) != 0)
{
int curIdx = (baseSprite + ((ty / 8) * pitch) + ((tx / 8) * scale)) * 32 + ((ty & 7) * 8) + (tx & 7);
int lookup = vram[0x10000 + curIdx];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[0x200 + lookup * 2] | (palette[0x200 + lookup * 2 + 1] << 8)));
if ((this.windowCover[i & 0x1ff] & (1 << 5)) != 0)
{
if ((this.blend[i & 0x1ff] & this.blendTarget) != 0 && this.blend[i & 0x1ff] != blendMaskType)
{
uint r = ((pixelColor & 0xFF) * this.blendA) >> 4;
uint g = (((pixelColor >> 8) & 0xFF) * this.blendA) >> 4;
uint b = (((pixelColor >> 16) & 0xFF) * this.blendA) >> 4;
uint sourceValue = this.scanline[(i & 0x1ff)];
r += ((sourceValue & 0xFF) * this.blendB) >> 4;
g += (((sourceValue >> 8) & 0xFF) * this.blendB) >> 4;
b += (((sourceValue >> 16) & 0xFF) * this.blendB) >> 4;
if (r > 0xff) r = 0xff;
if (g > 0xff) g = 0xff;
if (b > 0xff) b = 0xff;
pixelColor = r | (g << 8) | (b << 16);
}
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
rx += dx;
ry += dy;
}
}
else
{
// 16 colors
int palIdx = 0x200 + (((attr2 >> 12) & 0xF) * 16 * 2);
for (int i = x; i < x + rwidth; i++)
{
int tx = rx >> 8;
int ty = ry >> 8;
if ((i & 0x1ff) < 240 && tx >= 0 && tx < width && ty >= 0 && ty < height
&& (this.windowCover[i & 0x1ff] & (1 << 4)) != 0)
{
int curIdx = (baseSprite + ((ty / 8) * pitch) + ((tx / 8) * scale)) * 32 + ((ty & 7) * 4) + ((tx & 7) / 2);
int lookup = vram[0x10000 + curIdx];
if ((tx & 1) == 0)
{
lookup &= 0xf;
}
else
{
lookup >>= 4;
}
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[palIdx + lookup * 2] | (palette[palIdx + lookup * 2 + 1] << 8)));
if ((this.windowCover[i & 0x1ff] & (1 << 5)) != 0)
{
if ((this.blend[i & 0x1ff] & this.blendTarget) != 0 && this.blend[i & 0x1ff] != blendMaskType)
{
uint r = ((pixelColor & 0xFF) * this.blendA) >> 4;
uint g = (((pixelColor >> 8) & 0xFF) * this.blendA) >> 4;
uint b = (((pixelColor >> 16) & 0xFF) * this.blendA) >> 4;
uint sourceValue = this.scanline[(i & 0x1ff)];
r += ((sourceValue & 0xFF) * this.blendB) >> 4;
g += (((sourceValue >> 8) & 0xFF) * this.blendB) >> 4;
b += (((sourceValue >> 16) & 0xFF) * this.blendB) >> 4;
if (r > 0xff) r = 0xff;
if (g > 0xff) g = 0xff;
if (b > 0xff) b = 0xff;
pixelColor = r | (g << 8) | (b << 16);
}
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
rx += dx;
ry += dy;
}
}
}
}
else
{
if ((attr0 & (1 << 8)) == 0)
{
if ((attr1 & (1 << 13)) != 0) spritey = (height - 1) - spritey;
int baseSprite;
if ((this.dispCnt & (1 << 6)) != 0)
{
// 1 dimensional
baseSprite = (attr2 & 0x3FF) + ((spritey / 8) * (width / 8)) * scale;
}
else
{
// 2 dimensional
baseSprite = (attr2 & 0x3FF) + ((spritey / 8) * 0x20);
}
int baseInc = scale;
if ((attr1 & (1 << 12)) != 0)
{
baseSprite += ((width / 8) * scale) - scale;
baseInc = -baseInc;
}
if ((attr0 & (1 << 13)) != 0)
{
// 256 colors
for (int i = x; i < x + width; i++)
{
if ((i & 0x1ff) < 240 && (this.windowCover[i & 0x1ff] & (1 << 4)) != 0)
{
int tx = (i - x) & 7;
if ((attr1 & (1 << 12)) != 0) tx = 7 - tx;
int curIdx = baseSprite * 32 + ((spritey & 7) * 8) + tx;
int lookup = vram[0x10000 + curIdx];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[0x200 + lookup * 2] | (palette[0x200 + lookup * 2 + 1] << 8)));
if ((this.windowCover[i & 0x1ff] & (1 << 5)) != 0)
{
uint r = pixelColor & 0xFF;
uint g = (pixelColor >> 8) & 0xFF;
uint b = (pixelColor >> 16) & 0xFF;
r = r + (((0xFF - r) * this.blendY) >> 4);
g = g + (((0xFF - g) * this.blendY) >> 4);
b = b + (((0xFF - b) * this.blendY) >> 4);
pixelColor = r | (g << 8) | (b << 16);
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
if (((i - x) & 7) == 7) baseSprite += baseInc;
}
}
else
{
// 16 colors
int palIdx = 0x200 + (((attr2 >> 12) & 0xF) * 16 * 2);
for (int i = x; i < x + width; i++)
{
if ((i & 0x1ff) < 240 && (this.windowCover[i & 0x1ff] & (1 << 4)) != 0)
{
int tx = (i - x) & 7;
if ((attr1 & (1 << 12)) != 0) tx = 7 - tx;
int curIdx = baseSprite * 32 + ((spritey & 7) * 4) + (tx / 2);
int lookup = vram[0x10000 + curIdx];
if ((tx & 1) == 0)
{
lookup &= 0xf;
}
else
{
lookup >>= 4;
}
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[palIdx + lookup * 2] | (palette[palIdx + lookup * 2 + 1] << 8)));
if ((this.windowCover[i & 0x1ff] & (1 << 5)) != 0)
{
uint r = pixelColor & 0xFF;
uint g = (pixelColor >> 8) & 0xFF;
uint b = (pixelColor >> 16) & 0xFF;
r = r + (((0xFF - r) * this.blendY) >> 4);
g = g + (((0xFF - g) * this.blendY) >> 4);
b = b + (((0xFF - b) * this.blendY) >> 4);
pixelColor = r | (g << 8) | (b << 16);
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
if (((i - x) & 7) == 7) baseSprite += baseInc;
}
}
}
else
{
int rotScaleParam = (attr1 >> 9) & 0x1F;
short dx = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x6);
short dmx = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0xE);
short dy = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x16);
short dmy = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x1E);
int cx = rwidth / 2;
int cy = rheight / 2;
int baseSprite = attr2 & 0x3FF;
int pitch;
if ((this.dispCnt & (1 << 6)) != 0)
{
// 1 dimensional
pitch = (width / 8) * scale;
}
else
{
// 2 dimensional
pitch = 0x20;
}
int rx = (int)((dmx * (spritey - cy)) - (cx * dx) + (width << 7));
int ry = (int)((dmy * (spritey - cy)) - (cx * dy) + (height << 7));
// Draw a rot/scale sprite
if ((attr0 & (1 << 13)) != 0)
{
// 256 colors
for (int i = x; i < x + rwidth; i++)
{
int tx = rx >> 8;
int ty = ry >> 8;
if ((i & 0x1ff) < 240 && tx >= 0 && tx < width && ty >= 0 && ty < height
&& (this.windowCover[i & 0x1ff] & (1 << 4)) != 0)
{
int curIdx = (baseSprite + ((ty / 8) * pitch) + ((tx / 8) * scale)) * 32 + ((ty & 7) * 8) + (tx & 7);
int lookup = vram[0x10000 + curIdx];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[0x200 + lookup * 2] | (palette[0x200 + lookup * 2 + 1] << 8)));
if ((this.windowCover[i & 0x1ff] & (1 << 5)) != 0)
{
uint r = pixelColor & 0xFF;
uint g = (pixelColor >> 8) & 0xFF;
uint b = (pixelColor >> 16) & 0xFF;
r = r + (((0xFF - r) * this.blendY) >> 4);
g = g + (((0xFF - g) * this.blendY) >> 4);
b = b + (((0xFF - b) * this.blendY) >> 4);
pixelColor = r | (g << 8) | (b << 16);
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
rx += dx;
ry += dy;
}
}
else
{
// 16 colors
int palIdx = 0x200 + (((attr2 >> 12) & 0xF) * 16 * 2);
for (int i = x; i < x + rwidth; i++)
{
int tx = rx >> 8;
int ty = ry >> 8;
if ((i & 0x1ff) < 240 && tx >= 0 && tx < width && ty >= 0 && ty < height
&& (this.windowCover[i & 0x1ff] & (1 << 4)) != 0)
{
int curIdx = (baseSprite + ((ty / 8) * pitch) + ((tx / 8) * scale)) * 32 + ((ty & 7) * 4) + ((tx & 7) / 2);
int lookup = vram[0x10000 + curIdx];
if ((tx & 1) == 0)
{
lookup &= 0xf;
}
else
{
lookup >>= 4;
}
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[palIdx + lookup * 2] | (palette[palIdx + lookup * 2 + 1] << 8)));
if ((this.windowCover[i & 0x1ff] & (1 << 5)) != 0)
{
uint r = pixelColor & 0xFF;
uint g = (pixelColor >> 8) & 0xFF;
uint b = (pixelColor >> 16) & 0xFF;
r = r + (((0xFF - r) * this.blendY) >> 4);
g = g + (((0xFF - g) * this.blendY) >> 4);
b = b + (((0xFF - b) * this.blendY) >> 4);
pixelColor = r | (g << 8) | (b << 16);
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
rx += dx;
ry += dy;
}
}
}
}
}
}
private void DrawSpritesWindowBrightDec(int priority)
{
byte[] palette = this.memory.PaletteRam;
byte[] vram = this.memory.VideoRam;
// OBJ must be enabled in this.dispCnt
if ((this.dispCnt & (1 << 12)) == 0) return;
byte blendMaskType = (byte)(1 << 4);
for (int oamNum = 127; oamNum >= 0; oamNum--)
{
ushort attr2 = this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(oamNum * 8) + 4);
if (((attr2 >> 10) & 3) != priority) continue;
ushort attr0 = this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(oamNum * 8) + 0);
ushort attr1 = this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(oamNum * 8) + 2);
int x = attr1 & 0x1FF;
int y = attr0 & 0xFF;
bool semiTransparent = false;
switch ((attr0 >> 10) & 3)
{
case 1:
// Semi-transparent
semiTransparent = true;
break;
case 2:
// Obj window
continue;
case 3:
continue;
}
if ((this.dispCnt & 0x7) >= 3 && (attr2 & 0x3FF) < 0x200) continue;
int width = -1, height = -1;
switch ((attr0 >> 14) & 3)
{
case 0:
// Square
switch ((attr1 >> 14) & 3)
{
case 0: width = 8; height = 8; break;
case 1: width = 16; height = 16; break;
case 2: width = 32; height = 32; break;
case 3: width = 64; height = 64; break;
}
break;
case 1:
// Horizontal Rectangle
switch ((attr1 >> 14) & 3)
{
case 0: width = 16; height = 8; break;
case 1: width = 32; height = 8; break;
case 2: width = 32; height = 16; break;
case 3: width = 64; height = 32; break;
}
break;
case 2:
// Vertical Rectangle
switch ((attr1 >> 14) & 3)
{
case 0: width = 8; height = 16; break;
case 1: width = 8; height = 32; break;
case 2: width = 16; height = 32; break;
case 3: width = 32; height = 64; break;
}
break;
}
// Check double size flag here
int rwidth = width, rheight = height;
if ((attr0 & (1 << 8)) != 0)
{
// Rot-scale on
if ((attr0 & (1 << 9)) != 0)
{
rwidth *= 2;
rheight *= 2;
}
}
else
{
// Invalid sprite
if ((attr0 & (1 << 9)) != 0)
width = -1;
}
if (width == -1)
{
// Invalid sprite
continue;
}
// Y clipping
if (y > ((y + rheight) & 0xff))
{
if (this.curLine >= ((y + rheight) & 0xff) && !(y < this.curLine)) continue;
}
else
{
if (this.curLine < y || this.curLine >= ((y + rheight) & 0xff)) continue;
}
int scale = 1;
if ((attr0 & (1 << 13)) != 0) scale = 2;
int spritey = this.curLine - y;
if (spritey < 0) spritey += 256;
if (semiTransparent)
{
if ((attr0 & (1 << 8)) == 0)
{
if ((attr1 & (1 << 13)) != 0) spritey = (height - 1) - spritey;
int baseSprite;
if ((this.dispCnt & (1 << 6)) != 0)
{
// 1 dimensional
baseSprite = (attr2 & 0x3FF) + ((spritey / 8) * (width / 8)) * scale;
}
else
{
// 2 dimensional
baseSprite = (attr2 & 0x3FF) + ((spritey / 8) * 0x20);
}
int baseInc = scale;
if ((attr1 & (1 << 12)) != 0)
{
baseSprite += ((width / 8) * scale) - scale;
baseInc = -baseInc;
}
if ((attr0 & (1 << 13)) != 0)
{
// 256 colors
for (int i = x; i < x + width; i++)
{
if ((i & 0x1ff) < 240 && (this.windowCover[i & 0x1ff] & (1 << 4)) != 0)
{
int tx = (i - x) & 7;
if ((attr1 & (1 << 12)) != 0) tx = 7 - tx;
int curIdx = baseSprite * 32 + ((spritey & 7) * 8) + tx;
int lookup = vram[0x10000 + curIdx];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[0x200 + lookup * 2] | (palette[0x200 + lookup * 2 + 1] << 8)));
if ((this.windowCover[i & 0x1ff] & (1 << 5)) != 0)
{
if ((this.blend[i & 0x1ff] & this.blendTarget) != 0 && this.blend[i & 0x1ff] != blendMaskType)
{
uint r = ((pixelColor & 0xFF) * this.blendA) >> 4;
uint g = (((pixelColor >> 8) & 0xFF) * this.blendA) >> 4;
uint b = (((pixelColor >> 16) & 0xFF) * this.blendA) >> 4;
uint sourceValue = this.scanline[(i & 0x1ff)];
r += ((sourceValue & 0xFF) * this.blendB) >> 4;
g += (((sourceValue >> 8) & 0xFF) * this.blendB) >> 4;
b += (((sourceValue >> 16) & 0xFF) * this.blendB) >> 4;
if (r > 0xff) r = 0xff;
if (g > 0xff) g = 0xff;
if (b > 0xff) b = 0xff;
pixelColor = r | (g << 8) | (b << 16);
}
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
if (((i - x) & 7) == 7) baseSprite += baseInc;
}
}
else
{
// 16 colors
int palIdx = 0x200 + (((attr2 >> 12) & 0xF) * 16 * 2);
for (int i = x; i < x + width; i++)
{
if ((i & 0x1ff) < 240 && (this.windowCover[i & 0x1ff] & (1 << 4)) != 0)
{
int tx = (i - x) & 7;
if ((attr1 & (1 << 12)) != 0) tx = 7 - tx;
int curIdx = baseSprite * 32 + ((spritey & 7) * 4) + (tx / 2);
int lookup = vram[0x10000 + curIdx];
if ((tx & 1) == 0)
{
lookup &= 0xf;
}
else
{
lookup >>= 4;
}
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[palIdx + lookup * 2] | (palette[palIdx + lookup * 2 + 1] << 8)));
if ((this.windowCover[i & 0x1ff] & (1 << 5)) != 0)
{
if ((this.blend[i & 0x1ff] & this.blendTarget) != 0 && this.blend[i & 0x1ff] != blendMaskType)
{
uint r = ((pixelColor & 0xFF) * this.blendA) >> 4;
uint g = (((pixelColor >> 8) & 0xFF) * this.blendA) >> 4;
uint b = (((pixelColor >> 16) & 0xFF) * this.blendA) >> 4;
uint sourceValue = this.scanline[(i & 0x1ff)];
r += ((sourceValue & 0xFF) * this.blendB) >> 4;
g += (((sourceValue >> 8) & 0xFF) * this.blendB) >> 4;
b += (((sourceValue >> 16) & 0xFF) * this.blendB) >> 4;
if (r > 0xff) r = 0xff;
if (g > 0xff) g = 0xff;
if (b > 0xff) b = 0xff;
pixelColor = r | (g << 8) | (b << 16);
}
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
if (((i - x) & 7) == 7) baseSprite += baseInc;
}
}
}
else
{
int rotScaleParam = (attr1 >> 9) & 0x1F;
short dx = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x6);
short dmx = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0xE);
short dy = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x16);
short dmy = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x1E);
int cx = rwidth / 2;
int cy = rheight / 2;
int baseSprite = attr2 & 0x3FF;
int pitch;
if ((this.dispCnt & (1 << 6)) != 0)
{
// 1 dimensional
pitch = (width / 8) * scale;
}
else
{
// 2 dimensional
pitch = 0x20;
}
int rx = (int)((dmx * (spritey - cy)) - (cx * dx) + (width << 7));
int ry = (int)((dmy * (spritey - cy)) - (cx * dy) + (height << 7));
// Draw a rot/scale sprite
if ((attr0 & (1 << 13)) != 0)
{
// 256 colors
for (int i = x; i < x + rwidth; i++)
{
int tx = rx >> 8;
int ty = ry >> 8;
if ((i & 0x1ff) < 240 && tx >= 0 && tx < width && ty >= 0 && ty < height
&& (this.windowCover[i & 0x1ff] & (1 << 4)) != 0)
{
int curIdx = (baseSprite + ((ty / 8) * pitch) + ((tx / 8) * scale)) * 32 + ((ty & 7) * 8) + (tx & 7);
int lookup = vram[0x10000 + curIdx];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[0x200 + lookup * 2] | (palette[0x200 + lookup * 2 + 1] << 8)));
if ((this.windowCover[i & 0x1ff] & (1 << 5)) != 0)
{
if ((this.blend[i & 0x1ff] & this.blendTarget) != 0 && this.blend[i & 0x1ff] != blendMaskType)
{
uint r = ((pixelColor & 0xFF) * this.blendA) >> 4;
uint g = (((pixelColor >> 8) & 0xFF) * this.blendA) >> 4;
uint b = (((pixelColor >> 16) & 0xFF) * this.blendA) >> 4;
uint sourceValue = this.scanline[(i & 0x1ff)];
r += ((sourceValue & 0xFF) * this.blendB) >> 4;
g += (((sourceValue >> 8) & 0xFF) * this.blendB) >> 4;
b += (((sourceValue >> 16) & 0xFF) * this.blendB) >> 4;
if (r > 0xff) r = 0xff;
if (g > 0xff) g = 0xff;
if (b > 0xff) b = 0xff;
pixelColor = r | (g << 8) | (b << 16);
}
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
rx += dx;
ry += dy;
}
}
else
{
// 16 colors
int palIdx = 0x200 + (((attr2 >> 12) & 0xF) * 16 * 2);
for (int i = x; i < x + rwidth; i++)
{
int tx = rx >> 8;
int ty = ry >> 8;
if ((i & 0x1ff) < 240 && tx >= 0 && tx < width && ty >= 0 && ty < height
&& (this.windowCover[i & 0x1ff] & (1 << 4)) != 0)
{
int curIdx = (baseSprite + ((ty / 8) * pitch) + ((tx / 8) * scale)) * 32 + ((ty & 7) * 4) + ((tx & 7) / 2);
int lookup = vram[0x10000 + curIdx];
if ((tx & 1) == 0)
{
lookup &= 0xf;
}
else
{
lookup >>= 4;
}
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[palIdx + lookup * 2] | (palette[palIdx + lookup * 2 + 1] << 8)));
if ((this.windowCover[i & 0x1ff] & (1 << 5)) != 0)
{
if ((this.blend[i & 0x1ff] & this.blendTarget) != 0 && this.blend[i & 0x1ff] != blendMaskType)
{
uint r = ((pixelColor & 0xFF) * this.blendA) >> 4;
uint g = (((pixelColor >> 8) & 0xFF) * this.blendA) >> 4;
uint b = (((pixelColor >> 16) & 0xFF) * this.blendA) >> 4;
uint sourceValue = this.scanline[(i & 0x1ff)];
r += ((sourceValue & 0xFF) * this.blendB) >> 4;
g += (((sourceValue >> 8) & 0xFF) * this.blendB) >> 4;
b += (((sourceValue >> 16) & 0xFF) * this.blendB) >> 4;
if (r > 0xff) r = 0xff;
if (g > 0xff) g = 0xff;
if (b > 0xff) b = 0xff;
pixelColor = r | (g << 8) | (b << 16);
}
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
rx += dx;
ry += dy;
}
}
}
}
else
{
if ((attr0 & (1 << 8)) == 0)
{
if ((attr1 & (1 << 13)) != 0) spritey = (height - 1) - spritey;
int baseSprite;
if ((this.dispCnt & (1 << 6)) != 0)
{
// 1 dimensional
baseSprite = (attr2 & 0x3FF) + ((spritey / 8) * (width / 8)) * scale;
}
else
{
// 2 dimensional
baseSprite = (attr2 & 0x3FF) + ((spritey / 8) * 0x20);
}
int baseInc = scale;
if ((attr1 & (1 << 12)) != 0)
{
baseSprite += ((width / 8) * scale) - scale;
baseInc = -baseInc;
}
if ((attr0 & (1 << 13)) != 0)
{
// 256 colors
for (int i = x; i < x + width; i++)
{
if ((i & 0x1ff) < 240 && (this.windowCover[i & 0x1ff] & (1 << 4)) != 0)
{
int tx = (i - x) & 7;
if ((attr1 & (1 << 12)) != 0) tx = 7 - tx;
int curIdx = baseSprite * 32 + ((spritey & 7) * 8) + tx;
int lookup = vram[0x10000 + curIdx];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[0x200 + lookup * 2] | (palette[0x200 + lookup * 2 + 1] << 8)));
if ((this.windowCover[i & 0x1ff] & (1 << 5)) != 0)
{
uint r = pixelColor & 0xFF;
uint g = (pixelColor >> 8) & 0xFF;
uint b = (pixelColor >> 16) & 0xFF;
r = r - ((r * this.blendY) >> 4);
g = g - ((g * this.blendY) >> 4);
b = b - ((b * this.blendY) >> 4);
pixelColor = r | (g << 8) | (b << 16);
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
if (((i - x) & 7) == 7) baseSprite += baseInc;
}
}
else
{
// 16 colors
int palIdx = 0x200 + (((attr2 >> 12) & 0xF) * 16 * 2);
for (int i = x; i < x + width; i++)
{
if ((i & 0x1ff) < 240 && (this.windowCover[i & 0x1ff] & (1 << 4)) != 0)
{
int tx = (i - x) & 7;
if ((attr1 & (1 << 12)) != 0) tx = 7 - tx;
int curIdx = baseSprite * 32 + ((spritey & 7) * 4) + (tx / 2);
int lookup = vram[0x10000 + curIdx];
if ((tx & 1) == 0)
{
lookup &= 0xf;
}
else
{
lookup >>= 4;
}
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[palIdx + lookup * 2] | (palette[palIdx + lookup * 2 + 1] << 8)));
if ((this.windowCover[i & 0x1ff] & (1 << 5)) != 0)
{
uint r = pixelColor & 0xFF;
uint g = (pixelColor >> 8) & 0xFF;
uint b = (pixelColor >> 16) & 0xFF;
r = r - ((r * this.blendY) >> 4);
g = g - ((g * this.blendY) >> 4);
b = b - ((b * this.blendY) >> 4);
pixelColor = r | (g << 8) | (b << 16);
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
if (((i - x) & 7) == 7) baseSprite += baseInc;
}
}
}
else
{
int rotScaleParam = (attr1 >> 9) & 0x1F;
short dx = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x6);
short dmx = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0xE);
short dy = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x16);
short dmy = (short)this.memory.ReadU16Debug(Memory.OAM_BASE + (uint)(rotScaleParam * 8 * 4) + 0x1E);
int cx = rwidth / 2;
int cy = rheight / 2;
int baseSprite = attr2 & 0x3FF;
int pitch;
if ((this.dispCnt & (1 << 6)) != 0)
{
// 1 dimensional
pitch = (width / 8) * scale;
}
else
{
// 2 dimensional
pitch = 0x20;
}
int rx = (int)((dmx * (spritey - cy)) - (cx * dx) + (width << 7));
int ry = (int)((dmy * (spritey - cy)) - (cx * dy) + (height << 7));
// Draw a rot/scale sprite
if ((attr0 & (1 << 13)) != 0)
{
// 256 colors
for (int i = x; i < x + rwidth; i++)
{
int tx = rx >> 8;
int ty = ry >> 8;
if ((i & 0x1ff) < 240 && tx >= 0 && tx < width && ty >= 0 && ty < height
&& (this.windowCover[i & 0x1ff] & (1 << 4)) != 0)
{
int curIdx = (baseSprite + ((ty / 8) * pitch) + ((tx / 8) * scale)) * 32 + ((ty & 7) * 8) + (tx & 7);
int lookup = vram[0x10000 + curIdx];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[0x200 + lookup * 2] | (palette[0x200 + lookup * 2 + 1] << 8)));
if ((this.windowCover[i & 0x1ff] & (1 << 5)) != 0)
{
uint r = pixelColor & 0xFF;
uint g = (pixelColor >> 8) & 0xFF;
uint b = (pixelColor >> 16) & 0xFF;
r = r - ((r * this.blendY) >> 4);
g = g - ((g * this.blendY) >> 4);
b = b - ((b * this.blendY) >> 4);
pixelColor = r | (g << 8) | (b << 16);
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
rx += dx;
ry += dy;
}
}
else
{
// 16 colors
int palIdx = 0x200 + (((attr2 >> 12) & 0xF) * 16 * 2);
for (int i = x; i < x + rwidth; i++)
{
int tx = rx >> 8;
int ty = ry >> 8;
if ((i & 0x1ff) < 240 && tx >= 0 && tx < width && ty >= 0 && ty < height
&& (this.windowCover[i & 0x1ff] & (1 << 4)) != 0)
{
int curIdx = (baseSprite + ((ty / 8) * pitch) + ((tx / 8) * scale)) * 32 + ((ty & 7) * 4) + ((tx & 7) / 2);
int lookup = vram[0x10000 + curIdx];
if ((tx & 1) == 0)
{
lookup &= 0xf;
}
else
{
lookup >>= 4;
}
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[palIdx + lookup * 2] | (palette[palIdx + lookup * 2 + 1] << 8)));
if ((this.windowCover[i & 0x1ff] & (1 << 5)) != 0)
{
uint r = pixelColor & 0xFF;
uint g = (pixelColor >> 8) & 0xFF;
uint b = (pixelColor >> 16) & 0xFF;
r = r - ((r * this.blendY) >> 4);
g = g - ((g * this.blendY) >> 4);
b = b - ((b * this.blendY) >> 4);
pixelColor = r | (g << 8) | (b << 16);
}
this.scanline[(i & 0x1ff)] = pixelColor;
this.blend[(i & 0x1ff)] = blendMaskType;
}
}
rx += dx;
ry += dy;
}
}
}
}
}
}
#endregion Sprite Drawing
#region Rot/Scale Bg
private void RenderRotScaleBgNormal(int bg)
{
byte[] palette = this.memory.PaletteRam;
byte[] vram = this.memory.VideoRam;
byte blendMaskType = (byte)(1 << bg);
ushort bgcnt = Memory.ReadU16(this.memory.IORam, Memory.BG0CNT + 0x2 * (uint)bg);
int width = 0, height = 0;
switch ((bgcnt >> 14) & 0x3)
{
case 0: width = 128; height = 128; break;
case 1: width = 256; height = 256; break;
case 2: width = 512; height = 512; break;
case 3: width = 1024; height = 1024; break;
}
int screenBase = ((bgcnt >> 8) & 0x1F) * 0x800;
int charBase = ((bgcnt >> 2) & 0x3) * 0x4000;
int x = this.memory.Bgx[bg - 2];
int y = this.memory.Bgy[bg - 2];
short dx = (short)Memory.ReadU16(this.memory.IORam, Memory.BG2PA + (uint)(bg - 2) * 0x10);
short dy = (short)Memory.ReadU16(this.memory.IORam, Memory.BG2PC + (uint)(bg - 2) * 0x10);
bool transparent = (bgcnt & (1 << 13)) == 0;
for (int i = 0; i < 240; i++)
{
if (true)
{
int ax = x >> 8;
int ay = y >> 8;
if ((ax >= 0 && ax < width && ay >= 0 && ay < height) || !transparent)
{
int tmpTileIdx = (int)(screenBase + ((ay & (height - 1)) / 8) * (width / 8) + ((ax & (width - 1)) / 8));
int tileChar = vram[tmpTileIdx];
int lookup = vram[charBase + (tileChar * 64) + ((ay & 7) * 8) + (ax & 7)];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[lookup * 2] | (palette[lookup * 2 + 1] << 8)));
this.scanline[i] = pixelColor; this.blend[i] = blendMaskType;
}
}
}
x += dx;
y += dy;
}
}
private void RenderRotScaleBgBlend(int bg)
{
byte[] palette = this.memory.PaletteRam;
byte[] vram = this.memory.VideoRam;
byte blendMaskType = (byte)(1 << bg);
ushort bgcnt = Memory.ReadU16(this.memory.IORam, Memory.BG0CNT + 0x2 * (uint)bg);
int width = 0, height = 0;
switch ((bgcnt >> 14) & 0x3)
{
case 0: width = 128; height = 128; break;
case 1: width = 256; height = 256; break;
case 2: width = 512; height = 512; break;
case 3: width = 1024; height = 1024; break;
}
int screenBase = ((bgcnt >> 8) & 0x1F) * 0x800;
int charBase = ((bgcnt >> 2) & 0x3) * 0x4000;
int x = this.memory.Bgx[bg - 2];
int y = this.memory.Bgy[bg - 2];
short dx = (short)Memory.ReadU16(this.memory.IORam, Memory.BG2PA + (uint)(bg - 2) * 0x10);
short dy = (short)Memory.ReadU16(this.memory.IORam, Memory.BG2PC + (uint)(bg - 2) * 0x10);
bool transparent = (bgcnt & (1 << 13)) == 0;
for (int i = 0; i < 240; i++)
{
if (true)
{
int ax = x >> 8;
int ay = y >> 8;
if ((ax >= 0 && ax < width && ay >= 0 && ay < height) || !transparent)
{
int tmpTileIdx = (int)(screenBase + ((ay & (height - 1)) / 8) * (width / 8) + ((ax & (width - 1)) / 8));
int tileChar = vram[tmpTileIdx];
int lookup = vram[charBase + (tileChar * 64) + ((ay & 7) * 8) + (ax & 7)];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[lookup * 2] | (palette[lookup * 2 + 1] << 8)));
if ((this.blend[i] & this.blendTarget) != 0)
{
uint r = ((pixelColor & 0xFF) * this.blendA) >> 4;
uint g = (((pixelColor >> 8) & 0xFF) * this.blendA) >> 4;
uint b = (((pixelColor >> 16) & 0xFF) * this.blendA) >> 4;
uint sourceValue = this.scanline[i];
r += ((sourceValue & 0xFF) * this.blendB) >> 4;
g += (((sourceValue >> 8) & 0xFF) * this.blendB) >> 4;
b += (((sourceValue >> 16) & 0xFF) * this.blendB) >> 4;
if (r > 0xff) r = 0xff;
if (g > 0xff) g = 0xff;
if (b > 0xff) b = 0xff;
pixelColor = r | (g << 8) | (b << 16);
}
this.scanline[i] = pixelColor; this.blend[i] = blendMaskType;
}
}
}
x += dx;
y += dy;
}
}
private void RenderRotScaleBgBrightInc(int bg)
{
byte[] palette = this.memory.PaletteRam;
byte[] vram = this.memory.VideoRam;
byte blendMaskType = (byte)(1 << bg);
ushort bgcnt = Memory.ReadU16(this.memory.IORam, Memory.BG0CNT + 0x2 * (uint)bg);
int width = 0, height = 0;
switch ((bgcnt >> 14) & 0x3)
{
case 0: width = 128; height = 128; break;
case 1: width = 256; height = 256; break;
case 2: width = 512; height = 512; break;
case 3: width = 1024; height = 1024; break;
}
int screenBase = ((bgcnt >> 8) & 0x1F) * 0x800;
int charBase = ((bgcnt >> 2) & 0x3) * 0x4000;
int x = this.memory.Bgx[bg - 2];
int y = this.memory.Bgy[bg - 2];
short dx = (short)Memory.ReadU16(this.memory.IORam, Memory.BG2PA + (uint)(bg - 2) * 0x10);
short dy = (short)Memory.ReadU16(this.memory.IORam, Memory.BG2PC + (uint)(bg - 2) * 0x10);
bool transparent = (bgcnt & (1 << 13)) == 0;
for (int i = 0; i < 240; i++)
{
if (true)
{
int ax = x >> 8;
int ay = y >> 8;
if ((ax >= 0 && ax < width && ay >= 0 && ay < height) || !transparent)
{
int tmpTileIdx = (int)(screenBase + ((ay & (height - 1)) / 8) * (width / 8) + ((ax & (width - 1)) / 8));
int tileChar = vram[tmpTileIdx];
int lookup = vram[charBase + (tileChar * 64) + ((ay & 7) * 8) + (ax & 7)];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[lookup * 2] | (palette[lookup * 2 + 1] << 8)));
uint r = pixelColor & 0xFF;
uint g = (pixelColor >> 8) & 0xFF;
uint b = (pixelColor >> 16) & 0xFF;
r = r + (((0xFF - r) * this.blendY) >> 4);
g = g + (((0xFF - g) * this.blendY) >> 4);
b = b + (((0xFF - b) * this.blendY) >> 4);
pixelColor = r | (g << 8) | (b << 16);
this.scanline[i] = pixelColor; this.blend[i] = blendMaskType;
}
}
}
x += dx;
y += dy;
}
}
private void RenderRotScaleBgBrightDec(int bg)
{
byte[] palette = this.memory.PaletteRam;
byte[] vram = this.memory.VideoRam;
byte blendMaskType = (byte)(1 << bg);
ushort bgcnt = Memory.ReadU16(this.memory.IORam, Memory.BG0CNT + 0x2 * (uint)bg);
int width = 0, height = 0;
switch ((bgcnt >> 14) & 0x3)
{
case 0: width = 128; height = 128; break;
case 1: width = 256; height = 256; break;
case 2: width = 512; height = 512; break;
case 3: width = 1024; height = 1024; break;
}
int screenBase = ((bgcnt >> 8) & 0x1F) * 0x800;
int charBase = ((bgcnt >> 2) & 0x3) * 0x4000;
int x = this.memory.Bgx[bg - 2];
int y = this.memory.Bgy[bg - 2];
short dx = (short)Memory.ReadU16(this.memory.IORam, Memory.BG2PA + (uint)(bg - 2) * 0x10);
short dy = (short)Memory.ReadU16(this.memory.IORam, Memory.BG2PC + (uint)(bg - 2) * 0x10);
bool transparent = (bgcnt & (1 << 13)) == 0;
for (int i = 0; i < 240; i++)
{
if (true)
{
int ax = x >> 8;
int ay = y >> 8;
if ((ax >= 0 && ax < width && ay >= 0 && ay < height) || !transparent)
{
int tmpTileIdx = (int)(screenBase + ((ay & (height - 1)) / 8) * (width / 8) + ((ax & (width - 1)) / 8));
int tileChar = vram[tmpTileIdx];
int lookup = vram[charBase + (tileChar * 64) + ((ay & 7) * 8) + (ax & 7)];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[lookup * 2] | (palette[lookup * 2 + 1] << 8)));
uint r = pixelColor & 0xFF;
uint g = (pixelColor >> 8) & 0xFF;
uint b = (pixelColor >> 16) & 0xFF;
r = r - ((r * this.blendY) >> 4);
g = g - ((g * this.blendY) >> 4);
b = b - ((b * this.blendY) >> 4);
pixelColor = r | (g << 8) | (b << 16);
this.scanline[i] = pixelColor; this.blend[i] = blendMaskType;
}
}
}
x += dx;
y += dy;
}
}
private void RenderRotScaleBgWindow(int bg)
{
byte[] palette = this.memory.PaletteRam;
byte[] vram = this.memory.VideoRam;
byte blendMaskType = (byte)(1 << bg);
ushort bgcnt = Memory.ReadU16(this.memory.IORam, Memory.BG0CNT + 0x2 * (uint)bg);
int width = 0, height = 0;
switch ((bgcnt >> 14) & 0x3)
{
case 0: width = 128; height = 128; break;
case 1: width = 256; height = 256; break;
case 2: width = 512; height = 512; break;
case 3: width = 1024; height = 1024; break;
}
int screenBase = ((bgcnt >> 8) & 0x1F) * 0x800;
int charBase = ((bgcnt >> 2) & 0x3) * 0x4000;
int x = this.memory.Bgx[bg - 2];
int y = this.memory.Bgy[bg - 2];
short dx = (short)Memory.ReadU16(this.memory.IORam, Memory.BG2PA + (uint)(bg - 2) * 0x10);
short dy = (short)Memory.ReadU16(this.memory.IORam, Memory.BG2PC + (uint)(bg - 2) * 0x10);
bool transparent = (bgcnt & (1 << 13)) == 0;
for (int i = 0; i < 240; i++)
{
if ((this.windowCover[i] & (1 << bg)) != 0)
{
int ax = x >> 8;
int ay = y >> 8;
if ((ax >= 0 && ax < width && ay >= 0 && ay < height) || !transparent)
{
int tmpTileIdx = (int)(screenBase + ((ay & (height - 1)) / 8) * (width / 8) + ((ax & (width - 1)) / 8));
int tileChar = vram[tmpTileIdx];
int lookup = vram[charBase + (tileChar * 64) + ((ay & 7) * 8) + (ax & 7)];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[lookup * 2] | (palette[lookup * 2 + 1] << 8)));
this.scanline[i] = pixelColor; this.blend[i] = blendMaskType;
}
}
}
x += dx;
y += dy;
}
}
private void RenderRotScaleBgWindowBlend(int bg)
{
byte[] palette = this.memory.PaletteRam;
byte[] vram = this.memory.VideoRam;
byte blendMaskType = (byte)(1 << bg);
ushort bgcnt = Memory.ReadU16(this.memory.IORam, Memory.BG0CNT + 0x2 * (uint)bg);
int width = 0, height = 0;
switch ((bgcnt >> 14) & 0x3)
{
case 0: width = 128; height = 128; break;
case 1: width = 256; height = 256; break;
case 2: width = 512; height = 512; break;
case 3: width = 1024; height = 1024; break;
}
int screenBase = ((bgcnt >> 8) & 0x1F) * 0x800;
int charBase = ((bgcnt >> 2) & 0x3) * 0x4000;
int x = this.memory.Bgx[bg - 2];
int y = this.memory.Bgy[bg - 2];
short dx = (short)Memory.ReadU16(this.memory.IORam, Memory.BG2PA + (uint)(bg - 2) * 0x10);
short dy = (short)Memory.ReadU16(this.memory.IORam, Memory.BG2PC + (uint)(bg - 2) * 0x10);
bool transparent = (bgcnt & (1 << 13)) == 0;
for (int i = 0; i < 240; i++)
{
if ((this.windowCover[i] & (1 << bg)) != 0)
{
int ax = x >> 8;
int ay = y >> 8;
if ((ax >= 0 && ax < width && ay >= 0 && ay < height) || !transparent)
{
int tmpTileIdx = (int)(screenBase + ((ay & (height - 1)) / 8) * (width / 8) + ((ax & (width - 1)) / 8));
int tileChar = vram[tmpTileIdx];
int lookup = vram[charBase + (tileChar * 64) + ((ay & 7) * 8) + (ax & 7)];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[lookup * 2] | (palette[lookup * 2 + 1] << 8)));
if ((this.windowCover[i] & (1 << 5)) != 0)
{
if ((this.blend[i] & this.blendTarget) != 0)
{
uint r = ((pixelColor & 0xFF) * this.blendA) >> 4;
uint g = (((pixelColor >> 8) & 0xFF) * this.blendA) >> 4;
uint b = (((pixelColor >> 16) & 0xFF) * this.blendA) >> 4;
uint sourceValue = this.scanline[i];
r += ((sourceValue & 0xFF) * this.blendB) >> 4;
g += (((sourceValue >> 8) & 0xFF) * this.blendB) >> 4;
b += (((sourceValue >> 16) & 0xFF) * this.blendB) >> 4;
if (r > 0xff) r = 0xff;
if (g > 0xff) g = 0xff;
if (b > 0xff) b = 0xff;
pixelColor = r | (g << 8) | (b << 16);
}
}
this.scanline[i] = pixelColor; this.blend[i] = blendMaskType;
}
}
}
x += dx;
y += dy;
}
}
private void RenderRotScaleBgWindowBrightInc(int bg)
{
byte[] palette = this.memory.PaletteRam;
byte[] vram = this.memory.VideoRam;
byte blendMaskType = (byte)(1 << bg);
ushort bgcnt = Memory.ReadU16(this.memory.IORam, Memory.BG0CNT + 0x2 * (uint)bg);
int width = 0, height = 0;
switch ((bgcnt >> 14) & 0x3)
{
case 0: width = 128; height = 128; break;
case 1: width = 256; height = 256; break;
case 2: width = 512; height = 512; break;
case 3: width = 1024; height = 1024; break;
}
int screenBase = ((bgcnt >> 8) & 0x1F) * 0x800;
int charBase = ((bgcnt >> 2) & 0x3) * 0x4000;
int x = this.memory.Bgx[bg - 2];
int y = this.memory.Bgy[bg - 2];
short dx = (short)Memory.ReadU16(this.memory.IORam, Memory.BG2PA + (uint)(bg - 2) * 0x10);
short dy = (short)Memory.ReadU16(this.memory.IORam, Memory.BG2PC + (uint)(bg - 2) * 0x10);
bool transparent = (bgcnt & (1 << 13)) == 0;
for (int i = 0; i < 240; i++)
{
if ((this.windowCover[i] & (1 << bg)) != 0)
{
int ax = x >> 8;
int ay = y >> 8;
if ((ax >= 0 && ax < width && ay >= 0 && ay < height) || !transparent)
{
int tmpTileIdx = (int)(screenBase + ((ay & (height - 1)) / 8) * (width / 8) + ((ax & (width - 1)) / 8));
int tileChar = vram[tmpTileIdx];
int lookup = vram[charBase + (tileChar * 64) + ((ay & 7) * 8) + (ax & 7)];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[lookup * 2] | (palette[lookup * 2 + 1] << 8)));
if ((this.windowCover[i] & (1 << 5)) != 0)
{
uint r = pixelColor & 0xFF;
uint g = (pixelColor >> 8) & 0xFF;
uint b = (pixelColor >> 16) & 0xFF;
r = r + (((0xFF - r) * this.blendY) >> 4);
g = g + (((0xFF - g) * this.blendY) >> 4);
b = b + (((0xFF - b) * this.blendY) >> 4);
pixelColor = r | (g << 8) | (b << 16);
}
this.scanline[i] = pixelColor; this.blend[i] = blendMaskType;
}
}
}
x += dx;
y += dy;
}
}
private void RenderRotScaleBgWindowBrightDec(int bg)
{
byte[] palette = this.memory.PaletteRam;
byte[] vram = this.memory.VideoRam;
byte blendMaskType = (byte)(1 << bg);
ushort bgcnt = Memory.ReadU16(this.memory.IORam, Memory.BG0CNT + 0x2 * (uint)bg);
int width = 0, height = 0;
switch ((bgcnt >> 14) & 0x3)
{
case 0: width = 128; height = 128; break;
case 1: width = 256; height = 256; break;
case 2: width = 512; height = 512; break;
case 3: width = 1024; height = 1024; break;
}
int screenBase = ((bgcnt >> 8) & 0x1F) * 0x800;
int charBase = ((bgcnt >> 2) & 0x3) * 0x4000;
int x = this.memory.Bgx[bg - 2];
int y = this.memory.Bgy[bg - 2];
short dx = (short)Memory.ReadU16(this.memory.IORam, Memory.BG2PA + (uint)(bg - 2) * 0x10);
short dy = (short)Memory.ReadU16(this.memory.IORam, Memory.BG2PC + (uint)(bg - 2) * 0x10);
bool transparent = (bgcnt & (1 << 13)) == 0;
for (int i = 0; i < 240; i++)
{
if ((this.windowCover[i] & (1 << bg)) != 0)
{
int ax = x >> 8;
int ay = y >> 8;
if ((ax >= 0 && ax < width && ay >= 0 && ay < height) || !transparent)
{
int tmpTileIdx = (int)(screenBase + ((ay & (height - 1)) / 8) * (width / 8) + ((ax & (width - 1)) / 8));
int tileChar = vram[tmpTileIdx];
int lookup = vram[charBase + (tileChar * 64) + ((ay & 7) * 8) + (ax & 7)];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[lookup * 2] | (palette[lookup * 2 + 1] << 8)));
if ((this.windowCover[i] & (1 << 5)) != 0)
{
uint r = pixelColor & 0xFF;
uint g = (pixelColor >> 8) & 0xFF;
uint b = (pixelColor >> 16) & 0xFF;
r = r - ((r * this.blendY) >> 4);
g = g - ((g * this.blendY) >> 4);
b = b - ((b * this.blendY) >> 4);
pixelColor = r | (g << 8) | (b << 16);
}
this.scanline[i] = pixelColor; this.blend[i] = blendMaskType;
}
}
}
x += dx;
y += dy;
}
}
#endregion Rot/Scale Bg
#region Text Bg
private void RenderTextBgNormal(int bg)
{
byte[] palette = this.memory.PaletteRam;
byte[] vram = this.memory.VideoRam;
byte blendMaskType = (byte)(1 << bg);
ushort bgcnt = Memory.ReadU16(this.memory.IORam, Memory.BG0CNT + 0x2 * (uint)bg);
int width = 0, height = 0;
switch ((bgcnt >> 14) & 0x3)
{
case 0: width = 256; height = 256; break;
case 1: width = 512; height = 256; break;
case 2: width = 256; height = 512; break;
case 3: width = 512; height = 512; break;
}
int screenBase = ((bgcnt >> 8) & 0x1F) * 0x800;
int charBase = ((bgcnt >> 2) & 0x3) * 0x4000;
int hofs = Memory.ReadU16(this.memory.IORam, Memory.BG0HOFS + (uint)bg * 4) & 0x1FF;
int vofs = Memory.ReadU16(this.memory.IORam, Memory.BG0VOFS + (uint)bg * 4) & 0x1FF;
if ((bgcnt & (1 << 7)) != 0)
{
// 256 color tiles
int bgy = ((this.curLine + vofs) & (height - 1)) / 8;
int tileIdx = screenBase + (((bgy & 31) * 32) * 2);
switch ((bgcnt >> 14) & 0x3)
{
case 2: if (bgy >= 32) tileIdx += 32 * 32 * 2; break;
case 3: if (bgy >= 32) tileIdx += 32 * 32 * 4; break;
}
int tileY = ((this.curLine + vofs) & 0x7) * 8;
for (int i = 0; i < 240; i++)
{
if (true)
{
int bgx = ((i + hofs) & (width - 1)) / 8;
int tmpTileIdx = tileIdx + ((bgx & 31) * 2);
if (bgx >= 32) tmpTileIdx += 32 * 32 * 2;
int tileChar = vram[tmpTileIdx] | (vram[tmpTileIdx + 1] << 8);
int x = (i + hofs) & 7;
int y = tileY;
if ((tileChar & (1 << 10)) != 0) x = 7 - x;
if ((tileChar & (1 << 11)) != 0) y = 56 - y;
int lookup = vram[charBase + ((tileChar & 0x3FF) * 64) + y + x];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[lookup * 2] | (palette[lookup * 2 + 1] << 8)));
this.scanline[i] = pixelColor; this.blend[i] = blendMaskType;
}
}
}
}
else
{
// 16 color tiles
int bgy = ((this.curLine + vofs) & (height - 1)) / 8;
int tileIdx = screenBase + (((bgy & 31) * 32) * 2);
switch ((bgcnt >> 14) & 0x3)
{
case 2: if (bgy >= 32) tileIdx += 32 * 32 * 2; break;
case 3: if (bgy >= 32) tileIdx += 32 * 32 * 4; break;
}
int tileY = ((this.curLine + vofs) & 0x7) * 4;
for (int i = 0; i < 240; i++)
{
if (true)
{
int bgx = ((i + hofs) & (width - 1)) / 8;
int tmpTileIdx = tileIdx + ((bgx & 31) * 2);
if (bgx >= 32) tmpTileIdx += 32 * 32 * 2;
int tileChar = vram[tmpTileIdx] | (vram[tmpTileIdx + 1] << 8);
int x = (i + hofs) & 7;
int y = tileY;
if ((tileChar & (1 << 10)) != 0) x = 7 - x;
if ((tileChar & (1 << 11)) != 0) y = 28 - y;
int lookup = vram[charBase + ((tileChar & 0x3FF) * 32) + y + (x / 2)];
if ((x & 1) == 0)
{
lookup &= 0xf;
}
else
{
lookup >>= 4;
}
if (lookup != 0)
{
int palNum = ((tileChar >> 12) & 0xf) * 16 * 2;
uint pixelColor = Renderer.GbaTo32((ushort)(palette[palNum + lookup * 2] | (palette[palNum + lookup * 2 + 1] << 8)));
this.scanline[i] = pixelColor; this.blend[i] = blendMaskType;
}
}
}
}
}
private void RenderTextBgBlend(int bg)
{
byte[] palette = this.memory.PaletteRam;
byte[] vram = this.memory.VideoRam;
byte blendMaskType = (byte)(1 << bg);
ushort bgcnt = Memory.ReadU16(this.memory.IORam, Memory.BG0CNT + 0x2 * (uint)bg);
int width = 0, height = 0;
switch ((bgcnt >> 14) & 0x3)
{
case 0: width = 256; height = 256; break;
case 1: width = 512; height = 256; break;
case 2: width = 256; height = 512; break;
case 3: width = 512; height = 512; break;
}
int screenBase = ((bgcnt >> 8) & 0x1F) * 0x800;
int charBase = ((bgcnt >> 2) & 0x3) * 0x4000;
int hofs = Memory.ReadU16(this.memory.IORam, Memory.BG0HOFS + (uint)bg * 4) & 0x1FF;
int vofs = Memory.ReadU16(this.memory.IORam, Memory.BG0VOFS + (uint)bg * 4) & 0x1FF;
if ((bgcnt & (1 << 7)) != 0)
{
// 256 color tiles
int bgy = ((this.curLine + vofs) & (height - 1)) / 8;
int tileIdx = screenBase + (((bgy & 31) * 32) * 2);
switch ((bgcnt >> 14) & 0x3)
{
case 2: if (bgy >= 32) tileIdx += 32 * 32 * 2; break;
case 3: if (bgy >= 32) tileIdx += 32 * 32 * 4; break;
}
int tileY = ((this.curLine + vofs) & 0x7) * 8;
for (int i = 0; i < 240; i++)
{
if (true)
{
int bgx = ((i + hofs) & (width - 1)) / 8;
int tmpTileIdx = tileIdx + ((bgx & 31) * 2);
if (bgx >= 32) tmpTileIdx += 32 * 32 * 2;
int tileChar = vram[tmpTileIdx] | (vram[tmpTileIdx + 1] << 8);
int x = (i + hofs) & 7;
int y = tileY;
if ((tileChar & (1 << 10)) != 0) x = 7 - x;
if ((tileChar & (1 << 11)) != 0) y = 56 - y;
int lookup = vram[charBase + ((tileChar & 0x3FF) * 64) + y + x];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[lookup * 2] | (palette[lookup * 2 + 1] << 8)));
if ((this.blend[i] & this.blendTarget) != 0)
{
uint r = ((pixelColor & 0xFF) * this.blendA) >> 4;
uint g = (((pixelColor >> 8) & 0xFF) * this.blendA) >> 4;
uint b = (((pixelColor >> 16) & 0xFF) * this.blendA) >> 4;
uint sourceValue = this.scanline[i];
r += ((sourceValue & 0xFF) * this.blendB) >> 4;
g += (((sourceValue >> 8) & 0xFF) * this.blendB) >> 4;
b += (((sourceValue >> 16) & 0xFF) * this.blendB) >> 4;
if (r > 0xff) r = 0xff;
if (g > 0xff) g = 0xff;
if (b > 0xff) b = 0xff;
pixelColor = r | (g << 8) | (b << 16);
}
this.scanline[i] = pixelColor; this.blend[i] = blendMaskType;
}
}
}
}
else
{
// 16 color tiles
int bgy = ((this.curLine + vofs) & (height - 1)) / 8;
int tileIdx = screenBase + (((bgy & 31) * 32) * 2);
switch ((bgcnt >> 14) & 0x3)
{
case 2: if (bgy >= 32) tileIdx += 32 * 32 * 2; break;
case 3: if (bgy >= 32) tileIdx += 32 * 32 * 4; break;
}
int tileY = ((this.curLine + vofs) & 0x7) * 4;
for (int i = 0; i < 240; i++)
{
if (true)
{
int bgx = ((i + hofs) & (width - 1)) / 8;
int tmpTileIdx = tileIdx + ((bgx & 31) * 2);
if (bgx >= 32) tmpTileIdx += 32 * 32 * 2;
int tileChar = vram[tmpTileIdx] | (vram[tmpTileIdx + 1] << 8);
int x = (i + hofs) & 7;
int y = tileY;
if ((tileChar & (1 << 10)) != 0) x = 7 - x;
if ((tileChar & (1 << 11)) != 0) y = 28 - y;
int lookup = vram[charBase + ((tileChar & 0x3FF) * 32) + y + (x / 2)];
if ((x & 1) == 0)
{
lookup &= 0xf;
}
else
{
lookup >>= 4;
}
if (lookup != 0)
{
int palNum = ((tileChar >> 12) & 0xf) * 16 * 2;
uint pixelColor = Renderer.GbaTo32((ushort)(palette[palNum + lookup * 2] | (palette[palNum + lookup * 2 + 1] << 8)));
if ((this.blend[i] & this.blendTarget) != 0)
{
uint r = ((pixelColor & 0xFF) * this.blendA) >> 4;
uint g = (((pixelColor >> 8) & 0xFF) * this.blendA) >> 4;
uint b = (((pixelColor >> 16) & 0xFF) * this.blendA) >> 4;
uint sourceValue = this.scanline[i];
r += ((sourceValue & 0xFF) * this.blendB) >> 4;
g += (((sourceValue >> 8) & 0xFF) * this.blendB) >> 4;
b += (((sourceValue >> 16) & 0xFF) * this.blendB) >> 4;
if (r > 0xff) r = 0xff;
if (g > 0xff) g = 0xff;
if (b > 0xff) b = 0xff;
pixelColor = r | (g << 8) | (b << 16);
}
this.scanline[i] = pixelColor; this.blend[i] = blendMaskType;
}
}
}
}
}
private void RenderTextBgBrightInc(int bg)
{
byte[] palette = this.memory.PaletteRam;
byte[] vram = this.memory.VideoRam;
byte blendMaskType = (byte)(1 << bg);
ushort bgcnt = Memory.ReadU16(this.memory.IORam, Memory.BG0CNT + 0x2 * (uint)bg);
int width = 0, height = 0;
switch ((bgcnt >> 14) & 0x3)
{
case 0: width = 256; height = 256; break;
case 1: width = 512; height = 256; break;
case 2: width = 256; height = 512; break;
case 3: width = 512; height = 512; break;
}
int screenBase = ((bgcnt >> 8) & 0x1F) * 0x800;
int charBase = ((bgcnt >> 2) & 0x3) * 0x4000;
int hofs = Memory.ReadU16(this.memory.IORam, Memory.BG0HOFS + (uint)bg * 4) & 0x1FF;
int vofs = Memory.ReadU16(this.memory.IORam, Memory.BG0VOFS + (uint)bg * 4) & 0x1FF;
if ((bgcnt & (1 << 7)) != 0)
{
// 256 color tiles
int bgy = ((this.curLine + vofs) & (height - 1)) / 8;
int tileIdx = screenBase + (((bgy & 31) * 32) * 2);
switch ((bgcnt >> 14) & 0x3)
{
case 2: if (bgy >= 32) tileIdx += 32 * 32 * 2; break;
case 3: if (bgy >= 32) tileIdx += 32 * 32 * 4; break;
}
int tileY = ((this.curLine + vofs) & 0x7) * 8;
for (int i = 0; i < 240; i++)
{
if (true)
{
int bgx = ((i + hofs) & (width - 1)) / 8;
int tmpTileIdx = tileIdx + ((bgx & 31) * 2);
if (bgx >= 32) tmpTileIdx += 32 * 32 * 2;
int tileChar = vram[tmpTileIdx] | (vram[tmpTileIdx + 1] << 8);
int x = (i + hofs) & 7;
int y = tileY;
if ((tileChar & (1 << 10)) != 0) x = 7 - x;
if ((tileChar & (1 << 11)) != 0) y = 56 - y;
int lookup = vram[charBase + ((tileChar & 0x3FF) * 64) + y + x];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[lookup * 2] | (palette[lookup * 2 + 1] << 8)));
uint r = pixelColor & 0xFF;
uint g = (pixelColor >> 8) & 0xFF;
uint b = (pixelColor >> 16) & 0xFF;
r = r + (((0xFF - r) * this.blendY) >> 4);
g = g + (((0xFF - g) * this.blendY) >> 4);
b = b + (((0xFF - b) * this.blendY) >> 4);
pixelColor = r | (g << 8) | (b << 16);
this.scanline[i] = pixelColor; this.blend[i] = blendMaskType;
}
}
}
}
else
{
// 16 color tiles
int bgy = ((this.curLine + vofs) & (height - 1)) / 8;
int tileIdx = screenBase + (((bgy & 31) * 32) * 2);
switch ((bgcnt >> 14) & 0x3)
{
case 2: if (bgy >= 32) tileIdx += 32 * 32 * 2; break;
case 3: if (bgy >= 32) tileIdx += 32 * 32 * 4; break;
}
int tileY = ((this.curLine + vofs) & 0x7) * 4;
for (int i = 0; i < 240; i++)
{
if (true)
{
int bgx = ((i + hofs) & (width - 1)) / 8;
int tmpTileIdx = tileIdx + ((bgx & 31) * 2);
if (bgx >= 32) tmpTileIdx += 32 * 32 * 2;
int tileChar = vram[tmpTileIdx] | (vram[tmpTileIdx + 1] << 8);
int x = (i + hofs) & 7;
int y = tileY;
if ((tileChar & (1 << 10)) != 0) x = 7 - x;
if ((tileChar & (1 << 11)) != 0) y = 28 - y;
int lookup = vram[charBase + ((tileChar & 0x3FF) * 32) + y + (x / 2)];
if ((x & 1) == 0)
{
lookup &= 0xf;
}
else
{
lookup >>= 4;
}
if (lookup != 0)
{
int palNum = ((tileChar >> 12) & 0xf) * 16 * 2;
uint pixelColor = Renderer.GbaTo32((ushort)(palette[palNum + lookup * 2] | (palette[palNum + lookup * 2 + 1] << 8)));
uint r = pixelColor & 0xFF;
uint g = (pixelColor >> 8) & 0xFF;
uint b = (pixelColor >> 16) & 0xFF;
r = r + (((0xFF - r) * this.blendY) >> 4);
g = g + (((0xFF - g) * this.blendY) >> 4);
b = b + (((0xFF - b) * this.blendY) >> 4);
pixelColor = r | (g << 8) | (b << 16);
this.scanline[i] = pixelColor; this.blend[i] = blendMaskType;
}
}
}
}
}
private void RenderTextBgBrightDec(int bg)
{
byte[] palette = this.memory.PaletteRam;
byte[] vram = this.memory.VideoRam;
byte blendMaskType = (byte)(1 << bg);
ushort bgcnt = Memory.ReadU16(this.memory.IORam, Memory.BG0CNT + 0x2 * (uint)bg);
int width = 0, height = 0;
switch ((bgcnt >> 14) & 0x3)
{
case 0: width = 256; height = 256; break;
case 1: width = 512; height = 256; break;
case 2: width = 256; height = 512; break;
case 3: width = 512; height = 512; break;
}
int screenBase = ((bgcnt >> 8) & 0x1F) * 0x800;
int charBase = ((bgcnt >> 2) & 0x3) * 0x4000;
int hofs = Memory.ReadU16(this.memory.IORam, Memory.BG0HOFS + (uint)bg * 4) & 0x1FF;
int vofs = Memory.ReadU16(this.memory.IORam, Memory.BG0VOFS + (uint)bg * 4) & 0x1FF;
if ((bgcnt & (1 << 7)) != 0)
{
// 256 color tiles
int bgy = ((this.curLine + vofs) & (height - 1)) / 8;
int tileIdx = screenBase + (((bgy & 31) * 32) * 2);
switch ((bgcnt >> 14) & 0x3)
{
case 2: if (bgy >= 32) tileIdx += 32 * 32 * 2; break;
case 3: if (bgy >= 32) tileIdx += 32 * 32 * 4; break;
}
int tileY = ((this.curLine + vofs) & 0x7) * 8;
for (int i = 0; i < 240; i++)
{
if (true)
{
int bgx = ((i + hofs) & (width - 1)) / 8;
int tmpTileIdx = tileIdx + ((bgx & 31) * 2);
if (bgx >= 32) tmpTileIdx += 32 * 32 * 2;
int tileChar = vram[tmpTileIdx] | (vram[tmpTileIdx + 1] << 8);
int x = (i + hofs) & 7;
int y = tileY;
if ((tileChar & (1 << 10)) != 0) x = 7 - x;
if ((tileChar & (1 << 11)) != 0) y = 56 - y;
int lookup = vram[charBase + ((tileChar & 0x3FF) * 64) + y + x];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[lookup * 2] | (palette[lookup * 2 + 1] << 8)));
uint r = pixelColor & 0xFF;
uint g = (pixelColor >> 8) & 0xFF;
uint b = (pixelColor >> 16) & 0xFF;
r = r - ((r * this.blendY) >> 4);
g = g - ((g * this.blendY) >> 4);
b = b - ((b * this.blendY) >> 4);
pixelColor = r | (g << 8) | (b << 16);
this.scanline[i] = pixelColor; this.blend[i] = blendMaskType;
}
}
}
}
else
{
// 16 color tiles
int bgy = ((this.curLine + vofs) & (height - 1)) / 8;
int tileIdx = screenBase + (((bgy & 31) * 32) * 2);
switch ((bgcnt >> 14) & 0x3)
{
case 2: if (bgy >= 32) tileIdx += 32 * 32 * 2; break;
case 3: if (bgy >= 32) tileIdx += 32 * 32 * 4; break;
}
int tileY = ((this.curLine + vofs) & 0x7) * 4;
for (int i = 0; i < 240; i++)
{
if (true)
{
int bgx = ((i + hofs) & (width - 1)) / 8;
int tmpTileIdx = tileIdx + ((bgx & 31) * 2);
if (bgx >= 32) tmpTileIdx += 32 * 32 * 2;
int tileChar = vram[tmpTileIdx] | (vram[tmpTileIdx + 1] << 8);
int x = (i + hofs) & 7;
int y = tileY;
if ((tileChar & (1 << 10)) != 0) x = 7 - x;
if ((tileChar & (1 << 11)) != 0) y = 28 - y;
int lookup = vram[charBase + ((tileChar & 0x3FF) * 32) + y + (x / 2)];
if ((x & 1) == 0)
{
lookup &= 0xf;
}
else
{
lookup >>= 4;
}
if (lookup != 0)
{
int palNum = ((tileChar >> 12) & 0xf) * 16 * 2;
uint pixelColor = Renderer.GbaTo32((ushort)(palette[palNum + lookup * 2] | (palette[palNum + lookup * 2 + 1] << 8)));
uint r = pixelColor & 0xFF;
uint g = (pixelColor >> 8) & 0xFF;
uint b = (pixelColor >> 16) & 0xFF;
r = r - ((r * this.blendY) >> 4);
g = g - ((g * this.blendY) >> 4);
b = b - ((b * this.blendY) >> 4);
pixelColor = r | (g << 8) | (b << 16);
this.scanline[i] = pixelColor; this.blend[i] = blendMaskType;
}
}
}
}
}
private void RenderTextBgWindow(int bg)
{
byte[] palette = this.memory.PaletteRam;
byte[] vram = this.memory.VideoRam;
byte blendMaskType = (byte)(1 << bg);
ushort bgcnt = Memory.ReadU16(this.memory.IORam, Memory.BG0CNT + 0x2 * (uint)bg);
int width = 0, height = 0;
switch ((bgcnt >> 14) & 0x3)
{
case 0: width = 256; height = 256; break;
case 1: width = 512; height = 256; break;
case 2: width = 256; height = 512; break;
case 3: width = 512; height = 512; break;
}
int screenBase = ((bgcnt >> 8) & 0x1F) * 0x800;
int charBase = ((bgcnt >> 2) & 0x3) * 0x4000;
int hofs = Memory.ReadU16(this.memory.IORam, Memory.BG0HOFS + (uint)bg * 4) & 0x1FF;
int vofs = Memory.ReadU16(this.memory.IORam, Memory.BG0VOFS + (uint)bg * 4) & 0x1FF;
if ((bgcnt & (1 << 7)) != 0)
{
// 256 color tiles
int bgy = ((this.curLine + vofs) & (height - 1)) / 8;
int tileIdx = screenBase + (((bgy & 31) * 32) * 2);
switch ((bgcnt >> 14) & 0x3)
{
case 2: if (bgy >= 32) tileIdx += 32 * 32 * 2; break;
case 3: if (bgy >= 32) tileIdx += 32 * 32 * 4; break;
}
int tileY = ((this.curLine + vofs) & 0x7) * 8;
for (int i = 0; i < 240; i++)
{
if ((this.windowCover[i] & (1 << bg)) != 0)
{
int bgx = ((i + hofs) & (width - 1)) / 8;
int tmpTileIdx = tileIdx + ((bgx & 31) * 2);
if (bgx >= 32) tmpTileIdx += 32 * 32 * 2;
int tileChar = vram[tmpTileIdx] | (vram[tmpTileIdx + 1] << 8);
int x = (i + hofs) & 7;
int y = tileY;
if ((tileChar & (1 << 10)) != 0) x = 7 - x;
if ((tileChar & (1 << 11)) != 0) y = 56 - y;
int lookup = vram[charBase + ((tileChar & 0x3FF) * 64) + y + x];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[lookup * 2] | (palette[lookup * 2 + 1] << 8)));
this.scanline[i] = pixelColor; this.blend[i] = blendMaskType;
}
}
}
}
else
{
// 16 color tiles
int bgy = ((this.curLine + vofs) & (height - 1)) / 8;
int tileIdx = screenBase + (((bgy & 31) * 32) * 2);
switch ((bgcnt >> 14) & 0x3)
{
case 2: if (bgy >= 32) tileIdx += 32 * 32 * 2; break;
case 3: if (bgy >= 32) tileIdx += 32 * 32 * 4; break;
}
int tileY = ((this.curLine + vofs) & 0x7) * 4;
for (int i = 0; i < 240; i++)
{
if ((this.windowCover[i] & (1 << bg)) != 0)
{
int bgx = ((i + hofs) & (width - 1)) / 8;
int tmpTileIdx = tileIdx + ((bgx & 31) * 2);
if (bgx >= 32) tmpTileIdx += 32 * 32 * 2;
int tileChar = vram[tmpTileIdx] | (vram[tmpTileIdx + 1] << 8);
int x = (i + hofs) & 7;
int y = tileY;
if ((tileChar & (1 << 10)) != 0) x = 7 - x;
if ((tileChar & (1 << 11)) != 0) y = 28 - y;
int lookup = vram[charBase + ((tileChar & 0x3FF) * 32) + y + (x / 2)];
if ((x & 1) == 0)
{
lookup &= 0xf;
}
else
{
lookup >>= 4;
}
if (lookup != 0)
{
int palNum = ((tileChar >> 12) & 0xf) * 16 * 2;
uint pixelColor = Renderer.GbaTo32((ushort)(palette[palNum + lookup * 2] | (palette[palNum + lookup * 2 + 1] << 8)));
this.scanline[i] = pixelColor; this.blend[i] = blendMaskType;
}
}
}
}
}
private void RenderTextBgWindowBlend(int bg)
{
byte[] palette = this.memory.PaletteRam;
byte[] vram = this.memory.VideoRam;
byte blendMaskType = (byte)(1 << bg);
ushort bgcnt = Memory.ReadU16(this.memory.IORam, Memory.BG0CNT + 0x2 * (uint)bg);
int width = 0, height = 0;
switch ((bgcnt >> 14) & 0x3)
{
case 0: width = 256; height = 256; break;
case 1: width = 512; height = 256; break;
case 2: width = 256; height = 512; break;
case 3: width = 512; height = 512; break;
}
int screenBase = ((bgcnt >> 8) & 0x1F) * 0x800;
int charBase = ((bgcnt >> 2) & 0x3) * 0x4000;
int hofs = Memory.ReadU16(this.memory.IORam, Memory.BG0HOFS + (uint)bg * 4) & 0x1FF;
int vofs = Memory.ReadU16(this.memory.IORam, Memory.BG0VOFS + (uint)bg * 4) & 0x1FF;
if ((bgcnt & (1 << 7)) != 0)
{
// 256 color tiles
int bgy = ((this.curLine + vofs) & (height - 1)) / 8;
int tileIdx = screenBase + (((bgy & 31) * 32) * 2);
switch ((bgcnt >> 14) & 0x3)
{
case 2: if (bgy >= 32) tileIdx += 32 * 32 * 2; break;
case 3: if (bgy >= 32) tileIdx += 32 * 32 * 4; break;
}
int tileY = ((this.curLine + vofs) & 0x7) * 8;
for (int i = 0; i < 240; i++)
{
if ((this.windowCover[i] & (1 << bg)) != 0)
{
int bgx = ((i + hofs) & (width - 1)) / 8;
int tmpTileIdx = tileIdx + ((bgx & 31) * 2);
if (bgx >= 32) tmpTileIdx += 32 * 32 * 2;
int tileChar = vram[tmpTileIdx] | (vram[tmpTileIdx + 1] << 8);
int x = (i + hofs) & 7;
int y = tileY;
if ((tileChar & (1 << 10)) != 0) x = 7 - x;
if ((tileChar & (1 << 11)) != 0) y = 56 - y;
int lookup = vram[charBase + ((tileChar & 0x3FF) * 64) + y + x];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[lookup * 2] | (palette[lookup * 2 + 1] << 8)));
if ((this.windowCover[i] & (1 << 5)) != 0)
{
if ((this.blend[i] & this.blendTarget) != 0)
{
uint r = ((pixelColor & 0xFF) * this.blendA) >> 4;
uint g = (((pixelColor >> 8) & 0xFF) * this.blendA) >> 4;
uint b = (((pixelColor >> 16) & 0xFF) * this.blendA) >> 4;
uint sourceValue = this.scanline[i];
r += ((sourceValue & 0xFF) * this.blendB) >> 4;
g += (((sourceValue >> 8) & 0xFF) * this.blendB) >> 4;
b += (((sourceValue >> 16) & 0xFF) * this.blendB) >> 4;
if (r > 0xff) r = 0xff;
if (g > 0xff) g = 0xff;
if (b > 0xff) b = 0xff;
pixelColor = r | (g << 8) | (b << 16);
}
}
this.scanline[i] = pixelColor; this.blend[i] = blendMaskType;
}
}
}
}
else
{
// 16 color tiles
int bgy = ((this.curLine + vofs) & (height - 1)) / 8;
int tileIdx = screenBase + (((bgy & 31) * 32) * 2);
switch ((bgcnt >> 14) & 0x3)
{
case 2: if (bgy >= 32) tileIdx += 32 * 32 * 2; break;
case 3: if (bgy >= 32) tileIdx += 32 * 32 * 4; break;
}
int tileY = ((this.curLine + vofs) & 0x7) * 4;
for (int i = 0; i < 240; i++)
{
if ((this.windowCover[i] & (1 << bg)) != 0)
{
int bgx = ((i + hofs) & (width - 1)) / 8;
int tmpTileIdx = tileIdx + ((bgx & 31) * 2);
if (bgx >= 32) tmpTileIdx += 32 * 32 * 2;
int tileChar = vram[tmpTileIdx] | (vram[tmpTileIdx + 1] << 8);
int x = (i + hofs) & 7;
int y = tileY;
if ((tileChar & (1 << 10)) != 0) x = 7 - x;
if ((tileChar & (1 << 11)) != 0) y = 28 - y;
int lookup = vram[charBase + ((tileChar & 0x3FF) * 32) + y + (x / 2)];
if ((x & 1) == 0)
{
lookup &= 0xf;
}
else
{
lookup >>= 4;
}
if (lookup != 0)
{
int palNum = ((tileChar >> 12) & 0xf) * 16 * 2;
uint pixelColor = Renderer.GbaTo32((ushort)(palette[palNum + lookup * 2] | (palette[palNum + lookup * 2 + 1] << 8)));
if ((this.windowCover[i] & (1 << 5)) != 0)
{
if ((this.blend[i] & this.blendTarget) != 0)
{
uint r = ((pixelColor & 0xFF) * this.blendA) >> 4;
uint g = (((pixelColor >> 8) & 0xFF) * this.blendA) >> 4;
uint b = (((pixelColor >> 16) & 0xFF) * this.blendA) >> 4;
uint sourceValue = this.scanline[i];
r += ((sourceValue & 0xFF) * this.blendB) >> 4;
g += (((sourceValue >> 8) & 0xFF) * this.blendB) >> 4;
b += (((sourceValue >> 16) & 0xFF) * this.blendB) >> 4;
if (r > 0xff) r = 0xff;
if (g > 0xff) g = 0xff;
if (b > 0xff) b = 0xff;
pixelColor = r | (g << 8) | (b << 16);
}
}
this.scanline[i] = pixelColor; this.blend[i] = blendMaskType;
}
}
}
}
}
private void RenderTextBgWindowBrightInc(int bg)
{
byte[] palette = this.memory.PaletteRam;
byte[] vram = this.memory.VideoRam;
byte blendMaskType = (byte)(1 << bg);
ushort bgcnt = Memory.ReadU16(this.memory.IORam, Memory.BG0CNT + 0x2 * (uint)bg);
int width = 0, height = 0;
switch ((bgcnt >> 14) & 0x3)
{
case 0: width = 256; height = 256; break;
case 1: width = 512; height = 256; break;
case 2: width = 256; height = 512; break;
case 3: width = 512; height = 512; break;
}
int screenBase = ((bgcnt >> 8) & 0x1F) * 0x800;
int charBase = ((bgcnt >> 2) & 0x3) * 0x4000;
int hofs = Memory.ReadU16(this.memory.IORam, Memory.BG0HOFS + (uint)bg * 4) & 0x1FF;
int vofs = Memory.ReadU16(this.memory.IORam, Memory.BG0VOFS + (uint)bg * 4) & 0x1FF;
if ((bgcnt & (1 << 7)) != 0)
{
// 256 color tiles
int bgy = ((this.curLine + vofs) & (height - 1)) / 8;
int tileIdx = screenBase + (((bgy & 31) * 32) * 2);
switch ((bgcnt >> 14) & 0x3)
{
case 2: if (bgy >= 32) tileIdx += 32 * 32 * 2; break;
case 3: if (bgy >= 32) tileIdx += 32 * 32 * 4; break;
}
int tileY = ((this.curLine + vofs) & 0x7) * 8;
for (int i = 0; i < 240; i++)
{
if ((this.windowCover[i] & (1 << bg)) != 0)
{
int bgx = ((i + hofs) & (width - 1)) / 8;
int tmpTileIdx = tileIdx + ((bgx & 31) * 2);
if (bgx >= 32) tmpTileIdx += 32 * 32 * 2;
int tileChar = vram[tmpTileIdx] | (vram[tmpTileIdx + 1] << 8);
int x = (i + hofs) & 7;
int y = tileY;
if ((tileChar & (1 << 10)) != 0) x = 7 - x;
if ((tileChar & (1 << 11)) != 0) y = 56 - y;
int lookup = vram[charBase + ((tileChar & 0x3FF) * 64) + y + x];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[lookup * 2] | (palette[lookup * 2 + 1] << 8)));
if ((this.windowCover[i] & (1 << 5)) != 0)
{
uint r = pixelColor & 0xFF;
uint g = (pixelColor >> 8) & 0xFF;
uint b = (pixelColor >> 16) & 0xFF;
r = r + (((0xFF - r) * this.blendY) >> 4);
g = g + (((0xFF - g) * this.blendY) >> 4);
b = b + (((0xFF - b) * this.blendY) >> 4);
pixelColor = r | (g << 8) | (b << 16);
}
this.scanline[i] = pixelColor; this.blend[i] = blendMaskType;
}
}
}
}
else
{
// 16 color tiles
int bgy = ((this.curLine + vofs) & (height - 1)) / 8;
int tileIdx = screenBase + (((bgy & 31) * 32) * 2);
switch ((bgcnt >> 14) & 0x3)
{
case 2: if (bgy >= 32) tileIdx += 32 * 32 * 2; break;
case 3: if (bgy >= 32) tileIdx += 32 * 32 * 4; break;
}
int tileY = ((this.curLine + vofs) & 0x7) * 4;
for (int i = 0; i < 240; i++)
{
if ((this.windowCover[i] & (1 << bg)) != 0)
{
int bgx = ((i + hofs) & (width - 1)) / 8;
int tmpTileIdx = tileIdx + ((bgx & 31) * 2);
if (bgx >= 32) tmpTileIdx += 32 * 32 * 2;
int tileChar = vram[tmpTileIdx] | (vram[tmpTileIdx + 1] << 8);
int x = (i + hofs) & 7;
int y = tileY;
if ((tileChar & (1 << 10)) != 0) x = 7 - x;
if ((tileChar & (1 << 11)) != 0) y = 28 - y;
int lookup = vram[charBase + ((tileChar & 0x3FF) * 32) + y + (x / 2)];
if ((x & 1) == 0)
{
lookup &= 0xf;
}
else
{
lookup >>= 4;
}
if (lookup != 0)
{
int palNum = ((tileChar >> 12) & 0xf) * 16 * 2;
uint pixelColor = Renderer.GbaTo32((ushort)(palette[palNum + lookup * 2] | (palette[palNum + lookup * 2 + 1] << 8)));
if ((this.windowCover[i] & (1 << 5)) != 0)
{
uint r = pixelColor & 0xFF;
uint g = (pixelColor >> 8) & 0xFF;
uint b = (pixelColor >> 16) & 0xFF;
r = r + (((0xFF - r) * this.blendY) >> 4);
g = g + (((0xFF - g) * this.blendY) >> 4);
b = b + (((0xFF - b) * this.blendY) >> 4);
pixelColor = r | (g << 8) | (b << 16);
}
this.scanline[i] = pixelColor; this.blend[i] = blendMaskType;
}
}
}
}
}
private void RenderTextBgWindowBrightDec(int bg)
{
byte[] palette = this.memory.PaletteRam;
byte[] vram = this.memory.VideoRam;
byte blendMaskType = (byte)(1 << bg);
ushort bgcnt = Memory.ReadU16(this.memory.IORam, Memory.BG0CNT + 0x2 * (uint)bg);
int width = 0, height = 0;
switch ((bgcnt >> 14) & 0x3)
{
case 0: width = 256; height = 256; break;
case 1: width = 512; height = 256; break;
case 2: width = 256; height = 512; break;
case 3: width = 512; height = 512; break;
}
int screenBase = ((bgcnt >> 8) & 0x1F) * 0x800;
int charBase = ((bgcnt >> 2) & 0x3) * 0x4000;
int hofs = Memory.ReadU16(this.memory.IORam, Memory.BG0HOFS + (uint)bg * 4) & 0x1FF;
int vofs = Memory.ReadU16(this.memory.IORam, Memory.BG0VOFS + (uint)bg * 4) & 0x1FF;
if ((bgcnt & (1 << 7)) != 0)
{
// 256 color tiles
int bgy = ((this.curLine + vofs) & (height - 1)) / 8;
int tileIdx = screenBase + (((bgy & 31) * 32) * 2);
switch ((bgcnt >> 14) & 0x3)
{
case 2: if (bgy >= 32) tileIdx += 32 * 32 * 2; break;
case 3: if (bgy >= 32) tileIdx += 32 * 32 * 4; break;
}
int tileY = ((this.curLine + vofs) & 0x7) * 8;
for (int i = 0; i < 240; i++)
{
if ((this.windowCover[i] & (1 << bg)) != 0)
{
int bgx = ((i + hofs) & (width - 1)) / 8;
int tmpTileIdx = tileIdx + ((bgx & 31) * 2);
if (bgx >= 32) tmpTileIdx += 32 * 32 * 2;
int tileChar = vram[tmpTileIdx] | (vram[tmpTileIdx + 1] << 8);
int x = (i + hofs) & 7;
int y = tileY;
if ((tileChar & (1 << 10)) != 0) x = 7 - x;
if ((tileChar & (1 << 11)) != 0) y = 56 - y;
int lookup = vram[charBase + ((tileChar & 0x3FF) * 64) + y + x];
if (lookup != 0)
{
uint pixelColor = Renderer.GbaTo32((ushort)(palette[lookup * 2] | (palette[lookup * 2 + 1] << 8)));
if ((this.windowCover[i] & (1 << 5)) != 0)
{
uint r = pixelColor & 0xFF;
uint g = (pixelColor >> 8) & 0xFF;
uint b = (pixelColor >> 16) & 0xFF;
r = r - ((r * this.blendY) >> 4);
g = g - ((g * this.blendY) >> 4);
b = b - ((b * this.blendY) >> 4);
pixelColor = r | (g << 8) | (b << 16);
}
this.scanline[i] = pixelColor; this.blend[i] = blendMaskType;
}
}
}
}
else
{
// 16 color tiles
int bgy = ((this.curLine + vofs) & (height - 1)) / 8;
int tileIdx = screenBase + (((bgy & 31) * 32) * 2);
switch ((bgcnt >> 14) & 0x3)
{
case 2: if (bgy >= 32) tileIdx += 32 * 32 * 2; break;
case 3: if (bgy >= 32) tileIdx += 32 * 32 * 4; break;
}
int tileY = ((this.curLine + vofs) & 0x7) * 4;
for (int i = 0; i < 240; i++)
{
if ((this.windowCover[i] & (1 << bg)) != 0)
{
int bgx = ((i + hofs) & (width - 1)) / 8;
int tmpTileIdx = tileIdx + ((bgx & 31) * 2);
if (bgx >= 32) tmpTileIdx += 32 * 32 * 2;
int tileChar = vram[tmpTileIdx] | (vram[tmpTileIdx + 1] << 8);
int x = (i + hofs) & 7;
int y = tileY;
if ((tileChar & (1 << 10)) != 0) x = 7 - x;
if ((tileChar & (1 << 11)) != 0) y = 28 - y;
int lookup = vram[charBase + ((tileChar & 0x3FF) * 32) + y + (x / 2)];
if ((x & 1) == 0)
{
lookup &= 0xf;
}
else
{
lookup >>= 4;
}
if (lookup != 0)
{
int palNum = ((tileChar >> 12) & 0xf) * 16 * 2;
uint pixelColor = Renderer.GbaTo32((ushort)(palette[palNum + lookup * 2] | (palette[palNum + lookup * 2 + 1] << 8)));
if ((this.windowCover[i] & (1 << 5)) != 0)
{
uint r = pixelColor & 0xFF;
uint g = (pixelColor >> 8) & 0xFF;
uint b = (pixelColor >> 16) & 0xFF;
r = r - ((r * this.blendY) >> 4);
g = g - ((g * this.blendY) >> 4);
b = b - ((b * this.blendY) >> 4);
pixelColor = r | (g << 8) | (b << 16);
}
this.scanline[i] = pixelColor; this.blend[i] = blendMaskType;
}
}
}
}
}
#endregion Text Bg
}
}
