//---------------------------------------------------------------------------------
bool sdio_Startup() {
//---------------------------------------------------------------------------------
if (!REG_DSIMODE) return false;
fifoSendValue32(FIFO_SDMMC,SDMMC_HAVE_SD);
while(!fifoCheckValue32(FIFO_SDMMC));
int result = fifoGetValue32(FIFO_SDMMC);
if(result==0) return false;
fifoSendValue32(FIFO_SDMMC,SDMMC_SD_START);
while(!fifoCheckValue32(FIFO_SDMMC));
result = fifoGetValue32(FIFO_SDMMC);
return result == 0;
}
//---------------------------------------------------------------------------------
bool sdio_IsInserted() {
//---------------------------------------------------------------------------------
if (!REG_DSIMODE) return false;
fifoSendValue32(FIFO_SDMMC,SDMMC_SD_IS_INSERTED);
while(!fifoCheckValue32(FIFO_SDMMC));
int result = fifoGetValue32(FIFO_SDMMC);
return result == 1;
}
int CommandStopRecording(void)
{
NTXMFifoMessage command;
command.commandType = STOP_RECORDING;
fifoSendDatamsg(FIFO_NTXM, sizeof(command), (u8*)&command);
while(!fifoCheckValue32(FIFO_NTXM))
swiDelay(1);
return (int)fifoGetValue32(FIFO_NTXM);
}
int soundPlayNoise(u16 freq, u8 volume, u8 pan){
FifoMessage msg;
msg.type = SOUND_NOISE_MESSAGE;
msg.SoundPsg.freq = freq;
msg.SoundPsg.volume = volume;
msg.SoundPsg.pan = pan;
fifoSendDatamsg(FIFO_SOUND, sizeof(msg), (u8*)&msg);
while(!fifoCheckValue32(FIFO_SOUND));
return (int)fifoGetValue32(FIFO_SOUND);
}
int CommandStopRecording(void)
{
NTXMFifoMessage command;
command.commandType = STOP_RECORDING;
fifoSetValue32Handler(FIFO_NTXM, 0, 0);
fifoSendDatamsg(FIFO_NTXM, sizeof(command), (u8*)&command);
while(!fifoCheckValue32(FIFO_NTXM))
//swiDelay(1);
DSWaitForIRQ(~0);
int x = (int)fifoGetValue32(FIFO_NTXM);
fifoSetValue32Handler(FIFO_NTXM, CommandRecvHandler, 0);
return x;
}
void sleepMode(u32 value32, void* userdata)
{iprintf("sleep mode engaged\n");for(;;);
fifoSendValue32(FIFO_USER_03, 1);
// turn shit off
u32 powerstate = *(vu32*)0x04000304;
*(vu32*)0x04000304 = (powerstate & 0x8001);
swiIntrWait(1, IRQ_FIFO_NOT_EMPTY);
iprintf("done sleeping\n");
// turn shit back on
*(vu32*)0x04000304 = powerstate;
fifoSendValue32(FIFO_USER_03, 1);
while (!fifoCheckValue32(FIFO_USER_03));
}
// fifoSetValue32Handler - Set a callback to receive incoming value32 messages on a specific channel.
bool fifoSetValue32Handler(int channel, FifoValue32HandlerFunc newhandler, void * userdata) {
if(channel<0 || channel>=FIFO_NUM_CHANNELS) return false;
int oldIME = enterCriticalSection();
fifo_value32_func[channel] = newhandler;
fifo_value32_data[channel] = userdata;
if(newhandler) {
while(fifoCheckValue32(channel)) {
newhandler( fifoGetValue32(channel) , userdata );
}
}
leaveCriticalSection(oldIME);
return true;
}
void send_mp3_stop_message(void)
{
do_mp3 = 0;
fifo_msg msg;
msg.type = kStopMP3;
fifoSendDatamsg(FIFO_7to9,sizeof(msg),(u8 *)&msg);
while(!fifoCheckValue32(FIFO_7to9));
int ret = (int)fifoGetValue32(FIFO_7to9);
/*while (quake_ipc_7to9->message == 0xffffffff);
quake_ipc_7to9->message_type = kStopMP3;
quake_ipc_7to9->message = 0xffffffff;
while (quake_ipc_7to9->message == 0xffffffff);*/
ARM7_PRINT("mp3 stop message sent\n");
}
int soundMicRecord(void *buffer, u32 bufferLength, MicFormat format, int freq, MicCallback callback){
FifoMessage msg;
msg.type = MIC_RECORD_MESSAGE;
msg.MicRecord.format = format;
msg.MicRecord.buffer = buffer;
msg.MicRecord.freq = freq;
msg.MicRecord.bufferLength = bufferLength;
micCallback = callback;
fifoSetDatamsgHandler(FIFO_SOUND, micBufferHandler, 0);
fifoSendDatamsg(FIFO_SOUND, sizeof(msg), (u8*)&msg);
while(!fifoCheckValue32(FIFO_SOUND));
return (int)fifoGetValue32(FIFO_SOUND);
}
//---------------------------------------------------------------------------------
bool sdio_WriteSectors(sec_t sector, sec_t numSectors,const void* buffer) {
//---------------------------------------------------------------------------------
if (!REG_DSIMODE) return false;
FifoMessage msg;
DC_FlushRange(buffer,numSectors * 512);
msg.type = SDMMC_SD_WRITE_SECTORS;
msg.sdParams.startsector = sector;
msg.sdParams.numsectors = numSectors;
msg.sdParams.buffer = (void*)buffer;
fifoSendDatamsg(FIFO_SDMMC, sizeof(msg), (u8*)&msg);
while(!fifoCheckValue32(FIFO_SDMMC));
int result = fifoGetValue32(FIFO_SDMMC);
return result == 0;
}
int soundPlaySample(const void* data, SoundFormat format, u32 dataSize, u16 freq, u8 volume, u8 pan, bool loop, u16 loopPoint){
FifoMessage msg;
msg.type = SOUND_PLAY_MESSAGE;
msg.SoundPlay.data = data;
msg.SoundPlay.freq = freq;
msg.SoundPlay.volume = volume;
msg.SoundPlay.pan = pan;
msg.SoundPlay.loop = loop;
msg.SoundPlay.format = format;
msg.SoundPlay.loopPoint = loopPoint;
msg.SoundPlay.dataSize = dataSize >> 2;
fifoSendDatamsg(FIFO_SOUND, sizeof(msg), (u8*)&msg);
while(!fifoCheckValue32(FIFO_SOUND));
return (int)fifoGetValue32(FIFO_SOUND);
}
static inline void render1(void)
{
scanKeys();
// cpuEndSlice();
playerControls(NULL);
updateControls();
// iprintf("controls : %d \n",cpuEndSlice());
updatePlayer(NULL);
// iprintf("player : %d \n",cpuEndSlice());
updatePortals();
updateTurrets();
updateBigButtons();
updateTimedButtons();
updateEnergyDevices();
updateEnergyBalls();
updatePlatforms();
updateCubeDispensers();
updateEmancipators();
updateEmancipationGrids();
updateDoors();
updateWallDoors();
// iprintf("updates : %d \n",cpuEndSlice());
// if(currentPortal)GFX_CLEAR_COLOR=currentPortal->color|(31<<16);
// else GFX_CLEAR_COLOR=0;
u16 color=getCurrentPortalColor(getPlayer()->object->position);
// NOGBA("col %d",color);
// GFX_CLEAR_COLOR=color|(31<<16);
GFX_CLEAR_COLOR=RGB15(0,0,0)|(31<<16);
#ifdef DEBUG_GAME
if(fifoCheckValue32(FIFO_USER_08))iprintf("\x1b[0J");
while(fifoCheckValue32(FIFO_USER_08)){int32 cnt=fifoGetValue32(FIFO_USER_08);iprintf("ALERT %d \n",cnt);NOGBA("ALERT %d \n",cnt);}
#else
while(fifoCheckValue32(FIFO_USER_08)){int32 cnt=fifoGetValue32(FIFO_USER_08);NOGBA("ALERT %d \n",cnt);}
#endif
projectCamera(NULL);
glPushMatrix();
glScalef32(SCALEFACT,SCALEFACT,SCALEFACT);
renderGun(NULL);
transformCamera(NULL);
cpuEndSlice();
// drawRoomsGame(128, color);
drawRoomsGame(0, color);
// drawCell(getCurrentCell(getPlayer()->currentRoom,getPlayerCamera()->position));
// iprintf("room : %d \n",cpuEndSlice());
updateParticles();
drawParticles();
// iprintf("particles : %d \n",cpuEndSlice());
drawOBBs();
// iprintf("OBBs : %d \n",cpuEndSlice());
drawBigButtons();
drawTimedButtons();
drawEnergyDevices();
drawEnergyBalls();
drawPlatforms();
drawCubeDispensers();
drawTurretsStuff();
drawEmancipators();
drawEmancipationGrids();
drawDoors();
drawWallDoors(NULL);
drawSludge(&gameRoom);
// iprintf("stuff : %d \n",cpuEndSlice());
drawPortal(&portal1);
drawPortal(&portal2);
glPopMatrix(1);
//HUD TEST
if(levelInfoCounter>0 && (levelTitle || levelAuthor))
{
levelInfoCounter--;
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glOrthof32(inttof32(0), inttof32(255), inttof32(191), inttof32(0), -inttof32(1), inttof32(1));
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
if(levelTitle)drawCenteredString(levelTitle, inttof32(17)/10, (82));
if(levelAuthor)drawCenteredString(levelAuthor, inttof32(1), (100));
glPopMatrix(1);
glMatrixMode(GL_PROJECTION);
glPopMatrix(1);
}
glFlush(0);
}
//---------------------------------------------------------------------------------
int loadNDS(int socket, u32 remote) {
//---------------------------------------------------------------------------------
int len;
int i=0;
ioctl(socket,FIONBIO,&i);
len = recvall(socket,__NDSHeader,512,0);
if (len != 512) {
kprintf("Error reading header.\n");
return 1;
}
int arm7dest = __NDSHeader->arm7destination;
int arm7size = __NDSHeader->arm7binarySize;
int arm9dest = __NDSHeader->arm9destination;
int arm9size = __NDSHeader->arm9binarySize;
volatile int response = 0;
if (arm9dest + arm9size > (int)_start) response = 1;
if (arm7dest >= 0x02000000 && arm7dest < 0x03000000 && arm7dest + arm7size > (int)_start) response = 2;
send(socket,(int *)&response,sizeof(response),0);
if(response) return 1;
kprintf("Reading arm7 binary: ");
if (progressRead(socket,(char *)memUncached((void*)0x02000000),arm7size)) {
kprintf("\nReceive error.\n");
return 1;
}
fifoSendValue32(FIFO_USER_01,1);
while(!fifoCheckValue32(FIFO_USER_01)) {
swiIntrWait(1,IRQ_FIFO_NOT_EMPTY);
}
fifoGetValue32(FIFO_USER_01);
kprintf("Reading arm9 binary: ");
if(progressRead(socket,(char *)arm9dest,arm9size)) {
kprintf("\nReceive error.\n");
return 1;
}
volatile int cmdlen=0;
char *cmdline;
if (arm9size != 0){
cmdline = (char*)(arm9dest+arm9size);
} else {
cmdline = (char*)(arm7dest+arm7size);
}
len = recvall(socket,(char*)&cmdlen,4,0);
if (cmdlen) {
len = recvall(socket,cmdline,cmdlen,0);
__system_argv->argvMagic = ARGV_MAGIC;
__system_argv->commandLine = cmdline;
__system_argv->length = cmdlen;
__system_argv->host = remote;
}
Wifi_DisableWifi();
DC_FlushAll();
REG_IPC_SYNC = 0;
fifoSendValue32(FIFO_USER_01,2);
fifoSendValue32(FIFO_USER_01,__NDSHeader->arm9executeAddress);
irqDisable(IRQ_ALL);
REG_IME = 0;
//clear out ARM9 DMA channels
for (i=0; i<4; i++) {
DMA_CR(i) = 0;
DMA_SRC(i) = 0;
DMA_DEST(i) = 0;
TIMER_CR(i) = 0;
TIMER_DATA(i) = 0;
}
u16 *mainregs = (u16*)0x04000000;
u16 *subregs = (u16*)0x04001000;
for (i=0; i<43; i++) {
mainregs[i] = 0;
subregs[i] = 0;
}
REG_DISPSTAT = 0;
dmaFillWords(0, BG_PALETTE, (2*1024));
VRAM_A_CR = 0x80;
dmaFillWords(0, VRAM, 128*1024);
VRAM_A_CR = 0;
VRAM_B_CR = 0;
// Don't mess with the ARM7's VRAM
// VRAM_C_CR = 0;
VRAM_D_CR = 0;
VRAM_E_CR = 0;
VRAM_F_CR = 0;
VRAM_G_CR = 0;
VRAM_H_CR = 0;
VRAM_I_CR = 0;
REG_POWERCNT = 0x820F;
//set shared ram to ARM7
WRAM_CR = 0x03;
// Return to passme loop
*((vu32*)0x02FFFE04) = (u32)0xE59FF018; // ldr pc, 0x02FFFE24
*((vu32*)0x02FFFE24) = (u32)0x02FFFE04; // Set ARM9 Loop address
REG_IPC_SYNC = 0x500;
arm9Reset();
while(1);
}
