[ADD] comments to backgroundRemover

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/BackgroundRemover.cpp

@@ -0,0 +1,59 @@
+#include "BackgroundRemover.h"
+
+/*
+ Author: Pierfrancesco Soffritti https://github.com/PierfrancescoSoffritti
+*/
+namespace computervision
+{
+	BackgroundRemover::BackgroundRemover(void) {
+		background;
+		calibrated = false;
+	}
+
+	void BackgroundRemover::calibrate(Mat input) {
+		cvtColor(input, background, CV_BGR2GRAY);
+		calibrated = true;
+	}
+
+	Mat BackgroundRemover::getForeground(Mat input) {
+		Mat foregroundMask = getForegroundMask(input);
+
+		//imshow("foregroundMask", foregroundMask);
+
+		Mat foreground;
+		input.copyTo(foreground, foregroundMask);
+
+		return foreground;
+	}
+
+	Mat BackgroundRemover::getForegroundMask(Mat input) {
+		Mat foregroundMask;
+
+		if (!calibrated) {
+			foregroundMask = Mat::zeros(input.size(), CV_8UC1);
+			return foregroundMask;
+		}
+
+		cvtColor(input, foregroundMask, CV_BGR2GRAY);
+
+		removeBackground(foregroundMask, background);
+
+		return foregroundMask;
+	}
+
+	void BackgroundRemover::removeBackground(Mat input, Mat background) {
+		int thresholdOffset = 25;
+
+		for (int i = 0; i < input.rows; i++) {
+			for (int j = 0; j < input.cols; j++) {
+				uchar framePixel = input.at<uchar>(i, j);
+				uchar bgPixel = background.at<uchar>(i, j);
+
+				if (framePixel >= bgPixel - thresholdOffset && framePixel <= bgPixel + thresholdOffset)
+					input.at<uchar>(i, j) = 0;
+				else
+					input.at<uchar>(i, j) = 255;
+			}
+		}
+	}
+}

src/computervision/BackgroundRemover.h

@@ -0,0 +1,58 @@
+#pragma once
+#include"opencv2\opencv.hpp"
+#include <opencv2/imgproc\types_c.h>
+/*
+ Author: Pierfrancesco Soffritti https://github.com/PierfrancescoSoffritti
+*/
+namespace computervision
+{
+using namespace cv;
+using namespace std;
+
+	class BackgroundRemover {
+	public:
+
+		/**
+		 * @brief constructor, 
+		 * create background variable and set calibrated to faslse
+		 * 
+		 */
+		BackgroundRemover(void);
+
+		/**
+		 * @brief sets the input image to a grayscale image
+		 * sets calibrated to true
+		 * 
+		 * @param input input the image that has to be calibrated
+		 */
+		void calibrate(Mat input);
+
+		/**
+		 * @brief Gets the mask of the foregorund of the input image
+		 * and copies it to another image
+		 * 
+		 * @param input The image from which the forground needs to be picked
+		 * @return The image on which te foregroundmask is copied
+		 */
+		Mat getForeground(Mat input);
+
+	private:
+		Mat background;
+		bool calibrated = false;
+
+		/**
+		 * @brief Sets the image to grayscale and removes the background
+		 * 
+		 * @param input The image from which the forground needs to be picked
+		 * @return The mask of the foreground of the image 
+		 */
+		Mat getForegroundMask(Mat input);
+		/**
+		 * @brief makes everything on the background black
+		 * 
+		 * @param input the image from which the background needs to be removed
+		 * @param background the background of the image
+		 */
+		void removeBackground(Mat input, Mat background);
+	};
+}

src/computervision/FaceDetector.cpp

@@ -0,0 +1,53 @@
+#include "FaceDetector.h"
+
+
+/*
+ Author: Pierfrancesco Soffritti https://github.com/PierfrancescoSoffritti
+*/
+namespace computervision
+{
+	Rect getFaceRect(Mat input);
+
+	String faceClassifierFileName = "res/haarcascade_frontalface_alt.xml";
+	CascadeClassifier faceCascadeClassifier;
+
+	FaceDetector::FaceDetector(void) {
+		if (!faceCascadeClassifier.load(faceClassifierFileName))
+			throw runtime_error("can't load file " + faceClassifierFileName);
+	}
+
+	void FaceDetector::removeFaces(Mat input, Mat output) {
+		vector<Rect> faces;
+		Mat frameGray;
+
+		cvtColor(input, frameGray, CV_BGR2GRAY);
+		equalizeHist(frameGray, frameGray);
+
+		faceCascadeClassifier.detectMultiScale(frameGray, faces, 1.1, 2, 0 | 2, Size(120, 120)); // HAAR_SCALE_IMAGE is 2
+
+		for (size_t i = 0; i < faces.size(); i++) {
+			rectangle(
+				output,
+				Point(faces[i].x, faces[i].y),
+				Point(faces[i].x + faces[i].width, faces[i].y + faces[i].height),
+				Scalar(0, 0, 0),
+				-1
+			);
+		}
+	}
+
+	Rect getFaceRect(Mat input) {
+		vector<Rect> faceRectangles;
+		Mat inputGray;
+
+		cvtColor(input, inputGray, CV_BGR2GRAY);
+		equalizeHist(inputGray, inputGray);
+
+		faceCascadeClassifier.detectMultiScale(inputGray, faceRectangles, 1.1, 2, 0 | 2, Size(120, 120)); // HAAR_SCALE_IMAGE is 2
+
+		if (faceRectangles.size() > 0)
+			return faceRectangles[0];
+		else
+			return Rect(0, 0, 1, 1);
+	}
+}

src/computervision/FaceDetector.h

@@ -0,0 +1,31 @@
+#pragma once
+#include <opencv2/opencv.hpp>
+#include <opencv2/imgproc/types_c.h>
+#include <opencv2/objdetect.hpp>
+#include <opencv2/core.hpp>
+#include <opencv2/objdetect/objdetect.hpp>
+/*
+ Author: Pierfrancesco Soffritti https://github.com/PierfrancescoSoffritti
+*/
+
+using namespace cv;
+using namespace std;
+
+namespace computervision
+{
+	class FaceDetector {
+	public:
+		/**
+		 * @brief Constructor for the class FaceDetector, loads training data from a file
+		 * 
+		 */
+		FaceDetector(void);
+		/**
+		 * @brief Detects faces on an image and blocks them with a black rectangle
+		 * 
+		 * @param input Input image
+		 * @param output Output image
+		 */
+		void removeFaces(Mat input, Mat output);
+	};
+}

src/computervision/FingerCount.cpp

@@ -0,0 +1,291 @@
+#include "FingerCount.h"
+
+#include "opencv2/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+
+/*
+ Author: Nicol<6F> Castellazzi https://github.com/nicast
+*/
+
+#define LIMIT_ANGLE_SUP 60
+#define LIMIT_ANGLE_INF 5
+#define BOUNDING_RECT_FINGER_SIZE_SCALING 0.3
+#define BOUNDING_RECT_NEIGHBOR_DISTANCE_SCALING 0.05
+
+namespace computervision
+{
+	FingerCount::FingerCount(void) {
+		color_blue = Scalar(255, 0, 0);
+		color_green = Scalar(0, 255, 0);
+		color_red = Scalar(0, 0, 255);
+		color_black = Scalar(0, 0, 0);
+		color_white = Scalar(255, 255, 255);
+		color_yellow = Scalar(0, 255, 255);
+		color_purple = Scalar(255, 0, 255);
+	}
+
+	Mat FingerCount::findFingersCount(Mat input_image, Mat frame) {
+		Mat contours_image = Mat::zeros(input_image.size(), CV_8UC3);
+
+		// check if the source image is good
+		if (input_image.empty())
+			return contours_image;
+
+		// we work only on the 1 channel result, since this function is called inside a loop we are not sure that this is always the case
+		if (input_image.channels() != 1)
+			return contours_image;
+
+		vector<vector<Point>> contours;
+		vector<Vec4i> hierarchy;
+
+		findContours(input_image, contours, hierarchy, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_NONE);
+
+		// we need at least one contour to work
+		if (contours.size() <= 0)
+			return contours_image;
+
+		// find the biggest contour (let's suppose it's our hand)
+		int biggest_contour_index = -1;
+		double biggest_area = 0.0;
+
+		for (int i = 0; i < contours.size(); i++) {
+			double area = contourArea(contours[i], false);
+			if (area > biggest_area) {
+				biggest_area = area;
+				biggest_contour_index = i;
+			}
+		}
+
+		if (biggest_contour_index < 0)
+			return contours_image;
+
+		// find the convex hull object for each contour and the defects, two different data structure are needed by the OpenCV api
+		vector<Point> hull_points;
+		vector<int> hull_ints;
+
+		// for drawing the convex hull and for finding the bounding rectangle
+		convexHull(Mat(contours[biggest_contour_index]), hull_points, true);
+
+		// for finding the defects
+		convexHull(Mat(contours[biggest_contour_index]), hull_ints, false);
+
+		// we need at least 3 points to find the defects
+		vector<Vec4i> defects;
+		if (hull_ints.size() > 3)
+			convexityDefects(Mat(contours[biggest_contour_index]), hull_ints, defects);
+		else
+			return contours_image;
+
+		// we bound the convex hull
+		Rect bounding_rectangle = boundingRect(Mat(hull_points));
+
+		// we find the center of the bounding rectangle, this should approximately also be the center of the hand
+		Point center_bounding_rect(
+			(bounding_rectangle.tl().x + bounding_rectangle.br().x) / 2,
+			(bounding_rectangle.tl().y + bounding_rectangle.br().y) / 2
+		);
+
+		// we separate the defects keeping only the ones of intrest
+		vector<Point> start_points;
+		vector<Point> far_points;
+
+		for (int i = 0; i < defects.size(); i++) {
+			start_points.push_back(contours[biggest_contour_index][defects[i].val[0]]);
+
+			// filtering the far point based on the distance from the center of the bounding rectangle
+			if (findPointsDistance(contours[biggest_contour_index][defects[i].val[2]], center_bounding_rect) < bounding_rectangle.height * BOUNDING_RECT_FINGER_SIZE_SCALING)
+				far_points.push_back(contours[biggest_contour_index][defects[i].val[2]]);
+		}
+
+		// we compact them on their medians
+		vector<Point> filtered_start_points = compactOnNeighborhoodMedian(start_points, bounding_rectangle.height * BOUNDING_RECT_NEIGHBOR_DISTANCE_SCALING);
+		vector<Point> filtered_far_points = compactOnNeighborhoodMedian(far_points, bounding_rectangle.height * BOUNDING_RECT_NEIGHBOR_DISTANCE_SCALING);
+
+		// now we try to find the fingers
+		vector<Point> filtered_finger_points;
+
+		if (filtered_far_points.size() > 1) {
+			vector<Point> finger_points;
+
+			for (int i = 0; i < filtered_start_points.size(); i++) {
+				vector<Point> closest_points = findClosestOnX(filtered_far_points, filtered_start_points[i]);
+
+				if (isFinger(closest_points[0], filtered_start_points[i], closest_points[1], LIMIT_ANGLE_INF, LIMIT_ANGLE_SUP, center_bounding_rect, bounding_rectangle.height * BOUNDING_RECT_FINGER_SIZE_SCALING))
+					finger_points.push_back(filtered_start_points[i]);
+			}
+
+			if (finger_points.size() > 0) {
+
+				// we have at most five fingers usually :)
+				while (finger_points.size() > 5)
+					finger_points.pop_back();
+
+				// filter out the points too close to each other
+				for (int i = 0; i < finger_points.size() - 1; i++) {
+					if (findPointsDistanceOnX(finger_points[i], finger_points[i + 1]) > bounding_rectangle.height * BOUNDING_RECT_NEIGHBOR_DISTANCE_SCALING * 1.5)
+						filtered_finger_points.push_back(finger_points[i]);
+				}
+
+				if (finger_points.size() > 2) {
+					if (findPointsDistanceOnX(finger_points[0], finger_points[finger_points.size() - 1]) > bounding_rectangle.height * BOUNDING_RECT_NEIGHBOR_DISTANCE_SCALING * 1.5)
+						filtered_finger_points.push_back(finger_points[finger_points.size() - 1]);
+				}
+				else
+					filtered_finger_points.push_back(finger_points[finger_points.size() - 1]);
+			}
+		}
+
+		// we draw what found on the returned image 
+		drawContours(contours_image, contours, biggest_contour_index, color_green, 2, 8, hierarchy);
+		polylines(contours_image, hull_points, true, color_blue);
+		rectangle(contours_image, bounding_rectangle.tl(), bounding_rectangle.br(), color_red, 2, 8, 0);
+		circle(contours_image, center_bounding_rect, 5, color_purple, 2, 8);
+		drawVectorPoints(contours_image, filtered_start_points, color_blue, true);
+		drawVectorPoints(contours_image, filtered_far_points, color_red, true);
+		drawVectorPoints(contours_image, filtered_finger_points, color_yellow, false);
+		putText(contours_image, to_string(filtered_finger_points.size()), center_bounding_rect, FONT_HERSHEY_PLAIN, 3, color_purple);
+
+		// and on the starting frame
+		drawContours(frame, contours, biggest_contour_index, color_green, 2, 8, hierarchy);
+		circle(frame, center_bounding_rect, 5, color_purple, 2, 8);
+		drawVectorPoints(frame, filtered_finger_points, color_yellow, false);
+		putText(frame, to_string(filtered_finger_points.size()), center_bounding_rect, FONT_HERSHEY_PLAIN, 3, color_purple);
+
+		return contours_image;
+	}
+
+	double FingerCount::findPointsDistance(Point a, Point b) {
+		Point difference = a - b;
+		return sqrt(difference.ddot(difference));
+	}
+
+	vector<Point> FingerCount::compactOnNeighborhoodMedian(vector<Point> points, double max_neighbor_distance) {
+		vector<Point> median_points;
+
+		if (points.size() == 0)
+			return median_points;
+
+		if (max_neighbor_distance <= 0)
+			return median_points;
+
+		// we start with the first point
+		Point reference = points[0];
+		Point median = points[0];
+
+		for (int i = 1; i < points.size(); i++) {
+			if (findPointsDistance(reference, points[i]) > max_neighbor_distance) {
+
+				// the point is not in range, we save the median
+				median_points.push_back(median);
+
+				// we swap the reference
+				reference = points[i];
+				median = points[i];
+			}
+			else
+				median = (points[i] + median) / 2;
+		}
+
+		// last median
+		median_points.push_back(median);
+
+		return median_points;
+	}
+
+	double FingerCount::findAngle(Point a, Point b, Point c) {
+		double ab = findPointsDistance(a, b);
+		double bc = findPointsDistance(b, c);
+		double ac = findPointsDistance(a, c);
+		return acos((ab * ab + bc * bc - ac * ac) / (2 * ab * bc)) * 180 / CV_PI;
+	}
+
+	bool FingerCount::isFinger(Point a, Point b, Point c, double limit_angle_inf, double limit_angle_sup, Point palm_center, double min_distance_from_palm) {
+		double angle = findAngle(a, b, c);
+		if (angle > limit_angle_sup || angle < limit_angle_inf)
+			return false;
+
+		// the finger point sohould not be under the two far points
+		int delta_y_1 = b.y - a.y;
+		int delta_y_2 = b.y - c.y;
+		if (delta_y_1 > 0 && delta_y_2 > 0)
+			return false;
+
+		// the two far points should not be both under the center of the hand
+		int delta_y_3 = palm_center.y - a.y;
+		int delta_y_4 = palm_center.y - c.y;
+		if (delta_y_3 < 0 && delta_y_4 < 0)
+			return false;
+
+		double distance_from_palm = findPointsDistance(b, palm_center);
+		if (distance_from_palm < min_distance_from_palm)
+			return false;
+
+		// this should be the case when no fingers are up
+		double distance_from_palm_far_1 = findPointsDistance(a, palm_center);
+		double distance_from_palm_far_2 = findPointsDistance(c, palm_center);
+		if (distance_from_palm_far_1 < min_distance_from_palm / 4 || distance_from_palm_far_2 < min_distance_from_palm / 4)
+			return false;
+
+		return true;
+	}
+
+	vector<Point> FingerCount::findClosestOnX(vector<Point> points, Point pivot) {
+		vector<Point> to_return(2);
+
+		if (points.size() == 0)
+			return to_return;
+
+		double distance_x_1 = DBL_MAX;
+		double distance_1 = DBL_MAX;
+		double distance_x_2 = DBL_MAX;
+		double distance_2 = DBL_MAX;
+		int index_found = 0;
+
+		for (int i = 0; i < points.size(); i++) {
+			double distance_x = findPointsDistanceOnX(pivot, points[i]);
+			double distance = findPointsDistance(pivot, points[i]);
+
+			if (distance_x < distance_x_1 && distance_x != 0 && distance <= distance_1) {
+				distance_x_1 = distance_x;
+				distance_1 = distance;
+				index_found = i;
+			}
+		}
+
+		to_return[0] = points[index_found];
+
+		for (int i = 0; i < points.size(); i++) {
+			double distance_x = findPointsDistanceOnX(pivot, points[i]);
+			double distance = findPointsDistance(pivot, points[i]);
+
+			if (distance_x < distance_x_2 && distance_x != 0 && distance <= distance_2 && distance_x != distance_x_1) {
+				distance_x_2 = distance_x;
+				distance_2 = distance;
+				index_found = i;
+			}
+		}
+
+		to_return[1] = points[index_found];
+
+		return to_return;
+	}
+
+	double FingerCount::findPointsDistanceOnX(Point a, Point b) {
+		double to_return = 0.0;
+
+		if (a.x > b.x)
+			to_return = a.x - b.x;
+		else
+			to_return = b.x - a.x;
+
+		return to_return;
+	}
+
+	void FingerCount::drawVectorPoints(Mat image, vector<Point> points, Scalar color, bool with_numbers) {
+		for (int i = 0; i < points.size(); i++) {
+			circle(image, points[i], 5, color, 2, 8);
+			if (with_numbers)
+				putText(image, to_string(i), points[i], FONT_HERSHEY_PLAIN, 3, color);
+		}
+	}
+}

