[EDIT] stuff

.gitignore

@@ -428,4 +428,6 @@ FodyWeavers.xsd
 **/docs/*
 **/doc/*
 
+**/pose_iter_160000.caffemodel
+
 # End of https://www.toptal.com/developers/gitignore/api/c++,visualstudio,visualstudiocode,opencv

src/collision/collision.h

@@ -1,31 +0,0 @@
-#pragma once
-
-#include <glm/gtc/matrix_transform.hpp>
-#include "../entities/entity.h"
-
-namespace collision
-{
-	/*
-	 * This structure represents a collision box inside the world.
-	 *
-	 * center_pos:	The center position of the collision box
-	 * size:		The size in each axis of the collision box
-	 */
-	struct Box
-	{
-		glm::vec3 center_pos;
-		glm::vec3 size;
-	};
-
-	/*
-	 * This structure represents a collision between 2 entities
-	 *
-	 * entity1:		The first entity
-	 * entity2:		The second entity
-	 */
-	struct Collision
-	{
-		entities::Entity& entity1;
-		entities::Entity& entity2;
-	};
-}

src/collision/collision_handler.cpp

@@ -1,40 +0,0 @@
-#include "collision_handler.h"
-
-namespace collision
-{
-	void CheckCollisions(std::vector<entities::CollisionEntity*>& entities)
-	{
-		if (entities.size() == 2)
-		{			
-			if (entities[0]->IsColliding(*entities[1]))
-			{
-				collision::Collision c = { *entities[0], *entities[1] };
-				entities[0]->OnCollide(c);
-				entities[1]->OnCollide(c);
-			}
-		}
-		
-		for (int i = 0; i < entities.size() - 2; i++)
-		{			
-		 	entities::CollisionEntity* entity = entities[i];
-		 	
-		 	for (int j = i + 1; i < entities.size() - 1; j++)
-		 	{
-		 		entities::CollisionEntity* entity2 = entities[j];
-		 		
-		 		if (entity == entity2)
-		 		{
-		 			continue;
-		 		}
-		 		
-		 		if (entity->IsColliding(*entity2))
-		 		{
-		 			collision::Collision c = { *entity, *entity2 };
-		 			entity->OnCollide(c);
-		 			entity2->OnCollide(c);
-		 			break;
-		 		}
-		 	}
-		}
-	}
-}

src/collision/collision_handler.h

@@ -1,16 +0,0 @@
-#pragma once
-
-#include <vector>
-#include "../entities/collision_entity.h"
-#include "collision.h"
-
-namespace collision
-{
-	/*
-	 * @brief: This function will check all the collision entities for
-	 *         collisions and call the OnCollide function when a entity collides.
-	 *
-	 * @param entities: A list with all the collision entities.
-	 */
-	void CheckCollisions(std::vector<entities::CollisionEntity*>& entities);
-}

src/computervision/ObjectDetection.cpp

@@ -8,10 +8,10 @@
 #include "SkinDetector.h"
 #include "FaceDetector.h"
 #include "FingerCount.h"
+#include "async/StaticCameraInstance.h"
 
 namespace computervision
 {
-	cv::VideoCapture cap(0);
 
 	cv::Mat img, imgGray, img2, img2Gray, img3, img4;
 
@@ -24,6 +24,8 @@ namespace computervision
 	FaceDetector faceDetector;
 	FingerCount fingerCount;
 
+	cv::VideoCapture cap = static_camera::getCap();
+
 	ObjectDetection::ObjectDetection()
 	{
 	}
@@ -33,6 +35,11 @@ namespace computervision
 		return img;
 	}
 
+	cv::VideoCapture ObjectDetection::getCap()
+	{
+		return cap;
+	}
+
 	bool ObjectDetection::detectHand(Mat cameraFrame)
 	{
 		Mat inputFrame = generateHandMaskSquare(cameraFrame);
@@ -59,10 +66,10 @@ namespace computervision
 		putText(cameraFrame,hand_text, Point(10, 75), FONT_HERSHEY_PLAIN, 2.0, Scalar(255, 0, 255),3);
 		imshow("camera", cameraFrame);
 
-	/*	imshow("output", frameOut);
+		imshow("output", frameOut);
 		imshow("foreground", foreground);
 		imshow("handMask", handMask);
-		imshow("handDetection", fingerCountDebug);*/
+		imshow("handDetection", fingerCountDebug);
 
 		int key = waitKey(1);
 

src/computervision/ObjectDetection.h

@@ -65,6 +65,9 @@ namespace computervision
 		 */
 		bool drawHandMaskRect(cv::Mat *input);
 
+
+		cv::VideoCapture getCap();
+
 	};
 
 

src/computervision/OpenPoseVideo.cpp

@@ -0,0 +1,108 @@
+#include "OpenPoseVideo.h"
+
+using namespace std;
+using namespace cv;
+using namespace cv::dnn;
+
+namespace computervision
+{
+#define MPI
+
+#ifdef MPI
+	const int POSE_PAIRS[7][2] =
+	{
+		{0,1}, {1,2}, {2,3},
+		{3,4}, {1,5}, {5,6},
+		{6,7}
+	};
+
+	string protoFile = "res/pose/mpi/pose_deploy_linevec_faster_4_stages.prototxt";
+	string weightsFile = "res/pose/mpi/pose_iter_160000.caffemodel";
+
+	int nPoints = 8;
+#endif
+
+#ifdef COCO
+	const int POSE_PAIRS[17][2] =
+	{
+		{1,2}, {1,5}, {2,3},
+		{3,4}, {5,6}, {6,7},
+		{1,8}, {8,9}, {9,10},
+		{1,11}, {11,12}, {12,13},
+		{1,0}, {0,14},
+		{14,16}, {0,15}, {15,17}
+	};
+
+	string protoFile = "pose/coco/pose_deploy_linevec.prototxt";
+	string weightsFile = "pose/coco/pose_iter_440000.caffemodel";
+
+	int nPoints = 18;
+#endif
+	Net net;
+
+	void OpenPoseVideo::setup() {
+		net = readNetFromCaffe(protoFile, weightsFile);
+
+		net.setPreferableBackend(DNN_TARGET_CPU);
+	}
+
+	void OpenPoseVideo::movementSkeleton(Mat& inputImage, std::function<void(std::vector<Point>&, cv::Mat& poinst_on_image)> f) {
+		std::cout << "movement skeleton start" << std::endl;
+
+		int inWidth = 368;
+		int inHeight = 368;
+		float thresh = 0.01;
+
+		Mat frame;
+		int frameWidth = inputImage.size().width;
+		int frameHeight = inputImage.size().height;
+
+		double t = (double)cv::getTickCount();
+		std::cout << "reading input image and blob" << std::endl;
+
+		frame = inputImage;
+		Mat inpBlob = blobFromImage(frame, 1.0 / 255, Size(inWidth, inHeight), Scalar(0, 0, 0), false, false);
+
+		std::cout << "done reading image and blob" << std::endl;
+
+		net.setInput(inpBlob);
+
+		std::cout << "done setting input to net" << std::endl;
+		Mat output = net.forward();
+		std::cout << "time took to set input and forward: " << t << std::endl;
+
+		int H = output.size[2];
+		int W = output.size[3];
+
+		std::cout << "about to find position of boxy parts" << std::endl;
+		// find the position of the body parts
+		vector<Point> points(nPoints);
+		for (int n = 0; n < nPoints; n++)
+		{
+			// Probability map of corresponding body's part.
+			Mat probMap(H, W, CV_32F, output.ptr(0, n));
+
+			Point2f p(-1, -1);
+			Point maxLoc;
+			double prob;
+			minMaxLoc(probMap, 0, &prob, 0, &maxLoc);
+			if (prob > thresh)
+			{
+				p = maxLoc;
+				p.x *= (float)frameWidth / W;
+				p.y *= (float)frameHeight / H;
+
+				circle(frame, cv::Point((int)p.x, (int)p.y), 8, Scalar(0, 255, 255), -1);
+				cv::putText(frame, cv::format("%d", n), cv::Point((int)p.x, (int)p.y), cv::FONT_HERSHEY_COMPLEX, 1.1, cv::Scalar(0, 0, 255), 2);
+			}
+			points[n] = p;
+		}
+
+		cv::putText(frame, cv::format("time taken = %.2f sec", t), cv::Point(50, 50), cv::FONT_HERSHEY_COMPLEX, .8, cv::Scalar(255, 50, 0), 2);
+		std::cout << "time taken: " << t << std::endl;
+		//imshow("Output-Keypoints", frame);
+		//imshow("Output-Skeleton", frame);
+		std::cout << "about to call points receiving method" << std::endl;
+		f(points,frame);
+	}
+}

src/computervision/OpenPoseVideo.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <opencv2/dnn.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+#include <iostream>
+
+using namespace cv;
+
+namespace computervision
+{
+	class OpenPoseVideo{
+	private:
+
+	public:
+		void movementSkeleton(Mat& inputImage, std::function<void(std::vector<Point>&, cv::Mat& poinst_on_image)> f);
+		void setup();
+	};
+}

src/computervision/async/StaticCameraInstance.h

@@ -0,0 +1,12 @@
+#pragma once
+#include <opencv2/videoio.hpp>
+
+namespace static_camera
+{
+
+	static cv::VideoCapture getCap()
+	{
+		static cv::VideoCapture cap(0);
+		return cap;
+	}
+};

src/computervision/async/async_arm_detection.cpp

@@ -0,0 +1,46 @@
+#include <iostream>
+#include "async_arm_detection.h"
+#include "../OpenPoseVideo.h"
+#include <thread>
+#include "StaticCameraInstance.h"
+
+
+namespace computervision
+{
+	AsyncArmDetection::AsyncArmDetection()
+	{
+
+	}
+
+	void AsyncArmDetection::run_arm_detection(std::function<void(std::vector<Point>, cv::Mat poinst_on_image)> points_ready_func, OpenPoseVideo op)
+	{
+		VideoCapture cap = static_camera::getCap();
+		
+		std::cout << "STARTING THREAD LAMBDA" << std::endl;
+		/*cv::VideoCapture cap = static_camera::getCap();*/
+
+		if (!cap.isOpened())
+		{
+			std::cout << "capture was closed, opening..." << std::endl;
+			cap.open(0);
+		}
+
+		while (true)
+		{
+			Mat img;
+			cap.read(img);
+			op.movementSkeleton(img, points_ready_func);
+		}
+	}
+
+	void AsyncArmDetection::start(std::function<void(std::vector<Point>, cv::Mat poinst_on_image)> points_ready_func, OpenPoseVideo op)
+	{
+
+		std::cout << "starting function" << std::endl;
+
+
+		std::thread async_arm_detect_thread(&AsyncArmDetection::run_arm_detection,this, points_ready_func, op);
+
+		async_arm_detect_thread.detach(); // makes sure the thread is detached from the variable.
+	}
+}

src/computervision/async/async_arm_detection.h

@@ -0,0 +1,23 @@
+#pragma once
+#include <vector>
+#include <opencv2/core/types.hpp>
+#include <opencv2/videoio.hpp>
+#include <functional>
+#include "../OpenPoseVideo.h"
+#include "StaticCameraInstance.h"
+
+
+namespace computervision
+{
+	class AsyncArmDetection
+	{
+	public:
+		AsyncArmDetection(void);
+
+		
+		void start(std::function<void(std::vector<cv::Point>, cv::Mat poinst_on_image)>, computervision::OpenPoseVideo op);
+	private:
+		void run_arm_detection(std::function<void(std::vector<Point>, cv::Mat poinst_on_image)> points_ready_func, OpenPoseVideo op);
+	};
+
+}

src/entities/Camera.cpp

