void onInit()
{
setBrightness(3, -16);
videoSetMode(MODE_5_2D);
videoSetModeSub(MODE_0_2D);
vramSetBankA(VRAM_A_MAIN_BG);
vramSetBankC(VRAM_C_SUB_BG);
int bg3 = bgInit(3, BgType_Bmp8, BgSize_B8_256x256, 0, 0);
dmaCopy(splashBitmap, bgGetGfxPtr(bg3), 256*256);
dmaCopy(splashPal, BG_PALETTE, 256*2);
for(int i = 0; i < 128; i++)
{
setBrightness(3, -16+(i/8));
swiWaitForVBlank();
}
for(int i = 0; i < 128; i++)
{
setBrightness(3, -(i/8));
swiWaitForVBlank();
}
}
void Display::slidersUpdate(){
bool change = false;
if (Cfg::sliders.bank != Cfg::sliders.previousBank){
sliders();
Cfg::sliders.previousBank = Cfg::sliders.bank;
change = true;
}
CCParam* sliderCC;
for (u8 s = 0; s < 16; ++s){
sliderCC = &Cfg::sliders.ccs[Cfg::sliders.bank][s];
if (Cfg::ccChangedVblank[(*sliderCC).channel][(*sliderCC).cc]){
updateSliderUpMap(s);
change = true;
}
}
DC_FlushAll();
dmaCopy(this->slidersBg2Map, bgGetMapPtr(subbg2), 1536);
if (change){
DC_FlushAll();
dmaCopy(this->slidersBg3Map, bgGetMapPtr(subbg3), 1536);
}
showBank(Cfg::sliders.bank, 3);
}
static int
NDS_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
const SDL_Rect * rect, const void *pixels, int pitch)
{
NDS_TextureData *txdat;
Uint8 *src, *dst;
int row;
size_t length;
txdat = (NDS_TextureData *) texture->driverdata;
src = (Uint8 *) pixels;
dst =
(Uint8 *) txdat->vram_pixels + rect->y * txdat->pitch + rect->x *
((txdat->bpp + 1) / 8);
length = rect->w * ((txdat->bpp + 1) / 8);
if (rect->w == texture->w) {
dmaCopy(src, dst, length * rect->h);
} else {
for (row = 0; row < rect->h; ++row) {
dmaCopy(src, dst, length);
src += pitch;
dst += txdat->pitch;
}
}
return 0;
}
void gbaFrame(void)
{
u16* frame=NULL;
cBMP15 frameBMP=createBMP15FromFile("/GBA/gbaframe.bmp");
if(frameBMP.valid()&&frameBMP.width()==SCREEN_WIDTH&&frameBMP.height()==SCREEN_HEIGHT)
{
frame=(u16*)malloc(SCREEN_WIDTH*SCREEN_HEIGHT*2);
memcpy(frame,frameBMP.buffer(),SCREEN_WIDTH*SCREEN_HEIGHT*2); //tricky thing
}
videoSetMode(MODE_5_2D | DISPLAY_BG3_ACTIVE);
videoSetModeSub(MODE_5_2D | DISPLAY_BG3_ACTIVE);
vramSetMainBanks(VRAM_A_MAIN_BG_0x06000000, VRAM_B_MAIN_BG_0x06020000, VRAM_C_SUB_BG_0x06200000, VRAM_D_LCD);
// for the main screen
BG3_CR = BG_BMP16_256x256 | BG_BMP_BASE(0) | BG_WRAP_OFF;
BG3_XDX = 1 << 8; //scale x
BG3_XDY = 0; //rotation x
BG3_YDX = 0; //rotation y
BG3_YDY = 1 << 8; //scale y
BG3_CX = 0; //translation x
BG3_CY = 0; //translation y
if(frame)
{
dmaCopy(frame,(void*)BG_BMP_RAM(0),SCREEN_WIDTH*SCREEN_HEIGHT*2);
dmaCopy(frame,(void*)BG_BMP_RAM(8),SCREEN_WIDTH*SCREEN_HEIGHT*2);
free(frame);
}
else
{
memset((void*)BG_BMP_RAM(0),0,0x18000);
memset((void*)BG_BMP_RAM(8),0,0x18000);
}
}
//Update all of the objects to be displayed before next redraw
void menu_main_update(void)
{
//we should probably make sure that we draw everything next refresh
int i;
for (i = 0; i < sizeof(BUTTON) * NUM_BUTTONS; i += sizeof(BUTTON))
{
if (menu_buttons[i]->state == BTN_UP)
{
//iprintf("%i\n", i);
u8 *map_offset = menu_buttons[i]->frame_gfx;
dmaCopy(map_offset, menu_buttons[i]->sprite_gfx_mem, menu_buttons[i]->w * menu_buttons[i]->h);
}
else
{
//iprintf("%i\n", i);
u8 *map_offset = menu_buttons[i]->frame_gfx + menu_buttons[i]->w * menu_buttons[i]->h;
dmaCopy(map_offset, menu_buttons[i]->sprite_gfx_mem, menu_buttons[i]->w * menu_buttons[i]->h);
}
}
//TODO: maybe other things?
}
void Display::modeSelektor(){
//Displaying bg3, and mode sprites
bgSetPriority(this->subbg3, 1);
DC_FlushAll();
dmaCopy(greyedBgSubTiles, bgGetGfxPtr(this->subbg3), greyedBgSubTilesLen);
dmaCopy(greyedBgSubMap, bgGetMapPtr(this->subbg3), greyedBgSubMapLen);
bgShow(subbg3);
s8 i;
for (i = 0; i < 4; ++i){
modesSprite->display(64 + i, 32 + 128 * (i % 2), 16 + 96 * (i / 2), OBJPRIORITY_0, i);
}
oamUpdate(&oamSub);
input->paused = true;
while(!(Cfg::modeSelector && input->pad->select() == DOWN) && input->modeSelektor() != 1){
swiWaitForVBlank();
}
Cfg::modeSelector = false;
oamClear(&oamSub, 64, 4);
if (Cfg::mode == SLIDERS){
dmaCopy(slidersBg3SubTiles, bgGetGfxPtr(this->subbg3), slidersBg3SubTilesLen);
dmaCopy(this->slidersBg3Map, bgGetMapPtr(this->subbg3), 1536);
} else {
bgSetPriority(this->subbg3, 2);
bgHide(this->subbg3);
}
}
void DSGM_LoadSpriteFull(u8 screen, DSGM_Sprite *sprite) {
int i;
switch(screen) {
case DSGM_TOP:
//sprite->topTiles = DSGM_TrackedAlloc((void **)&sprite->topTiles, sizeof(u16 *) * sprite->frames);
sprite->topTiles = malloc(sizeof(u16 *) * sprite->frames);
for(i = 0; i < sprite->frames; i++) {
sprite->topTiles[i] = oamAllocateGfx(&oamMain, sprite->size, SpriteColorFormat_256Color);
if(DSGM_SpriteIsNitro(sprite)) {
DSGM_ReadFileManual(sprite->topTiles[i], i * (DSGM_GetSpriteWidth(sprite) * DSGM_GetSpriteHeight(sprite)), DSGM_GetSpriteWidth(sprite) * DSGM_GetSpriteHeight(sprite)/*32 * 32*//*DSGM_AUTO_LENGTH*/, sprite->nitroFilename);
}
else {
dmaCopy(sprite->tiles + (i * DSGM_GetSpriteWidth(sprite) * DSGM_GetSpriteHeight(sprite)), sprite->topTiles[i], *sprite->tilesLength);
}
}
break;
case DSGM_BOTTOM:
//sprite->bottomTiles = DSGM_TrackedAlloc((void **)&sprite->bottomTiles, sizeof(u16 *) * sprite->frames);
sprite->bottomTiles = malloc(sizeof(u16 *) * sprite->frames);
for(i = 0; i < sprite->frames; i++) {
sprite->bottomTiles[i] = oamAllocateGfx(&oamSub, sprite->size, SpriteColorFormat_256Color);
if(DSGM_SpriteIsNitro(sprite)) {
DSGM_ReadFileManual(sprite->bottomTiles[i], i * (DSGM_GetSpriteWidth(sprite) * DSGM_GetSpriteHeight(sprite)), DSGM_GetSpriteWidth(sprite) * DSGM_GetSpriteHeight(sprite)/*DSGM_AUTO_LENGTH*/, sprite->nitroFilename);
}
else {
dmaCopy(sprite->tiles + (i * DSGM_GetSpriteWidth(sprite) * DSGM_GetSpriteHeight(sprite)), sprite->bottomTiles[i], *sprite->tilesLength);
}
}
break;
}
}
void CGbaLoader::LoadBorder(void)
{
videoSetMode(MODE_5_2D | DISPLAY_BG3_ACTIVE);
videoSetModeSub(MODE_5_2D | DISPLAY_BG3_ACTIVE);
vramSetMainBanks(VRAM_A_MAIN_BG_0x06000000, VRAM_B_MAIN_BG_0x06020000, VRAM_C_SUB_BG_0x06200000, VRAM_D_LCD);
// for the main screen
REG_BG3CNT = BG_BMP16_256x256 | BG_BMP_BASE(0) | BG_WRAP_OFF;
REG_BG3PA = 1 << 8; //scale x
REG_BG3PB = 0; //rotation x
REG_BG3PC = 0; //rotation y
REG_BG3PD = 1 << 8; //scale y
REG_BG3X = 0; //translation x
REG_BG3Y = 0; //translation y
memset((void*)BG_BMP_RAM(0),0,0x18000);
memset((void*)BG_BMP_RAM(8),0,0x18000);
cBMP15 frameBMP=createBMP15FromFile(SFN_GBAFRAME);
if(frameBMP.valid()&&frameBMP.width()==SCREEN_WIDTH&&frameBMP.height()==SCREEN_HEIGHT)
{
DC_FlushRange(frameBMP.buffer(),SCREEN_WIDTH*SCREEN_HEIGHT*2);
dmaCopy(frameBMP.buffer(),(void*)BG_BMP_RAM(0),SCREEN_WIDTH*SCREEN_HEIGHT*2);
dmaCopy(frameBMP.buffer(),(void*)BG_BMP_RAM(8),SCREEN_WIDTH*SCREEN_HEIGHT*2);
}
}
static pj_bool_t topbar_update_battery(void)
{
static pj_uint16_t bat = 0x7fff, aux = 0x7fff;
if(bat == IPC->battery && aux == IPC->aux)
return PJ_FALSE;
bat = IPC->battery;
aux = IPC->aux;
if(bat == 0 && aux == 0) // Chargé
{
dmaCopy(battery->icons, battery->icon,
battery->size * battery->size * 2);
}
else if(bat == 0 && aux != 0) // En charge
{
dmaCopy(battery->icons + 5 * battery->size * battery->size, battery->icon,
battery->size * battery->size * 2);
}
else // Charger
{
dmaCopy(battery->icons + battery->size * battery->size, battery->icon,
battery->size * battery->size * 2);
}
return PJ_TRUE;
}
void internal_load_sprite_sheet()
{
u16* pal = (u16*)background_bin;
int pal_size = 256 * sizeof(u16);
u8* sprites = (u8*)(background_bin + pal_size);
dmaCopy(pal, BG_COLORS, pal_size);
dmaCopy(sprites, (u32*)VRAM, 12 * 8 * 8 + 2 * 32 * 64) ;
}
void sprites_load_sprite_sheet()
{
u16* pal = (u16*)sprites_bin;
int pal_size = 256 * sizeof(u16);
u8* sprites = (u8*)(sprites_bin + pal_size);
dmaCopy(pal, SPRITE_PALETTE, pal_size);
dmaCopy(sprites, SPRITE_GFX, 12 * 16 * 16);
}
void gameFrame(void)
{
int lala;
switch(currentBuffer)
{
case false:
#ifdef DEBUG_GAME
iprintf("\x1b[0;0H");
iprintf("%d FPS \n", FPS);
iprintf("%d (debug) \n", debugVal);
iprintf("%d (free ram) \n", getMemFree()/1024);
iprintf("%p (portal) \n", portal1.displayList);
iprintf("%p (portal) \n", portal2.displayList);
#endif
cpuEndSlice();
postProcess1();
// iprintf("postproc : %d \n",cpuEndSlice());
render1();
// if(keysDown()&KEY_SELECT)testStepByStep^=1; //TEMP
#ifdef DEBUG_GAME
iprintf("full : %d (%d) \n",cpuEndTiming(),testStepByStep);
#endif
swiWaitForVBlank();
cpuStartTiming(0);
prevTiming=0;
if(previousPortal)dmaCopy(VRAM_C, previousPortal->viewPoint, 256*192*2);
setRegCapture(true, 0, 15, 2, 0, 3, 1, 0);
frmCNT++;
break;
case true:
// cpuStartTiming(0);
postProcess2();
// iprintf("frm 2 : %d \n",cpuGetTiming());
render2();
listenPI9();
updateOBBs();
// iprintf("frm 2 : %d \n",cpuEndTiming());
#ifdef DEBUG_GAME
iprintf("fake frame : %d \n",cpuEndTiming());
#endif
swiWaitForVBlank();
cpuStartTiming(0);
prevTiming=0;
dmaCopy(VRAM_C, mainScreen, 256*192*2);
setRegCapture(true, 0, 15, 2, 0, 3, 1, 0);
break;
}
// if(testStepByStep){int i=0;while(!(keysUp()&KEY_TOUCH)){scanKeys();listenPI9();swiWaitForVBlank();}NOGBA("WAITED");scanKeys();scanKeys();if(keysHeld()&KEY_SELECT)testStepByStep=false;}
// else if(keysDown()&KEY_SELECT)testStepByStep=true;
currentBuffer^=1;
}
void init() {
initMemory();
//Init backgrounds
// Main 3D
init3DSettings();
// Main Map:
mapEngine = new MapEngine(1, 4, 1);
// Main Console:
consoleInit(&main_console,3,BgType_ExRotation, BgSize_ER_256x256, 31, 0, true, false);
bg3 = main_console.bgId;
bgSetCenter(bg3, 254, 0);
bgSetRotate(bg3, -8192);
// Sub Console:
consoleInit(&sub_console,3,BgType_ExRotation, BgSize_ER_256x256, 31, 1, false, false);
bg3Sub = sub_console.bgId;
bgSetCenter(bg3Sub, 254, 0);
bgSetRotate(bg3Sub, -8192);
// Sub Image:
bg2Sub = bgInitSub(2, BgType_Bmp8, BgSize_B8_256x256, 4,0);
dmaCopy(leftmenuBitmap, bgGetGfxPtr(bg2Sub), 256*192);
dmaCopy(leftmenuPal, BG_PALETTE_SUB, leftmenuPalLen);
// Init Sprites
oamInit(&oamMain, SpriteMapping_1D_128, false);
// Set the priorities
bgSetPriority(0,1);
bgSetPriority(1,2);
bgSetPriority(2,3);
bgSetPriority(3,0);
bgSetPriority(bg3Sub, 2);
bgSetPriority(bg2Sub, 3);
//Init font
font.gfx = (u16*)fontTiles;
font.pal = (u16*)fontPal;
font.numChars = 95;
font.numColors = fontPalLen / 2;
font.bpp = 8;
font.asciiOffset = 32;
font.convertSingleColor = false;
consoleSetFont(&main_console, &font);
consoleSetFont(&sub_console, &font);
consoleSelect(&main_console);
iprintf("\x1b[2J");
iprintf("Arkham Tower v0.01");
consoleSelect(&sub_console);
iprintf("\x1b[2J");
}
void advMultipleLayers(void)
{
videoSetMode(MODE_5_2D);
vramSetBankA(VRAM_A_MAIN_BG);
//initialize the backgrounds
int bg1 = bgInit(0, BgType_Text8bpp, BgSize_ER_256x256, 0,1);
int bg2 = bgInit(1, BgType_Text8bpp, BgSize_ER_256x256, 1,1);
int bg3 = bgInit(2, BgType_ExRotation, BgSize_ER_256x256, 2,1);
//make sure the floor is on the bottom (by default hardware layer 0 will be rendered last)
bgSetPriority(bg1, 3);
bgSetPriority(bg2, 2);
bgSetPriority(bg3, 1);
//they all share tiles and a palette
dmaCopy(MultilayerTiles, bgGetGfxPtr(bg1), sizeof(MultilayerTiles));
dmaCopy(MultilayerPal, BG_PALETTE, sizeof(MultilayerPal));
//all we need to do is copy in the maps
dmaCopy(Layer_1Map, bgGetMapPtr(bg1), Layer_1MapLen);
dmaCopy(Layer_2Map, bgGetMapPtr(bg2), Layer_2MapLen);
dmaCopy(Layer_3Map, bgGetMapPtr(bg3), Layer_3MapLen);
int keys = 0;
bool bg1_hidden = false;
bool bg2_hidden = false;
bool bg3_hidden = false;
while(!(keys & KEY_B))
{
scanKeys();
keys = keysDown();
if(keys & KEY_UP) bg1_hidden = !bg1_hidden;
if(keys & KEY_DOWN) bg2_hidden = !bg2_hidden;
if(keys & KEY_LEFT) bg3_hidden = !bg3_hidden;
swiWaitForVBlank();
bg1_hidden ? bgHide(bg1) : bgShow(bg1);
bg2_hidden ? bgHide(bg2) : bgShow(bg2);
bg3_hidden ? bgHide(bg3) : bgShow(bg3);
consoleClear();
iprintf("Press UP DOWN LEFT to toggle the layers\n\n");
iprintf("Floor (UP): %s\n", bg1_hidden ? "hidden" : "displayed");
iprintf("Walls (DOWN): %s\n", bg2_hidden ? "hidden" : "displayed");
iprintf("Decorations (LEFT): %s\n", bg3_hidden ? "hidden" : "displayed");
}
}
void advRotating(void)
{
videoSetMode(MODE_5_2D);
vramSetBankA(VRAM_A_MAIN_BG);
int bg = bgInit(3, BgType_ExRotation, BgSize_ER_256x256, 0,1);
dmaCopy(TextBackgroundsTiles, bgGetGfxPtr(bg), sizeof(TextBackgroundsTiles));
dmaCopy(TextBackgroundsPal, BG_PALETTE, sizeof(TextBackgroundsPal));
dmaCopy(Layer256x256Map, bgGetMapPtr(bg), Layer256x256MapLen);
bgMosaicEnable(bg);
int keys = 0;
int angle = 0;
int center_x = 0;
int center_y = 0;
while(!(keys & KEY_B))
{
scanKeys();
keys = keysHeld();
if(keys & KEY_UP) center_y--;
if(keys & KEY_DOWN) center_y++;
if(keys & KEY_LEFT) center_x--;
if(keys & KEY_RIGHT) center_x++;
if(keys & KEY_L) angle-=40;
if(keys & KEY_R) angle+=40;
if(center_x > 256) center_x = 256;
if(center_x < 0) center_x = 0;
if(center_y > 192) center_y = 192;
if(center_y < 0) center_y = 0;
swiWaitForVBlank();
bgSetRotate(bg, angle);
bgSetScroll(bg, center_x, center_y);
bgSetCenter(bg, center_x, center_y);
bgUpdate();
consoleClear();
iprintf("Press B to exit.n");
iprintf("Angle: %d \ncenter X: %d center Y: %d", angleToDegrees(angle), center_x, center_y);
}
}
Bar::Bar(coord pos, u16* gfxSource, int palIdx) :
AffineSprite(true, pos, 0, palIdx, SpriteSize_64x32, SpriteColorFormat_16Color, false, false, false, false, 1, true/*allocGfx*/, true, true),
value(0),
initX(pos.first)
{
char * bottomBar = 64+((char*) gfxSource);
for(int n = 0; n < 8; ++n)
{
dmaCopy(gfxSource, (n*32)+((char*)(gfxPtr[0])), 32);
dmaCopy(bottomBar, 256+(n*32)+((char*)(gfxPtr[0])), 32);
}
dmaFillWords(0,512+((char*)(gfxPtr[0])),1024);
}
// MIXER Functions
//-------------------------------------------------------------------------
void Display::mixer(){
clearGfx();
DC_FlushAll();
dmaCopy(mixerBgSubTiles, bgGetGfxPtr(subbg2), mixerBgSubTilesLen);
dmaCopy(mixerBgSubMap, bgGetMapPtr(subbg2), mixerBgSubMapLen);
for (u8 i = 0; i < 8; ++i)
muteSprite->display(i, i*32 , 163, 1, 1);
bgHide(mainbg3);
save->writeCcs();
}
void blu_impl::GFX_LDSprite(bluSprite* bsp){
if(bsp->init == 0){
u16* gfx;
oamInit(&oamMain, bsp->sm, false);
gfx = oamAllocateGfx(&oamMain, bsp->sz, bsp->sfmt);
bsp->gfx = gfx;
bsp->init = 1;
}
dmaCopy(bsp->tiles, bsp->gfx, bsp->tlen);
dmaCopy(bsp->pal, SPRITE_PALETTE, bsp->plen);
}
void Display::editKaossParams(){
CCParam* ccParam = NULL;
bgSetPriority(this->subbg3, 1);
DC_FlushAll();
dmaCopy(greyedBgSubTiles, bgGetGfxPtr(this->subbg3), greyedBgSubTilesLen);
dmaCopy(greyedBgSubMap, bgGetMapPtr(this->subbg3), greyedBgSubMapLen);
bgShow(this->subbg3);
while(!(Cfg::editParams && input->pad->start() == DOWN)){
for (u8 i = 0; i<3; ++i){
if (i == 0){
echo(0, RED, 5, 7 + 8*(i%8), "X");
ccParam = &Cfg::kaoss.x[Cfg::kaoss.bank];
}
if (i == 1){
echo(0, RED, 5, 7 + 8*(i%8), "Y");
ccParam = &Cfg::kaoss.y[Cfg::kaoss.bank];
}
if (i == 2){
echo(0, RED, 5, 7 + 8*(i%8), "Z");
ccParam = &Cfg::kaoss.z[Cfg::kaoss.bank];
}
echo(0, WHITE, 8, 7 + 8*(i%8), "CC");
paramsEditSprite->display(16+i, 56 + 64*(i%8), 72, OBJPRIORITY_0, 0);
iprintf("\x1b[%d;%dH%3d", 10, 6 + 8*(i%8), (*ccParam).cc);
paramsEditSprite->display(32+i, 56 + 64*(i%8), 88, OBJPRIORITY_0, 1);
echo(0, WHITE, 13, 7 + 8*(i%8), "CH");
paramsEditSprite->display(48+i, 56 + 64*(i%8), 112, OBJPRIORITY_0, 0);
iprintf("\x1b[%d;%dH%3d", 15, 6 + 8*(i%8), 1 + (*ccParam).channel);
paramsEditSprite->display(64+i, 56 + 64*(i%8), 128, OBJPRIORITY_0, 1);
}
oamUpdate(&oamSub);
input->editKaossParams();
Cfg::editParams = true;
swiWaitForVBlank();
}
Cfg::editParams = false;
save->write();
oamClear(&oamSub, 16, 80);
consoleClear();
if (Cfg::mode == SLIDERS){
dmaCopy(slidersBg3SubTiles, bgGetGfxPtr(this->subbg3), slidersBg3SubTilesLen);
dmaCopy(slidersBg3Map, bgGetMapPtr(this->subbg3), 1536);
} else {
bgSetPriority(this->subbg3, 2);
bgHide(this->subbg3);
}
}
static int NDS_UpdateWindowFramebuffer(_THIS, SDL_Window * window,
SDL_Rect * rects, int numrects)
{
struct NDS_WindowData *wdata = window->driverdata;
/* Copy everything. TODO: use rects/numrects. */
DC_FlushRange(wdata->pixels, wdata->pixels_length);
swiWaitForVBlank();
dmaCopy(wdata->main.pixels, wdata->main.vram_pixels, wdata->main.length);
dmaCopy(wdata->sub.pixels, wdata->sub.vram_pixels, wdata->sub.length);
return 0;
}
void TextButton::init_vram( const void* source, u16*& vram_dest )
{
vram_dest = oamAllocateGfx( this->get_oam(), this->sprite_size, SpriteColorFormat_Bmp );
DC_FlushRange( source, SPRITE_SIZE_PIXELS(this->sprite_size)*2 );
dmaCopy( source, vram_dest, SPRITE_SIZE_PIXELS(this->sprite_size)*2 );
set_16bpp_sprite_opague( vram_dest, SPRITE_SIZE_PIXELS(this->sprite_size)*2 );
}
// KAOSS Functions
//-------------------------------------------------------------------------
void Display::kaoss(){
u16 i;
clearGfx();
dmaCopy(kaossBgSubTiles, bgGetGfxPtr(subbg2), kaossBgSubTilesLen);
dmaCopy(kaossBgSubMap, bgGetMapPtr(subbg2), kaossBgSubMapLen);
for (i = 0; i < 64; ++i)
setKaossSpriteFrame(i, 0);
bgHide(mainbg3);
echo(1, LIGHT_GREY, 1, 2, "BANK:");
save->writeCcs();
}
// Loading a sprite
Sprite::Sprite(u8 screen, const unsigned int* tiles, u8 palette, SpriteSize spriteSize, u8 frames){
u16 memorySize = 0;
switch(spriteSize){
case SpriteSize_8x8 : memorySize = 64;
break;
case SpriteSize_8x16 :
case SpriteSize_16x8 : memorySize = 128;
break;
case SpriteSize_32x8 :
case SpriteSize_8x32 :
case SpriteSize_16x16: memorySize = 256;
break;
case SpriteSize_32x16:
case SpriteSize_16x32: memorySize = 512;
break;
case SpriteSize_32x32: memorySize = 1024;
break;
case SpriteSize_64x32:
case SpriteSize_32x64: memorySize = 2048;
break;
case SpriteSize_64x64: memorySize = 4096;
break;
}
oam = (screen == 1 ? &oamMain : &oamSub);
palNumber = palette;
this->frames = frames;
gfxMem = new u16*[frames];
this->spriteSize = spriteSize;
for (u8 i = 0; i < frames; ++i){
gfxMem[i] = oamAllocateGfx(oam, spriteSize, SpriteColorFormat_256Color);
dmaCopy((u8*)tiles + (i * memorySize), gfxMem[i], memorySize);
}
}
void I_FinishUpdate (void)
{
int h = 200;
int w = 320;
int step = 512;
unsigned char *srcmain = screens[0].data;
unsigned char *destmain = NULL;
destmain = (unsigned char *)BG_GFX;
for (; h>0; h--)
{
dmaCopy(srcmain, destmain, w);
destmain += step;
srcmain += SCREENWIDTH;
}
// Update the display buffer (flipping video pages if supported)
// If we need to change palette, that implicitely does a flip
if (newpal != NO_PALETTE_CHANGE) {
I_UploadNewPalette(newpal);
newpal = NO_PALETTE_CHANGE;
}
}
void gamestate::initLandscape() {
// Sets up the palette
landscape1.Palette[BLACK] = BLACK_15BIT;
landscape1.Palette[RED] = RED_15BIT;
landscape1.Palette[GREEN] = GREEN_15BIT;
landscape1.Palette[BLUE] = BLUE_15BIT;
landscape1.Palette[YELLOW] = YELLOW_15BIT;
landscape1.Palette[TURQUIS] = TURQUIS_15BIT;
landscape1.Palette[PURPLE] = PURPLE_15BIT;
landscape1.Palette[WHITE] = WHITE_15BIT;
landscape1.Palette[ORANGE] = ORANGE_15BIT;
landscape1.Palette[MAGENTA] = MAGENTA_15BIT;
landscape1.Palette[SALMON] = SALMON_15BIT;
landscape1.Palette[DIRT] = DIRT_15BIT;
landscape1.Palette[DARKBG] = DARKBG_15BIT;
// Gets the DS ready to write to VRAM
DC_FlushRange(landscape1.Palette, BG_PAL_LEN);
// Writes Palette to VRAM
dmaCopy(landscape1.Palette, BG_PALETTE, BG_PAL_LEN);
landscape1.colorI = DIRT;
landscape1.backgroundColorI = DARKBG;
// makes all pixels of the background blue
landscape1.fill(landscape1.backgroundColorI);
landscape1.initCosLandscape(); //Calculates heights for a Landscape
landscape1.fillLandscape(); // Sets the landscape based on heights
object::landscape1 = &landscape1;
}
void Display::editMixerParams(){
CCParam ccParam;
bgSetPriority(this->subbg3, 1);
DC_FlushAll();
dmaCopy(greyedBgSubTiles, bgGetGfxPtr(this->subbg3), greyedBgSubTilesLen);
dmaCopy(greyedBgSubMap, bgGetMapPtr(this->subbg3), greyedBgSubMapLen);
bgShow(this->subbg3);
echo(0, RED, 0, 13, "MIXER");
echo(0, RED, 12, 13, "MUTES");
while(!(Cfg::editParams && input->pad->start() == DOWN)){
for (u8 i = 0; i<8; ++i){
ccParam = Cfg::mixer.ccs[i];
echo(0, WHITE, 2, 1 + 4*(i%8), "CC");
paramsEditSprite->display(16+i, 8 + 32*(i%8), 24, OBJPRIORITY_0, 0);
iprintf("\x1b[%d;%dH%3d", 4, 4*(i%8), ccParam.cc);
paramsEditSprite->display(32+i, 8 + 32*(i%8), 40, OBJPRIORITY_0, 1);
echo(0, WHITE, 6, 1 + 4*(i%8), "CH");
paramsEditSprite->display(48+i, 8 + 32*(i%8), 56, OBJPRIORITY_0, 0);
iprintf("\x1b[%d;%dH%3d", 8, 4*(i%8), 1 + ccParam.channel);
paramsEditSprite->display(64+i, 8 + 32*(i%8), 72, OBJPRIORITY_0, 1);
ccParam = Cfg::mixer.mutes[i];
echo(0, WHITE, 14, 1 + 4*(i%8), "CC");
paramsEditSprite->display(24+i, 8 + 32*(i%8), 120, OBJPRIORITY_0, 0);
iprintf("\x1b[%d;%dH%3d", 16, 4*(i%8), ccParam.cc);
paramsEditSprite->display(40+i, 8 + 32*(i%8), 136, OBJPRIORITY_0, 1);
echo(0, WHITE, 18, 1 + 4*(i%8), "CH");
paramsEditSprite->display(56+i, 8 + 32*(i%8), 152, OBJPRIORITY_0, 0);
iprintf("\x1b[%d;%dH%3d", 20, 4*(i%8), 1 + ccParam.channel);
paramsEditSprite->display(72+i, 8 + 32*(i%8), 168, OBJPRIORITY_0, 1);
}
oamUpdate(&oamSub);
input->editMixerParams();
Cfg::editParams = true;
swiWaitForVBlank();
}
save->write();
Cfg::editParams = false;
oamClear(&oamSub, 16, 80);
consoleClear();
}
void advMosaic(void)
{
videoSetMode(MODE_0_2D);
vramSetBankA(VRAM_A_MAIN_BG);
int bg = bgInit(0, BgType_Text8bpp, BgSize_T_256x256, 0,1);
dmaCopy(TextBackgroundsTiles, bgGetGfxPtr(bg), sizeof(TextBackgroundsTiles));
dmaCopy(Layer256x256Map, bgGetMapPtr(bg), Layer256x256MapLen);
dmaCopy(TextBackgroundsPal, BG_PALETTE, sizeof(TextBackgroundsPal));
bgMosaicEnable(bg);
int keys = 0;
int mosaic_x = 0;
int mosaic_y = 0;
while(!(keys & KEY_B))
{
scanKeys();
keys = keysDown();
if(keys & KEY_UP) mosaic_y--;
if(keys & KEY_DOWN) mosaic_y++;
if(keys & KEY_LEFT) mosaic_x--;
if(keys & KEY_RIGHT) mosaic_x++;
if(mosaic_x > 15) mosaic_x = 15;
if(mosaic_x < 0) mosaic_x = 0;
if(mosaic_y > 15) mosaic_y = 15;
if(mosaic_y < 0) mosaic_y = 0;
swiWaitForVBlank();
bgSetMosaic(mosaic_x, mosaic_y);
consoleClear();
iprintf("Press B to exit\n");
iprintf("DX: %d DY: %d", mosaic_x, mosaic_y);
}
}
BG_INF* initBg(s16* tiles, int tileSz, s16* pal, int width, int height, int layer, u16* map)
{
BG_INF* tmp;
if((tmp = malloc(sizeof(BG_INF)))) {
tmp->bgId = bgInit(layer, BgType_Text8bpp, BgSize_T_512x256, 0,1);
dmaCopy(tiles, bgGetGfxPtr(tmp->bgId), tileSz);
dmaCopy(pal, BG_PALETTE, 256*2);
tmp->vram_map = bgGetMapPtr(tmp->bgId);
tmp->map = map;
tmp->mapwidth = width;
tmp->mapHeight = height;
tmp->x = 0;
tmp->y = 0;
fillScreen(tmp, 0, 0);
return tmp;
}
return NULL;
}
void sprites_update_OAM()
{
const int oamSize = 128 * sizeof(SpriteEntry);
#ifdef USE_DMA
dmaCopy(sm_OAMCopy, OAM, oamSize);
#else
for (int i = 0; i < oamSize / 4; i++)
((u32*)OAM)[i] = ((u32*)sm_OAMCopy)[i];
#endif
}
void I_FinishUpdate (void)
{
if (I_SkipFrame()) return;
#ifndef GL_DOOM
int h = 200;
int w = 320;
int step = 512;
unsigned char *srcmain = screens[0];
unsigned char *srcsub = screens[1];
unsigned char *destmain = NULL, *destsub = NULL;
// Jefklak 19/11/06 - sub screen rendering
destmain = (unsigned char *)BG_GFX;
if(!gen_console_enable)
destsub = (unsigned char *)BG_GFX_SUB;
for (; h>0; h--)
{
dmaCopy(srcmain, destmain, w);
destmain += step;
srcmain += SCREENWIDTH;
if(!gen_console_enable)
{
// dmaCopy() uses DMA_CR(3) with syncs
dmaCopy(srcsub, destsub, w);
destsub += step;
srcsub += SCREENWIDTH;
}
}
// Update the display buffer (flipping video pages if supported)
// If we need to change palette, that implicitely does a flip
if (newpal != NO_PALETTE_CHANGE) {
I_UploadNewPalette(newpal);
newpal = NO_PALETTE_CHANGE;
}
#else
// proff 04/05/2000: swap OpenGL buffers
gld_Finish();
#endif
}