src/computervision/FingerCount.h

@@ -0,0 +1,110 @@
+#pragma once
+
+#include "opencv2/core.hpp"
+#include <opencv2/imgproc/types_c.h>
+
+/*
+ Author: Nicol<6F> Castellazzi https://github.com/nicast
+*/
+
+namespace computervision
+{
+	using namespace cv;
+	using namespace std;
+
+	class FingerCount {
+	public:
+		FingerCount(void);
+		/**
+		 * @brief gets the amount of fingers that are held up.
+		 * 
+		 * @param input_image the source image to find the fingers on. It should be a mask of a hand
+		 * @param frame the frame to draw the resulting values on (how many fingers are held up etc)
+		 * @return a new image with all the data drawn on it.
+		 */
+		Mat findFingersCount(Mat input_image, Mat frame);
+
+	private:
+		// colors to use
+		Scalar color_blue;
+		Scalar color_green;
+		Scalar color_red;
+		Scalar color_black;
+		Scalar color_white;
+		Scalar color_yellow;
+		Scalar color_purple;
+
+		/**
+		 * @brief finds the distance between 2 points.
+		 * 
+		 * @param a the first point
+		 * @param b the second point
+		 * @return a double representing the distance
+		 */
+		double findPointsDistance(Point a, Point b);
+
+		/**
+		 * @brief compacts the given points on their medians. 
+		 * what it does is for each point, it checks if the distance to it's neighbour is greater than the 
+		 * max distance. If so, it just adds it to the list that is returned. If not, it calculates the 
+		 * median and adds it to the returned list
+		 * 
+		 * @param points the points to compact
+		 * @param max_neighbor_distance the maximum distance between points
+		 * @return a vector with the points now compacted.
+		 */
+		vector<Point> compactOnNeighborhoodMedian(vector<Point> points, double max_neighbor_distance);
+		
+		/**
+		 * @brief finds the angle between 3 different points.
+		 * 
+		 * @param a the first point
+		 * @param b the second point
+		 * @param c the third point
+		 * @return the angle between the 3 points
+		 */
+		double findAngle(Point a, Point b, Point c);
+
+		/**
+		 * @brief checks if the given points make up a finger.
+		 * 
+		 * @param a the first point to check for
+		 * @param b the second point to check for
+		 * @param c the third point to check for
+		 * @param limit_angle_inf the limit of the angle between 2 fingers
+		 * @param limit_angle_sup the limit of the angle between a finger and a convex point
+		 * @param palm_center the center of the palm
+		 * @param distance_from_palm_tollerance the distance from the palm tolerance
+		 * @return true if the points are a finger, false if not.
+		 */
+		bool isFinger(Point a, Point b, Point c, double limit_angle_inf, double limit_angle_sup, cv::Point palm_center, double distance_from_palm_tollerance);
+		
+		/**
+		 * @brief finds the closest point to the given point that is in the given list.
+		 * 
+		 * @param points the points to check for
+		 * @param pivot the pivot to check against
+		 * @return a vector containing the point that is closest
+		 */
+		vector<Point> findClosestOnX(vector<Point> points, Point pivot);
+
+		/**
+		 * @brief finds the distance between the x coords of the points.
+		 * 
+		 * @param a the first point
+		 * @param b the second point
+		 * @return the distance between the x values
+		 */
+		double findPointsDistanceOnX(Point a, Point b);
+
+		/**
+		 * @brief draws the points on the image.
+		 * 
+		 * @param image the image to draw on
+		 * @param points the points to draw
+		 * @param color the color to draw them with
+		 * @param with_numbers if the numbers should be drawn with the points
+		 */
+		void drawVectorPoints(Mat image, vector<Point> points, Scalar color, bool with_numbers);
+	};
+}