@@ -9,42 +9,24 @@ namespace entities
 
 	void Camera::Move(GLFWwindow* window)
 	{
-		float movement_speed = 0;
-		
 		if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
 		{
-			movement_speed -= SPEED;
+			position.z -= SPEED;
 		}
 
 		if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
 		{
-			movement_speed += SPEED;
+			position.z += SPEED;
 		}
 
 		if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
 		{
-			rotation.y += ROT_SPEED;
+			position.x += SPEED;
 		}
 
 		if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
 		{
-			rotation.y -= ROT_SPEED;
+			position.x -= SPEED;
 		}
-
-		if (glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS)
-		{
-			rotation.x -= ROT_SPEED;
-		}
-
-		if (glfwGetKey(window, GLFW_KEY_LEFT_SHIFT) == GLFW_PRESS)
-		{
-			rotation.x += ROT_SPEED;
-		}
-
-		float dx = glm::cos(glm::radians(rotation.y + 90)) * movement_speed;
-		float dz = glm::sin(glm::radians(rotation.y + 90)) * movement_speed;
-
-		position.x += dx;
-		position.z += dz;
 	}
 }

src/entities/Camera.h

@@ -1,20 +1,14 @@
 #pragma once
-#include <GL/glew.h>
+
 #include <GLFW/glfw3.h>
 #include <glm/gtc/matrix_transform.hpp>
 
 namespace entities
 {
-	/*
-	 * This class represents the viewport of the game. The whole game is seen through this class
-	 */
-	
 	class Camera
 	{
 	private:
-		// The movement speed of the camera
+		const float SPEED = 0.02f;
-		const float SPEED = 0.52f;
-		const float ROT_SPEED = 1.0f;
 		
 		glm::vec3 position;
 		glm::vec3 rotation;
@@ -22,11 +16,6 @@ namespace entities
 	public:
 		Camera(const ::glm::vec3& position, const ::glm::vec3& rotation);
 
-		/*
-		 * @brief: This funtion moves the camera's position from the inputs of the keyboard
-		 *
-		 * @param window: The OpenGL window
-		 */
 		void Move(GLFWwindow* window);
 		
 		inline glm::vec3 GetPosition() const{ return position; }

src/entities/Entity.h

@@ -5,15 +5,10 @@
 
 namespace entities
 {
-	/*
-	 * This class represents a movable model in the game
-	 */
-	
 	class Entity
 	{
-	protected:
+	private:
 		models::TexturedModel model;
-		
 		glm::vec3 position;
 		glm::vec3 rotation;
 		float scale;
@@ -21,18 +16,7 @@ namespace entities
 	public:
 		Entity(const models::TexturedModel& model, const glm::vec3& position, const glm::vec3& rotation, float scale);
 
-		/*
-		 * @brief: This function increases the position of the entity
-		 *
-		 * @param distance: The amount of distance in each axis the entity needs to move
-		 */
 		void IncreasePosition(const glm::vec3& distance);
-
-		/*
-		 * @brief: This function increases the rotation of the entity
-		 *
-		 * @param rotation: The angle of each axis the entity needs to rotate
-		 */
 		void IncreaseRotation(const glm::vec3& rotation);
 		
 		inline models::TexturedModel GetModel() const{return model;}

src/entities/collision_entity.cpp

@@ -1,44 +0,0 @@
-#include "collision_entity.h"
-
-namespace entities
-{
-	CollisionEntity::CollisionEntity(const models::TexturedModel& model, const glm::vec3& position,
-		const glm::vec3& rotation, float scale, const collision::Box& bounding_box)
-		: Entity(model, position, rotation, scale),
-		bounding_box(bounding_box)
-	{
-		MoveCollisionBox();
-	}
-
-	void CollisionEntity::OnCollide(const collision::Collision& collision)
-	{
-		if (on_collide != nullptr)
-		{
-			on_collide(collision);
-		}
-	}
-
-	bool CollisionEntity::IsColliding(const glm::vec3& point) const
-	{
-		return (point.x >= min_xyz.x && point.x <= max_xyz.x) &&
-			(point.y >= min_xyz.y && point.y <= max_xyz.y) &&
-			(point.z >= min_xyz.z && point.z <= max_xyz.z);
-	}
-
-	bool CollisionEntity::IsColliding(const CollisionEntity& e) const
-	{
-		return (min_xyz.x <= e.max_xyz.x && max_xyz.x >= e.min_xyz.x) &&
-			(min_xyz.y <= e.max_xyz.y && max_xyz.y >= e.min_xyz.y) &&
-			(min_xyz.z <= e.max_xyz.z && max_xyz.z >= e.min_xyz.z);
-	}
-
-	void CollisionEntity::MoveCollisionBox()
-	{
-		bounding_box.center_pos = position;
-		
-		const glm::vec3 size = bounding_box.size;
-
-		min_xyz = bounding_box.center_pos;
-		max_xyz = glm::vec3(min_xyz.x + size.x, min_xyz.y + size.y, min_xyz.z + size.z);
-	}
-}

src/entities/collision_entity.h

@@ -1,65 +0,0 @@
-#pragma once
-
-#include "entity.h"
-#include "../collision/collision.h"
-
-namespace entities
-{
-	/*
-	 * This class is an entity with a collision box
-	 */
-	class CollisionEntity : public Entity
-	{
-	public:
-		collision::Box bounding_box;
-
-		glm::vec3 min_xyz;
-		glm::vec3 max_xyz;
-
-		void (*on_collide)(const collision::Collision& collision);
-
-	public:
-		CollisionEntity(const models::TexturedModel& model, const glm::vec3& position, const glm::vec3& rotation,
-			float scale, const collision::Box& bounding_box);
-
-		/*
-		 * @brief: A function to do some sort of behaviour when the entity collides
-		 *
-		 * @param collision: The collision
-		 */
-		virtual void OnCollide(const collision::Collision& collision);
-
-		/*
-		 * @brief: A function to check if the entity is colliding with a point in 3D space
-		 *
-		 * @param point: The point to check if its colliding with the entity
-		 *
-		 * @return: True is the entity is colliding, false if not
-		 */
-		bool IsColliding(const glm::vec3& point) const;
-
-		/*
-		 * @brief: A function to check if the entity is colliding with another entity
-		 *
-		 * @param e: The other entity to check if its colliding with this
-		 *
-		 * @return: True is the entity is colliding, false if not
-		 */
-		bool IsColliding(const CollisionEntity& e) const;
-
-		/*
-		 * @brief: A function to set the collision behaviour of the entity
-		 *
-		 * @param function: A function pointer to a function with the collision behaviour
-		 */
-		void SetCollisionBehaviour(void (*function)(const collision::Collision& collision))
-		{ if (function != nullptr) { on_collide = function; } }
-
-	protected:
-
-		/*
-		 * @brief: This method moves the collision to the center of the entity
-		 */
-		void MoveCollisionBox();
-	};
-}

src/entities/light.h

@@ -1,30 +0,0 @@
-#pragma once
-
-#include <glm/vec3.hpp>
-
-namespace entities
-{
-	/*
-	 * This class represents a light in the game 
-	 */
-	
-	class Light
-	{
-	private:
-		glm::vec3 position;
-		glm::vec3 color;
-		glm::vec3 attenuation = { 1, 0, 0 };
-
-	public:
-		Light(const glm::vec3& position, const glm::vec3& color) : position(position), color(color) { }
-		Light(const glm::vec3& position, const glm::vec3& color, const glm::vec3& attenuation)
-			: position(position), color(color), attenuation(attenuation) { }
-
-		glm::vec3 GetPosition() const { return position; }
-		void setPosition(const glm::vec3& position) { this->position = position; }
-		glm::vec3 GetColor() const { return color; }
-		void setColor(const glm::vec3& color) { this->color = color; }
-		glm::vec3 GetAttenuation() const { return attenuation; }
-		void SetAttenuation(const glm::vec3& attenuation) { this->attenuation = attenuation; }
-	};
-}

src/gui/gui_element.h

@@ -1,26 +0,0 @@
-#pragma once
-
-#include <glm/gtc/matrix_transform.hpp>
-#include "../toolbox/toolbox.h"
-
-namespace gui
-{
-	/*
-	 * Structure for representing a gui item to display on the screen
-	 *
-	 * texture  = The texture for the gui
-	 * position = The center position of the gui
-	 * scale    = The size (scale) of the gui
-	 */
-	struct GuiTexture
-	{
-		int texture;
-		glm::vec2 position;
-		glm::vec2 scale;
-
-		GuiTexture(int texture, glm::vec2 position, glm::vec2 scale): texture(texture), position(position), scale(scale)
-		{
-			scale.x /= (WINDOW_WIDTH / WINDOW_HEIGT);
-		}
-	};
-}

src/gui/gui_interactable.cpp

@@ -1,83 +0,0 @@
-#include <GL/glew.h>
-#include <GLFW/glfw3.h>
-#include "gui_interactable.h"
-
-namespace gui
-{
-	InteractableGui::InteractableGui(int default_texture, glm::vec2 position, glm::vec2 scale)
-		: GuiTexture(default_texture, position, scale)
-	{
-		this->default_texture = default_texture;
-
-		minXY = glm::vec2(position.x - scale.x, position.y - scale.y);
-		maxXY = glm::vec2(position.x + scale.x, position.y + scale.y);
-	}
-
-	void InteractableGui::Update(GLFWwindow* window)
-	{
-		if (IsHoveringAbove(window) && glfwGetMouseButton(window, GLFW_MOUSE_BUTTON_LEFT) == GLFW_PRESS)
-		{
-			if (clicked_texture != 0)
-			{
-				texture = clicked_texture;
-			}
-			else
-			{
-				texture = default_texture;
-			}
-
-			if (!is_clicking)
-			{
-				OnClick();
-				is_clicking = true;
-			}
-		}
-		else
-		{
-			if (is_clicking)
-			{
-				is_clicking = false;
-			}
-		}
-	}
-
-	bool InteractableGui::IsHoveringAbove(GLFWwindow* window)
-	{
-		double x_pos, y_pos;
-		glfwGetCursorPos(window, &x_pos, &y_pos);
-
-		const float x_rel = (x_pos / SCALED_WIDTH / DEFAULT_WIDTH) * 2.0f - 1.0f;
-		const float y_rel = -((y_pos / SCALED_HEIGHT / DEFAULT_HEIGHT) * 2.0f - 1.0f);
-
-		if (x_rel >= minXY.x && x_rel <= maxXY.x &&
-			y_rel >= minXY.y && y_rel <= maxXY.y)
-		{
-			if (hover_texture != 0)
-			{
-				texture = hover_texture;
-			}
-			else
-			{
-				texture = default_texture;
-			}
-
-			if (!is_hovering)
-			{
-				OnEnter();
-				is_hovering = true;
-			}
-
-			return true;
-		}
-
-		texture = default_texture;
-
-		if (is_hovering)
-		{
-			OnExit();
-			is_hovering = false;
-		}
-
-		return false;
-	}
-}

src/gui/gui_interactable.h

@@ -1,112 +0,0 @@
-#pragma once
-
-#include <glm/gtc/matrix_transform.hpp>
-#include "../toolbox/toolbox.h"
-#include "gui_element.h"
-
-namespace gui
-{
-	/*
-	 * This class represents a gui item which can be interacted with
-	 */
-	class InteractableGui : public GuiTexture
-	{
-	private:
-		int default_texture;
-		int clicked_texture = 0;
-		int hover_texture = 0;
-
-		bool is_hovering = false;
-		bool is_clicking = false;
-
-		glm::vec2 minXY;
-		glm::vec2 maxXY;
-
-	public:
-		InteractableGui(int default_texture, glm::vec2 position, glm::vec2 scale);
-
-		/*
-		 * @brief: Call this function every frame
-		 *
-		 * @param window: An openGL window
-		 */
-		void Update(GLFWwindow* window);
-
-		/*
-		 * @brief: This function gets called when the InteractabeGui is clicked
-		 */
-		virtual void OnClick() = 0;
-
-		/*
-		 * @brief: This function gets called when the mouse starts hovering above the InteractableGUI
-		 */
-		virtual void OnEnter() = 0;
-
-		/*
-		 * @brief: This function gets called when the mouse stops hovering above the InteractableGUI
-		 */
-		virtual void OnExit() = 0;
-
-		/*
-		 * @brief: This function sets the texture of the InteractableGUI for when the InteractableGUI is clicked
-		 */
-		void SetClickedTexture(int texture) { clicked_texture = texture; }
-
-		/*
-		 * @brief: This function sets the texture of the InteractableGUI for when the mouse is hovering above the InteractableGUI
-		 */
-		void SetHoverTexture(int texture) { hover_texture = texture; }
-
-	private:
-		/*
-		 * @brief: This function checks if the mouse is hovering above the InteractableGUI
-		 *
-		 * @param window: An openGL window
-		 *
-		 * @return: True or false
-		 */
-		bool IsHoveringAbove(GLFWwindow* window);
-	};
-
-
-	
-	/*
-	 * This class represents a button
-	 */
-	class Button : public InteractableGui
-	{
-	private:
-		void (*on_click_action)();
-		void (*on_enter_action)();
-		void (*on_exit_action)();
-
-	public:
-		Button(int default_texture, glm::vec2 position, glm::vec2 scale) : InteractableGui(default_texture, position, scale) {}
-
-		/*
-		 * @brief: This function sets an action (function pointer) to the OnClick function
-		 *
-		 * @param fun: A function pointer to a function (or lambda)
-		 */
-		void SetOnClickAction(void (*fun)()) { on_click_action = fun; }
-
-		/*
-		 * @brief: This function sets an action (function pointer) to the OnEnter function
-		 *
-		 * @param fun: A function pointer to a function (or lambda)
-		 */
-		void SetOnEnterAction(void (*fun)()) { on_enter_action = fun; }
-
-		/*
-		 * @brief: This function sets an action (function pointer) to the OnExit function
-		 *
-		 * @param fun: A function pointer to a function (or lambda)
-		 */
-		void SetOnExitAction(void (*fun)()) { on_exit_action = fun; }
-
-	protected:
-		void OnClick() override { if (on_click_action != nullptr) on_click_action(); }
-		void OnEnter() override { if (on_enter_action != nullptr) on_enter_action(); }
-		void OnExit() override { if (on_exit_action != nullptr) on_exit_action(); }
-	};
-}

src/main.cpp

@@ -1,29 +1,29 @@
 #include <GL/glew.h>
 #include <GLFW/glfw3.h>
 #include <glm/gtc/matrix_transform.hpp>
+#include <functional>
+#include <vector>
 #define STB_IMAGE_IMPLEMENTATION
-#include <iostream>
-#include <map>
-
 #include "stb_image.h"
 #include <ostream>
+#include <stdlib.h>
 
 #include <opencv2/core.hpp>
 #include <opencv2/videoio.hpp>
 #include <opencv2/video.hpp>
 
-#include "gui/gui_interactable.h"
 #include "models/model.h"
 #include "renderEngine/loader.h"
 #include "renderEngine/obj_loader.h"
 #include "renderEngine/renderer.h"
-#include "shaders/entity_shader.h"
+#include "shaders/static_shader.h"
 #include "toolbox/toolbox.h"
-#include "scenes/scene.h"
-#include "scenes/in_Game_Scene.h"
-#include "scenes/startup_Scene.h"
 
 #include "computervision/ObjectDetection.h"
+//#include "computervision/OpenPoseImage.h"
+#include "computervision/OpenPoseVideo.h"
+
+#include "computervision/async/async_arm_detection.h"
 
 #pragma comment(lib, "glfw3.lib")
 #pragma comment(lib, "glew32s.lib")
@@ -32,7 +32,17 @@
 static double UpdateDelta();
 
 static GLFWwindow* window;
-scene::Scene* current_scene;
+bool points_img_available = false;
+cv::Mat points_img;
+
+void retrieve_points(std::vector<Point> arm_points, cv::Mat points_on_image)
+{
+
+	std::cout << "got points!!" << std::endl;
+	std::cout << "points: " << arm_points << std::endl;
+	points_img = points_on_image;
+	points_img_available = true;
+}
 
 int main(void)
 {
@@ -50,50 +60,77 @@ int main(void)
 	glGetError();
 #pragma endregion
 
+	glfwSetKeyCallback(window, [](GLFWwindow* window, int key, int scancode, int action, int mods)
+		{
+			if (key == GLFW_KEY_ESCAPE)
+				glfwSetWindowShouldClose(window, true);
+		});
 
-    current_scene = new scene::Startup_Scene();
 
-    glfwSetKeyCallback(window, [](GLFWwindow* window, int key, int scancode, int action, int mods)
+	models::RawModel raw_model = LoadObjModel("res/Tree.obj");
-        {
+	models::ModelTexture texture = { render_engine::loader::LoadTexture("res/TreeTexture.png") };
-            if (key == GLFW_KEY_ESCAPE)
+	models::TexturedModel model = { raw_model, texture };
-            {
+	entities::Entity entity(model, glm::vec3(0, -5, -20), glm::vec3(0, 0, 0), 1);
-                glfwSetWindowShouldClose(window, true);
+
-            }
+	shaders::StaticShader shader;
+	shader.Init();
+	render_engine::renderer::Init(shader);
+
+	entities::Camera camera(glm::vec3(0, 0, 0), glm::vec3(0, 0, 0));
+
+	// create object detection object instance
+	computervision::ObjectDetection objDetect;
+	//computervision::OpenPoseImage openPoseImage;
+	computervision::OpenPoseVideo openPoseVideo;
+	openPoseVideo.setup();
+
+
+	// set up object detection
+	//objDetect.setup();
+	//cv::VideoCapture cam = objDetect.getCap();
+	cv::Mat img;
+	cv::VideoCapture cap = objDetect.getCap();
+	//cam.read(img);
+	//imshow("camera in main loop", img);
+
+
+	computervision::AsyncArmDetection as;
+
+	as.start(retrieve_points,openPoseVideo);
 	
-            current_scene->onKey(window, key, scancode, action, mods);
-        });
 
-    bool window_open = true;
 	// Main game loop
-	while (!glfwWindowShouldClose(window) && window_open)
+	while (!glfwWindowShouldClose(window))
 	{
-        //Update
+		// Update
-        const double delta = UpdateDelta();
+		const double delta = UpdateDelta();
+		entity.IncreaseRotation(glm::vec3(0, 1, 0));
+		camera.Move(window);
 
-        scene::Scenes return_value = current_scene->start(window);
+		// Render
-        delete current_scene;
+		render_engine::renderer::Prepare();
+		shader.Start();
+		shader.LoadViewMatrix(camera);
 
-        switch (return_value) {
-            case scene::Scenes::STOP:
-                window_open = false;
-                break;
 
-            case scene::Scenes::STARTUP:
+		render_engine::renderer::Render(entity, shader);
-                current_scene = new scene::Startup_Scene();
-                break;
 
-            case scene::Scenes::INGAME:
+		//objDetect.detectHand(cameraFrame);
-                current_scene = new scene::In_Game_Scene();
+		if (points_img_available)
-                break;
+		{
+			imshow("points", points_img);
+			points_img_available = false;
+		}
 
-            default:
+		// Finish up
-                std::cout << "Wrong return value!!! ->" << std::endl;
+		shader.Stop();
-                break;
+		glfwSwapBuffers(window);
-        }
+		glfwPollEvents();
 	}
 
-	// Clean up -> preventing memory leaks!!!
+	// Clean up
-    std::cout << "ending..." << std::endl;
+	shader.CleanUp();
+	render_engine::loader::CleanUp();
 	glfwTerminate();
 	return 0;
 }

src/models/Model.h

@@ -5,31 +5,24 @@
 namespace models
 {
 	/*
-		Structure for storing a vboID and vertex_count (this representa a mesh without a model).
+		Structure for storing a vboID and vertex_count.
 
-		vao_id = The openGL id of the model
+		This structure represents a Bare bones Model (A mesh without a texture).
-		vertex_count = The amount of vertices in the model
+		The vao_id, points to an ID stored by openGL and the
-		model_size = The size on each axis of the model
+		vertex_count is how many triangles in the mesh there are.
 	*/
 	struct RawModel
 	{
 		GLuint vao_id;
 		int vertex_count;
-		glm::vec3 model_size = { -1, -1, -1 };
 	};
 
 	/*
 		Structure for storing a texture (texture_id) to apply to a RawModel.
-
-		texture_id = The openGL id of the textures
-		shine_damper = A damper for the angle the model needs to be look at to see reflections
-		reflectivity = The amount of light the model reflects
 	*/
 	struct ModelTexture
 	{
 		GLuint texture_id;
-		float shine_damper = 1;
-		float reflectivity = 0;
 	};
 	
 	/*

src/renderEngine/Loader.cpp

@@ -1,10 +1,7 @@
 #include <GL/glew.h>
-#include <glm/vec3.hpp>
 #include "../stb_image.h"
 #include "loader.h"
 
-#include <iostream>
-
 namespace render_engine
 {
 	namespace loader
@@ -12,38 +9,22 @@ namespace render_engine
 		static GLuint CreateVao();
 		static void StoreDataInAttributeList(int attribute_number, int coordinate_size, std::vector<float>& data);
 		static void BindIndicesBuffer(std::vector<unsigned int>& indices);
-		static glm::vec3 GetSizeModel(std::vector<float>& positions);
 
 		static std::vector<GLuint> vaos;
 		static std::vector<GLuint> vbos;
 		static std::vector<GLuint> textures;
 
 		/*
-			This function will generate a Model from vertex positions, textureCoordinates normals and indices.
+			This function will generate a Model from vertex positions, textureCoordinates and indices.
 		*/
-		models::RawModel LoadToVAO(std::vector<float>& positions, std::vector<float>& texture_coords, std::vector<float>& normals, std::vector<unsigned int>& indices)
+		struct models::RawModel LoadToVAO(std::vector<float>& positions, std::vector<float>& texture_coords, std::vector<unsigned int>& indices)
 		{
-			const GLuint vao_id = CreateVao();
+			GLuint vao_id = CreateVao();
 			BindIndicesBuffer(indices);
 			StoreDataInAttributeList(0, 3, positions);
 			StoreDataInAttributeList(1, 2, texture_coords);
-			StoreDataInAttributeList(2, 3, normals);
 			glBindVertexArray(0);
-			
+			return { vao_id, static_cast<int>(indices.size()) };
-			const glm::vec3 model_size = GetSizeModel(positions);
-			
-			return { vao_id, static_cast<int>(indices.size()), model_size };
-		}
-
-		/*
-			This function will generate a Model from vertex positions.
-		*/
-		models::RawModel LoadToVAO(std::vector<float>& positions)
-		{
-			const GLuint vao_id = CreateVao();
-			StoreDataInAttributeList(0, 2, positions);
-			glBindVertexArray(0);
-			return { vao_id, static_cast<int>(positions.size()) / 2 };
 		}
 
 		/*
@@ -59,12 +40,6 @@ namespace render_engine
 			glEnable(GL_TEXTURE_2D);
 			glBindTexture(GL_TEXTURE_2D, texture_id);
 			glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, imgData);
-
-			// Set mipmapping with a constant LOD
-			glGenerateMipmap(GL_TEXTURE_2D);
-			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
-			glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_LOD_BIAS, -0.4f);
-
 			glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 			glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 			
@@ -138,72 +113,5 @@ namespace render_engine
 			glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo_id);
 			glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(int) * indices.size(), &indices[0], GL_STATIC_DRAW);
 		}
-
-		/**
-		* @brief gets the width, height and depth of a model
-		* @param positions all the points of a model
-		* @returns vec3<float> the size values of a model (width, height and depth)
-		**/
-		static glm::vec3 GetSizeModel(std::vector<float>& positions)
-		{
-			float minX = 100;
-			float maxX = -100;
-
-			float minY = 100;
-			float maxY = -100;
-
-			float minZ = 100;
-			float maxZ = -100;
-			
-			for (int i = 0; i < positions.size(); ++i)
-			{
-				const int index = i % 3;
-				const float value = positions[i];
-				
-				switch (index)
-				{
-				case 0: // x
-					{
-						if (value < minX)
-						{
-							minX = value;
-						} else if (value > maxX)
-						{
-							maxX = value;
-						}
-						break;
-					}
-				case 1: // y
-					{
-						if (value < minY)
-						{
-							minY = value;
-						}
-						else if (value > maxY)
-						{
-							maxY = value;
-						}
-						break;
-					}
-				case 2: // z
-				{
-					if (value < minZ)
-					{
-						minZ = value;
-					}
-					else if (value > maxZ)
-					{
-						maxZ = value;
-					}
-					break;
-				}
-				}
-			}
-
-			const float sizeX = maxX - minX;
-			const float sizeY = maxY - minY;
-			const float sizeZ = maxZ - minZ;
-			return { sizeX, sizeY, sizeZ };
-		}
 	}
 }

src/renderEngine/Loader.h

@@ -9,36 +9,17 @@ namespace render_engine
 	namespace loader
 	{
 		/*
-		*	@brief: This function generates a model from model data.
+			This function generates a model from model data.
-		*
-		*	@param position: The positions of each vertex (in order: x, y, z) in the model
-		*	@param texture_coords: The texture coordinates of the model
-		*	@param normals: The normals of each face of the model
-		*	@param indices: A list with a sort of lookup table to the positions parameter
-		*
-		*	@return: A new rawmodel which represents al the parameters in one struct
 		*/
-		models::RawModel LoadToVAO(std::vector<float>& positions, std::vector<float>& texture_coords, std::vector<float>& normals, std::vector<unsigned int>& indices);
+		struct models::RawModel LoadToVAO(std::vector<float>& positions, std::vector<float>& texture_coords, std::vector<unsigned int>& indices);
 
 		/*
-		 * @brief: Overloaded function of the function above, but does not need normals and indices.
+			Loads a texture from a file into openGL using stb_image.h
-		 *         Use this function to for example load GUI items to OpenGL.
-		 *
-		 * @param position: The positions of each vertex (in order: x, y, z) in the model
-		 *
-		 * @return: A new rawmodel which represents al the parameters in one struct
-		 */
-		models::RawModel LoadToVAO(std::vector<float>& positions);
-		
-		/*
-		*	@brief: Loads a texture from a file into openGL using stb_image.h
-		*
-		*	@param file_name: The filepath to the texture
 		 */
 		GLuint LoadTexture(std::string file_name);
 		
 		/*
-		*	@brief: Call this function when cleaning up all the meshes (when exiting the program).
+			Call this function when cleaning up all the meshes (when exiting the program).
 		*/
 		void CleanUp();
 	}

src/renderEngine/Renderer.cpp

@@ -1,11 +1,8 @@
 #include <GL/glew.h>
 #include <glm/gtc/matrix_transform.hpp>
 #include "../models/model.h"
-#include "loader.h"
-#include "../toolbox/toolbox.h"
 #include "renderer.h"
-
+#include "../toolbox/toolbox.h"
-#include <iostream>
 
 namespace render_engine
 {
@@ -15,27 +12,17 @@ namespace render_engine
 		static const float NEAR_PLANE = 0.01f;
 		static const float FAR_PLANE = 1000.0f;
 
-		// GUI variables
+		/*
-		static models::RawModel quad;
+			This function will load the projectionMatrix into the shader
-		
+		 */
-		
+		void Init(shaders::StaticShader& shader)
-		void Init(shaders::EntityShader& shader)
 		{
-			// Faces which are not facing the camera are not rendered
-			glEnable(GL_CULL_FACE);
-			glCullFace(GL_BACK);
-			
 			const glm::mat4 projectionMatrix = 
-				glm::perspective(glm::radians(FOV), (WINDOW_WIDTH / WINDOW_HEIGT), NEAR_PLANE, FAR_PLANE);
+				glm::perspective(glm::radians(FOV), (float)(WINDOW_WIDTH / WINDOW_HEIGT), NEAR_PLANE, FAR_PLANE);
 			
-			// Load the projectionmatrix into the shader
 			shader.Start();
 			shader.LoadProjectionMatrix(projectionMatrix);
 			shader.Stop();
-
-			// Initialize the quad for the GUI
-			std::vector<float> quad_positions = { -1, 1, -1, -1, 1, 1, 1, -1 };
-			quad = loader::LoadToVAO(quad_positions);
 		}
 
 		/*
@@ -45,82 +32,36 @@ namespace render_engine
 		{
 			glEnable(GL_DEPTH_TEST);
 			glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-			glClearColor(SKY_COLOR.r, SKY_COLOR.g, SKY_COLOR.b, 1.0f);
+			glClearColor(0.3f, 0.4f, 0.6f, 1.0f);
 		}
 
 		/*
 			This function will Render a Model on the screen.
 		*/
-		void Render(entities::Entity& entity, shaders::EntityShader& shader)
+		void Render(entities::Entity& entity, shaders::StaticShader& shader)
 		{
 			const models::TexturedModel model = entity.GetModel();
-			const models::RawModel raw_model = model.raw_model;
+			const models::RawModel rawModel = model.raw_model;
-			const models::ModelTexture texture = model.texture;
 
-			// Enable the model (VAO)
+			// Enable the model
-			glBindVertexArray(raw_model.vao_id);
+			glBindVertexArray(rawModel.vao_id);
 
-			// Enable the VBO's from the model (VAO)
+			// Enable the inputs for the vertexShader
 			glEnableVertexAttribArray(0);
 			glEnableVertexAttribArray(1);
-			glEnableVertexAttribArray(2);
 
 			// Load the transformation of the model into the shader
 			const glm::mat4 modelMatrix = toolbox::CreateModelMatrix(entity.GetPosition(), entity.GetRotation(), entity.GetScale());
 			shader.LoadModelMatrix(modelMatrix);
-			shader.LoadShineVariables(texture.shine_damper, texture.reflectivity);
 			
 			// Draw the model
 			glActiveTexture(GL_TEXTURE0);
 			glBindTexture(GL_TEXTURE_2D, model.texture.texture_id);
-			glDrawElements(GL_TRIANGLES, raw_model.vertex_count, GL_UNSIGNED_INT, 0);
+			glDrawElements(GL_TRIANGLES, rawModel.vertex_count, GL_UNSIGNED_INT, 0);
 			
-			// Disable the VBO's and model (VAO)
 			glDisableVertexAttribArray(0);
 			glDisableVertexAttribArray(1);
-			glDisableVertexAttribArray(2);
 			glBindVertexArray(0);
 		}
-
-		void Render(std::vector<gui::GuiTexture*>& guis, shaders::GuiShader& shader)
-		{
-			shader.Start();
-			
-			// Enable the VAO and the positions VBO
-			glBindVertexArray(quad.vao_id);
-			glEnableVertexAttribArray(0);
-
-			// Enable alpha blending (for transparency in the texture)
-			glEnable(GL_BLEND);
-			glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-
-			// Disable depth testing to textures with transparency can overlap
-			glDisable(GL_DEPTH_TEST);
-			
-			// Render each gui to the screen
-			for (gui::GuiTexture* gui : guis)
-			{				
-				// Bind the texture of the gui to the shader
-				glActiveTexture(GL_TEXTURE0);
-				glBindTexture(GL_TEXTURE_2D, gui->texture);
-
-				glm::mat4 matrix = toolbox::CreateModelMatrix(gui->position, gui->scale);
-				shader.LoadModelMatrix(matrix);
-				
-				glDrawArrays(GL_TRIANGLE_STRIP, 0, quad.vertex_count);
-			}
-
-			// Enable depth test again
-			glEnable(GL_DEPTH_TEST);
-			
-			// Disable alpha blending
-			glDisable(GL_BLEND);
-			
-			// Disable the VBO and VAO
-			glDisableVertexAttribArray(0);
-			glBindVertexArray(0);
-
-			shader.Stop();
-		}
 	}
 }

src/renderEngine/Renderer.h

@@ -1,43 +1,25 @@
 #pragma once
 
-#include "../gui/gui_element.h"
 #include "../entities/entity.h"
-#include "../shaders/entity_shader.h"
+#include "../shaders/static_shader.h"
-#include "../shaders/gui_shader.h"
 
 namespace render_engine
 {
 	namespace renderer
 	{
-		const glm::vec3 SKY_COLOR = { 0.3f, 0.4f, 0.6f };
-		
 		/*
-			@brief: Call this function when starting the program
+			Call this function when starting the program
-
-			@param shader: The shader to render the entities with
 		 */
-		void Init(shaders::EntityShader& shader);
+		void Init(shaders::StaticShader& shader);
 		
 		/*
-			@brief: Call this function before rendering.
+			Call this function before rendering. 
-					This function will enable culling and load the projectionMatrix into the shader.
 		*/
 		void Prepare();
 
 		/*
-			@brief: Call this function when wanting to Render a mesh to the screen.
+			Call this function when wanting to Render a mesh to the screen.
-
-			@param entity: The entity which needs to be rendered
-			@param shader: The shader the entity needs to be rendered with
 		*/
-		void Render(entities::Entity& entity, shaders::EntityShader& shader);
+		void Render(entities::Entity& entity, shaders::StaticShader& shader);
-
-		/*
-			@brief: Call this function to render gui_textures on the screen
-
-			@param guis:  A list with all the GUI textures you want to render
-			@param shade: The shader the GUI textures need to be rendered with
-		 */
-		void Render(std::vector<gui::GuiTexture*>& guis, shaders::GuiShader& shader);
 	}
 }

src/renderEngine/obj_loader.cpp

@@ -6,128 +6,124 @@
 #include "loader.h"
 #include "obj_loader.h"
 
-namespace render_engine
+static void Split(const std::string& s, char delim, std::vector<std::string>& elems)
 {
-    static void Split(const std::string& s, char delim, std::vector<std::string>& elems)
+    std::stringstream ss;
-    {
+    ss.str(s);
-        std::stringstream ss;
+    std::string item;
-        ss.str(s);
+    while (getline(ss, item, delim)) {
-        std::string item;
+        elems.push_back(item);
-        while (getline(ss, item, delim)) {
-            elems.push_back(item);
-        }
-    }
-
-    static std::vector<std::string> Split(const std::string& s, char delim)
-    {
-        std::vector<std::string> elems;
-        Split(s, delim, elems);
-        return elems;
-    }
-
-    static void ProcessVertex(const std::vector<std::string>& vertex_data,
-        const std::vector<glm::vec3>& normals,
-        const std::vector<glm::vec2>& textures,
-        std::vector<GLuint>& indices,
-        std::vector<GLfloat>& texture_array,
-        std::vector<GLfloat>& normal_array)
-    {
-        GLuint current_vertex_pointer = std::stoi(vertex_data.at(0)) - 1;
-        indices.push_back(current_vertex_pointer);
-
-        glm::vec2 current_texture = textures.at(std::stoi(vertex_data.at(1)) - 1);
-        texture_array[(current_vertex_pointer * 2) % texture_array.size()] = current_texture.x;
-        texture_array[(current_vertex_pointer * 2 + 1) % texture_array.size()] = 1 - current_texture.y;
-
-        glm::vec3 current_norm = normals.at(std::stoi(vertex_data.at(2)) - 1);
-        normal_array[current_vertex_pointer * 3] = current_norm.x;
-        normal_array[current_vertex_pointer * 3 + 1] = current_norm.y;
-        normal_array[current_vertex_pointer * 3 + 2] = current_norm.z;
-    }
-
-    models::RawModel LoadObjModel(std::string file_name)
-    {
-        std::ifstream inFile(file_name);
-        if (!inFile.is_open())
-        {
-            throw std::runtime_error("Could not open model file " + file_name + ".obj!");
-        }
-        std::vector<glm::vec3> vertices;
-        std::vector<glm::vec3> normals;
-        std::vector<glm::vec2> textures;
-        std::vector<GLuint> indices;
-        std::vector<GLfloat> vertex_array;
-        std::vector<GLfloat> normal_array;
-        std::vector<GLfloat> texture_array;
-        std::string line;
-
-        try
-        {
-            while (std::getline(inFile, line))
-            {
-                std::vector<std::string> split_line = Split(line, ' ');
-                if (split_line.at(0) == "v")
-                {
-                    glm::vec3 vertex;
-                    vertex.x = std::stof(split_line.at(1));
-                    vertex.y = std::stof(split_line.at(2));
-                    vertex.z = std::stof(split_line.at(3));
-                    vertices.push_back(vertex);
-                }
-                else if (split_line.at(0) == "vt")
-                {
-                    glm::vec2 texture;
-                    texture.x = std::stof(split_line.at(1));
-                    texture.y = std::stof(split_line.at(2));
-                    textures.push_back(texture);
-                }
-                else if (split_line.at(0) == "vn")
-                {
-                    glm::vec3 normal;
-                    normal.x = std::stof(split_line.at(1));
-                    normal.y = std::stof(split_line.at(2));
-                    normal.z = std::stof(split_line.at(3));
-                    normals.push_back(normal);
-                }
-                else if (split_line.at(0) == "f")
-                {
-                    normal_array = std::vector<GLfloat>(vertices.size() * 3);
-                    texture_array = std::vector<GLfloat>(textures.size() * 2);
-                    break;
-                }
-            }
-
-            while (true)
-            {
-                std::vector<std::string> split = Split(line, ' ');
-                std::vector<std::string> vertex1 = Split(split.at(1), '/');
-                std::vector<std::string> vertex2 = Split(split.at(2), '/');
-                std::vector<std::string> vertex3 = Split(split.at(3), '/');
-                ProcessVertex(vertex1, normals, textures, indices, texture_array, normal_array);
-                ProcessVertex(vertex2, normals, textures, indices, texture_array, normal_array);
-                ProcessVertex(vertex3, normals, textures, indices, texture_array, normal_array);
-                if (!std::getline(inFile, line))
-                {
-                    break;
-                }
-            }
-        }
-        catch (const std::exception& e)
-        {
-            // Always go in here
-        }
-
-        inFile.close();
-
-        vertex_array = std::vector<GLfloat>(vertices.size() * 3);
-        int p = 0;
-        for (auto& vertex : vertices)
-        {
-            vertex_array[p++] = vertex.x;
-            vertex_array[p++] = vertex.y;
-            vertex_array[p++] = vertex.z;
-        }
-
-        return render_engine::loader::LoadToVAO(vertex_array, texture_array, normal_array, indices);
     }
 }
+
+static std::vector<std::string> Split(const std::string& s, char delim)
+{
+    std::vector<std::string> elems;
+    Split(s, delim, elems);
+    return elems;
+}
+
+static void ProcessVertex(const std::vector<std::string>& vertex_data,
+    const std::vector<glm::vec3>& normals,
+    const std::vector<glm::vec2>& textures,
+    std::vector<GLuint>& indices,
+    std::vector<GLfloat>& texture_array,
+    std::vector<GLfloat>& normal_array)
+{
+    GLuint current_vertex_pointer = std::stoi(vertex_data.at(0)) - 1;
+    indices.push_back(current_vertex_pointer);
+
+    glm::vec2 current_texture = textures.at(std::stoi(vertex_data.at(1)) - 1);
+    texture_array[(current_vertex_pointer * 2) % texture_array.size()] = current_texture.x;
+    texture_array[(current_vertex_pointer * 2 + 1) % texture_array.size()] = 1 - current_texture.y;
+
+    glm::vec3 current_norm = normals.at(std::stoi(vertex_data.at(2)) - 1);
+    normal_array[current_vertex_pointer * 3] = current_norm.x;
+    normal_array[current_vertex_pointer * 3 + 1] = current_norm.y;
+    normal_array[current_vertex_pointer * 3 + 2] = current_norm.z;
+}
+
+models::RawModel LoadObjModel(std::string file_name)
+{
+    std::ifstream inFile (file_name);
+    if ( !inFile.is_open() ) 
+    {
+        throw std::runtime_error ( "Could not open model file " + file_name + ".obj!" );
+    }
+    std::vector<glm::vec3> vertices;
+    std::vector<glm::vec3> normals;
+    std::vector<glm::vec2> textures;
+    std::vector<GLuint> indices;
+    std::vector<GLfloat> vertex_array;
+    std::vector<GLfloat> normal_array;
+    std::vector<GLfloat> texture_array;
+    std::string line;
+	
+    try
+    {
+        while (std::getline(inFile, line))
+        {
+            std::vector<std::string> split_line = Split(line, ' ');
+            if (split_line.at(0) == "v")
+            {
+                glm::vec3 vertex;
+                vertex.x = std::stof(split_line.at(1));
+                vertex.y = std::stof(split_line.at(2));
+                vertex.z = std::stof(split_line.at(3));
+                vertices.push_back(vertex);
+            }
+            else if (split_line.at(0) == "vt")
+            {
+                glm::vec2 texture;
+                texture.x = std::stof(split_line.at(1));
+                texture.y = std::stof(split_line.at(2));
+                textures.push_back(texture);
+            }
+            else if (split_line.at(0) == "vn")
+            {
+                glm::vec3 normal;
+                normal.x = std::stof(split_line.at(1));
+                normal.y = std::stof(split_line.at(2));
+                normal.z = std::stof(split_line.at(3));
+                normals.push_back(normal);
+            }
+            else if (split_line.at(0) == "f")
+            {
+                normal_array = std::vector<GLfloat>(vertices.size() * 3);
+                texture_array = std::vector<GLfloat>(textures.size() * 2);
+                break;
+            }
+        }
+    	
+        while (true)
+        {
+            std::vector<std::string> split = Split(line, ' ');
+            std::vector<std::string> vertex1 = Split(split.at(1), '/');
+            std::vector<std::string> vertex2 = Split(split.at(2), '/');
+            std::vector<std::string> vertex3 = Split(split.at(3), '/');
+            ProcessVertex(vertex1, normals, textures, indices, texture_array, normal_array);
+            ProcessVertex(vertex2, normals, textures, indices, texture_array, normal_array);
+            ProcessVertex(vertex3, normals, textures, indices, texture_array, normal_array);
+            if (!std::getline(inFile, line))
+            {
+                break;
+            }
+        }
+    } catch (const std::exception& e)
+    {
+    	// Always go in here
+    }
+
+    inFile.close();
+	
+    vertex_array = std::vector<GLfloat>( vertices.size() * 3 );
+    int p = 0;
+    for ( auto& vertex : vertices ) 
+    {
+        vertex_array[p++] = vertex.x;
+        vertex_array[p++] = vertex.y;
+        vertex_array[p++] = vertex.z;
+    }
+
+    return render_engine::loader::LoadToVAO( vertex_array, texture_array, indices);
+}

src/renderEngine/obj_loader.h

@@ -3,12 +3,4 @@
 #include <string>
 #include "../models/model.h"
 
-namespace render_engine
+models::RawModel LoadObjModel(std::string file_name);
-{
-	/*
-	 * @brief: This function retrieves an .obj file, loads it into the VBO and returns a RawModel
-	 *
-	 * @param file_name: The path to the .obj file
-	 */
-	models::RawModel LoadObjModel(std::string file_name);
-}

src/scenes/in_Game_Scene.cpp

@@ -1,118 +0,0 @@
-#include <iostream>
-#include <GL/glew.h>
-#include <GLFW/glfw3.h>
-#include "in_Game_Scene.h"
-#include "startup_Scene.h"
-#include "../gui/gui_interactable.h"
-#include "../models/model.h"
-#include "../renderEngine/loader.h"
-#include "../renderEngine/obj_loader.h"
-#include "../renderEngine/renderer.h"
-#include "../shaders/entity_shader.h"
-#include "../toolbox/toolbox.h"
-
-
-namespace scene
-{
-	std::vector<entities::Entity> entities;
-	std::vector<entities::Light> lights;
-	models::RawModel raw_model;
-	models::ModelTexture texture;
-	shaders::EntityShader *shader;
-	shaders::GuiShader *gui_shader;
-	entities::Camera camera(glm::vec3(0, 0, 0), glm::vec3(0, 0, 0));
-	std::vector<gui::GuiTexture*> guis;
-
-	
-	In_Game_Scene::In_Game_Scene()
-	{
-		shader = new shaders::EntityShader;
-		shader->Init();	
-		render_engine::renderer::Init(*shader);
-
-		gui_shader = new shaders::GuiShader();
-		gui_shader->Init();
-	}
-
-	scene::Scenes scene::In_Game_Scene::start(GLFWwindow* window)
-	{
-		raw_model = render_engine::LoadObjModel("res/House.obj");
-		texture = { render_engine::loader::LoadTexture("res/Texture.png") };
-		texture.shine_damper = 10;
-		texture.reflectivity = 0;
-		models::TexturedModel model = { raw_model, texture };
-		
-		int z = 0;
-		for (int i = 0; i < 5; ++i)
-		{
-			entities.push_back(entities::Entity(model, glm::vec3(0, -50, -50 - z), glm::vec3(0, 90, 0), 20));
-			z += (raw_model.model_size.x * 20);
-		}
-
-		lights.push_back(entities::Light(glm::vec3(0, 1000, -7000), glm::vec3(5, 5, 5)));
-		lights.push_back(entities::Light(glm::vec3(0, 0, -30), glm::vec3(2, 0, 2), glm::vec3(0.0001f, 0.0001f, 0.0001f)));
-		lights.push_back(entities::Light(glm::vec3(0, 0, -200), glm::vec3(0, 2, 0), glm::vec3(0.0001f, 0.0001f, 0.0001f)));
-
-		// GUI stuff
-		gui::Button button(render_engine::loader::LoadTexture("res/Mayo.png"), glm::vec2(0.5f, 0.0f), glm::vec2(0.25f, 0.25f));
-		button.SetHoverTexture(render_engine::loader::LoadTexture("res/Texture.png"));
-		button.SetClickedTexture(render_engine::loader::LoadTexture("res/Mayo.png"));
-		button.SetOnClickAction([]()
-		{
-			std::cout << "I got clicked on!" << std::endl;
-		});
-		guis.push_back(&button);
-	
-
-		while (return_value == scene::Scenes::INGAME)
-		{
-			update(window);
-			button.Update(window);
-			render();
-
-			glfwSwapBuffers(window);
-			glfwPollEvents();
-		}
-		shader->CleanUp();
-		gui_shader->CleanUp();
-		render_engine::loader::CleanUp();
-		return return_value;
-	}
-
-	void scene::In_Game_Scene::render()
-	{
-		// Render
-		render_engine::renderer::Prepare();
-
-		shader->Start();
-		shader->LoadSkyColor(render_engine::renderer::SKY_COLOR);
-		shader->LoadLights(lights);
-		shader->LoadViewMatrix(camera);
-
-		// Renders each entity in the entities list
-		for (entities::Entity& entity : entities)
-		{
-			render_engine::renderer::Render(entity, *shader);
-		}
-
-		// Render GUI items
-		render_engine::renderer::Render(guis, *gui_shader);
-
-		// Stop rendering the entities
-		shader->Stop();
-	}
-
-	void scene::In_Game_Scene::update(GLFWwindow* window)
-	{
-		camera.Move(window);
-	}
-
-	void scene::In_Game_Scene::onKey(GLFWwindow* window, int key, int scancode, int action, int mods)
-	{
-		if (glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS)
-		{
-			return_value = scene::Scenes::STOP;
-		}
-	}
-
-}

src/scenes/in_Game_Scene.h

@@ -1,22 +0,0 @@
-#pragma once
-#include "scene.h"
-
-namespace scene
-{
-
-	class In_Game_Scene : public scene::Scene
-	{
-	private:
-		scene::Scenes return_value = scene::Scenes::INGAME;
-	
-	public:
-		In_Game_Scene();
-
-		Scenes start(GLFWwindow* window) override;
-		void render() override;
-		void update(GLFWwindow* window) override;
-		void onKey(GLFWwindow* window, int key, int scancode, int action, int mods) override;
-	};
-}
-
-

src/scenes/scene.h

@@ -1,31 +0,0 @@
-#pragma once
-#include <GL/glew.h>
-#include <GLFW/glfw3.h>
-#include <map>
-
-
-namespace scene {
-
-	enum class Scenes
-	{
-		STARTUP,
-		INGAME,
-		GAMEOVER,
-		CALIBRATION,
-		STOP
-	};
-
-	class Scene
-	{
-	public:
-		virtual Scenes start(GLFWwindow* window) = 0;
-		virtual void render() = 0;
-		virtual void update(GLFWwindow* window) = 0;
-		virtual void onKey(GLFWwindow* window, int key, int scancode, int action, int mods) {};
-
-	};
-
-	
-}
-
-

src/scenes/startup_Scene.cpp

@@ -1,40 +0,0 @@
-#include <GL/glew.h>
-#include <GLFW/glfw3.h>
-#include <map>
-#include "startup_Scene.h"
-
-namespace scene
-{
-
-	scene::Scenes scene::Startup_Scene::start(GLFWwindow *window)
-	{
-		while (return_value == scene::Scenes::STARTUP)
-		{
-			render();
-			update(window);
-
-			glfwSwapBuffers(window);
-			glfwPollEvents();
-		}
-
-		return return_value;
-	}
-
-	void scene::Startup_Scene::render() 
-	{
-
-	}
-
-	void scene::Startup_Scene::update(GLFWwindow* window)
-	{
-
-	}
-
-	void scene::Startup_Scene::onKey(GLFWwindow* window, int key, int scancode, int action, int mods)
-	{
-		if (glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS)
-		{
-			return_value = scene::Scenes::INGAME;
-		}
-	}
-}

src/scenes/startup_Scene.h

@@ -1,22 +0,0 @@
-#pragma once
-#include "scene.h"
-#include <map>
-
-namespace scene
-{
-	extern GLFWwindow* window;
-
-	class Startup_Scene : public scene::Scene
-	{
-	private:
-		scene::Scenes return_value = scene::Scenes::STARTUP;
-
-	public:
-		Scenes start(GLFWwindow* window) override;
-		void render() override;
-		void update(GLFWwindow* window) override;
-		void onKey(GLFWwindow* window, int key, int scancode, int action, int mods) override;
-	};
-}
-
-

src/shaders/entity_shader.cpp

@@ -1,204 +0,0 @@
-#include "entity_shader.h"
-#include "../toolbox/toolbox.h"
-
-namespace shaders
-{
-	static std::string vertex_shader = R"(
-	#version 400 core
-	// The VertexShader is run for each vertex on the screen.
-
-
-	// Position of the vertex
-	in vec3 position;
-	// Coordinates of the texture
-	in vec2 texture_coords;
-	// The normal of the vertex
-	in vec3 normal;
-
-	// Equal to the texture_coords
-	out vec2 pass_texture_coords;
-	out vec3 surface_normal;
-	out vec3 to_light_vector[4];
-	out vec3 to_camera_vector;
-	out float visibility;
-
-	uniform mat4 model_matrix;
-	uniform mat4 projection_matrix;
-	uniform mat4 view_matrix;
-	uniform vec3 light_position[4];
-
-	const float density = 0.0017;
-	const float gradient = 4;
-	
-	void main(void)
-	{
-		// Calculate the real position of the vertex (after rotation and scaling)
-		vec4 world_position = model_matrix * vec4(position, 1.0);
-
-		vec4 position_rel_to_cam = view_matrix * world_position;
-	
-		// Tell OpenGL where to render the vertex
-		gl_Position = projection_matrix * position_rel_to_cam;
-
-		// Pass the textureCoords directly to the fragment shader
-		pass_texture_coords = texture_coords;
-
-		surface_normal = (model_matrix * vec4(normal, 0.0)).xyz;
-		for (int i = 0; i < 4; i++)
-		{
-			to_light_vector[i] = light_position[i] - world_position.xyz;
-		}
-		to_camera_vector = (inverse(view_matrix) * vec4(0.0, 0.0, 0.0, 1.0)).xyz - world_position.xyz;
-
-		// Calculate the density/visibility of the vertex with the fog
-		float distance = length(position_rel_to_cam.xyz);
-		visibility = exp(-pow((distance * density), gradient));
-		visibility = clamp(visibility, 0.0, 1.0);
-	}
-	)";
-	
-
-	static std::string fragment_shader = R"(
-	#version 400 core
-	// The FragmentShader is run for each pixel in a face on the screen.
-
-
-	// Interpolated textureCoordinates of the vertex (relative to the distance to each vertex)
-	in vec2 pass_texture_coords;
-
-	in vec3 surface_normal;
-	in vec3 to_light_vector[4];
-	in vec3 to_camera_vector;
-	in float visibility;
-
-	// Final color of the pixel
-	out vec4 out_color;
-
-	// The texture of the model
-	uniform sampler2D model_texture;
-
-	uniform vec3 light_color[4];
-	uniform vec3 attenuation[4];
-	uniform float shine_damper;
-	uniform float reflectivity;
-	uniform vec3 sky_color;
-
-	const float min_diffuse_lighting = 0.1;
-	
-	void main(void)
-	{
-		vec3 unit_normal = normalize(surface_normal);
-		vec3 unit_camera_vector = normalize(to_camera_vector);
-
-		vec3 total_diffuse = vec3(0.0);
-		vec3 total_specular = vec3(0.0);
-	
-		for (int i = 0; i < 4; i++)
-		{
-			float distance = length(to_light_vector[i]);
-			float att_factor = attenuation[i].x + (attenuation[i].y * distance) + (attenuation[i].z * distance * distance);
-	
-			vec3 unit_light_vector = normalize(to_light_vector[i]);
-
-			// Calculate the diffuse lighting
-			float dot_diffuse = dot(unit_normal, unit_light_vector);
-			float brightness = max(dot_diffuse, 0.0);
-
-			// Calculate the specular lighting
-			vec3 light_direction = -unit_light_vector;
-			vec3 reflected_light_direction = reflect(light_direction, unit_normal);
-			float dot_specular = dot(reflected_light_direction, unit_camera_vector);
-			dot_specular = max(dot_specular, 0.0);
-			float damped_specular = pow(dot_specular, shine_damper);
-		
-			total_diffuse = total_diffuse + (brightness * light_color[i]) / att_factor;
-			total_specular = total_specular + (damped_specular * reflectivity * light_color[i]) / att_factor;
-		}
-
-		total_diffuse = max(total_diffuse, min_diffuse_lighting);
-	
-		out_color = vec4(total_diffuse, 1.0) * texture(model_texture, pass_texture_coords) + vec4(total_specular, 1.0);
-		out_color = mix(vec4(sky_color, 1.0), out_color, visibility);
-	}
-	)";
-	
-	
-	EntityShader::EntityShader(): ShaderProgram(vertex_shader, fragment_shader)
-	{ }
-
-	void EntityShader::LoadModelMatrix(const glm::mat4& matrix) const
-	{
-		LoadMatrix(location_model_matrix, matrix);
-	}
-
-	void EntityShader::LoadProjectionMatrix(const glm::mat4& projection) const
-	{
-		LoadMatrix(location_projection_matrix, projection);
-	}
-
-	void EntityShader::LoadViewMatrix(entities::Camera& camera) const
-	{
-		const glm::mat4 view_matrix = toolbox::CreateViewMatrix(camera);
-		LoadMatrix(location_view_matrix, view_matrix);
-	}
-
-	void EntityShader::LoadLights(std::vector<entities::Light>& lights) const
-	{
-		for (int i = 0; i < MAX_LIGHTS; ++i)
-		{
-			if (i < lights.size())
-			{
-				LoadVector(location_light_position[i], lights[i].GetPosition());
-				LoadVector(location_light_color[i], lights[i].GetColor());
-				LoadVector(location_light_attenuation[i], lights[i].GetAttenuation());
-			} else
-			{
-				LoadVector(location_light_position[i], glm::vec3(0, 0, 0));
-				LoadVector(location_light_color[i], glm::vec3(0, 0, 0));
-				LoadVector(location_light_attenuation[i], glm::vec3(1, 0, 0));
-			}
-		}
-	}
-
-	void EntityShader::LoadShineVariables(float shine_damper, float reflectivity) const
-	{
-		LoadFloat(location_shine_damper, shine_damper);
-		LoadFloat(location_reflectivity, reflectivity);
-	}
-
-	void EntityShader::LoadSkyColor(glm::vec3 sky_color) const
-	{
-		LoadVector(location_sky_color, sky_color);
-	}
-
-	void EntityShader::SetAttributes() const
-	{
-		// Load the position VBO and textureCoords VBO from the VAO into the shader "in" variables
-		SetAttribute(0, "position");
-		SetAttribute(1, "texture_coords");
-		SetAttribute(2, "normal");
-	}
-
-	void EntityShader::GetAllUniformLocations()
-	{
-		// Get the locations from the uniform variables from the shaders
-		location_model_matrix = GetUniformLocation("model_matrix");
-		location_projection_matrix = GetUniformLocation("projection_matrix");
-		location_view_matrix = GetUniformLocation("view_matrix");
-		location_shine_damper = GetUniformLocation("shine_damper");
-		location_reflectivity = GetUniformLocation("reflectivity");
-		location_sky_color = GetUniformLocation("sky_color");
-
-		for (int i = 0; i < MAX_LIGHTS; ++i)
-		{
-			std::string light_pos = std::string("light_position[") + std::to_string(i) + "]";
-			location_light_position[i] = GetUniformLocation(light_pos.c_str());
-
-			std::string light_color = std::string("light_color[") + std::to_string(i) + "]";
-			location_light_color[i] = GetUniformLocation(light_color.c_str());
-
-			std::string light_attenuation = std::string("attenuation[") + std::to_string(i) + "]";
-			location_light_attenuation[i] = GetUniformLocation(light_attenuation.c_str());
-		}
-	}
-}

src/shaders/entity_shader.h

@@ -1,80 +0,0 @@
-#pragma once
-
-#include <glm/gtc/matrix_transform.hpp>
-#include <vector>
-#include "shader_program.h"
-#include "../entities/camera.h"
-#include "../entities/light.h"
-
-/*
-	This class handles the shaders for the entities.
- */
-
-namespace shaders
-{	
-	class EntityShader : public ShaderProgram
-	{
-	private:
-		const static int MAX_LIGHTS = 4;
-		
-		GLuint location_model_matrix;
-		GLuint location_projection_matrix;
-		GLuint location_view_matrix;
-		GLuint location_light_position[MAX_LIGHTS];
-		GLuint location_light_color[MAX_LIGHTS];
-		GLuint location_light_attenuation[MAX_LIGHTS];
-		GLuint location_shine_damper;
-		GLuint location_reflectivity;
-		GLuint location_sky_color;
-		
-	public:
-		EntityShader();
-
-		/*
-		 * @brief: A method to load the model matrix into the shader
-		 *
-		 * @param matrix: The model matrix
-		 */
-		void LoadModelMatrix(const glm::mat4& matrix) const;
-
-		/*
-		 * @brief: A method to load the projection matrix into the shader
-		 *
-		 * @param projection: The projection matrix
-		 */
-		void LoadProjectionMatrix(const glm::mat4& projection) const;
-
-		/*
-		 * @brief: A method to load the view matrix (camera) into the shader
-		 *
-		 * @param camera: The camera which the scene needs to be rendered from
-		 */
-		void LoadViewMatrix(entities::Camera& camera) const;
-
-		/*
-		 * @brief: A method to load some lights into the shader
-		 *
-		 * @param lights: The lights
-		 */
-		void LoadLights(std::vector<entities::Light>& lights) const;
-
-		/*
-		 * @brief: A method to load the the shine variables from a model into the shader
-		 *
-		 * @param shine_damper: The dampening of the angle from when to render reflectivity on the vertex
-		 * @param reflectivity: The amount the model reflects
-		 */
-		void LoadShineVariables(float shine_damper, float reflectivity) const;
-
-		/*
-		 * @brief: A method to load the sky color into the shader. This color will be used for the fog
-		 *
-		 * @param sky_color: The color of the sky
-		 */
-		void LoadSkyColor(glm::vec3 sky_color) const;
-			
-	protected:
-		void SetAttributes() const override;
-		void GetAllUniformLocations() override;
-	};
-}

src/shaders/gui_shader.cpp

@@ -1,57 +0,0 @@
-#include "gui_shader.h"
-
-namespace shaders
-{
-	static std::string vertex_shader = R"(
-	#version 140
-
-	in vec2 position;
-
-	out vec2 texture_coords;
-
-	uniform mat4 model_matrix;
-
-	void main(void)
-	{
-		gl_Position = model_matrix * vec4(position, 0.0, 1.0);
-	
-		// This makes top left corner coordinate (0, 0) and bottom right (1, 1)
-		texture_coords = vec2((position.x + 1.0) / 2.0, 1 - (position.y + 1.0) / 2.0);
-	}
-	)";
-
-
-	static std::string fragment_shader = R"(
-	#version 140
-
-	in vec2 texture_coords;
-
-	out vec4 out_color;
-
-	uniform sampler2D gui_texture;
-
-	void main(void)
-	{
-		out_color = texture(gui_texture, texture_coords);
-	}
-	)";
-
-	
-	GuiShader::GuiShader() : ShaderProgram(vertex_shader, fragment_shader)
-	{ }
-
-	void GuiShader::LoadModelMatrix(const glm::mat4& matrix) const
-	{
-		LoadMatrix(location_model_matrix, matrix);
-	}
-
-	void GuiShader::SetAttributes() const
-	{
-		SetAttribute(0, "position");
-	}
-
-	void GuiShader::GetAllUniformLocations()
-	{
-		location_model_matrix = GetUniformLocation("model_matrix");
-	}
-}

