// threadId of ALL_THREADS means run all threads. Otherwise, run just the // indicated thread. static void runUntilInterrupt(Core *core, uint32_t threadId, bool enableFbWindow) { fd_set readFds; int result; struct timeval timeout; FD_ZERO(&readFds); while (1) { if (!executeInstructions(core, threadId, gScreenRefreshRate)) break; if (enableFbWindow) { updateFramebuffer(getFramebuffer(core)); pollEvent(); } FD_SET(gClientSocket, &readFds); timeout.tv_sec = 0; timeout.tv_usec = 0; result = select(gClientSocket + 1, &readFds, NULL, NULL, &timeout); if ((result < 0 && errno != EINTR) || result == 1) break; } }
void SDL_Controller::mainLoop() { while (!quitGame) { if (stateStack.empty()) { pollEvent(); } else { int result = stateStack.top()->handleEvents(); if (result == -1) { quitGame = true; } else if (result == 0) { stateStack.pop(); } } bg.render(renderer, 0, 0); if (stateStack.empty()) { snake->update(); } if (snake->crash()) { quitGame = true; } if (snake->getHeadX() == minionX && snake->getHeadY() == minionY) { snake->addTail(); score++; minionAlive = false; } if (!minionAlive) { minionX = (rand() % ((SCREEN_WIDTH - ICON_SIZE) / ICON_SIZE)) * ICON_SIZE; minionY = (rand() % ((SCREEN_HEIGHT - ICON_SIZE) / ICON_SIZE)) * ICON_SIZE; minionAlive = true; } snake->draw(renderer); minion.render(renderer, minionX, minionY); if (!stateStack.empty()) { stateStack.top()->drawState(renderer); } SDL_RenderPresent(renderer); SDL_Delay(FPS_INTERVAL); } SDL_DestroyWindow(window); std::cout << "Thanks for playing! Your score is : " << score << std::endl; system("pause"); }
void pollEvents(Window* w) { clearAllEvents(w); SDL_Event event; while (SDL_PollEvent(&event)) { pollEvent(w, event); } }
void CWindow::gameTool(CGame *game) { static CFrameCounter counter; while(!exit) { pollEvent(); game->GameTool(); //wywoluje tylko rendering, nie moze byc w osobnym watku!!!!!!! window.display(); ///counter.count(); } }
void Window::pollInput(double delta) { sf::Event ev; while (pollEvent(ev)) { if (!m_input.handleEvent(ev)) m_running = false; } m_input.update(delta); }
void CWindow::renderIntro(bool *done) { static CPoster post(-1,1,2,2); post.texId = CTexture("texture/intro.bmp").texId; while(!*done and !exit) { post.draw(); pollEvent(); window.display(); } }
bool KeySource::flushEvents(EventStage& next) { bool more(false); pollEvent(next); mKeyHardware.pressed(KeyHardwareEventHandler::create([&](const KeyHardwareEvent&) { more = true; })); return more; }
void Frame::run() { while(isOpen()) { calculate_bounds(); calculate_mouse_pos(); while(pollEvent(_event)) { eventHandling(); } drawAll(); } }
/** * Standard event retrieval, which only returns keyboard and mouse clicks */ bool EventsClass::getEvent(Event &evt, int eventMask) { while (pollEvent() && !_vm->getEventManager()->shouldQuit()) { evt.handled = false; evt.eventType = EVENT_NONE; evt.mousePos = _event.mouse; evt.kbd = _event.kbd; switch (_event.type) { case Common::EVENT_MOUSEMOVE: evt.eventType = EVENT_MOUSE_MOVE; break; case Common::EVENT_LBUTTONDOWN: evt.eventType = EVENT_BUTTON_DOWN; evt.btnState = BTNSHIFT_LEFT; break; case Common::EVENT_RBUTTONDOWN: evt.eventType = EVENT_BUTTON_DOWN; evt.btnState = BTNSHIFT_RIGHT; break; case Common::EVENT_MBUTTONDOWN: evt.eventType = EVENT_BUTTON_DOWN; evt.btnState = BTNSHIFT_MIDDLE; break; case Common::EVENT_LBUTTONUP: case Common::EVENT_RBUTTONUP: case Common::EVENT_MBUTTONUP: evt.eventType = EVENT_BUTTON_UP; evt.btnState = 0; break; case Common::EVENT_KEYDOWN: evt.eventType = EVENT_KEYPRESS; evt.kbd = _event.kbd; break; default: break; } if (evt.eventType & eventMask) return true; } evt.handled = false; evt.eventType = EVENT_NONE; return false; }
int main ( int argc, char * argv[] ) { Uint32 time = SDL_GetTicks(); init(); loadData(); long long iterator = 0; while ( !quit ) { printf( "\tLoop start {\n " ); Uint32 timePre = time; time = SDL_GetTicks(); dt = ((double)( time - timePre )) / 1000.0; printf( "\tEvents\n " ); pollEvent(); printf( "\tUpdate\n " ); update(); printf( "\tRender\n " ); render(); printf( "%i\t} Loop end\n ", iterator++ ); } return 0x127; }
void CAppWindow::EnterLoop() { while (isOpen()) { sf::Event event; while (pollEvent(event)) { if (event.type == sf::Event::Closed) { close(); return; } m_menu->OnEvent(event); } clear(sf::Color::Black); if (m_state != State::WaitingInput) { OnRunningDemo(); } draw(*m_menu); display(); } }
int Game::run() { while (isOpen() && !mvStates.empty()) { sf::Event event; while (pollEvent(event)) { if (event.type == sf::Event::Closed) { close(); } } if (isOpen()) { mvFrameTime = mvFrameClock.restart(); std::deque<StatePtr>::iterator iter; for (iter = mvStates.begin(); iter != mvStates.end(); iter++) { try { (*iter)->update(); if (!mvStates.empty()) { clear(); (*iter)->draw(); display(); } } catch (DAException &e) { // If an exception manages to propagate to this level of // operation, we can assume it's pretty severe and we'll // just let ourselves crash. std::cerr << e.message(); close(); return EXIT_FAILURE; } } } } return EXIT_SUCCESS; }
bool zeq_window_t::pollInput(zeq_input_t* input) { sf::Event ev; if (pollEvent(ev)) { memcpy(input, &ev, sizeof(zeq_input_t)); zeq_input_event_t t; switch (ev.type) { case sf::Event::Closed: t = ZEQ_INPUT_WINDOW_CLOSE; break; case sf::Event::Resized: t = ZEQ_INPUT_WINDOW_RESIZE; break; case sf::Event::LostFocus: t = ZEQ_INPUT_WINDOW_LOSE_FOCUS; break; case sf::Event::GainedFocus: t = ZEQ_INPUT_WINDOW_GAIN_FOCUS; break; case sf::Event::TextEntered: t = ZEQ_INPUT_TEXT_ENTRY; break; case sf::Event::KeyPressed: t = ZEQ_INPUT_KEY_PRESS; break; case sf::Event::KeyReleased: t = ZEQ_INPUT_KEY_RELEASE; break; case sf::Event::MouseWheelScrolled: t = ZEQ_INPUT_MOUSE_WHEEL; break; case sf::Event::MouseButtonPressed: t = ZEQ_INPUT_MOUSE_CLICK; break; case sf::Event::MouseButtonReleased: t = ZEQ_INPUT_MOUSE_RELEASE; break; case sf::Event::MouseMoved: t = ZEQ_INPUT_MOUSE_MOVE; break; case sf::Event::MouseEntered: t = ZEQ_INPUT_MOUSE_ENTER_WINDOW; break; case sf::Event::MouseLeft: t = ZEQ_INPUT_MOUSE_LEAVE_WINDOW; break; default: t = ZEQ_INPUT_UNKNOWN; break; } input->event = t; return true; } return false; }
task main() { waitForStart(); StartTask(safeGuard); eventengine_t engine; event_t event; eventengine_init(&engine); engine.eventNone = true; engine.joysticks = false; engine.controller1 = true; engine.controller2 = false; float driveSpeed = 1.0; int controllerPov; memset(&state, 0, sizeof(state)); // Reset servo values bFloatDuringInactiveMotorPWM = false; // the motors will NOT coast when power is not applied nMotorEncoder[motorARM1] = 0; // reset the Motor Encoder of Motor ARM 1 nMotorEncoder[motorARM2] = 0; // reset the Motor Encoder of Motor ARM 2 servo[clawservo1] = 180; // set servo to zero servo[clawservo2] = 180; // set servo to zero servo[sweeper] = 0; wait1Msec(500); while (true) { // Set wheel speeds motor[leftWheels] = (float) controllerValue(1, 1, 2) * driveSpeed; motor[rightWheels] = (float) controllerValue(1, 2, 2) * driveSpeed; // First, update states state.arm1_state = nMotorEncoder[motorARM1]; state.arm2_state = nMotorEncoder[motorARM2]; controllerPov = joystick.joy1_TopHat; // Manual joint and servo controls { // Lower joint controls if (joy1Btn(CONTROLLER_L1)) { state.arm1_manual_lock = true; state.arm1_target = state.arm1_state; motor[motorARM1] = ARM_SPEED_LOWER; } else if (joy1Btn(CONTROLLER_L2)) { state.arm1_manual_lock = true; state.arm1_target = state.arm1_state; motor[motorARM1] = -ARM_SPEED_LOWER; } else { // If it is locked, this means we can set speed to zero // without disrupting auto-rotation if (state.arm1_manual_lock) motor[motorARM1] = 0; // Don't disengage the lock - we don't want auto-adjust until // we hit the button } // Upper joint controlls if (joy1Btn(CONTROLLER_R1)) { state.arm2_manual_lock = true; state.arm2_target = state.arm2_state; motor[motorARM2] = ARM_SPEED_UPPER; } else if (joy1Btn(CONTROLLER_R2)) { state.arm2_manual_lock = true; state.arm2_target = state.arm2_state; motor[motorARM2] = -ARM_SPEED_UPPER; } else { if (state.arm2_manual_lock) motor[motorARM2] = 0; } // Manual servo controls if (controllerPov == DPAD_UP) { servo[clawservo1] = ServoValue[clawservo1] - 2; servo[clawservo2] = ServoValue[clawservo2] - 2; } else if (controllerPov == DPAD_DOWN) { servo[clawservo1] = ServoValue[clawservo1] + 2; servo[clawservo2] = ServoValue[clawservo2] + 2; } else if (controllerPov == DPAD_LEFT) { servo[sweeper] = ServoValue[sweeper] + 3; } else if (controllerPov == DPAD_RIGHT) { servo[sweeper] = ServoValue[sweeper] - 3; } } // Button press events pollEvent(&engine, &event); if (event.type == EVENT_TYPE_CONTROLLER_1_BUTTON_DOWN) { if (event.data == CONTROLLER_X) { // Middle row state.arm1_target = ARM_1_COUNT_1; state.arm2_target = ARM_2_COUNT_1; state.arm1_manual_lock = false; state.arm2_manual_lock = false; servo[clawservo1] = SERVO_ANGLE_1; servo[clawservo2] = SERVO_ANGLE_1; PlaySound(soundBeepBeep); } else if (event.data == CONTROLLER_A) { // Bottom row state.arm1_target = ARM_1_COUNT_2; state.arm2_target = ARM_2_COUNT_2; state.arm1_manual_lock = false; state.arm2_manual_lock = false; servo[clawservo1] = SERVO_ANGLE_2; servo[clawservo2] = SERVO_ANGLE_2; } else if (event.data == CONTROLLER_Y) { // Top row state.arm1_target = ARM_1_COUNT_4; state.arm2_target = ARM_2_COUNT_4; state.arm1_manual_lock = false; state.arm2_manual_lock = false; servo[clawservo1] = SERVO_ANGLE_4; servo[clawservo2] = SERVO_ANGLE_4; } else if (event.data == CONTROLLER_B) { // Pick-up position state.arm1_target = ARM_1_COUNT_3; state.arm2_target = ARM_2_COUNT_3; state.arm1_manual_lock = false; state.arm2_manual_lock = false; servo[clawservo1] = SERVO_ANGLE_3; servo[clawservo2] = SERVO_ANGLE_3; } else if (event.data == CONTROLLER_JOYCLICK_RIGHT) { // Sweep position state.arm1_target = ARM_1_COUNT_5; state.arm2_target = ARM_2_COUNT_5; state.arm1_manual_lock = false; state.arm2_manual_lock = false; servo[clawservo1] = SERVO_ANGLE_5; servo[clawservo2] = SERVO_ANGLE_5; } else if (event.data == CONTROLLER_JOYCLICK_LEFT) { driveSpeed = driveSpeed == SLOW_CONSTANT ? 1.0 : SLOW_CONSTANT; } } // Refresh some values for important accuracy state.arm1_state = nMotorEncoder[motorARM1]; state.arm2_state = nMotorEncoder[motorARM2]; // Rotate to the target locations if things arent locked if (!state.arm1_manual_lock) { if (abs(state.arm1_target - state.arm1_state) > 100) motor[motorARM1] = state.arm1_target > state.arm1_state ? ARM_SPEED_LOWER : -ARM_SPEED_LOWER; else motor[motorARM1] = 0; } if (!state.arm2_manual_lock) { if (abs(state.arm2_target - state.arm2_state) > 100) motor[motorARM2] = state.arm2_target > state.arm2_state ? ARM_SPEED_UPPER : -ARM_SPEED_UPPER; else motor[motorARM2] = 0; } // Display encoder values on the screen nxtDisplayTextLine(0, "L:%d", nMotorEncoder[motorARM1]); nxtDisplayTextLine(1, "U:%d", nMotorEncoder[motorARM2]); nxtDisplayTextLine(2, "S:%d", ServoValue[clawservo1]); nxtDisplayTextLine(3, "S2:%d", ServoValue[sweeper]); } }
int Main() { run = true; //Peanuts::WindowOptions windowOptions("GL test", Peanuts::Windowed(Peanuts::size(640,480), Peanuts::position(100,100)), Peanuts::OpenGLVersion(3, 1)); Peanuts::WindowOptions windowOptions("GL test", Peanuts::Windowed(Peanuts::size(640,480), Peanuts::Centered()), Peanuts::OpenGLVersion(3, 1)); //Peanuts::WindowOptions windowOptions("GL test", Peanuts::Windowed(Peanuts::size(640,480), Peanuts::Centered(), Peanuts::Borders::Off), Peanuts::OpenGLVersion(3, 1)); //Peanuts::WindowOptions windowOptions("GL test", Peanuts::Windowed(Peanuts::Maximised()), Peanuts::OpenGLVersion(3, 1)); //Peanuts::WindowOptions windowOptions("GL test", Peanuts::Windowed(Peanuts::Maximised(), Peanuts::Borders::Off), Peanuts::OpenGLVersion(3, 1)); //Peanuts::WindowOptions windowOptions("GL test", Peanuts::FullScreen(), Peanuts::OpenGLVersion(3, 1)); auto win = Peanuts::Window::create(windowOptions); EventHandler eventHandler; gl::ClearColor(1.0f, 0.0f, 0.0f, 0.0f); gl::Enable(gl::GL_DEPTH_TEST); gl::DepthFunc(gl::GL_LEQUAL); gl::Enable(gl::GL_CULL_FACE); gl::CullFace(gl::GL_BACK); gl::PolygonMode(gl::GL_FRONT, gl::GL_FILL); gldr::VertexArray vao; vao.bind(); gldr::Texture2d tex; gldr::Program program; { gldr::VertexShader vertexShader(util::loadShader("resource/shaders/basic.vert")); gldr::FragmentShader fragmentShader(util::loadShader("resource/shaders/basic.frag")); program.attach(vertexShader, fragmentShader); program.link(); } GLint modelview, projection; gldr::indexVertexBuffer indexBuffer; gldr::dataVertexBuffer vertexBuffer; gldr::dataVertexBuffer colorBuffer; gldr::dataVertexBuffer textureCoordBuffer; { std::vector<GLfloat> vertexData = { -0.5, -0.5, -0.5, 0.5, -0.5, -0.5, 0.5, 0.5, -0.5, -0.5, 0.5, -0.5, }; std::vector<GLuint> indexdata = { 0, 1, 2, 2, 3, 0 }; std::vector<GLfloat> colors = { 1.0,0.0,0.0, 0.0,1.0,0.0, 0.0,0.0,1.0, 0.0,1.0,1.0 }; std::vector<GLfloat> textureCoord = { 0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, }; vertexBuffer.bufferData(vertexData); colorBuffer.bufferData(colors); indexBuffer.bufferData(indexdata); textureCoordBuffer.bufferData(textureCoord); tex.setFiltering(gldr::textureOptions::FilterDirection::Minification, gldr::textureOptions::FilterMode::Linear); tex.setFiltering(gldr::textureOptions::FilterDirection::Magnification, gldr::textureOptions::FilterMode::Linear); auto image = loadImage("resource/images/pheonixflames.png"); tex.imageData(image.width, image.height, gldr::textureOptions::Format::RGBA, gldr::textureOptions::InternalFormat::RGB, gldr::textureOptions::DataType::UnsignedByte, image.data.data() ); program.use(); GLint position_attribute = program.getAttribLocation("position"); GLint color_attribute = program.getAttribLocation("color"); GLint texture_coord_attribute = program.getAttribLocation("texture_coord"); modelview = program.getUniformLocation("ModelView"); projection = program.getUniformLocation("Projection"); vertexBuffer.bind(); gl::VertexAttribPointer(position_attribute, 3, gl::GL_FLOAT, gl::GL_FALSE, 0, 0); gl::EnableVertexAttribArray(position_attribute); colorBuffer.bind(); gl::VertexAttribPointer(color_attribute, 3, gl::GL_FLOAT, gl::GL_FALSE, 0, 0); gl::EnableVertexAttribArray(color_attribute); textureCoordBuffer.bind(); gl::VertexAttribPointer(texture_coord_attribute, 2, gl::GL_FLOAT, gl::GL_FALSE, 0, 0); gl::EnableVertexAttribArray(texture_coord_attribute); } projectionMat = cam.projection(); cam.pos = glm::vec3(0.0f, 0.0f, -2.0f); cam.dir = glm::vec3(0.0f, 0.0f, 1.0f); Crate crate; while (run) { gl::Clear(gl::GL_COLOR_BUFFER_BIT); gl::Clear(gl::GL_DEPTH_BUFFER_BIT); gl::UniformMatrix4fv(modelview, 1, gl::GL_FALSE, glm::value_ptr(cam.modelView())); gl::UniformMatrix4fv(projection, 1, gl::GL_FALSE, glm::value_ptr(projectionMat)); vao.bind(); tex.bind(); program.use(); gl::DrawElements(gl::GL_TRIANGLES, 6, gl::GL_UNSIGNED_INT, 0); crate.projectWith(projectionMat); crate.draw(); std::this_thread::sleep_for(std::chrono::milliseconds(100)); win->pumpEvents(); while(auto event = win->pollEvent()){ boost::apply_visitor(eventHandler, *event); } win->swapBuffers(); update(); } return 0; }
bool NWindow::depilerPileEvenement(NEvent evenement) { pollEvent(evenement); return true; }
int main() { createWindow(640, 480); int framecnt = 0; Image* img = loadTGAImage("cat.tga"); if(img == NULL) { printf("ERROR: Could not open image file\n"); exit(1); } Image* font = loadTGAImage("font.tga"); if(font == NULL) { printf("ERROR: Could not load font file\n"); exit(1); } int mousePos[2] = {0, 0}; while(1) { KeyEvent ev; profileBlockStart("eventHandling"); while(pollEvent(&ev)) { switch(ev.type) { case KEY_DOWN: printf("Keycode: %d\n", ev.key); if(ev.key == 53) { goto endGame; } break; case MOUSE_MOVE: mousePos[0] = ev.posx; mousePos[1] = ev.posy; break; } } profileBlockEnd("eventHandling"); Image* fb = getFramebuffer(); profileBlockStart("clearFramebuffer"); Color backColor = color(0, 30, 140, 40); clear(fb, &backColor); profileBlockEnd("clearFramebuffer"); profileBlockStart("paintCats"); for(int i = 0; i < 300; i++) { paint(PAINT_OVER, img, fb, (int)(fb->width / 2 + (i * 0.7) * sin(i * 1.221 + framecnt * 0.004)), (int)(fb->height / 2 + (i * 0.7) * cos(i * 1.221 + framecnt * 0.004))); } profileBlockEnd("paintCats"); profileBlockStart("paintText"); Color textColor = color(255, 200, 250, 255); textColor.a = (framecnt * 32) % 256; drawText(fb, font, &textColor, "Hello world!", mousePos[0], mousePos[1]); drawButton(fb, font, "Click here!", 120, 200); profileBlockEnd("paintText"); profileBlockStart("flush"); flushFramebuffer(); profileBlockEnd("flush"); framecnt++; } endGame: saveProfile("_profile.json"); deleteImage(img); closeWindow(); }
int main() { auto window = makeWindow(); // Asset loader setup auto assets = std::make_shared<sfr::AssetTable>(); auto assetLoader = std::make_shared<sfr::AssetLoader>(assets); // Renderer setup auto deferredRenderer = std::make_shared<sfr::DeferredRenderer>(assets); auto transformUpdater = std::make_shared<sfr::TransformUpdater>(); // Scene setup auto scene = std::make_shared<sfr::Scene>(); // Set up a camera positioned at (1, 0, 1) and looking at (0, 0, 0). The // camera's up vector is the y-axis. auto up = sfr::Vector(0, 1.f, 0); auto origin = sfr::Vector(1.f, 0, 1.f); auto target = sfr::Vector(0, 0, 0); auto cameraNode = scene->root()->childIs<sfr::Transform>("camera"); cameraNode->transformIs(sfr::Matrix::look(origin, target, up)); auto camera = cameraNode->childIs<sfr::Camera>(); camera->viewportWidthIs(window->getSize().x); camera->viewportWidthIs(window->getSize().y); scene->cameraIs(camera); // set this camera to the active camera // Place the car mesh (loaded from the asset loader) at (0, 0, 0) auto car = assets->assetIs<sfr::Transform>("meshes/Lexus.obj"); scene->root()->childIs(car); // Place a spotlight at (0, 16, 0) and point it down towards the car. The // spotlight's position is determined from the parent transform. auto lightNode = scene->root()->childIs<sfr::Transform>("light"); lightNode->positionIs(sfr::Vector(0, 16.f, 0)); auto light = lightNode->childIs<sfr::SpotLight>(); light->spotCutoffIs(20.f); // set spot light to spread by 20 degrees light->spotPowerIs(40.f); // larger spotPower results in sharper beam edges light->constantAttenuationIs(1.f); light->linearAttenuationIs(0); light->quadraticAttenuationIs(0); light->specularColorIs(sfr::Color(1.f, 1.f, 1.f, 1.f)); light->diffuseColorIs(sfr::Color(3.f, 3.f, 3.f, 3.f)); // really bright light light->directionIs(sfr::Vector(0, -1.f, 0)); // point the light down the y-axis // Enable shadows for the light light->shadowMapIs(std::make_shared<sfr::DepthRenderTarget>(1024, 1024)); // Run the render loop. This code differs depending on what windowing // library you use. The parts that will always remain the same are: // 1. glClear // 2. transformUpdater->operator(): Updates the scene graph world transforms // 3. deferredRenderer->operator()): Renders the scene while (window->isOpen()) { sf::Event evt; while (window->pollEvent(evt)) { switch (evt.type) { case sf::Event::Closed: exit(0); break; default: break; } } glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); transformUpdater->operator()(scene); deferredRenderer->operator()(scene); window->display(); } return 0; }
bool NWindow::depilerPileEvenement(NEvent evenement) { pollEvent(evenement); }
Common::Error TinselEngine::run() { // Initialize backend if (getGameID() == GID_DW2) { #ifndef DW2_EXACT_SIZE initGraphics(640, 480, true); #else initGraphics(640, 432, true); #endif _screenSurface.create(640, 432, 1); } else { initGraphics(320, 200, false); _screenSurface.create(320, 200, 1); } g_system->getEventManager()->registerRandomSource(_random, "tinsel"); _console = new Console(); _scheduler = new Scheduler(); InitSysVars(); // init memory manager MemoryInit(); // load user configuration ReadConfig(); #if 1 // FIXME: The following is taken from RestartGame(). // It may have to be adjusted a bit CountOut = 1; RebootCursor(); RebootDeadTags(); RebootMovers(); resetUserEventTime(); RebootTimers(); RebootScalingReels(); DelayedScene.scene = HookScene.scene = 0; #endif // Load in text strings ChangeLanguage(g_language); // Init palette and object managers, scheduler, keyboard and mouse RestartDrivers(); // load in graphics info SetupHandleTable(); // Actors, globals and inventory icons LoadBasicChunks(); // Continuous game processes CreateConstProcesses(); // allow game to run in the background //RestartBackgroundProcess(); // FIXME: is this still needed? //dumpMusic(); // dumps all of the game's music in external XMIDI files // Load game from specified slot, if any // // TODO: We might want to think about properly taking care of possible // errors when loading the save state. if (ConfMan.hasKey("save_slot")) { if (loadGameState(ConfMan.getInt("save_slot")) == Common::kNoError) loadingFromGMM = true; } // Foreground loop uint32 timerVal = 0; while (!shouldQuit()) { assert(_console); if (_console->isAttached()) _console->onFrame(); // Check for time to do next game cycle if ((g_system->getMillis() > timerVal + GAME_FRAME_DELAY)) { timerVal = g_system->getMillis(); AudioCD.updateCD(); NextGameCycle(); } if (bRestart) { RestartGame(); bRestart = false; bHasRestarted = true; // Set restarted flag } // Save/Restore scene file transfers ProcessSRQueue(); // Handle any playing movie FettleBMV(); #ifdef DEBUG if (bFast) continue; // run flat-out #endif // Loop processing events while there are any pending while (pollEvent()) ; DoCdChange(); if (MoviePlaying() && NextMovieTime()) g_system->delayMillis(MAX<int>(NextMovieTime() - g_system->getMillis() + MovieAudioLag(), 0)); else g_system->delayMillis(10); } // Write configuration WriteConfig(); return Common::kNoError; }
int Main() { run = true; Peanuts::WindowOptions windowOptions("GL test", Peanuts::Windowed(std::pair<int,int>(640,480),Peanuts::Centered()), Peanuts::OpenGLVersion(1, 4)); auto win = Peanuts::Window::create(windowOptions); EventHandler eventHandler; gl::ClearColor(1.0f, 0.0f, 0.0f, 0.0f); std::chrono::milliseconds dura( 2000 ); GLfloat vertices_position[24] = { 0.0, 0.0, 0.5, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 0.5, -0.5, 0.5, 0.0, 0.0, -0.5, 0.0, -0.5, -0.5, 0.0, 0.0, 0.0, -0.5, 0.5, -0.5, }; // Create a Vector Buffer Object that will store the vertices on video memory GLuint vbo; gl::GenBuffers(1, &vbo); gl::BindBuffer(gl::ARRAY_BUFFER, vbo); gl::BufferData(gl::ARRAY_BUFFER, sizeof(vertices_position), vertices_position, gl::STATIC_DRAW); std::string vert_shader_code = ( "#version 150\n" "\n" "in vec4 position;\n" "\n" "void main() {\n" " gl_Position = position;\n" "}\n" ); std::string frag_shader_code = ( "#version 150\n" "\n" "out vec4 out_color;\n" "\n" "void main() {\n" " out_color = vec4(0.0, 1.0, 1.0, 1.0);\n" "}\n" ); auto program = create_program(vert_shader_code, frag_shader_code); GLuint vao; gl::GenVertexArrays(1, &vao); gl::BindVertexArray(vao); GLint position_attribute = gl::GetAttribLocation(program, "position"); // Specify how the data for position can be accessed gl::VertexAttribPointer(position_attribute, 2, gl::FLOAT, false, 0, 0); // Enable the attribute gl::EnableVertexAttribArray(position_attribute); while (run) { gl::Clear(gl::COLOR_BUFFER_BIT); gl::BindVertexArray(vao); gl::DrawArrays(gl::TRIANGLES, 0, 12); std::this_thread::sleep_for(dura); win->pumpEvents(); while(auto event = win->pollEvent()){ boost::apply_visitor(eventHandler, *event); } win->swapBuffers(); } return 0; }
void AsyncCopier::copyHtoD(void* dest, const void* src, size_t size) { VLOG(1) << "copyHtoD " << size; auto pdest = static_cast<uint8_t*>(dest); auto psrc = static_cast<const uint8_t*>(src); unsigned int flags; auto err = cudaHostGetFlags(&flags, const_cast<void*>(src)); if (err == cudaSuccess) { // Page-locked using cudaHostAlloc / cudaHostRegister, copy directly. checkCudaError(cudaMemcpyAsync(dest, src, size, cudaMemcpyHostToDevice), "cudaMemcpyAsync"); return; } else if (err != cudaErrorInvalidValue) { checkCudaError(err, "invalid return code from cudaMemcpyAsync"); } cudaGetLastError(); // reset last error // This is dicey -- what if another kernel has completed with an error? // But there's nothing else we can do, as any cuda function may return an // error from a previous kernel launch. if (size > bufferSize_) { // Copy synchronously. checkCudaError(cudaMemcpy(dest, src, size, cudaMemcpyHostToDevice), "cudaMemcpy"); return; } Event* eventToWait = nullptr; auto copyRange = [this, &size, &pdest, &psrc] (AllocatedBlock& range) { size_t n = std::min(size, range.length); range.length = n; VLOG(1) << "Copy " << range.start << " + " << n; auto bufPtr = buffer_.get() + range.start; memcpy(bufPtr, psrc, n); checkCudaError(cudaMemcpyAsync(pdest, bufPtr, n, cudaMemcpyHostToDevice), "cudaMemcpyAsync"); pdest += n; psrc += n; size -= n; checkCudaError(cudaEventRecord(*range.event->event), "cudaEventRecord"); allocated_.push_back(range); }; for (;;) { { std::lock_guard<std::mutex> lock(mutex_); if (eventToWait) { releaseEventLocked(eventToWait); eventToWait = nullptr; } // Always reap while (!allocated_.empty() && pollEvent(allocated_.front().event)) { releaseEventLocked(allocated_.front().event); allocated_.pop_front(); } auto ranges = getRangesLocked(); if (!ranges.empty()) { auto ev = getEventLocked(); for (auto it = ranges.begin(); size != 0 && it != ranges.end(); ++it) { auto& range = *it; ++ev->refCount; range.event = ev; copyRange(range); } releaseEventLocked(ev); if (size == 0) { break; } } // Sigh, we have to wait. eventToWait = allocated_.front().event; ++eventToWait->refCount; } DCHECK(eventToWait); VLOG(1) << "Waiting, remaining " << size; waitEvent(eventToWait); } VLOG(1) << "End copyHtoD"; DCHECK(!eventToWait); }
int main(int argc, char* argv[]) { printf("SimpleDS\n"); printf("Build: " VERSION_STR " (" SYSTEM_NAME " " SYSTEM_PROCESSOR ")"); #ifdef SDL_HAPTIC_DISABLED printf(" - No Haptic"); #endif printf("\nAuthors: " VERSION_AUTHORS "\n"); args = std::vector<const char*>(argv, argv + argc); int offset = 1; std::string configFile = "./simpleds.conf"; if (hasOpt("-c") || hasOpt("--config")) { configFile = getOpt("-c"); if (configFile.size() == 0) { configFile = getOpt("--config"); } offset += 2; } config = new Config(configFile); if (config->loaded) { printf("Config: %s\n", configFile.c_str()); if (config->has("DS.foo")) { printf("Foo: %s\n", config->getString("DS.foo").c_str()); } } else { printf("Config file couldn't be loaded, won't be able to save\n"); } uint16_t teamNum = (uint16_t)config->getInt32("DS.team"); verbose = (hasOpt("-v") || hasOpt("--verbose")); if (hasOpt("-V") || hasOpt("--version")) { return 0; } if (hasOpt("-h") || hasOpt("--help")) { printUsage(); printf("Options:\n"); printf(" -h, --help Prints this message\n"); printf(" -v, --verbose Output debugging information\n"); printf(" -V, --version Prints version info and exits\n"); printf(" -c, --config Sets the config file to use [default: ./simpleds.conf]\n"); printf(" teamNum The team number to use, must be provided here or in configuration file\n"); return 0; } if (teamNum == 0 && args.begin() + offset == args.end()) { // We're out of arguments printUsage(); return 1; } else { char* endptr; uint16_t argTeamNum = (uint16_t)std::strtol(args[offset], &endptr, 10); if (endptr == args[offset] || *endptr != '\0') { // No team number in config, and none provided if (teamNum == 0) { printUsage(); return 1; } } else { teamNum = argTeamNum; } } printf("Team Number: %d\n", teamNum); bool quit = false; SDL_Event e; auto gui = new GUI(); if (!gui->isValid()) { return 1; } config->setInt32("DS.team", teamNum); config->initInt32("DS.alliance", Alliance::RED); config->initInt32("DS.position", 1); DS::initialize(teamNum); auto ds = DS::getInstance(); enum GUIMode { MAIN, INFO, JOYSTICKS, CONTROL, HELP, COUNT }; GUIMode mode = GUIMode::MAIN; auto runner = std::async(std::launch::async, &DS::run, ds); std::map<GUIMode, Screen*> screens; screens[MAIN] = new ScreenMain(); screens[INFO] = new ScreenInfo(); screens[JOYSTICKS] = new ScreenJoysticks(); screens[CONTROL] = new ScreenControl(); screens[HELP] = new ScreenHelp(); while (!quit) { while (gui->pollEvent(&e) != 0) { if (e.type == SDL_QUIT) { quit = true; } else if (e.type == SDL_JOYDEVICEREMOVED || e.type == SDL_JOYDEVICEADDED) { ds->setEnable(false); ds->loadJoysticks(); } else if (e.type == SDL_KEYDOWN && e.key.repeat == 0) { auto key = e.key.keysym; if (key.sym == SDLK_e) { ds->toggleEnable(); } else if (key.sym == SDLK_SPACE) { ds->setEnable(false); } else if (key.sym == SDLK_0) { ds->setEStop(); } else if (key.sym == SDLK_q) { quit = true; } else if (key.sym == SDLK_r) { if (key.mod & KMOD_SHIFT) { ds->reboot(); } else { ds->restartCode(); } } else if (key.sym == SDLK_BACKQUOTE) { ds->setAlliance(ds->getAlliance() == Alliance::BLUE ? Alliance::RED : Alliance::BLUE); } else if (key.sym >= SDLK_1 && key.sym <= SDLK_9) { uint8_t keyNum = (uint8_t)(1 + key.sym - SDLK_1); if (key.mod & KMOD_CTRL && keyNum >= 1 && keyNum <= 3) { ds->setPosition(keyNum); } else if (key.mod & KMOD_SHIFT && keyNum >= 1 && keyNum <= 3) { ds->setEnable(false); ds->setMode((Mode)(keyNum - 1)); } else if (keyNum >= 1 && keyNum <= GUIMode::COUNT) { mode = (GUIMode)(keyNum - 1); } } } screens[mode]->update(e); } if (gui->readyToDraw()) { gui->setOffset(10, 10); gui->clear(); gui->drawScreen(screens[mode]); gui->setOffset(10, gui->getHeight() - gui->getCharSize().y); gui->drawText(0, 0, "1: Main", mode == GUIMode::MAIN ? Colors::BLACK : Colors::DISABLED); gui->drawTextRel(9, 0, "2: Info", mode == GUIMode::INFO ? Colors::BLACK : Colors::DISABLED); gui->drawTextRel(9, 0, "3: Joysticks", mode == GUIMode::JOYSTICKS ? Colors::BLACK : Colors::DISABLED); gui->drawTextRel(14, 0, "4: Control", mode == GUIMode::CONTROL ? Colors::BLACK : Colors::DISABLED); gui->drawTextRel(12, 0, "5: Help", mode == GUIMode::HELP ? Colors::BLACK : Colors::DISABLED); gui->render(); } std::string s = narf::util::format("Team %d", teamNum); if (ds->isConnected()) { auto rio = ds->getRoboRIO(); s += " - "; if (rio->getEStop()) { s += "E-Stopped"; } else { s += narf::util::format("%s %s", modeNames[rio->getMode()].c_str(), rio->getEnable() ? "Enabled" : "Disabled"); } s += narf::util::format(" - %s %d", allianceNames[ds->getAlliance()].c_str(), ds->getPosition()); if (!rio->getCode()) { s += " - No Code"; } } else { s += " - No Comms"; } gui->setTitle(s); ds->updateJoysticks(); SDL_Delay(25); } ds->saveJoysticks(); ds->stop(); SDL_Quit(); return 0; }
void Fenettre::RenderMe() { #if FRAME_TIME <= 0 sf::Clock clock; #endif bool run = false; PositionCamera(); while(isOpen()) { sf::Event event; while(pollEvent(event)) { if (event.type == sf::Event::Closed) { close(); } else if ((event.type == sf::Event::KeyPressed) && (event.key.code == sf::Keyboard::Escape)) { close(); } else if ((event.type == sf::Event::KeyPressed) && (event.key.code == sf::Keyboard::Space)) { run = !run; } else if ((event.type == sf::Event::KeyPressed) && (event.key.code == sf::Keyboard::R)) { camera->setPosition(btVector3(-100,50,0)); } // Adjust the viewport when the window is resized else if (event.type == sf::Event::Resized) { glViewport(0, 0, event.size.width, event.size.height); } else if (run && event.type == sf::Event::MouseMoved) { camera->MouseMoved(); } else if (run && event.type == sf::Event::MouseWheelMoved) { camera->MouseWheelMoved(event); } else if (run && event.type == sf::Event::MouseButtonPressed) { shootBox(camera->GetCible()); } } // Clear color and depth buffer glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Update dynamics if (run) { #if FRAME_TIME <= 0 World->stepSimulation(clock.GetElapsedTime()); camera->animate(clock.GetElapsedTime()); #else World->stepSimulation(1.0f/FRAME_TIME); camera->animate(1.0f/FRAME_TIME); #endif PositionCamera(); } RenderScene(); glFlush(); display(); } };
void android_main(struct android_app* app) { char * argv[] = {"cvandroid"}; const EGLint attr[] = { EGL_SURFACE_TYPE, EGL_WINDOW_BIT, EGL_BLUE_SIZE, 8, EGL_GREEN_SIZE, 8, EGL_RED_SIZE, 8, EGL_NONE }; EGLint ncfg; EGLint fmt; EGLint w; EGLint h; EGLConfig cfg; EGLDisplay dpy; EGLSurface surf; EGLContext ctx; app_dummy(); app->userData = 0; app->onAppCmd = handle; app->onInputEvent = input; dbg("wait\n"); while (!app->userData) pollEvent(app); g_app = app; cvInject(CVE_INIT, 1, (intptr_t)argv); dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY); if (!eglInitialize(dpy, 0, 0)) err("initialize display"); eglChooseConfig(dpy, attr, &cfg, 1, &ncfg); eglGetConfigAttrib(dpy, cfg, EGL_NATIVE_VISUAL_ID, &fmt); ANativeWindow_setBuffersGeometry(app->window, 0, 0, fmt); surf = eglCreateWindowSurface(dpy, cfg, app->window, 0); ctx = eglCreateContext(dpy, cfg, 0, 0); eglMakeCurrent(dpy, surf, surf, ctx); eglQuerySurface(dpy, surf, EGL_WIDTH, &w); eglQuerySurface(dpy, surf, EGL_HEIGHT, &h); if (!eglSwapInterval(dpy, 1)) err("setting swap interval"); cvInject(CVE_RESIZE, w, h); cvInject(CVE_GLINIT, 0, 0); app->userData = 0; while (!app->userData && !app->destroyRequested) { cvInject(CVE_UPDATE, 0, 0); if (!eglSwapBuffers(dpy, surf)) err("swapbuffers failed"); pollEvent(app); } if (app->destroyRequested) cvInject(CVE_CLOSE, 0, 0); dbg("terminated"); cvInject(CVE_GLTERM, 0, 0); if (!eglMakeCurrent(dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT)) err("clearing current"); if (!eglDestroyContext(dpy, ctx)) err("destroying context"); if (!eglDestroySurface(dpy, surf)) err("destroying surface"); if (!eglTerminate(dpy)) err("terminating"); }