int main(int argc, char* argv[]) { unsigned int width = 0; unsigned int height = 0; if(argc > 1) { for(int i = 1; i < argc; i++) { if(strcmp(argv[i], "-w") == 0) { width = atoi(argv[i + 1]); i++; //skip the argument value }else if(strcmp(argv[i], "-h") == 0) { height = atoi(argv[i + 1]); i++; //skip the argument value }else if(strcmp(argv[i], "--gamelist-only") == 0) { Settings::getInstance()->setBool("PARSEGAMELISTONLY", true); }else if(strcmp(argv[i], "--ignore-gamelist") == 0) { Settings::getInstance()->setBool("IGNOREGAMELIST", true); }else if(strcmp(argv[i], "--draw-framerate") == 0) { Settings::getInstance()->setBool("DRAWFRAMERATE", true); }else if(strcmp(argv[i], "--no-exit") == 0) { Settings::getInstance()->setBool("DONTSHOWEXIT", true); }else if(strcmp(argv[i], "--debug") == 0) { Settings::getInstance()->setBool("DEBUG", true); Log::setReportingLevel(LogDebug); }else if(strcmp(argv[i], "--dimtime") == 0) { Settings::getInstance()->setInt("DIMTIME", atoi(argv[i + 1]) * 1000); i++; //skip the argument value }else if(strcmp(argv[i], "--windowed") == 0) { Settings::getInstance()->setBool("WINDOWED", true); }else if(strcmp(argv[i], "--help") == 0) { std::cout << "EmulationStation, a graphical front-end for ROM browsing.\n"; std::cout << "Command line arguments:\n"; std::cout << "-w [width in pixels] set screen width\n"; std::cout << "-h [height in pixels] set screen height\n"; std::cout << "--gamelist-only skip automatic game detection, only read from gamelist.xml\n"; std::cout << "--ignore-gamelist ignore the gamelist (useful for troubleshooting)\n"; std::cout << "--draw-framerate display the framerate\n"; std::cout << "--no-exit don't show the exit option in the menu\n"; std::cout << "--debug even more logging\n"; std::cout << "--dimtime [seconds] time to wait before dimming the screen (default 30, use 0 for never)\n"; #ifdef USE_OPENGL_DESKTOP std::cout << "--windowed not fullscreen\n"; #endif std::cout << "--help summon a sentient, angry tuba\n\n"; std::cout << "More information available in README.md.\n"; return 0; } } } #ifdef _RPI_ bcm_host_init(); #endif bool running = true; //make sure the config directory exists std::string home = getHomePath(); std::string configDir = home + "/.emulationstation"; if(!fs::exists(configDir)) { std::cout << "Creating config directory \"" << configDir << "\"\n"; fs::create_directory(configDir); } //start the logger Log::open(); LOG(LogInfo) << "EmulationStation - " << PROGRAM_VERSION_STRING; //the renderer also takes care of setting up SDL for input and sound bool renderInit = Renderer::init(width, height); if(!renderInit) { std::cerr << "Error initializing renderer!\n"; Log::close(); return 1; } Window window; //don't call Window.init() because we manually pass the resolution to Renderer::init window.getInputManager()->init(); //try loading the system config file if(!fs::exists(SystemData::getConfigPath())) //if it doesn't exist, create the example and quit { std::cerr << "A system config file in " << SystemData::getConfigPath() << " was not found. An example will be created.\n"; SystemData::writeExampleConfig(); std::cerr << "Set it up, then re-run EmulationStation.\n"; running = false; }else{ SystemData::loadConfig(); if(SystemData::sSystemVector.size() == 0) //if it exists but was empty, notify the user and quit { std::cerr << "A system config file in " << SystemData::getConfigPath() << " was found, but contained no systems.\n"; std::cerr << "Does at least one system have a game present?\n"; running = false; }else{ //choose which GUI to open depending on Input configuration if(fs::exists(InputManager::getConfigPath())) { //an input config already exists - we have input, proceed to the gamelist as usual. GuiGameList::create(&window); }else{ window.pushGui(new GuiDetectDevice(&window)); } } } bool sleeping = false; unsigned int timeSinceLastEvent = 0; int lastTime = 0; while(running) { SDL_Event event; while(SDL_PollEvent(&event)) { switch(event.type) { case SDL_JOYHATMOTION: case SDL_JOYBUTTONDOWN: case SDL_JOYBUTTONUP: case SDL_KEYDOWN: case SDL_KEYUP: case SDL_JOYAXISMOTION: if(window.getInputManager()->parseEvent(event)) { sleeping = false; timeSinceLastEvent = 0; } break; case InputManager::SDL_USEREVENT_POLLDEVICES: //try to poll input devices, but do not necessarily wake up... window.getInputManager()->parseEvent(event); break; case SDL_QUIT: running = false; break; } } if(sleeping) { lastTime = SDL_GetTicks(); sleep(1); //this doesn't need to accurate continue; } int curTime = SDL_GetTicks(); int deltaTime = curTime - lastTime; lastTime = curTime; window.update(deltaTime); Renderer::swapBuffers(); //swap here so we can read the last screen state during updates (see ImageComponent::copyScreen()) window.render(); if(Settings::getInstance()->getBool("DRAWFRAMERATE")) { static int timeElapsed = 0; static int nrOfFrames = 0; static std::string fpsString; nrOfFrames++; timeElapsed += deltaTime; //wait until half a second has passed to recalculate fps if (timeElapsed >= 500) { std::stringstream ss; ss << std::fixed << std::setprecision(1) << (1000.0f * (float)nrOfFrames / (float)timeElapsed) << "fps, "; ss << std::fixed << std::setprecision(2) << ((float)timeElapsed / (float)nrOfFrames) << "ms"; fpsString = ss.str(); nrOfFrames = 0; timeElapsed = 0; } Renderer::drawText(fpsString, 50, 50, 0x00FF00FF, Renderer::getDefaultFont(Renderer::MEDIUM)); } //sleep if we're past our threshold //sleeping entails setting a flag to start skipping frames //and initially drawing a black semi-transparent rect to dim the screen timeSinceLastEvent += deltaTime; if(timeSinceLastEvent >= (unsigned int)Settings::getInstance()->getInt("DIMTIME") && Settings::getInstance()->getInt("DIMTIME") != 0) { sleeping = true; timeSinceLastEvent = 0; Renderer::drawRect(0, 0, Renderer::getScreenWidth(), Renderer::getScreenHeight(), 0x000000A0); Renderer::swapBuffers(); } Log::flush(); } Renderer::deinit(); SystemData::deleteSystems(); std::cout << "EmulationStation cleanly shutting down...\n"; Log::close(); #ifdef _RPI_ bcm_host_deinit(); #endif return 0; }
void handle_events() { static int button_left = 0; static int button_right = 0; static int button_middle = 0; int width = 0, height = 0; SDL_Event event; while (SDL_PollEvent(&event)) { switch (event.type) { case SDL_MOUSEBUTTONDOWN: switch (event.button.button) { case SDL_BUTTON_LEFT: button_left = 1; break; case SDL_BUTTON_MIDDLE: button_middle = 1; break; case SDL_BUTTON_RIGHT: button_right = 1; break; default: break; } break; case SDL_MOUSEBUTTONUP: switch (event.button.button) { case SDL_BUTTON_LEFT: button_left = 0; break; case SDL_BUTTON_MIDDLE: button_middle = 0; break; case SDL_BUTTON_RIGHT: button_right = 0; break; default: break; } break; case SDL_MOUSEMOTION: if (button_left) { yoff -= zoom * (float)event.motion.yrel / (float)screen->h; xoff -= zoom * (float)event.motion.xrel / (float)screen->w; } if (button_middle) { } if (button_right) { zoom -= zoom * (float)event.motion.yrel / (float)screen->h; } break; case SDL_KEYDOWN: switch (event.key.keysym.sym) { case SDLK_q: exit(0); break; case SDLK_ESCAPE: exit(0); break; case SDLK_r: zoom = 5.0; xoff = -0.75; yoff = 0.0; break; default: break; } break; case SDL_VIDEORESIZE: width = event.resize.w; height = event.resize.h; break; case SDL_QUIT: exit(1); break; default: break; } } if (width && height) resize_screen(width, height); }
int main(int argc, char **argv) { Uint8 *RawMooseData; SDL_RWops *handle; SDL_Surface *screen; SDL_Surface *MooseFrame[MOOSEFRAMES_COUNT]; SDL_Overlay *overlay; SDL_Rect overlayrect; SDL_Event event; Uint32 lastftick; int paused = 0; int resized = 0; int i; int fps = 12; int fpsdelay; int overlay_format = SDL_YUY2_OVERLAY; int scale = 5; if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_NOPARACHUTE) < 0) { fprintf(stderr, "Couldn't initialize SDL: %s\n", SDL_GetError()); return 3; } while (argc > 1) { if (strcmp(argv[1], "-fps") == 0) { if (argv[2]) { fps = atoi(argv[2]); if (fps == 0) { fprintf(stderr, "The -fps option requires an argument [from 1 to 1000], default is 12.\n"); quit(10); } if ((fps < 0) || (fps > 1000)) { fprintf(stderr, "The -fps option must be in range from 1 to 1000, default is 12.\n"); quit(10); } argv += 2; argc -= 2; } else { fprintf(stderr, "The -fps option requires an argument [from 1 to 1000], default is 12.\n"); quit(10); } } else if (strcmp(argv[1], "-format") == 0) { if (argv[2]) { if (!strcmp(argv[2], "YV12")) overlay_format = SDL_YV12_OVERLAY; else if (!strcmp(argv[2], "IYUV")) overlay_format = SDL_IYUV_OVERLAY; else if (!strcmp(argv[2], "YUY2")) overlay_format = SDL_YUY2_OVERLAY; else if (!strcmp(argv[2], "UYVY")) overlay_format = SDL_UYVY_OVERLAY; else if (!strcmp(argv[2], "YVYU")) overlay_format = SDL_YVYU_OVERLAY; else { fprintf(stderr, "The -format option %s is not recognized, see help for info.\n", argv[2]); quit(10); } argv += 2; argc -= 2; } else { fprintf(stderr, "The -format option requires an argument, default is YUY2.\n"); quit(10); } } else if (strcmp(argv[1], "-scale") == 0) { if (argv[2]) { scale = atoi(argv[2]); if (scale == 0) { fprintf(stderr, "The -scale option requires an argument [from 1 to 50], default is 5.\n"); quit(10); } if ((scale < 0) || (scale > 50)) { fprintf(stderr, "The -scale option must be in range from 1 to 50, default is 5.\n"); quit(10); } argv += 2; argc -= 2; } else { fprintf(stderr, "The -fps option requires an argument [from 1 to 1000], default is 12.\n"); quit(10); } } else if ((strcmp(argv[1], "-help") == 0) || (strcmp(argv[1], "-h") == 0)) { PrintUsage(argv[0]); quit(0); } else { fprintf(stderr, "Unrecognized option: %s.\n", argv[1]); quit(10); } break; } RawMooseData = (Uint8 *) malloc(MOOSEFRAME_SIZE * MOOSEFRAMES_COUNT); if (RawMooseData == NULL) { fprintf(stderr, "Can't allocate memory for movie !\n"); free(RawMooseData); quit(1); } /* load the trojan moose images */ handle = SDL_RWFromFile("moose.dat", "rb"); if (handle == NULL) { fprintf(stderr, "Can't find the file moose.dat !\n"); free(RawMooseData); quit(2); } SDL_RWread(handle, RawMooseData, MOOSEFRAME_SIZE, MOOSEFRAMES_COUNT); SDL_RWclose(handle); /* Set video mode */ if ((screen = SDL_SetVideoMode(MOOSEPIC_W * scale, MOOSEPIC_H * scale, 0, SDL_RESIZABLE | SDL_SWSURFACE)) == NULL) { fprintf(stderr, "Couldn't set video mode: %s\n", SDL_GetError()); free(RawMooseData); quit(4); } /* Set the window manager title bar */ SDL_WM_SetCaption("SDL test overlay: running moose", "testoverlay2"); for (i = 0; i < MOOSEFRAMES_COUNT; i++) { MooseFrame[i] = SDL_CreateRGBSurfaceFrom(RawMooseData + i * MOOSEFRAME_SIZE, MOOSEPIC_W, MOOSEPIC_H, 8, MOOSEPIC_W, 0, 0, 0, 0); if (MooseFrame[i] == NULL) { fprintf(stderr, "Couldn't create SDL_Surfaces:%s\n", SDL_GetError()); free(RawMooseData); quit(5); } SDL_SetColors(MooseFrame[i], MooseColors, 0, 84); { SDL_Surface *newsurf; SDL_PixelFormat format; format.palette = NULL; format.BitsPerPixel = 32; format.BytesPerPixel = 4; #if SDL_BYTEORDER == SDL_LIL_ENDIAN format.Rshift = 0; format.Gshift = 8; format.Bshift = 16; #else format.Rshift = 24; format.Gshift = 16; format.Bshift = 8; #endif format.Ashift = 0; format.Rmask = 0xff << format.Rshift; format.Gmask = 0xff << format.Gshift; format.Bmask = 0xff << format.Bshift; format.Amask = 0; format.Rloss = 0; format.Gloss = 0; format.Bloss = 0; format.Aloss = 8; newsurf = SDL_ConvertSurface(MooseFrame[i], &format, SDL_SWSURFACE); if (!newsurf) { fprintf(stderr, "Couldn't convert picture to 32bits RGB: %s\n", SDL_GetError()); quit(6); } SDL_FreeSurface(MooseFrame[i]); MooseFrame[i] = newsurf; } } free(RawMooseData); overlay = SDL_CreateYUVOverlay(MOOSEPIC_W, MOOSEPIC_H, overlay_format, screen); if (!overlay) { fprintf(stderr, "Couldn't create overlay: %s\n", SDL_GetError()); quit(7); } printf("Created %dx%dx%d %s %s overlay\n", overlay->w, overlay->h, overlay->planes, overlay->hw_overlay ? "hardware" : "software", overlay->format == SDL_YV12_OVERLAY ? "YV12" : overlay->format == SDL_IYUV_OVERLAY ? "IYUV" : overlay->format == SDL_YUY2_OVERLAY ? "YUY2" : overlay->format == SDL_UYVY_OVERLAY ? "UYVY" : overlay->format == SDL_YVYU_OVERLAY ? "YVYU" : "Unknown"); for (i = 0; i < overlay->planes; i++) { printf(" plane %d: pitch=%d\n", i, overlay->pitches[i]); } overlayrect.x = 0; overlayrect.y = 0; overlayrect.w = MOOSEPIC_W * scale; overlayrect.h = MOOSEPIC_H * scale; /* set the start frame */ i = 0; fpsdelay = 1000 / fps; /* Ignore key up events, they don't even get filtered */ SDL_EventState(SDL_KEYUP, SDL_IGNORE); lastftick = SDL_GetTicks(); /* Loop, waiting for QUIT or RESIZE */ while (1) { if (SDL_PollEvent(&event)) { switch (event.type) { case SDL_VIDEORESIZE: screen = SDL_SetVideoMode(event.resize.w, event.resize.h, 0, SDL_RESIZABLE | SDL_SWSURFACE); overlayrect.w = event.resize.w; overlayrect.h = event.resize.h; if (paused) { resized = 1; } break; case SDL_MOUSEBUTTONDOWN: overlayrect.x = event.button.x - overlayrect.w / 2; overlayrect.y = event.button.y - overlayrect.h / 2; break; case SDL_KEYDOWN: if (event.key.keysym.sym == SDLK_SPACE) { paused = !paused; break; } if (event.key.keysym.sym != SDLK_ESCAPE) { break; } case SDL_QUIT: SDL_FreeYUVOverlay(overlay); for (i = 0; i < MOOSEFRAMES_COUNT; i++) { SDL_FreeSurface(MooseFrame[i]); } quit(0); } } if ((!paused) || (resized)) { if (((SDL_GetTicks() - lastftick) > fpsdelay) || (resized)) { lastftick = SDL_GetTicks(); switch (overlay_format) { case SDL_YUY2_OVERLAY: ConvertRGBtoYUY2(MooseFrame[i], overlay, 0, 100); break; case SDL_YV12_OVERLAY: ConvertRGBtoYV12(MooseFrame[i], overlay, 0, 100); break; case SDL_UYVY_OVERLAY: ConvertRGBtoUYVY(MooseFrame[i], overlay, 0, 100); break; case SDL_YVYU_OVERLAY: ConvertRGBtoYVYU(MooseFrame[i], overlay, 0, 100); break; case SDL_IYUV_OVERLAY: ConvertRGBtoIYUV(MooseFrame[i], overlay, 0, 100); break; } SDL_DisplayYUVOverlay(overlay, &overlayrect); if (!resized) { i++; if (i == 10) { i = 0; } } else { resized = 0; } } } /* kind of timeslice to OS */ SDL_Delay(1); } SDL_Quit(); return 0; }
bool CGame::Start() { // Esta variable nos ayudara a controlar la salida del juego... int salirJuego = false; while (salirJuego == false){ openGlImplement.DrawStart(); keys = (Uint8*)SDL_GetKeyboardState(NULL); //Maquina de estados switch (estadoJuego){ case ESTADO_INICIANDO: IniciandoVideo(); openGlImplement.InitGL(); openGlImplement.InitShaders(); CargandoObjetos(); InicializandoStage(); estadoJuego = ESTADO_MENU; break; case ESTADO_MENU: MenuActualizar(); MenuPintar(); break; case ESTADO_PRE_JUGANDO: nivelActual = CERO; vida = UNO; enemigosEliminados = CERO; estadoJuego = ESTADO_JUGANDO; juegoGanado = false; IniciarEnemigo(); IniciarNave(); break; case ESTADO_JUGANDO: JugandoActualizar(); JugandoPintar(); break; case ESTADO_FINALIZANDO: salirJuego = true; break; case ESTADO_TERMINANDO: TerminadoPintar(); TerminadoActualizar(); break; }; openGlImplement.DrawEnd(); while (SDL_PollEvent(&event))//Aqui sdl creara una lista de eventos ocurridos { if (event.type == SDL_QUIT) { salirJuego = true; } //si se detecta una salida del sdl o..... if (event.type == SDL_KEYDOWN) {} } //Calculando fps tiempoFrameFinal = SDL_GetTicks(); while (tiempoFrameFinal < (tiempoFrameInicial + FPS_DELAY)) { tiempoFrameFinal = SDL_GetTicks(); SDL_Delay(1); } tiempoFrameInicial = tiempoFrameFinal; tick++; } return true; }
static void IN_ProcessEvents( void ) { SDL_Event e; fakeAscii_t key = A_NULL; static fakeAscii_t lastKeyDown = A_NULL; if( !SDL_WasInit( SDL_INIT_VIDEO ) ) return; while( SDL_PollEvent( &e ) ) { switch( e.type ) { case SDL_KEYDOWN: key = IN_TranslateSDLToJKKey( &e.key.keysym, qtrue ); if ( key != A_NULL ) Sys_QueEvent( 0, SE_KEY, key, qtrue, 0, NULL ); if ( key == A_BACKSPACE ) Sys_QueEvent( 0, SE_CHAR, CTRL('h'), qfalse, 0, NULL); else if ( kg.keys[A_CTRL].down && key >= A_CAP_A && key <= A_CAP_Z ) Sys_QueEvent( 0, SE_CHAR, CTRL(tolower(key)), qfalse, 0, NULL ); lastKeyDown = key; break; case SDL_KEYUP: key = IN_TranslateSDLToJKKey( &e.key.keysym, qfalse ); if( key != A_NULL ) Sys_QueEvent( 0, SE_KEY, key, qfalse, 0, NULL ); lastKeyDown = A_NULL; break; case SDL_TEXTINPUT: if( lastKeyDown != A_CONSOLE ) { char *c = e.text.text; // Quick and dirty UTF-8 to UTF-32 conversion while( *c ) { uint32_t utf32 = ConvertUTF8ToUTF32( c, &c ); if( utf32 != 0 ) { if( IN_IsConsoleKey( A_NULL, utf32 ) ) { Sys_QueEvent( 0, SE_KEY, A_CONSOLE, qtrue, 0, NULL ); Sys_QueEvent( 0, SE_KEY, A_CONSOLE, qfalse, 0, NULL ); } else { uint8_t encoded = ConvertUTF32ToExpectedCharset( utf32 ); Sys_QueEvent( 0, SE_CHAR, encoded, 0, 0, NULL ); } } } } break; case SDL_MOUSEMOTION: if ( mouseActive ) { if ( !e.motion.xrel && !e.motion.yrel ) break; Sys_QueEvent( 0, SE_MOUSE, e.motion.xrel, e.motion.yrel, 0, NULL ); } break; case SDL_MOUSEBUTTONDOWN: case SDL_MOUSEBUTTONUP: { unsigned short b; switch( e.button.button ) { case SDL_BUTTON_LEFT: b = A_MOUSE1; break; case SDL_BUTTON_MIDDLE: b = A_MOUSE3; break; case SDL_BUTTON_RIGHT: b = A_MOUSE2; break; case SDL_BUTTON_X1: b = A_MOUSE4; break; case SDL_BUTTON_X2: b = A_MOUSE5; break; default: b = A_AUX0 + ( e.button.button - 6 ) % 32; break; } Sys_QueEvent( 0, SE_KEY, b, ( e.type == SDL_MOUSEBUTTONDOWN ? qtrue : qfalse ), 0, NULL ); } break; case SDL_MOUSEWHEEL: if( e.wheel.y > 0 ) { Sys_QueEvent( 0, SE_KEY, A_MWHEELUP, qtrue, 0, NULL ); Sys_QueEvent( 0, SE_KEY, A_MWHEELUP, qfalse, 0, NULL ); } else if( e.wheel.y < 0 ) { Sys_QueEvent( 0, SE_KEY, A_MWHEELDOWN, qtrue, 0, NULL ); Sys_QueEvent( 0, SE_KEY, A_MWHEELDOWN, qfalse, 0, NULL ); } break; case SDL_QUIT: Cbuf_ExecuteText(EXEC_NOW, "quit Closed window\n"); break; case SDL_WINDOWEVENT: switch( e.window.event ) { case SDL_WINDOWEVENT_MINIMIZED: Cvar_SetValue( "com_minimized", 1 ); break; case SDL_WINDOWEVENT_RESTORED: case SDL_WINDOWEVENT_MAXIMIZED: Cvar_SetValue( "com_minimized", 0 ); break; case SDL_WINDOWEVENT_FOCUS_LOST: { Cvar_SetValue( "com_unfocused", 1 ); SNDDMA_Activate( qfalse ); break; } case SDL_WINDOWEVENT_FOCUS_GAINED: { Cvar_SetValue( "com_unfocused", 0 ); SNDDMA_Activate( qtrue ); break; } } break; default: break; } } }
bool Window::handleEvent() { SDL_Event event; while(SDL_PollEvent(&event)) { switch(event.type) { case SDL_MOUSEBUTTONDOWN: case SDL_MOUSEBUTTONUP: case SDL_MOUSEMOTION: input.setLastMouseEvent(Chrono::getCurMillis()); input.setMousePos(Vec2i(event.button.x, event.button.y)); } switch(event.type) { case SDL_QUIT: return false; case SDL_MOUSEBUTTONDOWN: handleMouseDown(event); break; case SDL_MOUSEBUTTONUP: { MouseButton b = Input::getMouseButton(event.button.button); input.setMouseState(b, false); eventMouseUp(event.button.x, event.button.y, b); break; } case SDL_MOUSEMOTION: input.setMouseState(MouseButton::LEFT, event.motion.state & SDL_BUTTON_LMASK); input.setMouseState(MouseButton::RIGHT, event.motion.state & SDL_BUTTON_RMASK); input.setMouseState(MouseButton::MIDDLE, event.motion.state & SDL_BUTTON_MMASK); eventMouseMove(event.motion.x, event.motion.y, input.getMouseState()); break; case SDL_KEYDOWN: /* handle ALT+Return */ if(event.key.keysym.sym == SDLK_RETURN && (event.key.keysym.mod & (KMOD_LALT | KMOD_RALT))) { toggleFullscreen(); } else { eventKeyDown(Key(event.key.keysym)); eventKeyPress(static_cast<char>(event.key.keysym.unicode)); } break; case SDL_KEYUP: eventKeyUp(Key(event.key.keysym)); break; case SDL_ACTIVEEVENT: if(event.active.state & SDL_APPACTIVE){ if(event.active.gain){ // got focus eventResize(ssRestored); }else{ // lost focus (minimized) eventResize(ssMinimized); } } break; } } return true; }
int main(int argc, char *argv[]) { SDL_Init(SDL_INIT_VIDEO); displayWindow = SDL_CreateWindow("My Game", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 640, 360, SDL_WINDOW_OPENGL); SDL_GLContext context = SDL_GL_CreateContext(displayWindow); SDL_GL_MakeCurrent(displayWindow, context); #ifdef _WINDOWS glewInit(); #endif glViewport(0, 0, 640, 360); ShaderProgram program(RESOURCE_FOLDER"vertex_textured.glsl", RESOURCE_FOLDER"fragment_textured.glsl"); Matrix projectionMatrix; Matrix modelMatrix; Matrix viewMatrix; projectionMatrix.setOrthoProjection(-3.55f, 3.55f, -2.0f, 2.0f, -1.0f, 1.0f); program.setModelMatrix(modelMatrix); program.setProjectionMatrix(projectionMatrix); program.setViewMatrix(viewMatrix); glUseProgram(program.programID); float stevenPos = 0.0; float stevenJump = 0.1; glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); SDL_Event event; bool done = false; while (!done) { while (SDL_PollEvent(&event)) { if (event.type == SDL_QUIT || event.type == SDL_WINDOWEVENT_CLOSE) { done = true; } } glClearColor(0.5f, 0.3f, 0.4f, 0.1f); glClear(GL_COLOR_BUFFER_BIT); //Finn the Human GLuint img1 = LoadTexture("finn.png"); float vertices[] = { -0.5f, -1.0f, 0.5f, 1.0f, -0.5f, 1.0f, 0.5f, 1.0f, -0.5f, -1.0f, 0.5f, -1.0f }; glVertexAttribPointer(program.positionAttribute, 2, GL_FLOAT, false, 0, vertices); glEnableVertexAttribArray(program.positionAttribute); float texCoords[] = { 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f }; glVertexAttribPointer(program.texCoordAttribute, 2, GL_FLOAT, false, 0, texCoords); glEnableVertexAttribArray(program.texCoordAttribute); modelMatrix.identity(); program.setModelMatrix(modelMatrix); glBindTexture(GL_TEXTURE_2D, img1); glDrawArrays(GL_TRIANGLES, 0, 6); glDisableVertexAttribArray(program.positionAttribute); glDisableVertexAttribArray(program.texCoordAttribute); //Rick and Morty GLuint img2 = LoadTexture("RickandMorty.png"); float vertices2[] = { -3.5f, -2.0f, -0.5f, 0.5f, -3.5f, 0.5f, -0.5f, 0.5f, -3.5, -2.0f, -0.5f, -2.0f }; glVertexAttribPointer(program.positionAttribute, 2, GL_FLOAT, false, 0, vertices2); glEnableVertexAttribArray(program.positionAttribute); float texCoords2[] = { 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f }; glVertexAttribPointer(program.texCoordAttribute, 2, GL_FLOAT, false, 0, texCoords2); glEnableVertexAttribArray(program.texCoordAttribute); modelMatrix.identity(); program.setModelMatrix(modelMatrix); glBindTexture(GL_TEXTURE_2D, img2); glDrawArrays(GL_TRIANGLES, 0, 6); glDisableVertexAttribArray(program.positionAttribute); glDisableVertexAttribArray(program.texCoordAttribute); //Steven GLuint img3 = LoadTexture("steven.png"); float vertices3[] = { 1.0f, -1.0f, 3.0f, 1.0f, 1.0f, 1.0f, 3.0f, 1.0f, 1.0f, -1.0f, 3.0, -1.0f }; glVertexAttribPointer(program.positionAttribute, 2, GL_FLOAT, false, 0, vertices3); glEnableVertexAttribArray(program.positionAttribute); float texCoords3[] = { 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f }; glVertexAttribPointer(program.texCoordAttribute, 2, GL_FLOAT, false, 0, texCoords3); glEnableVertexAttribArray(program.texCoordAttribute); if (stevenPos >= 1.0) stevenJump = -0.1; else if (stevenPos <= -1.0) stevenJump = 0.1; stevenPos += stevenJump; modelMatrix.identity(); modelMatrix.Translate(0.0, stevenPos, 0.0); program.setModelMatrix(modelMatrix); glBindTexture(GL_TEXTURE_2D, img3); glDrawArrays(GL_TRIANGLES, 0, 6); glDisableVertexAttribArray(program.positionAttribute); glDisableVertexAttribArray(program.texCoordAttribute); SDL_GL_SwapWindow(displayWindow); } SDL_Quit(); return 0; }
int fs_ml_event_loop(void) { // printf("fs_ml_event_loop\n"); int result = 0; SDL_Event event; while (SDL_PollEvent(&event)) { switch(event.type) { case SDL_QUIT: fs_log("intercepted SDL_QUIT\n"); fs_ml_quit(); #ifdef FS_EMU_DRIVERS printf("returning 1 from fs_ml_event_loop\n"); result = 1; #endif continue; #ifdef USE_SDL2 case SDL_WINDOWEVENT: // printf("SDL_WINDOWEVENT...\n"); if (event.window.event == SDL_WINDOWEVENT_RESIZED) { on_resize(event.window.data1, event.window.data2); } else if (event.window.event == SDL_WINDOWEVENT_CLOSE) { event.type = SDL_QUIT; SDL_PushEvent(&event); } continue; #else case SDL_VIDEORESIZE: on_resize(event.resize.w, event.resize.h); continue; case SDL_ACTIVEEVENT: //fs_log("got active event %d %d %d %d\n", event.active.state, // SDL_APPMOUSEFOCUS, SDL_APPINPUTFOCUS, SDL_APPACTIVE); if ((event.active.state & SDL_APPINPUTFOCUS)) { if (event.active.gain) { fs_log("got keyboard focus\n"); // just got keyboard focus -- clearing modifier states fs_ml_clear_keyboard_modifier_state(); if (g_fs_ml_had_input_grab) { fs_log("- had input grab, re-acquiring\n"); fs_ml_grab_input(1, 1); g_fs_ml_had_input_grab = 0; } if (g_fs_ml_was_fullscreen) { if (!g_fs_emu_video_fullscreen) { fs_log("- was in fullsreen mode before (switching)\n"); fs_ml_toggle_fullscreen(); } g_fs_ml_was_fullscreen = 0; } } else { fs_log("lost keyboard focus\n"); if (fs_ml_has_input_grab()) { fs_log("- releasing input grab\n"); fs_ml_grab_input(0, 1); g_fs_ml_had_input_grab = 1; } else { fs_log("- did not have input grab\n"); //g_fs_ml_had_input_grab = 0; } } } continue; #endif case SDL_KEYDOWN: case SDL_KEYUP: if (g_debug_input) { fs_log("SDL key sym %d mod %d scancode %d state %d\n", event.key.keysym.sym, event.key.keysym.mod, event.key.keysym.scancode, event.key.state); } if (event.key.keysym.sym == 0 && event.key.keysym.scancode == 0) { // ignore "ghost key" seen on OS X which without this // specific check will cause the A key to be mysteriously // pressed. if (g_debug_input) { fs_log("- ignored key with keysym 0 and scancode 0\n"); } continue; } /* if (event.key.keysym.sym == SDLK_F12) { g_f12_state = event.key.state ? FS_ML_KEY_MOD_F12 : 0; printf("-- g_f12_state is %d\n", g_f12_state); } else if (event.key.keysym.sym == SDLK_F11) { g_f11_state = event.key.state ? FS_ML_KEY_MOD_F11 : 0; } */ const Uint8* key_state; int num_keys; #ifdef USE_SDL2 key_state = SDL_GetKeyboardState(&num_keys); g_f11_state = key_state[SDL_SCANCODE_F11] ? FS_ML_KEY_MOD_F11 : 0; g_f12_state = key_state[SDL_SCANCODE_F12] ? FS_ML_KEY_MOD_F12 : 0; // printf("%d %d\n", g_f11_state, g_f12_state); #else key_state = SDL_GetKeyState(&num_keys); g_f11_state = key_state[SDLK_F11] ? FS_ML_KEY_MOD_F11 : 0; g_f12_state = key_state[SDLK_F12] ? FS_ML_KEY_MOD_F12 : 0; #endif int key = -1; #ifdef USE_SDL2 if (event.key.keysym.scancode <= LAST_SDL2_SCANCODE) { key = g_sdl2_keys[event.key.keysym.scancode]; } #else if (0) { } #endif #if defined(MACOSX) #ifdef USE_SDL2 #else else if (event.key.keysym.sym == SDLK_LSHIFT) { key = SDLK_LSHIFT; } else if (event.key.keysym.sym == SDLK_LCTRL) { key = SDLK_LCTRL; } else if (event.key.keysym.sym == SDLK_LALT) { key = SDLK_LALT; } else if (event.key.keysym.sym == SDLK_LMETA) { key = SDLK_LSUPER; } else if (event.key.keysym.sym == SDLK_RMETA) { key = SDLK_RSUPER; } else if (event.key.keysym.sym == SDLK_RALT) { key = SDLK_RALT; } else if (event.key.keysym.sym == SDLK_RCTRL) { key = SDLK_RCTRL; } else if (event.key.keysym.sym == SDLK_RSHIFT) { key = SDLK_RSHIFT; } else if (event.key.keysym.sym == SDLK_CAPSLOCK) { key = SDLK_CAPSLOCK; } #endif #elif defined(WINDOWS) #else else if (event.key.keysym.sym == SDLK_MODE) { key = SDLK_RALT; } #endif else { key = fs_ml_scancode_to_key(event.key.keysym.scancode); } #ifdef USE_SDL2 if (0) { // the below trick does not currently work for SDL2, as // there is no mapping yet for translated keys } #else if (g_f12_state || g_f11_state) { // leave translated key code in keysym } #endif else if (key >= 0) { if (g_debug_input) { fs_log("- key code set to %d (was %d) based on " "scancode %d\n", key, event.key.keysym.sym, event.key.keysym.scancode); } event.key.keysym.sym = key; } int mod = event.key.keysym.mod; if (mod & KMOD_LSHIFT || mod & KMOD_RSHIFT) { event.key.keysym.mod |= KMOD_SHIFT; } if (mod & KMOD_LALT || mod & KMOD_RALT) { //mod & ~(KMOD_LALT | KMOD_RALT); event.key.keysym.mod |= KMOD_ALT; } if (mod & KMOD_LCTRL || mod & KMOD_RCTRL) { event.key.keysym.mod |= KMOD_CTRL; } if (mod & KMOD_LMETA || mod & KMOD_RMETA) { event.key.keysym.mod |= KMOD_META; } // filter out other modidifers event.key.keysym.mod &= (KMOD_SHIFT | KMOD_ALT | KMOD_CTRL | KMOD_META); // add F11/F12 state event.key.keysym.mod |= g_f11_state | g_f12_state; //printf("%d %d %d %d\n", event.key.keysym.mod, // KMOD_ALT, KMOD_LALT, KMOD_RALT); break; //case SDL_MOUSEBUTTONDOWN: // printf("--- mousebutton down ---\n"); } fs_ml_event *new_event = NULL; #if !defined(USE_SDL2) fs_ml_event *new_event_2 = NULL; #endif if (event.type == SDL_KEYDOWN) { new_event = fs_ml_alloc_event(); new_event->type = FS_ML_KEYDOWN; new_event->key.keysym.sym = event.key.keysym.sym; new_event->key.keysym.mod = event.key.keysym.mod; #ifdef USE_SDL2 // SDL2 sends its own text input events #else if (event.key.keysym.unicode && event.key.keysym.unicode < 128) { // FIXME: only supporting ASCII for now.. new_event_2 = fs_ml_alloc_event(); new_event_2->type = FS_ML_TEXTINPUT; new_event_2->text.text[0] = event.key.keysym.unicode; new_event_2->text.text[1] = '\0'; } #endif new_event->key.state = event.key.state; } else if (event.type == SDL_KEYUP) { new_event = fs_ml_alloc_event(); new_event->type = FS_ML_KEYUP; new_event->key.keysym.sym = event.key.keysym.sym; new_event->key.keysym.mod = event.key.keysym.mod; new_event->key.state = event.key.state; } else if (event.type == SDL_JOYBUTTONDOWN) { new_event = fs_ml_alloc_event(); new_event->type = FS_ML_JOYBUTTONDOWN; new_event->jbutton.which = g_fs_ml_first_joystick_index + \ event.jbutton.which; new_event->jbutton.button = event.jbutton.button; new_event->jbutton.state = event.jbutton.state; } else if (event.type == SDL_JOYBUTTONUP) { new_event = fs_ml_alloc_event(); new_event->type = FS_ML_JOYBUTTONUP; new_event->jbutton.which = g_fs_ml_first_joystick_index + \ event.jbutton.which; new_event->jbutton.button = event.jbutton.button; new_event->jbutton.state = event.jbutton.state; } else if (event.type == SDL_JOYAXISMOTION) { new_event = fs_ml_alloc_event(); new_event->type = FS_ML_JOYAXISMOTION; new_event->jaxis.which = g_fs_ml_first_joystick_index + \ event.jaxis.which; new_event->jaxis.axis = event.jaxis.axis; new_event->jaxis.value = event.jaxis.value; } else if (event.type == SDL_JOYHATMOTION) { new_event = fs_ml_alloc_event(); new_event->type = FS_ML_JOYHATMOTION; new_event->jhat.which = g_fs_ml_first_joystick_index + \ event.jhat.which; new_event->jhat.hat = event.jhat.hat; new_event->jhat.value = event.jhat.value; } else if (event.type == SDL_MOUSEMOTION) { new_event = fs_ml_alloc_event(); new_event->type = FS_ML_MOUSEMOTION; new_event->motion.device = g_fs_ml_first_mouse_index; new_event->motion.xrel = event.motion.xrel; new_event->motion.yrel = event.motion.yrel; /* Absolute window coordinates */ new_event->motion.x = event.motion.x; new_event->motion.y = event.motion.y; //printf("ISREL %d\n", SDL_GetRelativeMouseMode()); if (g_debug_input) { fs_log("SDL mouse event x: %4d y: %4d xrel: %4d yrel: %4d\n", event.motion.x, event.motion.y, event.motion.xrel, event.motion.yrel); } } else if (event.type == SDL_MOUSEBUTTONDOWN) { new_event = fs_ml_alloc_event(); new_event->type = FS_ML_MOUSEBUTTONDOWN; new_event->button.device = g_fs_ml_first_mouse_index; new_event->button.button = event.button.button; #ifdef MACOSX if (new_event->button.button == 1) { int mod = SDL_GetModState(); if (mod & KMOD_ALT) { new_event->button.button = 2; } else if (mod & KMOD_CTRL) { new_event->button.button = 3; } } #endif new_event->button.state = event.button.state; } else if (event.type == SDL_MOUSEBUTTONUP) { new_event = fs_ml_alloc_event(); new_event->type = FS_ML_MOUSEBUTTONUP; new_event->button.device = g_fs_ml_first_mouse_index; new_event->button.button = event.button.button; #ifdef MACOSX if (new_event->button.button == 1) { int mod = SDL_GetModState(); if (mod & KMOD_ALT) { new_event->button.button = 2; } else if (mod & KMOD_CTRL) { new_event->button.button = 3; } } #endif new_event->button.state = event.button.state; } #ifdef USE_SDL2 else if (event.type == SDL_MOUSEWHEEL) { /* if (event.wheel.which == SDL_TOUCH_MOUSEID) { } */ if (event.wheel.y) { if (g_debug_input) { fs_log("SDL mouse event y-scroll: %4d\n", event.wheel.y); } new_event = fs_ml_alloc_event(); new_event->type = FS_ML_MOUSEBUTTONDOWN; if (event.wheel.y > 0) { new_event->button.button = FS_ML_BUTTON_WHEELUP; } else { new_event->button.button = FS_ML_BUTTON_WHEELDOWN; } new_event->button.device = g_fs_ml_first_mouse_index; new_event->button.state = 1; } } else if (event.type == SDL_TEXTINPUT) { new_event = fs_ml_alloc_event(); new_event->type = FS_ML_TEXTINPUT; memcpy(&(new_event->text.text), &(event.text.text), MIN(TEXTINPUTEVENT_TEXT_SIZE, SDL_TEXTINPUTEVENT_TEXT_SIZE)); new_event->text.text[TEXTINPUTEVENT_TEXT_SIZE - 1] = 0; } #endif if (new_event) { fs_ml_post_event(new_event); } #if !defined(USE_SDL2) if (new_event_2) { fs_ml_post_event(new_event_2); } #endif } return result; }
int main(int argc, char *argv[]) { int quit = 0; /* event handler */ SDL_Event event; /* set text color as black */ SDL_Color textColor = { 0, 0, 0, 255 }; /* current time start time */ Uint32 startTime = 0; char timeText[128]; /* starts up SDL and create window */ if (init_sdl() == -1) { fprintf(stderr, "Failed to initialize SDL!\n"); return -1; } /* load media */ if (load_media() == -1) { fprintf(stderr, "Failed to load media!\n"); return -2; } /* main loop */ while (quit == 0) { /* handle events on queue */ while (SDL_PollEvent(&event) != 0) { /* users request quit */ if (event.type == SDL_QUIT) quit = 1; /* reset start time on return key press */ else if (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_RETURN) { startTime = SDL_GetTicks(); } } /* set text to be rendered */ snprintf(timeText, sizeof(timeText), "%d", SDL_GetTicks() - startTime); /* render text */ if (gTimeTextTexture.loadFromRenderedText(timeText, textColor) == -1) fprintf(stderr, "Unable to render time texture!\n"); /* clear screen */ SDL_SetRenderDrawColor(gRenderer, 0xFF, 0xFF, 0xFF, 0xFF); SDL_RenderClear(gRenderer); /* render texture */ gPromptTexture.render((SCREEN_WIDTH - gPromptTexture.getWidth()) / 2, 0); gTimeTextTexture.render((SCREEN_WIDTH - gTimeTextTexture.getWidth()) / 2, (SCREEN_HEIGHT - gTimeTextTexture.getHeight()) / 2); /* update screen */ SDL_RenderPresent(gRenderer); } /* free resources and close */ close_sdl(); return 0; }
void Input_Frame(void) { static bool sbOldMouseState = false; while(SDL_PollEvent(&sEvent)) { switch(sEvent.type) { case SDL_WINDOWEVENT: switch(sEvent.window.event) { case SDL_WINDOWEVENT_FOCUS_GAINED: Video.bActive = true; // Then restore it. if(sbOldMouseState) Input_ActivateMouse(); else Input_DeactivateMouse(); // Window isn't active! Clear states. Key_ClearStates(); break; case SDL_WINDOWEVENT_FOCUS_LOST: Video.bActive = false; // Save our old mouse state. sbOldMouseState = bMouseActive; Input_DeactivateMouse(); // Window isn't active! Clear states. Key_ClearStates(); break; case SDL_WINDOWEVENT_RESIZED: Video_UpdateWindow(); break; case SDL_WINDOWEVENT_CLOSE: Sys_Quit(); break; } break; case SDL_KEYDOWN: case SDL_KEYUP: Key_Event(Input_ConvertKey(sEvent.key.keysym.sym),(sEvent.key.state == SDL_PRESSED)); break; case SDL_MOUSEMOTION: if (bIsDedicated || !bMouseActive) return; // Originally handled this differently for fullscreen but this works fine apparently! if(((unsigned)sEvent.motion.x != (Video.iWidth/2)) || ((unsigned)sEvent.motion.y != (Video.iHeight/2))) { iMousePosition[pX] = sEvent.motion.xrel*5; iMousePosition[pY] = sEvent.motion.yrel*5; // [22/12/2013] TODO: This currently isn't accounting for any frame-loss... Ugh ~hogsy if( ((unsigned)sEvent.motion.x < Video.iWidth) || ((unsigned)sEvent.motion.x > Video.iWidth) || ((unsigned)sEvent.motion.y < Video.iHeight) || ((unsigned)sEvent.motion.y > Video.iHeight)) SDL_WarpMouseInWindow(sMainWindow,Video.iWidth/2,Video.iHeight/2); } break; case SDL_MOUSEBUTTONDOWN: case SDL_MOUSEBUTTONUP: if(sEvent.button.button <= 18) Key_Event(InputMouseRemap[sEvent.button.button-1],(sEvent.button.state == SDL_PRESSED)); break; case SDL_MOUSEWHEEL: if(sEvent.wheel.y > 0) { Key_Event(K_MWHEELUP,true); Key_Event(K_MWHEELUP,false); } else { Key_Event(K_MWHEELDOWN,true); Key_Event(K_MWHEELDOWN,false); } break; /* Controller Input */ case SDL_CONTROLLERBUTTONDOWN: case SDL_CONTROLLERBUTTONUP: break; /* Joystick Input */ case SDL_JOYAXISMOTION: if((sEvent.jaxis.value > INPUT_MAX_ZONE) || (sEvent.jaxis.value < INPUT_MIN_ZONE)) { } break; case SDL_JOYBALLMOTION: case SDL_JOYHATMOTION: case SDL_JOYBUTTONDOWN: case SDL_JOYBUTTONUP: break; case SDL_QUIT: Sys_Quit(); break; } } }
/* =============== IN_ProcessEvents =============== */ static void IN_ProcessEvents( void ) { SDL_Event e; const char *character = NULL; keyNum_t key = 0; if( !SDL_WasInit( SDL_INIT_VIDEO ) ) return; if( Key_GetCatcher( ) == 0 && keyRepeatEnabled ) { SDL_EnableKeyRepeat( 0, 0 ); keyRepeatEnabled = qfalse; } else if( !keyRepeatEnabled ) { SDL_EnableKeyRepeat( SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL ); keyRepeatEnabled = qtrue; } while( SDL_PollEvent( &e ) ) { switch( e.type ) { case SDL_KEYDOWN: character = IN_TranslateSDLToQ3Key( &e.key.keysym, &key, qtrue ); if( key ) Com_QueueEvent( 0, SE_KEY, key, qtrue, 0, NULL ); if( character ) Com_QueueEvent( 0, SE_CHAR, *character, 0, 0, NULL ); break; case SDL_KEYUP: IN_TranslateSDLToQ3Key( &e.key.keysym, &key, qfalse ); if( key ) Com_QueueEvent( 0, SE_KEY, key, qfalse, 0, NULL ); break; case SDL_MOUSEMOTION: if( mouseActive ) { if( !e.motion.xrel && !e.motion.yrel ) break; Com_QueueEvent( 0, SE_MOUSE, e.motion.xrel, e.motion.yrel, 0, NULL ); } break; case SDL_MOUSEBUTTONDOWN: case SDL_MOUSEBUTTONUP: { int b; switch( e.button.button ) { case SDL_BUTTON_LEFT: b = K_MOUSE1; break; case SDL_BUTTON_MIDDLE: b = K_MOUSE3; break; case SDL_BUTTON_RIGHT: b = K_MOUSE2; break; case SDL_BUTTON_WHEELUP: b = K_MWHEELUP; break; case SDL_BUTTON_WHEELDOWN: b = K_MWHEELDOWN; break; case SDL_BUTTON_X1: b = K_MOUSE4; break; case SDL_BUTTON_X2: b = K_MOUSE5; break; default: b = K_AUX1 + ( e.button.button - SDL_BUTTON_X2 + 1 ) % 16; break; } Com_QueueEvent( 0, SE_KEY, b, ( e.type == SDL_MOUSEBUTTONDOWN ? qtrue : qfalse ), 0, NULL ); } break; case SDL_QUIT: Sys_Quit( ); break; case SDL_VIDEORESIZE: { char width[32], height[32]; Com_sprintf( width, sizeof(width), "%d", e.resize.w ); Com_sprintf( height, sizeof(height), "%d", e.resize.h ); ri.Cvar_Set( "r_customwidth", width ); ri.Cvar_Set( "r_customheight", height ); ri.Cvar_Set( "r_mode", "-1" ); /* wait until user stops dragging for 1 second, so we aren't constantly recreating the GL context while he tries to drag...*/ vidRestartTime = Sys_Milliseconds() + 1000; } break; case SDL_ACTIVEEVENT: if (e.active.state & SDL_APPINPUTFOCUS) { Cvar_SetValue( "com_unfocused", !e.active.gain); } if (e.active.state & SDL_APPACTIVE) { Cvar_SetValue( "com_minimized", !e.active.gain); } break; default: break; } } }
int main(int argc, char *argv[]) { #if PPSSPP_PLATFORM(RPI) bcm_host_init(); #endif putenv((char*)"SDL_VIDEO_CENTERED=1"); SDL_SetHint(SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS, "0"); std::string app_name; std::string app_name_nice; std::string version; bool landscape; NativeGetAppInfo(&app_name, &app_name_nice, &landscape, &version); bool joystick_enabled = true; if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK | SDL_INIT_GAMECONTROLLER | SDL_INIT_AUDIO) < 0) { joystick_enabled = false; if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO) < 0) { fprintf(stderr, "Unable to initialize SDL: %s\n", SDL_GetError()); return 1; } } #ifdef __APPLE__ // Make sure to request a somewhat modern GL context at least - the // latest supported by MacOSX (really, really sad...) // Requires SDL 2.0 // We really should upgrade to SDL 2.0 soon. //SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE); //SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3); //SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2); #endif #ifdef USING_EGL if (EGL_Open()) return 1; #endif // Get the video info before doing anything else, so we don't get skewed resolution results. // TODO: support multiple displays correctly SDL_DisplayMode displayMode; int should_be_zero = SDL_GetCurrentDisplayMode(0, &displayMode); if (should_be_zero != 0) { fprintf(stderr, "Could not get display mode: %s\n", SDL_GetError()); return 1; } g_DesktopWidth = displayMode.w; g_DesktopHeight = displayMode.h; 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_STENCIL_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); SDL_GL_SetSwapInterval(1); Uint32 mode; #ifdef USING_GLES2 mode = SDL_WINDOW_OPENGL | SDL_WINDOW_FULLSCREEN; #else mode = SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE; #endif int set_xres = -1; int set_yres = -1; bool portrait = false; bool set_ipad = false; float set_dpi = 1.0f; float set_scale = 1.0f; // Produce a new set of arguments with the ones we skip. int remain_argc = 1; const char *remain_argv[256] = { argv[0] }; for (int i = 1; i < argc; i++) { if (!strcmp(argv[i],"--fullscreen")) mode |= SDL_WINDOW_FULLSCREEN_DESKTOP; else if (set_xres == -2) set_xres = parseInt(argv[i]); else if (set_yres == -2) set_yres = parseInt(argv[i]); else if (set_dpi == -2) set_dpi = parseFloat(argv[i]); else if (set_scale == -2) set_scale = parseFloat(argv[i]); else if (!strcmp(argv[i],"--xres")) set_xres = -2; else if (!strcmp(argv[i],"--yres")) set_yres = -2; else if (!strcmp(argv[i],"--dpi")) set_dpi = -2; else if (!strcmp(argv[i],"--scale")) set_scale = -2; else if (!strcmp(argv[i],"--ipad")) set_ipad = true; else if (!strcmp(argv[i],"--portrait")) portrait = true; else { remain_argv[remain_argc++] = argv[i]; } } // Is resolution is too low to run windowed if (g_DesktopWidth < 480 * 2 && g_DesktopHeight < 272 * 2) { mode |= SDL_WINDOW_FULLSCREEN_DESKTOP; } if (mode & SDL_WINDOW_FULLSCREEN_DESKTOP) { pixel_xres = g_DesktopWidth; pixel_yres = g_DesktopHeight; g_Config.bFullScreen = true; } else { // set a sensible default resolution (2x) pixel_xres = 480 * 2 * set_scale; pixel_yres = 272 * 2 * set_scale; if (portrait) { std::swap(pixel_xres, pixel_yres); } g_Config.bFullScreen = false; } set_dpi = 1.0f / set_dpi; if (set_ipad) { pixel_xres = 1024; pixel_yres = 768; } if (!landscape) { std::swap(pixel_xres, pixel_yres); } if (set_xres > 0) { pixel_xres = set_xres; } if (set_yres > 0) { pixel_yres = set_yres; } float dpi_scale = 1.0f; if (set_dpi > 0) { dpi_scale = set_dpi; } dp_xres = (float)pixel_xres * dpi_scale; dp_yres = (float)pixel_yres * dpi_scale; #ifdef _MSC_VER // VFSRegister("temp/", new DirectoryAssetReader("E:\\Temp\\")); TCHAR path[MAX_PATH]; SHGetFolderPath(NULL, CSIDL_APPDATA, NULL, 0, path); PathAppend(path, (app_name + "\\").c_str()); #else // Mac / Linux char path[2048]; const char *the_path = getenv("HOME"); if (!the_path) { struct passwd* pwd = getpwuid(getuid()); if (pwd) the_path = pwd->pw_dir; } strcpy(path, the_path); if (path[strlen(path)-1] != '/') strcat(path, "/"); #endif #ifdef _WIN32 NativeInit(remain_argc, (const char **)remain_argv, path, "D:\\", nullptr); #else NativeInit(remain_argc, (const char **)remain_argv, path, "/tmp", nullptr); #endif // Use the setting from the config when initing the window. if (g_Config.bFullScreen) mode |= SDL_WINDOW_FULLSCREEN_DESKTOP; g_Screen = SDL_CreateWindow(app_name_nice.c_str(), SDL_WINDOWPOS_UNDEFINED_DISPLAY(getDisplayNumber()),\ SDL_WINDOWPOS_UNDEFINED, pixel_xres, pixel_yres, mode); if (g_Screen == NULL) { NativeShutdown(); fprintf(stderr, "SDL_CreateWindow failed: %s\n", SDL_GetError()); SDL_Quit(); return 2; } SDL_GLContext glContext = SDL_GL_CreateContext(g_Screen); if (glContext == NULL) { NativeShutdown(); fprintf(stderr, "SDL_GL_CreateContext failed: %s\n", SDL_GetError()); SDL_Quit(); return 2; } #ifdef USING_EGL EGL_Init(); #endif SDL_SetWindowTitle(g_Screen, (app_name_nice + " " + PPSSPP_GIT_VERSION).c_str()); #ifdef MOBILE_DEVICE SDL_ShowCursor(SDL_DISABLE); #endif #ifndef USING_GLES2 // Some core profile drivers elide certain extensions from GL_EXTENSIONS/etc. // glewExperimental allows us to force GLEW to search for the pointers anyway. if (gl_extensions.IsCoreContext) glewExperimental = true; if (GLEW_OK != glewInit()) { printf("Failed to initialize glew!\n"); return 1; } // Unfortunately, glew will generate an invalid enum error, ignore. if (gl_extensions.IsCoreContext) glGetError(); if (GLEW_VERSION_2_0) { printf("OpenGL 2.0 or higher.\n"); } else { printf("Sorry, this program requires OpenGL 2.0.\n"); return 1; } #endif pixel_in_dps_x = (float)pixel_xres / dp_xres; pixel_in_dps_y = (float)pixel_yres / dp_yres; g_dpi_scale_x = dp_xres / (float)pixel_xres; g_dpi_scale_y = dp_yres / (float)pixel_yres; g_dpi_scale_real_x = g_dpi_scale_x; g_dpi_scale_real_y = g_dpi_scale_y; printf("Pixels: %i x %i\n", pixel_xres, pixel_yres); printf("Virtual pixels: %i x %i\n", dp_xres, dp_yres); GraphicsContext *graphicsContext = new GLDummyGraphicsContext(); NativeInitGraphics(graphicsContext); NativeResized(); SDL_AudioSpec fmt, ret_fmt; memset(&fmt, 0, sizeof(fmt)); fmt.freq = 44100; fmt.format = AUDIO_S16; fmt.channels = 2; fmt.samples = 2048; fmt.callback = &mixaudio; fmt.userdata = (void *)0; if (SDL_OpenAudio(&fmt, &ret_fmt) < 0) { ELOG("Failed to open audio: %s", SDL_GetError()); } else { if (ret_fmt.samples != fmt.samples) // Notify, but still use it ELOG("Output audio samples: %d (requested: %d)", ret_fmt.samples, fmt.samples); if (ret_fmt.freq != fmt.freq || ret_fmt.format != fmt.format || ret_fmt.channels != fmt.channels) { ELOG("Sound buffer format does not match requested format."); ELOG("Output audio freq: %d (requested: %d)", ret_fmt.freq, fmt.freq); ELOG("Output audio format: %d (requested: %d)", ret_fmt.format, fmt.format); ELOG("Output audio channels: %d (requested: %d)", ret_fmt.channels, fmt.channels); ELOG("Provided output format does not match requirement, turning audio off"); SDL_CloseAudio(); } } // Audio must be unpaused _after_ NativeInit() SDL_PauseAudio(0); #ifndef _WIN32 if (joystick_enabled) { joystick = new SDLJoystick(); } else { joystick = nullptr; } #endif EnableFZ(); int framecount = 0; float t = 0; float lastT = 0; bool mouseDown = false; while (true) { SDL_Event event; while (SDL_PollEvent(&event)) { float mx = event.motion.x * g_dpi_scale_x; float my = event.motion.y * g_dpi_scale_y; switch (event.type) { case SDL_QUIT: g_QuitRequested = 1; break; #if !defined(MOBILE_DEVICE) case SDL_WINDOWEVENT: switch (event.window.event) { case SDL_WINDOWEVENT_RESIZED: { Uint32 window_flags = SDL_GetWindowFlags(g_Screen); bool fullscreen = (window_flags & SDL_WINDOW_FULLSCREEN); pixel_xres = event.window.data1; pixel_yres = event.window.data2; dp_xres = (float)pixel_xres * dpi_scale; dp_yres = (float)pixel_yres * dpi_scale; NativeResized(); // Set variable here in case fullscreen was toggled by hotkey g_Config.bFullScreen = fullscreen; // Hide/Show cursor correctly toggling fullscreen if (lastUIState == UISTATE_INGAME && fullscreen && !g_Config.bShowTouchControls) { SDL_ShowCursor(SDL_DISABLE); } else if (lastUIState != UISTATE_INGAME || !fullscreen) { SDL_ShowCursor(SDL_ENABLE); } break; } default: break; } break; #endif case SDL_KEYDOWN: { if (event.key.repeat > 0) { break;} int k = event.key.keysym.sym; KeyInput key; key.flags = KEY_DOWN; auto mapped = KeyMapRawSDLtoNative.find(k); if (mapped == KeyMapRawSDLtoNative.end() || mapped->second == NKCODE_UNKNOWN) { break; } key.keyCode = mapped->second; key.deviceId = DEVICE_ID_KEYBOARD; NativeKey(key); break; } case SDL_KEYUP: { if (event.key.repeat > 0) { break;} int k = event.key.keysym.sym; KeyInput key; key.flags = KEY_UP; auto mapped = KeyMapRawSDLtoNative.find(k); if (mapped == KeyMapRawSDLtoNative.end() || mapped->second == NKCODE_UNKNOWN) { break; } key.keyCode = mapped->second; key.deviceId = DEVICE_ID_KEYBOARD; NativeKey(key); break; } case SDL_TEXTINPUT: { int pos = 0; int c = u8_nextchar(event.text.text, &pos); KeyInput key; key.flags = KEY_CHAR; key.keyCode = c; key.deviceId = DEVICE_ID_KEYBOARD; NativeKey(key); break; } case SDL_MOUSEBUTTONDOWN: switch (event.button.button) { case SDL_BUTTON_LEFT: { mouseDown = true; TouchInput input; input.x = mx; input.y = my; input.flags = TOUCH_DOWN | TOUCH_MOUSE; input.id = 0; NativeTouch(input); KeyInput key(DEVICE_ID_MOUSE, NKCODE_EXT_MOUSEBUTTON_1, KEY_DOWN); NativeKey(key); } break; case SDL_BUTTON_RIGHT: { KeyInput key(DEVICE_ID_MOUSE, NKCODE_EXT_MOUSEBUTTON_2, KEY_DOWN); NativeKey(key); } break; } break; case SDL_MOUSEWHEEL: { KeyInput key; key.deviceId = DEVICE_ID_MOUSE; if (event.wheel.y > 0) { key.keyCode = NKCODE_EXT_MOUSEWHEEL_UP; } else { key.keyCode = NKCODE_EXT_MOUSEWHEEL_DOWN; } key.flags = KEY_DOWN; NativeKey(key); // SDL2 doesn't consider the mousewheel a button anymore // so let's send the KEY_UP right away. // Maybe KEY_UP alone will suffice? key.flags = KEY_UP; NativeKey(key); } case SDL_MOUSEMOTION: if (mouseDown) { TouchInput input; input.x = mx; input.y = my; input.flags = TOUCH_MOVE | TOUCH_MOUSE; input.id = 0; NativeTouch(input); } break; case SDL_MOUSEBUTTONUP: switch (event.button.button) { case SDL_BUTTON_LEFT: { mouseDown = false; TouchInput input; input.x = mx; input.y = my; input.flags = TOUCH_UP | TOUCH_MOUSE; input.id = 0; NativeTouch(input); KeyInput key(DEVICE_ID_MOUSE, NKCODE_EXT_MOUSEBUTTON_1, KEY_UP); NativeKey(key); } break; case SDL_BUTTON_RIGHT: { KeyInput key(DEVICE_ID_MOUSE, NKCODE_EXT_MOUSEBUTTON_2, KEY_UP); NativeKey(key); } break; } break; default: #ifndef _WIN32 if (joystick) { joystick->ProcessInput(event); } #endif break; } } if (g_QuitRequested) break; const uint8_t *keys = SDL_GetKeyboardState(NULL); UpdateRunLoop(); if (g_QuitRequested) break; #if !defined(MOBILE_DEVICE) if (lastUIState != GetUIState()) { lastUIState = GetUIState(); if (lastUIState == UISTATE_INGAME && g_Config.bFullScreen && !g_Config.bShowTouchControls) SDL_ShowCursor(SDL_DISABLE); if (lastUIState != UISTATE_INGAME && g_Config.bFullScreen) SDL_ShowCursor(SDL_ENABLE); } #endif if (framecount % 60 == 0) { // glsl_refresh(); // auto-reloads modified GLSL shaders once per second. } #ifdef USING_EGL eglSwapBuffers(g_eglDisplay, g_eglSurface); #else if (!keys[SDLK_TAB] || t - lastT >= 1.0/60.0) { SDL_GL_SwapWindow(g_Screen); lastT = t; } #endif ToggleFullScreenIfFlagSet(); time_update(); t = time_now(); framecount++; } #ifndef _WIN32 delete joystick; #endif NativeShutdownGraphics(); graphicsContext->Shutdown(); NativeShutdown(); delete graphicsContext; // Faster exit, thanks to the OS. Remove this if you want to debug shutdown // The speed difference is only really noticable on Linux. On Windows you do notice it though #ifndef MOBILE_DEVICE exit(0); #endif SDL_PauseAudio(1); SDL_CloseAudio(); #ifdef USING_EGL EGL_Close(); #endif SDL_GL_DeleteContext(glContext); SDL_Quit(); #if PPSSPP_PLATFORM(RPI) bcm_host_deinit(); #endif exit(0); return 0; }
// Called each loop iteration bool M_Input::PreUpdate() { static SDL_Event event; const Uint8* keys = SDL_GetKeyboardState(NULL); for(int i = 0; i < MAX_KEYS; ++i) { if(keys[i] == 1) { if(keyboard[i] == KEY_IDLE) keyboard[i] = KEY_DOWN; else keyboard[i] = KEY_REPEAT; } else { if(keyboard[i] == KEY_REPEAT || keyboard[i] == KEY_DOWN) keyboard[i] = KEY_UP; else keyboard[i] = KEY_IDLE; } } mouse_motion_x = mouse_motion_y = 0; for(int i = 0; i < NUM_MOUSE_BUTTONS; ++i) { if(mouse_buttons[i] == KEY_DOWN) mouse_buttons[i] = KEY_REPEAT; if(mouse_buttons[i] == KEY_UP) mouse_buttons[i] = KEY_IDLE; } while(SDL_PollEvent(&event) != 0) { switch(event.type) { case SDL_QUIT: windowEvents[WE_QUIT] = true; break; case SDL_WINDOWEVENT: switch(event.window.event) { //case SDL_WINDOWEVENT_LEAVE: case SDL_WINDOWEVENT_HIDDEN: case SDL_WINDOWEVENT_MINIMIZED: case SDL_WINDOWEVENT_FOCUS_LOST: windowEvents[WE_HIDE] = true; break; //case SDL_WINDOWEVENT_ENTER: case SDL_WINDOWEVENT_SHOWN: case SDL_WINDOWEVENT_FOCUS_GAINED: case SDL_WINDOWEVENT_MAXIMIZED: case SDL_WINDOWEVENT_RESTORED: windowEvents[WE_SHOW] = true; break; } break; case SDL_MOUSEBUTTONDOWN: mouse_buttons[event.button.button - 1] = KEY_DOWN; //LOG("Mouse button %d down", event.button.button-1); break; case SDL_MOUSEBUTTONUP: mouse_buttons[event.button.button - 1] = KEY_UP; //LOG("Mouse button %d up", event.button.button-1); break; case SDL_MOUSEMOTION: { int scale = App->win->GetScale(); mouse_motion_x = event.motion.xrel / scale; mouse_motion_y = event.motion.yrel / scale; mouse_x = event.motion.x / scale; mouse_y = event.motion.y / scale; //LOG("Mouse motion x %d y %d", mouse_motion_x, mouse_motion_y); } break; case SDL_TEXTINPUT: App->gui->SendNewInput(event.text.text); break; } } return true; }
/** * The state machine takes care of passing all the events from SDL to the * active state, running any code within and blitting all the states and * cursor to the screen. This is run indefinitely until the game quits. */ void Game::run() { enum ApplicationState { RUNNING = 0, SLOWED = 1, PAUSED = 2 } runningState = RUNNING; static const ApplicationState kbFocusRun[4] = { RUNNING, RUNNING, SLOWED, PAUSED }; static const ApplicationState stateRun[4] = { SLOWED, PAUSED, PAUSED, PAUSED }; // this will avoid processing SDL's resize event on startup, workaround for the heap allocation error it causes. bool startupEvent = Options::allowResize; while (!_quit) { // Clean up states while (!_deleted.empty()) { delete _deleted.back(); _deleted.pop_back(); } // Initialize active state if (!_init) { _init = true; _states.back()->init(); // Unpress buttons _states.back()->resetAll(); // Refresh mouse position SDL_Event ev; int x, y; SDL_GetMouseState(&x, &y); ev.type = SDL_MOUSEMOTION; ev.motion.x = x; ev.motion.y = y; Action action = Action(&ev, _screen->getXScale(), _screen->getYScale(), _screen->getCursorTopBlackBand(), _screen->getCursorLeftBlackBand()); _states.back()->handle(&action); } // Process events while (SDL_PollEvent(&_event)) { if (CrossPlatform::isQuitShortcut(_event)) _event.type = SDL_QUIT; switch (_event.type) { case SDL_QUIT: quit(); break; case SDL_ACTIVEEVENT: switch (reinterpret_cast<SDL_ActiveEvent*>(&_event)->state) { case SDL_APPACTIVE: runningState = reinterpret_cast<SDL_ActiveEvent*>(&_event)->gain ? RUNNING : stateRun[Options::pauseMode]; break; case SDL_APPMOUSEFOCUS: // We consciously ignore it. break; case SDL_APPINPUTFOCUS: runningState = reinterpret_cast<SDL_ActiveEvent*>(&_event)->gain ? RUNNING : kbFocusRun[Options::pauseMode]; break; } break; case SDL_VIDEORESIZE: if (Options::allowResize) { if (!startupEvent) { Options::newDisplayWidth = Options::displayWidth = std::max(Screen::ORIGINAL_WIDTH, _event.resize.w); Options::newDisplayHeight = Options::displayHeight = std::max(Screen::ORIGINAL_HEIGHT, _event.resize.h); int dX = 0, dY = 0; Screen::updateScale(Options::battlescapeScale, Options::battlescapeScale, Options::baseXBattlescape, Options::baseYBattlescape, false); Screen::updateScale(Options::geoscapeScale, Options::geoscapeScale, Options::baseXGeoscape, Options::baseYGeoscape, false); for (std::list<State*>::iterator i = _states.begin(); i != _states.end(); ++i) { (*i)->resize(dX, dY); } _screen->resetDisplay(); } else { startupEvent = false; } } break; case SDL_MOUSEMOTION: case SDL_MOUSEBUTTONDOWN: case SDL_MOUSEBUTTONUP: // Skip mouse events if they're disabled if (!_mouseActive) continue; // re-gain focus on mouse-over or keypress. runningState = RUNNING; // Go on, feed the event to others default: Action action = Action(&_event, _screen->getXScale(), _screen->getYScale(), _screen->getCursorTopBlackBand(), _screen->getCursorLeftBlackBand()); _screen->handle(&action); _cursor->handle(&action); _fpsCounter->handle(&action); _states.back()->handle(&action); if (action.getDetails()->type == SDL_KEYDOWN) { // "ctrl-g" grab input if (action.getDetails()->key.keysym.sym == SDLK_g && (SDL_GetModState() & KMOD_CTRL) != 0) { Options::captureMouse = (SDL_GrabMode)(!Options::captureMouse); SDL_WM_GrabInput(Options::captureMouse); } else if (Options::debug) { if (action.getDetails()->key.keysym.sym == SDLK_t && (SDL_GetModState() & KMOD_CTRL) != 0) { setState(new TestState); } // "ctrl-u" debug UI else if (action.getDetails()->key.keysym.sym == SDLK_u && (SDL_GetModState() & KMOD_CTRL) != 0) { Options::debugUi = !Options::debugUi; _states.back()->redrawText(); } } } break; } } // Process rendering if (runningState != PAUSED) { // Process logic _states.back()->think(); _fpsCounter->think(); if (Options::FPS > 0 && !(Options::useOpenGL && Options::vSyncForOpenGL)) { // Update our FPS delay time based on the time of the last draw. int fps = SDL_GetAppState() & SDL_APPINPUTFOCUS ? Options::FPS : Options::FPSInactive; _timeUntilNextFrame = (1000.0f / fps) - (SDL_GetTicks() - _timeOfLastFrame); } else { _timeUntilNextFrame = 0; } if (_init && _timeUntilNextFrame <= 0) { // make a note of when this frame update occured. _timeOfLastFrame = SDL_GetTicks(); _fpsCounter->addFrame(); _screen->clear(); std::list<State*>::iterator i = _states.end(); do { --i; } while (i != _states.begin() && !(*i)->isScreen()); for (; i != _states.end(); ++i) { (*i)->blit(); } _fpsCounter->blit(_screen->getSurface()); _cursor->blit(_screen->getSurface()); _screen->flip(); } } // Save on CPU switch (runningState) { case RUNNING: SDL_Delay(1); //Save CPU from going 100% break; case SLOWED: case PAUSED: SDL_Delay(100); break; //More slowing down. } } Options::save(); }
static void sdl_refresh(DisplayState *ds) { SDL_Event ev1, *ev = &ev1; int mod_state; if (last_vm_running != vm_running) { last_vm_running = vm_running; sdl_update_caption(); } vga_hw_update(); while (SDL_PollEvent(ev)) { switch (ev->type) { case SDL_VIDEOEXPOSE: sdl_update(ds, 0, 0, screen->w, screen->h); break; case SDL_KEYDOWN: case SDL_KEYUP: if (ev->type == SDL_KEYDOWN) { mod_state = (SDL_GetModState() & gui_grab_code) == gui_grab_code; gui_key_modifier_pressed = mod_state; if (gui_key_modifier_pressed) { int keycode; keycode = sdl_keyevent_to_keycode(&ev->key); switch(keycode) { case 0x21: /* 'f' key on US keyboard */ toggle_full_screen(ds); gui_keysym = 1; break; case 0x02 ... 0x0a: /* '1' to '9' keys */ /* Reset the modifiers sent to the current console */ reset_keys(); console_select(keycode - 0x02); if (!is_graphic_console()) { /* display grab if going to a text console */ if (gui_grab) sdl_grab_end(); } gui_keysym = 1; break; default: break; } } else if (!is_graphic_console()) { int keysym; keysym = 0; if (ev->key.keysym.mod & (KMOD_LCTRL | KMOD_RCTRL)) { switch(ev->key.keysym.sym) { case SDLK_UP: keysym = QEMU_KEY_CTRL_UP; break; case SDLK_DOWN: keysym = QEMU_KEY_CTRL_DOWN; break; case SDLK_LEFT: keysym = QEMU_KEY_CTRL_LEFT; break; case SDLK_RIGHT: keysym = QEMU_KEY_CTRL_RIGHT; break; case SDLK_HOME: keysym = QEMU_KEY_CTRL_HOME; break; case SDLK_END: keysym = QEMU_KEY_CTRL_END; break; case SDLK_PAGEUP: keysym = QEMU_KEY_CTRL_PAGEUP; break; case SDLK_PAGEDOWN: keysym = QEMU_KEY_CTRL_PAGEDOWN; break; default: break; } } else { switch(ev->key.keysym.sym) { case SDLK_UP: keysym = QEMU_KEY_UP; break; case SDLK_DOWN: keysym = QEMU_KEY_DOWN; break; case SDLK_LEFT: keysym = QEMU_KEY_LEFT; break; case SDLK_RIGHT: keysym = QEMU_KEY_RIGHT; break; case SDLK_HOME: keysym = QEMU_KEY_HOME; break; case SDLK_END: keysym = QEMU_KEY_END; break; case SDLK_PAGEUP: keysym = QEMU_KEY_PAGEUP; break; case SDLK_PAGEDOWN: keysym = QEMU_KEY_PAGEDOWN; break; case SDLK_BACKSPACE: keysym = QEMU_KEY_BACKSPACE; break; case SDLK_DELETE: keysym = QEMU_KEY_DELETE; break; default: break; } } if (keysym) { kbd_put_keysym(keysym); } else if (ev->key.keysym.unicode != 0) { kbd_put_keysym(ev->key.keysym.unicode); } } } else if (ev->type == SDL_KEYUP) {
void FHTML5Application::PollGameDeviceState( const float TimeDelta ) { SDL_Event Event; while (SDL_PollEvent(&Event)) { // Tick Input Interface. switch (Event.type) { case SDL_WINDOWEVENT: { SDL_WindowEvent windowEvent = Event.window; // ignore resized client Height/Width #if PLATFORM_HTML5_BROWSER int fs; emscripten_get_canvas_size(&WindowWidth, &WindowHeight, &fs); UE_LOG(LogHTML5Application, Verbose, TEXT("emscripten_get_canvas_size: Width:%d, Height:%d, Fullscreen:%d"), WindowWidth, WindowHeight, fs); #endif #if PLATFORM_HTML5_WIN32 WindowWidth = windowEvent.data1; WindowHeight = windowEvent.data2; #endif switch (windowEvent.event) { case SDL_WINDOWEVENT_SIZE_CHANGED: { UE_LOG(LogHTML5Application, Verbose, TEXT("WindowSizeChanged: Width:%d, Height:%d"), WindowWidth, WindowHeight); FDisplayMetrics DisplayMetrics; FDisplayMetrics::GetDisplayMetrics(DisplayMetrics); if ( DisplayMetrics.PrimaryDisplayWidth != WindowWidth || DisplayMetrics.PrimaryDisplayHeight != WindowHeight ) { int32 delta = FMath::Abs<int32>(DisplayMetrics.PrimaryDisplayHeight - WindowHeight); if (delta > 2) // UE-35363: retina bug fix - otherwise, event does infinite loops { MessageHandler->OnSizeChanged(ApplicationWindow,WindowWidth,WindowHeight, false); MessageHandler->OnResizingWindow(ApplicationWindow); BroadcastDisplayMetricsChanged(DisplayMetrics); } } } break; case SDL_WINDOWEVENT_RESIZED: { UE_LOG(LogHTML5Application, Verbose, TEXT("WindowResized: Width:%d, Height:%d"), WindowWidth, WindowHeight); FDisplayMetrics DisplayMetrics; FDisplayMetrics::GetDisplayMetrics(DisplayMetrics); if ( DisplayMetrics.PrimaryDisplayWidth != WindowWidth || DisplayMetrics.PrimaryDisplayHeight != WindowHeight ) { int32 delta = FMath::Abs<int32>(DisplayMetrics.PrimaryDisplayHeight - WindowHeight); if (delta > 2) // UE-35363: retina bug fix - otherwise, event does infinite loops { MessageHandler->OnResizingWindow(ApplicationWindow); BroadcastDisplayMetricsChanged(DisplayMetrics); } } } break; case SDL_WINDOWEVENT_ENTER: { UE_LOG(LogHTML5Application, Verbose, TEXT("WindowEnter")); // MessageHandler->OnWindowActivationChanged(ApplicationWindow, EWindowActivation::Activate); WarmUpTicks = 0; } break; case SDL_WINDOWEVENT_LEAVE: { UE_LOG(LogHTML5Application, Verbose, TEXT("WindowLeave")); // MessageHandler->OnWindowActivationChanged(ApplicationWindow, EWindowActivation::Deactivate); } break; case SDL_WINDOWEVENT_FOCUS_GAINED: { UE_LOG(LogHTML5Application, Verbose, TEXT("WindowFocusGained")); MessageHandler->OnCursorSet(); MessageHandler->OnWindowActivationChanged(ApplicationWindow, EWindowActivation::Activate); WarmUpTicks = 0; } break; case SDL_WINDOWEVENT_FOCUS_LOST: { UE_LOG(LogHTML5Application, Verbose, TEXT("WindowFocusLost")); MessageHandler->OnWindowActivationChanged(ApplicationWindow, EWindowActivation::Deactivate); } break; default: break; } } default: { InputInterface->Tick( TimeDelta,Event, ApplicationWindow); } } } InputInterface->SendControllerEvents(); if ( WarmUpTicks >= 0) WarmUpTicks ++; if ( WarmUpTicks == MaxWarmUpTicks ) { // browsers don't allow locking and hiding to work independently. use warmup ticks after the application has settled // on its mouse lock/visibility status. This is necessary even in cases where the game doesn't want to locking because // the lock status oscillates for few ticks before settling down. This causes a Browser UI pop even when we don't intend to lock. // see http://www.w3.org/TR/pointerlock more for information. #if PLATFORM_HTML5_WIN32 SDL_Window* WindowHandle= SDL_GL_GetCurrentWindow(); if (((FHTML5Cursor*)Cursor.Get())->LockStatus && !((FHTML5Cursor*)Cursor.Get())->CursorStatus) { SDL_SetWindowGrab(WindowHandle, SDL_TRUE); SDL_ShowCursor(SDL_DISABLE); SDL_SetRelativeMouseMode(SDL_TRUE); } else { SDL_SetRelativeMouseMode(SDL_FALSE); SDL_ShowCursor(SDL_ENABLE); SDL_SetWindowGrab(WindowHandle, SDL_FALSE); } #endif #if PLATFORM_HTML5_BROWSER if (((FHTML5Cursor*)Cursor.Get())->LockStatus && !((FHTML5Cursor*)Cursor.Get())->CursorStatus) { UE_LOG(LogHTML5Application, Verbose, TEXT("Request pointer lock")); emscripten_request_pointerlock ( "#canvas" , true); } else { UE_LOG(LogHTML5Application, Verbose, TEXT("Exit pointer lock")); //emscripten_exit_pointerlock(); } #endif WarmUpTicks = -1; } }
void game::handelevents() { SDL_Event event; while (SDL_PollEvent(&event)) { switch (event.type) { case SDL_QUIT: running=false; return; case SDL_KEYDOWN: switch(event.key.keysym.sym) { case SDLK_LEFT : direction[0]=1; player1->setMoving(1); //player1->setJump(0); break; case SDLK_RIGHT: direction[1]=1; player1->setMoving(1); // player1->setJump(0); break; case SDLK_SPACE: player1->setJump(); player1->setMoving(0); break; case SDLK_c: if(player1->getDirection()=='r' && player1->getpower()==1) { bullets.push_back(new bullet(bull,player1->getRect()->x+player1->getRect()->w-8,player1->getRect()->y-5,5,0,10)); break; } if(player1->getDirection()=='l' && player1->getpower()==1) { bullets.push_back(new bullet(bull,player1->getRect()->x-player1->getRect()->w+10,player1->getRect()->y-5,-5,0,10)); break; case SDLK_ESCAPE : int h=pause(screen); if (h==1) running=false; break; } } break; case SDL_KEYUP: switch(event.key.keysym.sym) { case SDLK_LEFT : direction[0]=0; player1->setMoving(0); break; case SDLK_RIGHT: direction[1]=0; player1->setMoving(0); break; } break; } } }
Keyboard::Keyboard(){ Keyboard::Clear(); Keyboard::Quit=false; SDL_EnableKeyRepeat(50,50); SDL_PollEvent(NULL); }
int main(int argc, char* args[]) { std::cout << "Hello!\n"; int a = 1; while (argc > 1) { if (!strcmp(args[a], "s")) { ++a; --argc; continue; } } GFX::Init(); // SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_INFORMATION, "C", "H", NULL); App::Options.SMsCd = "/Volumes/contn/deviceuser/Downloads/Game/civ/"; std::vector<PICImage> PICs(10);//CivPicFiles.size()); std::vector<PICImageTexture> PICImageTextures(PICs.size()); for (int iter = 0; iter < PICs.size(); ++iter) { PICImageIni(App::Options.SMsCd + CivPicFiles[iter], &PICs[iter]); } for (int iter = 0; iter < PICImageTextures.size(); ++iter) { GFX::Create256ColourPICImageTexture(&PICs[iter], &PICImageTextures[iter], GFX::renderer_GFXRenderer); } int ti = 0; GFX::RenderPICImageTexture(PICs, PICImageTextures, ti, GFX::renderer_GFXRenderer); SDL_Event sdl_event; bool quit = false; while(!quit) { while(SDL_PollEvent(&sdl_event) != 0) { switch (sdl_event.type) { case SDL_QUIT: quit = true; break; case SDL_KEYDOWN: switch (sdl_event.key.keysym.sym) { case SDLK_RIGHT: if (ti < PICImageTextures.size() - 1) {ti++;} else {ti = 0;}; break; case SDLK_LEFT: if (ti == 0) {ti = PICImageTextures.size() - 1;} else {ti--;} break; } if (PICImageTextures[ti].PICImageTexture_datap != nullptr) { GFX::RenderPICImageTexture(PICs, PICImageTextures, ti, GFX::renderer_GFXRenderer); } break; } } } for (int iter = 0; iter < PICs.size(); ++iter) { if (PICs[iter].picimage_rawimage != nullptr) { delete PICs[iter].picimage_rawimage; PICs[iter].picimage_rawimage = nullptr; } } for (int iter = 0; iter < PICImageTextures.size(); ++iter) { if (PICImageTextures[iter].PICImageTexture_datap != nullptr) { SDL_DestroyTexture(PICImageTextures[iter].PICImageTexture_datap); PICImageTextures[iter].PICImageTexture_datap = nullptr; } } GFX::Quit(); std::cout << " Bye.\n"; return 0; }
/** ** Wait for interactive input event for one frame. ** ** Handles system events, joystick, keyboard, mouse. ** Handles the network messages. ** Handles the sound queue. ** ** All events available are fetched. Sound and network only if available. ** Returns if the time for one frame is over. ** ** @param callbacks Call backs that handle the events. */ global void WaitEventsOneFrame(const EventCallback* callbacks) { struct timeval tv; fd_set rfds; fd_set wfds; int maxfd; Uint32 i; SDL_Event event[1]; if( SoundFildes==-1 ) { SoundOff=1; } InputMouseTimeout(callbacks,SDL_GetTicks()); for(;;) { #if 1 static Uint32 LastTick; // // Time of frame over? This makes the CPU happy. :( // i=WinCE_GetTicks(); while( i>=LastTick ) { ++VideoInterrupts; LastTick+=(100*1000/CYCLES_PER_SECOND)/VideoSyncSpeed; } #endif // // Prepare select // maxfd=0; tv.tv_sec=tv.tv_usec=0; FD_ZERO(&rfds); FD_ZERO(&wfds); // // Network // if( NetworkFildes!=-1 ) { if( NetworkFildes>maxfd ) { maxfd=NetworkFildes; } FD_SET(NetworkFildes,&rfds); } // // Sound // if( !SoundOff && !SoundThreadRunning ) { if( SoundFildes>maxfd ) { maxfd=SoundFildes; } FD_SET(SoundFildes,&wfds); } #if 0 maxfd=select(maxfd+1,&rfds,&wfds,NULL ,(i=SDL_PollEvent(event)) ? &tv : NULL); #else // QUICK HACK to fix the event/timer problem // The timer code didn't interrupt the select call. // Perhaps I could send a signal to the process // Not very nice, but this is the problem if you use other libraries // The event handling of SDL is wrong designed = polling only. // There is hope on SDL 1.3 which will have this fixed. maxfd=select(maxfd+1,&rfds,&wfds,NULL,&tv); i=SDL_PollEvent(event); #endif if ( i ) { // Handle SDL event SdlDoEvent(callbacks,event); } if( maxfd>0 ) { // // Sound // if( !SoundOff && !SoundThreadRunning && FD_ISSET(SoundFildes,&wfds) ) { callbacks->SoundReady(); } // // Not more input and network in syn and time for frame over // if( !i && NetworkInSync && VideoInterrupts ) { break; } // // Network // if( NetworkFildes!=-1 && FD_ISSET(NetworkFildes,&rfds) ) { callbacks->NetworkEvent(); } } // // Not more input and time for frame over: return // if( !i && VideoInterrupts ) { break; } } // // Prepare return, time for one frame is over. // VideoInterrupts=0; }
int main(int argc, char *argv[]) { int i, done; const char *driver; SDL_Window *window; SDL_Renderer *renderer; SDL_Texture *sprite; int window_w, window_h; int sprite_w, sprite_h; SDL_Event event; /* Enable standard application logging */ SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO); if (SDL_VideoInit(NULL) < 0) { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't initialize SDL video: %s\n", SDL_GetError()); exit(1); } driver = SDL_GetCurrentVideoDriver(); /* Find a native window driver and create a native window */ for (i = 0; factories[i]; ++i) { if (SDL_strcmp(driver, factories[i]->tag) == 0) { factory = factories[i]; break; } } if (!factory) { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't find native window code for %s driver\n", driver); quit(2); } SDL_Log("Creating native window for %s driver\n", driver); native_window = factory->CreateNativeWindow(WINDOW_W, WINDOW_H); if (!native_window) { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create native window\n"); quit(3); } window = SDL_CreateWindowFrom(native_window); if (!window) { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create SDL window: %s\n", SDL_GetError()); quit(4); } SDL_SetWindowTitle(window, "SDL Native Window Test"); /* Create the renderer */ renderer = SDL_CreateRenderer(window, -1, 0); if (!renderer) { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create renderer: %s\n", SDL_GetError()); quit(5); } /* Clear the window, load the sprite and go! */ SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, 0xFF); SDL_RenderClear(renderer); sprite = LoadSprite(renderer, "icon.bmp"); if (!sprite) { quit(6); } /* Allocate memory for the sprite info */ SDL_GetWindowSize(window, &window_w, &window_h); SDL_QueryTexture(sprite, NULL, NULL, &sprite_w, &sprite_h); positions = (SDL_Rect *) SDL_malloc(NUM_SPRITES * sizeof(SDL_Rect)); velocities = (SDL_Rect *) SDL_malloc(NUM_SPRITES * sizeof(SDL_Rect)); if (!positions || !velocities) { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Out of memory!\n"); quit(2); } srand(time(NULL)); for (i = 0; i < NUM_SPRITES; ++i) { positions[i].x = rand() % (window_w - sprite_w); positions[i].y = rand() % (window_h - sprite_h); positions[i].w = sprite_w; positions[i].h = sprite_h; velocities[i].x = 0; velocities[i].y = 0; while (!velocities[i].x && !velocities[i].y) { velocities[i].x = (rand() % (MAX_SPEED * 2 + 1)) - MAX_SPEED; velocities[i].y = (rand() % (MAX_SPEED * 2 + 1)) - MAX_SPEED; } } /* Main render loop */ done = 0; while (!done) { /* Check for events */ while (SDL_PollEvent(&event)) { switch (event.type) { case SDL_WINDOWEVENT: switch (event.window.event) { case SDL_WINDOWEVENT_EXPOSED: SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, 0xFF); SDL_RenderClear(renderer); break; } break; case SDL_QUIT: done = 1; break; default: break; } } MoveSprites(renderer, sprite); } quit(0); return 0; /* to prevent compiler warning */ }
void loop() { SDL_Event event; // Get the stage as it will receive most events. Loom2D::Stage *stage = Loom2D::Stage::smMainStage; /* Check for events */ while (SDL_PollEvent(&event)) { if (event.type == SDL_QUIT) { // Terminate execution. gLoomExecutionDone = 1; continue; } // Bail on the rest if no stage! if(!stage) continue; // Adjust coordinates for mouse events to work properly on high dpi screens. if(event.type == SDL_MOUSEMOTION || event.type == SDL_MOUSEBUTTONDOWN || event.type == SDL_MOUSEBUTTONUP) { if (SDL_GetWindowFlags(gSDLWindow) & SDL_WINDOW_ALLOW_HIGHDPI) { // We work in drawable space but OS gives us these events in // window coords - so scale. Usually it's an integer scale. int winW, winH; SDL_GetWindowSize(gSDLWindow, &winW, &winH); int drawableW, drawableH; SDL_GL_GetDrawableSize(gSDLWindow, &drawableW, &drawableH); if(event.type == SDL_MOUSEMOTION) { event.motion.x *= drawableW / winW; event.motion.y *= drawableH / winH; } else { event.button.x *= drawableW / winW; event.button.y *= drawableH / winH; } } } if(event.type == SDL_KEYDOWN) { SDL_Keysym key = event.key.keysym; // Handle a key! stage->_KeyDownDelegate.pushArgument(key.scancode); stage->_KeyDownDelegate.pushArgument(key.sym); stage->_KeyDownDelegate.pushArgument(key.mod); stage->_KeyDownDelegate.invoke(); //lmLog(coreLogGroup, "keydown %d %d", key.sym, SDLK_BACKSPACE); if (SDL_IsTextInputActive() && key.mod == KMOD_NONE && key.sym == SDLK_BACKSPACE) IMEDelegateDispatcher::shared()->dispatchDeleteBackward(); if (key.mod & KMOD_CTRL && key.sym == SDLK_v) { char* clipboard = SDL_GetClipboardText(); IMEDelegateDispatcher::shared()->dispatchInsertText(clipboard, strlen(clipboard)); SDL_free(clipboard); } } else if(event.type == SDL_KEYUP) { stage->_KeyUpDelegate.pushArgument(event.key.keysym.scancode); stage->_KeyUpDelegate.pushArgument(event.key.keysym.sym); stage->_KeyUpDelegate.pushArgument(event.key.keysym.mod); stage->_KeyUpDelegate.invoke(); } else if(event.type == SDL_FINGERDOWN) { if (!stage->fingerEnabled) continue; stage->_TouchBeganDelegate.pushArgument((int)event.tfinger.fingerId); stage->_TouchBeganDelegate.pushArgument(event.tfinger.x*stage->stageWidth); stage->_TouchBeganDelegate.pushArgument(event.tfinger.y*stage->stageHeight); stage->_TouchBeganDelegate.invoke(); } else if(event.type == SDL_FINGERUP) { if (!stage->fingerEnabled) continue; stage->_TouchEndedDelegate.pushArgument((int)event.tfinger.fingerId); stage->_TouchEndedDelegate.pushArgument(event.tfinger.x*stage->stageWidth); stage->_TouchEndedDelegate.pushArgument(event.tfinger.y*stage->stageHeight); stage->_TouchEndedDelegate.invoke(); } else if(event.type == SDL_FINGERMOTION) { if (!stage->fingerEnabled) continue; stage->_TouchMovedDelegate.pushArgument((int)event.tfinger.fingerId); stage->_TouchMovedDelegate.pushArgument(event.tfinger.x*stage->stageWidth); stage->_TouchMovedDelegate.pushArgument(event.tfinger.y*stage->stageHeight); stage->_TouchMovedDelegate.pushArgument(SDL_BUTTON_LEFT); stage->_TouchMovedDelegate.invoke(); } else if(event.type == SDL_MOUSEBUTTONDOWN) { if (!stage->mouseEnabled) continue; stage->_TouchBeganDelegate.pushArgument((int)event.button.which); stage->_TouchBeganDelegate.pushArgument(event.button.x); stage->_TouchBeganDelegate.pushArgument(event.button.y); stage->_TouchBeganDelegate.invoke(); } else if(event.type == SDL_MOUSEBUTTONUP) { if (!stage->mouseEnabled) continue; stage->_TouchEndedDelegate.pushArgument((int)event.button.which); stage->_TouchEndedDelegate.pushArgument(event.button.x); stage->_TouchEndedDelegate.pushArgument(event.button.y); stage->_TouchEndedDelegate.invoke(); } else if(event.type == SDL_MOUSEMOTION) { if (!stage->mouseEnabled) continue; stage->_TouchMovedDelegate.pushArgument((int)event.motion.which); stage->_TouchMovedDelegate.pushArgument(event.motion.x); stage->_TouchMovedDelegate.pushArgument(event.motion.y); stage->_TouchMovedDelegate.pushArgument((int)event.motion.state); stage->_TouchMovedDelegate.invoke(); } else if(event.type == SDL_MOUSEWHEEL) { stage->_ScrollWheelYMovedDelegate.pushArgument(event.wheel.y); stage->_ScrollWheelYMovedDelegate.invoke(); } else if (event.type == SDL_WINDOWEVENT && (event.window.event == SDL_WINDOWEVENT_RESIZED || event.window.event == SDL_WINDOWEVENT_SIZE_CHANGED)) { int winWidth = event.window.data1, winHeight = event.window.data2; SDL_GL_GetDrawableSize(gSDLWindow, &winWidth, &winHeight); stage->noteNativeSize(winWidth, winHeight); GFX::Graphics::setNativeSize(winWidth, winHeight); } else if (event.type == SDL_TEXTINPUT) { IMEDelegateDispatcher::shared()->dispatchInsertText(event.text.text, strlen(event.text.text)); } else if (event.type == SDL_TEXTEDITING) { IMEDelegateDispatcher::shared()->dispatchShowComposition(event.text.text, strlen(event.text.text), event.edit.start, event.edit.length); } else if (event.type == SDL_CONTROLLERBUTTONDOWN) { //lmLogInfo(coreLogGroup, "Controller Button Down %d %d %d", event.cbutton.which, event.cbutton.button); LoomGameController::getGameController(LoomGameController::getControllerIndex(event.cbutton.which))->buttonDown(event); } else if (event.type == SDL_CONTROLLERBUTTONUP) { //lmLogInfo(coreLogGroup, "Controller Button Up %d %d %d", event.cbutton.which, event.cbutton.button); LoomGameController::getGameController(LoomGameController::getControllerIndex(event.cbutton.which))->buttonUp(event); } else if (event.type == SDL_CONTROLLERAXISMOTION) { //lmLog(coreLogGroup, "Controller [%d] triggered axis event.", LoomGameController::indexOfDevice(event.caxis.which)); LoomGameController::getGameController(LoomGameController::getControllerIndex(event.cbutton.which))->axisMove(event); } else if (event.type == SDL_CONTROLLERDEVICEADDED) { int addedDevice = LoomGameController::addDevice(event.cdevice.which); if (addedDevice != -1) { stage->_GameControllerAddedDelegate.pushArgument(addedDevice); stage->_GameControllerAddedDelegate.invoke(); } } else if (event.type == SDL_CONTROLLERDEVICEREMOVED) { int removedDevice = LoomGameController::removeDevice(event.cdevice.which); if (removedDevice != -1) { stage->_GameControllerRemovedDelegate.pushArgument(removedDevice); stage->_GameControllerRemovedDelegate.invoke(); } } else if (event.type == SDL_WINDOWEVENT) { if (event.window.event == SDL_WINDOWEVENT_FOCUS_GAINED) { const NativeDelegate* activated = LoomApplication::getApplicationActivatedDelegate(); activated->invoke(); } else if (event.window.event == SDL_WINDOWEVENT_FOCUS_LOST) { const NativeDelegate* deactivated = LoomApplication::getApplicationDeactivatedDelegate(); deactivated->invoke(); } } } /* Tick and render Loom. */ loom_tick(); }
int main(int argc, char *argv[]) { GLuint vao; GLuint vbo; GLfloat vertices[] = { 0.5f, -0.5f, 0.0f, -0.5f, -0.5f, 0.0f, 0.0f, 0.5f, 0.0f, }; GLfloat colorUniform[3]; GLint colorUniformLocation; GLint status; GLuint vertexShader; GLuint fragmentShader; GLuint program; GLchar *pbuffer; GLchar buffer[4096]; GLsizei bufferLen; GLchar logBuffer[256]; GLsizei logBufferLen; GLboolean running = GL_FALSE; SDL_Window* window = NULL; SDL_GLContext glContext = NULL; if( 0 > SDL_Init(SDL_INIT_VIDEO) ){ printf("SDL_Init(Video) failed: %s\n", SDL_GetError()); goto error_sdl_init; } SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4); SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3); SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE); window = SDL_CreateWindow(argv[0], 100, 100, 800, 600, SDL_WINDOW_OPENGL); if( !window ){ printf("SDL_CreateWindow failed: %s\n", SDL_GetError()); goto error_sdl_create_window; } glContext = SDL_GL_CreateContext(window); if( !glContext ){ printf("SDL_GL_CreateContext failed: %s\n", SDL_GetError()); goto error_sdl_gl_create_context; } if( 0 == gladLoadGLLoader(SDL_GL_GetProcAddress) ){ printf("gladLoadGLLoader failed\n"); goto error_glad_load_error; } /* load vertex data */ glGenVertexArrays(1, &vao); if( 0 == vao ){ printf("glGenVertexArrays failed: %d\n", glGetError()); goto error_gl_gen_vertex_arrays; } glBindVertexArray(vao); glGenBuffers(1, &vbo); if( 0 == vbo ){ printf("glGenBuffers failed: %d\n", glGetError()); goto error_gl_gen_buffers; } glBindBuffer(GL_ARRAY_BUFFER, vbo); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), NULL); glEnableVertexAttribArray(0); glBindVertexArray(0); program = glCreateProgram(); if( 0 == program ){ printf("glCreateProgram failed: %d\n", glGetError()); goto error_gl_create_program; } /* load vertex shader */ bufferLen = sizeof(buffer); if( 0 == loadFile("../03_02_UseUniformVariable/shader.vert", buffer, &bufferLen) ){ goto error_load_vertex_source; } vertexShader = glCreateShader(GL_VERTEX_SHADER); if( 0 == vertexShader ){ goto error_gl_create_vertex_shader; } pbuffer = buffer; glShaderSource(vertexShader, 1, &pbuffer, &bufferLen); glCompileShader(vertexShader); glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &status); if( 0 == status ){ glGetShaderInfoLog(vertexShader, sizeof(logBuffer), &logBufferLen, logBuffer); printf("compile shader failed:\n%s\nerror: %s\n", buffer, logBuffer); goto error_gl_compile_shader; } glAttachShader(program, vertexShader); glDeleteShader(vertexShader); vertexShader = 0; /* load fragment shader */ bufferLen = sizeof(buffer); if( 0 == loadFile("../03_02_UseUniformVariable/shader.frag", buffer, &bufferLen) ){ goto error_load_fragment_source; } fragmentShader = glCreateShader(GL_FRAGMENT_SHADER); if( 0 == fragmentShader ){ goto error_gl_create_fragment_shader; } pbuffer = buffer; glShaderSource(fragmentShader, 1, &pbuffer, &bufferLen); glCompileShader(fragmentShader); glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &status); if( 0 == status ){ glGetShaderInfoLog(fragmentShader, sizeof(logBuffer), &logBufferLen, logBuffer); printf("compile shader failed:\n%s\nerror: %s\n", buffer, logBuffer); goto error_gl_compile_fragment_shader; } glAttachShader(program, fragmentShader); /* link program */ glLinkProgram(program); glGetProgramiv(program, GL_LINK_STATUS, &status); if( 0 == status ){ glGetProgramInfoLog(program, sizeof(logBuffer), &logBufferLen, logBuffer); printf("link program failed: %s\n", logBuffer); goto error_link_program; } colorUniformLocation = glGetUniformLocation(program, "vertColor"); if( -1 == colorUniformLocation ){ printf("get uniformm location failed: %d\n", glGetError()); goto error_get_uniform_vertColor_location; } glGetUniformfv(program, colorUniformLocation, colorUniform); running = GL_TRUE; while( running ){ SDL_Event event; while( SDL_PollEvent(&event)){ if( event.type == SDL_KEYDOWN ){ switch(event.key.keysym.sym){ case SDLK_1: if( colorUniform[0] > 0.0f ) colorUniform[0] -= 0.05f; break; case SDLK_2: if( colorUniform[0] < 1.0f ) colorUniform[0] += 0.05f; break; case SDLK_3: if( colorUniform[1] > 0.0f ) colorUniform[1] -= 0.05f; break; case SDLK_4: if( colorUniform[1] < 1.0f ) colorUniform[1] += 0.05f; break; case SDLK_5: if( colorUniform[2] > 0.0f ) colorUniform[2] -= 0.05f; break; case SDLK_6: if( colorUniform[2] < 1.0f ) colorUniform[2] += 0.05f; break; default: printf("quit\n"); running = GL_FALSE; break; } } } glClearColor(0.0f, 0.0f, 0.0f, 1.0f); glClear(GL_COLOR_BUFFER_BIT); glBindVertexArray(vao); glUseProgram(program); glUniform3fv(colorUniformLocation, 1, colorUniform); //glUniform3f(colorUniformLocation, colorUniform[0], colorUniform[1], colorUniform[2]); glDrawArrays(GL_TRIANGLES, 0, 3); glUseProgram(0); glBindVertexArray(0); SDL_GL_SwapWindow(window); } glDeleteProgram(program); glDeleteBuffers(1, &vbo); glDeleteVertexArrays(1, &vao); SDL_GL_DeleteContext(glContext); SDL_DestroyWindow(window); SDL_Quit(); return 0; error_get_uniform_vertColor_location: error_link_program: error_gl_compile_fragment_shader: if( fragmentShader ) glDeleteShader(fragmentShader); error_gl_create_fragment_shader: error_load_fragment_source: error_gl_compile_shader: if( vertexShader ) glDeleteShader(vertexShader); error_gl_create_vertex_shader: error_load_vertex_source: glDeleteProgram(program); error_gl_create_program: glDeleteBuffers(1, &vbo); error_gl_gen_buffers: glDeleteVertexArrays(1, &vao); error_gl_gen_vertex_arrays: error_glad_load_error: SDL_GL_DeleteContext(glContext); error_sdl_gl_create_context: SDL_DestroyWindow(window); error_sdl_create_window: SDL_Quit(); error_sdl_init: return -1; }
bool Visualization::update() { if (!m_initialized) { printf("Visualization has not been yet initialized."); return false; } // Compute the time since last update (in seconds). Uint32 time = SDL_GetTicks(); float dt = (time - m_lastTickCount) / 1000.0f; m_lastTickCount = time; bool singleSimulationStep = false; bool scrollForward = false; bool scrollBackward = false; int mscroll = 0; SDL_Event event; while (SDL_PollEvent(&event)) { switch (event.type) { case SDL_KEYDOWN: // Handle any key presses here. if (event.key.keysym.sym == SDLK_ESCAPE) //Escape. { m_stopRequested = true; } else if (event.key.keysym.sym == SDLK_SPACE) { m_paused = !m_paused; } else if (event.key.keysym.sym == SDLK_TAB) { singleSimulationStep = true; } else if (event.key.keysym.sym == SDLK_r) { float pos[3] = {-15, 0, 15}; m_crowd->pushAgentPosition(0, pos); } else if (event.key.keysym.sym == SDLK_KP7) { float pos[3] = {-19, 0, -19}; dtVnormalize(pos); dtVscale(pos, pos, 2.f); dtCrowdAgent ag; m_crowd->fetchAgent(ag, 0); dtVcopy(ag.velocity, pos); m_crowd->pushAgent(ag); } else if (event.key.keysym.sym == SDLK_KP9) { float pos[] = {19, 0, -19}; dtVnormalize(pos); dtVscale(pos, pos, 2.f); dtCrowdAgent ag; m_crowd->fetchAgent(ag, 0); dtVcopy(ag.velocity, pos); m_crowd->pushAgent(ag); } else if (event.key.keysym.sym == SDLK_KP3) { float pos[3] = {19, 0, 19}; dtVnormalize(pos); dtVscale(pos, pos, 2.f); dtCrowdAgent ag; m_crowd->fetchAgent(ag, 0); dtVcopy(ag.velocity, pos); m_crowd->pushAgent(ag); } else if (event.key.keysym.sym == SDLK_KP1) { float pos[3] = {-19, 0, 19}; dtVnormalize(pos); dtVscale(pos, pos, 2.f); dtCrowdAgent ag; m_crowd->fetchAgent(ag, 0); dtVcopy(ag.velocity, pos); m_crowd->pushAgent(ag); } else if (event.key.keysym.sym == SDLK_KP5) { float pos[3] = {0, 0, 0}; dtVnormalize(pos); dtVscale(pos, pos, 2.f); dtCrowdAgent ag; m_crowd->fetchAgent(ag, 0); dtVcopy(ag.velocity, pos); m_crowd->pushAgent(ag); } break; case SDL_MOUSEBUTTONDOWN: if (event.button.button == SDL_BUTTON_RIGHT) { // Rotate view m_rotating = true; m_initialMousePosition[0] = m_mousePosition[0]; m_initialMousePosition[1] = m_mousePosition[1]; m_intialCameraOrientation[0] = m_cameraOrientation[0]; m_intialCameraOrientation[1] = m_cameraOrientation[1]; m_intialCameraOrientation[2] = m_cameraOrientation[2]; } else if (event.button.button == SDL_BUTTON_WHEELUP) { scrollForward = true; } else if (event.button.button == SDL_BUTTON_WHEELDOWN) { scrollBackward = true; } break; case SDL_MOUSEBUTTONUP: if (event.button.button == SDL_BUTTON_RIGHT) { m_rotating = false; } else if (event.button.button == SDL_BUTTON_LEFT) { float pickedPosition[3]; int index = 0; pick(pickedPosition, &index); } break; case SDL_MOUSEMOTION: m_mousePosition[0] = event.motion.x; m_mousePosition[1] = m_winHeight-1 - event.motion.y; if (m_rotating) { int dx = m_mousePosition[0] - m_initialMousePosition[0]; int dy = m_mousePosition[1] - m_initialMousePosition[1]; m_cameraOrientation[0] = m_intialCameraOrientation[0] - dy*0.25f; m_cameraOrientation[1] = m_intialCameraOrientation[1] + dx*0.25f; } break; case SDL_QUIT: m_stopRequested = true; break; default: break; } } unsigned char mbut = 0; if (SDL_GetMouseState(0,0) & SDL_BUTTON_LMASK) mbut |= IMGUI_MBUT_LEFT; if (SDL_GetMouseState(0,0) & SDL_BUTTON_RMASK) mbut |= IMGUI_MBUT_RIGHT; // Update the camera velocity from keyboard state. Uint8* keystate = SDL_GetKeyState(NULL); #ifdef _MSC_VER #pragma warning(push) #pragma warning(disable:4800) #endif updateCameraVelocity( dt, keystate[SDLK_w] || keystate[SDLK_UP] || scrollForward, keystate[SDLK_s] || keystate[SDLK_DOWN] || scrollBackward, keystate[SDLK_a] || keystate[SDLK_LEFT], keystate[SDLK_d] || keystate[SDLK_RIGHT], SDL_GetModState() & KMOD_SHIFT); #ifdef _MSC_VER #pragma warning(pop) #endif //Update the camera position updateCameraPosition(dt); //Update the crowd if (m_crowd) { if (singleSimulationStep) { m_paused = true; m_debugInfo->startUpdate(); m_crowd->update(m_crowdDt); m_debugInfo->endUpdate(m_crowdDt); m_crowdAvailableDt = 0.f; } else if (!m_paused) { m_crowdAvailableDt += dt; while(m_crowdAvailableDt > m_crowdDt) { m_debugInfo->startUpdate(); m_crowd->update(m_crowdDt); m_debugInfo->endUpdate(m_crowdDt); m_crowdAvailableDt -= m_crowdDt; } } else { m_crowdAvailableDt = 0.f; } } // Set rendering context glViewport(0, 0, m_winWidth, m_winHeight); glClearColor(0.3f, 0.3f, 0.32f, 1.0f); glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glDisable(GL_TEXTURE_2D); // Render 3D glEnable(GL_DEPTH_TEST); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(50.0f, (float)m_winWidth/(float)m_winHeight, m_zNear, m_zFar); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glRotatef(m_cameraOrientation[0],1,0,0); glRotatef(m_cameraOrientation[1],0,1,0); glRotatef(m_cameraOrientation[2],0,0,1); glTranslatef(-m_cameraPosition[0], -m_cameraPosition[1], -m_cameraPosition[2]); // Extract OpenGL view properties glGetDoublev(GL_PROJECTION_MATRIX, m_projection); glGetDoublev(GL_MODELVIEW_MATRIX, m_modelView); glGetIntegerv(GL_VIEWPORT, m_viewport); renderScene(); renderCrowd(); // Render 2D Overlay glDisable(GL_DEPTH_TEST); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluOrtho2D(0, m_winWidth, 0, m_winHeight); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); imguiBeginFrame(m_mousePosition[0], m_mousePosition[1], mbut,mscroll); renderDebugInfoOverlay(); imguiEndFrame(); imguiRenderGLDraw(); glEnable(GL_DEPTH_TEST); SDL_GL_SwapBuffers(); return true; }
int main(int, char**) { // Setup SDL if (SDL_Init(SDL_INIT_VIDEO|SDL_INIT_TIMER) != 0) { printf("Error: %s\n", SDL_GetError()); return -1; } // Setup window SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24); SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2); SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2); SDL_DisplayMode current; SDL_GetCurrentDisplayMode(0, ¤t); SDL_Window* window = SDL_CreateWindow("ImGui SDL2+OpenGL example", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 1280, 720, SDL_WINDOW_OPENGL|SDL_WINDOW_RESIZABLE); SDL_GLContext gl_context = SDL_GL_CreateContext(window); SDL_GL_SetSwapInterval(1); // Enable vsync // Setup Dear ImGui binding IMGUI_CHECKVERSION(); ImGui::CreateContext(); ImGuiIO& io = ImGui::GetIO(); (void)io; //io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; // Enable Keyboard Controls ImGui_ImplSdlGL2_Init(window); // Setup style ImGui::StyleColorsDark(); //ImGui::StyleColorsClassic(); // Load Fonts // - If no fonts are loaded, dear imgui will use the default font. You can also load multiple fonts and use ImGui::PushFont()/PopFont() to select them. // - AddFontFromFileTTF() will return the ImFont* so you can store it if you need to select the font among multiple. // - If the file cannot be loaded, the function will return NULL. Please handle those errors in your application (e.g. use an assertion, or display an error and quit). // - The fonts will be rasterized at a given size (w/ oversampling) and stored into a texture when calling ImFontAtlas::Build()/GetTexDataAsXXXX(), which ImGui_ImplXXXX_NewFrame below will call. // - Read 'misc/fonts/README.txt' for more instructions and details. // - Remember that in C/C++ if you want to include a backslash \ in a string literal you need to write a double backslash \\ ! //io.Fonts->AddFontDefault(); //io.Fonts->AddFontFromFileTTF("../../misc/fonts/Roboto-Medium.ttf", 16.0f); //io.Fonts->AddFontFromFileTTF("../../misc/fonts/Cousine-Regular.ttf", 15.0f); //io.Fonts->AddFontFromFileTTF("../../misc/fonts/DroidSans.ttf", 16.0f); //io.Fonts->AddFontFromFileTTF("../../misc/fonts/ProggyTiny.ttf", 10.0f); //ImFont* font = io.Fonts->AddFontFromFileTTF("c:\\Windows\\Fonts\\ArialUni.ttf", 18.0f, NULL, io.Fonts->GetGlyphRangesJapanese()); //IM_ASSERT(font != NULL); bool show_demo_window = true; bool show_another_window = false; ImVec4 clear_color = ImVec4(0.45f, 0.55f, 0.60f, 1.00f); // Main loop bool done = false; while (!done) { // You can read the io.WantCaptureMouse, io.WantCaptureKeyboard flags to tell if dear imgui wants to use your inputs. // - When io.WantCaptureMouse is true, do not dispatch mouse input data to your main application. // - When io.WantCaptureKeyboard is true, do not dispatch keyboard input data to your main application. // Generally you may always pass all inputs to dear imgui, and hide them from your application based on those two flags. SDL_Event event; while (SDL_PollEvent(&event)) { ImGui_ImplSdlGL2_ProcessEvent(&event); if (event.type == SDL_QUIT) done = true; } ImGui_ImplSdlGL2_NewFrame(window); // 1. Show a simple window. // Tip: if we don't call ImGui::Begin()/ImGui::End() the widgets automatically appears in a window called "Debug". { static float f = 0.0f; static int counter = 0; ImGui::Text("Hello, world!"); // Display some text (you can use a format string too) ImGui::SliderFloat("float", &f, 0.0f, 1.0f); // Edit 1 float using a slider from 0.0f to 1.0f ImGui::ColorEdit3("clear color", (float*)&clear_color); // Edit 3 floats representing a color ImGui::Checkbox("Demo Window", &show_demo_window); // Edit bools storing our windows open/close state ImGui::Checkbox("Another Window", &show_another_window); if (ImGui::Button("Button")) // Buttons return true when clicked (NB: most widgets return true when edited/activated) counter++; ImGui::SameLine(); ImGui::Text("counter = %d", counter); ImGui::Text("Application average %.3f ms/frame (%.1f FPS)", 1000.0f / ImGui::GetIO().Framerate, ImGui::GetIO().Framerate); } // 2. Show another simple window. In most cases you will use an explicit Begin/End pair to name your windows. if (show_another_window) { ImGui::Begin("Another Window", &show_another_window); ImGui::Text("Hello from another window!"); if (ImGui::Button("Close Me")) show_another_window = false; ImGui::End(); } // 3. Show the ImGui demo window. Most of the sample code is in ImGui::ShowDemoWindow(). Read its code to learn more about Dear ImGui! if (show_demo_window) { ImGui::SetNextWindowPos(ImVec2(650, 20), ImGuiCond_FirstUseEver); // Normally user code doesn't need/want to call this because positions are saved in .ini file anyway. Here we just want to make the demo initial state a bit more friendly! ImGui::ShowDemoWindow(&show_demo_window); } // Rendering glViewport(0, 0, (int)ImGui::GetIO().DisplaySize.x, (int)ImGui::GetIO().DisplaySize.y); glClearColor(clear_color.x, clear_color.y, clear_color.z, clear_color.w); glClear(GL_COLOR_BUFFER_BIT); //glUseProgram(0); // You may want this if using this code in an OpenGL 3+ context where shaders may be bound ImGui::Render(); ImGui_ImplSdlGL2_RenderDrawData(ImGui::GetDrawData()); SDL_GL_SwapWindow(window); } // Cleanup ImGui_ImplSdlGL2_Shutdown(); ImGui::DestroyContext(); SDL_GL_DeleteContext(gl_context); SDL_DestroyWindow(window); SDL_Quit(); return 0; }
static int get_event(struct input_event *event, int wait) { SDL_Event sdl_ev; int ret; DEBUG(3, "input_sdl: get_event(x, %s %d)\n" ,wait?"/*wait*/":"/*poll*/" ,wait); if (wait) { ret = SDL_WaitEvent(&sdl_ev); if (!ret) ERROR("error while polling/waiting for event!"); } else ret = SDL_PollEvent(&sdl_ev); if (!ret) return 1; switch (sdl_ev.type) { case SDL_KEYDOWN: case SDL_KEYUP: event->type = BUTTON; event->id = sdl_ev.key.keysym.sym; event->pressed = sdl_ev.type == SDL_KEYDOWN; if (event->pressed) { DEBUG(3, "Key press event, id == %d\n", event->id); } else { DEBUG(3, "Key release event, id == %d\n", event->id); } break; case SDL_MOUSEMOTION: if (mouse_mode == MOUSE_POINTER) { event->type = POINTER; event->id = SDLK_LAST+11; event->x = sdl_ev.motion.x; event->y = sdl_ev.motion.y; DEBUG(3, "Mouse pointer event, id == %d, pos = (%g, %g)\n", event->id, event->x, event->y); } else if (mouse_mode == MOUSE_MOVE) { event->type = BALL; event->id = SDLK_LAST+12; event->x = sdl_ev.motion.xrel; event->y = sdl_ev.motion.yrel; DEBUG(3, "Mouse motion event, id == %d, movement = (%g, %g)\n", event->id, event->x, event->y); } else { ERROR("invalid mouse_mode value %d (!), discarding event", mouse_mode); return 1; } break; case SDL_MOUSEBUTTONDOWN: #if SDL_VERSION_ATLEAST(1, 2, 5) /* Handle mouse wheel events specially. */ if (sdl_ev.button.button == SDL_BUTTON_WHEELUP) { event->type = WHEEL; event->id = SDLK_LAST+16; event->value = -1; DEBUG(3, "Mouse wheel (up) event, id == %d\n", event->id); break; } else if (sdl_ev.button.button == SDL_BUTTON_WHEELDOWN) { event->type = WHEEL; event->id = SDLK_LAST+16; event->value = 1; DEBUG(3, "Mouse wheel (down) event, id == %d\n", event->id); break; } /* If neither, pass it through to the code below. */ #endif case SDL_MOUSEBUTTONUP: event->type = BUTTON; switch (sdl_ev.button.button) { case SDL_BUTTON_LEFT: event->id = SDLK_LAST+13; break; case SDL_BUTTON_MIDDLE: event->id = SDLK_LAST+14; break; case SDL_BUTTON_RIGHT: event->id = SDLK_LAST+15; break; #if SDL_VERSION_ATLEAST(1, 2, 5) case SDL_BUTTON_WHEELUP: case SDL_BUTTON_WHEELDOWN: /* Ignore mouse wheel "release" events. */ return 1; #endif #if SDL_VERSION_ATLEAST(1, 2, 13) case SDL_BUTTON_X1: event->id = SDLK_LAST+18; break; case SDL_BUTTON_X2: event->id = SDLK_LAST+19; break; #endif } event->pressed = sdl_ev.type == SDL_MOUSEBUTTONDOWN; if (event->pressed) { DEBUG(3, "Mouse button press event, id == %d\n", event->id); } else { DEBUG(3, "Mouse button release event, id == %d\n", event->id); } break; case SDL_JOYAXISMOTION: event->type = AXIS; event->id = joy_control_to_id( joy_from_id(sdl_ev.jaxis.which) ,AXIS ,sdl_ev.jaxis.axis ); event->value = (float) sdl_ev.jaxis.value / 32768.0f; DEBUG(3, "Joystick axis event, id == %d, value = %g\n", event->id, event->value); break; case SDL_JOYBUTTONDOWN: case SDL_JOYBUTTONUP: event->type = BUTTON; event->id = joy_control_to_id( joy_from_id(sdl_ev.jbutton.which) ,BUTTON ,sdl_ev.jbutton.button ); event->pressed = sdl_ev.type == SDL_JOYBUTTONDOWN; DEBUG(3, "Joystick button event, id == %d, state = %s\n", event->id, event->pressed ? "pressed" : "released"); break; case SDL_JOYBALLMOTION: event->type = POINTER; event->id = joy_control_to_id( joy_from_id(sdl_ev.jball.which) ,POINTER ,sdl_ev.jball.ball ); event->x = sdl_ev.jball.xrel; event->y = sdl_ev.jball.yrel; DEBUG(3, "Joystick trackball event, id == %d, movement = (%d, %d)\n", event->id, sdl_ev.jball.xrel, sdl_ev.jball.yrel); break; case SDL_QUIT: event->type = BUTTON; event->id = SDLK_LAST+1; event->pressed = 1; DEBUG(3, "Quit event, id == %d\n", event->id); break; default: DEBUG(3, "Unhandled event (discarded)\n"); return 1; } return 0; }
void OEMFMain :: run(void) { unsigned int menuIndex = 0; unsigned int frames = 0; unsigned int timepassed; if (musicPlayer->isPlayingSong()) musicPlayer->stopSong(); string songfile = PREPATH "boiling.mp3"; musicPlayer->playSongAtPath(songfile.c_str()); drawIntro(); SDL_Event event; int done = 0; while ( !done) { timepassed = SDL_GetTicks(); OEMF_LOCKSCREEN; clearWithColor(0xFF000000, false); OEMF_UNLOCKSCREEN; blitImage(images[IMG_INTRO], 0, 0); for (unsigned int i = 0; i < m_menuCount; i++) fonts[FNT_MENU]->blitText(this, m_menuOptions[i].c_str(), 160, 240 + i * 32, 480, false); blitImage(images[IMG_OEMFOE], 128, (unsigned int) (240 + menuIndex * 32 + sin(frames / 2.0) * 8)); SDL_UpdateRect(m_screen, 128, 232, 512, 248); /* Check for events */ while (SDL_PollEvent(&event)) { switch (event.type) { case SDL_MOUSEMOTION: break; case SDL_MOUSEBUTTONDOWN: break; case SDL_KEYDOWN: if (event.key.keysym.sym == SDLK_ESCAPE) { done = 1; } else if (event.key.keysym.sym == SDLK_UP) { menuIndex = (menuIndex - 1 + m_menuCount) % m_menuCount; musicPlayer->playSound(sounds[SND_TOK]); } else if (event.key.keysym.sym == SDLK_DOWN) { menuIndex = (menuIndex + 1) % m_menuCount; musicPlayer->playSound(sounds[SND_TOK]); } else if (event.key.keysym.sym == SDLK_p) { SDL_SaveBMP(m_screen, "screenshot.bmp"); } else if (event.key.keysym.sym == SDLK_RETURN) { musicPlayer->playSound(sounds[SND_TIK]); if (menuIndex == 4) { fadeOut(); done = 1; } else if (menuIndex == 0) // new game { fadeOut(); OEMFGame * game = new OEMFGame(m_screen, m_execPath, m_screenWidth, m_screenHeight, m_screenBpp); game->run(); delete game; drawIntro(); } else if (menuIndex == 3) // level editor { fadeOut(); OEMFLevelEdit * leveledit = new OEMFLevelEdit(m_screen, m_execPath, m_screenWidth, m_screenHeight, m_screenBpp); leveledit->run(); delete leveledit; drawIntro(); } else if (menuIndex == 2) // options { unsigned int choice = 0; string * options = new string[2]; while (choice != 2) // not exit { if (musicEnabled) options[0] = "Turn Music Off"; else options[0] = "Turn Music On"; options[1] = "Toggle Fullscreen"; drawIntro(); choice = chooseList(2 /* exit */, "Options", options, 2); if (choice == 0) { musicEnabled = !musicEnabled; if (!musicEnabled) { if (musicPlayer->isPlayingSong()) musicPlayer->stopSong(); } else { musicPlayer->playSongAtPath(songfile.c_str()); } } else if (choice == 1) { if (fullscreenMode) { m_screen = SDL_SetVideoMode(m_screenWidth, m_screenHeight, m_screenBpp, SDL_SWSURFACE); m_fb = (Uint32 *) m_screen->pixels; m_pitch = (Uint32) m_screen->pitch / 4; fullscreenMode = false; } else { m_screen = SDL_SetVideoMode(m_screenWidth, m_screenHeight, m_screenBpp, SDL_SWSURFACE | SDL_FULLSCREEN); m_fb = (Uint32 *) m_screen->pixels; m_pitch = (Uint32) m_screen->pitch / 4; fullscreenMode = true; } choice = 2; } } drawIntro(); } else { fadeOut(); fonts[FNT_MENU]->blitCenterText(this, "NOT AVAILABLE YET", 240, m_screenWidth); SDL_UpdateRect(m_screen, 0, 0, m_screenWidth, m_screenHeight); SDL_Delay(2000); string test = fonts[FNT_MENU]->inputText(this, "default", 32, 32, 10); drawIntro(); } } break; case SDL_QUIT: done = 1; break; default: break; } } frames++; // 30 FPS timepassed = SDL_GetTicks() - timepassed; if (timepassed <= 33) SDL_Delay(33 - timepassed); } }
int main( int argc, char* args[] ) { //Quit flag bool quit = false; //Initialize if( init() == false ) { return 1; } //Load the files if( load_files() == false ) { return 1; } //Clip the sprite sheet set_clips(); //The frame rate regulator Timer fps; //The stick figure Foo walk; //While the user hasn't quit while( quit == false ) { //Start the frame timer fps.start(); //While there's events to handle while( SDL_PollEvent( &event ) ) { //Handle events for the stick figure walk.handle_events(); //If the user has Xed out the window if( event.type == SDL_QUIT ) { //Quit the program quit = true; } } //Move the stick figure walk.move(); //Fill the screen white SDL_FillRect( screen, &screen->clip_rect, SDL_MapRGB( screen->format, 0xFF, 0xFF, 0xFF ) ); //Show the stick figure on the screen walk.show(); //Update the screen if( SDL_Flip( screen ) == -1 ) { return 1; } //Cap the frame rate if( fps.get_ticks() < 1000 / FRAMES_PER_SECOND ) { SDL_Delay( ( 1000 / FRAMES_PER_SECOND ) - fps.get_ticks() ); } } //Clean up clean_up(); return 0; }
/* Get pl_name from user; other strings are text displayed by dialog: */ void NameEntry(char* pl_name, const char* s1, const char* s2, const char* s3) { char UTF8_buf[HIGH_SCORE_NAME_LENGTH * 3] = {'\0'}; SDL_Rect loc; SDL_Rect redraw_rect; int redraw = 0; int first_draw = 1; int finished = 0; Uint32 frame = 0; Uint32 start = 0; wchar_t wchar_buf[HIGH_SCORE_NAME_LENGTH + 1] = {'\0'}; const int NAME_FONT_SIZE = 32; const int BG_Y = 100; const int BG_WIDTH = 400; const int BG_HEIGHT = 200; if (!pl_name) return; /* We need to get Unicode vals from SDL keysyms */ SDL_EnableUNICODE(SDL_ENABLE); DEBUGMSG(debug_highscore, "Enter NameEntry()\n" ); DrawTitleScreen(); /* Red "Stop" circle in upper right corner to go back to main menu: */ if (stop_button) { SDL_BlitSurface(stop_button, NULL, screen, &stop_rect); } /* Draw translucent background for text: */ { SDL_Rect bg_rect; bg_rect.x = (screen->w)/2 - BG_WIDTH/2; bg_rect.y = BG_Y; bg_rect.w = BG_WIDTH; bg_rect.h = BG_HEIGHT; T4K_DrawButton(&bg_rect, 15, REG_RGBA); bg_rect.x += 10; bg_rect.y += 10; bg_rect.w -= 20; bg_rect.h = 60; T4K_DrawButton(&bg_rect, 10, SEL_RGBA); } /* Draw headings: */ { SDL_Surface* surf = T4K_BlackOutline(_(s1), DEFAULT_MENU_FONT_SIZE, &white); if (surf) { loc.x = (screen->w/2) - (surf->w/2); loc.y = 110; SDL_BlitSurface(surf, NULL, screen, &loc); SDL_FreeSurface(surf); } surf = T4K_BlackOutline(_(s2), DEFAULT_MENU_FONT_SIZE, &white); if (surf) { loc.x = (screen->w/2) - (surf->w/2); loc.y = 140; SDL_BlitSurface(surf, NULL, screen, &loc); SDL_FreeSurface(surf); } surf = T4K_BlackOutline(_(s3), DEFAULT_MENU_FONT_SIZE, &white); if (surf) { loc.x = (screen->w/2) - (surf->w/2); loc.y = 170; SDL_BlitSurface(surf, NULL, screen, &loc); SDL_FreeSurface(surf); } } if (_(s3) != NULL) T4K_Tts_say(DEFAULT_VALUE,DEFAULT_VALUE,APPEND,"%s %s %s",_(s1),_(s2),_(s3)); else if(_(s2) != NULL) T4K_Tts_say(DEFAULT_VALUE,DEFAULT_VALUE,APPEND,"%s %s",_(s1),_(s2)); else T4K_Tts_say(DEFAULT_VALUE,DEFAULT_VALUE,APPEND,"%s",_(s1)); /* and update: */ SDL_UpdateRect(screen, 0, 0, 0, 0); while (!finished) { start = SDL_GetTicks(); while (SDL_PollEvent(&event)) { switch (event.type) { case SDL_QUIT: { cleanup(); } case SDL_MOUSEBUTTONDOWN: /* "Stop" button - go to main menu: */ { if (T4K_inRect(stop_rect, event.button.x, event.button.y )) { finished = 1; playsound(SND_TOCK); break; } } case SDL_KEYDOWN: { DEBUGMSG(debug_highscore, "Before keypress, string is %S\tlength = %d\n", wchar_buf, (int)wcslen(wchar_buf)); switch (event.key.keysym.sym) { case SDLK_ESCAPE: case SDLK_RETURN: case SDLK_KP_ENTER: { finished = 1; playsound(SND_TOCK); break; } case SDLK_BACKSPACE: { if (wcslen(wchar_buf) > 0) wchar_buf[(int)wcslen(wchar_buf) - 1] = '\0'; redraw = 1; break; } /* For any other keys, if the key has a Unicode value, */ /* we add it to our string: */ default: { if ((event.key.keysym.unicode > 0) && (wcslen(wchar_buf) < HIGH_SCORE_NAME_LENGTH)) { wchar_buf[(int)wcslen(wchar_buf)] = event.key.keysym.unicode; redraw = 1; T4K_Tts_say(DEFAULT_VALUE,DEFAULT_VALUE,INTERRUPT,"%C",event.key.keysym.unicode); } } } /* end 'switch (event.key.keysym.sym)' */ DEBUGMSG(debug_highscore, "After keypress, string is %S\tlength = %d\n", wchar_buf, (int)wcslen(wchar_buf)); /* Now draw name, if needed: */ if (redraw) { SDL_Surface* s = NULL; redraw = 0; /* Convert text to UTF-8 so T4K_BlackOutline() can handle it: */ // wcstombs((char*) UTF8_buf, wchar_buf, HIGH_SCORE_NAME_LENGTH * 3); T4K_ConvertToUTF8(wchar_buf, UTF8_buf, HIGH_SCORE_NAME_LENGTH * 3); /* Redraw background and shading in area where we drew text last time: */ if (!first_draw) { SDL_BlitSurface(current_bkg(), &redraw_rect, screen, &redraw_rect); T4K_DrawButton(&redraw_rect, 0, REG_RGBA); SDL_UpdateRect(screen, redraw_rect.x, redraw_rect.y, redraw_rect.w, redraw_rect.h); } s = T4K_BlackOutline(UTF8_buf, NAME_FONT_SIZE, &yellow); if (s) { /* set up loc and blit: */ loc.x = (screen->w/2) - (s->w/2); loc.y = 230; SDL_BlitSurface(s, NULL, screen, &loc); /* Remember where we drew so we can update background next time through: */ /* (for some reason we need to update a wider area to get clean image) */ redraw_rect.x = loc.x - 20; redraw_rect.y = loc.y - 10; redraw_rect.h = s->h + 20; redraw_rect.w = s->w + 40; first_draw = 0; SDL_UpdateRect(screen, redraw_rect.x, redraw_rect.y, redraw_rect.w, redraw_rect.h); SDL_FreeSurface(s); s = NULL; } } } } } HandleTitleScreenAnimations(); /* Wait so we keep frame rate constant: */ while ((SDL_GetTicks() - start) < 33) { SDL_Delay(20); } frame++; } // End of while (!finished) loop /* Turn off SDL Unicode lookup (because has some overhead): */ SDL_EnableUNICODE(SDL_DISABLE); /* Now copy name into location pointed to by arg: */ strncpy(pl_name, UTF8_buf, HIGH_SCORE_NAME_LENGTH * 3); DEBUGMSG(debug_highscore, "Leaving NameEntry(), final string is: %s\n", pl_name); if (wcslen(wchar_buf) != 0) T4K_Tts_say(DEFAULT_VALUE,DEFAULT_VALUE,INTERRUPT,"%S.",wchar_buf); }
bool CWinEventsSDL::MessagePump() { SDL_Event event; bool ret = false; while (SDL_PollEvent(&event)) { switch(event.type) { case SDL_QUIT: if (!g_application.m_bStop) CApplicationMessenger::Get().Quit(); break; #ifdef HAS_SDL_JOYSTICK case SDL_JOYBUTTONUP: case SDL_JOYBUTTONDOWN: case SDL_JOYAXISMOTION: case SDL_JOYBALLMOTION: case SDL_JOYHATMOTION: g_Joystick.Update(event); ret = true; break; #endif case SDL_ACTIVEEVENT: //If the window was inconified or restored if( event.active.state & SDL_APPACTIVE ) { g_application.m_AppActive = event.active.gain != 0; g_Windowing.NotifyAppActiveChange(g_application.m_AppActive); } else if (event.active.state & SDL_APPINPUTFOCUS) { g_application.m_AppFocused = event.active.gain != 0; g_Windowing.NotifyAppFocusChange(g_application.m_AppFocused); } break; case SDL_KEYDOWN: { // process any platform specific shortcuts before handing off to XBMC #ifdef __APPLE__ if (ProcessOSXShortcuts(event)) { ret = true; break; } #endif XBMC_Event newEvent; newEvent.type = XBMC_KEYDOWN; newEvent.key.keysym.scancode = event.key.keysym.scancode; newEvent.key.keysym.sym = (XBMCKey) event.key.keysym.sym; newEvent.key.keysym.unicode = event.key.keysym.unicode; newEvent.key.state = event.key.state; newEvent.key.type = event.key.type; newEvent.key.which = event.key.which; // Check if the Windows keys are down because SDL doesn't flag this. uint16_t mod = event.key.keysym.mod; uint8_t* keystate = SDL_GetKeyState(NULL); if (keystate[SDLK_LSUPER] || keystate[SDLK_RSUPER]) mod |= XBMCKMOD_LSUPER; newEvent.key.keysym.mod = (XBMCMod) mod; #if defined(_LINUX) && !defined(__APPLE__) // If the keysym.sym is zero try to get it from the scan code if (newEvent.key.keysym.sym == 0) newEvent.key.keysym.sym = (XBMCKey) SymFromScancode(newEvent.key.keysym.scancode); #endif // don't handle any more messages in the queue until we've handled keydown, // if a keyup is in the queue it will reset the keypress before it is handled. ret |= g_application.OnEvent(newEvent); break; } case SDL_KEYUP: { XBMC_Event newEvent; newEvent.type = XBMC_KEYUP; newEvent.key.keysym.scancode = event.key.keysym.scancode; newEvent.key.keysym.sym = (XBMCKey) event.key.keysym.sym; newEvent.key.keysym.mod =(XBMCMod) event.key.keysym.mod; newEvent.key.keysym.unicode = event.key.keysym.unicode; newEvent.key.state = event.key.state; newEvent.key.type = event.key.type; newEvent.key.which = event.key.which; ret |= g_application.OnEvent(newEvent); break; } case SDL_MOUSEBUTTONDOWN: { XBMC_Event newEvent; newEvent.type = XBMC_MOUSEBUTTONDOWN; newEvent.button.button = event.button.button; newEvent.button.state = event.button.state; newEvent.button.type = event.button.type; newEvent.button.which = event.button.which; newEvent.button.x = event.button.x; newEvent.button.y = event.button.y; ret |= g_application.OnEvent(newEvent); break; } case SDL_MOUSEBUTTONUP: { XBMC_Event newEvent; newEvent.type = XBMC_MOUSEBUTTONUP; newEvent.button.button = event.button.button; newEvent.button.state = event.button.state; newEvent.button.type = event.button.type; newEvent.button.which = event.button.which; newEvent.button.x = event.button.x; newEvent.button.y = event.button.y; ret |= g_application.OnEvent(newEvent); break; } case SDL_MOUSEMOTION: { if (0 == (SDL_GetAppState() & SDL_APPMOUSEFOCUS)) { g_Mouse.SetActive(false); #if defined(__APPLE__) // See CApplication::ProcessSlow() for a description as to why we call Cocoa_HideMouse. // this is here to restore the pointer when toggling back to window mode from fullscreen. Cocoa_ShowMouse(); #endif break; } XBMC_Event newEvent; newEvent.type = XBMC_MOUSEMOTION; newEvent.motion.xrel = event.motion.xrel; newEvent.motion.yrel = event.motion.yrel; newEvent.motion.state = event.motion.state; newEvent.motion.type = event.motion.type; newEvent.motion.which = event.motion.which; newEvent.motion.x = event.motion.x; newEvent.motion.y = event.motion.y; ret |= g_application.OnEvent(newEvent); break; } case SDL_VIDEORESIZE: { XBMC_Event newEvent; newEvent.type = XBMC_VIDEORESIZE; newEvent.resize.w = event.resize.w; newEvent.resize.h = event.resize.h; ret |= g_application.OnEvent(newEvent); g_windowManager.MarkDirty(); break; } case SDL_USEREVENT: { XBMC_Event newEvent; newEvent.type = XBMC_USEREVENT; newEvent.user.code = event.user.code; ret |= g_application.OnEvent(newEvent); break; } case SDL_VIDEOEXPOSE: g_windowManager.MarkDirty(); break; } memset(&event, 0, sizeof(SDL_Event)); } return ret; }