Had some include troubles, renamed util but need to rename it back to .hpp. Switched the fps counter to run with imgui

include/Camera.h

@@ -1,7 +1,7 @@
 #pragma once
 #include <SFML/System/Vector3.hpp>
 #include <SFML/System/Vector2.hpp> 
-#include "util.hpp"
+#include "util.cpp"
 #include "Pub_Sub.h"
 
 class Camera : public VrEventSubscriber{

include/GL_Testing.h

@@ -1,6 +1,6 @@
 #pragma once
 #include <string>
-#include <util.hpp>
+#include <util.cpp>
 #include <cstring>
 
 #ifdef _WIN32

include/LightController.h

@@ -1,7 +1,7 @@
 #pragma once
 #include <SFML/System/Vector3.hpp>
 #include <SFML/System/Vector2.hpp> 
-#include "util.hpp"
+#include "util.cpp"
 #include "Pub_Sub.h"
 #include "raycaster/RayCaster.h"
 #include <list>

include/LightHandle.h

@@ -1,6 +1,6 @@
 #pragma once
 #include <SFML/Graphics.hpp>
-#include <util.hpp>
+#include <util.cpp>
 #include <memory>
 #include "Pub_Sub.h"
 

include/Map.h

@@ -8,7 +8,7 @@
 #include <iostream>
 #include <functional>
 #include <cmath>
-#include "util.hpp"
+#include "util.cpp"
 #include <deque>
 #include <unordered_map>
 #include <bitset>

include/raycaster/Hardware_Caster.h

@@ -2,10 +2,9 @@
 #include <raycaster/RayCaster.h>
 #include <vector>
 #include <iostream>
-#include "util.hpp"
 #include <map>
 #include <string.h>
-
+#include "LightController.h"
 
 #ifdef linux
 #include <CL/cl.h>
@@ -95,7 +94,7 @@ private:
 
 	void print_kernel_arguments();
 
-	bool assert(int error_code, std::string function_name);
+	bool vr_assert(int error_code, std::string function_name);
 
 	cl_device_id getDeviceID();
 	cl_platform_id getPlatformID();

include/util.cpp

@@ -1,338 +1,286 @@
-#pragma once
+#pragma once
-#include <SFML/Graphics.hpp>
+#include <SFML/Graphics.hpp>
-#include "Vector4.hpp"
+#include "Vector4.hpp"
-#include <math.h>
+#include <math.h>
-#include <bitset>
+#include <string.h>
-#include <iostream>
+#include <bitset>
-#include <fstream>
+#include <iostream>
-#include <sstream>
+#include <fstream>
-#include <string>
+#include <sstream>
-#include <iterator>
+#include <string>
-#include <list>
+#include <iterator>
-#include <algorithm>
+#include <list>
-
+#include <algorithm>
-
+#include <imgui/imgui.h>
-const double PI = 3.141592653589793238463;
+
-const float  PI_F = 3.14159265358979f;
+const double PI = 3.141592653589793238463;
-struct fps_counter {
+const float  PI_F = 3.14159265358979f;
-public:
+struct fps_counter {
-	fps_counter() :
+public:
-		backdrop(sf::Vector2f(200, 100)), vertex_array(sf::LinesStrip) {
+	fps_counter() {};
-
+
-		backdrop.setFillColor(sf::Color(0x0000003F));
+	void frame(double delta_time) {
-
+		// Apply 100 units of smoothing
-		if (!f.loadFromFile("../assets/fonts/Arial.ttf")) {
+		if (frame_count == 100) {
-			std::cout << "couldn't find the fall back Arial font in ../assets/fonts/" << std::endl;
+			frame_count = 0;
-		}
+			fps_average = 0;
-		else {
+		}
-			t.setFont(f);
+		frame_count++;
-			t.setCharacterSize(18);
+		fps_average += (delta_time - fps_average) / frame_count;
-			t.setColor(sf::Color::White);
+	}
-		}
+
-	}
+	void draw() {
-
+
-	void frame(double delta_time) {
+		if (arr_pos == 200)
-		// Apply 100 units of smoothing
+			arr_pos = 0;
-		if (frame_count == 100) {
+
-			frame_count = 0;
+		fps_array[arr_pos] = (1.0 / fps_average);
-			fps_average = 0;
+		arr_pos++;
-		}
+
-		frame_count++;
+		ImGui::Begin("Performance");
-		fps_average += (delta_time - fps_average) / frame_count;
+		ImGui::PlotLines("FPS", fps_array, 200, 0, std::to_string(1.0 / fps_average).c_str(), 0.0f, 150.0f, ImVec2(0, 80));
-	}
+		ImGui::End();
-
+	}
-	void flip_units() {
+
-		if (milliseconds)
+private:
-			milliseconds = false;
+
-		else
+	float fps_array[200]{60};
-			milliseconds = true;
+	int arr_pos = 0;
-	}
+
-
+	int frame_count = 0;
-	void set_position(sf::Vector2f position) {
+	double fps_average = 0;
-		backdrop.setPosition(position);
+
-	}
+};
-
+
-	sf::Vector2f get_position() {
+struct debug_text {
-		return backdrop.getPosition();
+public:
-	}
+	debug_text(int slot, int pixel_spacing, void* data_, std::string prefix_) : data(data_), prefix(prefix_) {
-
+		if (!f.loadFromFile("../assets/fonts/Arial.ttf")) {
-	void draw(sf::RenderWindow *r) {
+			std::cout << "couldn't find the fall back Arial font in ../assets/fonts/" << std::endl;
-
+		}
-		// FPS Line graph
+		else {
-		r->draw(backdrop);
+			t.setFont(f);
-
+			t.setCharacterSize(20);
-		if (vertex_position == 200)
+			t.setPosition(static_cast<float>(20), static_cast<float>(slot * pixel_spacing));
-			vertex_position = 0;
+		}
-
+
-		sf::Vector2f origin = backdrop.getPosition();
+	}
-		sf::Vector2f point = origin + sf::Vector2f(vertex_position, backdrop.getSize().y - (1.0 / fps_average));
+
-
+	void draw(sf::RenderWindow *r) {
-		if (vertex_array.getVertexCount() < 200)
+		t.setString(prefix + std::to_string(*(float*)data));
-			vertex_array.append(sf::Vertex(point, sf::Color::Red));
+		r->draw(t);
-		else
+	}
-			vertex_array[vertex_position] = sf::Vertex(point, sf::Color::Red);
+
-
+private:
-		r->draw(vertex_array);
+	void* data;
-
+	std::string prefix;
-		vertex_position++;
+	sf::Font f;
-
+	sf::Text t;
-		// FPS Text
+
-		std::string out;
+};
-
+
-		if (milliseconds)
+inline sf::Vector3f SphereToCart(sf::Vector2f i) {
-			out = std::to_string(fps_average);
+
-		else
+	auto r = sf::Vector3f(
-			out = std::to_string(floor(1 / fps_average));
+		(1 * sin(i.y) * cos(i.x)),
-
+		(1 * sin(i.y) * sin(i.x)),
-		t.setPosition(origin);
+		(1 * cos(i.y))
-		t.setString(out);
+		);
-		r->draw(t);
+	return r;
-	}
+};
-
+
-private:
+inline sf::Vector3f SphereToCart(sf::Vector3f i) {
-
+
-	sf::RectangleShape backdrop;
+	auto r = sf::Vector3f(
-	sf::VertexArray vertex_array;
+		(i.x * sin(i.z) * cos(i.y)),
-
+		(i.x * sin(i.z) * sin(i.y)),
-	sf::Font f;
+		(i.x * cos(i.z))
-	sf::Text t;
+		);
-
+	return r;
-	int frame_count = 0;
+};
-	double fps_average = 0;
+
-	bool milliseconds = false;
+
-
+inline sf::Vector3f CartToSphere(sf::Vector3f in) {
-	int vertex_position = 0;
+
-};
+	auto r = sf::Vector3f(
-
+		sqrt(in.x * in.x + in.y * in.y + in.z * in.z),
-struct debug_text {
+		atan(in.y / in.x),
-public:
+		atan(sqrt(in.x * in.x + in.y * in.y) / in.z)
-	debug_text(int slot, int pixel_spacing, void* data_, std::string prefix_) : data(data_), prefix(prefix_) {
+		);
-		if (!f.loadFromFile("../assets/fonts/Arial.ttf")) {
+	return r;
-			std::cout << "couldn't find the fall back Arial font in ../assets/fonts/" << std::endl;
+};
-		}
+
-		else {
+inline sf::Vector2f CartToNormalizedSphere(sf::Vector3f in) {
-			t.setFont(f);
+
-			t.setCharacterSize(20);
+	auto r = sf::Vector2f(
-			t.setPosition(static_cast<float>(20), static_cast<float>(slot * pixel_spacing));
+		atan2(sqrt(in.x * in.x + in.y * in.y), in.z), 
-		}
+		atan2(in.y, in.x)
-
+		);
-	}
+	
-
+	return r;
-	void draw(sf::RenderWindow *r) {
+}
-		t.setString(prefix + std::to_string(*(float*)data));
+
-		r->draw(t);
+inline sf::Vector3f FixOrigin(sf::Vector3f base, sf::Vector3f head) {
-	}
+	return head - base;
-
+}
-private:
+
-	void* data;
+
-	std::string prefix;
+inline sf::Vector3f Normalize(sf::Vector3f in) {
-	sf::Font f;
+	
-	sf::Text t;
+	float multiplier = sqrt(in.x * in.x + in.y * in.y + in.z * in.z);
-
+	auto r = sf::Vector3f(
-};
+		in.x / multiplier,
-
+		in.y / multiplier,
-inline sf::Vector3f SphereToCart(sf::Vector2f i) {
+		in.z / multiplier
-
+	);
-	auto r = sf::Vector3f(
+	return r;
-		(1 * sin(i.y) * cos(i.x)),
+
-		(1 * sin(i.y) * sin(i.x)),
+}
-		(1 * cos(i.y))
+
-		);
+
-	return r;
+inline float DotProduct(sf::Vector3f a, sf::Vector3f b){
-};
+	return a.x * b.x + a.y * b.y + a.z * b.z;
-
+}
-inline sf::Vector3f SphereToCart(sf::Vector3f i) {
+
-
+inline float Magnitude(sf::Vector3f in){
-	auto r = sf::Vector3f(
+	return sqrt(in.x * in.x + in.y * in.y + in.z * in.z);
-		(i.x * sin(i.z) * cos(i.y)),
+}
-		(i.x * sin(i.z) * sin(i.y)),
+
-		(i.x * cos(i.z))
+inline float AngleBetweenVectors(sf::Vector3f a, sf::Vector3f b){
-		);
+	return acos(DotProduct(a, b) / (Magnitude(a) * Magnitude(b)));
-	return r;
+}
-};
+
-
+inline float DistanceBetweenPoints(sf::Vector3f a, sf::Vector3f b) {
-
+	return sqrt(DotProduct(a, b));
-inline sf::Vector3f CartToSphere(sf::Vector3f in) {
+}
-
+
-	auto r = sf::Vector3f(
+inline float DegreesToRadians(float in) {
-		sqrt(in.x * in.x + in.y * in.y + in.z * in.z),
+	return static_cast<float>(in * PI / 180.0f);
-		atan(in.y / in.x),
+}
-		atan(sqrt(in.x * in.x + in.y * in.y) / in.z)
+
-		);
+inline float RadiansToDegrees(float in) {
-	return r;
+	return static_cast<float>(in * 180.0f / PI);
-};
+}
-
+
-inline sf::Vector2f CartToNormalizedSphere(sf::Vector3f in) {
+inline std::string read_file(std::string file_name){
-
+	std::ifstream input_file(file_name);
-	auto r = sf::Vector2f(
+
-		atan2(sqrt(in.x * in.x + in.y * in.y), in.z), 
+	if (!input_file.is_open()){
-		atan2(in.y, in.x)
+		std::cout << file_name << " could not be opened" << std::endl;
-		);
+		return "";
-	
+	}
-	return r;
+
-}
+	std::stringstream buf;
-
+	buf << input_file.rdbuf();
-inline sf::Vector3f FixOrigin(sf::Vector3f base, sf::Vector3f head) {
+	input_file.close();
-	return head - base;
+	return buf.str();
-}
+}
-
+
-
+inline void PrettyPrintUINT64(uint64_t i, std::stringstream* ss) {
-inline sf::Vector3f Normalize(sf::Vector3f in) {
+
-	
+	*ss << "[" << std::bitset<15>(i) << "]";
-	float multiplier = sqrt(in.x * in.x + in.y * in.y + in.z * in.z);
+	*ss << "[" << std::bitset<1>(i >> 15) << "]";
-	auto r = sf::Vector3f(
+	*ss << "[" << std::bitset<8>(i >> 16) << "]";
-		in.x / multiplier,
+	*ss << "[" << std::bitset<8>(i >> 24) << "]";
-		in.y / multiplier,
+	*ss << "[" << std::bitset<32>(i >> 32) << "]";
-		in.z / multiplier
+
-	);
+}
-	return r;
+
-
+inline void PrettyPrintUINT64(uint64_t i) {
-}
+
-
+	std::cout << "[" << std::bitset<15>(i) << "]";
-
+	std::cout << "[" << std::bitset<1>(i >> 15) << "]";
-inline float DotProduct(sf::Vector3f a, sf::Vector3f b){
+	std::cout << "[" << std::bitset<8>(i >> 16) << "]";
-	return a.x * b.x + a.y * b.y + a.z * b.z;
+	std::cout << "[" << std::bitset<8>(i >> 24) << "]";
-}
+	std::cout << "[" << std::bitset<32>(i >> 32) << "]" << std::endl;
-
+
-inline float Magnitude(sf::Vector3f in){
+}
-	return sqrt(in.x * in.x + in.y * in.y + in.z * in.z);
+
-}
+inline void DumpLog(std::stringstream* ss, std::string file_name) {
-
+	
-inline float AngleBetweenVectors(sf::Vector3f a, sf::Vector3f b){
+	std::ofstream log_file;
-	return acos(DotProduct(a, b) / (Magnitude(a) * Magnitude(b)));
+	log_file.open(file_name);
-}
+
-
+	log_file << ss->str();
-inline float DistanceBetweenPoints(sf::Vector3f a, sf::Vector3f b) {
+
-	return sqrt(DotProduct(a, b));
+	log_file.close();
-}
+
-
+}
-inline float DegreesToRadians(float in) {
+
-	return static_cast<float>(in * PI / 180.0f);
+inline std::string sfml_get_input(sf::RenderWindow *window) {
-}
+	
-
+	std::stringstream ss;
-inline float RadiansToDegrees(float in) {
+
-	return static_cast<float>(in * 180.0f / PI);
+	sf::Event event;
-}
+	while (window->pollEvent(event)) {
-
+		if (event.type == sf::Event::TextEntered) {
-inline std::string read_file(std::string file_name){
+			ss << event.text.unicode;
-	std::ifstream input_file(file_name);
+		} 
-
+		
-	if (!input_file.is_open()){
+		else if (event.type == sf::Event::KeyPressed) {
-		std::cout << file_name << " could not be opened" << std::endl;
+			if (event.key.code == sf::Keyboard::Return) {
-		return "";
+				return ss.str();
-	}
+			}
-
+		}
-	std::stringstream buf;
+	}
-	buf << input_file.rdbuf();
+}
-	input_file.close();
+
-	return buf.str();
+inline std::vector<float> sfml_get_float_input(sf::RenderWindow *window) {
-}
+
-
+	std::stringstream ss;
-inline void PrettyPrintUINT64(uint64_t i, std::stringstream* ss) {
+
-
+	sf::Event event;
-	*ss << "[" << std::bitset<15>(i) << "]";
+	while (true) {
-	*ss << "[" << std::bitset<1>(i >> 15) << "]";
+
-	*ss << "[" << std::bitset<8>(i >> 16) << "]";
+		if (window->pollEvent(event)) {
-	*ss << "[" << std::bitset<8>(i >> 24) << "]";
+
-	*ss << "[" << std::bitset<32>(i >> 32) << "]";
+			if (event.type == sf::Event::TextEntered) {
-
+				if (event.text.unicode > 47 && event.text.unicode < 58 || event.text.unicode == 32)
-}
+					ss << static_cast<char>(event.text.unicode);
-
+			}
-inline void PrettyPrintUINT64(uint64_t i) {
+
-
+			else if (event.type == sf::Event::KeyPressed) {
-	std::cout << "[" << std::bitset<15>(i) << "]";
+
-	std::cout << "[" << std::bitset<1>(i >> 15) << "]";
+				if (event.key.code == sf::Keyboard::Return) {
-	std::cout << "[" << std::bitset<8>(i >> 16) << "]";
+					break;
-	std::cout << "[" << std::bitset<8>(i >> 24) << "]";
+				}
-	std::cout << "[" << std::bitset<32>(i >> 32) << "]" << std::endl;
+			}
-
+		}
-}
+	}
-
+
-inline void DumpLog(std::stringstream* ss, std::string file_name) {
+	std::istream_iterator<std::string> begin(ss);
-	
+	std::istream_iterator<std::string> end;
-	std::ofstream log_file;
+	std::vector<std::string> vstrings(begin, end);
-	log_file.open(file_name);
+
-
+	std::vector<float> ret;
-	log_file << ss->str();
+
-
+	for (auto i: vstrings) {
-	log_file.close();
+		ret.push_back(std::stof(i));
-
+	}
-}
+
-
+	return ret;
-inline std::string sfml_get_input(sf::RenderWindow *window) {
+
-	
+}
-	std::stringstream ss;
+
-
+inline int count_bits(int32_t v) {
-	sf::Event event;
+	
-	while (window->pollEvent(event)) {
+	v = v - ((v >> 1) & 0x55555555);                       // reuse input as temporary
-		if (event.type == sf::Event::TextEntered) {
+	v = (v & 0x33333333) + ((v >> 2) & 0x33333333);        // temp
-			ss << event.text.unicode;
+	return (((v + (v >> 4)) & 0xF0F0F0F) * 0x1010101) >> 24; // count
-		} 
+}
-		
+
-		else if (event.type == sf::Event::KeyPressed) {
+inline int count_bits(int64_t v) {
-			if (event.key.code == sf::Keyboard::Return) {
+
-				return ss.str();
+	int32_t left = (int32_t)(v);
-			}
+	int32_t right = (int32_t)(v >> 32);
-		}
+
-	}
+	left = left - ((left >> 1) & 0x55555555);                    // reuse input as temporary
-}
+	left = (left & 0x33333333) + ((left >> 2) & 0x33333333);     // temp
-
+	left = ((left + (left >> 4) & 0xF0F0F0F) * 0x1010101) >> 24; // count
-inline std::vector<float> sfml_get_float_input(sf::RenderWindow *window) {
+
-
+	right = right - ((right >> 1) & 0x55555555);                    // reuse input as temporary
-	std::stringstream ss;
+	right = (right & 0x33333333) + ((right >> 2) & 0x33333333);     // temp
-
+	right = ((right + (right >> 4) & 0xF0F0F0F) * 0x1010101) >> 24; // count
-	sf::Event event;
+
-	while (true) {
+	return left + right;
-
-		if (window->pollEvent(event)) {
-
-			if (event.type == sf::Event::TextEntered) {
-				if (event.text.unicode > 47 && event.text.unicode < 58 || event.text.unicode == 32)
-					ss << static_cast<char>(event.text.unicode);
-			}
-
-			else if (event.type == sf::Event::KeyPressed) {
-
-				if (event.key.code == sf::Keyboard::Return) {
-					break;
-				}
-			}
-		}
-	}
-
-	std::istream_iterator<std::string> begin(ss);
-	std::istream_iterator<std::string> end;
-	std::vector<std::string> vstrings(begin, end);
-
-	std::vector<float> ret;
-
-	for (auto i: vstrings) {
-		ret.push_back(std::stof(i));
-	}
-
-	return ret;
-
-}
-
-inline int count_bits(int32_t v) {
-	
-	v = v - ((v >> 1) & 0x55555555);                       // reuse input as temporary
-	v = (v & 0x33333333) + ((v >> 2) & 0x33333333);        // temp
-	return (((v + (v >> 4)) & 0xF0F0F0F) * 0x1010101) >> 24; // count
-}
-
-inline int count_bits(int64_t v) {
-
-	int32_t left = (int32_t)(v);
-	int32_t right = (int32_t)(v >> 32);
-
-	left = left - ((left >> 1) & 0x55555555);                    // reuse input as temporary
-	left = (left & 0x33333333) + ((left >> 2) & 0x33333333);     // temp
-	left = ((left + (left >> 4) & 0xF0F0F0F) * 0x1010101) >> 24; // count
-
-	right = right - ((right >> 1) & 0x55555555);                    // reuse input as temporary
-	right = (right & 0x33333333) + ((right >> 2) & 0x33333333);     // temp
-	right = ((right + (right >> 4) & 0xF0F0F0F) * 0x1010101) >> 24; // count
-
-	return left + right;
 }

src/Old_Map.cpp

@@ -1,7 +1,7 @@
 #include <iostream>
 #include <SFML/System/Vector3.hpp>
 #include <SFML/System/Vector2.hpp>
-#include "util.hpp"
+#include "util.cpp"
 #include <Old_Map.h>
 #include <algorithm>
 

src/Ray.cpp

@@ -2,7 +2,7 @@
 #include <iostream>
 #include "Map.h"
 #include <Ray.h>
-#include "util.hpp"
+#include "util.cpp"
 
 Ray::Ray(
         Map *map,

src/main.cpp

@@ -23,12 +23,12 @@
 #endif
 
 #pragma once
+#include "util.cpp"
 #include <iostream>
 #include <chrono>
 #include <SFML/Graphics.hpp>
 #include <SFML/Network.hpp>
 #include "Old_Map.h"
-#include "util.hpp"
 #include "raycaster/RayCaster.h"
 #include "raycaster/Hardware_Caster.h"
 #include "Vector4.hpp"
@@ -41,6 +41,7 @@
 #include "imgui/imgui-SFML.h"
 #include "imgui/imgui.h"
 
+
 const int WINDOW_X = 1440;
 const int WINDOW_Y = 900;
 const int WORK_SIZE = WINDOW_X * WINDOW_Y;
@@ -236,48 +237,23 @@ int main() {
             // ==== DELTA TIME LOCKED ====
         }
 
+		// ==== FPS LOCKED ====
 
 		ImGui::SFML::Update(window, sf_delta_clock.restart());
-
-
-		ImGui::Begin("Sample window"); // begi
-		ImGui::InputText("Window title", "asdfoij", 255);
-
-		float values[] = { 0, 1, 2, 3, 4, 5 };
-		ImGui::PlotLines("graph", values, 6);
-		if (ImGui::Button("Print")) {
-			std::cout << "print" << std::endl;
-		}
-
-		ImGui::End(); // end window
-
-
-        // ==== FPS LOCKED ====
 		camera->update(delta_time);
 		handle->update(delta_time);
 
-		window.clear(sf::Color::Black);
-
 		// Run the raycast
 		raycaster->compute();
+
+
+		window.clear(sf::Color::Black);
+
 		raycaster->draw(&window);
 
-		ImGui::Render();
-
-		//window.popGLStates();
-
-		//glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
-		//t.rotate(delta_time);
-		//t.transform();
-		//t.draw();
-		
-		//glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
-		
-		//window.pushGLStates();
-
 		// Give the frame counter the frame time and draw the average frame time
 		fps.frame(delta_time);
-		fps.draw(&window);
+		fps.draw();
 
 		cam_text_x.draw(&window);
 		cam_text_y.draw(&window);
@@ -286,6 +262,7 @@ int main() {
 		cam_text_pos_y.draw(&window);
 		cam_text_pos_z.draw(&window);
 
+		ImGui::Render();
 		window.display();
 
 	}

src/raycaster/Hardware_Caster.cpp

@@ -1,6 +1,4 @@
 #include "raycaster/Hardware_Caster.h"
-#include <raycaster/RayCaster.h>
-#include "LightController.h"
 
 Hardware_Caster::Hardware_Caster() {
 
@@ -15,23 +13,23 @@ int Hardware_Caster::init() {
 	// Initialize opencl up to the point where we start assigning buffers
 
 	error = acquire_platform_and_device();
-	if(assert(error, "aquire_platform_and_device"))
+	if(vr_assert(error, "aquire_platform_and_device"))
 		return error;
 
 	error = check_cl_khr_gl_sharing();
-	if(assert(error, "check_cl_khr_gl_sharing"))
+	if(vr_assert(error, "check_cl_khr_gl_sharing"))
 		return error;
 
 	error = create_shared_context();
-	if (assert(error, "create_shared_context"))
+	if (vr_assert(error, "create_shared_context"))
 		return error;
 
 	error = create_command_queue();
-	if (assert(error, "create_command_queue"))
+	if (vr_assert(error, "create_command_queue"))
 		return error;
 
 	error = compile_kernel("../kernels/ray_caster_kernel.cl", true, "raycaster");
-	if (assert(error, "compile_kernel")) {
+	if (vr_assert(error, "compile_kernel")) {
 		std::cin.get(); // hang the output window so we can read the error
 		return error;
 	}
@@ -216,7 +214,7 @@ void Hardware_Caster::draw(sf::RenderWindow* window) {
 int Hardware_Caster::debug_quick_recompile()
 {
 	int error = compile_kernel("../kernels/ray_caster_kernel.cl", true, "raycaster");
-	if (assert(error, "compile_kernel")) {
+	if (vr_assert(error, "compile_kernel")) {
 		std::cin.get(); // hang the output window so we can read the error
 		return error;
 	}
@@ -306,7 +304,7 @@ int Hardware_Caster::acquire_platform_and_device() {
 		std::vector<cl_device_id> deviceIds(deviceIdCount);
 		error = clGetDeviceIDs(plt_buf[i], CL_DEVICE_TYPE_ALL, deviceIdCount, deviceIds.data(), NULL);
 
-		if (assert(error, "clGetDeviceIDs"))
+		if (vr_assert(error, "clGetDeviceIDs"))
 			return OPENCL_ERROR;
 
 		for (unsigned int q = 0; q < deviceIdCount; q++) {
@@ -409,7 +407,7 @@ int Hardware_Caster::create_shared_context() {
 		&error
 		);
 
-	if (assert(error, "clCreateContext"))
+	if (vr_assert(error, "clCreateContext"))
 		return OPENCL_ERROR;
 
 	return 1;
@@ -422,7 +420,7 @@ int Hardware_Caster::create_command_queue() {
 		
 		command_queue = clCreateCommandQueue(context, device_id, 0, &error);
 
-		if (assert(error, "clCreateCommandQueue"))
+		if (vr_assert(error, "clCreateCommandQueue"))
 			return OPENCL_ERROR;
 
 		return 1;
@@ -477,7 +475,7 @@ int Hardware_Caster::compile_kernel(std::string kernel_source, bool is_path, std
 		);
 
 	// This is not for compilation, it only loads the source
-	if (assert(error, "clCreateProgramWithSource"))
+	if (vr_assert(error, "clCreateProgramWithSource"))
 		return OPENCL_ERROR;
 
 
@@ -485,7 +483,7 @@ int Hardware_Caster::compile_kernel(std::string kernel_source, bool is_path, std
 	error = clBuildProgram(program, 1, &device_id, NULL, NULL, NULL);
 
 	// Check to see if it errored out
-	if (assert(error, "clBuildProgram")) {
+	if (vr_assert(error, "clBuildProgram")) {
 
 		// Get the size of the queued log
 		size_t log_size;
@@ -502,7 +500,7 @@ int Hardware_Caster::compile_kernel(std::string kernel_source, bool is_path, std
 	// Done initializing the kernel
 	cl_kernel kernel = clCreateKernel(program, kernel_name.c_str(), &error);
 
-	if (assert(error, "clCreateKernel"))
+	if (vr_assert(error, "clCreateKernel"))
 		return OPENCL_ERROR;
 
 	// Do I want these to overlap when repeated??
@@ -523,7 +521,7 @@ int Hardware_Caster::set_kernel_arg(
 		sizeof(cl_mem),
 		(void *)&buffer_map.at(buffer_name));
 
-	if (assert(error, "clSetKernelArg")){
+	if (vr_assert(error, "clSetKernelArg")){
 		std::cout << buffer_name << std::endl;
 		std::cout << buffer_map.at(buffer_name) << std::endl;
 		return OPENCL_ERROR;
@@ -545,7 +543,7 @@ int Hardware_Caster::create_image_buffer(std::string buffer_name, cl_uint size,
 		getContext(), access_type, GL_TEXTURE_2D,
 		0, texture->getNativeHandle(), &error);
 
-	if (assert(error, "clCreateFromGLTexture"))
+	if (vr_assert(error, "clCreateFromGLTexture"))
 		return OPENCL_ERROR;
 
 	store_buffer(buff, buffer_name);
@@ -566,7 +564,7 @@ int Hardware_Caster::create_buffer(std::string buffer_name, cl_uint size, void*
 		size, data, &error
 		);
 
-	if (assert(error, "clCreateBuffer"))
+	if (vr_assert(error, "clCreateBuffer"))
 		return OPENCL_ERROR;
 
 	store_buffer(buff, buffer_name);
@@ -588,7 +586,7 @@ int Hardware_Caster::create_buffer(std::string buffer_name, cl_uint size, void*
 		size, data, &error
 		);
 
-	if (assert(error, "clCreateBuffer"))
+	if (vr_assert(error, "clCreateBuffer"))
 		return OPENCL_ERROR;
 
 	store_buffer(buff, buffer_name);
@@ -603,7 +601,7 @@ int Hardware_Caster::release_buffer(std::string buffer_name) {
 		
 		int error = clReleaseMemObject(buffer_map.at(buffer_name));
 		
-		if (assert(error, "clReleaseMemObject")) {
+		if (vr_assert(error, "clReleaseMemObject")) {
 			std::cout << "Error releasing buffer : " << buffer_name;
 			std::cout << "Buffer not removed";
 			return -1;
@@ -634,7 +632,7 @@ int Hardware_Caster::run_kernel(std::string kernel_name, const int work_size) {
 	cl_kernel kernel = kernel_map.at(kernel_name);
 
 	error = clEnqueueAcquireGLObjects(getCommandQueue(), 1, &buffer_map.at("image"), 0, 0, 0);
-	if (assert(error, "clEnqueueAcquireGLObjects"))
+	if (vr_assert(error, "clEnqueueAcquireGLObjects"))
 		return OPENCL_ERROR;
 
 	//error = clEnqueueTask(command_queue, kernel, 0, NULL, NULL);
@@ -643,14 +641,14 @@ int Hardware_Caster::run_kernel(std::string kernel_name, const int work_size) {
 		1, NULL, global_work_size,
 		NULL, 0, NULL, NULL);
 
-	if (assert(error, "clEnqueueNDRangeKernel"))
+	if (vr_assert(error, "clEnqueueNDRangeKernel"))
 		return OPENCL_ERROR;
 
 	clFinish(getCommandQueue());
 
 	// What if errors out and gl objects are never released?
 	error = clEnqueueReleaseGLObjects(getCommandQueue(), 1, &buffer_map.at("image"), 0, NULL, NULL);
-	if (assert(error, "clEnqueueReleaseGLObjects"))
+	if (vr_assert(error, "clEnqueueReleaseGLObjects"))
 		return OPENCL_ERROR;
 
 	return 1;
@@ -678,7 +676,7 @@ cl_context Hardware_Caster::getContext() { return context; };
 cl_kernel Hardware_Caster::getKernel(std::string kernel_name) { return kernel_map.at(kernel_name); };
 cl_command_queue Hardware_Caster::getCommandQueue() { return command_queue; };
 
-bool Hardware_Caster::assert(int error_code, std::string function_name) {
+bool Hardware_Caster::vr_assert(int error_code, std::string function_name) {
 
 	// Just gonna do a little jump table here, just error codes so who cares
 	std::string err_msg = "Error : ";