mirror of
https://github.com/dborth/vbagx.git
synced 2024-12-01 15:04:17 +01:00
588 lines
20 KiB
C++
588 lines
20 KiB
C++
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <assert.h>
|
|
|
|
#include "../System.h"
|
|
#include "../NLS.h"
|
|
#include "gb.h"
|
|
#include "gbCheats.h"
|
|
#include "gbGlobals.h"
|
|
#include "vba.h"
|
|
#include "../ngc/menu.h"
|
|
#include "../ngc/fastmath.h"
|
|
|
|
#define CARLLOG
|
|
|
|
bool ColorizeGameboy = true;
|
|
|
|
// The 14-colour palette for a monochrome gameboy game
|
|
// bg black, bg dark, bg light, bg white, window black, window dark, window light, window white,
|
|
// obj0 dark, obj0 light, obj0 white, obj1 dark, obj1 light, obj1 white
|
|
// Only the user sets these colours from emulator menu, and it is only read
|
|
// by the palette setting functions.
|
|
u16 systemMonoPalette[14];
|
|
|
|
// quickly map the 12 possible indices to 15-bit colours
|
|
// bg index 0..3, obj0 index 0..3, obj1 index 0..3
|
|
// This is set internally by the palette setting functions, and used by the
|
|
// drawing functions.
|
|
//u16 gbPalette[12];
|
|
|
|
static bool HadBgPal = false, HadObj0Pal = false, HadObj1Pal = false;
|
|
|
|
|
|
const float BL[4] = {0.1f, 0.4f, 0.7f, 1.0f};
|
|
|
|
// Averages colour with white
|
|
// factor is from 0 to 1. 0 = no extra whiteness, 1 = 100% whiteness
|
|
u16 changeColourWhiteness(u16 rgb, float factor) {
|
|
if (factor==0.0f) return rgb;
|
|
int f1factor = (0x1f*factor);
|
|
int factorm1 = 1-factor;
|
|
int r = (rgb & 0x1f);
|
|
r = (r * factorm1)+ f1factor;
|
|
if (r>31) {
|
|
r=31;
|
|
}
|
|
int g = ((rgb >> 5) & 0x1f);
|
|
g = (g * factorm1)+f1factor;
|
|
if (g>31) {
|
|
g=31;
|
|
}
|
|
int b = ((rgb >> 10) & 0x1f);
|
|
b = (b * factorm1)+f1factor;
|
|
if (b>31) {
|
|
b=31;
|
|
}
|
|
return r | (g << 5) | (b << 10);
|
|
}
|
|
|
|
// Brightens or darkens a colour
|
|
// factor is a multiple of normal brightness
|
|
u16 changeColourBrightness(u16 rgb, float factor) {
|
|
if (factor==1.0f) return rgb;
|
|
int bonus = 0;
|
|
int r = int(float(rgb & 0x1f) * factor);
|
|
if (r>31) {
|
|
r=31;
|
|
bonus+= (1 >> 1);
|
|
}
|
|
int g = int(float((rgb >> 5) & 0x1f) * factor);
|
|
|
|
if (g>31) {
|
|
g=31;
|
|
bonus+=(1 >> 1);
|
|
}
|
|
int b = int(float((rgb >> 10) & 0x1f) * factor);
|
|
|
|
if (b>31) {
|
|
b=31;
|
|
bonus += (1 >> 1);
|
|
}
|
|
r += bonus;
|
|
g += bonus;
|
|
b += bonus;
|
|
if (r>31) r=31;
|
|
if (g>31) g=31;
|
|
if (b>31) b=31;
|
|
return r | (g << 5) | (b << 10);
|
|
}
|
|
|
|
u8 oldBgp = 0xFC;
|
|
|
|
// Sets the brightnesses of both the background and window palettes
|
|
void gbSetBGPalette(u8 value, bool ColoursChanged=false) {
|
|
static u8 DarkestToBrightestIndex[4] = {3, 2, 1, 0};
|
|
static u8 Darkness[4] = {0, 1, 2, 3};
|
|
static float BrightnessForBrightest=1, BrightnessForDarkest=0.1; // brightness of palette when indexes are right
|
|
|
|
// darkness of each index (0 = white, 3 = black)
|
|
gbBgp[0] = value & 0x03;
|
|
gbBgp[1] = (value & 0x0c)>>2;
|
|
gbBgp[2] = (value & 0x30)>>4;
|
|
gbBgp[3] = (value & 0xc0)>>6;
|
|
// Don't mess with the palette unless we have a Mono gameboy and either the colours changed
|
|
// or the brightness palette changed.
|
|
if ((value==oldBgp && !ColoursChanged) || gbCgbMode || gbSgbMode || !ColorizeGameboy) return;
|
|
bool dup = false;
|
|
int dupDarkness = -1;
|
|
if (value!=oldBgp) {
|
|
#ifdef CARLLOG
|
|
const char DN[5] = "3210";
|
|
log("Bg Pal: %c %c %c %c", DN[gbObp0[0]], DN[gbObp0[1]], DN[gbObp0[2]], DN[gbObp0[3]]);
|
|
#endif
|
|
// check for duplicates
|
|
for (unsigned i=0; i<=2u; ++i)
|
|
for (unsigned j=i+1; j<=3u; ++j)
|
|
if (gbBgp[i]==gbBgp[j]) {
|
|
dup=true;
|
|
dupDarkness = gbBgp[i];
|
|
break;
|
|
}
|
|
// We haven't had a full palette yet, so guess...
|
|
if (dup && !HadBgPal) {
|
|
if (gbBgp[0]>gbBgp[3]) {
|
|
DarkestToBrightestIndex[0] = 0;
|
|
DarkestToBrightestIndex[1] = 1;
|
|
DarkestToBrightestIndex[2] = 2;
|
|
DarkestToBrightestIndex[3] = 3;
|
|
|
|
Darkness[0] = gbBgp[0];
|
|
Darkness[1] = gbBgp[1];
|
|
Darkness[2] = gbBgp[2];
|
|
Darkness[3] = gbBgp[3];
|
|
} else {
|
|
DarkestToBrightestIndex[0] = 3;
|
|
DarkestToBrightestIndex[1] = 2;
|
|
DarkestToBrightestIndex[2] = 1;
|
|
DarkestToBrightestIndex[3] = 0;
|
|
|
|
Darkness[0] = gbBgp[3];
|
|
Darkness[1] = gbBgp[2];
|
|
Darkness[2] = gbBgp[1];
|
|
Darkness[3] = gbBgp[0];
|
|
}
|
|
// brightness of brightest colour
|
|
BrightnessForBrightest = BL[3-gbBgp[DarkestToBrightestIndex[3]]];
|
|
BrightnessForDarkest = BL[3-gbBgp[DarkestToBrightestIndex[0]]];
|
|
} else if (!dup) { // no duplicates, therefore a complete palette change
|
|
HadBgPal = true;
|
|
// now we need to map them from darkest to brightest
|
|
int Colour = 0;
|
|
for (int darkness = 3; darkness>=0; --darkness) {
|
|
for (int index=0; index<=3; ++index) {
|
|
if (gbBgp[index]==darkness) {
|
|
DarkestToBrightestIndex[Colour]=index;
|
|
Darkness[Colour]=gbBgp[index];
|
|
++Colour;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
// brightness of brightest colour
|
|
BrightnessForBrightest = BL[3-gbBgp[DarkestToBrightestIndex[3]]];
|
|
BrightnessForDarkest = BL[3-gbBgp[DarkestToBrightestIndex[0]]];
|
|
} else { // duplicates implies fading in or out
|
|
// since we are really trying to fade, not change palette,
|
|
// rely on previous DarkestToBrightest list
|
|
}
|
|
}
|
|
float NewBrightnessForBrightest = BL[3-gbBgp[DarkestToBrightestIndex[3]]];
|
|
float BrightnessFactor;
|
|
float WhitenessFactor = 0;
|
|
// check if they are trying to make the palette whiter
|
|
if (dupDarkness==0) {
|
|
// Multiple colours set to white
|
|
BrightnessFactor = 0;
|
|
WhitenessFactor += BL[3-gbBgp[0]]
|
|
+ BL[3-gbBgp[1]]
|
|
+ BL[3-gbBgp[2]]
|
|
+ BL[3-gbBgp[3]]
|
|
- BL[3] - BL[2] - BL[1]- BL[0];
|
|
|
|
float MaxWhiteness = BL[3] + BL[3] + BL[3] + BL[3]
|
|
-BL[3] -BL[2] -BL[1] -BL[0];
|
|
|
|
WhitenessFactor /= (MaxWhiteness+0.4f);
|
|
// check if they are trying to make the palette brighter
|
|
} else if (NewBrightnessForBrightest==1.0f && BrightnessForBrightest==1.0f) {
|
|
float NewBrightnessForDarkest = BL[3-gbBgp[DarkestToBrightestIndex[0]]];
|
|
BrightnessFactor = NewBrightnessForDarkest/BrightnessForDarkest;
|
|
|
|
// Perhaps they are trying to make the palette darker
|
|
} else {
|
|
BrightnessFactor = NewBrightnessForBrightest/BrightnessForBrightest;
|
|
}
|
|
if (WhitenessFactor) {
|
|
// BG colours
|
|
for (int colour = 0; colour <= 3; ++colour) {
|
|
u16 colourRGB = systemMonoPalette[colour];
|
|
float colourBrightness = BL[colour];
|
|
float indexBrightness = BL[3-Darkness[colour]];
|
|
colourRGB = changeColourBrightness(colourRGB, indexBrightness/colourBrightness);
|
|
gbPalette[0+DarkestToBrightestIndex[colour]] = changeColourWhiteness(colourRGB, WhitenessFactor);
|
|
}
|
|
// Window colours
|
|
for (int colour = 0; colour <= 3; ++colour) {
|
|
u16 colourRGB = systemMonoPalette[4+colour];
|
|
float colourBrightness = BL[colour];
|
|
float indexBrightness = BL[3-Darkness[colour]];
|
|
colourRGB = changeColourBrightness(colourRGB, indexBrightness/colourBrightness);
|
|
gbPalette[4+DarkestToBrightestIndex[colour]] = changeColourWhiteness(colourRGB, WhitenessFactor);
|
|
}
|
|
} else {
|
|
// BG colours
|
|
for (int colour = 0; colour <= 3; ++colour) {
|
|
u16 colourRGB = systemMonoPalette[colour];
|
|
float colourBrightness = BL[colour];
|
|
float indexBrightness = BL[3-Darkness[colour]]*BrightnessFactor;
|
|
gbPalette[0+DarkestToBrightestIndex[colour]] = changeColourBrightness(colourRGB, indexBrightness/colourBrightness);
|
|
}
|
|
// Window colours
|
|
for (int colour = 0; colour <= 3; ++colour) {
|
|
u16 colourRGB = systemMonoPalette[4+colour];
|
|
float colourBrightness = BL[colour];
|
|
float indexBrightness = BL[3-Darkness[colour]]*BrightnessFactor;
|
|
gbPalette[4+DarkestToBrightestIndex[colour]] = changeColourBrightness(colourRGB, indexBrightness/colourBrightness);
|
|
}
|
|
}
|
|
}
|
|
|
|
u8 oldObp0 = 0xFF;
|
|
|
|
void gbSetObj0Palette(u8 value, bool ColoursChanged = false) {
|
|
static u8 DarkestToBrightestIndex[3] = {3, 2, 1};
|
|
static u8 Darkness[3] = {1, 2, 3};
|
|
static float BrightnessForBrightest, BrightnessForDarkest; // brightness of palette when indexes are right
|
|
|
|
// darkness of each index (0 = white, 3 = black)
|
|
gbObp0[0] = value & 0x03;
|
|
gbObp0[1] = (value & 0x0c)>>2;
|
|
gbObp0[2] = (value & 0x30)>>4;
|
|
gbObp0[3] = (value & 0xc0)>>6;
|
|
|
|
// Don't mess with the palette unless we have a Mono gameboy and either the colours changed
|
|
// or the brightness palette changed.
|
|
if ((value==oldObp0 && !ColoursChanged) || gbCgbMode || gbSgbMode || !ColorizeGameboy) return;
|
|
bool dup = false;
|
|
int dupDarkness = -1;
|
|
if (value!=oldObp0) {
|
|
#ifdef CARLLOG
|
|
const char DN[5] = "3210";
|
|
log("Obj0 Pal: %c %c %c", DN[gbObp0[1]], DN[gbObp0[2]], DN[gbObp0[3]]);
|
|
#endif
|
|
// check for duplicates
|
|
for (int i=1; i<=2; i++)
|
|
for (int j=i+1; j<=3; j++)
|
|
if (gbObp0[i]==gbObp0[j]) {
|
|
dup=true;
|
|
dupDarkness = gbObp0[i];
|
|
break;
|
|
}
|
|
// We haven't had a full palette yet, so guess...
|
|
if (dup && !HadObj1Pal) {
|
|
if (gbObp0[1]>gbObp0[3]) {
|
|
DarkestToBrightestIndex[0] = 1;
|
|
DarkestToBrightestIndex[1] = 2;
|
|
DarkestToBrightestIndex[2] = 3;
|
|
Darkness[0] = gbObp0[1];
|
|
Darkness[1] = gbObp0[2];
|
|
Darkness[2] = gbObp0[3];
|
|
|
|
} else {
|
|
DarkestToBrightestIndex[0] = 3;
|
|
DarkestToBrightestIndex[1] = 2;
|
|
DarkestToBrightestIndex[2] = 1;
|
|
Darkness[0] = gbObp0[3];
|
|
Darkness[1] = gbObp0[2];
|
|
Darkness[2] = gbObp0[1];
|
|
}
|
|
// brightness of brightest colour
|
|
BrightnessForBrightest = BL[3-gbObp0[DarkestToBrightestIndex[2]]];
|
|
BrightnessForDarkest = BL[3-gbObp0[DarkestToBrightestIndex[0]]];
|
|
} else if (!dup) { // no duplicates, therefore a complete brightness palette change
|
|
HadObj0Pal = true;
|
|
// now we need to map them from darkest to brightest
|
|
int Colour = 0;
|
|
for (int darkness = 3; darkness>=0; --darkness) {
|
|
for (int index=1; index<=3; index++) {
|
|
if (gbObp0[index]==darkness) {
|
|
DarkestToBrightestIndex[Colour]=index;
|
|
Darkness[Colour]=gbObp0[index];
|
|
++Colour;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
// brightness of brightest colour
|
|
BrightnessForBrightest = BL[3-gbObp0[DarkestToBrightestIndex[2]]];
|
|
BrightnessForDarkest = BL[3-gbObp0[DarkestToBrightestIndex[0]]];
|
|
} else { // duplicates implies fading in or out
|
|
// since we are really trying to fade, not change palette,
|
|
// rely on previous DarkestToBrightest list
|
|
}
|
|
}
|
|
float NewBrightnessForBrightest = BL[3-gbObp0[DarkestToBrightestIndex[2]]];
|
|
float BrightnessFactor;
|
|
float WhitenessFactor = 0;
|
|
// check if they are trying to make the palette whiter
|
|
if (dupDarkness==0) {
|
|
// Multiple colours set to white
|
|
BrightnessFactor = 0;
|
|
WhitenessFactor+= BL[3-gbObp0[1]]
|
|
+ BL[3-gbObp0[2]]
|
|
+ BL[3-gbObp0[3]]
|
|
-BL[3] -BL[2] -BL[1];
|
|
|
|
float MaxWhiteness = BL[3] + BL[3] + BL[3]
|
|
- BL[3] - BL[2] - BL[1];
|
|
|
|
|
|
WhitenessFactor /= (MaxWhiteness+0.3f);
|
|
// check if they are trying to make the palette brighter
|
|
} else if (NewBrightnessForBrightest==1.0f && BrightnessForBrightest==1.0f) {
|
|
float NewBrightnessForDarkest = BL[3-gbObp0[DarkestToBrightestIndex[0]]];
|
|
BrightnessFactor = NewBrightnessForDarkest/BrightnessForDarkest;
|
|
} else {
|
|
BrightnessFactor = NewBrightnessForBrightest/BrightnessForBrightest;
|
|
}
|
|
|
|
if (WhitenessFactor) {
|
|
for (int colour = 0; colour <= 2; colour++) {
|
|
u16 colourRGB = systemMonoPalette[colour+8];
|
|
float colourBrightness = BL[colour+1];
|
|
float indexBrightness = BL[3-Darkness[colour]];
|
|
colourRGB = changeColourBrightness(colourRGB, indexBrightness/colourBrightness);
|
|
gbPalette[8+DarkestToBrightestIndex[colour]] = changeColourWhiteness(colourRGB, WhitenessFactor);
|
|
}
|
|
} else {
|
|
for (int colour = 0; colour <= 2; colour++) {
|
|
u16 colourRGB = systemMonoPalette[colour+8];
|
|
float colourBrightness = BL[colour+1];
|
|
float indexBrightness = BL[3-Darkness[colour]]*BrightnessFactor;
|
|
gbPalette[8+DarkestToBrightestIndex[colour]] = changeColourBrightness(colourRGB, indexBrightness/colourBrightness);
|
|
}
|
|
}
|
|
gbPalette[8] = 0; // always transparent
|
|
}
|
|
|
|
u8 oldObp1 = 0xFF;
|
|
|
|
void gbSetObj1Palette(u8 value, bool ColoursChanged = false) {
|
|
static u8 DarkestToBrightestIndex[3] = {3, 2, 1};
|
|
static u8 Darkness[3] = {1, 2, 3};
|
|
static float BrightnessForBrightest, BrightnessForDarkest; // brightness of palette when indexes are right
|
|
|
|
// darkness of each index (0 = white, 3 = black)
|
|
gbObp1[0] = value & 0x03;
|
|
gbObp1[1] = (value & 0x0c)>>2;
|
|
gbObp1[2] = (value & 0x30)>>4;
|
|
gbObp1[3] = (value & 0xc0)>>6;
|
|
// Don't mess with the palette unless we have a Mono gameboy and either the colours changed
|
|
// or the brightness palette changed.
|
|
if ((value==oldObp1 && !ColoursChanged) || gbCgbMode || gbSgbMode || !ColorizeGameboy) return;
|
|
bool dup = false;
|
|
int dupDarkness = -1;
|
|
if (value!=oldObp1) {
|
|
#ifdef CARLLOG
|
|
const char DN[5] = "3210";
|
|
log("Obj1 Pal: %c %c %c", DN[gbObp1[1]], DN[gbObp1[2]], DN[gbObp1[3]]);
|
|
#endif
|
|
// check for duplicates
|
|
for (int i=1; i<=2; i++)
|
|
for (int j=i+1; j<=3; j++)
|
|
if (gbObp1[i]==gbObp1[j]) {
|
|
dup=true;
|
|
dupDarkness=gbObp1[i];
|
|
break;
|
|
}
|
|
// We haven't had a full palette yet, so guess...
|
|
if (dup && !HadObj1Pal) {
|
|
if (gbObp0[1]>gbObp0[3]) {
|
|
DarkestToBrightestIndex[0] = 1;
|
|
DarkestToBrightestIndex[1] = 2;
|
|
DarkestToBrightestIndex[2] = 3;
|
|
Darkness[0] = gbObp0[1];
|
|
Darkness[1] = gbObp0[2];
|
|
Darkness[2] = gbObp0[3];
|
|
} else {
|
|
DarkestToBrightestIndex[0] = 3;
|
|
DarkestToBrightestIndex[1] = 2;
|
|
DarkestToBrightestIndex[2] = 1;
|
|
Darkness[0] = gbObp0[3];
|
|
Darkness[1] = gbObp0[2];
|
|
Darkness[2] = gbObp0[1];
|
|
|
|
}
|
|
// brightness of brightest colour
|
|
BrightnessForBrightest = BL[3-gbObp1[DarkestToBrightestIndex[2]]];
|
|
BrightnessForDarkest = BL[3-gbObp1[DarkestToBrightestIndex[0]]];
|
|
} else if (!dup) { // no duplicates, therefore a complete palette change
|
|
HadObj1Pal = true;
|
|
// now we need to map them from darkest to brightest
|
|
int Colour = 0;
|
|
for (int darkness = 3; darkness>=0; darkness--) {
|
|
for (int index=1; index<=3; index++) {
|
|
if (gbObp1[index]==darkness) {
|
|
DarkestToBrightestIndex[Colour]=index;
|
|
Darkness[Colour]=gbObp1[index];
|
|
Colour++;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
// brightness of brightest colour
|
|
BrightnessForBrightest = BL[3-gbObp1[DarkestToBrightestIndex[2]]];
|
|
BrightnessForDarkest = BL[3-gbObp1[DarkestToBrightestIndex[0]]];
|
|
} else { // duplicates implies fading in or out
|
|
// since we are really trying to fade, not change palette,
|
|
// rely on previous DarkestToBrightest list
|
|
}
|
|
}
|
|
float NewBrightnessForBrightest = BL[3-gbObp1[DarkestToBrightestIndex[2]]];
|
|
float BrightnessFactor;
|
|
float WhitenessFactor = 0;
|
|
// check if they are trying to make the palette whiter
|
|
if (dupDarkness==0) {
|
|
// Multiple colours set to white
|
|
BrightnessFactor = 0;
|
|
WhitenessFactor+= BL[3-gbObp1[1]]
|
|
+ BL[3-gbObp1[2]]
|
|
+ BL[3-gbObp1[3]]
|
|
-BL[3] -BL[2] -BL[1];
|
|
|
|
float MaxWhiteness = BL[3] + BL[3] + BL[3]
|
|
- BL[3] - BL[2] - BL[1];
|
|
WhitenessFactor /= (MaxWhiteness+0.3f);
|
|
// check if they are trying to make the palette brighter
|
|
} else if (NewBrightnessForBrightest==1.0f && BrightnessForBrightest==1.0f) {
|
|
float NewBrightnessForDarkest = BL[3-gbObp1[DarkestToBrightestIndex[0]]];
|
|
BrightnessFactor = NewBrightnessForDarkest/BrightnessForDarkest;
|
|
} else {
|
|
BrightnessFactor = NewBrightnessForBrightest/BrightnessForBrightest;
|
|
}
|
|
|
|
if (WhitenessFactor) {
|
|
for (int colour = 0; colour <= 2; colour++) {
|
|
u16 colourRGB = systemMonoPalette[colour+11];
|
|
float colourBrightness = BL[colour+1];
|
|
float indexBrightness = BL[3-Darkness[colour]];
|
|
colourRGB = changeColourBrightness(colourRGB, indexBrightness/colourBrightness);
|
|
gbPalette[12+DarkestToBrightestIndex[colour]] = changeColourWhiteness(colourRGB, WhitenessFactor);
|
|
}
|
|
} else {
|
|
for (int colour = 0; colour <= 2; colour++) {
|
|
u16 colourRGB = systemMonoPalette[colour+11];
|
|
float colourBrightness = BL[colour+1];
|
|
float indexBrightness = BL[3-Darkness[colour]]*BrightnessFactor;
|
|
gbPalette[12+DarkestToBrightestIndex[colour]] = changeColourBrightness(colourRGB, indexBrightness/colourBrightness);
|
|
}
|
|
}
|
|
gbPalette[12] = 0; // always transparent
|
|
}
|
|
|
|
bool StartColorizing() {
|
|
if ((!GCSettings.colorize) || gbSgbMode || gbCgbMode) return false;
|
|
if (ColorizeGameboy) return true;
|
|
ColorizeGameboy = true;
|
|
gbSetBGPalette(oldBgp);
|
|
gbSetObj0Palette(oldObp0);
|
|
gbSetObj1Palette(oldObp1);
|
|
return true;
|
|
}
|
|
|
|
void StopColorizing() {
|
|
if(!ColorizeGameboy || gbSgbMode || gbCgbMode) return;
|
|
|
|
int gbpo12 = gbPaletteOption*12;
|
|
for(int i = 0; i < 12; i+=4){
|
|
gbPalette[i] = systemGbPalette[gbpo12+i];
|
|
gbPalette[i+1] = systemGbPalette[gbpo12+i+1];
|
|
gbPalette[i+2] = systemGbPalette[gbpo12+i+2];
|
|
gbPalette[i+3] = systemGbPalette[gbpo12+i+3];
|
|
}
|
|
ColorizeGameboy = false;
|
|
}
|
|
|
|
// convert 0xRRGGBB to our 15 bit format
|
|
u16 Make15Bit(u32 rgb) {
|
|
return ((rgb >> 19) & 0x1F) | (((rgb >> 11) & 0x1F) << 5) | (((rgb >> 3) & 0x1F) << 10);
|
|
}
|
|
|
|
u32 OldObpBright[2]={0}, OldObpMedium[2]={0}, OldObpDark[2]={0};
|
|
|
|
void gbSetSpritePal(u8 WhichPal, u32 bright, u32 medium, u32 dark) {
|
|
if (!StartColorizing()) return;
|
|
// cancel if we already set to these colours
|
|
if (WhichPal>0) {
|
|
int p = WhichPal-1;
|
|
if(((OldObpBright[p] - bright) | (OldObpMedium[p] - medium) | (OldObpDark[p] - dark)) == 0){
|
|
return;
|
|
}
|
|
}
|
|
int index = 0;
|
|
// check if we are setting both sprite palettes at once
|
|
if (WhichPal==0) {
|
|
gbSetSpritePal(1, bright, medium, dark);
|
|
gbSetSpritePal(2, bright, medium, dark);
|
|
return;
|
|
} else if (WhichPal==1) index = 8; // Obj0
|
|
else if (WhichPal==2) index=11; // Obj1
|
|
// save colours as 15 bit
|
|
systemMonoPalette[index]=Make15Bit(dark);
|
|
systemMonoPalette[index+1]=Make15Bit(medium);
|
|
systemMonoPalette[index+2]=Make15Bit(bright);
|
|
// change the brightness palette
|
|
if (WhichPal==1) {
|
|
u8 old = oldObp0;
|
|
oldObp0 +=1;
|
|
gbSetObj0Palette(old);
|
|
} else if (WhichPal==2) {
|
|
u8 old = oldObp1;
|
|
oldObp1 +=1;
|
|
gbSetObj1Palette(old);
|
|
}
|
|
}
|
|
|
|
void gbSetSpritePal(u8 WhichPal, u32 bright) {
|
|
u8 r = (bright >> 16) & 0xFF;
|
|
u8 g = (bright >> 8) & 0xFF;
|
|
u8 b = (bright >> 0) & 0xFF;
|
|
u32 medium = (((u32)(r*0.7f)) << 16) | (((u32)(g*0.7f)) << 8) | (((u32)(b*0.7f)) << 0);
|
|
u32 dark = (((u32)(r*0.4f)) << 16) | (((u32)(g*0.4f)) << 8) | (((u32)(b*0.4f)) << 0);
|
|
gbSetSpritePal(WhichPal, bright, medium, dark);
|
|
}
|
|
|
|
u32 OldBgBright=0, OldBgMedium=0, OldBgDark=0, OldBgBlack=0;
|
|
|
|
void gbSetBgPal(u8 WhichPal, u32 bright, u32 medium, u32 dark, u32 black=0x000000) {
|
|
if (!StartColorizing()) return;
|
|
if (OldBgBright==bright && OldBgMedium==medium && OldBgDark==dark && OldBgBlack==black)
|
|
return;
|
|
int index = 0;
|
|
if (WhichPal==0) {
|
|
gbSetBgPal(1, bright, medium, dark, black);
|
|
gbSetBgPal(2, bright, medium, dark, black);
|
|
return;
|
|
} else if (WhichPal==1) index = 0; // background
|
|
else if (WhichPal==2) index=4; // window
|
|
systemMonoPalette[index]=Make15Bit(black);
|
|
systemMonoPalette[index+1]=Make15Bit(dark);
|
|
systemMonoPalette[index+2]=Make15Bit(medium);
|
|
systemMonoPalette[index+3]=Make15Bit(bright);
|
|
gbSetBGPalette(oldBgp, true);
|
|
OldBgBright = bright;
|
|
OldBgMedium = medium;
|
|
OldBgDark = dark;
|
|
OldBgBlack = black;
|
|
}
|
|
|
|
void gbSetBgPal(u8 WhichPal, u32 bright) {
|
|
u8 r = (bright >> 16) & 0xFF;
|
|
u8 g = (bright >> 8) & 0xFF;
|
|
u8 b = (bright >> 0) & 0xFF;
|
|
u32 medium = ((ftou((utof(r)*0.7f))) << 16) | ((ftou((utof(g)*0.7f))) << 8) | ((ftou((utof(b)*0.7f))) << 0);
|
|
u32 dark = ((ftou((utof(r)*0.4f))) << 16) | ((ftou((utof(g)*0.4f))) << 8) | ((ftou((utof(b)*0.4f))) << 0);
|
|
u32 black = ((ftou((utof(r)*0.1f))) << 16) | ((ftou((utof(g)*0.1f))) << 8) | ((ftou((utof(b)*0.1f))) << 0);
|
|
gbSetBgPal(WhichPal, bright, medium, dark, black);
|
|
}
|
|
|
|
// Set the whole 14-colour palette
|
|
void gbSetPalette(u32 RRGGBB[]) {
|
|
gbSetBgPal(1, RRGGBB[0], RRGGBB[1], RRGGBB[2], RRGGBB[3]);
|
|
gbSetBgPal(2, RRGGBB[4], RRGGBB[5], RRGGBB[6], RRGGBB[7]);
|
|
gbSetSpritePal(1, RRGGBB[8], RRGGBB[9], RRGGBB[10]);
|
|
gbSetSpritePal(2, RRGGBB[11], RRGGBB[12], RRGGBB[13]);
|
|
}
|
|
|
|
void gbPaletteReset() {
|
|
HadBgPal = HadObj0Pal = HadObj1Pal = false;
|
|
oldBgp = 0xFC;
|
|
oldObp0 = oldObp1 = 0xFF;
|
|
OldBgBright=0; OldBgMedium=0; OldBgDark=0; OldBgBlack=0;
|
|
OldObpBright[0]= OldObpBright[1]=
|
|
OldObpMedium[0]= OldObpMedium[1]=
|
|
OldObpDark[0]= OldObpDark[1] =0;
|
|
}
|