void on_mainwindow_lose_focus(GtkWidget* widget, gpointer user_data)
{
mainWindowHasFocus = 0;
PauseAudio(1);
while(!mainWindowHasFocus) // stop gameplay by looping until the window regains focus.
{
// Keep running GTK+ so that it can report when the window regains
// focus.
while(gtk_events_pending())
gtk_main_iteration_do(FALSE);
}
// Window is focused again; resume gameplay.
PauseAudio(0);
}
void on_pause_activate(GtkMenuItem* menuitem, gpointer user_data)
{
paused = !paused;
if(paused)
{
PauseAudio(1);
while(paused) // stop gameplay by looping until unpaused
{
// Keep running GTK+ so that the application doesn't lock up.
while(gtk_events_pending())
gtk_main_iteration_do(FALSE);
}
// Unpaused; resume gameplay.
PauseAudio(0);
}
}
// int main(int argc, char* argv[])
int GameMain()
{
// assert(argc || argv[0]); // Fixes the compiler complaining about unused values;
GameState* game_state = CreateNewGameState("EnGen", 1600, 900);
Renderer* renderer = game_state->renderer;
game_state->active_scene = PushScene(&game_state->permanent_memory, MAX_GAME_ENTITES);
TileMap* tilemap = game_state->active_scene->tilemap;
for (int32 i = 0; i < 10; ++i)
{
Vec2 pos = { (float)i, 2.f };
AddTileToMap(tilemap, pos);
}
for (int32 i = 0; i < 10; ++i)
{
Vec2 pos = { 0, (float)i };
AddTileToMap(tilemap, pos);
}
for (int32 i = 0; i < 10; ++i)
{
Vec2 pos = { 10.f, (float)i };
AddTileToMap(tilemap, pos);
}
UIWindow* ui = PushStruct(&game_state->permanent_memory, UIWindow);
SetTitle(ui, "Editor UI!");
SetSize(ui, { 0.1f, 0.3f, 0.2f, 0.2f }, 0.05f);
UIWindow* ui2 = PushStruct(&game_state->permanent_memory, UIWindow);
SetTitle(ui2, "Editor UI2!");
SetSize(ui2, { 0.2f, 0.3f, 0.2f, 0.2f }, 0.05f);
InitializeDebugConsole();
#if 0
InitializeAudio();
char* test_sound_file = "C:\\projects\\imperial_march.wav";
bool test_sound_loaded = LoadWavFile(test_sound_file);
if(test_sound_loaded)
{
printf("Loaded File\n");
}
PauseAudio(false);
#endif
Camera default_camera = {}; // maybe put this in game_state?
default_camera.position = vec2(0, 0);
default_camera.viewport_size.x = 16;
default_camera.viewport_size.y = 9;
uint32 frame_count = 0;
uint32 fps = 0;
double last_fps_time = 0;
bool running = true;
while (running)
{
ProfileBeginFrame();
ProfileBeginSection(Profile_Frame);
ProfileBeginSection(Profile_Input);
Platform_RunMessageLoop(game_state->input);
Camera* draw_camera = game_state->active_camera ? game_state->active_camera : &default_camera;
game_state->window.resolution = Platform_GetResolution();
UpdateMouseWorldPosition(game_state->input, game_state->window.resolution, draw_camera->viewport_size, draw_camera->position);
ProfileEndSection(Profile_Input);
Vec2i mouse_pos = MousePosition(game_state->input);
//DebugPrintf("Mouse World Position: (%.2f, %.2f)", mouse_pos.x, mouse_pos.y);
DebugPrintf("Mouse World Position: (%d, %d)", mouse_pos.x, mouse_pos.y);
DebugPrintf("Main Camera Position: (%.2f, %.2f)", default_camera.position.x, default_camera.position.y);
DebugPrintf("Key Pressed: %s", IsDown(game_state->input, KeyCode_a) ? "TRUE" : "FALSE");
if (OnDown(game_state->input, KeyCode_ESCAPE))
{
running = false;
break;
}
#if 0 // TODO: Platform layer
if (OnDown(game_state->input, KeyCode_z))
{
ForceColorClear();
SwapBuffer(game_state);
//WindowSetScreenMode(&game_state->window, ScreenMode_Windowed);
}
else if (OnDown(game_state->input, KeyCode_c))
{
ForceColorClear();
SwapBuffer(game_state);
//WindowSetScreenMode(&game_state->window, ScreenMode_Borderless);
}
#endif
static bool draw_debug = true;
if (OnDown(game_state->input, KeyCode_BACKQUOTE))
{
draw_debug = !draw_debug;
}
Renderer* debug_renderer = draw_debug ? renderer : 0;
TimeBeginFrame(game_state);
// Update the scene first, pushing draw calls if necessary.
// Then call begin_frame which builds matrices and clears buffers;
float current_time = CurrentTime(game_state);
if (current_time - last_fps_time > 1.0f)
{
last_fps_time = current_time;
fps = frame_count;
frame_count = 0;
}
frame_count++;
DebugPrintf("FPS: \t\t%d \tFrames: \t%d", fps, FrameCount(game_state));
DebugControlCamera(game_state, &default_camera);
// TODO(cgenova): separate update and render calls so that things can be set up when rendering begins;
BeginFrame(renderer, &game_state->window);
ProfileBeginSection(Profile_SceneUpdate);
DebugPrintPushColor(vec4(1.0f, 0, 0, 1.0f));
DebugPrintf("Active scene entity usage: (%d / %d)", game_state->active_scene->active_entities, MAX_GAME_ENTITES);
DebugPrintPopColor();
UpdateSceneEntities(game_state, game_state->active_scene);
DrawSceneEntities(game_state->active_scene, renderer);
ProfileEndSection(Profile_SceneUpdate);
#if 1 // Spaghetti test
const size_t num_verts = 200;
static SimpleVertex v[num_verts];
static bool initialized = false;
if (!initialized)
{
initialized = true;
for (uint32 i = 0; i < num_verts; ++i)
{
SimpleVertex verts = {};
verts.position = vec2((float)(i / 50.f) - 2.f, (float)i);
verts.color = vec4(1, 1, 0, 1.f);
v[i] = verts;
}
}
else
{
for (uint32 i = 0; i < num_verts; ++i)
{
v[i].position.y = sin(CurrentTime(game_state) + i / (PI * 20));
}
}
PrimitiveDrawParams spaghetti_params = {};
spaghetti_params.line_draw_flags |= PrimitiveDraw_Smooth;
// spaghetti_params.line_draw_flags |= Draw_ScreenSpace;
spaghetti_params.line_width = 0;
DrawLine(renderer, v, num_verts, spaghetti_params);
#endif
DrawTileMap(game_state, game_state->active_scene->tilemap);
UpdateUIWindow(game_state, ui);
UpdateUIWindow(game_state, ui2);
RenderDrawBuffer(renderer, draw_camera);
ProfileEndSection(Profile_Frame);
ProfileEndFrame(debug_renderer, TARGET_FPS);
DebugDrawConsole(debug_renderer);
// NOTE:
// For drawing Debug info, the profiling in this section will be discarded,
// but it is only drawing text and the debug graph.
RenderDrawBuffer(renderer, draw_camera);
SwapBuffer(game_state);
// TODO(cgenova): High granularity sleep function!
ResetArena(&game_state->temporary_memory);
}// End main loop
return 1;
}
_Use_decl_annotations_
VOID
OnIoDeviceControl(
WDFQUEUE Queue,
WDFREQUEST Request,
size_t OutputBufferLength,
size_t InputBufferLength,
ULONG IoControlCode
)
/*++
Routine Description:
This event handled device control calls.
Arguments:
Queue - Handle of the queue object associated with the request
Request - Handle of the request object
OutputBufferLength - length of the request's output buffer
InputBufferLength - length of the request's input buffer
IoControlCode - the driver-defined or system-defined I/O control code
Return Value:
None
--*/
{
UNREFERENCED_PARAMETER(OutputBufferLength);
UNREFERENCED_PARAMETER(InputBufferLength);
WDFDEVICE device;
PDEVICE_CONTEXT deviceContext;
NTSTATUS status = STATUS_SUCCESS;
device = WdfIoQueueGetDevice(Queue);
deviceContext = GetContext(device);
//
// Validate the IO code and exexute on it.
//
switch (IoControlCode)
{
case IOCTL_BCM_PWM_SET_CLOCKCONFIG:
status = ValidateAndSetClockConfig(device, Request);
break;
case IOCTL_BCM_PWM_GET_CLOCKCONFIG:
status = GetClockConfig(device, Request);
break;
case IOCTL_BCM_PWM_SET_CHANNELCONFIG:
status = ValidateAndSetChannelConfig(device, Request);
break;
case IOCTL_BCM_PWM_GET_CHANNELCONFIG:
status = GetChannelConfig(device, Request);
break;
case IOCTL_BCM_PWM_SET_DUTY_REGISTER:
status = ValidateAndSetDutyRegister(device, Request);
break;
case IOCTL_BCM_PWM_GET_DUTY_REGISTER:
status = GetDutyRegister(device, Request);
break;
case IOCTL_BCM_PWM_START:
status = ValidateAndStartChannel(device, Request);
break;
case IOCTL_BCM_PWM_STOP:
status = ValidateAndStopChannel(device, Request);
break;
case IOCTL_BCM_PWM_AQUIRE_AUDIO:
status = AquireAudio(device);
break;
case IOCTL_BCM_PWM_RELEASE_AUDIO:
status = ReleaseAudio(device);
break;
case IOCTL_BCM_PWM_INITIALIZE_AUDIO:
status = InitializeAudio(device, Request);
break;
case IOCTL_BCM_PWM_REGISTER_AUDIO_NOTIFICATION:
status = RegisterAudioNotification(device, Request);
break;
case IOCTL_BCM_PWM_UNREGISTER_AUDIO_NOTIFICATION:
status = UnregisterAudioNotification(device, Request);
break;
case IOCTL_BCM_PWM_START_AUDIO:
status = StartAudio(device);
break;
case IOCTL_BCM_PWM_PAUSE_AUDIO:
status = PauseAudio(device);
break;
case IOCTL_BCM_PWM_RESUME_AUDIO:
status = ResumeAudio(device);
break;
case IOCTL_BCM_PWM_STOP_AUDIO:
status = StopAudio(device);
break;
default:
status = STATUS_INVALID_DEVICE_REQUEST;
TraceEvents(TRACE_LEVEL_ERROR, TRACE_IOCTL, "Unexpected IO code in request. Request: 0x%08x, Code: 0x%08x", (ULONG)Request, IoControlCode);
break;
}
WdfRequestComplete(Request, status);
}
void FAppEventManager::Tick()
{
while (!Queue.IsEmpty())
{
bool bDestroyWindow = false;
FAppEventData Event = DequeueAppEvent();
switch (Event.State)
{
case APP_EVENT_STATE_WINDOW_CREATED:
check(FirstInitialized);
bCreateWindow = true;
PendingWindow = (ANativeWindow*)Event.Data;
break;
case APP_EVENT_STATE_WINDOW_RESIZED:
bWindowChanged = true;
break;
case APP_EVENT_STATE_WINDOW_CHANGED:
bWindowChanged = true;
break;
case APP_EVENT_STATE_SAVE_STATE:
bSaveState = true; //todo android: handle save state.
break;
case APP_EVENT_STATE_WINDOW_DESTROYED:
if (GEngine->HMDDevice.IsValid() && GEngine->HMDDevice->IsHMDConnected())
{
// delay the destruction until after the renderer teardown on GearVR
bDestroyWindow = true;
}
else
{
FAndroidAppEntry::DestroyWindow();
FPlatformMisc::SetHardwareWindow(NULL);
}
bHaveWindow = false;
break;
case APP_EVENT_STATE_ON_START:
//doing nothing here
break;
case APP_EVENT_STATE_ON_DESTROY:
FCoreDelegates::ApplicationWillTerminateDelegate.Broadcast();
GIsRequestingExit = true; //destroy immediately. Game will shutdown.
break;
case APP_EVENT_STATE_ON_STOP:
bHaveGame = false;
break;
case APP_EVENT_STATE_ON_PAUSE:
bHaveGame = false;
break;
case APP_EVENT_STATE_ON_RESUME:
bHaveGame = true;
break;
// window focus events that follow their own heirarchy, and might or might not respect App main events heirarchy
case APP_EVENT_STATE_WINDOW_GAINED_FOCUS:
bWindowInFocus = true;
break;
case APP_EVENT_STATE_WINDOW_LOST_FOCUS:
bWindowInFocus = false;
break;
default:
UE_LOG(LogAndroidEvents, Display, TEXT("Application Event : %u not handled. "), Event.State);
}
if (bCreateWindow)
{
// wait until activity is in focus.
if (bWindowInFocus)
{
ExecWindowCreated();
bCreateWindow = false;
bHaveWindow = true;
}
}
if (bWindowChanged)
{
// wait until window is valid and created.
if(FPlatformMisc::GetHardwareWindow() != NULL)
{
if(GEngine && GEngine->GameViewport && GEngine->GameViewport->ViewportFrame)
{
ExecWindowChanged();
bWindowChanged = false;
bHaveWindow = true;
}
}
}
if (!bRunning && bHaveWindow && bHaveGame)
{
ResumeRendering();
ResumeAudio();
// broadcast events after the rendering thread has resumed
FCoreDelegates::ApplicationHasEnteredForegroundDelegate.Broadcast();
FCoreDelegates::ApplicationHasReactivatedDelegate.Broadcast();
bRunning = true;
}
else if (bRunning && (!bHaveWindow || !bHaveGame))
{
// broadcast events before rendering thred suspends
FCoreDelegates::ApplicationWillDeactivateDelegate.Broadcast();
FCoreDelegates::ApplicationWillEnterBackgroundDelegate.Broadcast();
PauseRendering();
PauseAudio();
bRunning = false;
}
if (bDestroyWindow)
{
FAndroidAppEntry::DestroyWindow();
FPlatformMisc::SetHardwareWindow(NULL);
bDestroyWindow = false;
}
}
if (!bRunning && FirstInitialized)
{
EventHandlerEvent->Wait();
}
}
