Example #1
0
	void EventBuffer::pollEvents(sf::Window& window)
	{
		sf::Event event;

		while (window.pollEvent(event))
			pushEvent(event);
	}
Example #2
0
void mainEventHandler(sf::Window &window){

        sf::Event event;
        while (window.pollEvent(event))
        {
            switch (event.type){
                case sf::Event::Closed:
                    window.close();
                    break;

                case sf::Event::KeyPressed:
                    keyPressedHandler(event);
                    break;

                case sf::Event::KeyReleased:
                    keyReleasedHandler(event);
                    break;

                case sf::Event::LostFocus:
                    /* pause(); */
                    break;

                case sf::Event::GainedFocus:
                    /* resume(); */
                    break;


                default: break;
            }
        }
        
}
bool updatePlayer(){
	vec2 pos;
	pos = player.pos;
	sf::Event event;


	while (window.pollEvent(event)){
		while (event.type != sf::Event::KeyPressed){
		    switch (event.key.code){
		    	case sf::Keyboard::W:
	   			pos.y--;
		    	break;
		    	case sf::Keyboard::A:
				pos.x--;
		    	break;
		    	case sf::Keyboard::S:
				pos.y++;
		    	break;
		    	case sf::Keyboard::D:
				pos.x++;
		    	break;
		    	default:
		    	return false;
		    }
		}
	}

	if (arborArray[pos.x][pos.y] == '.'){
		updateWolf();
		player.pos = pos;
		arborArray[player.pos.x][player.pos.y] = '@';	
		return true;
	}
	return false;
}
Example #4
0
	void handleEvents(WorldState & state, RenderEngine & render)
	{
		sf::Event event;
		
		while (window->pollEvent(event))
		{
			if (event.type == sf::Event::Closed)
				state.setRunning(false);
			if ((event.type == sf::Event::KeyPressed) && (event.key.code == sf::Keyboard::Escape))
				state.setRunning(false);
			
			if((event.type == sf::Event::TextEntered) && (event.text.unicode == 'r'))
				state.toggleModelRotate();
			if((event.type == sf::Event::TextEntered) && (event.text.unicode == 'q'))
				state.toggleIncreaseVelocity();
			
			if(event.type == sf::Event::Resized) {
				resize(event.size.width, event.size.height);
			}

			if(event.type == sf::Event::MouseButtonPressed)
			{
				state.lastClickPos[0] = event.mouseButton.x;
				state.lastClickPos[1] = (state.currentRes[1]-event.mouseButton.y);
				state.lastFrameDragPos[0] = event.mouseButton.x;
				state.lastFrameDragPos[1] = (state.currentRes[1]-event.mouseButton.y);
				state.mouseButtonDown = true;
			}

			if(event.type == sf::Event::MouseButtonReleased)
				state.mouseButtonDown = false;

			if(event.type == sf::Event::MouseMoved && state.mouseButtonDown)
			{
				state.cursorDragAmount[0] += state.lastFrameDragPos[0] - event.mouseMove.x;
				state.cursorDragAmount[1] += state.lastFrameDragPos[1] - (state.currentRes[1]-event.mouseMove.y);
				state.lastFrameDragPos[0] = event.mouseMove.x;
				state.lastFrameDragPos[1] = (state.currentRes[1]-event.mouseMove.y);
			}

			if(event.type == sf::Event::MouseWheelMoved)
			{
				state.zoomCamera(event.mouseWheel.delta);
				state.cursorScrollAmount += event.mouseWheel.delta;
			}

			if(event.type == sf::Event::MouseMoved)
			{
				state.cursorAbsolutePos[0] = event.mouseMove.x;
				state.cursorAbsolutePos[1] = (state.currentRes[1]-event.mouseMove.y);
			}

			if ((event.type == sf::Event::KeyPressed) && (event.key.code == sf::Keyboard::Up))
				state.zoomCamera(1);
			if ((event.type == sf::Event::KeyPressed) && (event.key.code == sf::Keyboard::Down))
				state.zoomCamera(-1);

		}
	}
    void start() {
        std::chrono::time_point<std::chrono::system_clock> startTime=std::chrono::system_clock::now();

        //Event thread (main thread)
        bool running = true;
        while (running) {
            sf::Event event;
            while (window.pollEvent(event)) {
                if (event.type == sf::Event::KeyPressed) {
                    if (sf::Keyboard::isKeyPressed(sf::Keyboard::Escape)) {
                        window.close();
                        running=false;
                    }
                }
                else if (event.type == sf::Event::Closed) {
                    window.close();
                    running = false;
                }
            }
            
            std::chrono::duration<double> elapsed_seconds = std::chrono::system_clock::now() - startTime;
            double time=elapsed_seconds.count();
            
            glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
            glLoadIdentity();
        
            gluLookAt(0.0, 30.0, -65.0, //Camera position in World Space
                      0.0, 5.0, 0.0,    //Camera looks towards this position
                      0.0, 1.0, 0.0);   //Up
        
            glPushMatrix();
            glRotatef(-time*50.0, 0.0, 1.0, 0.0);
            glTranslatef(20.0, 0.0, 0.0);            
            unanimatedAstroBoy.draw();
            glPopMatrix();
            
            glPushMatrix();
            glRotatef(-time*50.0+90.0, 0.0, 1.0, 0.0);
            glTranslatef(20.0, 0.0, 0.0);            
            astroBoy.drawFrame(time);
            glPopMatrix();
            
            glPushMatrix();
            glRotatef(-time*50.0+180.0, 0.0, 1.0, 0.0);
            glTranslatef(20.0, 0.0, 0.0);            
            astroBoyMovingGlasses.drawFrame(time);
            glPopMatrix();
            
            glRotatef(-time*50.0+270.0, 0.0, 1.0, 0.0);
            glTranslatef(20.0, 0.0, 0.0);            
            astroBoyHeadBanging.drawFrame(time);
            
            //Swap buffer (show result)
            window.display();
        }
    }