src/computervision/ObjectDetection.cpp

@@ -0,0 +1,91 @@
+
+#include "ObjectDetection.h"
+#include "BackgroundRemover.h"
+#include "SkinDetector.h"
+#include "FaceDetector.h"
+#include "FingerCount.h"
+
+namespace computervision
+{
+	cv::VideoCapture cap(0);
+
+	cv::Mat img, imgGray, img2, img2Gray, img3, img4;
+
+	Mat frame, frameOut, handMask, foreground, fingerCountDebug;
+	BackgroundRemover backgroundRemover;
+	SkinDetector skinDetector;
+	FaceDetector faceDetector;
+	FingerCount fingerCount;
+
+
+	ObjectDetection::ObjectDetection()
+	{
+	}
+
+	bool ObjectDetection::setup() 
+	{
+		if (!cap.isOpened()) {
+			cout << "Can't find camera!" << endl;
+			return false;
+		}
+
+		cap.read(frame);
+		frameOut = frame.clone();
+
+		skinDetector.drawSkinColorSampler(frameOut);
+
+		foreground = backgroundRemover.getForeground(frame);
+
+		faceDetector.removeFaces(frame, foreground);
+		handMask = skinDetector.getSkinMask(foreground);
+		fingerCountDebug = fingerCount.findFingersCount(handMask, frameOut);
+
+		//backgroundRemover.calibrate(frame);
+
+
+		imshow("output", frameOut);
+		imshow("foreground", foreground);
+		imshow("handMask", handMask);
+		imshow("handDetection", fingerCountDebug);
+
+		int key = waitKey(1);
+
+		if (key == 98) // b
+			backgroundRemover.calibrate(frame);
+		else if (key == 115) // s
+			skinDetector.calibrate(frame);
+
+		return true;
+	}
+
+	void ObjectDetection::calculateDifference()
+	{
+		cap.read(img);
+		cap.read(img2);
+
+		cv::cvtColor(img, imgGray, cv::COLOR_RGBA2GRAY);
+		cv::cvtColor(img2, img2Gray, cv::COLOR_RGBA2GRAY);
+
+		cv::absdiff(imgGray, img2Gray, img3);
+		cv::threshold(img3, img4, 50, 170, cv::THRESH_BINARY);
+
+		imshow("threshold", img4);
+	}
+
+	void ObjectDetection::detect()
+	{
+		int key = waitKey(1);
+			
+		if (key == 98) // b
+			backgroundRemover.calibrate(frame);
+		else if (key == 115) // s
+			skinDetector.calibrate(frame);
+	}
+
+	void ObjectDetection::showWebcam()
+	{
+		imshow("Webcam image", img);
+	}
+
+
+}

