Yes, that's another possibility, but I would need to synchronize the threads so they all sleep at the same time. Otherwise I would kill performance. BTW, performance is the reason why I don't want the call to gspWaitForVBlank() in the main thread, too...
I don't think you're understanding how it works. Why would you have 2 threads and have both of them sleep? Why are you using 2 threads anyways?
That was your suggestion: "If you use svcsleepthread on both, that should make the home button work."
I wasn't giving you a suggestion, you use svcsleepthread to yeld the thread so the other one can resume. Either way, you don't need a second thread. You can omit the wait, or use gspSetEventCallback to trigger the frameswap.
If they run on another core yes, but the o3ds only has 2 cores and 1 is mostly reserved for the system so you will still have to yeld. On n3ds you can use threads on the extra cores without yelding, but your app will need to have some sort of synchronization.
I'm running into that exact problem where my homebrew doesn't wake up after opening the lid!
I played around a bit with the gspSetEventCallback() function and found a couple of issues:
I played around a bit with the gspSetEventCallback() function and found a couple of issues:
This is driving me crazy ... Everything is working fine in my homebrew - except the home button. And I don't really want to sacrifice performance by including sleep periods in the main thread
- The callback does not run in the main thread but rather in the GSP thread and thus does not solve my issue with the non-working home button
- A call to C3D_FrameBegin() in the callback function fails - no idea why. The call did not fail in the old code where it was called directly after gspWaitForVBlank()
That video thread is a little messy and I see why you don't want to fix it. You problem is thread exhaustion, add a svcSleepThread(1) to the main thread and the home button will become responsive. I just tried it.
#define __STDC_FORMAT_MACROS
#include <inttypes.h>
#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include <citro2d.h>
#include <3ds.h>
#include "fb_conv.h"
#include "CLUT_blues.h"
#include "CLUT_reds.h"
#include "CLUT_greens.h"
#include "fb8bpp.h"
#include "sub_ui.h"
extern const uint8_t FBImage[ ];
#define MainTextureWidth 512
#define MainTextureHeight 512
#define MainTextureSize ( MainTextureWidth * MainTextureHeight * 4 )
// Cobbled together main framebuffer sprite
C2D_Sprite ScreenSprite = {
.image = ( C2D_Image ) {
.tex = &( C3D_Tex ) {
// Gets initialized later
},
.subtex = &( const Tex3DS_SubTexture ) {
.width = MainTextureWidth,
.height = MainTextureHeight,
.left = 0.0f,
.right = 1.0f,
.top = 1.0f,
.bottom = 0.0f
}
},
.params = ( C2D_DrawParams ) {
.pos.x = 0.0f,
.pos.y = 0.0f,
.pos.w = MainTextureWidth,
.pos.h = MainTextureHeight,
.center.x = 1.0f,
.center.y = 1.0f,
.depth = 1.0f,
.angle = 0.0f //-C3D_AngleFromDegrees( 90.0f )
}
};
C3D_RenderTarget* MainRenderTarget = NULL;
uint32_t* MainScreenBuffer = NULL;
bool CreateMainScreen( void ) {
MainRenderTarget = C2D_CreateScreenTarget( GFX_TOP, GFX_LEFT );
if ( MainRenderTarget ) {
MainScreenBuffer = ( uint32_t* ) linearAlloc( MainTextureSize );
if ( MainScreenBuffer ) {
memset( MainScreenBuffer, 0, MainTextureSize );
return C3D_TexInit( ScreenSprite.image.tex, 512, 512, GPU_RGBA8 );
}
}
return false;
}
void DestroyMainScreen( void ) {
if ( MainScreenBuffer ) {
linearFree( MainScreenBuffer );
}
C3D_TexDelete( ScreenSprite.image.tex );
}
int ShowError( const char* ErrorText ) {
errorConf e;
errorInit( &e, ERROR_TEXT_WORD_WRAP, CFG_LANGUAGE_EN );
errorText( &e, ErrorText );
errorDisp( &e );
return 1;
}
volatile bool RenderThreadRun = true;
volatile bool RenderThreadReady = false;
volatile bool RenderThreadBusy = false;
volatile bool RenderThreadReqUpdate = false;
Thread RenderThreadHandle = NULL;
void RenderThread( void* Param ) {
gfxInitDefault( );
consoleInit( GFX_BOTTOM, NULL );
C3D_Init( C3D_DEFAULT_CMDBUF_SIZE );
C2D_Init( C2D_DEFAULT_MAX_OBJECTS );
C2D_Prepare( );
if ( CreateMainScreen( ) ) {
RenderThreadReady = true;
while ( RenderThreadRun ) {
if ( RenderThreadReqUpdate == true ) {
RenderThreadReqUpdate = false;
RenderThreadBusy = true;
Unpack8BPP( ( const uint8_t* ) fb8bpp, MainScreenBuffer, 512 * 384 );
RenderThreadBusy = false;
}
C3D_FrameBegin( C3D_FRAME_SYNCDRAW );
// Flush and transfer main screen to texture
GSPGPU_FlushDataCache( MainScreenBuffer, MainTextureSize );
C3D_SyncDisplayTransfer(
( uint32_t* ) MainScreenBuffer,
GX_BUFFER_DIM( MainTextureWidth, MainTextureHeight ),
ScreenSprite.image.tex->data,
GX_BUFFER_DIM( MainTextureWidth, MainTextureHeight ),
GX_TRANSFER_OUT_FORMAT( GX_TRANSFER_FMT_RGBA8 ) |
GX_TRANSFER_IN_FORMAT( GX_TRANSFER_FMT_RGBA8 ) |
GX_TRANSFER_OUT_TILED( 1 ) |
GX_TRANSFER_FLIP_VERT( 0 )
);
// Draw
C2D_TargetClear( MainRenderTarget, C2D_Color32( 0, 255, 255, 255 ) );
C2D_SceneBegin( MainRenderTarget );
C2D_DrawSprite( &ScreenSprite );
C3D_FrameEnd( 0 );
}
DestroyMainScreen( );
}
C2D_Fini( );
C3D_Fini( );
gfxExit( );
threadExit( 0 );
}
int main( void ) {
uint32_t Keys_Down = false;
osSetSpeedupEnable( false );
APT_SetAppCpuTimeLimit( 75 );
RenderThreadHandle = threadCreate( RenderThread, NULL, 4096, 0x20, 1, false );
if ( ! RenderThreadHandle ) {
return ShowError( "Failed to create render thread" );
}
// Wait for render thread to init and start running
while ( RenderThreadReady == false )
;
// Initial render req
RenderThreadReqUpdate = true;
// Spin until it finishes
while ( RenderThreadBusy )
;
printf( "Hi!\n" );
while ( aptMainLoop( ) ) {
hidScanInput( );
Keys_Down = hidKeysDown( );
if ( Keys_Down & KEY_A ) {
RenderThreadReqUpdate = true;
RenderThreadBusy = true;
while ( RenderThreadBusy )
;
}
if ( Keys_Down & KEY_START ) {
break;
}
}
RenderThreadReqUpdate = false;
RenderThreadRun = false;
threadJoin( RenderThreadHandle, U64_MAX );
threadFree( RenderThreadHandle );
return 0;
}Why does the same function call take varying amounts of time?
If I measure the time taken between setting the RenderThreadReq variable and RenderThreadBusy being false the time can vary wildly.
Sometimes it can take ~10ms, other 20.
Nothing makes seeeeeenseeeeeeee
There are many things that you need to fix. Don't keep the thread running the whole time, use signals. Use a mutex so you don't write to shared resources at the same time. Use C3D_FRAME_NONBLOCK. And APT_SetAppCpuTimeLimit above 30 only works for .3dsx
If you implement it correctly it could help a bit. Can't say if it will do much though, specially in the case of the o3ds
Xdqwerty
BakerMan
K3Nv2
Psionic Roshambo
@
Xdqwerty:
@
Psionic Roshambo:
