Implemented thread-safe queue.

Other general cleaning. Started making the Light class actually do
something.

Author: htmlboss

.gitattributes

@@ -0,0 +1,17 @@
+# Auto detect text files and perform LF normalization
+* text=auto
+
+# Custom for Visual Studio
+*.cs     diff=csharp
+
+# Standard to msysgit
+*.doc	 diff=astextplain
+*.DOC	 diff=astextplain
+*.docx diff=astextplain
+*.DOCX diff=astextplain
+*.dot  diff=astextplain
+*.DOT  diff=astextplain
+*.pdf  diff=astextplain
+*.PDF	 diff=astextplain
+*.rtf	 diff=astextplain
+*.RTF	 diff=astextplain

ShaderViewer/.vs/MP-APS/v15/.suo

@@ -164,8 +164,6 @@ void GLRenderer::Update(const double glfwTimer) {
 		m_camera.ProcessKeyboard(Camera::DOWN, deltaTime);
 	}
 
-	// Update Mouse
-
 
 	// Update view matrix inside UBO
 	const auto view = m_camera.GetViewMatrix();

ShaderViewer/.vs/MP-APS/v15/Browse.VC.db

@@ -1,13 +1,14 @@
 #pragma once
-#include <array>
+#include <vector>
 
 #include "Timer.h"
+#include "Light.h"
 
 #define KEY_PRESSED(KEY) (IRenderer::m_keys.at(KEY) = true, (void)0 )
 #define KEY_RELEASED(KEY) (IRenderer::m_keys.at(KEY) = false, (void)0 )
 
 class IRenderer {
-
+	typedef std::array<float, 3> Vec3;
 public:
 	IRenderer(const size_t width, const size_t height) : m_width(width), m_height(height) {}
 	virtual ~IRenderer() {}
@@ -23,14 +24,14 @@ class IRenderer {
 	// Deferred Stuff
 	virtual void BeginGeometryPass() const = 0;
 	virtual void EndGeometryPass() const = 0;
-
 	virtual void BeginLightingPass() const = 0;
 
+	virtual void AddLight(const Vec3 Position, const Vec3 Color, const Light::LightType Type) { m_lights.emplace_back(Position, Color, Type); }
+
 	static std::array<bool, 1024> m_keys;
 
 protected:
 	size_t m_width, m_height;
-
 	Timer m_timer;
 
 	const std::array<float, 20> m_screenQuadVertices = {
@@ -40,5 +41,8 @@ class IRenderer {
 		1.0f, 1.0f, 0.0f,		1.0f, 1.0f,
 		1.0f, -1.0f, 0.0f,		1.0f, 0.0f
 	};
+	
+	// Maybe private this later...
+	std::vector<Light> m_lights;
 };
 

ShaderViewer/GLRenderer.cpp

@@ -6,7 +6,7 @@
 #include <glm//gtc/matrix_transform.hpp>
 
 /***********************************************************************************/
-Light::Light(const glm::vec3& Position, const glm::vec3& Color, const LightType lightType) : m_position(Position), m_color(Color) {
+Light::Light(const Vec3 Position, const Vec3 Color, const LightType lightType) : m_position(Position), m_color(Color) {
 
 	glGenVertexArrays(1, &m_vao);
 	glGenBuffers(1, &m_vbo);
@@ -18,16 +18,14 @@ Light::Light(const glm::vec3& Position, const glm::vec3& Color, const LightType
 
 	// Vertex Positions
 	glEnableVertexAttribArray(0);
-	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, static_cast<GLvoid*>(0));
-
-	glBindVertexArray(0);
+	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
 }
 
 /***********************************************************************************/
 Light::~Light() {
 }
 
-/***********************************************************************************/
+/***********************************************************************************
 void Light::Draw(GLShaderProgram& shader) {
 	
 	shader.Bind();
@@ -42,3 +40,4 @@ void Light::Draw(GLShaderProgram& shader) {
 	glDrawArrays(GL_TRIANGLES, 0, 36);
 	glBindVertexArray(0);
 }
+*/

ShaderViewer/IRenderer.h

@@ -1,11 +1,12 @@
 #pragma once
 
 #include <GL/glew.h>
-#include <glm/gtc/type_ptr.hpp>
+#include <array>
 
 class GLShaderProgram;
 
 class Light {
+	typedef std::array<float, 3> Vec3;
 public:
 
 	enum LightType {
@@ -14,14 +15,14 @@ class Light {
 		DIRLIGHT
 	};
 
-	Light(const glm::vec3& Position, const glm::vec3& Color, const LightType lightType);
+	Light(const Vec3 Position, const Vec3 Color, const LightType lightType);
 	~Light();
 
-	void Draw(GLShaderProgram& shader);
+	//void Draw(GLShaderProgram& shader);
 
 private:
-	glm::vec3 m_position;
-	glm::vec3 m_color;
+	Vec3 m_position;
+	Vec3 m_color;
 
 	GLuint m_vao, m_vbo;
 };

ShaderViewer/Light.cpp

@@ -36,8 +36,6 @@ void Mesh::SetInstancing(const std::initializer_list<glm::vec3>& args) {
 	glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), nullptr);
 	glBindBuffer(GL_ARRAY_BUFFER, 0);
 	glVertexAttribDivisor(3, 1); // Tell OpenGL this is an instanced vertex attribute.
-
-	glBindVertexArray(0);
 }
 
 /***********************************************************************************/
@@ -48,7 +46,6 @@ void Mesh::Draw(GLShaderProgram& shader) {
 	// Draw mesh
 	glBindVertexArray(m_vao);
 	glDrawElements(GL_TRIANGLES, m_indices.size(), GL_UNSIGNED_INT, nullptr);
-	glBindVertexArray(0);
 }
 
 /***********************************************************************************/
@@ -59,7 +56,6 @@ void Mesh::DrawInstanced(GLShaderProgram& shader) {
 	// Draw instanced mesh
 	glBindVertexArray(m_vao);
 	glDrawElementsInstanced(GL_TRIANGLES, m_indices.size(), GL_UNSIGNED_INT, nullptr, m_instanceOffsets.size());
-	glBindVertexArray(0);
 }
 
 /***********************************************************************************/
@@ -121,6 +117,4 @@ void Mesh::setupMesh() {
 	// Vertex Texture Coords
 	glEnableVertexAttribArray(2);
 	glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), reinterpret_cast<GLvoid*>(offsetof(Vertex, TexCoords)));
-
-	glBindVertexArray(0);
 }