src/computervision/ObjectDetection.h

@@ -0,0 +1,53 @@
+#pragma once
+
+#include <opencv2/imgcodecs.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/objdetect.hpp>
+#include <opencv2/videoio.hpp>
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc/imgproc.hpp>
+#include <opencv2/highgui/highgui.hpp>
+
+
+namespace computervision
+{
+	class ObjectDetection
+	{
+	private:
+
+	public:
+		/**
+		 * @brief default constructor of ObjectDetection
+		 * 
+		 */
+		ObjectDetection();
+		/**
+		 * @brief Initializes the object detection, captures a frame and modifies it
+		 *  so it is ready to use for object detection
+		 * 
+		 * @return return true if webcam is connected, returns false if it isn't
+		 */
+		bool setup();
+		/**
+		 * @brief Displays an image of the current webcam-footage
+		 * 
+		 */
+		void showWebcam();
+		/**
+		 * @brief Calculates the difference between two images
+		 *  and outputs an image that only shows the difference
+		 * 
+		 */
+		void calculateDifference();
+		/**
+		 * @brief Listens for keypresses and handles them
+		 * 
+		 */
+		void detect();
+
+	};
+
+
+}
+

src/computervision/SkinDetector.cpp

@@ -0,0 +1,105 @@
+#include "SkinDetector.h"
+
+/*
+ Author: Pierfrancesco Soffritti https://github.com/PierfrancescoSoffritti
+*/
+
+namespace computervision
+{
+	SkinDetector::SkinDetector(void) {
+		hLowThreshold = 0;
+		hHighThreshold = 0;
+		sLowThreshold = 0;
+		sHighThreshold = 0;
+		vLowThreshold = 0;
+		vHighThreshold = 0;
+
+		calibrated = false;
+
+		skinColorSamplerRectangle1, skinColorSamplerRectangle2;
+	}
+
+	void SkinDetector::drawSkinColorSampler(Mat input) {
+		int frameWidth = input.size().width, frameHeight = input.size().height;
+
+		int rectangleSize = 20;
+		Scalar rectangleColor = Scalar(255, 0, 255);
+
+		skinColorSamplerRectangle1 = Rect(frameWidth / 5, frameHeight / 2, rectangleSize, rectangleSize);
+		skinColorSamplerRectangle2 = Rect(frameWidth / 5, frameHeight / 3, rectangleSize, rectangleSize);
+
+		rectangle(
+			input,
+			skinColorSamplerRectangle1,
+			rectangleColor
+		);
+
+		rectangle(
+			input,
+			skinColorSamplerRectangle2,
+			rectangleColor
+		);
+	}
+
+	void SkinDetector::calibrate(Mat input) {
+
+		Mat hsvInput;
+		cvtColor(input, hsvInput, CV_BGR2HSV);
+
+		Mat sample1 = Mat(hsvInput, skinColorSamplerRectangle1);
+		Mat sample2 = Mat(hsvInput, skinColorSamplerRectangle2);
+
+		calculateThresholds(sample1, sample2);
+
+		calibrated = true;
+	}
+
+	void SkinDetector::calculateThresholds(Mat sample1, Mat sample2) {
+		int offsetLowThreshold = 80;
+		int offsetHighThreshold = 30;
+
+		Scalar hsvMeansSample1 = mean(sample1);
+		Scalar hsvMeansSample2 = mean(sample2);
+
+		hLowThreshold = min(hsvMeansSample1[0], hsvMeansSample2[0]) - offsetLowThreshold;
+		hHighThreshold = max(hsvMeansSample1[0], hsvMeansSample2[0]) + offsetHighThreshold;
+
+		sLowThreshold = min(hsvMeansSample1[1], hsvMeansSample2[1]) - offsetLowThreshold;
+		sHighThreshold = max(hsvMeansSample1[1], hsvMeansSample2[1]) + offsetHighThreshold;
+
+		// the V channel shouldn't be used. By ignorint it, shadows on the hand wouldn't interfire with segmentation.
+		// Unfortunately there's a bug somewhere and not using the V channel causes some problem. This shouldn't be too hard to fix.
+		vLowThreshold = min(hsvMeansSample1[2], hsvMeansSample2[2]) - offsetLowThreshold;
+		vHighThreshold = max(hsvMeansSample1[2], hsvMeansSample2[2]) + offsetHighThreshold;
+		//vLowThreshold = 0;
+		//vHighThreshold = 255;
+	}
+
+	Mat SkinDetector::getSkinMask(Mat input) {
+		Mat skinMask;
+
+		if (!calibrated) {
+			skinMask = Mat::zeros(input.size(), CV_8UC1);
+			return skinMask;
+		}
+
+		Mat hsvInput;
+		cvtColor(input, hsvInput, CV_BGR2HSV);
+
+		inRange(
+			hsvInput,
+			Scalar(hLowThreshold, sLowThreshold, vLowThreshold),
+			Scalar(hHighThreshold, sHighThreshold, vHighThreshold),
+			skinMask);
+
+		performOpening(skinMask, MORPH_ELLIPSE, { 3, 3 });
+		dilate(skinMask, skinMask, Mat(), Point(-1, -1), 3);
+
+		return skinMask;
+	}
+
+	void SkinDetector::performOpening(Mat binaryImage, int kernelShape, Point kernelSize) {
+		Mat structuringElement = getStructuringElement(kernelShape, kernelSize);
+		morphologyEx(binaryImage, binaryImage, MORPH_OPEN, structuringElement);
+	}
+}

