Working on a messaging system for sf events

include/Camera.h

@@ -2,8 +2,9 @@
 #include <SFML/System/Vector3.hpp>
 #include <SFML/System/Vector2.hpp>
 #include "util.hpp"
+#include "Pub_Sub.hpp"
 
-class Camera {
+class Camera : public SfEventSubscriber{
 public:
 
 	enum DIRECTION { FORWARD, REARWARD, LEFT, RIGHT, UP, DOWN };
@@ -33,6 +34,9 @@ public:
 	sf::Vector3f get_position();
 	sf::Vector2f get_direction();
 
+
+	virtual void update(SfEventPublisher* p, sf::Event e) override;
+
 private:
 
 	float friction_coefficient = 0.1f;

include/Input.h

@@ -0,0 +1,30 @@
+#pragma once
+#include <SFML/Graphics.hpp>
+#include <list>
+#include "Pub_Sub.hpp"
+
+
+class Input : public SfEventPublisher {
+public:
+	
+	Input();
+	~Input();
+
+	// Keep track of keys that are not released
+	// Keep track of mouse up and downs in conjunction with dragging
+	// Keep track of joystick buttons
+
+	void consume_events(sf::RenderWindow *window);
+	void set_flags();
+	void dispatch_events();
+	
+private:
+	std::vector<sf::Keyboard::Key> held_keys;
+	std::vector<sf::Mouse::Button> held_mouse_buttons;
+	
+	std::vector<bool> keyboard_flags;
+	std::vector<bool> mouse_flags;
+
+private:
+	std::list<sf::Event> event_queue;
+};

include/Pub_Sub.hpp

@@ -0,0 +1,133 @@
+#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;
+		}
+
+
+		std::vector<SfEventSubscriber*> *event_type_bucket = &subscribers[event_class];
+
+		for (auto s : *event_type_bucket) {
+			s->update(this, e);
+		}
+	};
+private:
+	std::map<Event_Class, std::vector<SfEventSubscriber*>> subscribers;
+
+};
+

include/util.hpp

@@ -1,13 +1,12 @@
 #pragma once
 #include <SFML/Graphics.hpp>
-#include <iostream>
+#include "Vector4.hpp"
 #include <math.h>
+#include <bitset>
+#include <iostream>
 #include <fstream>
 #include <sstream>
-#include "Vector4.hpp"
-#include <bitset>
 #include <string>
-#include <math.h>
 #include <iterator>