void Platform::setWindowFullscreen(PlatformWindow *window, bool fullscreen) {
u32 value = 0;
if(!fullscreen) value = SDL_WINDOW_FULLSCREEN_DESKTOP;
SDL_SetWindowFullscreen((SDL_Window *)window->handle, value);
}
int
SDL_WM_ToggleFullScreen(SDL_Surface * surface)
{
int length;
void *pixels;
Uint8 *src, *dst;
int row;
int window_w;
int window_h;
if (!SDL_PublicSurface) {
SDL_SetError("SDL_SetVideoMode() hasn't been called");
return 0;
}
/* Copy the old bits out */
length = SDL_PublicSurface->w * SDL_PublicSurface->format->BytesPerPixel;
pixels = SDL_malloc(SDL_PublicSurface->h * length);
if (pixels && SDL_PublicSurface->pixels) {
src = (Uint8*)SDL_PublicSurface->pixels;
dst = (Uint8*)pixels;
for (row = 0; row < SDL_PublicSurface->h; ++row) {
SDL_memcpy(dst, src, length);
src += SDL_PublicSurface->pitch;
dst += length;
}
}
/* Do the physical mode switch */
if (SDL_GetWindowFlags(SDL_VideoWindow) & SDL_WINDOW_FULLSCREEN) {
if (SDL_SetWindowFullscreen(SDL_VideoWindow, 0) < 0) {
return 0;
}
SDL_PublicSurface->flags &= ~SDL_FULLSCREEN;
} else {
if (SDL_SetWindowFullscreen(SDL_VideoWindow, 1) < 0) {
return 0;
}
SDL_PublicSurface->flags |= SDL_FULLSCREEN;
}
/* Recreate the screen surface */
SDL_WindowSurface = SDL_GetWindowSurface(SDL_VideoWindow);
if (!SDL_WindowSurface) {
/* We're totally hosed... */
return 0;
}
/* Center the public surface in the window surface */
SDL_GetWindowSize(SDL_VideoWindow, &window_w, &window_h);
SDL_VideoViewport.x = (window_w - SDL_VideoSurface->w)/2;
SDL_VideoViewport.y = (window_h - SDL_VideoSurface->h)/2;
SDL_VideoViewport.w = SDL_VideoSurface->w;
SDL_VideoViewport.h = SDL_VideoSurface->h;
/* Do some shuffling behind the application's back if format changes */
if (SDL_VideoSurface->format->format != SDL_WindowSurface->format->format) {
if (SDL_ShadowSurface) {
if (SDL_ShadowSurface->format->format == SDL_WindowSurface->format->format) {
/* Whee! We don't need a shadow surface anymore! */
SDL_VideoSurface->flags &= ~SDL_DONTFREE;
SDL_FreeSurface(SDL_VideoSurface);
SDL_free(SDL_ShadowSurface->pixels);
SDL_VideoSurface = SDL_ShadowSurface;
SDL_VideoSurface->flags |= SDL_PREALLOC;
SDL_ShadowSurface = NULL;
} else {
/* No problem, just change the video surface format */
SDL_FreeFormat(SDL_VideoSurface->format);
SDL_VideoSurface->format = SDL_WindowSurface->format;
SDL_VideoSurface->format->refcount++;
SDL_InvalidateMap(SDL_ShadowSurface->map);
}
} else {
/* We can make the video surface the shadow surface */
SDL_ShadowSurface = SDL_VideoSurface;
SDL_ShadowSurface->pitch = SDL_CalculatePitch(SDL_ShadowSurface);
SDL_ShadowSurface->pixels = SDL_malloc(SDL_ShadowSurface->h * SDL_ShadowSurface->pitch);
if (!SDL_ShadowSurface->pixels) {
/* Uh oh, we're hosed */
SDL_ShadowSurface = NULL;
return 0;
}
SDL_ShadowSurface->flags &= ~SDL_PREALLOC;
SDL_VideoSurface = SDL_CreateRGBSurfaceFrom(NULL, 0, 0, 32, 0, 0, 0, 0, 0);
SDL_VideoSurface->flags = SDL_ShadowSurface->flags;
SDL_VideoSurface->flags |= SDL_PREALLOC;
SDL_FreeFormat(SDL_VideoSurface->format);
SDL_VideoSurface->format = SDL_WindowSurface->format;
SDL_VideoSurface->format->refcount++;
SDL_VideoSurface->w = SDL_ShadowSurface->w;
SDL_VideoSurface->h = SDL_ShadowSurface->h;
}
}
/* Update the video surface */
SDL_VideoSurface->pitch = SDL_WindowSurface->pitch;
SDL_VideoSurface->pixels = (void *)((Uint8 *)SDL_WindowSurface->pixels +
SDL_VideoViewport.y * SDL_VideoSurface->pitch +
SDL_VideoViewport.x * SDL_VideoSurface->format->BytesPerPixel);
SDL_SetClipRect(SDL_VideoSurface, NULL);
/* Copy the old bits back */
if (pixels) {
src = (Uint8*)pixels;
dst = (Uint8*)SDL_PublicSurface->pixels;
for (row = 0; row < SDL_PublicSurface->h; ++row) {
SDL_memcpy(dst, src, length);
src += length;
dst += SDL_PublicSurface->pitch;
}
SDL_Flip(SDL_PublicSurface);
SDL_free(pixels);
}
/* We're done! */
return 1;
}
void Game::Run(){
if (storedState != NULL){
stateStack.emplace(storedState);
storedState =NULL;
}
while (!SDL_QuitRequested() and not stateStack.top()->RequestedQuit()){
restart_cycle:
frameStart = dt;
CalculateDeltaTime();
InputManager::GetInstance().Update();
if (ConfigManager::GetInstance().IsResized())
goto restart_cycle;
Update();
if (InputManager::GetInstance().KeyPress(SDLK_F11)){
static bool full = false;
if (!full)
SDL_SetWindowFullscreen(window, SDL_TRUE);
else
SDL_SetWindowFullscreen(window, SDL_FALSE);
full = !full;
}
Render();
SDL_RenderPresent(GetRenderer() );
//Limitar dinamicamente o tempo de cada frame para atingir sempre que possivel 30 fps
float n = GetDeltaTime()*100.0;
if (stateStack.top()->RequestedDeleted()){
if (stateStack.empty() && storedState == NULL){
break;
}else{
stateStack.pop();
}
}
if (storedState != NULL){
stateStack.emplace(storedState);
stateStack.top()->Begin();
storedState =NULL;
}
n = n-(1000.0/MAXFPS);
n = n < 0 ? 0 : n;
n = (1000.0/MAXFPS)-n < 0 ? 0 : n;
//SDL_Delay( std::max( (1000.0/MAXFPS)-n - 5, 0.0) );
frames++;
UpdateTitleAsFps((1000.0/MAXFPS)-n );
}
isClosing = true;
};
rserr_t R_ChangeDisplaySettings( int width, int height, qboolean fullscreen )
{
#ifdef XASH_SDL
SDL_DisplayMode displayMode;
SDL_GetCurrentDisplayMode(0, &displayMode);
#ifdef __ANDROID__
width = displayMode.w;
height = displayMode.h;
fullscreen = false;
#endif
R_SaveVideoMode( width, height );
// check our desktop attributes
glw_state.desktopBitsPixel = SDL_BITSPERPIXEL(displayMode.format);
glw_state.desktopWidth = displayMode.w;
glw_state.desktopHeight = displayMode.h;
glState.fullScreen = fullscreen;
glState.wideScreen = true; // V_AdjustFov will check for widescreen
if(!host.hWnd)
{
if( !VID_CreateWindow( width, height, fullscreen ) )
return rserr_invalid_mode;
}
#ifndef __ANDROID__
else if( fullscreen )
{
SDL_DisplayMode want, got;
want.w = width;
want.h = height;
want.driverdata = NULL;
want.format = want.refresh_rate = 0; // don't care
if( !SDL_GetClosestDisplayMode(0, &want, &got) )
return rserr_invalid_mode;
MsgDev(D_NOTE, "Got closest display mode: %ix%i@%i\n", got.w, got.h, got.refresh_rate);
if( ( SDL_GetWindowFlags(host.hWnd) & SDL_WINDOW_FULLSCREEN ) == SDL_WINDOW_FULLSCREEN)
if( SDL_SetWindowFullscreen(host.hWnd, 0) == -1 )
return rserr_invalid_fullscreen;
if( SDL_SetWindowDisplayMode(host.hWnd, &got) )
return rserr_invalid_mode;
if( SDL_SetWindowFullscreen(host.hWnd, SDL_WINDOW_FULLSCREEN) == -1 )
return rserr_invalid_fullscreen;
R_ChangeDisplaySettingsFast( got.w, got.h );
}
else
{
if( SDL_SetWindowFullscreen(host.hWnd, 0) )
return rserr_invalid_fullscreen;
SDL_SetWindowSize(host.hWnd, width, height);
R_ChangeDisplaySettingsFast( width, height );
}
#endif
#endif // XASH_SDL
return rserr_ok;
}
/*
* Initializes the OpenGL window
*/
static qboolean
GLimp_InitGraphics(qboolean fullscreen)
{
int flags;
int msaa_samples;
int stencil_bits;
int width, height;
char title[24];
if (GetWindowSize(&width, &height) && (width == vid.width) && (height == vid.height))
{
/* If we want fullscreen, but aren't */
if (fullscreen != IsFullscreen())
{
#if SDL_VERSION_ATLEAST(2, 0, 0)
SDL_SetWindowFullscreen(window, fullscreen ? SDL_WINDOW_FULLSCREEN : 0);
#else
SDL_WM_ToggleFullScreen(window);
#endif
Cvar_SetValue("vid_fullscreen", fullscreen);
}
/* Are we now? */
if (fullscreen == IsFullscreen())
{
return true;
}
}
/* Is the surface used? */
if (window)
{
#if SDL_VERSION_ATLEAST(2, 0, 0)
SDL_GL_DeleteContext(context);
SDL_DestroyWindow(window);
#else
SDL_FreeSurface(window);
#endif
}
/* Create the window */
VID_NewWindow(vid.width, vid.height);
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
if (gl_msaa_samples->value)
{
msaa_samples = gl_msaa_samples->value;
if (SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1) < 0)
{
Com_Printf("MSAA is unsupported: %s\n", SDL_GetError());
Cvar_SetValue ("gl_msaa_samples", 0);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 0);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 0);
}
else if (SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, msaa_samples) < 0)
{
Com_Printf("MSAA %ix is unsupported: %s\n", msaa_samples, SDL_GetError());
Cvar_SetValue("gl_msaa_samples", 0);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 0);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 0);
}
}
/* Initiate the flags */
flags = SDL_OPENGL;
if (fullscreen)
{
flags |= SDL_FULLSCREEN;
}
#if !SDL_VERSION_ATLEAST(2, 0, 0)
/* For SDL1.2, these things must be done before creating the window */
/* Set the icon */
SetSDLIcon();
/* Set vsync */
SDL_GL_SetAttribute(SDL_GL_SWAP_CONTROL, gl_swapinterval->value ? 1 : 0);
#endif
while (1)
{
if (!CreateSDLWindow(flags))
{
if (gl_msaa_samples->value)
{
VID_Printf(PRINT_ALL, "SDL SetVideoMode failed: %s\n",
SDL_GetError());
VID_Printf(PRINT_ALL, "Reverting to %s gl_mode %i (%ix%i) without MSAA.\n",
(flags & SDL_FULLSCREEN) ? "fullscreen" : "windowed",
(int)Cvar_VariableValue("gl_mode"), vid.width, vid.height);
/* Try to recover */
Cvar_SetValue("gl_msaa_samples", 0);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 0);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 0);
}
else if (vid.width != 640 || vid.height != 480 || (flags & SDL_FULLSCREEN))
{
VID_Printf(PRINT_ALL, "SDL SetVideoMode failed: %s\n",
SDL_GetError());
VID_Printf(PRINT_ALL, "Reverting to windowed gl_mode 4 (640x480).\n");
/* Try to recover */
Cvar_SetValue("gl_mode", 4);
Cvar_SetValue("vid_fullscreen", 0);
vid.width = 640;
vid.height = 480;
flags &= ~SDL_FULLSCREEN;
}
else
{
VID_Error(ERR_FATAL, "Failed to revert to gl_mode 4. Exiting...\n");
return false;
}
}
else
{
break;
}
}
if (gl_msaa_samples->value)
{
if (SDL_GL_GetAttribute(SDL_GL_MULTISAMPLESAMPLES, &msaa_samples) == 0)
{
Cvar_SetValue("gl_msaa_samples", msaa_samples);
}
}
#if SDL_VERSION_ATLEAST(2, 0, 0)
/* For SDL2, these things must be done after creating the window */
/* Set the icon */
SetSDLIcon();
/* Set vsync - TODO: -1 could be set for "late swap tearing" */
SDL_GL_SetSwapInterval(gl_swapinterval->value ? 1 : 0);
#endif
/* Initialize the stencil buffer */
if (!SDL_GL_GetAttribute(SDL_GL_STENCIL_SIZE, &stencil_bits))
{
VID_Printf(PRINT_ALL, "Got %d bits of stencil.\n", stencil_bits);
if (stencil_bits >= 1)
{
have_stencil = true;
}
}
/* Initialize hardware gamma */
InitGamma();
/* Window title */
snprintf(title, sizeof(title), "Yamagi Quake II %s", YQ2VERSION);
#if SDL_VERSION_ATLEAST(2, 0, 0)
SDL_SetWindowTitle(window, title);
#else
SDL_WM_SetCaption(title, title);
#endif
/* No cursor */
SDL_ShowCursor(0);
return true;
}
void Window::makeWindowed()
{
if(isLoaded())
SDL_SetWindowFullscreen(win, 0);
removeInitFlags(FULLSCREEN | FULLSCREEN_DESKTOP);
}
void Window_setFullScreen() {
SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN);
}
void startscreen(SDL_Window *screen,uint *state,uint *grapset,uint *fullscreen) {
/* Renderer (with VSync, nice !) */
SDL_Renderer *renderer = SDL_CreateRenderer(screen, -1, SDL_RENDERER_PRESENTVSYNC|SDL_RENDERER_ACCELERATED);
SDL_SetHint("SDL_HINT_RENDER_SCALE_QUALITY", "0");
SDL_RenderSetLogicalSize(renderer, 256, 192);
uint exit = 0;
uint musicplay = 0;
SDL_Rect srcintro = {0,0,256,192};
SDL_Rect desintro = {0,0,256,192};
SDL_Event keyp;
/* Loading PNG */
SDL_Texture *intro = IMG_LoadTexture(renderer, DATADIR "/graphics/intro.png");
SDL_Texture *intromd = IMG_LoadTexture(renderer, DATADIR "/graphics/intromd.png");
/* Load audio */
Mix_Music *music = Mix_LoadMUS(DATADIR "/sounds/MainTitleN.ogg");
while (exit != 1) {
/* Cleaning the renderer */
SDL_RenderClear(renderer);
/* Put image on renderer */
if (*grapset == 0)
SDL_RenderCopy(renderer, intro, &srcintro, &desintro);
else
SDL_RenderCopy(renderer, intromd, &srcintro, &desintro);
/* Flip ! */
SDL_RenderPresent(renderer);
/* Play music if required */
if (musicplay == 0) {
musicplay = 1;
Mix_PlayMusic(music, 0);
}
/* Check keyboard */
if ( SDL_PollEvent(&keyp) ) {
if (keyp.type == SDL_KEYDOWN) { /* Key pressed */
if (keyp.key.keysym.sym == SDLK_c) { /* Change graphic set */
if (*grapset == 0)
*grapset = 1;
else
*grapset = 0;
}
if (keyp.key.keysym.sym == SDLK_i) { /* Show instructions */
if (srcintro.y == 0)
srcintro.y = 192;
else {
srcintro.y = 0;
musicplay = 0;
}
}
if (keyp.key.keysym.sym == SDLK_f) { /* Switch fullscreen/windowed */
if (*fullscreen == 0) {
SDL_SetWindowFullscreen(screen,SDL_WINDOW_FULLSCREEN_DESKTOP);
*fullscreen = 1;
}
else {
SDL_SetWindowFullscreen(screen,0);
*fullscreen = 0;
}
}
if (keyp.key.keysym.sym == SDLK_SPACE) { /* Start game */
*state = 1;
exit = 1;
}
if (keyp.key.keysym.sym == SDLK_ESCAPE) { /* Exit game */
exit = 1;
*state = 6;
}
}
}
}
/* Cleaning */
SDL_DestroyTexture(intro);
SDL_DestroyTexture(intromd);
SDL_DestroyRenderer(renderer);
}
void openvox::Window::setFullscreen(bool useFullscreen, bool overrideCheck /*= false*/) {
if (overrideCheck || m_displayMode.isFullscreen != useFullscreen) {
m_displayMode.isFullscreen = useFullscreen;
SDL_SetWindowFullscreen((SDL_Window*)m_window, m_displayMode.isFullscreen ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0);
}
}
/* check key */
void keyPressed( SDL_Keysym* keysym )
{
switch ( keysym->sym ) {
case SDLK_ESCAPE:
closePlayer(); //close
break;
case SDLK_SPACE:
WV_playStream(stream); //play
break;
case SDLK_BACKSPACE:
WV_pauseStream(stream); //pause
break;
case SDLK_KP_PLUS:
WV_shiftDBVolume(stream, +1); //encrease volume
break;
case SDLK_KP_MINUS:
WV_shiftDBVolume(stream, -1); //decrease volume
break;
case SDLK_f:
if(!fullscreenFlag){ //toggle fullscreen
fullscreenFlag = 1;
SDL_ShowCursor(SDL_DISABLE);
SDL_SetWindowFullscreen(screen, SDL_TRUE);
SDL_RenderSetViewport(screenRenderer, NULL);
if(streamObj)
WV_resetStreamRendererOutput(streamObj, screenRenderer, NULL);
}
else{
fullscreenFlag = 0;
SDL_ShowCursor(SDL_ENABLE);
SDL_SetWindowFullscreen(screen, SDL_FALSE);
SDL_RenderSetViewport(screenRenderer, NULL);
if(streamObj)
WV_resetStreamRendererOutput(streamObj, screenRenderer, NULL);
}
break;
/********/
/* seek */
/********/
uint32_t seekShift; //will be converted in milliseconds
int seekDirection;
case SDLK_RIGHT:
seekShift = 10;
seekDirection = WV_SEEK_FORWARD;
goto do_seek;
case SDLK_LEFT:
seekShift = 10;
seekDirection = WV_SEEK_BACKWARD;
goto do_seek;
case SDLK_UP:
seekShift = 60;
seekDirection = WV_SEEK_FORWARD;
goto do_seek;
case SDLK_DOWN:
seekShift = 60;
seekDirection = WV_SEEK_BACKWARD;
goto do_seek;
do_seek:
seekShift *= 1000;
WV_rseekStream(stream, seekShift, seekDirection);
break;
default:
break;
}
}
int
SDL2TestApplication::run()
{
m_window = SDL_CreateWindow("SDL2TestApplication",
SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED,
0, 0, // size shouldn't matter with fullscreen mode
SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL | SDL_WINDOW_FULLSCREEN);
if (m_window == NULL) {
printf("Could not create window: %s\n", SDL_GetError());
return 1;
}
int w, h;
SDL_GetWindowSize(m_window, &w, &h);
printf("Window size after create: (%d, %d)\n", w, h);
#if 0
SDL_SetWindowFullscreen(window, SDL_FALSE);
SDL_GetWindowSize(window, &w, &h);
printf("Window size after fullscreen off: (%d, %d)\n", w, h);
SDL_SetWindowSize(window, 200, 200);
SDL_GetWindowSize(window, &w, &h);
printf("Window size after resize: (%d, %d)\n", w, h);
SDL_SetWindowFullscreen(window, SDL_TRUE);
SDL_GetWindowSize(window, &w, &h);
printf("Window size after fullscreen on: (%d, %d)\n", w, h);
#endif
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, m_major);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, m_minor);
m_gl_context = SDL_GL_CreateContext(m_window);
initGL();
resizeGL(w, h);
std::vector<TouchPoint>::iterator it;
SDL_Event event;
int quit = 0;
while (!quit) {
while (SDL_PollEvent(&event)) {
switch (event.type) {
case SDL_QUIT:
quit = 1;
break;
case SDL_WINDOWEVENT:
printf("Window event: %d (%d, %d)\n", event.window.event,
event.window.data1, event.window.data2);
break;
case SDL_FINGERDOWN: {
TouchPoint touch(event.tfinger.fingerId,
event.tfinger.x, event.tfinger.y);
m_touches.push_back(touch);
onPressed(touch);
printf("Finger down: (%.2f, %.2f)\n", touch.x, touch.y);
break;
}
case SDL_FINGERUP:
case SDL_FINGERMOTION:
for (it=m_touches.begin(); it != m_touches.end(); ++it) {
if (it->id == event.tfinger.fingerId) {
if (event.type == SDL_FINGERMOTION) {
it->x = event.tfinger.x;
it->y = event.tfinger.y;
printf("finger move: (%.2f, %.2f)\n", it->x, it->y);
} else {
printf("Finger up: (%.2f, %.2f)\n", it->x, it->y);
m_touches.erase(it);
}
break;
}
}
break;
default:
printf("SDL Event: %d\n", event.type);
break;
}
}
if (quit) {
/* Application has to quit - don't render anymore */
break;
}
renderGL();
SDL_GL_SwapWindow(m_window);
SDL_Delay(10);
}
SDL_GL_DeleteContext(m_gl_context);
SDL_DestroyWindow(m_window);
SDL_Quit();
return 0;
}
inline void
SDLHandleUserInput(SDL_Event *Event,
game_code *GameCode,
game_memory *GameMemory,
keyboard_input *KeyboardInput,
gamepad_input *GamePadInput) {
int KeyCode = Event->key.keysym.sym;
uint8 GamePadButton = Event->cbutton.button;
const uint8 *KeyState = SDL_GetKeyboardState(NULL);
switch(Event->type) {
case SDL_KEYDOWN:
if(KeyCode == SDLK_ESCAPE) {
HandleButtonPress(&KeyboardInput->Escape);
GlobalRunning = false;
}
if(KeyCode == SDLK_a) {
HandleButtonPress(&KeyboardInput->A);
UnloadGameCode(GameCode);
*GameCode = LoadGameCode();
GameMemory->IsInitialized = false;
}
if(KeyState[SDL_SCANCODE_LALT] && KeyState[SDL_SCANCODE_RETURN] ) {
if(!Fullscreen){
SDL_SetWindowFullscreen(SDL_GetWindowFromID(Event->window.windowID),
SDL_WINDOW_FULLSCREEN);
SDL_SetRelativeMouseMode((SDL_bool)SDL_ENABLE);
Fullscreen = true;
} else {
SDL_SetWindowFullscreen(SDL_GetWindowFromID(Event->window.windowID), 0);
SDL_SetRelativeMouseMode((SDL_bool)SDL_DISABLE);
Fullscreen = false;
}
}
if(KeyCode == SDLK_b) {
HandleButtonPress(&KeyboardInput->B);
}
if(KeyCode == SDLK_f) {
HandleButtonPress(&KeyboardInput->F);
}
if(KeyCode == SDLK_UP) {
HandleButtonPress(&KeyboardInput->Up);
}
if(KeyCode == SDLK_DOWN) {
HandleButtonPress(&KeyboardInput->Down);
}
if(KeyCode == SDLK_LEFT) {
HandleButtonPress(&KeyboardInput->Left);
}
if(KeyCode == SDLK_RIGHT) {
HandleButtonPress(&KeyboardInput->Right);
}
break;
case SDL_KEYUP:
if(KeyCode == SDLK_ESCAPE) {
HandleButtonRelease(&KeyboardInput->Escape);
}
if(KeyCode == SDLK_b) {
HandleButtonRelease(&KeyboardInput->B);
}
if(KeyCode == SDLK_f) {
HandleButtonRelease(&KeyboardInput->F);
}
if(KeyCode == SDLK_a) {
HandleButtonRelease(&KeyboardInput->A);
}
if(KeyCode == SDLK_UP) {
HandleButtonRelease(&KeyboardInput->Up);
}
if(KeyCode == SDLK_DOWN) {
HandleButtonRelease(&KeyboardInput->Down);
}
if(KeyCode == SDLK_LEFT) {
HandleButtonRelease(&KeyboardInput->Left);
}
if(KeyCode == SDLK_RIGHT) {
HandleButtonRelease(&KeyboardInput->Right);
}
break;
case SDL_CONTROLLERBUTTONDOWN:
if(GamePadButton == SDL_CONTROLLER_BUTTON_A) {
HandleButtonPress(&GamePadInput->AButton);
}
if(GamePadButton == SDL_CONTROLLER_BUTTON_B) {
HandleButtonPress(&GamePadInput->BButton);
}
if(GamePadButton == SDL_CONTROLLER_BUTTON_X) {
HandleButtonPress(&GamePadInput->XButton);
}
if(GamePadButton == SDL_CONTROLLER_BUTTON_Y) {
HandleButtonPress(&GamePadInput->YButton);
}
break;
case SDL_CONTROLLERBUTTONUP:
if(GamePadButton == SDL_CONTROLLER_BUTTON_A) {
HandleButtonRelease(&GamePadInput->AButton);
}
if(GamePadButton == SDL_CONTROLLER_BUTTON_B) {
HandleButtonRelease(&GamePadInput->BButton);
GlobalRunning = false;
}
if(GamePadButton == SDL_CONTROLLER_BUTTON_X) {
HandleButtonRelease(&GamePadInput->XButton);
}
if(GamePadButton == SDL_CONTROLLER_BUTTON_Y) {
HandleButtonRelease(&GamePadInput->YButton);
}
break;
}
// NOTE(Redab): Get values from gamepad joysticks and normalize.
real32 LSX = (real32)SDL_GameControllerGetAxis(GamePadHandle, SDL_CONTROLLER_AXIS_LEFTX);
if(LSX < 0) {
GamePadInput->LeftStick.X = LSX / 32768.0f;
} else {
GamePadInput->LeftStick.X = LSX / 32767.0f;
}
real32 LSY = (real32)SDL_GameControllerGetAxis(GamePadHandle, SDL_CONTROLLER_AXIS_LEFTY);
if(LSY < 0) {
GamePadInput->LeftStick.Y = LSY / 32768.0f;
} else {
GamePadInput->LeftStick.Y = LSY / 32767.0f;
}
real32 RSX = (real32)SDL_GameControllerGetAxis(GamePadHandle, SDL_CONTROLLER_AXIS_RIGHTX);
if(RSX < 0) {
GamePadInput->RightStick.X = RSX / 32768.0f;
} else {
GamePadInput->RightStick.X = RSX / 32767.0f;
}
real32 RSY = (real32)SDL_GameControllerGetAxis(GamePadHandle, SDL_CONTROLLER_AXIS_RIGHTY);
if(RSY < 0) {
GamePadInput->RightStick.Y = RSY / 32768.0f;
} else {
GamePadInput->RightStick.Y = RSY / 32767.0f;
}
}
int main()
{
// Initialize SDL's Video subsystem
if (SDL_Init(SDL_INIT_VIDEO) < 0 )
{
// Or die on error
SDLErrorExit("Unable to initialize SDL");
}
// now get the size of the display and create a window we need to init the video
SDL_Rect rect;
SDL_GetDisplayBounds(0,&rect);
// now create our window
SDL_Window *window=SDL_CreateWindow("SDLNGL",
SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED,
rect.w/2,
rect.h/2,
SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE
);
// check to see if that worked or exit
if (!window)
{
SDLErrorExit("Unable to create window");
}
// Create our opengl context and attach it to our window
SDL_GLContext glContext=createOpenGLContext(window);
if(!glContext)
{
SDLErrorExit("Problem creating OpenGL context");
}
// make this our current GL context (we can have more than one window but in this case not)
SDL_GL_MakeCurrent(window, glContext);
/* This makes our buffer swap syncronized with the monitor's vertical refresh */
SDL_GL_SetSwapInterval(1);
// we need to initialise the NGL lib which will load all of the OpenGL functions, this must
// be done once we have a valid GL context but before we call any GL commands. If we dont do
// this everything will crash
ngl::NGLInit::instance();
// now clear the screen and swap whilst NGL inits (which may take time)
glClear(GL_COLOR_BUFFER_BIT);
SDL_GL_SwapWindow(window);
// flag to indicate if we need to exit
bool quit=false;
// sdl event processing data structure
SDL_Event event;
// now we create an instance of our ngl class, this will init NGL and setup basic
// opengl stuff ext. When this falls out of scope the dtor will be called and cleanup
// our gl stuff
NGLDraw ngl;
// resize the ngl to set the screen size and camera stuff
ngl.resize(rect.w,rect.h);
while(!quit)
{
while ( SDL_PollEvent(&event) )
{
switch (event.type)
{
// this is the window x being clicked.
case SDL_QUIT : quit = true; break;
// process the mouse data by passing it to ngl class
case SDL_MOUSEMOTION : ngl.mouseMoveEvent(event.motion); break;
case SDL_MOUSEBUTTONDOWN : ngl.mousePressEvent(event.button); break;
case SDL_MOUSEBUTTONUP : ngl.mouseReleaseEvent(event.button); break;
case SDL_MOUSEWHEEL : ngl.wheelEvent(event.wheel);
// if the window is re-sized pass it to the ngl class to change gl viewport
// note this is slow as the context is re-create by SDL each time
case SDL_WINDOWEVENT :
int w,h;
// get the new window size
SDL_GetWindowSize(window,&w,&h);
ngl.resize(w,h);
break;
// now we look for a keydown event
case SDL_KEYDOWN:
{
ngl.keyEvent(event.key);
switch( event.key.keysym.sym )
{
// if it's the escape key quit
case SDLK_ESCAPE : quit = true; break;
case SDLK_w : glPolygonMode(GL_FRONT_AND_BACK,GL_LINE); break;
case SDLK_s : glPolygonMode(GL_FRONT_AND_BACK,GL_FILL); break;
case SDLK_f :
SDL_SetWindowFullscreen(window,SDL_TRUE);
glViewport(0,0,rect.w,rect.h);
break;
case SDLK_g : SDL_SetWindowFullscreen(window,SDL_FALSE); break;
default : break;
} // end of key process
} // end of keydown
default : break;
} // end of event switch
} // end of poll events
// now we draw ngl
ngl.update();
ngl.draw();
// swap the buffers
SDL_GL_SwapWindow(window);
}
// now tidy up and exit SDL
SDL_Quit();
}
void EventThread::setFullscreen(SDL_Window *win, bool mode)
{
SDL_SetWindowFullscreen
(win, mode ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0);
fullscreen = mode;
}
void
CommonEvent(CommonState * state, SDL_Event * event, int *done)
{
int i;
if (state->verbose & VERBOSE_EVENT) {
PrintEvent(event);
}
switch (event->type) {
case SDL_WINDOWEVENT:
switch (event->window.event) {
case SDL_WINDOWEVENT_CLOSE:
{
SDL_Window *window = SDL_GetWindowFromID(event->window.windowID);
if (window) {
SDL_DestroyWindow(window);
}
}
break;
}
break;
case SDL_KEYDOWN:
switch (event->key.keysym.sym) {
/* Add hotkeys here */
case SDLK_PRINTSCREEN: {
SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
if (window) {
for (i = 0; i < state->num_windows; ++i) {
if (window == state->windows[i]) {
ScreenShot(state->renderers[i]);
}
}
}
}
break;
case SDLK_c:
if (event->key.keysym.mod & KMOD_CTRL) {
/* Ctrl-C copy awesome text! */
SDL_SetClipboardText("SDL rocks!\nYou know it!");
printf("Copied text to clipboard\n");
}
break;
case SDLK_v:
if (event->key.keysym.mod & KMOD_CTRL) {
/* Ctrl-V paste awesome text! */
char *text = SDL_GetClipboardText();
if (*text) {
printf("Clipboard: %s\n", text);
} else {
printf("Clipboard is empty\n");
}
SDL_free(text);
}
break;
case SDLK_g:
if (event->key.keysym.mod & KMOD_CTRL) {
/* Ctrl-G toggle grab */
SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
if (window) {
SDL_SetWindowGrab(window, !SDL_GetWindowGrab(window));
}
}
break;
case SDLK_m:
if (event->key.keysym.mod & KMOD_CTRL) {
/* Ctrl-M maximize */
SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
if (window) {
Uint32 flags = SDL_GetWindowFlags(window);
if (flags & SDL_WINDOW_MAXIMIZED) {
SDL_RestoreWindow(window);
} else {
SDL_MaximizeWindow(window);
}
}
}
break;
case SDLK_r:
if (event->key.keysym.mod & KMOD_CTRL) {
/* Ctrl-R toggle mouse relative mode */
SDL_SetRelativeMouseMode(!SDL_GetRelativeMouseMode());
}
break;
case SDLK_z:
if (event->key.keysym.mod & KMOD_CTRL) {
/* Ctrl-Z minimize */
SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
if (window) {
SDL_MinimizeWindow(window);
}
}
break;
case SDLK_RETURN:
if (event->key.keysym.mod & KMOD_CTRL) {
/* Ctrl-Enter toggle fullscreen */
SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
if (window) {
Uint32 flags = SDL_GetWindowFlags(window);
if (flags & SDL_WINDOW_FULLSCREEN) {
SDL_SetWindowFullscreen(window, SDL_FALSE);
} else {
SDL_SetWindowFullscreen(window, SDL_TRUE);
}
}
}
break;
case SDLK_ESCAPE:
*done = 1;
break;
default:
break;
}
break;
case SDL_QUIT:
*done = 1;
break;
}
}
static void sdl_fullscreen(void *ctx, int b_fullscreen)
{
platform_ctx *platform = (platform_ctx *)ctx;
/*SDL_Rect bounds, usablebounds;
float hdpi = 0;
float vdpi = 0;
SDL_DisplayMode mode;
uint32_t Rmask, Gmask, Bmask, Amask;
int bpp, i, j, m, n = SDL_GetNumVideoDisplays();
SDL_Log("Number of displays: %d\n", n);
for (i = 0; i < n; ++i)
{
SDL_Log("Display %d: %s\n", i, SDL_GetDisplayName(i));
SDL_zero(bounds);
SDL_GetDisplayBounds(i, &bounds);
SDL_zero(usablebounds);
//SDL_GetDisplayUsableBounds(i, &usablebounds);
SDL_GetDisplayDPI(i, NULL, &hdpi, &vdpi);
SDL_Log("Bounds: %dx%d at %d,%d\n", bounds.w, bounds.h, bounds.x, bounds.y);
//SDL_Log("Usable bounds: %dx%d at %d,%d\n", usablebounds.w, usablebounds.h, usablebounds.x, usablebounds.y);
SDL_Log("DPI: %fx%f\n", hdpi, vdpi);
SDL_GetDesktopDisplayMode(i, &mode);
SDL_PixelFormatEnumToMasks(mode.format, &bpp, &Rmask, &Gmask,
&Bmask, &Amask);
SDL_Log(" Current mode: %dx%d@%dHz, %d bits-per-pixel (%s)\n",
mode.w, mode.h, mode.refresh_rate, bpp,
SDL_GetPixelFormatName(mode.format));
if (Rmask || Gmask || Bmask)
{
SDL_Log(" Red Mask = 0x%.8x\n", Rmask);
SDL_Log(" Green Mask = 0x%.8x\n", Gmask);
SDL_Log(" Blue Mask = 0x%.8x\n", Bmask);
if (Amask)
SDL_Log(" Alpha Mask = 0x%.8x\n", Amask);
}
m = SDL_GetNumDisplayModes(i);
if (m == 0)
{
SDL_Log("No available fullscreen video modes\n");
} else
{
SDL_Log(" Fullscreen video modes:\n");
for (j = 0; j < m; ++j)
{
SDL_GetDisplayMode(i, j, &mode);
SDL_PixelFormatEnumToMasks(mode.format, &bpp, &Rmask,
&Gmask, &Bmask, &Amask);
SDL_Log(" Mode %d: %dx%d@%dHz, %d bits-per-pixel (%s)\n",
j, mode.w, mode.h, mode.refresh_rate, bpp,
SDL_GetPixelFormatName(mode.format));
if (Rmask || Gmask || Bmask) {
SDL_Log(" Red Mask = 0x%.8x\n", Rmask);
SDL_Log(" Green Mask = 0x%.8x\n", Gmask);
SDL_Log(" Blue Mask = 0x%.8x\n", Bmask);
if (Amask)
SDL_Log(" Alpha Mask = 0x%.8x\n", Amask);
}
if (b_fullscreen && 1024 == mode.w && 32 == bpp)
{
SDL_SetWindowDisplayMode(platform->window, &mode);
SDL_SetWindowFullscreen(platform->window, SDL_WINDOW_FULLSCREEN);
return;
}
}
}
}*/
SDL_SetWindowFullscreen(platform->window, b_fullscreen ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0);
}
//-------------------------------------------------------------------------------------------------
int main( int argc, char* args[] )
{
printf("JeZxLee's ''GT-R Twin TurboCharged'' game engine started!\n");
argc = argc; args = args;
if ( SDL_Init(SDL_INIT_EVERYTHING) != 0 )
{
printf( "Unable to initialize SDL2: %s\n", SDL_GetError() );
return(1);
}
else printf("SDL2 initialized.\n");
visuals = new Visuals();
if ( visuals->InitializeWindow() != true ) visuals->CoreFailure = true;
if ( visuals->LoadFontsIntoMemory() != true ) visuals->CoreFailure = true;
if ( visuals->LoadSpritesAndInitialize() != true ) visuals->CoreFailure = true;
input = new Input();
screens = new Screens();
interface = new Interface();
data = new Data();
srand( (unsigned)time(NULL) ); // Place unique time seed into random number generator.
logic = new Logic();
audio = new Audio();
audio->SetupAudio();
data->LoadHighScoresAndOptions();
if (visuals->FullScreenMode == true) SDL_SetWindowFullscreen(visuals->Window, SDL_WINDOW_FULLSCREEN_DESKTOP);
audio->PlayMusic(0, -1);
//-MAIN-LOOP------------------------------------------------------------------------
printf("Main loop started...\n");
while (visuals->CoreFailure != true && input->EXIT_Game != true)
{
input->GetAllUserInput();
visuals->CalculateFramerate();
screens->ProcessScreenToDisplay();
visuals->ProcessFramerate();
}
printf("...Main loop exited\n");
//------------------------------------------------------------------------MAIN-LOOP-
data->SaveHighScoresAndOptions();
delete logic;
delete data;
delete audio;
delete interface;
delete screens;
delete input;
delete visuals;
SDL_Quit();
printf("SDL2 closed.\n");
printf("JeZxLee's ''GT-R Twin TurboCharged'' game engine ended!\n");
return(0);
}
void GraphicsEngine::setFullscreen(bool b) {
SDL_SetWindowFullscreen(window, b ? SDL_WINDOW_FULLSCREEN_DESKTOP : SDL_WINDOW_MAXIMIZED);
}
void Device::applyFullscreen()
{
SDL_SetWindowFullscreen(window, fullscreen ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0);
}
extern SkinSurface*
skin_surface_create_window(int x,
int y,
int w,
int h,
int original_w,
int original_h,
int is_fullscreen)
{
static SkinSurface* result = NULL;
SDL_Window* window = skin_winsys_get_window();
SDL_Renderer* renderer = globals_get_renderer();
D("%s: x=%d y=%d w=%d h=%d original_w=%d original_h=%d is_fullscreen=%d",
__FUNCTION__, x, y, w, h, original_w, original_h, is_fullscreen);
// Textures do not survive window resize events, so
globals_foreach_surface(&_skin_surface_destroy_texture, NULL);
if (!window) {
// NOTE: Don't use SDL_WINDOW_ALLOW_HIGHDPI here. On OS X, this will
// make mouse event coordinates twice smaller than needed
// when running on a high-dpi machine (e.g. recent MacBook Pro),
// making the UI unusable. Note that this doesn't happen on a
// 'low-dpi' device such as a MacPro connected to a 30" monitor.
int window_flags = SDL_WINDOW_OPENGL;
if (is_fullscreen) {
window_flags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
}
window = SDL_CreateWindow("Android emulator",
x, y, w, h,
window_flags);
if (!window) {
panic("Could not create SDL2 window: %s\n", SDL_GetError());
}
skin_winsys_set_window(window);
} else {
if (is_fullscreen) {
SDL_CHECK(SDL_SetWindowFullscreen(window,
SDL_WINDOW_FULLSCREEN_DESKTOP));
#if DEBUG
#endif
} else {
SDL_CHECK(SDL_SetWindowFullscreen(window, 0));
SDL_SetWindowPosition(window, x, y);
SDL_SetWindowSize(window, w, h);
}
}
// Generate renderer
if (!renderer) {
SDL_CHECK(SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "linear"));
renderer = SDL_CreateRenderer(window,
-1,
SDL_RENDERER_ACCELERATED|
SDL_RENDERER_PRESENTVSYNC|
SDL_RENDERER_TARGETTEXTURE);
if (!renderer) {
panic("Could not create renderer: %s\n", SDL_GetError());
}
globals_set_renderer(renderer);
}
SDL_CHECK(SDL_RenderSetLogicalSize(renderer, original_w, original_h));
if (DEBUG && VERBOSE_CHECK(surface)) {
SDL_RendererInfo info;
SDL_CHECK(SDL_GetRendererInfo(renderer, &info));
printf("renderer.name = %s\n", info.name);
printf("renderer.flags = 0x%x\n", info.flags);
printf("renderer.num_texture_formats = %d\n", info.num_texture_formats);
int nn;
for (nn = 0; nn < info.num_texture_formats; ++nn) {
printf(" 0x%x (%s)\n", info.texture_formats[nn],
SDL_GetPixelFormatName(info.texture_formats[nn]));
}
printf("renderer.max_texture_width = %d\n", info.max_texture_width);
printf("renderer.max_texture_height = %d\n", info.max_texture_height);
}
// Compute scaling parameters.
{
int window_x, window_y, window_w, window_h;
SDL_GetWindowSize(window, &window_w, &window_h);
SDL_GetWindowPosition(window, &window_x, &window_y);
D("Window pos=(%d,%d) size=(%d,%d)", window_x, window_y, window_w, window_h);
double x_scale = window_w * 1.0 / original_w;
double y_scale = window_h * 1.0 / original_h;
double scale = (x_scale <= y_scale) ? x_scale : y_scale;
double effective_x = 0.;
double effective_y = 0.;
if (is_fullscreen) {
effective_x = (window_w - original_w * scale) * 0.5;
effective_y = (window_h - original_h * scale) * 0.5;
}
globals_set_window_scale(scale, effective_x, effective_y);
}
SDL_Texture* texture =
SDL_CreateTexture(renderer,
SDL_PIXELFORMAT_ARGB8888,
SDL_TEXTUREACCESS_TARGET,
original_w,
original_h);
if (!texture) {
panic("Could not create window texture: %s", SDL_GetError());
}
SDL_CHECK(SDL_SetRenderTarget(renderer, texture));
SDL_CHECK(SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255));
SDL_CHECK(SDL_RenderClear(renderer));
SDL_CHECK(SDL_SetRenderTarget(renderer, NULL));
SDL_CHECK(SDL_SetRenderDrawColor(renderer, 0, 0, 128, 255));
SDL_CHECK(SDL_RenderClear(renderer));
SDL_CHECK(SDL_RenderCopy(renderer, texture, NULL, NULL));
SDL_RenderPresent(renderer);
if (!result) {
result = _skin_surface_create(NULL, texture, original_w, original_h);
} else {
result->texture = texture;
result->w = original_w;
result->h = original_h;
}
skin_surface_ref(result);
// Ensure all textures are regenerated properly.
globals_foreach_surface(&_skin_surface_reset_texture, renderer);
return result;
}
qboolean VID_CreateWindow( int width, int height, qboolean fullscreen )
{
#ifdef XASH_SDL
static string wndname;
Uint32 wndFlags = SDL_WINDOW_MOUSE_FOCUS | SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE;
Q_strncpy( wndname, GI->title, sizeof( wndname ));
host.hWnd = SDL_CreateWindow(wndname, r_xpos->integer,
r_ypos->integer, width, height, wndFlags);
if( !host.hWnd )
{
MsgDev( D_ERROR, "VID_CreateWindow: couldn't create '%s': %s\n", wndname, SDL_GetError());
// remove MSAA, if it present, because
// window creating may fail on GLX visual choose
if( gl_msaa->integer )
{
Cvar_Set("gl_msaa", "0");
GL_SetupAttributes(); // re-choose attributes
// try again
return VID_CreateWindow( width, height, fullscreen );
}
return false;
}
if( fullscreen )
{
SDL_DisplayMode want, got;
want.w = width;
want.h = height;
want.driverdata = NULL;
want.format = want.refresh_rate = 0; // don't care
if( !SDL_GetClosestDisplayMode(0, &want, &got) )
return false;
MsgDev(D_NOTE, "Got closest display mode: %ix%i@%i\n", got.w, got.h, got.refresh_rate);
if( SDL_SetWindowDisplayMode(host.hWnd, &got) == -1 )
return false;
if( SDL_SetWindowFullscreen(host.hWnd, SDL_WINDOW_FULLSCREEN) == -1 )
return false;
}
host.window_center_x = width / 2;
host.window_center_y = height / 2;
SDL_ShowWindow( host.hWnd );
#else
host.hWnd = 1; //fake window
host.window_center_x = width / 2;
host.window_center_y = height / 2;
#endif
if( !glw_state.initialized )
{
if( !GL_CreateContext( ) )
{
return false;
}
VID_StartupGamma();
}
else
{
if( !GL_UpdateContext( ))
return false;
}
return true;
}
void RenderWindow::SetFullscreen(bool bFullscreen)
{
ATLASSERT(m_spWindow != nullptr);
SDL_SetWindowFullscreen(m_spWindow.get(), bFullscreen ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0);
}
/**
* @brief Responsible for doing a swapbuffers
*/
void GLimp_EndFrame(void)
{
// don't flip if drawing to front buffer
//FIXME: remove this nonesense
if (Q_stricmp(Cvar_VariableString("r_drawBuffer"), "GL_FRONT") != 0)
{
SDL_GL_SwapWindow(main_window);
}
if (r_fullscreen->modified)
{
qboolean fullscreen;
qboolean needToToggle;
// Find out the current state
fullscreen = !!(SDL_GetWindowFlags(main_window) & SDL_WINDOW_FULLSCREEN);
if (r_fullscreen->integer && Cvar_VariableIntegerValue("in_nograb"))
{
Com_Printf("Fullscreen not allowed with in_nograb 1\n");
Cvar_Set("r_fullscreen", "0");
r_fullscreen->modified = qfalse;
}
// Is the state we want different from the current state?
needToToggle = !!r_fullscreen->integer != fullscreen;
if (needToToggle)
{
// SDL_WM_ToggleFullScreen didn't work, so do it the slow way
if (!(SDL_SetWindowFullscreen(main_window, r_fullscreen->integer) >= 0)) // !sdlToggled
{
Cbuf_ExecuteText(EXEC_APPEND, "vid_restart\n");
}
IN_Restart();
}
#ifdef MACOS_X_GAMMA_RESET_FIX
// OS X 10.9 has a bug where toggling in or out of fullscreen mode
// will cause the gamma to reset to the system default after an unknown
// short delay. This little fix simply causes the gamma to be reset
// again after a hopefully-long-enough-delay of 3 seconds.
// Radar 15961845
gammaResetTime = CL_ScaledMilliseconds() + 3000;
#endif
r_fullscreen->modified = qfalse;
}
#ifdef MACOS_X_GAMMA_RESET_FIX
if ((gammaResetTime != 0) && (gammaResetTime < CL_ScaledMilliseconds()))
{
// Circuitous way of resetting the gamma to its current value.
char old[6] = { 0 };
Q_strncpyz(old, va("%i", Cvar_VariableIntegerValue("r_gamma")), 5);
if (strlen(old))
{
Cvar_Set("r_gamma", "1");
Cvar_Set("r_gamma", old);
}
gammaResetTime = 0;
}
#endif
}
static void event_sdl(player_ctx_t *ctx, int *is_min)
{
SDL_Event event;
double x_scale, y_scale;
int w, h;
event_code_t code = L_EVENT_NONE;
uint32_t data = 0;
while (SDL_PollEvent(&event))
{
switch (event.type)
{
case SDL_WINDOWEVENT:
switch (event.window.event)
{
case SDL_WINDOWEVENT_MINIMIZED:
*is_min = 1;
break;
case SDL_WINDOWEVENT_MAXIMIZED:
case SDL_WINDOWEVENT_RESTORED:
*is_min = 0;
break;
case SDL_WINDOWEVENT_SIZE_CHANGED:
w = event.window.data1;
h = event.window.data2;
x_scale = (double)w / (double)ctx->width;
y_scale = (double)h / (double)ctx->height;
if (x_scale > y_scale)
{
ctx->vp_rect.w = y_scale * ctx->width;
ctx->vp_rect.h = y_scale * ctx->height;
ctx->vp_rect.x = (w - ctx->vp_rect.w) / 2;
ctx->vp_rect.y = 0;
}
else
{
ctx->vp_rect.w = x_scale * ctx->width;
ctx->vp_rect.h = x_scale * ctx->height;
ctx->vp_rect.x = 0;
ctx->vp_rect.y = (h - ctx->vp_rect.h) / 2;
}
break;
default:
break;
}
break;
case SDL_KEYDOWN:
break;
case SDL_KEYUP:
switch (event.key.keysym.scancode)
{
case SDL_SCANCODE_Q:
code = L_EVENT_QUIT;
break;
case SDL_SCANCODE_SPACE:
code = L_EVENT_PAUSE;
break;
case SDL_SCANCODE_RIGHT:
code = L_EVENT_SEEK_RIGHT;
data = 60;
break;
case SDL_SCANCODE_LEFT:
code = L_EVENT_SEEK_LEFT;
data = 60;
break;
case SDL_SCANCODE_A:
code = L_EVENT_AUDIO_STREEM;
break;
case SDL_SCANCODE_M:
code = L_EVENT_MUTE;
break;
case SDL_SCANCODE_I:
code = L_EVENT_INFO;
break;
default:
break;
}
if (code != L_EVENT_NONE)
{
user_event_t *event;
event = (user_event_t *)malloc(sizeof(user_event_t));
if (event)
{
event->code = code;
event->data = data;
queue_push(ctx->common.event_queue, (queue_node_t *)event);
}
break;
}
if (event.key.keysym.scancode == SDL_SCANCODE_F)
SDL_SetWindowFullscreen(ctx->window, SDL_WINDOW_FULLSCREEN_DESKTOP);
else if (event.key.keysym.scancode == SDL_SCANCODE_ESCAPE)
SDL_SetWindowFullscreen(ctx->window, 0);
break;
default:
break;
}
}
}
void LWindow::handleEvent(SDL_Event &e) {
//Window event occured
if(e.type == SDL_WINDOWEVENT) {
//Caption update flag
bool updateCaption = false;
switch(e.window.event) {
//Get new dimensions and repaint on window size change
case SDL_WINDOWEVENT_SIZE_CHANGED:
m_width = e.window.data1;
m_height = e.window.data2;
SDL_RenderPresent(g_renderer);
break;
//Repaint on exposure
case SDL_WINDOWEVENT_EXPOSED:
SDL_RenderPresent(g_renderer);
break;
//Mouse entered window
case SDL_WINDOWEVENT_ENTER:
m_mouseFocus = true;
updateCaption = true;
break;
//Mouse left window
case SDL_WINDOWEVENT_LEAVE:
m_mouseFocus = false;
updateCaption = true;
//Window has keyboard focus
case SDL_WINDOWEVENT_FOCUS_GAINED:
m_keyboardFocus = true;
updateCaption = true;
break;
//Window lost keyboard focus
case SDL_WINDOWEVENT_FOCUS_LOST:
m_keyboardFocus = false;
updateCaption = true;
break;
//Window minimized
case SDL_WINDOWEVENT_MINIMIZED:
m_minimized = true;
break;
//Window maximized
case SDL_WINDOWEVENT_MAXIMIZED:
m_minimized = false;
break;
//Window restored
case SDL_WINDOWEVENT_RESTORED:
m_minimized = false;
break;
}
//Update window caption with new data
if(updateCaption) {
std::stringstream caption;
caption << "SDL Tutorial - MouseFocus:" << ((m_mouseFocus) ? "On" : "Off") << "KeyboardFocus:" << ((m_keyboardFocus) ? "On" : "Off");
SDL_SetWindowTitle(m_window, caption.str().c_str());
}
} else if (e.type == SDL_KEYDOWN && e.key.keysym.sym == SDLK_RETURN) {
if(m_fullScreen) {
SDL_SetWindowFullscreen(m_window, SDL_FALSE);
m_fullScreen = false;
} else {
SDL_SetWindowFullscreen(m_window, SDL_TRUE);
m_fullScreen = true;
m_minimized = false;
}
}
}
int SetVideoMode(int w, int h, int bpp, bool gl)
{
int flags = SDL_WINDOW_SHOWN | SDL_WINDOW_INPUT_FOCUS;
static bool last_gl = false;
static int last_x = SDL_WINDOWPOS_UNDEFINED;
static int last_y = SDL_WINDOWPOS_UNDEFINED;
if(gl) flags |= SDL_WINDOW_OPENGL;
if(savedata.fullscreen) flags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
if(!(SDL_GetWindowFlags(window) & SDL_WINDOW_FULLSCREEN_DESKTOP))
SDL_GetWindowPosition(window, &last_x, &last_y);
if(window && gl != last_gl)
{
SDL_DestroyWindow(window);
window = NULL;
}
last_gl = gl;
if(renderer) SDL_DestroyRenderer(renderer);
if(texture) SDL_DestroyTexture(texture);
renderer = NULL;
texture = NULL;
if(window)
{
if(savedata.fullscreen)
{
SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN_DESKTOP);
}
else
{
#ifndef WIN // hiding and showing the window is problematic on Windows
if(SDL_GetWindowFlags(window) & SDL_WINDOW_FULLSCREEN_DESKTOP)
SDL_HideWindow(window);
#endif
SDL_SetWindowFullscreen(window, 0);
SDL_SetWindowSize(window, w, h);
SDL_SetWindowPosition(window, last_x, last_y);
SDL_ShowWindow(window);
}
}
else
{
window = SDL_CreateWindow(windowTitle, last_x, last_y, w, h, flags);
if(!window)
{
printf("Error: failed to create window: %s\n", SDL_GetError());
return 0;
}
SDL_Surface* icon = (SDL_Surface*)pngToSurface((void*)openbor_icon_32x32_png.data);
SDL_SetWindowIcon(window, icon);
SDL_FreeSurface(icon);
if(!savedata.fullscreen) SDL_GetWindowPosition(window, &last_x, &last_y);
}
if(!gl)
{
renderer = SDL_CreateRenderer(window, -1, 0);
if(!renderer)
{
printf("Error: failed to create renderer: %s\n", SDL_GetError());
return 0;
}
}
return 1;
}
bool window_set_fullscreen_windowed()
{
if (SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN_DESKTOP) < 0)
printf("Error while setting fullscreen window: %s\n", SDL_GetError());
}
int main(int argc, char **argv)
{
MemStartCheck();
{ char* test = new char[16]; delete[] test; }
grinliz::TestContainers();
{
grinliz::GLString releasePath;
GetSystemPath(GAME_SAVE_DIR, "release_log.txt", &releasePath);
SetReleaseLog(fopen(releasePath.c_str(), "w"));
}
GLOUTPUT_REL(("Altera startup. version'%s'\n", VERSION));
SDL_version compiled;
SDL_version linked;
SDL_VERSION(&compiled);
SDL_GetVersion(&linked);
GLOUTPUT_REL(("SDL version compiled: %d.%d.%d\n", compiled.major, compiled.minor, compiled.patch));
GLOUTPUT_REL(("SDL version linked: %d.%d.%d\n", linked.major, linked.minor, linked.patch));
GLASSERT((linked.major == compiled.major && linked.minor == compiled.minor));
// SDL initialization steps.
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_NOPARACHUTE | SDL_INIT_TIMER | SDL_INIT_AUDIO | SDL_INIT_EVENTS) < 0)
{
fprintf(stderr, "SDL initialization failed: %s\n", SDL_GetError());
exit(1);
}
// OpenGL 4.3 provides full compatibility with OpenGL ES 3.0.
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
#ifdef DEBUG
#if 0 // I was hoping to get to Angle on intel - may still be able to. But
// as is this gets HW mode, which crashes in a function that should
// be supported. The Intel drivers are so terrible. As of this writing,
// you can't specify the DX version of ES:
// http://forums.libsdl.org/viewtopic.php?t=9770&highlight=angle+opengl
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3); // driver supports 2 and 3. Both crash.
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
#endif
#if 0
// 3.0 context.
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
#endif
#if 0
// The trickier 3.2 context.
// No GL_QUADs anymore.
// All the attributes need to be floats.
// No ALPHA textures.
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2);
#endif
#if 0
// In theory the minimum supported version:
// has instancing, and modern shader syntax
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
#endif
#if 0
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
#endif
#endif
if (multisample) {
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, multisample);
}
SDL_DisplayMode displayMode;
SDL_GetCurrentDisplayMode(0, &displayMode);
int screenX = displayMode.w / 8;
int screenY = displayMode.h / 8;
int screenWidth = displayMode.w * 3 / 4;
int screenHeight = displayMode.h * 3 / 4;
if (argc == 3) {
screenWidth = atoi(argv[1]);
screenHeight = atoi(argv[2]);
if (screenWidth <= 0) screenWidth = SCREEN_WIDTH;
if (screenHeight <= 0) screenHeight = SCREEN_HEIGHT;
}
restoreWidth = screenWidth;
restoreHeight = screenHeight;
SDL_Window *screen = SDL_CreateWindow("Altera",
screenX, screenY, screenWidth, screenHeight,
/*SDL_WINDOW_FULLSCREEN | */ SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE);
GLASSERT(screen);
SDL_GL_CreateContext(screen);
int stencil = 0;
int depth = 0;
CHECK_GL_ERROR;
SDL_GL_GetAttribute(SDL_GL_STENCIL_SIZE, &stencil);
SDL_GL_GetAttribute(SDL_GL_DEPTH_SIZE, &depth);
glGetError(); // the above stencil/depth query sometimes does throw an error.
glGetError(); // 2 queries, 2 errors.
CHECK_GL_ERROR;
GLOUTPUT_REL(("SDL screen created. stencil=%d depthBits=%d\n", stencil, depth));
/* Verify there is a surface */
if (!screen) {
fprintf(stderr, "Video mode set failed: %s\n", SDL_GetError());
exit(1);
}
CHECK_GL_ERROR;
glewExperimental = GL_TRUE;
int r = glewInit();
GLASSERT(r == GL_NO_ERROR);
(void)r;
while (glGetError() != GL_NO_ERROR) {
// around again
}
CHECK_GL_ERROR;
const unsigned char* vendor = glGetString(GL_VENDOR);
const unsigned char* renderer = glGetString(GL_RENDERER);
const unsigned char* version = glGetString(GL_VERSION);
GLOUTPUT_REL(("OpenGL vendor: '%s' Renderer: '%s' Version: '%s'\n", vendor, renderer, version));
CHECK_GL_ERROR;
bool done = false;
bool zooming = false;
SDL_Event event;
grinliz::Vector2I mouseDown = { 0, 0 };
grinliz::Vector2I rightMouseDown = { 0, 0 };
int zoomX = 0;
int zoomY = 0;
// Used to compute fingers close, but problems:
// - really to the OS to do that, because of all the tuning
// - the coordinates are in windows normalized, so can't get the physical distance reliably.
//bool fingersClose = true;
int nFingers = 0;
void* game = NewGame(screenWidth, screenHeight, 0);
int modKeys = SDL_GetModState();
U32 tickTimer = 0, lastTick = 0, thisTick = 0;
#ifdef OUTPUT_MOUSE_AND_TOUCH
int value = GetSystemMetrics(SM_DIGITIZER);
if (value & NID_INTEGRATED_TOUCH) GLOUTPUT(("NID_INTEGRATED_TOUCH\n"));
if (value & NID_MULTI_INPUT) GLOUTPUT(("NID_MULTI_INPUT\n"));
if (value & NID_READY) GLOUTPUT(("NID_READY\n"));
#endif
grinliz::Vector2F multiTouchStart = { 0, 0 };
// ---- Main Loop --- //
while (!done) {
while (SDL_PollEvent(&event)) {
switch (event.type)
{
case SDL_WINDOWEVENT:
if (event.window.event == SDL_WINDOWEVENT_RESIZED) {
screenWidth = event.window.data1;
screenHeight = event.window.data2;
GameDeviceLoss(game);
GameResize(game, screenWidth, screenHeight, 0);
}
break;
case SDL_KEYUP:
switch (event.key.keysym.scancode)
{
case SDL_SCANCODE_LCTRL: modKeys = modKeys & (~KMOD_LCTRL); break;
case SDL_SCANCODE_RCTRL: modKeys = modKeys & (~KMOD_RCTRL); break;
case SDL_SCANCODE_LSHIFT: modKeys = modKeys & (~KMOD_LSHIFT); break;
case SDL_SCANCODE_RSHIFT: modKeys = modKeys & (~KMOD_RSHIFT); break;
default:
break;
}
break;
case SDL_KEYDOWN:
{
// sym or scancode? I used a dvorak keyboard, so appreciate
// every day the difference. However, AWSD support is the
// primary thing so scancode is hopefully the better choice.
switch (event.key.keysym.scancode)
{
case SDL_SCANCODE_LCTRL: modKeys = modKeys | KMOD_LCTRL; break;
case SDL_SCANCODE_RCTRL: modKeys = modKeys | KMOD_RCTRL; break;
case SDL_SCANCODE_LSHIFT: modKeys = modKeys | KMOD_LSHIFT; break;
case SDL_SCANCODE_RSHIFT: modKeys = modKeys | KMOD_RSHIFT; break;
case SDL_SCANCODE_F4:
{
int sdlMod = SDL_GetModState();
if (sdlMod & (KMOD_RALT | KMOD_LALT))
done = true;
}
break;
case SDL_SCANCODE_ESCAPE: GameHotKey(game, GAME_HK_ESCAPE); break;
case SDL_SCANCODE_SPACE: GameHotKey(game, GAME_HK_TOGGLE_PAUSE); break;
case SDL_SCANCODE_RETURN: GameHotKey(game, GAME_HK_DEBUG_ACTION); break;
case SDL_SCANCODE_F1: GameHotKey(game, GAME_HK_TOGGLE_DEBUG_TEXT); break;
case SDL_SCANCODE_F2: GameHotKey(game, GAME_HK_TOGGLE_DEBUG_UI); break;
// F3: screenshot
case SDL_SCANCODE_TAB: GameHotKey(game, GAME_HK_CAMERA_TOGGLE); break;
case SDL_SCANCODE_HOME: GameHotKey(game, GAME_HK_CAMERA_CORE); break;
case SDL_SCANCODE_END: GameHotKey(game, GAME_HK_CAMERA_AVATAR); break;
case SDL_SCANCODE_PAGEUP: GameHotKey(game, GAME_HK_TELEPORT_AVATAR); break;
//case SDLK_a: reserved
case SDL_SCANCODE_B: GameHotKey(game, GAME_HK_CHEAT_GOLD); break;
case SDL_SCANCODE_C: GameHotKey(game, GAME_HK_ATTACH_CORE); break;
//case SDLK_d: reserved
case SDL_SCANCODE_E: GameHotKey(game, GAME_HK_CHEAT_ELIXIR); break;
case SDL_SCANCODE_H: GameHotKey(game, GAME_HK_TOGGLE_PATHING); break;
case SDL_SCANCODE_I: GameHotKey(game, GAME_HK_TOGGLE_AI_DEBUG); break;
case SDL_SCANCODE_K: GameHotKey(game, GAME_HK_CHEAT_CRYSTAL); break;
case SDL_SCANCODE_M: GameHotKey(game, GAME_HK_MAP); break;
case SDL_SCANCODE_P: GameHotKey(game, GAME_HK_TOGGLE_PERF); break;
case SDL_SCANCODE_Q: GameHotKey(game, GAME_HK_CHEAT_HERD); break;
//case SDLK_s: reserved
case SDL_SCANCODE_T: GameHotKey(game, GAME_HK_CHEAT_TECH); break;
case SDL_SCANCODE_U: GameHotKey(game, GAME_HK_TOGGLE_UI); break;
//case SDLK_w: reserved
case SDL_SCANCODE_1: GameHotKey(game, GAME_HK_TOGGLE_GLOW); break;
case SDL_SCANCODE_2: GameHotKey(game, GAME_HK_TOGGLE_PARTICLE); break;
case SDL_SCANCODE_3: GameHotKey(game, GAME_HK_TOGGLE_VOXEL); break;
case SDL_SCANCODE_4: GameHotKey(game, GAME_HK_TOGGLE_SHADOW); break;
case SDL_SCANCODE_5: GameHotKey(game, GAME_HK_TOGGLE_BOLT); break;
case SDL_SCANCODE_F3:
GameDoTick(game, SDL_GetTicks());
SDL_GL_SwapWindow(screen);
ScreenCapture();
break;
case SDL_SCANCODE_F11:
{
if (fullscreen) {
// SDL_RestoreWindow doesn't seem to work as I expect.
SDL_SetWindowFullscreen(screen, 0);
SDL_SetWindowSize(screen, restoreWidth, restoreHeight);
fullscreen = false;
}
else {
restoreWidth = screenWidth;
restoreHeight = screenHeight;
SDL_SetWindowFullscreen(screen, SDL_WINDOW_FULLSCREEN_DESKTOP);
fullscreen = true;
}
}
break;
default:
break;
}
}
break;
case SDL_MOUSEBUTTONDOWN:
{
int x = event.button.x;
int y = event.button.y;
int mod = 0;
if (modKeys & (KMOD_LSHIFT | KMOD_RSHIFT)) mod = GAME_TAP_MOD_SHIFT;
else if (modKeys & (KMOD_LCTRL | KMOD_RCTRL)) mod = GAME_TAP_MOD_CTRL;
if (nFingers > 1) {
// do nothing
}
else if (event.button.button == SDL_BUTTON_LEFT) {
#ifdef OUTPUT_MOUSE_AND_TOUCH
GLOUTPUT(("Left mouse down %d %d\n", x, y));
#endif
mouseDown.Set(event.button.x, event.button.y);
GameTap(game, GAME_TAP_DOWN, x, y, mod);
}
else if (event.button.button == SDL_BUTTON_RIGHT) {
#ifdef OUTPUT_MOUSE_AND_TOUCH
GLOUTPUT(("Right mouse down %d %d\n", x, y));
#endif
GameTap(game, GAME_TAP_CANCEL, x, y, mod);
rightMouseDown.Zero();
if (mod == 0) {
rightMouseDown.Set(event.button.x, event.button.y);
GameCameraPan(game, GAME_PAN_START, float(x), float(y));
}
else if (mod == GAME_TAP_MOD_CTRL) {
zooming = true;
//GameCameraRotate( game, GAME_ROTATE_START, 0.0f );
SDL_GetRelativeMouseState(&zoomX, &zoomY);
}
}
}
break;
case SDL_MOUSEBUTTONUP:
{
int x = event.button.x;
int y = event.button.y;
if (event.button.button == SDL_BUTTON_RIGHT) {
#ifdef OUTPUT_MOUSE_AND_TOUCH
GLOUTPUT(("Right mouse up %d %d\n", x, y));
#endif
zooming = false;
if (!rightMouseDown.IsZero()) {
GameCameraPan(game, GAME_PAN_END, float(x), float(y));
rightMouseDown.Zero();
}
}
if (event.button.button == SDL_BUTTON_LEFT) {
if (!mouseDown.IsZero()) { // filter out mouse events that become finger events.
#ifdef OUTPUT_MOUSE_AND_TOUCH
GLOUTPUT(("Left mouse up %d %d\n", x, y));
#endif
int mod = 0;
if (modKeys & (KMOD_LSHIFT | KMOD_RSHIFT)) mod = GAME_TAP_MOD_SHIFT;
else if (modKeys & (KMOD_LCTRL | KMOD_RCTRL)) mod = GAME_TAP_MOD_CTRL;
GameTap(game, GAME_TAP_UP, x, y, mod);
}
}
}
break;
case SDL_MOUSEMOTION:
{
SDL_GetRelativeMouseState(&zoomX, &zoomY);
int state = event.motion.state;
int x = event.motion.x;
int y = event.motion.y;
int mod = 0;
if (modKeys & (KMOD_LSHIFT | KMOD_RSHIFT)) mod = GAME_TAP_MOD_SHIFT;
else if (modKeys & (KMOD_LCTRL | KMOD_RCTRL)) mod = GAME_TAP_MOD_CTRL;
if (nFingers > 1) {
// Do nothing.
// Multi touch in progress.
}
else if (state & SDL_BUTTON(SDL_BUTTON_LEFT)) {
if (!mouseDown.IsZero()) {
#ifdef OUTPUT_MOUSE_AND_TOUCH
GLOUTPUT(("Left Mouse move %d %d\n", x, y));
#endif
GameTap(game, GAME_TAP_MOVE, x, y, mod);
// mouseMoveCount = 0;
}
}
else if (!rightMouseDown.IsZero()) {
GLASSERT(state & SDL_BUTTON(SDL_BUTTON_RIGHT));
GameCameraPan(game, GAME_PAN_END, float(x), float(y));
}
else if (zooming && (state & SDL_BUTTON(SDL_BUTTON_RIGHT))) {
float deltaZoom = 0.01f * (float)zoomY;
GameZoom(game, GAME_ZOOM_DISTANCE, deltaZoom);
GameCameraRotate(game, (float)(zoomX)*0.5f);
}
else if (state ==0) {
GameTap(game, GAME_MOVE_WHILE_UP, x, y, mod);
}
}
break;
case SDL_MOUSEWHEEL:
{
if (event.wheel.y) {
float deltaZoom = -0.1f * float(event.wheel.y);
GameZoom(game, GAME_ZOOM_DISTANCE, deltaZoom);
}
}
break;
case SDL_FINGERUP:
{
const SDL_TouchFingerEvent* tfe = &event.tfinger;
nFingers = SDL_GetNumTouchFingers(tfe->touchId);
if (nFingers < 2 && !multiTouchStart.IsZero()) {
#ifdef OUTPUT_MOUSE_AND_TOUCH
GLOUTPUT(("2 finger END.\n"));
#endif
multiTouchStart.Zero();
}
}
break;
case SDL_FINGERDOWN:
{
const SDL_TouchFingerEvent* tfe = &event.tfinger;
nFingers = SDL_GetNumTouchFingers(tfe->touchId);
if (nFingers > 1) {
if (!mouseDown.IsZero()) {
// Wrap up the existing action.
#ifdef OUTPUT_MOUSE_AND_TOUCH
GLOUTPUT(("Switch to gesture.\n"));
#endif
mouseDown.Zero();
}
}
}
break;
case SDL_MULTIGESTURE:
{
const SDL_MultiGestureEvent* mge = &event.mgesture;
nFingers = SDL_GetNumTouchFingers(mge->touchId);
if (nFingers > 1 && multiTouchStart.IsZero()) {
#ifdef OUTPUT_MOUSE_AND_TOUCH
GLOUTPUT(("2 finger START.\n"));
#endif
multiTouchStart.Set(mge->x, mge->y);
}
else if (!multiTouchStart.IsZero()) {
// The Pan interacts badly with zoom and rotated. So instead of a continuous,
// multi-event action do a bunch of "mini pans".
GameCameraPan(game, GAME_PAN_START,
multiTouchStart.x * float(screenWidth), multiTouchStart.y*float(screenHeight));
multiTouchStart.Set(mge->x, mge->y);
GameCameraPan(game, GAME_PAN_MOVE,
multiTouchStart.x * float(screenWidth), multiTouchStart.y*float(screenHeight));
GameCameraPan(game, GAME_PAN_END,
multiTouchStart.x * float(screenWidth), multiTouchStart.y*float(screenHeight));
}
if (nFingers == 2) {
GameZoom(game, GAME_ZOOM_DISTANCE, -mge->dDist * 10.f);
GameCameraRotate(game, -mge->dTheta * 100.0f);
//GLOUTPUT(("MultiGestureEvent dTheta=%.4f dDist=%.4f x=%.4f y=%.4f nFing=%d\n", mge->dTheta, mge->dDist, mge->x, mge->y, mge->numFingers));
}
}
break;
case SDL_DOLLARGESTURE:
{
GLOUTPUT(("DollarGestureEvent\n"));
}
break;
case SDL_QUIT:
{
done = true;
}
break;
default:
break;
}
}
U32 delta = SDL_GetTicks() - tickTimer;
if (delta < TIME_BETWEEN_FRAMES) {
SDL_Delay(1);
continue;
}
tickTimer = SDL_GetTicks();
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
const U8* keys = SDL_GetKeyboardState(0);
U32 tickDelta = thisTick - lastTick;
if (tickDelta > 100) tickDelta = 100;
float keyMoveSpeed = KEY_MOVE_SPEED * float(tickDelta) / float(TIME_BETWEEN_FRAMES);
float keyZoomSpeed = KEY_ZOOM_SPEED * float(tickDelta) / float(TIME_BETWEEN_FRAMES);
float keyRotatepeed = KEY_ROTATE_SPEED * float(tickDelta) / float(TIME_BETWEEN_FRAMES);
if (keys[SDL_SCANCODE_DOWN] || keys[SDL_SCANCODE_S]) {
if (modKeys & KMOD_CTRL)
GameZoom(game, GAME_ZOOM_DISTANCE, keyZoomSpeed);
else
GameCameraMove(game, 0, -keyMoveSpeed);
}
if (keys[SDL_SCANCODE_UP] || keys[SDL_SCANCODE_W]) {
if (modKeys & KMOD_CTRL)
GameZoom(game, GAME_ZOOM_DISTANCE, -keyZoomSpeed);
else
GameCameraMove(game, 0, keyMoveSpeed);
}
if (keys[SDL_SCANCODE_LEFT] || keys[SDL_SCANCODE_A]) {
if (modKeys & KMOD_CTRL)
GameCameraRotate(game, keyRotatepeed);
else
GameCameraMove(game, -keyMoveSpeed, 0);
}
if (keys[SDL_SCANCODE_RIGHT] || keys[SDL_SCANCODE_D]) {
if (modKeys & KMOD_CTRL)
GameCameraRotate(game, -keyRotatepeed);
else
GameCameraMove(game, keyMoveSpeed, 0);
}
if (game) {
lastTick = thisTick;
thisTick = SDL_GetTicks();
PROFILE_BLOCK(GameDoTick);
GameDoTick(game, thisTick);
}
{
PROFILE_BLOCK(Swap);
SDL_GL_SwapWindow(screen);
}
}
GameSave(game);
DeleteGame(game);
for (int i = 0; i < nModDB; ++i) {
delete databases[i];
}
SDL_Quit();
#if SEND_CRASH_LOGS
// Empty the file - quit went just fine.
{
FILE* fp = FOpen( "UFO_Running.txt", "w" );
if ( fp )
fclose( fp );
}
#endif
MemLeakCheck();
return 0;
}
static bool sdl_ctx_set_video_mode(void *data, unsigned width, unsigned height,
bool fullscreen)
{
unsigned fsflag = 0;
driver_t *driver = driver_get_ptr();
settings_t *settings = config_get_ptr();
gfx_ctx_sdl_data_t *sdl = (gfx_ctx_sdl_data_t*)driver->video_context_data;
(void)data;
sdl->g_new_width = width;
sdl->g_new_height = height;
#ifdef HAVE_SDL2
if (fullscreen)
{
if (settings->video.windowed_fullscreen)
fsflag = SDL_WINDOW_FULLSCREEN_DESKTOP;
else
fsflag = SDL_WINDOW_FULLSCREEN;
}
if (sdl->g_win)
{
SDL_SetWindowSize(sdl->g_win, width, height);
if (fullscreen)
SDL_SetWindowFullscreen(sdl->g_win, fsflag);
}
else
{
unsigned display = settings->video.monitor_index;
sdl->g_win = SDL_CreateWindow("", SDL_WINDOWPOS_UNDEFINED_DISPLAY(display),
SDL_WINDOWPOS_UNDEFINED_DISPLAY(display),
width, height, SDL_WINDOW_OPENGL | fsflag);
}
#else
if (fullscreen)
fsflag = SDL_FULLSCREEN;
sdl->g_win = SDL_SetVideoMode(width, height, 0, SDL_OPENGL | fsflag);
#endif
if (!sdl->g_win)
goto error;
#ifdef HAVE_SDL2
if (sdl->g_ctx)
driver->video_cache_context_ack = true;
else
{
sdl->g_ctx = SDL_GL_CreateContext(sdl->g_win);
if (!sdl->g_ctx)
goto error;
}
#endif
sdl->g_full = fullscreen;
sdl->g_width = width;
sdl->g_height = height;
return true;
error:
RARCH_WARN("[SDL_GL]: Failed to set video mode: %s\n", SDL_GetError());
return false;
}
void
SDLTest_CommonEvent(SDLTest_CommonState * state, SDL_Event * event, int *done)
{
int i;
static SDL_MouseMotionEvent lastEvent;
if (state->verbose & VERBOSE_EVENT) {
SDLTest_PrintEvent(event);
}
switch (event->type) {
case SDL_WINDOWEVENT:
switch (event->window.event) {
case SDL_WINDOWEVENT_CLOSE:
{
SDL_Window *window = SDL_GetWindowFromID(event->window.windowID);
if (window) {
SDL_DestroyWindow(window);
for (i = 0; i < state->num_windows; ++i) {
if (window == state->windows[i]) {
state->windows[i] = NULL;
break;
}
}
}
}
break;
}
break;
case SDL_KEYDOWN:
switch (event->key.keysym.sym) {
/* Add hotkeys here */
case SDLK_PRINTSCREEN: {
SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
if (window) {
for (i = 0; i < state->num_windows; ++i) {
if (window == state->windows[i]) {
SDLTest_ScreenShot(state->renderers[i]);
}
}
}
}
break;
case SDLK_EQUALS:
if (event->key.keysym.mod & KMOD_CTRL) {
/* Ctrl-+ double the size of the window */
SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
if (window) {
int w, h;
SDL_GetWindowSize(window, &w, &h);
SDL_SetWindowSize(window, w*2, h*2);
}
}
break;
case SDLK_MINUS:
if (event->key.keysym.mod & KMOD_CTRL) {
/* Ctrl-- half the size of the window */
SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
if (window) {
int w, h;
SDL_GetWindowSize(window, &w, &h);
SDL_SetWindowSize(window, w/2, h/2);
}
}
break;
case SDLK_c:
if (event->key.keysym.mod & KMOD_CTRL) {
/* Ctrl-C copy awesome text! */
SDL_SetClipboardText("SDL rocks!\nYou know it!");
printf("Copied text to clipboard\n");
}
if (event->key.keysym.mod & KMOD_ALT) {
/* Alt-C toggle a render clip rectangle */
for (i = 0; i < state->num_windows; ++i) {
int w, h;
if (state->renderers[i]) {
SDL_Rect clip;
SDL_GetWindowSize(state->windows[i], &w, &h);
SDL_RenderGetClipRect(state->renderers[i], &clip);
if (SDL_RectEmpty(&clip)) {
clip.x = w/4;
clip.y = h/4;
clip.w = w/2;
clip.h = h/2;
SDL_RenderSetClipRect(state->renderers[i], &clip);
} else {
SDL_RenderSetClipRect(state->renderers[i], NULL);
}
}
}
}
break;
case SDLK_v:
if (event->key.keysym.mod & KMOD_CTRL) {
/* Ctrl-V paste awesome text! */
char *text = SDL_GetClipboardText();
if (*text) {
printf("Clipboard: %s\n", text);
} else {
printf("Clipboard is empty\n");
}
SDL_free(text);
}
break;
case SDLK_g:
if (event->key.keysym.mod & KMOD_CTRL) {
/* Ctrl-G toggle grab */
SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
if (window) {
SDL_SetWindowGrab(window, !SDL_GetWindowGrab(window) ? SDL_TRUE : SDL_FALSE);
}
}
break;
case SDLK_m:
if (event->key.keysym.mod & KMOD_CTRL) {
/* Ctrl-M maximize */
SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
if (window) {
Uint32 flags = SDL_GetWindowFlags(window);
if (flags & SDL_WINDOW_MAXIMIZED) {
SDL_RestoreWindow(window);
} else {
SDL_MaximizeWindow(window);
}
}
}
break;
case SDLK_r:
if (event->key.keysym.mod & KMOD_CTRL) {
/* Ctrl-R toggle mouse relative mode */
SDL_SetRelativeMouseMode(!SDL_GetRelativeMouseMode() ? SDL_TRUE : SDL_FALSE);
}
break;
case SDLK_z:
if (event->key.keysym.mod & KMOD_CTRL) {
/* Ctrl-Z minimize */
SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
if (window) {
SDL_MinimizeWindow(window);
}
}
break;
case SDLK_RETURN:
if (event->key.keysym.mod & KMOD_CTRL) {
/* Ctrl-Enter toggle fullscreen */
SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
if (window) {
Uint32 flags = SDL_GetWindowFlags(window);
if (flags & SDL_WINDOW_FULLSCREEN) {
SDL_SetWindowFullscreen(window, SDL_FALSE);
} else {
SDL_SetWindowFullscreen(window, SDL_TRUE);
}
}
} else if (event->key.keysym.mod & KMOD_ALT) {
/* Alt-Enter toggle fullscreen desktop */
SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
if (window) {
Uint32 flags = SDL_GetWindowFlags(window);
if (flags & SDL_WINDOW_FULLSCREEN) {
SDL_SetWindowFullscreen(window, SDL_FALSE);
} else {
SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN_DESKTOP);
}
}
}
break;
case SDLK_b:
if (event->key.keysym.mod & KMOD_CTRL) {
/* Ctrl-B toggle window border */
SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
if (window) {
const Uint32 flags = SDL_GetWindowFlags(window);
const SDL_bool b = ((flags & SDL_WINDOW_BORDERLESS) != 0) ? SDL_TRUE : SDL_FALSE;
SDL_SetWindowBordered(window, b);
}
}
break;
case SDLK_0:
if (event->key.keysym.mod & KMOD_CTRL) {
SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_INFORMATION, "Test Message", "You're awesome!", window);
}
break;
case SDLK_1:
if (event->key.keysym.mod & KMOD_CTRL) {
FullscreenTo(0, event->key.windowID);
}
break;
case SDLK_2:
if (event->key.keysym.mod & KMOD_CTRL) {
FullscreenTo(1, event->key.windowID);
}
break;
case SDLK_ESCAPE:
*done = 1;
break;
case SDLK_SPACE:
{
char message[256];
SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
SDL_snprintf(message, sizeof(message), "(%i, %i), rel (%i, %i)\n", lastEvent.x, lastEvent.y, lastEvent.xrel, lastEvent.yrel);
SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_INFORMATION, "Last mouse position", message, window);
break;
}
default:
break;
}
break;
case SDL_QUIT:
*done = 1;
break;
case SDL_MOUSEMOTION:
lastEvent = event->motion;
break;
}
}