ShaderViewer/Light.h

@@ -7,6 +7,16 @@
 #include "Texture.h"
 #include "GLShaderProgram.h"
 
+/***********************************************************************************/
+struct Material {
+	Material(const std::string_view Name) : name(Name) {};
+
+	const std::string name;
+
+
+	bool wireframe = false;
+};
+
 /***********************************************************************************/
 struct Vertex {
 	glm::vec3 Position;

ShaderViewer/Material.h

@@ -106,43 +106,33 @@ Mesh Model::processMesh(aiMesh* mesh, const aiScene* scene) {
 
 	for (GLuint i = 0; i < mesh->mNumVertices; ++i) {
 		Vertex vertex;
-		glm::vec3 vector; // We declare a placeholder vector since assimp uses its own vector class that doesn't directly convert to glm's vec3 class so we transfer the data to this placeholder glm::vec3 first.
-		
-		// Positions
+
 		if (mesh->HasPositions()) {
-			vector.x = mesh->mVertices[i].x;
-			vector.y = mesh->mVertices[i].y;
-			vector.z = mesh->mVertices[i].z;
-			vertex.Position = vector;
+			vertex.Position.x = mesh->mVertices[i].x;
+			vertex.Position.y = mesh->mVertices[i].y;
+			vertex.Position.z = mesh->mVertices[i].z;
 		}
 
-		// Normals
 		if (mesh->HasNormals()) {
-			vector.x = mesh->mNormals[i].x;
-			vector.y = mesh->mNormals[i].y;
-			vector.z = mesh->mNormals[i].z;
-			vertex.Normal = vector;
+			vertex.Normal.x = mesh->mNormals[i].x;
+			vertex.Normal.y = mesh->mNormals[i].y;
+			vertex.Normal.z = mesh->mNormals[i].z;
 		}
 
-		// Tangents
 		if (mesh->HasTangentsAndBitangents()) {
-			vector.x = mesh->mTangents[i].x;
-			vector.y = mesh->mTangents[i].y;
-			vector.z = mesh->mTangents[i].z;
-			vertex.Tangent = vector;
+			vertex.Tangent.x = mesh->mTangents[i].x;
+			vertex.Tangent.y = mesh->mTangents[i].y;
+			vertex.Tangent.z = mesh->mTangents[i].z;
 		}
 
-		// Texture Coordinates
-		if (mesh->mTextureCoords[0]) { // Does the mesh contain texture coordinates?
-			glm::vec2 vec;
+		if (mesh->HasTextureCoords(0)) {
 			// A vertex can contain up to 8 different texture coordinates. We thus make the assumption that we won't 
 			// use models where a vertex can have multiple texture coordinates so we always take the first set (0).
-			vec.x = mesh->mTextureCoords[0][i].x;
-			vec.y = mesh->mTextureCoords[0][i].y;
-			vertex.TexCoords = vec;
+			vertex.TexCoords.x = mesh->mTextureCoords[0][i].x;
+			vertex.TexCoords.y = mesh->mTextureCoords[0][i].y;
 		}
 		else {
-			vertex.TexCoords = glm::vec2(0.0f, 0.0f);
+			vertex.TexCoords = glm::vec2(0.0f);
 		}
 		vertices.push_back(vertex);
 	}
@@ -169,7 +159,6 @@ Mesh Model::processMesh(aiMesh* mesh, const aiScene* scene) {
 
 		// 1. Diffuse maps
 		const auto diffuseMaps = loadMatTextures(material, aiTextureType_DIFFUSE, "texture_diffuse");
-
 		textures.insert(textures.end(), diffuseMaps.begin(), diffuseMaps.end());
 
 		// 2. Specular maps

ShaderViewer/Mesh.cpp

@@ -162,7 +162,6 @@
     <ClCompile Include="HUDText.cpp" />
     <ClCompile Include="Light.cpp" />
     <ClCompile Include="main.cpp" />
-    <ClCompile Include="Material.cpp" />
     <ClCompile Include="Mesh.cpp" />
     <ClCompile Include="Model.cpp" />
     <ClCompile Include="GLRenderer.cpp" />
@@ -182,7 +181,6 @@
     <ClInclude Include="HUDText.h" />
     <ClInclude Include="IRenderer.h" />
     <ClInclude Include="Light.h" />
-    <ClInclude Include="Material.h" />
     <ClInclude Include="Mesh.h" />
     <ClInclude Include="Model.h" />
     <ClInclude Include="GLRenderer.h" />
@@ -194,6 +192,7 @@
     <ClInclude Include="Texture.h" />
     <ClInclude Include="Timer.h" />
     <ClInclude Include="Utils.h" />
+    <ClInclude Include="Utils\Queue.h" />
   </ItemGroup>
   <ItemGroup>
     <None Include="..\README.md" />

ShaderViewer/Mesh.h

@@ -59,9 +59,6 @@
     <ClCompile Include="GLShaderProgram.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="Material.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="Shader.h">
@@ -118,7 +115,7 @@
     <ClInclude Include="Utils.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="Material.h">
+    <ClInclude Include="Utils\Queue.h">
       <Filter>Header Files</Filter>
     </ClInclude>
   </ItemGroup>

ShaderViewer/Model.cpp

@@ -15,8 +15,6 @@ Skybox::Skybox(const std::string& TextureDirectory) {
 	glBufferData(GL_ARRAY_BUFFER, sizeof(m_skyboxVertices), &m_skyboxVertices, GL_STATIC_DRAW);
 	glEnableVertexAttribArray(0);
 	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), nullptr);
-	// Cleanup
-	glBindVertexArray(0);
 
 	// Iterate through given directory and find files (labeled 1-6 for proper load order)
 	int i = 0; // Index for the loop
@@ -34,7 +32,7 @@ Skybox::Skybox(const std::string& TextureDirectory) {
 	int n = 0;
 	i = 0; // Index for the loop
 	for (auto& face : m_faces) {
-		image = ResourceLoader::LoadSTBImage(face.c_str(), &x, &y, &n, ResourceLoader::RGB); // 3 = STB_rgb
+		image = ResourceLoader::LoadSTBImage(face.c_str(), &x, &y, &n, ResourceLoader::RGB);
 
 		glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGB, x, y, 0, GL_RGB, GL_UNSIGNED_BYTE, image);
 		glGenerateMipmap(GL_TEXTURE_2D);
@@ -83,7 +81,5 @@ void Skybox::Draw(GLShaderProgram& shader, const glm::mat4& CameraMatrix, const
 	glBindTexture(GL_TEXTURE_CUBE_MAP, m_textureID);
 	glDrawArrays(GL_TRIANGLES, 0, 36);
 
-	// Cleanup
-	glBindVertexArray(0);
 	glDepthFunc(GL_LESS); // Set depth function back to default
 }

ShaderViewer/ShaderViewer.vcxproj

@@ -12,8 +12,8 @@ Texture::Texture(const std::string_view ModelPath, const std::string_view Textur
 	glGenTextures(1, &m_texture);
 	glBindTexture(GL_TEXTURE_2D, m_texture);
 	// Set texture parameters
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrapMode);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrapMode);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
 	// Texture filtering
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); // linearly interpolates between the two closest mipmaps and samples the texture via linear interpolation.
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // Mipmaps do not apply to magnification.