Nove repo opengl-learning

2021-02-12 15:43:03 +01:00
commit 63e3c0bc8b
1046 changed files with 358397 additions and 0 deletions
--- a/shader/Makefile
+++ b/shader/Makefile
@@ -0,0 +1,37 @@
+NAME := main
+CXX=g++
+DEBUG := 
+CXX_FLAGS := $(DEBUG) -std=c++14
+LIBS := -lGL -lGLU -lglfw3 -lX11 -lXxf86vm -lXrandr -pthread -lXi -ldl -lm -lassimp
+INCLUDE := ../../../include/
+BIN := bin
+SRC := src
+INPUT = src/main.cpp ../../../glad.c
+
+all: $(BIN)/$(NAME)
+
+run:
+	cd $(BIN) && ./$(NAME)
+
+$(BIN)/$(NAME): $(SRC)/main.o $(SRC)/glad.o $(SRC)/Shader.o $(SRC)/stb_image.o $(SRC)/Camera.o $(SRC)/Framebuffer.o $(SRC)/Mesh.o $(SRC)/Model.o
+	$(CXX) $(CXX_FLAGS) -I$(INCLUDE) $^ -o $@ $(LIBS)
+
+.cpp.o:
+	$(CXX) $(CXX_FLAGS) -I$(INCLUDE) -c $< -o $@
+
+.c.o:
+	$(CXX) $(CXX_FLAGS) -I$(INCLUDE) -c $< -o $@
+
+$(SRC)/glad.o: ../../../glad.c
+	$(CXX) $(CXX_FLAGS) -I$(INCLUDE) -c $< -o $@
+
+$(SRC)/stb_image.o: ../../../stb_image.cpp
+	$(CXX) $(CXX_FLAGS) -I$(INCLUDE) -c $< -o $@
+
+# dependencies
+$(SRC)/main.o: $(SRC)/main.cpp
+$(SRC)/Shader.o: $(SRC)/Shader.cpp
+
+clean:
+	rm -rf $(SRC)/*.o	
+	touch $(SRC)/*
--- a/shader/src/Camera.cpp
+++ b/shader/src/Camera.cpp
@@ -0,0 +1,83 @@
+#include "Camera.h"
+#include <glm/gtc/matrix_transform.hpp>
+
+Camera::Camera(glm::vec3 position, glm::vec3 worldUp, glm::vec3 worldFront, float yaw, float pitch) : Front(glm::vec3(0.0f, 0.0f, -1.0f)), MovementSpeed(2.5f), MouseSensitivity(0.1f), FOV(45.0f), Mode(CAM_FLOAT)
+{
+	this->Position = position;
+	this->WorldUp = worldUp;
+	this->Yaw = yaw;
+	this->Pitch = pitch;
+	this->WorldFront = worldFront;
+	this->WorldRight = glm::normalize(glm::cross(this->WorldFront, this->WorldUp));
+
+	updateCameraVectors();
+}
+void Camera::updateCameraVectors()
+{
+	glm::vec3 front;
+	front.x = cos(glm::radians(Yaw)) * cos(glm::radians(Pitch));
+	front.y = sin(glm::radians(Pitch));
+	front.z = sin(glm::radians(Yaw)) * cos(glm::radians(Pitch));
+	Front = glm::normalize(front);
+
+	Right = glm::normalize(glm::cross(Front, WorldUp));
+	Up = glm::normalize(glm::cross(Right, Front));	
+}
+glm::mat4 Camera::getViewMatrix()
+{
+	return glm::lookAt(Position, Position + Front, WorldUp);
+}
+void Camera::ProccessKeyboard(camera_movement direction, float deltaTime)
+{
+	switch (direction)
+	{
+	case CAM_FORWARD:
+		Position += deltaTime * MovementSpeed * Front;
+		break;
+	case CAM_BACKWARD:
+		Position -= deltaTime * MovementSpeed * Front;
+		break;
+	case CAM_LEFT:
+		Position -= deltaTime * MovementSpeed * Right;
+		break;
+	case CAM_RIGHT:
+		Position += deltaTime * MovementSpeed * Right;
+		break;
+	case CAM_UP:
+		Position += deltaTime * MovementSpeed * WorldUp;
+		break;
+	case CAM_DOWN:
+		Position -= deltaTime * MovementSpeed * WorldUp;
+		break;
+	}
+}
+void Camera::ProccessMouse(float xoffset, float yoffset, bool constrainPitch)
+{
+	xoffset *= MouseSensitivity;
+	yoffset *= MouseSensitivity;
+		
+	Yaw = fmodf(Yaw + xoffset, 360.0f);		
+	Pitch += yoffset;
+
+	if (constrainPitch)
+	{
+		if (Pitch > 89.0f)
+			Pitch = 89.0f;
+		else if (Pitch < -89.0f)
+			Pitch = -89.0f;
+	}
+
+	updateCameraVectors();
+}
+void Camera::ProccessScroll(float yoffset)
+{
+	FOV -= yoffset;
+	if (FOV < 1.0f)
+		FOV = 1.0f;
+	else if (FOV > 45.0f)
+		FOV = 45.0f;
+}
+void Camera::SetCameraMode(camera_mode mode)
+{
+	Mode = mode;
+}
--- a/shader/src/Camera.h
+++ b/shader/src/Camera.h
@@ -0,0 +1,54 @@
+#pragma once
+#include <glm/glm.hpp>
+
+enum camera_movement {
+	CAM_FORWARD,
+	CAM_BACKWARD,
+	CAM_LEFT,
+	CAM_RIGHT,
+	CAM_UP,
+	CAM_DOWN
+};
+
+enum camera_mode {
+	CAM_FLOAT,
+	CAM_MINECRAFT
+};
+
+class Camera
+{
+public:
+	float FOV;
+	float MovementSpeed;
+	float MouseSensitivity;
+	float Yaw;		// vlevo vpravo
+	float Pitch;		// nahoru dolu
+
+	camera_mode Mode;
+
+	glm::vec3 Position;
+	glm::vec3 Front;
+	glm::vec3 Right;
+	glm::vec3 Up;
+	glm::vec3 WorldUp;
+	glm::vec3 WorldRight;
+	glm::vec3 WorldFront;
+
+	Camera(glm::vec3 position = glm::vec3(0.0f, 0.0f, 0.0f),
+		glm::vec3 worldUp = glm::vec3(0.0f, 1.0f, 0.0f),
+		glm::vec3 worldFront = glm::vec3(0.0f, 0.0f, -1.0),
+		float yaw = -90.0f, float pitch = 0);	
+
+	glm::mat4 getViewMatrix();
+	void ProccessKeyboard(camera_movement direction, float deltaTime);
+	void ProccessMouse(float xoffset, float yoffset, bool constrainPitch = true);
+	void ProccessScroll(float yoffset);
+	void SetCameraMode(camera_mode mode);	
+
+private:
+	float lastY;
+	float lastX;	
+
+	void updateCameraVectors();
+};
+
--- a/shader/src/Framebuffer.cpp
+++ b/shader/src/Framebuffer.cpp
@@ -0,0 +1,139 @@
+#include "Framebuffer.h"
+#include <glad/glad.h>
+#include <iostream>
+#include <vector>
+
+Framebuffer::Framebuffer(const int& width, const int& height)
+{
+	glGenFramebuffers(1, &ID);
+	glBindFramebuffer(GL_FRAMEBUFFER, ID);
+
+	glGenTextures(1, &ColorBuffer);
+	glBindTexture(GL_TEXTURE_2D, ColorBuffer);
+	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+	glBindTexture(GL_TEXTURE_2D, 0);
+
+	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, ColorBuffer, 0);
+
+	glGenRenderbuffers(1, &DepthStencilBuffer);
+	glBindRenderbuffer(GL_RENDERBUFFER, DepthStencilBuffer);
+	glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, width, height);
+	glBindRenderbuffer(GL_RENDERBUFFER, 0);
+
+	glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, DepthStencilBuffer);
+
+	if (checkStatus() != 0)
+	{
+		glDeleteRenderbuffers(1, &DepthStencilBuffer);
+		glDeleteTextures(1, &ColorBuffer);
+		glDeleteFramebuffers(1, &ID);
+		std::cerr << "FRAMEBUFFER::ERROR Could not create framebuffer object." << std::endl;
+		return;
+	}
+	glBindFramebuffer(GL_FRAMEBUFFER, 0);
+
+	this->width = width;
+	this->height = height;
+}
+Framebuffer::~Framebuffer()
+{
+	glDeleteRenderbuffers(1, &DepthStencilBuffer);
+	glDeleteTextures(1, &ColorBuffer);
+	glDeleteFramebuffers(1, &ID);
+}
+int Framebuffer::checkStatus()
+{
+	if (!checkBind())
+		glBindFramebuffer(GL_FRAMEBUFFER, ID);
+	int status = glCheckFramebufferStatus(GL_FRAMEBUFFER);	
+
+	switch (status)
+	{
+	case GL_FRAMEBUFFER_COMPLETE:
+		return 0;
+		break;
+	default:
+		fprintf(stderr, "Framebuffer.h: [ERROR] code: %#04x\n", (int)status);
+		return -1;
+		break;
+	}	
+}
+
+/* updates width and height of buffers */
+void Framebuffer::UpdateSize(const unsigned int& newWidth, const unsigned int& newHeight)
+{
+	if (!checkBind())
+		glBindFramebuffer(GL_FRAMEBUFFER, ID);
+
+	glBindTexture(GL_TEXTURE_2D, ColorBuffer);
+	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, newWidth, newHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
+	glBindTexture(GL_TEXTURE_2D, 0);
+
+	glDeleteRenderbuffers(1, &DepthStencilBuffer);
+	glGenRenderbuffers(1, &DepthStencilBuffer);
+	glBindRenderbuffer(GL_RENDERBUFFER, DepthStencilBuffer);
+	glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, newWidth, newHeight);
+	glBindRenderbuffer(GL_RENDERBUFFER, 0);
+
+	glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, DepthStencilBuffer);
+}
+/* sets opengl to use this framebuffer */
+void Framebuffer::Use()
+{
+	glBindFramebuffer(GL_FRAMEBUFFER, ID);	
+}
+/* sets opengl to use default buffer */
+void Framebuffer::UseDefault()
+{
+	glBindFramebuffer(GL_FRAMEBUFFER, 0);
+}
+void Framebuffer::clearBuffers(float r, float g, float b, float a)
+{
+	if (!checkBind())
+		glBindFramebuffer(GL_FRAMEBUFFER, ID);
+	glClearColor(r, g, b, a);
+	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);	
+}
+void Framebuffer::clearColorBuffer(float r, float g, float b, float a)
+{
+	if (!checkBind())
+		glBindFramebuffer(GL_FRAMEBUFFER, ID);
+	glClearColor(r, g, b, a);
+	glClear(GL_COLOR_BUFFER_BIT);	
+}
+void Framebuffer::clearDepthBuffer()
+{
+	if (!checkBind())
+		glBindFramebuffer(GL_FRAMEBUFFER, ID);
+	glClear(GL_DEPTH_BUFFER_BIT);	
+}
+void Framebuffer::clearStencilBuffer()
+{
+	if (!checkBind())
+		glBindFramebuffer(GL_FRAMEBUFFER, ID);
+	glClear(GL_STENCIL_BUFFER_BIT);	
+}
+void Framebuffer::clearDepthStencilBuffer()
+{
+	if (!checkBind())
+		glBindFramebuffer(GL_FRAMEBUFFER, ID);
+	glClear(GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);	
+}
+unsigned int Framebuffer::getWidth()
+{
+	return width;
+}
+unsigned int Framebuffer::getHeight()
+{
+	return height;
+}
+bool Framebuffer::checkBind()
+{
+	int id = 0;
+	glGetIntegerv(GL_FRAMEBUFFER_BINDING, &id);
+	if (id == ID)
+		return true;
+	return false;
+}
--- a/shader/src/Framebuffer.h
+++ b/shader/src/Framebuffer.h
@@ -0,0 +1,36 @@
+#pragma once
+class Framebuffer
+{
+public:
+	/* opengl texture2D */
+	unsigned int ColorBuffer;
+	/* renderbuffer depth 24 bits stencil 8 bits */
+	unsigned int DepthStencilBuffer;
+	/* id of this framebuffer */
+	unsigned int ID;
+
+	Framebuffer(const int& width, const int& height);
+	~Framebuffer();
+
+	/* updates width and height of buffers */
+	void UpdateSize(const unsigned int& newWidth, const unsigned int& newHeight);
+	/* sets opengl to use this framebuffer */
+	void Use();
+	/* sets opengl to use default buffer */
+	void UseDefault();
+	void clearBuffers(float r = 0.0f, float g = 0.0f, float b = 0.0f, float a = 1.0f);
+	void clearColorBuffer(float r = 0.0f, float g = 0.0f, float b = 0.0f, float a = 1.0f);
+	void clearDepthBuffer();
+	void clearStencilBuffer();
+	void clearDepthStencilBuffer();
+	unsigned int getWidth();
+	unsigned int getHeight();
+
+private:
+	unsigned int width;
+	unsigned int height;	
+
+	int checkStatus();
+	bool checkBind();
+};
+
--- a/shader/src/Mesh.cpp
+++ b/shader/src/Mesh.cpp
@@ -0,0 +1,67 @@
+#include <glad/glad.h>
+#include "Mesh.h"
+
+using namespace glml;
+
+Mesh::Mesh(const std::vector<Vertex>& vertices,
+	const std::vector<unsigned int>& indices,
+	const std::vector<Texture>& textures) : vertices(vertices), indices(indices), textures(textures)
+{
+	setupMesh();
+}
+
+void Mesh::setupMesh()
+{
+	glGenVertexArrays(1, &VAO);
+	glGenBuffers(1, &VBO);
+	glGenBuffers(1, &EBO);
+
+	glBindVertexArray(VAO);
+
+	glBindBuffer(GL_ARRAY_BUFFER, VBO);
+	glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(Vertex), &vertices[0], GL_STATIC_DRAW);
+
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
+	glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(unsigned int), &indices[0], GL_STATIC_DRAW);
+
+	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (const void*)offsetof(Vertex, Position));
+	glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (const void*)offsetof(Vertex, Normal));
+	glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (const void*)offsetof(Vertex, TexCoord));
+	glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (const void*)offsetof(Vertex, Tangent));
+	glVertexAttribPointer(4, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (const void*)offsetof(Vertex, Bitangent));
+	for (int i = 0; i < 5; i++)
+		glEnableVertexAttribArray(i);
+
+	glBindVertexArray(0);
+}
+
+void Mesh::Draw(Shader& shader) const
+{
+	unsigned int diffNr = 0;
+	unsigned int specNr = 0;
+	unsigned int normNr = 0;
+	unsigned int heigNr = 0;
+
+	for (int i = 0; i < textures.size(); i++)
+	{
+		std::string name = TextureTypeStrings[static_cast<size_t>(textures[i].type)];
+
+		if (textures[i].type == TextureType::diffuse)
+			name += std::to_string(diffNr++);
+		else if (textures[i].type == TextureType::specular)
+			name += std::to_string(specNr++);
+		else if (textures[i].type == TextureType::normal)
+			name += std::to_string(normNr++);
+		else if (textures[i].type == TextureType::height)
+			name += std::to_string(heigNr++);
+
+		glActiveTexture(GL_TEXTURE0 + i);
+		shader.setInt("material." + name, i);
+		glBindTexture(GL_TEXTURE_2D, textures[i].id);
+	}
+	glActiveTexture(GL_TEXTURE0);
+
+	glBindVertexArray(VAO);
+	glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_INT, 0);
+	glBindVertexArray(0);
+}
--- a/shader/src/Mesh.h
+++ b/shader/src/Mesh.h
@@ -0,0 +1,52 @@
+#pragma once
+#include <glm/glm.hpp>
+#include <string>
+#include <vector>
+#include "Shader.h"
+
+namespace glml 
+{
+	static const std::string TextureTypeStrings[] = {
+		"texture_diffuse",
+		"texture_specular",
+		"texture_normal",
+		"texture_height"
+	};
+	enum class TextureType : size_t
+	{
+		diffuse = 0,
+		specular = 1,
+		normal = 2,
+		height = 3
+	};
+
+	struct Vertex {
+		glm::vec3 Position;
+		glm::vec3 Normal;
+		glm::vec2 TexCoord;
+		glm::vec3 Color;
+		glm::vec3 Tangent;
+		glm::vec3 Bitangent;
+	};
+	struct Texture {
+		unsigned int id;
+		TextureType type;
+		std::string path;
+	};
+
+	class Mesh {
+	public:
+		std::vector<Vertex>			vertices;
+		std::vector<unsigned int>	indices;
+		std::vector<Texture>		textures;
+
+		Mesh(const std::vector<Vertex>& vertices, const std::vector<unsigned int>& indices, const std::vector<Texture>& textures);
+
+		void Draw(Shader& shader) const;
+	private:
+		unsigned int VAO, VBO, EBO;
+
+		void setupMesh();
+	};
+};
+
--- a/shader/src/Model.cpp
+++ b/shader/src/Model.cpp
@@ -0,0 +1,187 @@
+#include <glad/glad.h>
+#include <assimp/Importer.hpp>
+#include <assimp/postprocess.h>
+#include <iostream>
+#include <stb_image.h>
+#include "Model.h"
+
+using namespace glml;
+
+Model::Model(const std::string path)
+{
+	loadModel(path);
+}
+void Model::Draw(Shader& shader) const
+{
+	for (int i = 0; i < meshes.size(); i++)
+		meshes[i].Draw(shader);
+}
+void Model::loadModel(const std::string path)
+{
+	Assimp::Importer importer;
+	const aiScene* scene = importer.ReadFile(path, aiProcess_Triangulate | aiProcess_FlipUVs);
+
+	if (!scene || scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode)
+	{
+		std::cerr << "[ASSIMP ERROR] Model '" << path << "' not loaded.\n" << importer.GetErrorString() << std::endl;
+		return;
+	}
+	directory = path.substr(0, path.find_last_of('/'));
+
+	processNode(scene->mRootNode, scene);
+}
+void Model::processNode(aiNode* node, const aiScene* scene)
+{
+	unsigned int i;
+	for (i = 0; i < node->mNumMeshes; i++)
+	{
+		aiMesh* mesh = scene->mMeshes[node->mMeshes[i]];
+		meshes.push_back(processMesh(mesh, scene));
+	}
+	for (i = 0; i < node->mNumChildren; i++)
+		processNode(node->mChildren[i], scene);
+}
+Mesh Model::processMesh(aiMesh* mesh, const aiScene* scene)
+{
+	std::vector<Vertex> vertices;
+	std::vector<unsigned int> indices;
+	std::vector<Texture> textures;
+	unsigned int i;
+
+	for (i = 0; i < mesh->mNumVertices; i++)
+	{
+		Vertex vertex;
+		glm::vec3 v;
+		v.x = mesh->mVertices[i].x;
+		v.y = mesh->mVertices[i].y;
+		v.z = mesh->mVertices[i].z;
+		vertex.Position = v;
+
+		if (mesh->mNormals != NULL)
+		{
+			v.x = mesh->mNormals[i].x;
+			v.y = mesh->mNormals[i].y;
+			v.z = mesh->mNormals[i].z;
+			vertex.Normal = v;
+		}
+
+		if (mesh->mTangents != NULL)
+		{
+			v.x = mesh->mTangents[i].x;
+			v.y = mesh->mTangents[i].y;
+			v.z = mesh->mTangents[i].z;
+			vertex.Tangent = v;
+		}
+		if (mesh->mBitangents != NULL)
+		{
+			v.x = mesh->mBitangents[i].x;
+			v.y = mesh->mBitangents[i].y;
+			v.z = mesh->mBitangents[i].z;
+			vertex.Bitangent = v;
+		}
+
+		vertex.Color = glm::vec3(0.0f);
+
+		if (mesh->mTextureCoords[0]) {	// does the mesh contains texture coordinates?
+			glm::vec2 vec;
+			vec.x = mesh->mTextureCoords[0][i].x;
+			vec.y = mesh->mTextureCoords[0][i].y;
+			vertex.TexCoord = vec;
+		}
+		else {
+			vertex.TexCoord = glm::vec2(0.0f);
+		}
+		vertices.push_back(vertex);
+	}
+	for (i = 0; i < mesh->mNumFaces; i++)
+	{
+		aiFace face = mesh->mFaces[i];
+		for (unsigned int j = 0; j < face.mNumIndices; j++)
+			indices.push_back(face.mIndices[j]);
+	}
+	if (mesh->mMaterialIndex >= 0)
+	{
+		aiMaterial* mat = scene->mMaterials[mesh->mMaterialIndex];
+		std::vector<Texture> diffuseMaps = loadMaterialTextures(mat, aiTextureType_DIFFUSE, TextureType::diffuse);
+		textures.insert(textures.end(), diffuseMaps.begin(), diffuseMaps.end());
+
+		std::vector<Texture> specularMaps = loadMaterialTextures(mat, aiTextureType_SPECULAR, TextureType::specular);
+		textures.insert(textures.end(), specularMaps.begin(), specularMaps.end());
+
+		std::vector<Texture> normalMaps = loadMaterialTextures(mat, aiTextureType_NORMALS, TextureType::normal);
+		textures.insert(textures.end(), normalMaps.begin(), normalMaps.end());
+
+		std::vector<Texture> heightMaps = loadMaterialTextures(mat, aiTextureType_HEIGHT, TextureType::height);
+		textures.insert(textures.end(), heightMaps.begin(), heightMaps.end());
+	}
+	return Mesh(vertices, indices, textures);
+}
+std::vector<Texture> Model::loadMaterialTextures(aiMaterial* mat, aiTextureType type, TextureType glmlType)
+{
+	std::vector<Texture> textures;
+
+	for (unsigned int i = 0; i < mat->GetTextureCount(type); i++)
+	{
+		aiString str;
+		mat->GetTexture(type, i, &str);
+		bool loaded = false;
+
+		for (int j = 0; j < textures_loaded.size(); j++)
+		{
+			if (std::strcmp(textures_loaded[j].path.data(), str.C_Str()) == 0)
+			{
+				textures.push_back(textures_loaded[j]);
+				loaded = true;
+				break;
+			}
+		}
+		if (!loaded)
+		{
+			Texture texture;
+			texture.id = load_texture(directory + '/' + str.C_Str());
+			texture.type = glmlType;
+			texture.path = str.C_Str();
+			textures.push_back(texture);
+			textures_loaded.push_back(texture);
+		}
+	}
+	return textures;
+}
+static unsigned int glml::load_texture(const std::string path)
+{
+	return glml::load_texture(path.c_str());
+}
+static unsigned int glml::load_texture(const char* path)
+{
+	unsigned int texture = 0;
+	int width, height, nrChannels, format;
+	unsigned char* data = stbi_load(path, &width, &height, &nrChannels, 0);		// load image to the array of bytes (char = 1 byte)	
+
+	switch (nrChannels)
+	{
+	case 4: format = GL_RGBA; break;
+	case 3: format = GL_RGB; break;
+	case 1: format = GL_RED; break;
+	default: format = GL_RGB; break;
+	}
+
+	if (data) // data != NULL
+	{
+		glGenTextures(1, &texture);
+		glBindTexture(GL_TEXTURE_2D, texture);
+
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+
+		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, format, GL_UNSIGNED_BYTE, data);	// generates texture
+		glGenerateMipmap(GL_TEXTURE_2D);
+	}
+	else {
+		std::cerr << "Could not load texture '" << path << "'\n";
+	}
+	stbi_image_free(data);
+
+	return texture;
+}
--- a/shader/src/Model.h
+++ b/shader/src/Model.h
@@ -0,0 +1,29 @@
+#pragma once
+#include <string>
+#include "Mesh.h"
+#include <vector>
+#include "Shader.h"
+#include <assimp/scene.h>
+
+namespace glml
+{
+	class Model {
+	public:
+		Model(const std::string path);
+
+		void Draw(Shader& shader) const;
+	private:
+		// model data
+		std::vector<Mesh> meshes;
+		std::string directory;
+		std::vector<Texture> textures_loaded;
+
+		void loadModel(const std::string path);
+		void processNode(aiNode* node, const aiScene* scene);
+		Mesh processMesh(aiMesh* mesh, const aiScene* scene);
+		std::vector<Texture> loadMaterialTextures(aiMaterial* mat, aiTextureType type, TextureType glmlType);
+	};
+	static unsigned int load_texture(const char* path);
+	static unsigned int load_texture(const std::string path);
+}
+
--- a/shader/src/Shader.cpp
+++ b/shader/src/Shader.cpp
@@ -0,0 +1,149 @@
+#include "Shader.h"
+#include <iostream>
+#include <fstream>
+#include <sstream>
+#include <glad/glad.h>
+#include <glm/gtc/type_ptr.hpp>
+
+Shader::Shader(const char* vertexShaderSourcePath, const char* fragmentShaderSourcePath, const char* geometryShaderSource, bool directSource)
+{	
+	const char* vertexSource;
+	const char* fragmentSource;
+	const char* geometrySource;
+	std::string v, f, g;
+	if (!directSource)
+	{
+		v = readFile(vertexShaderSourcePath);
+		f = readFile(fragmentShaderSourcePath);
+		vertexSource = v.c_str();
+		fragmentSource = f.c_str();
+		
+		if (geometryShaderSource != NULL)
+		{
+			g = readFile(geometryShaderSource);
+			geometrySource = g.c_str();
+		}
+		else
+			geometrySource = NULL;
+	}
+	else
+	{
+		vertexSource = vertexShaderSourcePath;
+		fragmentSource = fragmentShaderSourcePath;
+		geometrySource = geometryShaderSource;
+	}
+
+	int  success;
+	char infoLog[512];
+
+	unsigned int vertexShader = glCreateShader(GL_VERTEX_SHADER);
+	glShaderSource(vertexShader, 1, &vertexSource, NULL);
+	glCompileShader(vertexShader);	
+	glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
+	if (!success)
+	{
+		glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);
+		std::cerr << "Shader.h: [ERROR] Vertex shader compilation failed!\n" << infoLog << std::endl;
+	}
+
+	unsigned int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
+	glShaderSource(fragmentShader, 1, &fragmentSource, NULL);
+	glCompileShader(fragmentShader);
+	glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
+	if (!success)
+	{
+		glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
+		std::cerr << "Shader.h: [ERROR] Fragment shader compilation failed!\n" << infoLog << std::endl;
+	}
+
+	unsigned int geometryShader;
+	if (geometrySource)
+	{
+		geometryShader = glCreateShader(GL_GEOMETRY_SHADER);
+		glShaderSource(geometryShader, 1, &geometrySource, NULL);
+		glCompileShader(geometryShader);
+		glGetShaderiv(geometryShader, GL_COMPILE_STATUS, &success);
+		if (!success)
+		{
+			glGetShaderInfoLog(geometryShader, 512, NULL, infoLog);
+			std::cerr << "Shader.h: [ERROR] Geometry shader compilation failed!\nShader.h: [ERROR] Path: " << geometryShaderSource;
+			std::cerr << std::endl << infoLog << std::endl;
+		}
+	}
+
+	Program = glCreateProgram();
+	glAttachShader(Program, vertexShader);
+	glAttachShader(Program, fragmentShader);
+	if (geometrySource)
+		glAttachShader(Program, geometryShader);
+	glLinkProgram(Program);
+	glGetProgramiv(Program, GL_LINK_STATUS, &success);
+	if (!success)
+	{
+		glGetProgramInfoLog(Program, 512, NULL, infoLog);
+		std::cerr << "[ERROR] Program linking failed\n" << infoLog << std::endl;
+	}
+
+	glDeleteShader(vertexShader);
+	glDeleteShader(fragmentShader);
+}
+Shader::Shader(std::string vertexShaderSourcePath,
+	std::string fragmentShaderSourcePath,
+	std::string geometryShaderSource,
+	bool directSource)
+{
+	Shader(vertexShaderSourcePath.c_str(), fragmentShaderSourcePath.c_str(), geometryShaderSource.c_str(), directSource);
+}
+Shader::~Shader()
+{
+	glDeleteProgram(Program);
+}
+
+std::string Shader::readFile(const char* path)
+{
+	std::string out;
+	try
+	{
+		std::ifstream ifs(path);	// input file stream
+		std::stringstream buffer;
+		buffer << ifs.rdbuf();		
+		out = buffer.str();		
+	}
+	catch (std::ifstream::failure e)
+	{
+		std::cerr << "[ERROR] Could not read/open file '" << path << "'\n";
+	}
+	return out;
+}
+void Shader::Use()
+{
+	glUseProgram(Program);
+}
+void Shader::setBool(const std::string name, bool value) const
+{
+	glUniform1i(glGetUniformLocation(Program, name.c_str()), value ? 1 : 0);
+}
+void Shader::setFloat(const std::string name, float value) const
+{
+	glUniform1f(glGetUniformLocation(Program, name.c_str()), value);
+}
+void Shader::setInt(const std::string name, int value) const
+{
+	glUniform1i(glGetUniformLocation(Program, name.c_str()), value);
+}
+void Shader::setMat4(const std::string name, glm::mat4 value) const
+{
+	glUniformMatrix4fv(glGetUniformLocation(Program, name.c_str()), 1, GL_FALSE, glm::value_ptr(value));
+}
+void Shader::setVec3(const std::string name, glm::vec3 value) const
+{
+	setVec3(name, value.x, value.y, value.z);
+}
+void Shader::setVec3(const std::string name, float v0, float v1, float v2) const
+{
+	glUniform3f(glGetUniformLocation(Program, name.c_str()), v0, v1, v2);
+}
+void Shader::setMat3(const std::string name, glm::mat3 value) const
+{
+	glUniformMatrix3fv(glGetUniformLocation(Program, name.c_str()), 1, GL_FALSE, glm::value_ptr(value));
+}
--- a/shader/src/Shader.h
+++ b/shader/src/Shader.h
@@ -0,0 +1,27 @@
+#pragma once
+#include <string>
+#include <glm/glm.hpp>
+
+class Shader
+{
+public:
+	unsigned int Program;
+
+	Shader(const char* vertexShaderSourcePath, const char* fragmentShaderSourcePath, const char* geometryShaderSource = NULL, bool directSource = false);
+	Shader(std::string vertexShaderSourcePath, std::string fragmentShaderSourcePath, std::string geometryShaderSource = NULL, bool directSource = false);
+	~Shader();
+
+
+	void Use();
+
+	void setBool(const std::string name, bool value) const;
+	void setFloat(const std::string name, float value) const;
+	void setInt(const std::string name, int value) const;
+	void setMat4(const std::string name, glm::mat4 value) const;
+	void setVec3(const std::string name, glm::vec3 value) const;
+	void setVec3(const std::string name, float v0, float v1, float v2) const;
+	void setMat3(const std::string name, glm::mat3 value) const;
+
+	static std::string readFile(const char* path);	
+};
+
--- a/shader/src/main.cpp
+++ b/shader/src/main.cpp
@@ -0,0 +1,258 @@
+#include <glad/glad.h>
+#include <GLFW/glfw3.h>
+#include <iostream>
+#include <stb_image.h>
+#include <glm/glm.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+#include <glm/gtc/type_ptr.hpp>
+#include <vector>
+#include "Shader.h"
+#include "Camera.h"
+#include "Model.h"
+
+#define WINDOW_NAME  "8. Geometry shader"
+#define TEXTURES_DIR "../../../../textures/"
+#define MODELS_DIR	 "../../../../models/"
+#define SHADERS_DIR	"../src/shaders/"
+
+using namespace std;
+typedef unsigned int uint;
+using std::vector;
+using std::string;
+using glml::Model;
+
+// Global Constants
+// ...
+// Global Variables
+GLFWwindow* window;
+int WINDOW_WIDTH = 800;
+int WINDOW_HEIGHT = 600;
+Camera myCamera(glm::vec3(0.0f, 0.0f, 3.0f));
+float deltaTime = 0.0f;
+float lastFrame = 0.0f;
+float lastX = 400;
+float lastY = 300;
+bool firstmouse = true;
+glm::vec3 lightPos(1.2f, 1.0f, 2.0f);
+glm::vec3 lightColor(1.0f, 1.0f, 1.0f);
+
+uint8_t init(void);
+void framebuffersize_callback(GLFWwindow* window, int width, int height);
+void mouse_callback(GLFWwindow* window, double xpos, double ypos);
+void scroll_callback(GLFWwindow* window, double xoffset, double yoffset);
+void proccessInput(GLFWwindow* window);
+unsigned int load_texture(const char* path, bool flip = true, GLint wrapS = GL_REPEAT, GLint wrapT = GL_REPEAT);
+unsigned int load_cubemap(vector<string> faces);
+
+int main(int argc, char** argv)
+{
+	if (init() != 0)
+		return -1;
+
+	Shader shader(SHADERS_DIR "shader.vert", SHADERS_DIR "shader.frag");
+	Shader normalDisplayShader(SHADERS_DIR "ndShader.vert", SHADERS_DIR "ndShader.frag", SHADERS_DIR "ndShader.geom");
+
+	stbi_set_flip_vertically_on_load(1);
+	Model backpack(MODELS_DIR "backpack/backpack.obj");
+
+	// points 
+	float points[] = {
+		-0.5f,  0.5f, 1.0f, 0.0f, 0.0f, // top-left
+		 0.5f,  0.5f, 0.0f, 1.0f, 0.0f, // top-right
+		 0.5f, -0.5f, 0.0f, 0.0f, 1.0f, // bottom-right
+		-0.5f, -0.5f, 1.0f, 1.0f, 0.0f  // bottom-left
+	};
+
+	unsigned int pointsVAO, pointsVBO;
+	glGenVertexArrays(1, &pointsVAO);
+	glGenBuffers(1, &pointsVBO);
+	glBindVertexArray(pointsVAO);
+	glBindBuffer(GL_ARRAY_BUFFER, pointsVBO);
+	glBufferData(GL_ARRAY_BUFFER, sizeof(points), points, GL_STATIC_DRAW);
+	glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (const void*)0);
+	glEnableVertexAttribArray(0);
+	glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (const void*)(2 * sizeof(float)));
+	glEnableVertexAttribArray(1);
+	glBindVertexArray(0);
+
+	glEnable(GL_DEPTH_TEST);	
+	/* ------------------ MAIN loop ------------------ */
+	while (!glfwWindowShouldClose(window)) {
+		float currentFrame = glfwGetTime();
+		deltaTime = currentFrame - lastFrame;	// cas jak dlouho trval posledni frame
+		lastFrame = currentFrame;				// cas kdy zacal tento frame
+		// input ...
+		proccessInput(window);
+		// rendering commands here ...
+	
+		glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
+		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+		glm::mat4 model(1.0f);
+		glm::mat4 view = myCamera.getViewMatrix();
+		glm::mat4 projection = glm::perspective(glm::radians(myCamera.FOV), WINDOW_WIDTH / (float)WINDOW_HEIGHT, 0.1f, 100.0f);
+
+		shader.Use();
+		shader.setMat4("PVM", projection * view * model);
+		backpack.Draw(shader);
+
+		normalDisplayShader.Use();
+		normalDisplayShader.setMat4("model", model);
+		normalDisplayShader.setMat4("view", view);
+		normalDisplayShader.setMat4("projection", projection);
+		backpack.Draw(normalDisplayShader);
+
+		// check and calls events and swap the buffers
+		glfwSwapBuffers(window);
+		glfwPollEvents();
+	}
+
+	glfwTerminate();
+
+	return 0;
+}
+
+uint8_t init(void) {
+	// init of glfw window
+	glfwInit();
+	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
+	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);	
+	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+	window = glfwCreateWindow(WINDOW_WIDTH, WINDOW_HEIGHT, WINDOW_NAME, NULL, NULL);
+	if (window == NULL) {
+		cerr << "Failed to create glfw window" << endl;
+		glfwTerminate();
+		return 1;
+	}
+	glfwMakeContextCurrent(window);
+	glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
+
+	// init of GLAD
+	if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
+		cerr << "Failed to initialize GLAD" << endl;
+	}
+
+	glfwSetFramebufferSizeCallback(window, framebuffersize_callback);
+	glfwSetCursorPosCallback(window, mouse_callback);
+	glfwSetScrollCallback(window, scroll_callback);
+	return 0;
+}
+void framebuffersize_callback(GLFWwindow* window, int width, int height)
+{
+	glViewport(0, 0, width, height);
+	WINDOW_HEIGHT = height;
+	WINDOW_WIDTH = width;
+}
+void proccessInput(GLFWwindow* window)
+{	
+	if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
+		glfwSetWindowShouldClose(window, true);
+	if (glfwGetKey(window, GLFW_KEY_F1) == GLFW_PRESS)
+		glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+	if (glfwGetKey(window, GLFW_KEY_F2) == GLFW_PRESS)
+		glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+	/* -------------------- Movement -------------------- */
+	if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
+		myCamera.ProccessKeyboard(CAM_FORWARD, deltaTime);
+	if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
+		myCamera.ProccessKeyboard(CAM_BACKWARD, deltaTime);
+	if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
+		myCamera.ProccessKeyboard(CAM_RIGHT, deltaTime);
+	if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
+		myCamera.ProccessKeyboard(CAM_LEFT, deltaTime);
+	if (glfwGetKey(window, GLFW_KEY_LEFT_SHIFT) == GLFW_PRESS)
+		myCamera.ProccessKeyboard(CAM_DOWN, deltaTime);
+	if (glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS)
+		myCamera.ProccessKeyboard(CAM_UP, deltaTime);
+
+}
+void mouse_callback(GLFWwindow* window, double xpos, double ypos)
+{
+	if (firstmouse) {
+		lastX = xpos;
+		lastY = ypos;
+		firstmouse = false;
+	}
+
+	float xoffset = xpos - lastX;
+	float yoffset = lastY - ypos;
+	lastX = xpos;
+	lastY = ypos;
+
+	myCamera.ProccessMouse(xoffset, yoffset);
+}
+void scroll_callback(GLFWwindow* window, double xoffset, double yoffset)
+{
+	myCamera.ProccessScroll(yoffset);
+}
+unsigned int load_texture(const char* path, bool flip, GLint wrapS, GLint wrapT)
+{
+	unsigned int texture = 0;
+	int width, height, nrChannels, format;
+	stbi_set_flip_vertically_on_load(flip);
+	unsigned char* data = stbi_load(path, &width, &height, &nrChannels, 0);		// load image to the array of bytes (char = 1 byte)	
+	
+	switch (nrChannels)
+	{
+	case 4: format = GL_RGBA; break;
+	case 3: format = GL_RGB; break;
+	case 2: format = GL_RED; break;
+	default: format = GL_RGB; break;
+	}
+
+	if (data) // data != NULL
+	{
+		glGenTextures(1, &texture);
+		glBindTexture(GL_TEXTURE_2D, texture);
+		
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrapS);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrapT);		
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+
+		glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data);	// generates texture
+		glGenerateMipmap(GL_TEXTURE_2D);
+	}
+	else {
+		cerr << "Could not load texture '" << path << "'\n";
+	}
+	stbi_image_free(data);
+
+	glBindTexture(GL_TEXTURE_2D, 0);
+
+	return texture;
+}
+unsigned int load_cubemap(vector<string> faces)
+{
+	unsigned int textureID;
+	glGenTextures(1, &textureID);
+	glBindTexture(GL_TEXTURE_CUBE_MAP, textureID);
+
+	int width, height, nrChannels, format;
+	for (int i = 0; i < faces.size(); i++)
+	{
+			unsigned char* data = stbi_load(faces[i].c_str(), &width, &height, &nrChannels, 0);
+			switch (nrChannels)
+			{
+			case 4: format = GL_RGBA; break;
+			case 3: format = GL_RGB; break;
+			case 2: format = GL_RED; break;
+			default: format = GL_RGB; break;
+			}
+			if (data)
+			{
+				glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data);
+			}
+			else {
+				std::cerr << "[ERROR] Failed to load cubemap texture at " << faces[i] << std::endl;
+			}
+			stbi_image_free(data);
+	};
+	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
+
+	return textureID;
+}
--- a/shader/src/shaders/ndShader.frag
+++ b/shader/src/shaders/ndShader.frag
@@ -0,0 +1,7 @@
+#version 330 core
+out vec4 FragColor;
+
+void main()
+{
+    FragColor = vec4(1.0, 1.0, 0.0, 1.0);
+} 
--- a/shader/src/shaders/ndShader.geom
+++ b/shader/src/shaders/ndShader.geom
@@ -0,0 +1,35 @@
+#version 330 core
+
+layout (triangles) in;
+layout (line_strip, max_vertices = 6) out;
+
+in VS_OUT
+{
+	vec3 Normal;
+} gs_in[];
+
+const float MAGNITUDE = 0.4;
+
+uniform mat4 projection;
+
+vec3 GetNormal()
+{
+	vec3 a = vec3(gl_in[0].gl_Position) - vec3(gl_in[1].gl_Position);
+	vec3 b = vec3(gl_in[2].gl_Position) - vec3(gl_in[1].gl_Position);
+	return normalize(cross(a, b));
+}
+void GenLine(int index)
+{
+	gl_Position = projection * gl_in[index].gl_Position;
+	EmitVertex();
+	gl_Position = projection * (gl_in[index].gl_Position + vec4(gs_in[index].Normal, 0.0) * MAGNITUDE);
+	EmitVertex();
+	EndPrimitive();
+}
+
+void main()
+{
+	GenLine(0);
+	GenLine(1);
+	GenLine(2);
+}
--- a/shader/src/shaders/ndShader.vert
+++ b/shader/src/shaders/ndShader.vert
@@ -0,0 +1,22 @@
+#version 330 core
+
+layout (location = 0) in vec3 aPos;
+layout (location = 1) in vec3 aNormal;
+
+out VS_OUT
+{
+	vec3 Normal;
+};
+
+uniform mat4 view, model;
+
+void main()
+{
+	mat3 normalMatrix = mat3(transpose(inverse(view * model)));
+	//Normal = normalize(vec3(vec4(normalMatrix * aNormal, 0.0)));
+	Normal = normalize(normalMatrix * aNormal);
+	gl_Position = view * model * vec4(aPos, 1.0);
+
+	// projection matrix is applied at geometry shader, otherwise the lines generated will not
+	// have correct w value
+}
--- a/shader/src/shaders/shader.frag
+++ b/shader/src/shaders/shader.frag
@@ -0,0 +1,20 @@
+#version 330 core
+
+struct Material
+{
+	sampler2D texture_diffuse0;
+};
+
+out vec4 FragColor;
+
+in VS_OUT
+{	
+	vec2 TexCoord;
+} fs_in;
+
+uniform Material material;
+
+void main()
+{
+	FragColor = texture(material.texture_diffuse0, fs_in.TexCoord);
+}
--- a/shader/src/shaders/shader.vert
+++ b/shader/src/shaders/shader.vert
@@ -0,0 +1,18 @@
+#version 330 core
+
+layout (location = 0) in vec3 aPos;
+layout (location = 1) in vec3 aNormal;
+layout (location = 2) in vec2 aTexCoord;
+
+out VS_OUT
+{	
+	vec2 TexCoord;
+};
+
+uniform mat4 PVM;
+
+void main()
+{
+	TexCoord = aTexCoord;
+	gl_Position = PVM * vec4(aPos, 1.0);
+}