src/shaders/gui_shader.h

@@ -1,31 +0,0 @@
-#pragma once
-
-#include <glm/gtc/matrix_transform.hpp>
-#include "shader_program.h"
-
-namespace shaders
-{
-	/*
-	 * This class handles the shaders for all the GUI items
-	 */
-	
-	class GuiShader : public ShaderProgram
-	{
-	private:
-		GLuint location_model_matrix;
-
-	public:
-		GuiShader();
-
-		/*
-		 * @brief: A method to load the model matrix into the shader
-		 *
-		 * @param matrix: The model matrix
-		 */
-		void LoadModelMatrix(const glm::mat4& matrix) const;
-
-	protected:
-		void SetAttributes() const override;
-		void GetAllUniformLocations() override;
-	};
-}

src/shaders/shader_program.cpp

@@ -1,5 +1,4 @@
 #include <GL/glew.h>
-#include <GLFW/glfw3.h>
 #include <iostream>
 #include <fstream>
 #include <vector>

src/shaders/shader_program.h

@@ -21,87 +21,29 @@ namespace shaders
 		ShaderProgram(std::string& vertex_shader, std::string& fragment_shader);
 		virtual ~ShaderProgram() = default;
 
-		/*
+		// Call this function after making the shaderprogram (sets all the attributes of the shader)
-		 * @brief: Call this function after making the shaderprogram (sets all the attributes of the shader)
-		 */
 		void Init();
