968 lines
22 KiB
C
968 lines
22 KiB
C
/*
|
|
PokeMini - Pokémon-Mini Emulator
|
|
Copyright (C) 2009-2012 JustBurn
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "PokeMini.h"
|
|
#include "Video_x2.h"
|
|
|
|
const TPokeMini_VideoSpec PokeMini_Video2x2 = {
|
|
2, 2,
|
|
PokeMini_GetVideo2x2_16,
|
|
PokeMini_GetVideo2x2_32
|
|
};
|
|
|
|
const TPokeMini_VideoSpec PokeMini_Video2x2_NDS = { // For NDS
|
|
2, 2,
|
|
PokeMini_GetVideo2x2_8P,
|
|
PokeMini_GetVideo2x2_32
|
|
};
|
|
|
|
const int LCDMask2x2[2*2] = {
|
|
256, 192,
|
|
192, 160,
|
|
};
|
|
|
|
TPokeMini_DrawVideo32 PokeMini_GetVideo2x2_32(int filter, int lcdmode)
|
|
{
|
|
if (filter == PokeMini_Scanline) {
|
|
switch (lcdmode) {
|
|
case 3: return PokeMini_VideoColorL2x2_32;
|
|
case 2: return PokeMini_Video2ScanLine2x2_32;
|
|
case 1: return PokeMini_Video3ScanLine2x2_32;
|
|
default: return PokeMini_VideoAScanLine2x2_32;
|
|
}
|
|
} else if (filter == PokeMini_Matrix) {
|
|
switch (lcdmode) {
|
|
case 3: return (VidEnableHighcolor) ? PokeMini_VideoColorH2x2_32 : PokeMini_VideoColor2x2_32;
|
|
case 2: return PokeMini_Video2Matrix2x2_32;
|
|
case 1: return PokeMini_Video3Matrix2x2_32;
|
|
default: return PokeMini_VideoAMatrix2x2_32;
|
|
}
|
|
} else {
|
|
switch (lcdmode) {
|
|
case 3: return PokeMini_VideoColor2x2_32;
|
|
case 2: return PokeMini_Video2None2x2_32;
|
|
case 1: return PokeMini_Video3None2x2_32;
|
|
default: return PokeMini_VideoANone2x2_32;
|
|
}
|
|
}
|
|
}
|
|
|
|
TPokeMini_DrawVideo16 PokeMini_GetVideo2x2_16(int filter, int lcdmode)
|
|
{
|
|
if (filter == PokeMini_Scanline) {
|
|
switch (lcdmode) {
|
|
case 3: return PokeMini_VideoColorL2x2_16;
|
|
case 2: return PokeMini_Video2ScanLine2x2_16;
|
|
case 1: return PokeMini_Video3ScanLine2x2_16;
|
|
default: return PokeMini_VideoAScanLine2x2_16;
|
|
}
|
|
} else if (filter == PokeMini_Matrix) {
|
|
switch (lcdmode) {
|
|
case 3: return (VidEnableHighcolor) ? PokeMini_VideoColorH2x2_16 : PokeMini_VideoColor2x2_16;
|
|
case 2: return PokeMini_Video2Matrix2x2_16;
|
|
case 1: return PokeMini_Video3Matrix2x2_16;
|
|
default: return PokeMini_VideoAMatrix2x2_16;
|
|
}
|
|
} else {
|
|
switch (lcdmode) {
|
|
case 3: return PokeMini_VideoColor2x2_16;
|
|
case 2: return PokeMini_Video2None2x2_16;
|
|
case 1: return PokeMini_Video3None2x2_16;
|
|
default: return PokeMini_VideoANone2x2_16;
|
|
}
|
|
}
|
|
}
|
|
|
|
TPokeMini_DrawVideo16 PokeMini_GetVideo2x2_8P(int filter, int lcdmode)
|
|
{
|
|
if (filter == PokeMini_Scanline) {
|
|
switch (lcdmode) {
|
|
case 3: return PokeMini_VideoColorL2x2_8P;
|
|
case 2: return PokeMini_Video2ScanLine2x2_8P;
|
|
case 1: return PokeMini_Video3ScanLine2x2_8P;
|
|
default: return PokeMini_VideoAScanLine2x2_8P;
|
|
}
|
|
} else if (filter == PokeMini_Matrix) {
|
|
switch (lcdmode) {
|
|
case 3: return PokeMini_VideoColor2x2_8P;
|
|
case 2: return PokeMini_Video2Matrix2x2_8P;
|
|
case 1: return PokeMini_Video3Matrix2x2_8P;
|
|
default: return PokeMini_VideoAMatrix2x2_8P;
|
|
}
|
|
} else {
|
|
switch (lcdmode) {
|
|
case 3: return PokeMini_VideoColor2x2_8P;
|
|
case 2: return PokeMini_Video2None2x2_8P;
|
|
case 1: return PokeMini_Video3None2x2_8P;
|
|
default: return PokeMini_VideoANone2x2_8P;
|
|
}
|
|
}
|
|
}
|
|
|
|
void PokeMini_VideoAScanLine2x2_32(uint32_t *screen, int pitchW)
|
|
{
|
|
int xk, yk, LCDY;
|
|
uint32_t *ptr, pix;
|
|
|
|
LCDY = 0;
|
|
for (yk=0; yk<64; yk++) {
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
pix = VidPalette32[LCDPixelsA[LCDY + xk]];
|
|
*ptr++ = pix; *ptr++ = pix;
|
|
}
|
|
screen += pitchW;
|
|
memset(screen, 0, 192*4);
|
|
screen += pitchW;
|
|
LCDY += 96;
|
|
}
|
|
}
|
|
|
|
void PokeMini_VideoAScanLine2x2_16(uint16_t *screen, int pitchW)
|
|
{
|
|
int xk, yk, LCDY;
|
|
uint16_t *ptr, pix;
|
|
|
|
LCDY = 0;
|
|
for (yk=0; yk<64; yk++) {
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
pix = VidPalette16[LCDPixelsA[LCDY + xk]];
|
|
*ptr++ = pix; *ptr++ = pix;
|
|
}
|
|
screen += pitchW;
|
|
memset(screen, 0, 192*2);
|
|
screen += pitchW;
|
|
LCDY += 96;
|
|
}
|
|
}
|
|
|
|
void PokeMini_VideoAScanLine2x2_8P(uint16_t *screen, int pitchW)
|
|
{
|
|
int xk, yk, LCDY;
|
|
uint16_t *ptr, pix;
|
|
|
|
LCDY = 0;
|
|
for (yk=0; yk<64; yk++) {
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
pix = LCDPixelsA[LCDY + xk];
|
|
*ptr++ = pix | (pix << 8);
|
|
}
|
|
screen += pitchW;
|
|
ptr = screen;
|
|
for (xk=0; xk<(96>>2); xk++) {
|
|
*ptr++ = 0; *ptr++ = 0;
|
|
*ptr++ = 0; *ptr++ = 0;
|
|
}
|
|
screen += pitchW;
|
|
LCDY += 96;
|
|
}
|
|
}
|
|
|
|
void PokeMini_Video3ScanLine2x2_32(uint32_t *screen, int pitchW)
|
|
{
|
|
int xk, yk, LCDY;
|
|
uint32_t *ptr, pix;
|
|
|
|
LCDY = 0;
|
|
for (yk=0; yk<64; yk++) {
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
switch (LCDPixelsD[LCDY + xk] + LCDPixelsA[LCDY + xk]) {
|
|
case 2: pix = VidPalette32[MinxLCD.Pixel1Intensity]; break;
|
|
case 1: pix = VidPalette32[(MinxLCD.Pixel0Intensity + MinxLCD.Pixel1Intensity) >> 1]; break;
|
|
default: pix = VidPalette32[MinxLCD.Pixel0Intensity]; break;
|
|
}
|
|
*ptr++ = pix; *ptr++ = pix;
|
|
}
|
|
screen += pitchW;
|
|
ptr = screen;
|
|
memset(screen, 0, 192*4);
|
|
screen += pitchW;
|
|
LCDY += 96;
|
|
}
|
|
}
|
|
|
|
void PokeMini_Video3ScanLine2x2_16(uint16_t *screen, int pitchW)
|
|
{
|
|
int xk, yk, LCDY;
|
|
uint16_t *ptr, pix;
|
|
|
|
LCDY = 0;
|
|
for (yk=0; yk<64; yk++) {
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
switch (LCDPixelsD[LCDY + xk] + LCDPixelsA[LCDY + xk]) {
|
|
case 2: pix = VidPalette16[MinxLCD.Pixel1Intensity]; break;
|
|
case 1: pix = VidPalette16[(MinxLCD.Pixel0Intensity + MinxLCD.Pixel1Intensity) >> 1]; break;
|
|
default: pix = VidPalette16[MinxLCD.Pixel0Intensity]; break;
|
|
}
|
|
*ptr++ = pix; *ptr++ = pix;
|
|
}
|
|
screen += pitchW;
|
|
ptr = screen;
|
|
memset(screen, 0, 192*2);
|
|
screen += pitchW;
|
|
LCDY += 96;
|
|
}
|
|
}
|
|
|
|
void PokeMini_Video3ScanLine2x2_8P(uint16_t *screen, int pitchW)
|
|
{
|
|
int xk, yk, LCDY;
|
|
uint16_t *ptr, pix;
|
|
|
|
LCDY = 0;
|
|
for (yk=0; yk<64; yk++) {
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
switch (LCDPixelsD[LCDY + xk] + LCDPixelsA[LCDY + xk]) {
|
|
case 2: pix = MinxLCD.Pixel1Intensity; break;
|
|
case 1: pix = (MinxLCD.Pixel0Intensity + MinxLCD.Pixel1Intensity) >> 1; break;
|
|
default: pix = MinxLCD.Pixel0Intensity; break;
|
|
}
|
|
*ptr++ = pix | (pix << 8);
|
|
}
|
|
screen += pitchW;
|
|
ptr = screen;
|
|
for (xk=0; xk<(96>>2); xk++) {
|
|
*ptr++ = 0; *ptr++ = 0;
|
|
*ptr++ = 0; *ptr++ = 0;
|
|
}
|
|
screen += pitchW;
|
|
LCDY += 96;
|
|
}
|
|
}
|
|
|
|
void PokeMini_Video2ScanLine2x2_32(uint32_t *screen, int pitchW)
|
|
{
|
|
int xk, yk, LCDY;
|
|
uint32_t *ptr, pix, pix1, pix0;
|
|
|
|
LCDY = 0;
|
|
pix1 = VidPalette32[MinxLCD.Pixel1Intensity];
|
|
pix0 = VidPalette32[MinxLCD.Pixel0Intensity];
|
|
for (yk=0; yk<64; yk++) {
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
if (LCDPixelsD[LCDY + xk]) pix = pix1;
|
|
else pix = pix0;
|
|
*ptr++ = pix; *ptr++ = pix;
|
|
}
|
|
screen += pitchW;
|
|
ptr = screen;
|
|
memset(screen, 0, 192*4);
|
|
screen += pitchW;
|
|
LCDY += 96;
|
|
}
|
|
}
|
|
|
|
void PokeMini_Video2ScanLine2x2_16(uint16_t *screen, int pitchW)
|
|
{
|
|
int xk, yk, LCDY;
|
|
uint16_t *ptr, pix, pix1, pix0;
|
|
|
|
LCDY = 0;
|
|
pix1 = VidPalette16[MinxLCD.Pixel1Intensity];
|
|
pix0 = VidPalette16[MinxLCD.Pixel0Intensity];
|
|
for (yk=0; yk<64; yk++) {
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
if (LCDPixelsD[LCDY + xk]) pix = pix1;
|
|
else pix = pix0;
|
|
*ptr++ = pix; *ptr++ = pix;
|
|
}
|
|
screen += pitchW;
|
|
ptr = screen;
|
|
memset(screen, 0, 192*2);
|
|
screen += pitchW;
|
|
LCDY += 96;
|
|
}
|
|
}
|
|
|
|
void PokeMini_Video2ScanLine2x2_8P(uint16_t *screen, int pitchW)
|
|
{
|
|
int xk, yk, LCDY;
|
|
uint16_t *ptr, pix;
|
|
|
|
LCDY = 0;
|
|
for (yk=0; yk<64; yk++) {
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
if (LCDPixelsD[LCDY + xk]) pix = MinxLCD.Pixel1Intensity;
|
|
else pix = MinxLCD.Pixel0Intensity;
|
|
*ptr++ = pix | (pix << 8);
|
|
}
|
|
screen += pitchW;
|
|
ptr = screen;
|
|
for (xk=0; xk<(96>>2); xk++) {
|
|
*ptr++ = 0; *ptr++ = 0;
|
|
*ptr++ = 0; *ptr++ = 0;
|
|
}
|
|
screen += pitchW;
|
|
LCDY += 96;
|
|
}
|
|
}
|
|
|
|
void PokeMini_VideoAMatrix2x2_32(uint32_t *screen, int pitchW)
|
|
{
|
|
int xk, yk, level, LCDY, maskH;
|
|
uint32_t *ptr;
|
|
|
|
LCDY = 0;
|
|
maskH = 0;
|
|
for (yk=0; yk<64*2; yk++) {
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
level = LCDPixelsA[LCDY + xk];
|
|
*ptr++ = VidPalette32[level * LCDMask2x2[maskH] >> 8];
|
|
*ptr++ = VidPalette32[level * LCDMask2x2[maskH+1] >> 8];
|
|
}
|
|
screen += pitchW;
|
|
maskH += 2;
|
|
if (maskH >= 4) {
|
|
maskH = 0;
|
|
LCDY += 96;
|
|
}
|
|
}
|
|
}
|
|
|
|
void PokeMini_VideoAMatrix2x2_16(uint16_t *screen, int pitchW)
|
|
{
|
|
int xk, yk, level, LCDY, maskH;
|
|
uint16_t *ptr;
|
|
|
|
LCDY = 0;
|
|
maskH = 0;
|
|
for (yk=0; yk<64*2; yk++) {
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
level = LCDPixelsA[LCDY + xk];
|
|
*ptr++ = VidPalette16[level * LCDMask2x2[maskH] >> 8];
|
|
*ptr++ = VidPalette16[level * LCDMask2x2[maskH+1] >> 8];
|
|
}
|
|
screen += pitchW;
|
|
maskH += 2;
|
|
if (maskH >= 4) {
|
|
maskH = 0;
|
|
LCDY += 96;
|
|
}
|
|
}
|
|
}
|
|
|
|
void PokeMini_VideoAMatrix2x2_8P(uint16_t *screen, int pitchW)
|
|
{
|
|
int xk, yk, level, LCDY, maskH;
|
|
uint16_t *ptr;
|
|
|
|
LCDY = 0;
|
|
maskH = 0;
|
|
for (yk=0; yk<64*2; yk++) {
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
level = LCDPixelsA[LCDY + xk];
|
|
*ptr++ = (level * LCDMask2x2[maskH] >> 8) | ((level * LCDMask2x2[maskH+1]) & 0xFF00);
|
|
}
|
|
screen += pitchW;
|
|
maskH += 2;
|
|
if (maskH >= 4) {
|
|
maskH = 0;
|
|
LCDY += 96;
|
|
}
|
|
}
|
|
}
|
|
|
|
void PokeMini_Video3Matrix2x2_32(uint32_t *screen, int pitchW)
|
|
{
|
|
int xk, yk, level, LCDY, maskH;
|
|
uint32_t *ptr;
|
|
|
|
LCDY = 0;
|
|
maskH = 0;
|
|
for (yk=0; yk<64*2; yk++) {
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
switch (LCDPixelsD[LCDY + xk] + LCDPixelsA[LCDY + xk]) {
|
|
case 2: level = MinxLCD.Pixel1Intensity; break;
|
|
case 1: level = (MinxLCD.Pixel0Intensity + MinxLCD.Pixel1Intensity) >> 1; break;
|
|
default: level = MinxLCD.Pixel0Intensity; break;
|
|
}
|
|
*ptr++ = VidPalette32[level * LCDMask2x2[maskH] >> 8];
|
|
*ptr++ = VidPalette32[level * LCDMask2x2[maskH+1] >> 8];
|
|
}
|
|
screen += pitchW;
|
|
maskH += 2;
|
|
if (maskH >= 4) {
|
|
maskH = 0;
|
|
LCDY += 96;
|
|
}
|
|
}
|
|
}
|
|
|
|
void PokeMini_Video3Matrix2x2_16(uint16_t *screen, int pitchW)
|
|
{
|
|
int xk, yk, level, LCDY, maskH;
|
|
uint16_t *ptr;
|
|
|
|
LCDY = 0;
|
|
maskH = 0;
|
|
for (yk=0; yk<64*2; yk++) {
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
switch (LCDPixelsD[LCDY + xk] + LCDPixelsA[LCDY + xk]) {
|
|
case 2: level = MinxLCD.Pixel1Intensity; break;
|
|
case 1: level = (MinxLCD.Pixel0Intensity + MinxLCD.Pixel1Intensity) >> 1; break;
|
|
default: level = MinxLCD.Pixel0Intensity; break;
|
|
}
|
|
*ptr++ = VidPalette16[level * LCDMask2x2[maskH] >> 8];
|
|
*ptr++ = VidPalette16[level * LCDMask2x2[maskH+1] >> 8];
|
|
}
|
|
screen += pitchW;
|
|
maskH += 2;
|
|
if (maskH >= 4) {
|
|
maskH = 0;
|
|
LCDY += 96;
|
|
}
|
|
}
|
|
}
|
|
|
|
void PokeMini_Video3Matrix2x2_8P(uint16_t *screen, int pitchW)
|
|
{
|
|
int xk, yk, level, LCDY, maskH;
|
|
uint16_t *ptr;
|
|
|
|
LCDY = 0;
|
|
maskH = 0;
|
|
for (yk=0; yk<64*2; yk++) {
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
switch (LCDPixelsD[LCDY + xk] + LCDPixelsA[LCDY + xk]) {
|
|
case 2: level = MinxLCD.Pixel1Intensity; break;
|
|
case 1: level = (MinxLCD.Pixel0Intensity + MinxLCD.Pixel1Intensity) >> 1; break;
|
|
default: level = MinxLCD.Pixel0Intensity; break;
|
|
}
|
|
*ptr++ = (level * LCDMask2x2[maskH] >> 8) | ((level * LCDMask2x2[maskH+1]) & 0xFF00);
|
|
}
|
|
screen += pitchW;
|
|
maskH += 2;
|
|
if (maskH >= 4) {
|
|
maskH = 0;
|
|
LCDY += 96;
|
|
}
|
|
}
|
|
}
|
|
|
|
void PokeMini_Video2Matrix2x2_32(uint32_t *screen, int pitchW)
|
|
{
|
|
int xk, yk, level, LCDY, maskH;
|
|
uint32_t *ptr;
|
|
|
|
LCDY = 0;
|
|
maskH = 0;
|
|
for (yk=0; yk<64*2; yk++) {
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
if (LCDPixelsD[LCDY + xk]) level = MinxLCD.Pixel1Intensity;
|
|
else level = MinxLCD.Pixel0Intensity;
|
|
*ptr++ = VidPalette32[level * LCDMask2x2[maskH] >> 8];
|
|
*ptr++ = VidPalette32[level * LCDMask2x2[maskH+1] >> 8];
|
|
}
|
|
screen += pitchW;
|
|
maskH += 2;
|
|
if (maskH >= 4) {
|
|
maskH = 0;
|
|
LCDY += 96;
|
|
}
|
|
}
|
|
}
|
|
|
|
void PokeMini_Video2Matrix2x2_16(uint16_t *screen, int pitchW)
|
|
{
|
|
int xk, yk, level, LCDY, maskH;
|
|
uint16_t *ptr;
|
|
|
|
LCDY = 0;
|
|
maskH = 0;
|
|
for (yk=0; yk<64*2; yk++) {
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
if (LCDPixelsD[LCDY + xk]) level = MinxLCD.Pixel1Intensity;
|
|
else level = MinxLCD.Pixel0Intensity;
|
|
*ptr++ = VidPalette16[level * LCDMask2x2[maskH] >> 8];
|
|
*ptr++ = VidPalette16[level * LCDMask2x2[maskH+1] >> 8];
|
|
}
|
|
screen += pitchW;
|
|
maskH += 2;
|
|
if (maskH >= 4) {
|
|
maskH = 0;
|
|
LCDY += 96;
|
|
}
|
|
}
|
|
}
|
|
|
|
void PokeMini_Video2Matrix2x2_8P(uint16_t *screen, int pitchW)
|
|
{
|
|
int xk, yk, level, LCDY, maskH;
|
|
uint16_t *ptr;
|
|
|
|
LCDY = 0;
|
|
maskH = 0;
|
|
for (yk=0; yk<64*2; yk++) {
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
if (LCDPixelsD[LCDY + xk]) level = MinxLCD.Pixel1Intensity;
|
|
else level = MinxLCD.Pixel0Intensity;
|
|
*ptr++ = (level * LCDMask2x2[maskH] >> 8) | ((level * LCDMask2x2[maskH+1]) & 0xFF00);
|
|
}
|
|
screen += pitchW;
|
|
maskH += 2;
|
|
if (maskH >= 4) {
|
|
maskH = 0;
|
|
LCDY += 96;
|
|
}
|
|
}
|
|
}
|
|
|
|
void PokeMini_VideoANone2x2_32(uint32_t *screen, int pitchW)
|
|
{
|
|
int xk, yk, LCDY;
|
|
uint32_t *ptr, pix;
|
|
|
|
LCDY = 0;
|
|
for (yk=0; yk<64; yk++) {
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
pix = VidPalette32[LCDPixelsA[LCDY + xk]];
|
|
*ptr++ = pix; *ptr++ = pix;
|
|
}
|
|
screen += pitchW;
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
pix = VidPalette32[LCDPixelsA[LCDY + xk]];
|
|
*ptr++ = pix; *ptr++ = pix;
|
|
}
|
|
screen += pitchW;
|
|
LCDY += 96;
|
|
}
|
|
}
|
|
|
|
void PokeMini_VideoANone2x2_16(uint16_t *screen, int pitchW)
|
|
{
|
|
int xk, yk, LCDY;
|
|
uint16_t *ptr, pix;
|
|
|
|
LCDY = 0;
|
|
for (yk=0; yk<64; yk++) {
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
pix = VidPalette16[LCDPixelsA[LCDY + xk]];
|
|
*ptr++ = pix; *ptr++ = pix;
|
|
}
|
|
screen += pitchW;
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
pix = VidPalette16[LCDPixelsA[LCDY + xk]];
|
|
*ptr++ = pix; *ptr++ = pix;
|
|
}
|
|
screen += pitchW;
|
|
LCDY += 96;
|
|
}
|
|
}
|
|
|
|
void PokeMini_VideoANone2x2_8P(uint16_t *screen, int pitchW)
|
|
{
|
|
int xk, yk, LCDY;
|
|
uint16_t *ptr, pix;
|
|
|
|
LCDY = 0;
|
|
for (yk=0; yk<64; yk++) {
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
pix = LCDPixelsA[LCDY + xk];
|
|
*ptr++ = pix | (pix << 8);
|
|
}
|
|
screen += pitchW;
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
pix = LCDPixelsA[LCDY + xk];
|
|
*ptr++ = pix | (pix << 8);
|
|
}
|
|
screen += pitchW;
|
|
LCDY += 96;
|
|
}
|
|
}
|
|
|
|
void PokeMini_Video3None2x2_32(uint32_t *screen, int pitchW)
|
|
{
|
|
int xk, yk, LCDY;
|
|
uint32_t *ptr, pix;
|
|
|
|
LCDY = 0;
|
|
for (yk=0; yk<64; yk++) {
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
switch (LCDPixelsD[LCDY + xk] + LCDPixelsA[LCDY + xk]) {
|
|
case 2: pix = VidPalette32[MinxLCD.Pixel1Intensity]; break;
|
|
case 1: pix = VidPalette32[(MinxLCD.Pixel0Intensity + MinxLCD.Pixel1Intensity) >> 1]; break;
|
|
default: pix = VidPalette32[MinxLCD.Pixel0Intensity]; break;
|
|
}
|
|
*ptr++ = pix; *ptr++ = pix;
|
|
}
|
|
screen += pitchW;
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
switch (LCDPixelsD[LCDY + xk] + LCDPixelsA[LCDY + xk]) {
|
|
case 2: pix = VidPalette32[MinxLCD.Pixel1Intensity]; break;
|
|
case 1: pix = VidPalette32[(MinxLCD.Pixel0Intensity + MinxLCD.Pixel1Intensity) >> 1]; break;
|
|
default: pix = VidPalette32[MinxLCD.Pixel0Intensity]; break;
|
|
}
|
|
*ptr++ = pix; *ptr++ = pix;
|
|
}
|
|
screen += pitchW;
|
|
LCDY += 96;
|
|
}
|
|
}
|
|
|
|
void PokeMini_Video3None2x2_16(uint16_t *screen, int pitchW)
|
|
{
|
|
int xk, yk, LCDY;
|
|
uint16_t *ptr, pix;
|
|
|
|
LCDY = 0;
|
|
for (yk=0; yk<64; yk++) {
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
switch (LCDPixelsD[LCDY + xk] + LCDPixelsA[LCDY + xk]) {
|
|
case 2: pix = VidPalette16[MinxLCD.Pixel1Intensity]; break;
|
|
case 1: pix = VidPalette16[(MinxLCD.Pixel0Intensity + MinxLCD.Pixel1Intensity) >> 1]; break;
|
|
default: pix = VidPalette16[MinxLCD.Pixel0Intensity]; break;
|
|
}
|
|
*ptr++ = pix; *ptr++ = pix;
|
|
}
|
|
screen += pitchW;
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
switch (LCDPixelsD[LCDY + xk] + LCDPixelsA[LCDY + xk]) {
|
|
case 2: pix = VidPalette16[MinxLCD.Pixel1Intensity]; break;
|
|
case 1: pix = VidPalette16[(MinxLCD.Pixel0Intensity + MinxLCD.Pixel1Intensity) >> 1]; break;
|
|
default: pix = VidPalette16[MinxLCD.Pixel0Intensity]; break;
|
|
}
|
|
*ptr++ = pix; *ptr++ = pix;
|
|
}
|
|
screen += pitchW;
|
|
LCDY += 96;
|
|
}
|
|
}
|
|
|
|
void PokeMini_Video3None2x2_8P(uint16_t *screen, int pitchW)
|
|
{
|
|
int xk, yk, LCDY;
|
|
uint16_t *ptr, pix;
|
|
|
|
LCDY = 0;
|
|
for (yk=0; yk<64; yk++) {
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
switch (LCDPixelsD[LCDY + xk] + LCDPixelsA[LCDY + xk]) {
|
|
case 2: pix = MinxLCD.Pixel1Intensity; break;
|
|
case 1: pix = (MinxLCD.Pixel0Intensity + MinxLCD.Pixel1Intensity) >> 1; break;
|
|
default: pix = MinxLCD.Pixel0Intensity; break;
|
|
}
|
|
*ptr++ = pix | (pix << 8);
|
|
}
|
|
screen += pitchW;
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
switch (LCDPixelsD[LCDY + xk] + LCDPixelsA[LCDY + xk]) {
|
|
case 2: pix = MinxLCD.Pixel1Intensity; break;
|
|
case 1: pix = (MinxLCD.Pixel0Intensity + MinxLCD.Pixel1Intensity) >> 1; break;
|
|
default: pix = MinxLCD.Pixel0Intensity; break;
|
|
}
|
|
*ptr++ = pix | (pix << 8);
|
|
}
|
|
screen += pitchW;
|
|
LCDY += 96;
|
|
}
|
|
}
|
|
|
|
void PokeMini_Video2None2x2_32(uint32_t *screen, int pitchW)
|
|
{
|
|
int xk, yk, LCDY;
|
|
uint32_t *ptr, pix, pix1, pix0;
|
|
|
|
LCDY = 0;
|
|
pix1 = VidPalette32[MinxLCD.Pixel1Intensity];
|
|
pix0 = VidPalette32[MinxLCD.Pixel0Intensity];
|
|
for (yk=0; yk<64; yk++) {
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
if (LCDPixelsD[LCDY + xk]) pix = pix1;
|
|
else pix = pix0;
|
|
*ptr++ = pix; *ptr++ = pix;
|
|
}
|
|
screen += pitchW;
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
if (LCDPixelsD[LCDY + xk]) pix = pix1;
|
|
else pix = pix0;
|
|
*ptr++ = pix; *ptr++ = pix;
|
|
}
|
|
screen += pitchW;
|
|
LCDY += 96;
|
|
}
|
|
}
|
|
|
|
void PokeMini_Video2None2x2_16(uint16_t *screen, int pitchW)
|
|
{
|
|
int xk, yk, LCDY;
|
|
uint16_t *ptr, pix, pix1, pix0;
|
|
|
|
LCDY = 0;
|
|
pix1 = VidPalette16[MinxLCD.Pixel1Intensity];
|
|
pix0 = VidPalette16[MinxLCD.Pixel0Intensity];
|
|
for (yk=0; yk<64; yk++) {
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
if (LCDPixelsD[LCDY + xk]) pix = pix1;
|
|
else pix = pix0;
|
|
*ptr++ = pix; *ptr++ = pix;
|
|
}
|
|
screen += pitchW;
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
if (LCDPixelsD[LCDY + xk]) pix = pix1;
|
|
else pix = pix0;
|
|
*ptr++ = pix; *ptr++ = pix;
|
|
}
|
|
screen += pitchW;
|
|
LCDY += 96;
|
|
}
|
|
}
|
|
|
|
void PokeMini_Video2None2x2_8P(uint16_t *screen, int pitchW)
|
|
{
|
|
int xk, yk, LCDY;
|
|
uint16_t *ptr, pix;
|
|
|
|
LCDY = 0;
|
|
for (yk=0; yk<64; yk++) {
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
if (LCDPixelsD[LCDY + xk]) pix = MinxLCD.Pixel1Intensity;
|
|
else pix = MinxLCD.Pixel0Intensity;
|
|
*ptr++ = pix | (pix << 8);
|
|
}
|
|
screen += pitchW;
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
if (LCDPixelsD[LCDY + xk]) pix = MinxLCD.Pixel1Intensity;
|
|
else pix = MinxLCD.Pixel0Intensity;
|
|
*ptr++ = pix | (pix << 8);
|
|
}
|
|
screen += pitchW;
|
|
LCDY += 96;
|
|
}
|
|
}
|
|
|
|
void PokeMini_VideoColor2x2_32(uint32_t *screen, int pitchW)
|
|
{
|
|
int xk, yk, LCDY;
|
|
uint32_t *ptr, pix;
|
|
|
|
LCDY = 0;
|
|
for (yk=0; yk<64; yk++) {
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
pix = VidPalColor32[PRCColorPixels[LCDY + xk]];
|
|
*ptr++ = pix; *ptr++ = pix;
|
|
}
|
|
screen += pitchW;
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
pix = VidPalColor32[PRCColorPixels[LCDY + xk]];
|
|
*ptr++ = pix; *ptr++ = pix;
|
|
}
|
|
screen += pitchW;
|
|
LCDY += 96;
|
|
}
|
|
}
|
|
|
|
void PokeMini_VideoColor2x2_16(uint16_t *screen, int pitchW)
|
|
{
|
|
int xk, yk, LCDY;
|
|
uint16_t *ptr, pix;
|
|
|
|
LCDY = 0;
|
|
for (yk=0; yk<64; yk++) {
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
pix = VidPalColor16[PRCColorPixels[LCDY + xk]];
|
|
*ptr++ = pix; *ptr++ = pix;
|
|
}
|
|
screen += pitchW;
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
pix = VidPalColor16[PRCColorPixels[LCDY + xk]];
|
|
*ptr++ = pix; *ptr++ = pix;
|
|
}
|
|
screen += pitchW;
|
|
LCDY += 96;
|
|
}
|
|
}
|
|
|
|
// WARNING! Color palette should be in CRAM!
|
|
void PokeMini_VideoColor2x2_8P(uint16_t *screen, int pitchW)
|
|
{
|
|
int xk, yk, LCDY;
|
|
uint16_t *ptr, pix;
|
|
|
|
LCDY = 0;
|
|
for (yk=0; yk<64; yk++) {
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
pix = PRCColorPixels[LCDY + xk];
|
|
*ptr++ = pix | (pix << 8);
|
|
}
|
|
screen += pitchW;
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
pix = PRCColorPixels[LCDY + xk];
|
|
*ptr++ = pix | (pix << 8);
|
|
}
|
|
screen += pitchW;
|
|
LCDY += 96;
|
|
}
|
|
}
|
|
|
|
void PokeMini_VideoColorL2x2_32(uint32_t *screen, int pitchW)
|
|
{
|
|
int xk, yk, LCDY;
|
|
uint32_t *ptr, pix;
|
|
|
|
LCDY = 0;
|
|
for (yk=0; yk<64; yk++) {
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
pix = VidPalColor32[PRCColorPixels[LCDY + xk]];
|
|
*ptr++ = pix; *ptr++ = pix;
|
|
}
|
|
screen += pitchW;
|
|
ptr = screen;
|
|
for (xk=0; xk<(96>>2); xk++) {
|
|
*ptr++ = 0; *ptr++ = 0;
|
|
*ptr++ = 0; *ptr++ = 0;
|
|
}
|
|
screen += pitchW;
|
|
LCDY += 96;
|
|
}
|
|
}
|
|
|
|
void PokeMini_VideoColorL2x2_16(uint16_t *screen, int pitchW)
|
|
{
|
|
int xk, yk, LCDY;
|
|
uint16_t *ptr, pix;
|
|
|
|
LCDY = 0;
|
|
for (yk=0; yk<64; yk++) {
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
pix = VidPalColor16[PRCColorPixels[LCDY + xk]];
|
|
*ptr++ = pix; *ptr++ = pix;
|
|
}
|
|
screen += pitchW;
|
|
ptr = screen;
|
|
for (xk=0; xk<(96>>2); xk++) {
|
|
*ptr++ = 0; *ptr++ = 0;
|
|
*ptr++ = 0; *ptr++ = 0;
|
|
}
|
|
screen += pitchW;
|
|
LCDY += 96;
|
|
}
|
|
}
|
|
|
|
// WARNING! Color palette should be in CRAM!
|
|
void PokeMini_VideoColorL2x2_8P(uint16_t *screen, int pitchW)
|
|
{
|
|
int xk, yk, LCDY;
|
|
uint16_t *ptr, pix;
|
|
|
|
LCDY = 0;
|
|
for (yk=0; yk<64; yk++) {
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
pix = PRCColorPixels[LCDY + xk];
|
|
*ptr++ = pix | (pix << 8);
|
|
}
|
|
screen += pitchW;
|
|
ptr = screen;
|
|
for (xk=0; xk<(96>>2); xk++) {
|
|
*ptr++ = 0; *ptr++ = 0;
|
|
*ptr++ = 0; *ptr++ = 0;
|
|
}
|
|
screen += pitchW;
|
|
LCDY += 96;
|
|
}
|
|
}
|
|
|
|
void PokeMini_VideoColorH2x2_32(uint32_t *screen, int pitchW)
|
|
{
|
|
int xk, yk, LCDY;
|
|
uint32_t *ptr, pix;
|
|
|
|
LCDY = 0;
|
|
for (yk=0; yk<64; yk++) {
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
pix = VidPalColorH32[PRCColorPixels[LCDY + xk] * 256 + PRCColorPixelsOld[LCDY + xk]];
|
|
*ptr++ = pix; *ptr++ = pix;
|
|
}
|
|
screen += pitchW;
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
pix = VidPalColorH32[PRCColorPixels[LCDY + xk] * 256 + PRCColorPixelsOld[LCDY + xk]];
|
|
*ptr++ = pix; *ptr++ = pix;
|
|
}
|
|
screen += pitchW;
|
|
LCDY += 96;
|
|
}
|
|
}
|
|
|
|
void PokeMini_VideoColorH2x2_16(uint16_t *screen, int pitchW)
|
|
{
|
|
int xk, yk, LCDY;
|
|
uint16_t *ptr, pix;
|
|
|
|
LCDY = 0;
|
|
for (yk=0; yk<64; yk++) {
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
pix = VidPalColorH16[PRCColorPixels[LCDY + xk] * 256 + PRCColorPixelsOld[LCDY + xk]];
|
|
*ptr++ = pix; *ptr++ = pix;
|
|
}
|
|
screen += pitchW;
|
|
ptr = screen;
|
|
for (xk=0; xk<96; xk++) {
|
|
pix = VidPalColorH16[PRCColorPixels[LCDY + xk] * 256 + PRCColorPixelsOld[LCDY + xk]];
|
|
*ptr++ = pix; *ptr++ = pix;
|
|
}
|
|
screen += pitchW;
|
|
LCDY += 96;
|
|
}
|
|
}
|