Commit might have been messed up

include/Camera.h

@@ -37,7 +37,7 @@ public:
 	void setSpeed(float speed);
 	float getSpeed();
 
-	void recieve_event(VrEventPublisher* p, std::unique_ptr<vr::Event> event) override;
+	void recieve_event(VrEventPublisher* publisher, std::unique_ptr<vr::Event> event) override;
 
 private:
 

include/Event.hpp

@@ -4,7 +4,7 @@
 #include <SFML/Window/Mouse.hpp>
 #include <SFML/Window/Joystick.hpp>
 #include <SFML/Window/Sensor.hpp>
-
+#include <memory>
 
 
 namespace vr {
@@ -14,11 +14,11 @@ namespace vr {
 	// the ability to easily extend the class to contain
 	// even more event types.
 
-	// A result of getting rid of the union and extracting
+	// An annoying result of getting rid of the union and extracting
 	// event types into individual classes is the fact that
 	// there is going to be a lot of repeat code i.e 
 	// KeyPressed, KeyHeld, and KeyReleased all hold the same
-	// data, it's just their names that are different
+	// data, it's just their names that are different. 
 
 	class Event {
 	public:
@@ -63,20 +63,33 @@ namespace vr {
 		Event(EventType type) : type(type) {
 			
 		};
+		virtual ~Event() {};
+
+		virtual std::unique_ptr<Event> clone() = 0;
 
 		EventType type;
+	private:
 		
 	};
 
+	
+
 	class Closed : public Event {
 	public:
 		Closed() : Event(vr::Event::EventType::Closed) {};
+		~Closed() override {};
+		std::unique_ptr<Event> clone() override { 
+			return std::unique_ptr<vr::Event>(std::make_unique<vr::Closed>(vr::Closed())); 
+		};
 	};
 
 	class Resized : public Event {
 	public:
 		Resized(unsigned int width, unsigned int height) : 
-			width(width), height(height), Event(vr::Event::EventType::Resized) {};
+			Event(vr::Event::EventType::Resized), width(width), height(height) {};
+		std::unique_ptr<Event> clone() override { 
+			return std::unique_ptr<vr::Event>(std::make_unique<vr::Resized>(vr::Resized(width, height))); 
+		};
 		unsigned int		width;
 		unsigned int		height;
 	};
@@ -84,16 +97,25 @@ namespace vr {
 	class LostFocus : public Event {
 	public:
 		LostFocus() : Event(vr::Event::EventType::LostFocus) { };
+		std::unique_ptr<Event> clone() override { 
+			return std::unique_ptr<vr::Event>(std::make_unique<vr::LostFocus>(vr::LostFocus())); 
+		};
 	};
 	class GainedFocus : public Event {
 	public:
 		GainedFocus() : Event(vr::Event::EventType::GainedFocus) {};
+		std::unique_ptr<Event> clone() override { 
+			return std::unique_ptr<vr::Event>(std::make_unique<vr::GainedFocus>(vr::GainedFocus())); 
+		};
 	};
 	
 	class TextEntered : public Event {
 	public:
 		TextEntered(sf::Uint32 unicode) : 
-			unicode(unicode), Event(vr::Event::EventType::TextEntered) {};
+			Event(vr::Event::EventType::TextEntered), unicode(unicode) {};
+		std::unique_ptr<Event> clone() override { 
+			return std::unique_ptr<vr::Event>(std::make_unique<vr::TextEntered>(vr::TextEntered(unicode))); 
+		};
 
 		sf::Uint32 unicode;
 	};
@@ -101,7 +123,10 @@ namespace vr {
 	class KeyPressed : public Event {
 	public:
 		KeyPressed(sf::Keyboard::Key code, bool alt, bool control, bool shift, bool system ) :
-			code(code), alt(alt), control(control), shift(shift), system(system), Event(vr::Event::EventType::KeyPressed) {};
+			Event(vr::Event::EventType::KeyPressed), code(code), alt(alt), control(control), shift(shift), system(system) {};
+		std::unique_ptr<Event> clone() override { 
+			return std::unique_ptr<vr::Event>(std::make_unique<vr::KeyPressed>(vr::KeyPressed(code, alt, control, shift, system)));
+		};
 
 		sf::Keyboard::Key	code;
 		bool				alt;
@@ -113,7 +138,10 @@ namespace vr {
 	class KeyHeld : public Event {
 	public:
 		KeyHeld(sf::Keyboard::Key code, bool alt, bool control, bool shift, bool system) :
-			code(code), alt(alt), control(control), shift(shift), system(system), Event(vr::Event::EventType::KeyHeld) {};
+			Event(vr::Event::EventType::KeyHeld), code(code), alt(alt), control(control), shift(shift), system(system) {};
+		std::unique_ptr<Event> clone() override { 
+			return std::unique_ptr<vr::Event>(std::make_unique<vr::KeyHeld>(vr::KeyHeld(code, alt, control, shift, system)));
+		};
 
 		sf::Keyboard::Key	code;
 		bool				alt;
@@ -125,7 +153,10 @@ namespace vr {
 	class KeyReleased : public Event {
 	public:
 		KeyReleased(sf::Keyboard::Key code, bool alt, bool control, bool shift, bool system) :
-			code(code), alt(alt), control(control), shift(shift), system(system), Event(vr::Event::EventType::KeyReleased) {};
+			Event(vr::Event::EventType::KeyReleased), code(code), alt(alt), control(control), shift(shift), system(system) {};
+		std::unique_ptr<Event> clone() override { 
+			return std::unique_ptr<vr::Event>(std::make_unique<vr::KeyReleased>(vr::KeyReleased(code, alt, control, shift, system)));
+		};
 
 		sf::Keyboard::Key	code;
 		bool				alt;
@@ -138,12 +169,18 @@ namespace vr {
 	class MouseWheelMoved : public Event {
 	public:
 		MouseWheelMoved() : Event(vr::Event::EventType::MouseWheelMoved) {};
+		std::unique_ptr<Event> clone() override { 
+			return std::unique_ptr<vr::Event>(std::make_unique<vr::MouseWheelMoved>(vr::MouseWheelMoved()));
+		};
 	};
 
 	class MouseWheelScrolled : public Event {
 	public:
 		MouseWheelScrolled(sf::Mouse::Wheel wheel, float delta, int x, int y) :
-			wheel(wheel), delta(delta), x(x), y(y), Event(vr::Event::EventType::MouseWheelScrolled) {};
+			Event(vr::Event::EventType::MouseWheelScrolled), wheel(wheel), delta(delta), x(x), y(y) {};
+		std::unique_ptr<Event> clone() override { 
+			return std::unique_ptr<vr::Event>(std::make_unique<vr::MouseWheelScrolled>(vr::MouseWheelScrolled(wheel, delta, x, y)));
+		};
 
 		sf::Mouse::Wheel	wheel;
 		float				delta;
@@ -154,7 +191,10 @@ namespace vr {
 	class MouseButtonPressed : public Event {
 	public:
 		MouseButtonPressed(sf::Mouse::Button button, int x, int y) :
-			button(button), x(x), y(y), Event(vr::Event::EventType::MouseButtonPressed) {};
+			Event(vr::Event::EventType::MouseButtonPressed), button(button), x(x), y(y) {};
+		std::unique_ptr<Event> clone() override { 
+			return std::unique_ptr<vr::Event>(std::make_unique<vr::MouseButtonPressed>(vr::MouseButtonPressed(button, x ,y)));
+		};
 
 		sf::Mouse::Button	button;
 		int					x;
@@ -164,7 +204,10 @@ namespace vr {
 	class MouseButtonHeld : public Event {
 	public:
 		MouseButtonHeld(sf::Mouse::Button button, int x, int y) :
-			button(button), x(x), y(y), Event(vr::Event::EventType::MouseButtonHeld) {};
+			Event(vr::Event::EventType::MouseButtonHeld), button(button), x(x), y(y) {};
+		std::unique_ptr<Event> clone() override { 
+			return std::unique_ptr<vr::Event>(std::make_unique<vr::MouseButtonHeld>(vr::MouseButtonHeld(button, x, y)));
+		};
 
 		sf::Mouse::Button	button;
 		int					x;
@@ -174,7 +217,10 @@ namespace vr {
 	class MouseButtonReleased : public Event {
 	public:
 		MouseButtonReleased(sf::Mouse::Button button, int x, int y) :
-			button(button), x(x), y(y), Event(vr::Event::EventType::MouseButtonReleased) {};
+			Event(vr::Event::EventType::MouseButtonReleased), button(button), x(x), y(y) {};
+		std::unique_ptr<Event> clone() override {
+			return std::unique_ptr<vr::Event>(std::make_unique<vr::MouseButtonReleased>(vr::MouseButtonReleased(button, x, y)));
+		};
 
 		sf::Mouse::Button	button;
 		int					x;
@@ -184,7 +230,10 @@ namespace vr {
 	class MouseMoved : public Event {
 	public:
 		MouseMoved(int x, int y) :
-			x(x), y(y), Event(vr::Event::EventType::MouseMoved) {};
+			Event(vr::Event::EventType::MouseMoved), x(x), y(y) {};
+		std::unique_ptr<Event> clone() override { 
+			return std::unique_ptr<vr::Event>(std::make_unique<vr::MouseMoved>(vr::MouseMoved(x, y))); 
+		};
 
 		int					x;
 		int					y;
@@ -193,7 +242,10 @@ namespace vr {
 	class MouseEntered : public Event {
 	public:
 		MouseEntered(int x, int y) :
-			x(x), y(y), Event(vr::Event::EventType::MouseEntered) {};
+			Event(vr::Event::EventType::MouseEntered), x(x), y(y) {};
+		std::unique_ptr<Event> clone() override { 
+			return std::unique_ptr<vr::Event>(std::make_unique<vr::MouseEntered>(vr::MouseEntered(x, y))); 
+		};
 
 		int					x;
 		int					y;
@@ -202,7 +254,10 @@ namespace vr {
 	class MouseLeft : public Event {
 	public:
 		MouseLeft(int x, int y) :
-			x(x), y(y), Event(vr::Event::EventType::MouseLeft) {};
+			Event(vr::Event::EventType::MouseLeft), x(x), y(y) {};
+		std::unique_ptr<Event> clone() override { 
+			return std::unique_ptr<vr::Event>(std::make_unique<vr::MouseLeft>(vr::MouseLeft(x, y))); 
+		};
 
 		int					x;
 		int					y;
@@ -211,7 +266,10 @@ namespace vr {
 	class JoystickButtonPressed : public Event {
 	public:
 		JoystickButtonPressed(unsigned int joystickId, unsigned int button) :
-			joystickId(joystickId), button(button), Event(vr::Event::EventType::JoystickButtonPressed) {};
+			Event(vr::Event::EventType::JoystickButtonPressed), joystickId(joystickId), button(button) {};
+		std::unique_ptr<Event> clone() override { 
+			return std::unique_ptr<vr::Event>(std::make_unique<vr::JoystickButtonPressed>(vr::JoystickButtonPressed(joystickId, button))); 
+		};
 
 		unsigned int		joystickId;
 		unsigned int		button;
@@ -220,7 +278,10 @@ namespace vr {
 	class JoystickButtonHeld : public Event {
 	public:
 		JoystickButtonHeld(unsigned int joystickId, unsigned int button) :
-			joystickId(joystickId), button(button), Event(vr::Event::EventType::JoystickButtonHeld) {};
+			Event(vr::Event::EventType::JoystickButtonHeld), joystickId(joystickId), button(button) {};
+		std::unique_ptr<Event> clone() override { 
+			return std::unique_ptr<vr::Event>(std::make_unique<vr::JoystickButtonHeld>(vr::JoystickButtonHeld(joystickId, button)));
+		};
 
 		unsigned int		joystickId;
 		unsigned int		button;
@@ -230,6 +291,9 @@ namespace vr {
 	public:
 		JoystickButtonReleased(unsigned int joystickId, unsigned int button) :
 			joystickId(joystickId), button(button), Event(vr::Event::EventType::JoystickButtonReleased) {};
+		std::unique_ptr<Event> clone() override { 
+			return std::unique_ptr<vr::Event>(std::make_unique<vr::JoystickButtonReleased>(vr::JoystickButtonReleased(joystickId, button)));
+		};
 
 		unsigned int		joystickId;
 		unsigned int		button;
@@ -239,6 +303,9 @@ namespace vr {
 	public:
 		JoystickMoved(sf::Joystick::Axis axis, unsigned int joystickId, float position) :
 			axis(axis), joystickId(joystickId), position(position), Event(vr::Event::EventType::JoystickMoved) {};
+		std::unique_ptr<Event> clone() override { 
+			return std::unique_ptr<vr::Event>(std::make_unique<vr::JoystickMoved>(vr::JoystickMoved(axis, joystickId, position))); 
+		};
 
 		sf::Joystick::Axis	axis;
 		unsigned int		joystickId;
@@ -248,7 +315,10 @@ namespace vr {
 	class JoystickConnected : public Event {
 	public:
 		JoystickConnected(unsigned int joystickId) :
-			joystickId(joystickId), Event(vr::Event::EventType::JoystickConnected) {};
+			Event(vr::Event::EventType::JoystickConnected), joystickId(joystickId) {};
+		std::unique_ptr<Event> clone() override { 
+			return std::unique_ptr<vr::Event>(std::make_unique<vr::JoystickConnected>(vr::JoystickConnected(joystickId))); 
+		};
 
 		unsigned int		joystickId;
 	};
@@ -256,7 +326,10 @@ namespace vr {
 	class JoystickDisconnected : public Event {
 	public:
 		JoystickDisconnected(unsigned int joystickId) :
-			joystickId(joystickId), Event(vr::Event::EventType::JoystickDisconnected) {};
+			Event(vr::Event::EventType::JoystickDisconnected), joystickId(joystickId) {};
+		std::unique_ptr<Event> clone() override {
+			return std::unique_ptr<vr::Event>(std::make_unique<vr::JoystickDisconnected>(vr::JoystickDisconnected(joystickId))); 
+		};
 
 		unsigned int		joystickId;
 	};
@@ -264,7 +337,10 @@ namespace vr {
 	class TouchBegan : public Event {
 	public:
 		TouchBegan(unsigned int finger, int x, int y) :
-			finger(finger), x(x), y(y), Event(vr::Event::EventType::TouchBegan) {};
+			Event(vr::Event::EventType::TouchBegan), finger(finger), x(x), y(y) {};
+		std::unique_ptr<Event> clone() override { 
+			return std::unique_ptr<vr::Event>(std::make_unique<vr::TouchBegan>(vr::TouchBegan(finger, x, y)));
+		};
 
 		unsigned int		finger;
 		int					x;
@@ -274,7 +350,10 @@ namespace vr {
 	class TouchMoved : public Event {
 	public:
 		TouchMoved(unsigned int finger, int x, int y) :
-			finger(finger), x(x), y(y), Event(vr::Event::EventType::TouchMoved) {};
+			Event(vr::Event::EventType::TouchMoved), finger(finger), x(x), y(y) {};
+		std::unique_ptr<Event> clone() override {
+			return std::unique_ptr<vr::Event>(std::make_unique<vr::TouchMoved>(vr::TouchMoved(finger, x, y))); 
+		};
 
 		unsigned int		finger;
 		int					x;
@@ -284,7 +363,10 @@ namespace vr {
 	class TouchEnded : public Event {
 	public:
 		TouchEnded(unsigned int finger, int x, int y) :
-			finger(finger), x(x), y(y), Event(vr::Event::EventType::TouchEnded) {};
+			Event(vr::Event::EventType::TouchEnded), finger(finger), x(x), y(y) {};
+		std::unique_ptr<Event> clone() override { 
+			return std::unique_ptr<vr::Event>(std::make_unique<vr::TouchEnded>(vr::TouchEnded(finger, x, y))); 
+		};
 
 		unsigned int		finger;
 		int					x;
@@ -294,7 +376,10 @@ namespace vr {
 	class SensorChanged : public Event {
 	public:
 		SensorChanged(sf::Sensor::Type type, float x, float y, float z) :
-			type(type), x(x), y(y), z(z), Event(vr::Event::EventType::SensorChanged) {};
+			Event(vr::Event::EventType::SensorChanged), type(type), x(x), y(y), z(z){};
+		std::unique_ptr<Event> clone() override {
+			return std::unique_ptr<vr::Event>(std::make_unique<vr::SensorChanged>(vr::SensorChanged(type, x, y, z))); 
+		};
 
 		sf::Sensor::Type	type;
 		float				x;
@@ -310,7 +395,10 @@ namespace vr {
 	class NetworkJoystickButtonPressed : public Event {
 	public:
 		NetworkJoystickButtonPressed(unsigned int joystickId, unsigned int button) :
-			joystickId(joystickId), button(button), Event(vr::Event::EventType::NetworkJoystickButtonPressed) {};
+			Event(vr::Event::EventType::NetworkJoystickButtonPressed), joystickId(joystickId), button(button) {};
+		std::unique_ptr<Event> clone() override { 
+			return std::unique_ptr<vr::Event>(std::make_unique<vr::NetworkJoystickButtonPressed>(vr::NetworkJoystickButtonPressed(joystickId, button))); 
+		};
 
 		unsigned int		joystickId;
 		unsigned int		button;
@@ -319,7 +407,10 @@ namespace vr {
 	class NetworkJoystickButtonHeld : public Event {
 	public:
 		NetworkJoystickButtonHeld(unsigned int joystickId, unsigned int button) :
-			joystickId(joystickId), button(button), Event(vr::Event::EventType::NetworkJoystickButtonHeld) {};
+			Event(vr::Event::EventType::NetworkJoystickButtonHeld), joystickId(joystickId), button(button) {};
+		std::unique_ptr<Event> clone() override { 
+			return std::unique_ptr<vr::Event>(std::make_unique<vr::NetworkJoystickButtonHeld>(vr::NetworkJoystickButtonHeld(joystickId, button)));
+		};
 
 		unsigned int		joystickId;
 		unsigned int		button;
@@ -328,7 +419,10 @@ namespace vr {
 	class NetworkJoystickButtonReleased : public Event {
 	public:
 		NetworkJoystickButtonReleased(unsigned int joystickId, unsigned int button) :
-			joystickId(joystickId), button(button), Event(vr::Event::EventType::NetworkJoystickButtonReleased) {};
+			Event(vr::Event::EventType::NetworkJoystickButtonReleased), joystickId(joystickId), button(button) {};
+		std::unique_ptr<Event> clone() override { 
+			return std::unique_ptr<vr::Event>(std::make_unique<vr::NetworkJoystickButtonReleased>(vr::NetworkJoystickButtonReleased(joystickId, button)));
+		};
 
 		unsigned int		joystickId;
 		unsigned int		button;
@@ -337,7 +431,10 @@ namespace vr {
 	class NetworkJoystickMoved : public Event {
 	public:
 		NetworkJoystickMoved(sf::Joystick::Axis axis, unsigned int joystickId, float position) :
-			axis(axis), joystickId(joystickId), position(position), Event(vr::Event::EventType::NetworkJoystickMoved) {};
+			Event(vr::Event::EventType::NetworkJoystickMoved), axis(axis), joystickId(joystickId), position(position){};
+		std::unique_ptr<Event> clone() override { 
+			return std::unique_ptr<vr::Event>(std::make_unique<vr::NetworkJoystickMoved>(vr::NetworkJoystickMoved(axis, joystickId, position))); 
+		};
 
 		sf::Joystick::Axis	axis;
 		unsigned int		joystickId;
@@ -347,7 +444,10 @@ namespace vr {
 	class NetworkJoystickConnected : public Event {
 	public:
 		NetworkJoystickConnected(unsigned int joystickId) :
-			joystickId(joystickId), Event(vr::Event::EventType::NetworkJoystickConnected) {};
+			Event(vr::Event::EventType::NetworkJoystickConnected), joystickId(joystickId){};
+		std::unique_ptr<Event> clone() override { 
+			return std::unique_ptr<vr::Event>(std::make_unique<vr::NetworkJoystickConnected>(vr::NetworkJoystickConnected(joystickId))); 
+		};
 
 		unsigned int		joystickId;
 	};
@@ -355,7 +455,10 @@ namespace vr {
 	class NetworkJoystickDisconnected : public Event {
 	public:
 		NetworkJoystickDisconnected(unsigned int joystickId) :
-			joystickId(joystickId), Event(vr::Event::EventType::NetworkJoystickDisconnected) {};
+			Event(vr::Event::EventType::NetworkJoystickDisconnected), joystickId(joystickId) {};
+		std::unique_ptr<Event> clone() override { 
+			return std::unique_ptr<vr::Event>(std::make_unique<vr::NetworkJoystickDisconnected>(vr::NetworkJoystickDisconnected(joystickId))); 
+		};
 
 		unsigned int		joystickId;
 	};

include/Input.h

@@ -41,7 +41,7 @@ class WindowHandler : public VrEventSubscriber {
 public:
 	WindowHandler(sf::RenderWindow *window) : window_ref(window) { };
 
-	virtual void recieve_event(VrEventPublisher* p, std::unique_ptr<vr::Event> event) override {
+	virtual void recieve_event(VrEventPublisher* publisher, std::unique_ptr<vr::Event>(event)) override {
 		if (event.get()->type == vr::Event::Closed) {
 			window_ref->close();
 		}

include/LightController.h

@@ -60,7 +60,7 @@ public:
 	std::shared_ptr<LightHandle> create_light(LightPrototype light_prototype);
 	void remove_light(unsigned int light_index);
 
-	void recieve_event(VrEventPublisher* p, std::unique_ptr<vr::Event> event) override;
+	void recieve_event(VrEventPublisher* publisher, std::unique_ptr<vr::Event> event) override;
 
 private:
 

include/raycaster/Hardware_Caster.h

@@ -9,6 +9,7 @@
 #include "map/Old_Map.h"
 #include "Camera.h"
 #include <GL/glew.h>
+#include <unordered_map>
 
 #ifdef linux
 #include <CL/cl.h>
@@ -31,18 +32,18 @@
 
 #endif
 
-struct device {
+//struct device {
-	cl_device_id id;
+//	cl_device_id id;
-	cl_device_type type;
+//	cl_device_type type;
-	cl_uint clock_frequency;
+//	cl_uint clock_frequency;
-	char version[128];
+//	char version[128];
-	cl_platform_id platform;
+//	cl_platform_id platform;
-	cl_uint comp_units;
+//	cl_uint comp_units;
-	char extensions[1024];
+//	char extensions[1024];
-	char name[256];
+//	char name[256];
-	cl_bool is_little_endian = false;
+//	cl_bool is_little_endian = false;
-	bool cl_gl_sharing = false;
+//	bool cl_gl_sharing = false;
-};
+//};
 
 struct device_info {
 	cl_uint cl_device_address_bits;
@@ -99,30 +100,77 @@ struct raycaster_settings {
 
 struct PackedData;
 
-class Hardware_Caster : public RayCaster
+class Hardware_Caster
 {
-public:
-	Hardware_Caster();
 
+
+public:
+
+	enum ERROR_CODES {
+		SHARING_NOT_SUPPORTED = 800,
+		OPENCL_NOT_SUPPORTED = 801,
+		OPENCL_ERROR = 802,
+		ERR = 803
+	};
+
+	class device {
+
+	public:
+
+#pragma pack(push, 1)
+		struct packed_data {
+
+			cl_device_type device_type;
+			cl_uint clock_frequency;
+			char opencl_version[64];
+			cl_uint compute_units;
+			char device_extensions[1024];
+			char device_name[256];
+			char platform_name[128];
+		};
+#pragma pack(pop)
+
+		device(cl_device_id device_id, cl_platform_id platform_id);
+		device(const device& d);
+		void print(std::ostream& stream) const;
+		void print_packed_data(std::ostream& stream);
+
+		cl_device_id getDeviceId() const { return device_id; };
+		cl_platform_id getPlatformId() const { return platform_id; };
+
+	private:
+
+		packed_data data;
+
+		cl_device_id device_id;
+		cl_platform_id platform_id;
+
+		cl_bool is_little_endian = false;
+		bool cl_gl_sharing = false;
+
+	};
+
+
+	Hardware_Caster();
 	virtual ~Hardware_Caster();
 
 	
 	// Queries hardware, creates the command queue and context, and compiles kernel
-	int init() override;
+	int init();
 
 	// Creates a texture to send to the GPU via height and width
 	// Creates a viewport vector array via vertical and horizontal fov
-	void create_viewport(int width, int height, float v_fov, float h_fov) override;
+	void create_viewport(int width, int height, float v_fov, float h_fov) ;
 	
 	// Light controllers own the copy of the PackedData array.
 	// We receive a pointer to the array and USE_HOST_POINTER to map the memory to the GPU
-	void assign_lights(std::vector<PackedData> *data) override;
+	void assign_lights(std::vector<PackedData> *data) ;
 
 	// We take a ptr to the map and create the map, and map_dimensions buffer for the GPU
-	void assign_map(Old_Map *map) override;
+	void assign_map(Old_Map *map) ;
 
 	// We take a ptr to the camera and create a camera direction and position buffer
-	void assign_camera(Camera *camera) override;
+	void assign_camera(Camera *camera) ;
 
 	// TODO: Hoist this to the base class
 	// Creates 3 buffers relating to the texture atlas: texture_atlas, atlas_dim, and tile_dim
@@ -130,15 +178,16 @@ public:
 	void create_texture_atlas(sf::Texture *t, sf::Vector2i tile_dim);
 	
 	// Check to make sure that the buffers have been initiated and set them as kernel args
-	void validate() override;
+	void validate() ;
 
 	// Aquires the GL objects, runs the kernel, releases back the GL objects
-	void compute() override;
+	void compute() ;
 
 	// Take the viewport sprite and draw it to the screen
-	void draw(sf::RenderWindow* window) override;
+	void draw(sf::RenderWindow* window) ;
-
 
+	bool load_config();
+	void save_config();
 	// ================================== DEBUG =======================================
 	
 	// Re compile the kernel and revalidate the args
@@ -147,7 +196,6 @@ public:
 	// Modify the viewport matrix
 	void test_edit_viewport(int width, int height, float v_fov, float h_fov);
 
-	void gui();
 
 private:
 
@@ -155,6 +203,8 @@ private:
 	// Also checks for the sharing extension
 	int acquire_platform_and_device();
 
+	bool aquire_hardware();
+
 	int query_hardware();
 
 	// With respect to the individual platforms implementation of sharing
@@ -189,14 +239,13 @@ private:
 	int set_kernel_arg(std::string kernel_name, int index, std::string buffer_name);
 
 	// Run the kernel using a 1d work size
-	// TODO: Test 2d worksize
 	int run_kernel(std::string kernel_name, const int work_dim_x, const int work_dim_y);
 
 	// Run a test kernel that prints out the kernel args
 	void print_kernel_arguments();
 
 	// CL error code handler. ImGui overlaps the assert() function annoyingly so I had to rename it
-	bool vr_assert(int error_code, std::string function_name);
+	static bool vr_assert(int error_code, std::string function_name);
 
 	cl_device_id getDeviceID();
 	cl_platform_id getPlatformID();
@@ -215,6 +264,23 @@ private:
 	// Containers holding the kernels and buffers
 	std::map<std::string, cl_kernel> kernel_map;
 	std::map<std::string, cl_mem> buffer_map;
+	std::unordered_map<std::string, std::pair<sf::Sprite, std::unique_ptr<sf::Texture>>> image_map;
+
+	sf::Sprite viewport_sprite;
+	sf::Texture viewport_texture;
+
+	Old_Map * map = nullptr;
+	Camera *camera = nullptr;
+	//	std::vector<LightController::PackedData> *lights;
+	std::vector<PackedData> *lights;
+	int light_count = 0;
+	sf::Uint8 *viewport_image = nullptr;
+	sf::Vector4f *viewport_matrix = nullptr;
+	sf::Vector2i viewport_resolution;
+
+	int error = 0;
+
+	std::vector<device> device_list;
 
 };
 

kernels/ray_caster_kernel.cl

@@ -369,7 +369,7 @@ __kernel void raycaster(
 			//	intersection_t = (1, 1, 1) - intersection_t;
 				//intersection_t += delta_t * -convert_float3(isless(intersection_t, 0));
 				float3 ray_pos = (convert_float3(voxel) + face_position);
-				ray_dir *= sign;
+				//ray_dir *= sign;
 				delta_t = fabs(1.0f / ray_dir);
 				float3 offset = ((ray_pos)-floor(ray_pos)) * convert_float3(voxel_step);
 				intersection_t = delta_t * offset;

src/Camera.cpp

@@ -54,8 +54,8 @@ int Camera::add_relative_impulse(DIRECTION impulse_direction, float speed) {
 
 	}
 
-	movement += SphereToCart(dir);
+	std::cout << movement.x << " : " << movement.y << " : " << movement.z << std::endl;
-	movement *= speed;
+	movement += SphereToCart(dir) * speed;
 
 	return 1;
 }
@@ -88,9 +88,9 @@ int Camera::update(double delta_time) {
 
 void Camera::recieve_event(VrEventPublisher* publisher, std::unique_ptr<vr::Event> event) {
 
-	if (event.get()->type == vr::Event::KeyHeld) {
+	if (event->type == vr::Event::KeyHeld) {
 
-		vr::KeyHeld *held_event = static_cast<vr::KeyHeld*>(event.get());
+		auto held_event = static_cast<vr::KeyHeld*>(event.get());
 
 		if (held_event->code == sf::Keyboard::LShift) {
 			default_impulse = 0.01f;
@@ -154,6 +154,16 @@ void Camera::recieve_event(VrEventPublisher* publisher, std::unique_ptr<vr::Even
 			}
 		}
 	}
+	else if (event->type == vr::Event::MouseButtonPressed) {
+
+		vr::MouseButtonPressed *mouse_event = static_cast<vr::MouseButtonPressed*>(event.get());
+
+		if (mouse_event->button == sf::Mouse::Middle) {
+			mouse_enabled = !mouse_enabled;
+			sf::Mouse::setPosition(fixed, *window);
+		}
+		
+	}
 	else if (event->type == vr::Event::JoystickMoved) {
 
 		vr::JoystickMoved *joystick_event = static_cast<vr::JoystickMoved*>(event.get());

src/Input.cpp

@@ -61,7 +61,7 @@ void Input::handle_held_keys() {
 		}
 		else if (event->type == vr::Event::MouseButtonReleased) {
 			vr::MouseButtonReleased *e = static_cast<vr::MouseButtonReleased*>(event.get());
-			held_keys.erase(std::remove(held_keys.begin(), held_keys.end(), e->button), held_keys.end());
+			held_mouse_buttons.erase(std::remove(held_mouse_buttons.begin(), held_mouse_buttons.end(), e->button), held_mouse_buttons.end());
 		}
 	}
 
@@ -92,7 +92,7 @@ void Input::handle_held_keys() {
 			system = true;
 		}
 		
-		event_queue.push_back(std::make_unique<vr::KeyHeld>(vr::KeyHeld(key, alt, control, shift, system)));
+		event_queue.emplace_back(std::make_unique<vr::KeyHeld>(vr::KeyHeld(key, alt, control, shift, system)));
 	}
 
 
@@ -105,13 +105,14 @@ void Input::handle_held_keys() {
 
 		sf::Vector2i mouse_pos = sf::Mouse::getPosition();
 
-		event_queue.push_back(std::make_unique<vr::MouseButtonHeld>(vr::MouseButtonHeld(mouse_button, mouse_pos.x, mouse_pos.y)));
+		event_queue.emplace_back(std::make_unique<vr::MouseButtonHeld>(vr::MouseButtonHeld(mouse_button, mouse_pos.x, mouse_pos.y)));
 	}
 
 }
 
 void Input::dispatch_events() {
 
+	std::cout << event_queue.size() << std::endl;
 	while (event_queue.size() != 0) {
 		notify_subscribers(std::move(event_queue.front()));
 		event_queue.pop_front();
@@ -126,97 +127,97 @@ void Input::transpose_sf_events(std::list<sf::Event> sf_event_queue) {
 		switch(sf_event.type) {
 		
 			case sf::Event::Closed : {
-				event_queue.push_back(std::make_unique<vr::Closed>(vr::Closed()));
+				event_queue.emplace_back(std::make_unique<vr::Closed>(vr::Closed()));
 				break;
 			};
 			case sf::Event::Resized: {
-				event_queue.push_back(std::make_unique<vr::Resized>(vr::Resized(sf_event.size.width, sf_event.size.height)));
+				event_queue.emplace_back(std::make_unique<vr::Resized>(vr::Resized(sf_event.size.width, sf_event.size.height)));
 				break;
 			};
 			case sf::Event::LostFocus: {
-				event_queue.push_back(std::make_unique<vr::LostFocus>(vr::LostFocus()));
+				event_queue.emplace_back(std::make_unique<vr::LostFocus>(vr::LostFocus()));
 				break;
 			};
 			case sf::Event::GainedFocus: {
-				event_queue.push_back(std::make_unique<vr::GainedFocus>(vr::GainedFocus()));
+				event_queue.emplace_back(std::make_unique<vr::GainedFocus>(vr::GainedFocus()));
 				break;
 			};
 			case sf::Event::TextEntered: {
-				event_queue.push_back(std::make_unique<vr::TextEntered>(vr::TextEntered(sf_event.text.unicode)));
+				event_queue.emplace_back(std::make_unique<vr::TextEntered>(vr::TextEntered(sf_event.text.unicode)));
 				break;
 			};
 			case sf::Event::KeyPressed: {
-				event_queue.push_back(std::make_unique<vr::KeyPressed>(vr::KeyPressed(sf_event.key.code, sf_event.key.alt, sf_event.key.control, sf_event.key.shift, sf_event.key.system)));
+				event_queue.emplace_back(std::make_unique<vr::KeyPressed>(vr::KeyPressed(sf_event.key.code, sf_event.key.alt, sf_event.key.control, sf_event.key.shift, sf_event.key.system)));
 				break;
 			};
 			case sf::Event::KeyReleased: {
-				event_queue.push_back(std::make_unique<vr::KeyReleased>(vr::KeyReleased(sf_event.key.code, sf_event.key.alt, sf_event.key.control, sf_event.key.shift, sf_event.key.system)));
+				event_queue.emplace_back(std::make_unique<vr::KeyReleased>(vr::KeyReleased(sf_event.key.code, sf_event.key.alt, sf_event.key.control, sf_event.key.shift, sf_event.key.system)));
 				break;
 			};
 
 			// Mouse wheel moved will generate a MouseWheelScrolled event with the defaul vertical wheel
 			case sf::Event::MouseWheelMoved: {
-				event_queue.push_back(std::make_unique<vr::MouseWheelScrolled>(vr::MouseWheelScrolled(sf::Mouse::VerticalWheel, sf_event.mouseWheelScroll.delta, sf_event.mouseWheelScroll.x, sf_event.mouseWheelScroll.y)));
+				event_queue.emplace_back(std::make_unique<vr::MouseWheelScrolled>(vr::MouseWheelScrolled(sf::Mouse::VerticalWheel, sf_event.mouseWheelScroll.delta, sf_event.mouseWheelScroll.x, sf_event.mouseWheelScroll.y)));
 				break;
 			};
 			case sf::Event::MouseWheelScrolled: {
-				event_queue.push_back(std::make_unique<vr::MouseWheelScrolled>(vr::MouseWheelScrolled(sf_event.mouseWheelScroll.wheel, sf_event.mouseWheelScroll.delta, sf_event.mouseWheelScroll.x, sf_event.mouseWheelScroll.y)));
+				event_queue.emplace_back(std::make_unique<vr::MouseWheelScrolled>(vr::MouseWheelScrolled(sf_event.mouseWheelScroll.wheel, sf_event.mouseWheelScroll.delta, sf_event.mouseWheelScroll.x, sf_event.mouseWheelScroll.y)));
 				break;
 			};
 			case sf::Event::MouseButtonPressed: {
-				event_queue.push_back(std::make_unique<vr::MouseButtonPressed>(vr::MouseButtonPressed(sf_event.mouseButton.button, sf_event.mouseButton.x, sf_event.mouseButton.y)));
+				event_queue.emplace_back(std::make_unique<vr::MouseButtonPressed>(vr::MouseButtonPressed(sf_event.mouseButton.button, sf_event.mouseButton.x, sf_event.mouseButton.y)));
 				break;
 			};
 			case sf::Event::MouseButtonReleased: {
-				event_queue.push_back(std::make_unique<vr::MouseButtonReleased>(vr::MouseButtonReleased(sf_event.mouseButton.button, sf_event.mouseButton.x, sf_event.mouseButton.y)));
+				event_queue.emplace_back(std::make_unique<vr::MouseButtonReleased>(vr::MouseButtonReleased(sf_event.mouseButton.button, sf_event.mouseButton.x, sf_event.mouseButton.y)));
 				break;
 			};
 			case sf::Event::MouseMoved: {
-				event_queue.push_back(std::make_unique<vr::MouseMoved>(vr::MouseMoved(sf_event.mouseMove.x, sf_event.mouseMove.y)));
+				event_queue.emplace_back(std::make_unique<vr::MouseMoved>(vr::MouseMoved(sf_event.mouseMove.x, sf_event.mouseMove.y)));
 				break;
 			};
 			case sf::Event::MouseEntered: {
-				event_queue.push_back(std::make_unique<vr::MouseEntered>(vr::MouseEntered(sf_event.mouseMove.x, sf_event.mouseMove.y)));
+				event_queue.emplace_back(std::make_unique<vr::MouseEntered>(vr::MouseEntered(sf_event.mouseMove.x, sf_event.mouseMove.y)));
 				break;
 			};
 			case sf::Event::MouseLeft: {
-				event_queue.push_back(std::make_unique<vr::MouseLeft>(vr::MouseLeft(sf_event.mouseMove.x, sf_event.mouseMove.x)));
+				event_queue.emplace_back(std::make_unique<vr::MouseLeft>(vr::MouseLeft(sf_event.mouseMove.x, sf_event.mouseMove.x)));
 				break;
 			};
 			case sf::Event::JoystickButtonPressed: {
-				event_queue.push_back(std::make_unique<vr::JoystickButtonPressed>(vr::JoystickButtonPressed(sf_event.joystickButton.joystickId, sf_event.joystickButton.button)));
+				event_queue.emplace_back(std::make_unique<vr::JoystickButtonPressed>(vr::JoystickButtonPressed(sf_event.joystickButton.joystickId, sf_event.joystickButton.button)));
 				break;
 			};
 			case sf::Event::JoystickButtonReleased: {
-				event_queue.push_back(std::make_unique<vr::JoystickButtonReleased>(vr::JoystickButtonReleased(sf_event.joystickButton.joystickId, sf_event.joystickButton.button)));
+				event_queue.emplace_back(std::make_unique<vr::JoystickButtonReleased>(vr::JoystickButtonReleased(sf_event.joystickButton.joystickId, sf_event.joystickButton.button)));
 				break;
 			};
 			case sf::Event::JoystickMoved: {
-				event_queue.push_back(std::make_unique<vr::JoystickMoved>(vr::JoystickMoved(sf_event.joystickMove.axis, sf_event.joystickMove.joystickId, sf_event.joystickMove.position)));
+				event_queue.emplace_back(std::make_unique<vr::JoystickMoved>(vr::JoystickMoved(sf_event.joystickMove.axis, sf_event.joystickMove.joystickId, sf_event.joystickMove.position)));
 				break;
 			};
 			case sf::Event::JoystickConnected: {
-				event_queue.push_back(std::make_unique<vr::JoystickConnected>(vr::JoystickConnected(sf_event.joystickConnect.joystickId)));
+				event_queue.emplace_back(std::make_unique<vr::JoystickConnected>(vr::JoystickConnected(sf_event.joystickConnect.joystickId)));
 				break;
 			};
 			case sf::Event::JoystickDisconnected: {
-				event_queue.push_back(std::make_unique<vr::JoystickDisconnected>(vr::JoystickDisconnected(sf_event.joystickConnect.joystickId)));
+				event_queue.emplace_back(std::make_unique<vr::JoystickDisconnected>(vr::JoystickDisconnected(sf_event.joystickConnect.joystickId)));
 				break;
 			};
 			case sf::Event::TouchBegan: {
-				event_queue.push_back(std::make_unique<vr::TouchBegan>(vr::TouchBegan(sf_event.touch.finger, sf_event.touch.x, sf_event.touch.y)));
+				event_queue.emplace_back(std::make_unique<vr::TouchBegan>(vr::TouchBegan(sf_event.touch.finger, sf_event.touch.x, sf_event.touch.y)));
 				break;
 			};
 			case sf::Event::TouchMoved: {
-				event_queue.push_back(std::make_unique<vr::TouchMoved>(vr::TouchMoved(sf_event.touch.finger, sf_event.touch.x, sf_event.touch.y)));
+				event_queue.emplace_back(std::make_unique<vr::TouchMoved>(vr::TouchMoved(sf_event.touch.finger, sf_event.touch.x, sf_event.touch.y)));
 				break;
 			};
 			case sf::Event::TouchEnded: {
-				event_queue.push_back(std::make_unique<vr::TouchEnded>(vr::TouchEnded(sf_event.touch.finger, sf_event.touch.x, sf_event.touch.y)));
+				event_queue.emplace_back(std::make_unique<vr::TouchEnded>(vr::TouchEnded(sf_event.touch.finger, sf_event.touch.x, sf_event.touch.y)));
 				break;
 			};
 			case sf::Event::SensorChanged: {
-				event_queue.push_back(std::make_unique<vr::SensorChanged>(vr::SensorChanged(sf_event.sensor.type, sf_event.sensor.x, sf_event.sensor.y, sf_event.sensor.z)));
+				event_queue.emplace_back(std::make_unique<vr::SensorChanged>(vr::SensorChanged(sf_event.sensor.type, sf_event.sensor.x, sf_event.sensor.y, sf_event.sensor.z)));
 				break;
 			};
 			default: {

src/LightController.cpp

@@ -36,22 +36,23 @@ void LightController::remove_light(unsigned int light_index) {
 
 void LightController::recieve_event(VrEventPublisher* publisher, std::unique_ptr<vr::Event> event) {
 
-	if (event.get()->type == vr::Event::KeyHeld) {}
+	if (event->type == vr::Event::KeyHeld) {}
 	else if (event->type == vr::Event::KeyPressed) {}
 	else if (event->type == vr::Event::MouseMoved) {}
 
 	else if (event->type == vr::Event::JoystickMoved) {
 
-		vr::JoystickMoved *joystick_event = static_cast<vr::JoystickMoved*>(event.get());
 
-		if (joystick_event->axis == sf::Joystick::Axis::X) {
+		//vr::JoystickMoved *joystick_event = static_cast<vr::JoystickMoved*>(event.get());
-			//movement.x -= joystick_event->position / 5;
+
-			//add_relative_impulse(Camera::DIRECTION::FORWARD, joystick_event->position);
+		//if (joystick_event->axis == sf::Joystick::Axis::X) {
-		}
+		//	//movement.x -= joystick_event->position / 5;
-		else if (joystick_event->axis == sf::Joystick::Axis::Y) {
+		//	//add_relative_impulse(Camera::DIRECTION::FORWARD, joystick_event->position);
-			//movement.y += joystick_event->position / 5;
+		//}
-			//add_relative_impulse(Camera::DIRECTION::RIGHT, joystick_event->position);
+		//else if (joystick_event->axis == sf::Joystick::Axis::Y) {
-		}
+		//	//movement.y += joystick_event->position / 5;
+		//	//add_relative_impulse(Camera::DIRECTION::RIGHT, joystick_event->position);
+		//}
 		//else if (joystick_event->axis == sf::Joystick::Axis::Z) {
 		//	add_relative_impulse(Camera::DIRECTION::DOWN, joystick_event->position);
 		//}

src/Pub_Sub.cpp

@@ -32,10 +32,13 @@ void VrEventPublisher::unsubscribe(VrEventSubscriber *s, vr::Event::EventType ty
 void VrEventPublisher::notify_subscribers(std::unique_ptr<vr::Event> event) {
 
 	// get the bucket containing subscribers to that Event_Class
-	std::vector<VrEventSubscriber*> *event_type_bucket = &subscribers[event.get()->type];
+	//std::vector<VrEventSubscriber*> *event_type_bucket = &subscribers[event->type];
 
 	// Send them the event
-	for (auto s : *event_type_bucket) {
+	// Each and every event that is received in the recieve_event function
-		s->recieve_event(this, std::move(event));
+	// will be a unique ptr solely owned by that function
+	for (auto s : subscribers[event->type]) {
+		s->recieve_event(this, event->clone());
 	}
+
 }

src/main.cpp

@@ -84,7 +84,7 @@ int main() {
 	#ifdef linux
 	glewInit();
 	#elif defined _WIN32
-	glewInit();
+	//glewInit();
 	#elif defined TARGET_OS_MAC
 	// Do nothing, extension wrangling handled by macOS
 	#endif 
@@ -115,6 +115,7 @@ int main() {
 		abort();
 	}
 
+
 	// Create and generate the old 3d array style map
 	Old_Map* map = new Old_Map(sf::Vector3i(MAP_X, MAP_Y, MAP_Z));
 	map->generate_terrain();
@@ -161,6 +162,7 @@ int main() {
 	camera->subscribe_to_publisher(&input_handler, vr::Event::EventType::KeyHeld);
 	camera->subscribe_to_publisher(&input_handler, vr::Event::EventType::KeyPressed);
 	camera->subscribe_to_publisher(&input_handler, vr::Event::EventType::MouseMoved);
+	camera->subscribe_to_publisher(&input_handler, vr::Event::EventType::MouseButtonPressed);
 
 	WindowHandler win_hand(&window);
 	win_hand.subscribe_to_publisher(&input_handler, vr::Event::EventType::Closed);

src/raycaster/Hardware_Caster.cpp

@@ -10,12 +10,42 @@ Hardware_Caster::~Hardware_Caster() {
 
 int Hardware_Caster::init() {
 
-	query_hardware();
+//	query_hardware();
 
-	// Initialize opencl up to the point where we start assigning buffers
+	//// Initialize opencl up to the point where we start assigning buffers
-	error = acquire_platform_and_device();
+	//error = acquire_platform_and_device();
-	if(vr_assert(error, "aquire_platform_and_device"))
+	//if(vr_assert(error, "aquire_platform_and_device"))
-		return error;
+	//	return error;
+
+	if (!aquire_hardware())
+		return false;
+
+	if (!load_config()) {
+
+		std::cout << "Select a device number which you wish to use" << std::endl;
+
+		for (int i = 0; i < device_list.size(); i++) {
+
+			std::cout << "\n-----------------------------------------------------------------" << std::endl;
+			std::cout << "\tDevice Number : " << i << std::endl;
+			std::cout << "-----------------------------------------------------------------" << std::endl;
+
+			device_list.at(i).print(std::cout);
+		}
+
+		int selection = -1;
+
+		while (selection < 0 && selection >= device_list.size()) {
+
+			std::cout << "Device which you wish to use : ";
+			std::cin >> selection;
+		}
+
+		device_id = device_list.at(selection).getDeviceId();
+		platform_id = device_list.at(selection).getPlatformId();
+
+		save_config();
+	}
 
 	error = create_shared_context();
 	if (vr_assert(error, "create_shared_context"))
@@ -268,165 +298,102 @@ void Hardware_Caster::test_edit_viewport(int width, int height, float v_fov, flo
 }
 
 
-void Hardware_Caster::gui() {
+bool Hardware_Caster::aquire_hardware()
-
+{
-}
-
-int Hardware_Caster::acquire_platform_and_device() {
 
 	// Get the number of platforms
-	cl_uint plt_cnt = 0;
+	cl_uint platform_count = 0;
-	clGetPlatformIDs(0, nullptr, &plt_cnt);
+	clGetPlatformIDs(0, nullptr, &platform_count);
 
-	// Fetch the platforms
+	if (platform_count == 0) {
-	std::map<cl_platform_id, std::vector<device>> plt_ids;
+		std::cout << "There appears to be no OpenCL platforms on this machine" << std::endl;
-
+		return false;
-	// buffer before map init
-	std::vector<cl_platform_id> plt_buf(plt_cnt);
-	clGetPlatformIDs(plt_cnt, plt_buf.data(), nullptr);
-
-	// Map init
-	for (auto id : plt_buf) {
-		plt_ids.emplace(std::make_pair(id, std::vector<device>()));
 	}
 
-	// For each platform, populate its devices
+	// Get the ID's for those platforms
-	for (unsigned int i = 0; i < plt_cnt; i++) {
+	std::vector<cl_platform_id> plt_buf(platform_count);
 
+	clGetPlatformIDs(platform_count, plt_buf.data(), nullptr);
+	if (vr_assert(error, "clGetPlatformIDs"))
+		return false;
+
+	// Cycle through the platform ID's
+	for (unsigned int i = 0; i < platform_count; i++) {
+
+		// And get their device count
 		cl_uint deviceIdCount = 0;
 		error = clGetDeviceIDs(plt_buf[i], CL_DEVICE_TYPE_ALL, 0, nullptr, &deviceIdCount);
-
-		// Check to see if we even have OpenCL on this machine
-		if (deviceIdCount == 0) {
-			std::cout << "There appears to be no devices, or none at least supporting OpenCL" << std::endl;
-			return OPENCL_NOT_SUPPORTED;
-		}
-
-		// Get the device ids
-		std::vector<cl_device_id> deviceIds(deviceIdCount);
-		error = clGetDeviceIDs(plt_buf[i], CL_DEVICE_TYPE_ALL, deviceIdCount, deviceIds.data(), NULL);
-
 		if (vr_assert(error, "clGetDeviceIDs"))
-			return OPENCL_ERROR;
+			return false;
 
-		for (unsigned int q = 0; q < deviceIdCount; q++) {
+		if (deviceIdCount == 0) {
+			std::cout << "There appears to be no devices associated with this platform" << std::endl;
 
-			device d;
-
-			d.id = deviceIds[q];
-
-			clGetDeviceInfo(d.id, CL_DEVICE_PLATFORM, sizeof(cl_platform_id), &d.platform, NULL);
-			clGetDeviceInfo(d.id, CL_DEVICE_VERSION, sizeof(char) * 128, &d.version, NULL);
-			clGetDeviceInfo(d.id, CL_DEVICE_TYPE, sizeof(cl_device_type), &d.type, NULL);
-			clGetDeviceInfo(d.id, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof(cl_uint), &d.clock_frequency, NULL);
-			clGetDeviceInfo(d.id, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof(cl_uint), &d.comp_units, NULL);
-			clGetDeviceInfo(d.id, CL_DEVICE_EXTENSIONS, 1024, &d.extensions, NULL);
-			clGetDeviceInfo(d.id, CL_DEVICE_NAME, 256, &d.name, NULL);
-			clGetDeviceInfo(d.id, CL_DEVICE_ENDIAN_LITTLE, sizeof(cl_bool), &d.is_little_endian, NULL);
-
-			std::cout << "Device: " << q << std::endl;
-			std::cout << "Device Name : " << d.name << std::endl;
-			
-			std::cout << "Platform ID    : " << d.platform << std::endl;
-			std::cout << "Device Version : " << d.version << std::endl;
-
-			std::cout << "Device Type    : ";
-			if (d.type == CL_DEVICE_TYPE_CPU)
-				std::cout << "CPU" << std::endl;
-
-			else if (d.type == CL_DEVICE_TYPE_GPU)
-				std::cout << "GPU" << std::endl;
-
-			else if (d.type == CL_DEVICE_TYPE_ACCELERATOR)
-				std::cout << "Accelerator" << std::endl;
-
-			std::cout << "Max clock frequency : " << d.clock_frequency << std::endl;
-			std::cout << "Max compute units   : " << d.comp_units << std::endl;
-			std::cout << "Is little endian    : " << std::boolalpha << static_cast<bool>(d.is_little_endian) << std::endl;
-
-			std::cout << "cl_khr_gl_sharing supported: ";
-			if (std::string(d.extensions).find("cl_khr_gl_sharing") == std::string::npos &&
-				std::string(d.extensions).find("cl_APPLE_gl_sharing") == std::string::npos) {
-				std::cout << "False" << std::endl;
 		}
-			std::cout << "True" << std::endl;
+		else {
-			d.cl_gl_sharing = true;
 
-			std::cout << "Extensions supported: " << std::endl;
+			// Get the device ids and place them in the device list
-			std::cout << std::string(d.extensions) << std::endl;
+			std::vector<cl_device_id> deviceIds(deviceIdCount);
 
-			std::cout << " ===================================================================================== " << std::endl;
+			error = clGetDeviceIDs(plt_buf[i], CL_DEVICE_TYPE_ALL, deviceIdCount, deviceIds.data(), NULL);
+			if (vr_assert(error, "clGetDeviceIDs"))
+				return false;
 
-			plt_ids.at(d.platform).push_back(d);
+			for (int d = 0; d < deviceIds.size(); d++) {
+				device_list.emplace_back(device(deviceIds[d], plt_buf.at(i)));
+			}
 		}
 	}
 
-
+	return true;
-	// The devices how now been queried we want to shoot for a gpu with the fastest clock,
-	// falling back to the cpu with the fastest clock if we weren't able to find one
-
-	device current_best_device;
-	current_best_device.type = 0; // Set this to 0 so the first run always selects a new device
-	current_best_device.clock_frequency = 0;
-	current_best_device.comp_units = 0;
-
-
-	for (auto kvp : plt_ids) {
-
-		for (auto device : kvp.second) {
-
-			// Gonna just split this up into cases. There are so many devices I cant test with
-			// that opencl supports. I'm not going to waste my time making a generic implimentation
-
-			// Upon success of a condition, set the current best device values
-
-			//if (strcmp(device.version, "OpenCL 1.2 ") == 0 && strcmp(device.version, current_best_device.version) != 0) {
-			//	current_best_device = device;
-			//}
-
-			// If the current device is not a GPU and we are comparing it to a GPU
-			if (device.type == CL_DEVICE_TYPE_GPU && current_best_device.type != CL_DEVICE_TYPE_GPU) {
-				current_best_device = device;
 }
 
-			//if (device.type == CL_DEVICE_TYPE_CPU && 
+void Hardware_Caster::save_config() {
-			//	current_best_device.type != CL_DEVICE_TYPE_CPU) {
-			//	current_best_device = device;
-			//}
 
-			// Get the unit with the higher compute units
+	std::ofstream output_file;
-			if (device.comp_units > current_best_device.comp_units) {
+	output_file.open("device_config.bin", std::ofstream::binary | std::ofstream::out | std::ofstream::trunc);
-				current_best_device = device;
+
+	device d(device_id, platform_id);
+	d.print_packed_data(output_file);
+
+	output_file.close();
 }
 
-			// If we are comparing CPU to CPU get the one with the best clock
+bool Hardware_Caster::load_config() {
-			if (current_best_device.type != CL_DEVICE_TYPE_GPU && device.clock_frequency > current_best_device.clock_frequency) {
+
-				current_best_device = device;
+	std::cout << "Loading hardware config...";
+
+	std::ifstream input_file("device_config.bin", std::ios::binary | std::ios::in);
+
+	if (!input_file.is_open()) {
+		std::cout << "No config file found" << std::endl;
+		return false;
 	}
 
-			if (current_best_device.cl_gl_sharing == false && device.cl_gl_sharing == true) {
+	device::packed_data data;
-				current_best_device = device;
+	input_file.read(reinterpret_cast<char*>(&data), sizeof(data));
-			}
+	input_file.close();
 
+	bool found = false;
+
+	for (auto d : device_list) {
+
+		if (memcmp(&d, &data, sizeof(device::packed_data)) == 0) {
+			std::cout << "Found saved config" << std::endl;
+			found = true;
+			device_id = d.getDeviceId();
+			platform_id = d.getPlatformId();
+			break;
 		}
 	}
 
- 	platform_id = current_best_device.platform;
+	if (!found) {
-	device_id = current_best_device.id;
+		std::cout << "No hardware matching config found" << std::endl;
-
+		return false;
-	std::cout << std::endl;
-	std::cout << "Selected Platform : " << platform_id << std::endl;
-	std::cout << "Selected Device   : " << device_id << std::endl;
-	std::cout << "Selected Name     : " << current_best_device.name << std::endl;
-	std::cout << "Selected Version  : " << current_best_device.version << std::endl;
-
-	if (current_best_device.cl_gl_sharing == false) {
-		std::cout << "This device does not support the cl_khr_gl_sharing extension" << std::endl;
-		return RayCaster::SHARING_NOT_SUPPORTED;
 	}
-	return 1;
-};
 
+	return true;
+}
 
 int Hardware_Caster::query_hardware() {
 
@@ -526,6 +493,22 @@ int Hardware_Caster::query_hardware() {
 
 int Hardware_Caster::create_shared_context() {
 
+	//std::vector<DISPLAY_DEVICEA> display_devices;
+	//DISPLAY_DEVICEA dev;
+	//int k = 0;
+	//dev.cb = sizeof(dev);
+	//HDC hDC;
+	//while(EnumDisplayDevicesA(NULL, k, &dev, 0)) {
+	//	
+	//	display_devices.push_back(dev);
+	//	hDC = CreateDC(dev.DeviceName, dev.DeviceName, 0, 0);
+	//	k++;
+	//}
+	//	
+	//hDC = CreateDC(display_devices.at(1).DeviceName, display_devices.at(1).DeviceName, 0, 0);
+	//std::cout << GetLastError();
+	//HGLRC hGLRC = wglCreateContext(hDC);
+
 	// Hurray for standards!
 	// Setup the context properties to grab the current GL context
 
@@ -540,8 +523,8 @@ int Hardware_Caster::create_shared_context() {
 
 #elif defined _WIN32
 
-	HGLRC hGLRC = wglGetCurrentContext();
 	HDC hDC = wglGetCurrentDC();
+	HGLRC hGLRC = wglGetCurrentContext();
 	cl_context_properties context_properties[] = {
 		CL_CONTEXT_PLATFORM, (cl_context_properties)platform_id,
 		CL_GL_CONTEXT_KHR, (cl_context_properties)hGLRC,
@@ -1036,3 +1019,79 @@ bool Hardware_Caster::vr_assert(int error_code, std::string function_name) {
 	std::cout << err_msg << "  =at=  " << function_name << std::endl;
 	return true;
 }
+
+
+Hardware_Caster::device::device(cl_device_id device_id, cl_platform_id platform_id) {
+
+	this->device_id = device_id;
+	this->platform_id = platform_id;
+
+	int error = 0;
+	error = clGetPlatformInfo(platform_id, CL_PLATFORM_NAME, 128, (void*)&data.platform_name, nullptr);
+	if (vr_assert(error, "clGetPlatformInfo"))
+		return;
+
+	error = clGetDeviceInfo(device_id, CL_DEVICE_VERSION, sizeof(char) * 128, &data.opencl_version, NULL);
+	error = clGetDeviceInfo(device_id, CL_DEVICE_TYPE, sizeof(cl_device_type), &data.device_type, NULL);
+	error = clGetDeviceInfo(device_id, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof(cl_uint), &data.clock_frequency, NULL);
+	error = clGetDeviceInfo(device_id, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof(cl_uint), &data.compute_units, NULL);
+	error = clGetDeviceInfo(device_id, CL_DEVICE_EXTENSIONS, 1024, &data.device_extensions, NULL);
+	error = clGetDeviceInfo(device_id, CL_DEVICE_NAME, 256, &data.device_name, NULL);
+	error = clGetDeviceInfo(device_id, CL_DEVICE_ENDIAN_LITTLE, sizeof(cl_bool), &is_little_endian, NULL);
+
+	// Check for the sharing extension
+	if (std::string(data.device_extensions).find("cl_khr_gl_sharing") != std::string::npos ||
+		std::string(data.device_extensions).find("cl_APPLE_gl_sharing") != std::string::npos) {
+		cl_gl_sharing = true;
+	}
+}
+
+
+Hardware_Caster::device::device(const device& d) {
+
+	// member values, copy individually
+	device_id = d.device_id;
+	platform_id = d.platform_id;
+	is_little_endian = d.is_little_endian;
+	cl_gl_sharing = d.cl_gl_sharing;
+
+	// struct so it copies by value
+	data = d.data;
+
+}
+
+void Hardware_Caster::device::print(std::ostream& stream) const {
+
+	stream << "\n\tDevice ID        : " << device_id << std::endl;
+	stream << "\tDevice Name      : " << data.device_name << std::endl;
+
+	stream << "\tPlatform ID      : " << platform_id << std::endl;
+	stream << "\tPlatform Name    : " << data.platform_name << std::endl;
+
+	stream << "\tOpenCL Version   : " << data.opencl_version << std::endl;
+	stream << "\tSupports sharing : " << std::boolalpha << cl_gl_sharing << std::endl;
+	stream << "\tDevice Type      : ";
+
+	if (data.device_type == CL_DEVICE_TYPE_CPU)
+		stream << "CPU" << std::endl;
+
+	else if (data.device_type == CL_DEVICE_TYPE_GPU)
+		stream << "GPU" << std::endl;
+
+	else if (data.device_type == CL_DEVICE_TYPE_ACCELERATOR)
+		stream << "Accelerator" << std::endl;
+
+	stream << "\tIs Little Endian : " << std::boolalpha << is_little_endian << std::endl;
+
+	stream << "\tClock Frequency  : " << data.clock_frequency << std::endl;
+	stream << "\tCompute Units    : " << data.compute_units << std::endl;
+
+	stream << "\n*Extensions*" << std::endl;
+	stream << data.device_extensions << std::endl;
+	stream << "\n";
+
+}
+
+void Hardware_Caster::device::print_packed_data(std::ostream& stream) {
+	stream.write(reinterpret_cast<char*>(&data), sizeof(data));
+}