-
+		// Call this function before rendering
-		/*
-		 * @brief: Call this function before rendering
-		 */
 		void Start() const;
-
+		// Call this function after rendering
-		/*
-		 * @brief: Call this function after rendering
-		 */
 		void Stop() const;
-		
+		// Call this function when closing the application
-		/*
-		 * @brief: Call this function when closing the application
-		 */
 		void CleanUp() const;
 
 	protected:
-		/*
+		// Set the inputs of the vertex shader
-		 * @brief: Set the inputs of the vertex shader
-		 */
 		virtual void SetAttributes() const = 0;
-
-		/*
-		 * @brief: Sets/binds a input variable (in) to a VBO from the model
-		 *
-		 * @param attribute: The id of the VBO
-		 * @param variable_name: The name of the "in" variable in the shader
-		 */
 		void SetAttribute(const GLuint attribute, const char* variable_name) const;
 
-		/*
+		// Loads value's (uniform variables) into the shader
-		 * @brief: This function loads a float value into a uniform variable into the shader
-		 *
-		 * @param location: The location of the variable in openGL
-		 * @param value: The value which will be loaded into the variable
-		 */
 		void LoadFloat(GLuint location, GLfloat value) const;
-
-		/*
-		 * @brief: This function loads a vector value into a uniform variable into the shader
-		 *
-		 * @param location: The location of the variable in openGL
-		 * @param vector: The value which will be loaded into the variable
-		 */
 		void LoadVector(GLuint location, glm::vec3 vector) const;