Example #6
0
//!-----------------------------------------------------------------------------
//! FUNCTION IMPLEMENTATIONS
//!-----------------------------------------------------------------------------
int treatEvents(sf::Window &window)
{
  static sf::Event event;
  while (window.pollEvent(event))
  {
    if (event.type == sf::Event::Closed)
      return STOP;
  }
  return CONTINUE;
}
void
windowEvents ( sf::Window& window)
{
    sf::Event e;

    while ( window.pollEvent ( e ) ) {
        if ( e.type == sf::Event::Closed ) {
            window.close();
        }
    }
}
void pollEvents()
{
	sf::Event windowEvent;
	while (window.pollEvent(windowEvent))
	{
		switch (windowEvent.type)
		{
		case sf::Event::Closed:
			window.close();
			break;
		}
	}
}
Example #9
0
bool handleEvents(sf::Window& window, sf::View& view) {
	sf::Event event;
	bool continueRunning = true;

	while (window.pollEvent(event)) {
		if (event.type == sf::Event::Closed) {
			continueRunning = false;
		}
		if (event.type == sf::Event::Resized) {
			view.setSize(event.size.width, event.size.height);
		}
	}

	return continueRunning;
}
Example #10
0
void EventHandler::Listen(sf::Window& Window){
    event_queue_t& queue = Object()->m_event_queue;
    listener_map_pair_t ptr_range;
    sf::Event nextEvent;

    while (Window.pollEvent(nextEvent))
    {
        queue.push(nextEvent);
    }

    while(!queue.empty()){
        Object()->doCallEvent(queue.front(),
        Object()->m_listener_map.equal_range(queue.front().type));
        queue.pop();
    }
}
Example #11
0
File: main.cpp Project: mimaun/Rose
 void handleEvents(sf::Window & window, WorldState & state)
 {
     sf::Event event;
     while (window.pollEvent(event))
     {
         // Close window : exit
         if (event.type == sf::Event::Closed)
             state.setRunning(false);
         
         // Escape key : exit
         if ((event.type == sf::Event::KeyPressed) && (event.key.code == sf::Keyboard::Escape))
             state.setRunning(false);
         
         if (event.type == sf::Event::MouseMoved) {
             state.updateMousePos(event.mouseMove.x, event.mouseMove.y);
         }
     }
 }