src/computervision/SkinDetector.h

@@ -0,0 +1,76 @@
+#pragma once
+
+#include <opencv2\core.hpp>
+#include <opencv2/imgcodecs.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/imgproc/types_c.h>
+/*
+ Author: Pierfrancesco Soffritti https://github.com/PierfrancescoSoffritti
+*/
+
+namespace computervision
+{
+	using namespace cv;
+	using namespace std;
+
+	class SkinDetector {
+	public:
+		SkinDetector(void);
+
+		/*
+		* @brief draws the positions in where the skin color will be sampled.
+		* 
+		* @param input the input matrix to sample the skin color from
+		*/
+		void drawSkinColorSampler(Mat input);
+
+		/*
+		* @brief calibrates the skin color detector with the given input frame
+		* 
+		* @param input the input frame to calibrate from
+		*/
+		void calibrate(Mat input);
+
+		/*
+		* @brief gets the mask for the hand
+		* 
+		* @param input the input matrix to get the skin mask from
+		* @returns the skin mask in a new matrix
+		*/
+		Mat getSkinMask(Mat input);
+
+	private:
+
+		// thresholds for hsv calculation
+		int hLowThreshold = 0;
+		int hHighThreshold = 0;
+		int sLowThreshold = 0;
+		int sHighThreshold = 0;
+		int vLowThreshold = 0;
+		int vHighThreshold = 0;
+
+		// wether or not the skindetector has calibrated yet.
+		bool calibrated = false;
+
+		// rectangles that get drawn to show where the skin color will be sampled
+		Rect skinColorSamplerRectangle1, skinColorSamplerRectangle2;
+
+		/*
+		* @brief calculates the skin tresholds for the given samples
+		* 
+		* @param sample1 the first sample
+		* @param sample2 the second sample
+		*/
+		void calculateThresholds(Mat sample1, Mat sample2);
+
+		/**
+		 * @brief the opening. it generates the structuring element and performs the morphological transformations required to detect the hand.
+		 * This needs to be done to get the skin mask.
+		 * 
+		 * @param binaryImage the matrix to perform the opening on. This needs to be a binary image, so consisting of only 1's and 0's.
+		 * @param structuralElementShape the shape to use for the kernel that is used with generating the structuring element
+		 * @param structuralElementSize the size of the kernel that will be used with generating the structuring element.
+		 */
+		void performOpening(Mat binaryImage, int structuralElementShape, Point structuralElementSize);
+	};
+}

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.52f;
-		const float ROT_SPEED = 1.0f;
+		const float SPEED = 0.02f;
 		
 		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