-
-		/*
-		 * @brief: This function loads a 4x4 matrix value into a uniform variable into the shader
-		 *
-		 * @param location: The location of the variable in openGL
-		 * @param matrix: The value which will be loaded into the variable
-		 */
 		void LoadMatrix(GLuint location, glm::mat4 matrix) const;
 		
-		/*
-		 * @brief: This function will get all the locations of each uniform variable
-		 */
 		virtual void GetAllUniformLocations() = 0;
-
-		/*
-		 * @brief: This function will retrieve the location of a uniform variable
-		 *
-		 * @param uniform_name: The name of the uniform variable
-		 *
-		 * @return: The location of the uniform variable
-		 */
 		GLuint GetUniformLocation(const GLchar* uniform_name) const;
 	
 	private:
-		/*
-		 * @brief: This function will load a shader into openGL
-		 *
-		 * @param shader_string: The shader as a string (the whole code)
-		 * @param type: The type of the shader (Vertex/Fragment)
-		 *
-		 * @return: The id of the shader given by openGL
-		 */
 		GLuint LoadShader(const std::string& shader_string, GLuint type) const;
 	};
 }

src/shaders/static_shader.cpp

@@ -0,0 +1,87 @@
+#include "static_shader.h"
+#include "../toolbox/toolbox.h"
+
+namespace shaders
+{
+	static std::string vertex_shader = R"(
+	#version 400 core
+	// The VertexShader is run for each vertex on the screen.
+
+
+	// Position of the vertex
+	in vec3 position;
+	// Coordinates of the texture
+	in vec2 texture_coords;
+
+	// Equal to the texture_coords
+	out vec2 pass_texture_coords;
+
+	uniform mat4 model_matrix;
+	uniform mat4 projection_matrix;
+	uniform mat4 view_matrix;
+
+	void main(void)
+	{
+		// Tell OpenGL where to render the vertex
+		gl_Position = projection_matrix * view_matrix * model_matrix * vec4(position, 1.0);
+
+		// Pass the texture_coords directly to the fragment shader
+		pass_texture_coords = texture_coords;
+	}
+	)";
+	
+
+	static std::string fragment_shader = R"(
+	#version 400 core
+	// The FragmentShader is run for each pixel in a face on the screen.
+
+
+	// Interpolated textureCoordinates of the vertex (relative to the distance to each vertex)
+	in vec2 pass_texture_coords;
+
+	// Final color of the pixel
+	out vec4 out_color;
+
+	// The texture of the model
+	uniform sampler2D texture_sampler;
+
+	void main(void)
+	{
+		out_color = texture(texture_sampler, pass_texture_coords);
+	}
+	)";
+	
+	
+	StaticShader::StaticShader(): ShaderProgram(vertex_shader, fragment_shader)
+	{
+	}
+
+	void StaticShader::LoadModelMatrix(const glm::mat4& matrix) const
+	{
+		LoadMatrix(location_model_matrix, matrix);
+	}
+
+	void StaticShader::LoadProjectionMatrix(const glm::mat4& projection) const
+	{
+		LoadMatrix(location_projection_matrix, projection);
+	}
+
+	void StaticShader::LoadViewMatrix(entities::Camera& camera) const
+	{
+		const glm::mat4 view_matrix = toolbox::CreateViewMatrix(camera);
+		LoadMatrix(location_view_matrix, view_matrix);
+	}
+
+	void StaticShader::SetAttributes() const
+	{
+		SetAttribute(0, "position");
+		SetAttribute(1, "texture_coords");
+	}
+
+	void StaticShader::GetAllUniformLocations()
+	{
+		location_model_matrix = GetUniformLocation("model_matrix");
+		location_projection_matrix = GetUniformLocation("projection_matrix");
+		location_view_matrix = GetUniformLocation("view_matrix");
+	}
+}

