mitchellhansen/voxel-raycaster
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

More work on the event system, sf::Events are completely wrapped now.

Browse Source
This commit is contained in:
MitchellHansen
2017-01-14 13:49:56 -08:00
parent 36851ad011
commit 0e1e9af37c
10 changed files with 195 additions and 255 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
include/Camera.h
View File

@@ -2,9 +2,9 @@
#include <SFML/System/Vector3.hpp>
#include <SFML/System/Vector2.hpp>
#include "util.hpp"
#include "Pub_Sub.hpp"
#include "Pub_Sub.h"
class Camera : public SfEventSubscriber{
class Camera : public VrEventSubscriber{
public:
enum DIRECTION { FORWARD, REARWARD, LEFT, RIGHT, UP, DOWN };
@@ -35,7 +35,7 @@ public:
sf::Vector2f get_direction();
virtual void update(SfEventPublisher* p, sf::Event e) override;
void update(VrEventPublisher* p, vr::Event e) override;
private:

14
include/Event.hpp
View File

@@ -4,7 +4,7 @@
#include <SFML/Window/Mouse.hpp>
#include <SFML/Window/Joystick.hpp>
#include <SFML/Window/Sensor.hpp>
#include <GL/glew.h>
namespace vr {
@@ -125,7 +125,7 @@ namespace vr {
class MouseWheelScrolled : public Event {
public:
MouseWheelScrolled(sf::Mouse::Wheel wheel, bool delta, bool x, bool y) :
MouseWheelScrolled(sf::Mouse::Wheel wheel, float delta, int x, int y) :
wheel(wheel), delta(delta), x(x), y(y), Event(vr::Event::EventType::MouseWheelScrolled) {};
sf::Mouse::Wheel wheel;
@@ -136,7 +136,7 @@ namespace vr {
class MouseButtonPressed : public Event {
public:
MouseButtonPressed(sf::Mouse::Button button, bool x, bool y) :
MouseButtonPressed(sf::Mouse::Button button, int x, int y) :
button(button), x(x), y(y), Event(vr::Event::EventType::MouseButtonPressed) {};
sf::Mouse::Button button;
@@ -146,7 +146,7 @@ namespace vr {
class MouseButtonReleased : public Event {
public:
MouseButtonReleased(sf::Mouse::Button button, bool x, bool y) :
MouseButtonReleased(sf::Mouse::Button button, int x, int y) :
button(button), x(x), y(y), Event(vr::Event::EventType::MouseButtonReleased) {};
sf::Mouse::Button button;
@@ -156,7 +156,7 @@ namespace vr {
class MouseMoved : public Event {
public:
MouseMoved(bool x, bool y) :
MouseMoved(int x, int y) :
x(x), y(y), Event(vr::Event::EventType::MouseMoved) {};
int x;
@@ -165,7 +165,7 @@ namespace vr {
class MouseEntered : public Event {
public:
MouseEntered(bool x, bool y) :
MouseEntered(int x, int y) :
x(x), y(y), Event(vr::Event::EventType::MouseEntered) {};
int x;
@@ -174,7 +174,7 @@ namespace vr {
class MouseLeft : public Event {
public:
MouseLeft(bool x, bool y) :
MouseLeft(int x, int y) :
x(x), y(y), Event(vr::Event::EventType::MouseLeft) {};
int x;

7
include/Input.h
View File

@@ -1,11 +1,12 @@
#pragma once
#include <SFML/Graphics.hpp>
#include <list>
#include "Pub_Sub.hpp"
#include "Event.hpp"
#include <memory>
#include "Pub_Sub.h"
class Input : public SfEventPublisher {
class Input : public VrEventPublisher {
public:
Input();
@@ -34,6 +35,6 @@ private:
private:
std::list<vr::Event> event_queue;
std::list<std::unique_ptr<vr::Event>> event_queue;
};

32
include/Pub_Sub.h Normal file
View File

@@ -0,0 +1,32 @@
#pragma once
#include <SFML/Graphics.hpp>
#include <iostream>
#include "Event.hpp"
class VrEventPublisher;
class VrEventSubscriber {
public:
virtual ~VrEventSubscriber() {};
virtual void update(VrEventPublisher* p, vr::Event e) = 0;
void subscribe(VrEventPublisher* publisher, vr::Event::EventType type);
void subscribe(VrEventPublisher* publisher, std::vector<vr::Event::EventType> type);
protected:
std::vector<vr::Event::EventType> subscribed_event_types;
};
class VrEventPublisher {
public:
virtual ~VrEventPublisher() {};
virtual void subscribe(VrEventSubscriber *subscriber, vr::Event::EventType type);
virtual void subscribe(VrEventSubscriber *subscriber, std::vector<vr::Event::EventType> type);
virtual void unsubscribe(VrEventSubscriber *s, vr::Event::EventType c);
virtual void notify(vr::Event e);
private:
std::map<vr::Event::EventType, std::vector<VrEventSubscriber*>> subscribers;
};

139
include/Pub_Sub.hpp
View File

@@ -1,139 +0,0 @@
#pragma once
#include <SFML/Graphics.hpp>
class SfEventPublisher;
class SfEventSubscriber {
public:
virtual ~SfEventSubscriber() {};
virtual void update(SfEventPublisher* p, sf::Event e) = 0;
};
class SfEventPublisher {
public:
// Allows the subscription to classes of events
enum Event_Class {
JoystickButtonEvent,
JoystickConnectEvent,
JoystickMoveEvent,
KeyEvent,
MouseButtonEvent,
MouseMoveEvent,
MouseWheelEvent,
MouseWheelScrollEvent,
SensorEvent,
SizeEvent,
TextEvent,
TouchEvent,
WindowEvent
};
virtual ~SfEventPublisher() {};
virtual void subscribe(SfEventSubscriber *s, Event_Class c) {
subscribers[c].push_back(s);
};
virtual void unsubscribe(SfEventSubscriber *s, Event_Class c) {
std::remove(subscribers[c].begin(), subscribers[c].end(), s);
};
virtual void notify(sf::Event e) {
// I don't quite like that some event classes contained multiple types of events:
// KeyPressed, and KeyReleased under KeyEvent for example.
// While others are not represented by classes:
// Closed, LostFocus, and GainedFocus have no representing class.
// So, we'll add another "class", WindowEvent which contains those previously mentioned,
// and use those new identifiers to group our events
// This will also make it a bit easier when subscribing to certain events
Event_Class event_class;
if (e.type == sf::Event::Closed ||
e.type == sf::Event::LostFocus ||
e.type == sf::Event::GainedFocus ){
event_class = Event_Class::WindowEvent;
}
// Preserve a little of sfml's default behavior and separate resized event
else if (e.type == sf::Event::Resized) {
event_class = Event_Class::SizeEvent;
}
else if (e.type == sf::Event::TextEntered) {
event_class = Event_Class::TextEvent;
}
else if (e.type == sf::Event::KeyPressed ||
e.type == sf::Event::KeyReleased ){
event_class = Event_Class::KeyEvent;
}
else if (e.type == sf::Event::MouseWheelMoved ||
e.type == sf::Event::MouseWheelScrolled ){
event_class = Event_Class::MouseWheelScrollEvent;
}
else if (e.type == sf::Event::MouseButtonPressed ||
e.type == sf::Event::MouseButtonReleased ){
event_class = Event_Class::MouseButtonEvent;
}
// Is this a good idea, mixing events that contain data, and don't contain data?
else if (e.type == sf::Event::MouseMoved ||
e.type == sf::Event::MouseEntered ||
e.type == sf::Event::MouseLeft ){
event_class = Event_Class::MouseMoveEvent;
}
else if (e.type == sf::Event::JoystickButtonPressed ||
e.type == sf::Event::JoystickButtonReleased ){
event_class = Event_Class::JoystickButtonEvent;
}
else if (e.type == sf::Event::JoystickMoved) {
event_class = Event_Class::JoystickMoveEvent;
}
else if (e.type == sf::Event::JoystickConnected ||
e.type == sf::Event::JoystickDisconnected ){
event_class = Event_Class::JoystickConnectEvent;
}
else if (e.type == sf::Event::TouchBegan ||
e.type == sf::Event::TouchEnded ||
e.type == sf::Event::TouchMoved ){
event_class = Event_Class::TouchEvent;
}
else if (e.type == sf::Event::SensorChanged) {
event_class = Event_Class::SensorEvent;
}
else {
std::cout << "Unable to classify sf::Event into Event_Class";
abort();
}
// get the bucket containing subscribers to that Event_Class
std::vector<SfEventSubscriber*> *event_type_bucket = &subscribers[event_class];
// Send them the event
for (auto s : *event_type_bucket) {
s->update(this, e);
}
};
private:
std::map<Event_Class, std::vector<SfEventSubscriber*>> subscribers;
};