@@ -2,24 +2,17 @@
 #include <GLFW/glfw3.h>
 #include <glm/gtc/matrix_transform.hpp>
 #define STB_IMAGE_IMPLEMENTATION
-#include <iostream>
-#include <map>
-
 #include "stb_image.h"
 #include <ostream>
 
-#include <opencv2/core.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"
 
 #pragma comment(lib, "glfw3.lib")
 #pragma comment(lib, "glew32s.lib")
@@ -28,7 +21,7 @@
 static double UpdateDelta();
 
 static GLFWwindow* window;
-scene::Scene* current_scene;
+
 
 int main(void)
 {
@@ -46,45 +39,57 @@ int main(void)
     glGetError();
 	#pragma endregion
 
-    
-    current_scene = new scene::Startup_Scene();
-
     glfwSetKeyCallback(window, [](GLFWwindow* window, int key, int scancode, int action, int mods)
-        {
-            current_scene->onKey(window, key, scancode, action, mods);
-        });
+    {
+	    if (key == GLFW_KEY_ESCAPE)
+	        glfwSetWindowShouldClose(window, true);
+    });
+	
+	
+    models::RawModel raw_model = LoadObjModel("res/Tree.obj");
+    models::ModelTexture texture = { render_engine::loader::LoadTexture("res/TreeTexture.png") };
+    models::TexturedModel model = { raw_model, texture };
+    entities::Entity entity(model, glm::vec3(0, -5, -20), glm::vec3(0, 0, 0), 1);
+	
+    shaders::StaticShader shader;
+    shader.Init();
+    render_engine::renderer::Init(shader);
 
-    bool window_open = true;
+    entities::Camera camera(glm::vec3(0, 0, 0), glm::vec3(0, 0, 0));
+
+    // create object detection object instance
+    computervision::ObjectDetection objDetect;
+    
+    
+    // set up object detection
+    //objDetect.setup();
+	
 	// Main game loop
-	while (!glfwWindowShouldClose(window) && window_open)
+	while (!glfwWindowShouldClose(window))
 	{
-        //Update
+        // Update
         const double delta = UpdateDelta();
+        entity.IncreaseRotation(glm::vec3(0, 1, 0));
+        camera.Move(window);
 
-        scene::Scenes return_value = current_scene->start(window);
-        delete current_scene;
+		// Render
+        render_engine::renderer::Prepare();
+        shader.Start();
+        shader.LoadViewMatrix(camera);
+		
+        render_engine::renderer::Render(entity, shader);
 
-        switch (return_value) {
-            case scene::Scenes::STOP:
-                window_open = false;
-                break;
+        objDetect.setup();
 
-            case scene::Scenes::STARTUP:
-                current_scene = new scene::Startup_Scene();
-                break;
-
-            case scene::Scenes::INGAME:
-                current_scene = new scene::In_Game_Scene();
-                break;
-
-            default:
-                std::cout << "Wrong return value!!! ->" << std::endl;
-                break;
-        }
+		// Finish up
+        shader.Stop();
+		glfwSwapBuffers(window);
+		glfwPollEvents();
 	}
 
-	// Clean up -> preventing memory leaks!!!
-    std::cout << "ending..." << std::endl;
+	// Clean up
+    shader.CleanUp();
+    render_engine::loader::CleanUp();
 	glfwTerminate();
     return 0;
 }
@@ -96,4 +101,4 @@ static double UpdateDelta()
     double delt_time = current_time - last_frame_time;
     last_frame_time = current_time;
     return delt_time;
-}
+}

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
-		vertex_count = The amount of vertices in the model
-		model_size = The size on each axis of the model
+		This structure represents a Bare bones Model (A mesh without a texture).
+		The vao_id, points to an ID stored by openGL and the
+		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);
-			
-			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 };
+			return { vao_id, static_cast<int>(indices.size()) };
 		}
 
 		/*
@@ -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.
-		*
-		*	@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
+			This function generates a model from model data.
 		*/
-		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.
-		 *         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
+			Loads a texture from a file into openGL using stb_image.h
 		 */
 		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 <iostream>
+#include "../toolbox/toolbox.h"
 
 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;
-		
-		
-		void Init(shaders::EntityShader& shader)
+		/*
+			This function will load the projectionMatrix into the shader
+		 */
+		void Init(shaders::StaticShader& 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);
-
-			// 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::ModelTexture texture = model.texture;
+			const models::RawModel rawModel = model.raw_model;
 
-			// Enable the model (VAO)
-			glBindVertexArray(raw_model.vao_id);
+			// Enable the model
+			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);
-
-			// Disable the VBO's and model (VAO)
+			glDrawElements(GL_TRIANGLES, rawModel.vertex_count, GL_UNSIGNED_INT, 0);
+			
 			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/gui_shader.h"