Example #12
0
	void InputHandler::processEvents(sf::Window& window) {
		reset();

		sf::Event event;
		while (window.pollEvent(event)) {
			switch (event.type) {
				case sf::Event::KeyPressed:
					if (key_press_callback_func != nullptr)
						key_press_callback_func(event.key);
					break;
				case sf::Event::KeyReleased:
					if (key_release_callback_func != nullptr)
						key_release_callback_func(event.key);
					break;
				case sf::Event::MouseMoved:
					m_NewMousePosition.x = event.mouseMove.x;
					m_NewMousePosition.y = event.mouseMove.y;

					if (mouse_moved_callback_func != nullptr)
						mouse_moved_callback_func(event.mouseMove);

					m_LastMousePosition.x = event.mouseMove.x;
					m_LastMousePosition.y = event.mouseMove.y;
					break;
				case sf::Event::MouseWheelScrolled:
					if (mouse_wheel_scroll_callback_func != nullptr)
						mouse_wheel_scroll_callback_func(event.mouseWheelScroll);
					break;
				case sf::Event::MouseButtonPressed:
					if (mouse_button_pressed_callback_func != nullptr)
						mouse_button_pressed_callback_func(event.mouseButton);
					StartDrag(event.mouseButton);
					break;
				case sf::Event::MouseButtonReleased:
					StopDrag(event.mouseButton);
					if (mouse_button_released_callback_func != nullptr)
						mouse_button_released_callback_func(event.mouseButton);
					break;
				case sf::Event::Closed:
					window.close();
					break;
			}
		}
	}
Example #13
0
	void handleEvents(WorldState & state, RenderEngine & render)
	{
		sf::Event event;
		
		while (App->pollEvent(event))
		{
			if (event.type == sf::Event::Closed)
				state.setRunning(false);
			if ((event.type == sf::Event::KeyPressed) && (event.key.code == sf::Keyboard::Escape))
				state.setRunning(false);
			
            if((event.type == sf::Event::TextEntered) && (event.text.unicode == 'q'))
                state.setShadingMode(0);
            if((event.type == sf::Event::TextEntered) && (event.text.unicode == 'w'))
                state.setShadingMode(1);
            if((event.type == sf::Event::TextEntered) && (event.text.unicode == 'e'))
                state.setShadingMode(2);
			if((event.type == sf::Event::TextEntered) && (event.text.unicode == 'r'))
                state.toggleModelRotate();
			if((event.type == sf::Event::TextEntered) && (event.text.unicode == 't'))
                state.toggleLightRotate();
		}
	}
Example #14
0
	void handleEvents(sf::Window & window, WorldState & state)
	{
		sf::Event event;
		while (window.pollEvent(event))
		{
			// Close window : exit
			if (event.type == sf::Event::Closed)
				state.setRunning(false);
			
			// Escape key : exit
			if ((event.type == sf::Event::KeyPressed) && (event.key.code == sf::Keyboard::Escape))
				state.setRunning(false);
            
            if (event.type == sf::Event::TextEntered) {
                
                Model const & model = state.getModel();
                float time = state.getCurrentTime();
                RenderEngine render = RenderEngine(render);
                switch (static_cast<char>(event.key.code)) {
                        
                    case 'q':
                        printf("'q' should scale\n");
                        
                        // scale = true.
                        //if(!state.scaleEnabled())
                            state.toggleScale();
                            
                        break;
                        
                    case 'w':
                        printf("'w' should enable bouncing\n");

                            state.toggleTranslate();
                            
                        break;
                        
                    case 'e':
                        printf("'e' should enable z rotation\n");
                        
                        // rotZ = true.

                            state.toggleRotZ();
                        
                        break;
                        
                    case 'r':
                        printf("'r' should enable y rotation\n");
                        
                        // rotY = true.

                            state.toggleRotY();
                        
                        break;
                        
                    default:
                        printf("nothing\n");
                        break;
                }
            }
//                std::cout << "Your Input: " << static_cast<char>(event.key.code) << std::endl;

			
			//TODO add event handlers for qwer
			//'q' should scale
			//'w' should enable bouncing
			//'e' should enable z rotation
			//'r' should enable y rotation
		}
	}