src/shaders/static_shader.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <glm/gtc/matrix_transform.hpp>
+#include "shader_program.h"
+#include "../entities/camera.h"
+
+/*
+	This class does represents the shaders for the models.
+ */
+
+namespace shaders
+{	
+	class StaticShader : public ShaderProgram
+	{
+	private:
+		GLuint location_model_matrix;
+		GLuint location_projection_matrix;
+		GLuint location_view_matrix;
+		
+	public:
+		StaticShader();
+
+		void LoadModelMatrix(const glm::mat4& matrix) const;
+		void LoadProjectionMatrix(const glm::mat4& projection) const;
+		void LoadViewMatrix(entities::Camera& camera) const;
+			
+	protected:
+		void SetAttributes() const override;
+		void GetAllUniformLocations() override;
+	};
+}

src/toolbox/Timer.h

@@ -1,46 +0,0 @@
-#pragma once
-
-namespace toolbox
-{
-	/*
-	 * This class represents a timer which needs to be updated
-	 * every frame to work correctly.
-	 */
-	class Timer
-	{
-	private:
-		float current_time;
-		float final_time;
-		bool has_finished;
-
-	public:
-		/*
-		 * @brief: Constructor to make the timer
-		 *
-		 * @param final_time: The time which the timer needs to count to
-		 */
-		Timer(float final_time): current_time(0), final_time(final_time), has_finished(false) {}
-
-		/*
-		 * @brief: Updates the timer. Call this method once every iteration in the game loop
-		 *
-		 * @param delta: The deltatime of the game
-		 */
-		void UpdateTimer(const double delta)
-		{
-			current_time += delta;
-			
-			if (current_time >= final_time)
-			{
-				has_finished = true;
-			}
-		}
-
-		/*
-		 * @brief: Returns if the timer has finished
-		 *
-		 * @return: True if the timer has finished 
-		 */
-		bool HasFinished() const { return has_finished; }
-	};
-}