+#include "../shaders/static_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
-
-			@param shader: The shader to render the entities with
+			Call this function when starting the program
 		 */
-		void Init(shaders::EntityShader& shader);
+		void Init(shaders::StaticShader& shader);
 		
 		/*
-			@brief: Call this function before rendering.
-					This function will enable culling and load the projectionMatrix into the shader.
+			Call this function before rendering. 
 		*/
 		void Prepare();
 
 		/*
-			@brief: 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
+			Call this function when wanting to Render a mesh to the screen.
 		*/
-		void Render(entities::Entity& entity, shaders::EntityShader& 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);
+		void Render(entities::Entity& entity, shaders::StaticShader& 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::string item;
-        while (getline(ss, item, delim)) {
-            elems.push_back(item);
-        }
+    std::stringstream ss;
+    ss.str(s);
+    std::string item;
+    while (getline(ss, item, delim)) {
+        elems.push_back(item);
     }
+}
 
-    static std::vector<std::string> Split(const std::string& s, char delim)
+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() ) 
     {
-        std::vector<std::string> elems;
-        Split(s, delim, elems);
-        return elems;
+        throw std::runtime_error ( "Could not open model file " + file_name + ".obj!" );
     }
-
-    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)
+    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
     {
-        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())
+        while (std::getline(inFile, line))
         {
-            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")
             {
-                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;
-                }
+                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);
             }
-
-            while (true)
+            else if (split_line.at(0) == "vt")
             {
-                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;
-                }
+                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;
             }
         }
-        catch (const std::exception& e)
+    	
+        while (true)
         {
-            // Always go in here
+            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;
+            }
         }
-
-        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);
+    } 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
-{
-	/*
-	 * @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);
-}
+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;
 
-		/*
-		 * @brief: Call this function after making the shaderprogram (sets all the attributes of the shader)
-		 */
+		// Call this function after making the shaderprogram (sets all the attributes of the shader)
 		void Init();
-
-		/*
-		 * @brief: Call this function before rendering
-		 */
+		// Call this function before rendering
 		void Start() const;
-
-		/*
-		 * @brief: Call this function after rendering
-		 */
+		// Call this function after rendering
 		void Stop() const;
-		
-		/*
-		 * @brief: Call this function when closing the application
-		 */
+		// Call this function when closing the application
 		void CleanUp() const;
 
 	protected:
-		/*
-		 * @brief: Set the inputs of the vertex shader
-		 */
+		// 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;
 
-		/*
-		 * @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
-		 */
+		// Loads value's (uniform variables) into the shader
 		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/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 DEFAULT_WIDTH 1920
-		#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)
-	//
+	#define WINDOW_WIDTH 1400.0f
+	#define WINDOW_HEIGT 800.0f
 	
-	/*
-	 * @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,43 +19,40 @@
     </ProjectConfiguration>
   </ItemGroup>
   <ItemGroup>
-    <ClCompile Include="src\collision\collision_handler.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\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\collision\collision_handler.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\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\toolbox.h" />
-    <ClInclude Include="src\scenes\startup_Scene.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <Xml Include="res\haarcascade_frontalface_alt.xml" />
   </ItemGroup>
   <PropertyGroup Label="Globals">
     <VCProjectVersion>16.0</VCProjectVersion>
@@ -115,16 +112,14 @@
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <LinkIncremental>true</LinkIncremental>
-    <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</LibraryPath>
+    <IncludePath>C:\opencv\build\include;$(IncludePath)</IncludePath>
+    <LibraryPath>C:\opencv\build\x64\vc15\lib;$(LibraryPath)</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</IncludePath>
-    <LibraryPath>$(VC_LibraryPath_x64);$(WindowsSDK_LibraryPath_x64);C:\opencv\opencv\build\x64\vc15\lib</LibraryPath>
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>
@@ -156,7 +151,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</AdditionalDependencies>
+      <AdditionalDependencies>opencv_world452d.lib;%(AdditionalDependencies)</AdditionalDependencies>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
@@ -197,7 +192,6 @@
       <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</AdditionalDependencies>
     </Link>
   </ItemDefinitionGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />

wk2_fps.vcxproj.filters

@@ -33,31 +33,28 @@
     <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">
+    <ClCompile Include="src\computervision\ObjectDetection.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="src\shaders\gui_shader.cpp">
+    <ClCompile Include="src\computervision\SkinDetector.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="src\gui\gui_interactable.cpp">
+    <ClCompile Include="src\computervision\FingerCount.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="src\scenes\in_Game_Scene.cpp">
+    <ClCompile Include="src\computervision\FaceDetector.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">
+    <ClCompile Include="src\computervision\BackgroundRemover.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
   </ItemGroup>
@@ -83,44 +80,32 @@
     <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">
+    <ClInclude Include="src\computervision\ObjectDetection.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="src\shaders\entity_shader.h">
+    <ClInclude Include="src\computervision\SkinDetector.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="src\shaders\gui_shader.h">
+    <ClInclude Include="src\computervision\FingerCount.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="src\gui\gui_element.h">
+    <ClInclude Include="src\computervision\FaceDetector.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">
+    <ClInclude Include="src\computervision\BackgroundRemover.h">
       <Filter>Header Files</Filter>
     </ClInclude>
   </ItemGroup>
+  <ItemGroup>
+    <Xml Include="res\haarcascade_frontalface_alt.xml" />
+  </ItemGroup>
 </Project>