Example #15
0
	void handleEvents(WorldState & state, RenderEngine & render)
	{
		bool shiftDown = sf::Keyboard::isKeyPressed(sf::Keyboard::LShift) ||sf::Keyboard::isKeyPressed(sf::Keyboard::RShift);
		sf::Event Event;
		
		while (App->pollEvent(Event))
		{
			if (Event.type == sf::Event::Closed)
				state.setRunning(false);
			if ((Event.type == sf::Event::KeyPressed) && (Event.key.code == sf::Keyboard::Escape))
				state.setRunning(false);
			
			if (Event.type == sf::Event::MouseButtonPressed)
			{
				previousPos = glm::vec2(Event.mouseButton.x, Event.mouseButton.y);
				
				if(Event.mouseButton.button == sf::Mouse::Left && !shiftDown)
					buttonDown[0] = 1;
				if(Event.mouseButton.button == sf::Mouse::Right)
					buttonDown[1] = true;
				if(Event.mouseButton.button == sf::Mouse::Middle)
					buttonDown[2] = true;
				if(Event.mouseButton.button == sf::Mouse::Left && shiftDown)
					buttonDown[2] = true;
			}
			
			if (Event.type == sf::Event::MouseButtonReleased)
			{
				if(Event.mouseButton.button == sf::Mouse::Left && !shiftDown)
					buttonDown[0] = false;
				if(Event.mouseButton.button == sf::Mouse::Right)
					buttonDown[1] = false;
				if(Event.mouseButton.button == sf::Mouse::Middle)
					buttonDown[2] = false;
				if(Event.mouseButton.button == sf::Mouse::Left && shiftDown)
					buttonDown[2] = false;
				
				lastUpdate = timer.getElapsedTime().asSeconds();
			}
			
			if (Event.type == sf::Event::Resized) {
				render.reshape( Event.size.width, Event.size.height );
				state.setSize( Event.size.width, Event.size.height );
			}
		}
		
		
		lastUpdate = timer.getElapsedTime().asSeconds();
		bool needsUpdate = lastUpdate > TIME_BETWEEN_UPDATES;
		if (needsUpdate)
		{
			glm::ivec2 newPos = glm::ivec2(sf::Mouse::getPosition(*App).x, sf::Mouse::getPosition(*App).y);
			
			if(buttonDown[0])
				state.updateRotate(previousPos, newPos);
			if(buttonDown[1])
				state.updateXYTranslate(previousPos, newPos);
			if(buttonDown[2])
				state.updateZTranslate(previousPos, newPos);
			
			lastUpdate = timer.restart().asSeconds();
			previousPos = newPos;
		}
	}
Example #16
0
void InputSystem::update( sf::Window &window )
{
	sf::Event lEvent;

	while (window.pollEvent( lEvent ))
	{
		switch (lEvent.type)
		{
			case sf::Event::KeyPressed:
			{
				KeyboardEvent* e = new KeyboardEvent();

				e->mKeyCode = lEvent.key.code;
				e->mkeyPressed = true;
				e->setID(E_KeyboardPressed);

				EventSystem::ptr()->dispatchEvent(e);
				break;
			}
		
			case sf::Event::KeyReleased:
			{
				KeyboardEvent* e = new KeyboardEvent();

				e->mKeyCode = lEvent.key.code;
				e->mKeyReleased = true;
				e->setID(E_KeyboardReleased);

				EventSystem::ptr()->dispatchEvent(e);
				break;

			}

			case sf::Event::MouseButtonPressed:
			{
				MouseEvent* e = new MouseEvent();

				e->mMouseButton = static_cast<int>(lEvent.mouseButton.button);
				e->mMousePressed = true;
				e->setID(E_MouseButtonPressed);

				EventSystem::ptr()->dispatchEvent(e);
				break;
			}

			case sf::Event::MouseButtonReleased:
			{
				MouseEvent* e = new MouseEvent();

				e->mMouseButton = lEvent.mouseButton.button;
				e->mMouseReleased = true;
				e->setID(E_MouseButtonReleased);

				EventSystem::ptr()->dispatchEvent(e);
				break;
			}

			case sf::Event::MouseMoved:
			{
				MouseEvent* e = new MouseEvent();

				e->mMouseMoved = true;
				e->mMouseMoveX = lEvent.mouseMove.x;
				e->mMouseMoveY = lEvent.mouseMove.y;
				e->mMouseMoveZ = lEvent.mouseWheel.delta;
				e->setID(E_MouseMoved);

				EventSystem::ptr()->dispatchEvent(e);
				break;
			}

			case sf::Event::Closed:
			{
				Event* e = new Event( E_INPUT );
				e->setID(E_WindowClosed);

				EventSystem::ptr()->dispatchEvent(e);
				break;
			}

			case sf::Event::Resized:
			{
				Event* e = new Event(E_INPUT);
				e->setID(E_WindowResized);

				EventSystem::ptr()->dispatchEvent(e);
				break;
			}
		}
	}
}