src/toolbox/toolbox.cpp

@@ -2,14 +2,6 @@
 
 namespace toolbox
 {
-	glm::mat4 CreateModelMatrix(glm::vec2 translation, glm::vec2 scale)
-	{
-		glm::mat4 matrix(1.0f);
-		matrix = glm::translate(matrix, glm::vec3(translation.x, translation.y, 0));
-		matrix = glm::scale(matrix, glm::vec3(scale.x, scale.y, 0));
-		return matrix;
-	}
-
 	glm::mat4 CreateModelMatrix(glm::vec3 translation, glm::vec3 rotation, float scale)
 	{
 		glm::mat4 matrix(1.0f);

src/toolbox/toolbox.h

@@ -5,45 +5,10 @@
 
 namespace toolbox
 {
-	// Window macro's
+	#define WINDOW_WIDTH 1400
-	    #define DEFAULT_WIDTH 1920
+	#define WINDOW_HEIGT 800
-		#define DEFAULT_HEIGHT 1080
 	
-		// Change these macros to change the window size
-		#define WINDOW_WIDTH 1400.0f
-		#define WINDOW_HEIGT 800.0f
-
-		#define SCALED_WIDTH (WINDOW_WIDTH/DEFAULT_WIDTH)
-		#define SCALED_HEIGHT (WINDOW_HEIGT/DEFAULT_HEIGHT)
-	//
-	
-	/*
-	 * @brief: This function will create a model matrix
-	 *
-	 * @param translation: The position of the model
-	 * @param scale: The scale of the model
-	 *
-	 * @return: The model matrix of the model
-	 */
-	glm::mat4 CreateModelMatrix(glm::vec2 translation, glm::vec2 scale);
-	
-	/*
-	 * @brief: This function will create a model matrix
-	 *
-	 * @param translation: The position of the model
-	 * @param rotation: The rotation of the model
-	 * @param scale: The scale of the model
-	 *
-	 * @return: The model matrix of the model
-	 */
 	glm::mat4 CreateModelMatrix(glm::vec3 translation, glm::vec3 rotation, float scale);
 
-	/*
-	 * @brief: This function will create a view matrix from the camera's position
-	 *
-	 * @param camera: The camera the view matrix needs to be made from
-	 *
-	 * @return: The view matrix
-	 */
 	glm::mat4 CreateViewMatrix(entities::Camera& camera);
 }

wk2_fps.vcxproj

@@ -19,58 +19,52 @@
     </ProjectConfiguration>
   </ItemGroup>
   <ItemGroup>
-    <ClCompile Include="src\collision\collision_handler.cpp" />
+    <ClCompile Include="src\computervision\async\async_arm_detection.cpp" />
-    <ClCompile Include="src\scenes\in_Game_Scene.cpp" />
     <ClCompile Include="src\computervision\FaceDetector.cpp" />
     <ClCompile Include="src\computervision\ObjectDetection.cpp" />
+    <ClCompile Include="src\computervision\OpenPoseVideo.cpp" />
     <ClCompile Include="src\computervision\SkinDetector.cpp" />
     <ClCompile Include="src\computervision\FingerCount.cpp" />
     <ClCompile Include="src\computervision\BackgroundRemover.cpp" />
     <ClCompile Include="src\entities\camera.cpp" />
-    <ClCompile Include="src\entities\collision_entity.cpp" />
     <ClCompile Include="src\entities\entity.cpp" />
-    <ClCompile Include="src\gui\gui_interactable.cpp" />
     <ClCompile Include="src\main.cpp" />
     <ClCompile Include="src\renderEngine\loader.cpp" />
     <ClCompile Include="src\renderEngine\obj_loader.cpp" />
     <ClCompile Include="src\renderEngine\renderer.cpp" />
-    <ClCompile Include="src\shaders\gui_shader.cpp" />
     <ClCompile Include="src\shaders\shader_program.cpp" />
-    <ClCompile Include="src\shaders\entity_shader.cpp" />
+    <ClCompile Include="src\shaders\static_shader.cpp" />
     <ClCompile Include="src\toolbox\toolbox.cpp" />
-    <ClCompile Include="src\scenes\startup_Scene.cpp" />
   </ItemGroup>
   <ItemGroup>
-    <ClInclude Include="src\collision\collision.h" />
+    <ClInclude Include="src\computervision\async\async_arm_detection.h" />
-    <ClInclude Include="src\collision\collision_handler.h" />
+    <ClInclude Include="src\computervision\async\StaticCameraInstance.h" />
-    <ClInclude Include="src\scenes\in_Game_Scene.h" />
-    <ClInclude Include="src\scenes\scene.h" />
     <ClInclude Include="src\computervision\FaceDetector.h" />
     <ClInclude Include="src\computervision\FingerCount.h" />
     <ClInclude Include="src\computervision\BackgroundRemover.h" />
+    <ClInclude Include="src\computervision\OpenPoseVideo.h" />
     <ClInclude Include="src\computervision\SkinDetector.h" />
     <ClInclude Include="src\computervision\ObjectDetection.h" />
     <ClInclude Include="src\entities\camera.h" />
-    <ClInclude Include="src\entities\collision_entity.h" />
     <ClInclude Include="src\entities\entity.h" />
-    <ClInclude Include="src\entities\light.h" />
-    <ClInclude Include="src\gui\gui_element.h" />
-    <ClInclude Include="src\gui\gui_interactable.h" />
     <ClInclude Include="src\models\model.h" />
     <ClInclude Include="src\renderEngine\loader.h" />
     <ClInclude Include="src\renderEngine\obj_loader.h" />
     <ClInclude Include="src\renderEngine\renderer.h" />
-    <ClInclude Include="src\shaders\gui_shader.h" />
     <ClInclude Include="src\shaders\shader_program.h" />
-    <ClInclude Include="src\shaders\entity_shader.h" />
+    <ClInclude Include="src\shaders\static_shader.h" />
     <ClInclude Include="src\stb_image.h" />
-    <ClInclude Include="src\toolbox\Timer.h" />
     <ClInclude Include="src\toolbox\toolbox.h" />
-    <ClInclude Include="src\scenes\startup_Scene.h" />
   </ItemGroup>
   <ItemGroup>
     <Xml Include="res\haarcascade_frontalface_alt.xml" />
   </ItemGroup>
+  <ItemGroup>
+    <None Include="..\..\Avans Hogeschool\Kim Veldhoen - Proftaak 2.4\pose_iter_160000.caffemodel" />
+    <None Include="res\pose\coco\pose_deploy_linevec.prototxt" />
+    <None Include="res\pose\mpi\pose_deploy_linevec_faster_4_stages.prototxt" />
+    <None Include="res\pose\mpi\pose_iter_160000.caffemodel" />
+  </ItemGroup>
   <PropertyGroup Label="Globals">
     <VCProjectVersion>16.0</VCProjectVersion>
     <ProjectGuid>{A7ECF1BE-DB22-4BF7-BFF6-E3BF72691EE6}</ProjectGuid>
@@ -129,16 +123,16 @@
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <LinkIncremental>true</LinkIncremental>
-    <IncludePath>C:\opencv\build\include;$(IncludePath);C:\opencv\opencv\build\include;C:\opencv\build\include</IncludePath>
+    <IncludePath>C:\opencv\build\include;$(IncludePath);C:\opencv\opencv\build\include</IncludePath>
-    <LibraryPath>C:\opencv\build\x64\vc15\lib;$(LibraryPath);C:\opencv\opencv\build\x64\vc15\lib;C:\opencv\build\x64\vc15\lib</LibraryPath>
+    <LibraryPath>C:\opencv\build\x64\vc15\lib;$(LibraryPath);C:\opencv\opencv\build\x64\vc15\lib</LibraryPath>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <LinkIncremental>false</LinkIncremental>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <LinkIncremental>false</LinkIncremental>
-    <IncludePath>$(VC_IncludePath);$(WindowsSDK_IncludePath);;C:\opencv\opencv\build\include;C:\opencv\build\include</IncludePath>
+    <IncludePath>C:\opencv\build\include\;$(VC_IncludePath);$(WindowsSDK_IncludePath);C:\opencv\opencv\build\include</IncludePath>
-    <LibraryPath>$(VC_LibraryPath_x64);$(WindowsSDK_LibraryPath_x64);C:\opencv\opencv\build\x64\vc15\lib;C:\opencv\build\x64\vc15\lib</LibraryPath>
+    <LibraryPath>C:\opencv\build\x64\vc15\lib;$(VC_LibraryPath_x64);$(WindowsSDK_LibraryPath_x64);C:\opencv\opencv\build\x64\vc15\lib</LibraryPath>
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>
@@ -170,7 +164,7 @@
       <SubSystem>Console</SubSystem>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <AdditionalLibraryDirectories>$(SolutionDir)lib\glfw-3.3.2\$(Platform);$(SolutionDir)lib\glew-2.1.0\lib\Release\$(Platform);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <AdditionalDependencies>opencv_world452d.lib;%(AdditionalDependencies); opencv_world452.lib;opencv_world452d.lib</AdditionalDependencies>
+      <AdditionalDependencies>opencv_world452d.lib;%(AdditionalDependencies); opencv_world452.lib</AdditionalDependencies>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
@@ -211,7 +205,7 @@
       <OptimizeReferences>true</OptimizeReferences>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <AdditionalLibraryDirectories>$(SolutionDir)lib\glfw-3.3.2\$(Platform);$(SolutionDir)lib\glew-2.1.0\lib\Release\$(Platform);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <AdditionalDependencies>kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies); opencv_world452.lib;opencv_world452d.lib</AdditionalDependencies>
+      <AdditionalDependencies>opencv_world452.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
     </Link>
   </ItemDefinitionGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />

wk2_fps.vcxproj.filters

@@ -33,33 +33,15 @@
     <ClCompile Include="src\shaders\shader_program.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="src\shaders\static_shader.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
     <ClCompile Include="src\renderEngine\obj_loader.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
     <ClCompile Include="src\toolbox\toolbox.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="src\shaders\entity_shader.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="src\shaders\gui_shader.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="src\gui\gui_interactable.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="src\scenes\in_Game_Scene.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="src\scenes\startup_Scene.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="src\entities\collision_entity.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="src\collision\collision_handler.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
     <ClCompile Include="src\computervision\ObjectDetection.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
@@ -75,6 +57,12 @@
     <ClCompile Include="src\computervision\BackgroundRemover.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="src\computervision\OpenPoseVideo.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\computervision\async\async_arm_detection.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="src\entities\Camera.h">
@@ -98,45 +86,15 @@
     <ClInclude Include="src\shaders\shader_program.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="src\shaders\static_shader.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
     <ClInclude Include="src\renderEngine\obj_loader.h">
       <Filter>Header Files</Filter>
     </ClInclude>
     <ClInclude Include="src\toolbox\toolbox.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="src\entities\light.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\shaders\entity_shader.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\shaders\gui_shader.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\gui\gui_element.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\gui\gui_interactable.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\scenes\scene.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\scenes\in_Game_Scene.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\scenes\startup_Scene.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\entities\collision_entity.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\collision\collision.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\collision\collision_handler.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
     <ClInclude Include="src\computervision\ObjectDetection.h">
       <Filter>Header Files</Filter>
     </ClInclude>
@@ -152,11 +110,23 @@
     <ClInclude Include="src\computervision\BackgroundRemover.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="src\toolbox\Timer.h">
+    <ClInclude Include="src\computervision\OpenPoseVideo.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\computervision\async\async_arm_detection.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\computervision\async\StaticCameraInstance.h">
       <Filter>Header Files</Filter>
     </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <Xml Include="res\haarcascade_frontalface_alt.xml" />
   </ItemGroup>
+  <ItemGroup>
+    <None Include="res\pose\coco\pose_deploy_linevec.prototxt" />
+    <None Include="res\pose\mpi\pose_deploy_linevec_faster_4_stages.prototxt" />
+    <None Include="res\pose\mpi\pose_iter_160000.caffemodel" />
+    <None Include="..\..\Avans Hogeschool\Kim Veldhoen - Proftaak 2.4\pose_iter_160000.caffemodel" />
+  </ItemGroup>
 </Project>