added in poor grid

backend/include/backend/Shader.hpp

@@ -19,6 +19,7 @@ public:
 	void Use();
 
 	void SetUniform(const std::string& name, const glm::mat4& value);
+	void SetUniform(const std::string& name, const glm::vec4& value);
 
 private:
 	unsigned int id;

backend/include/backend/Transformable.hpp

@@ -8,16 +8,17 @@ class Transformable
 public:
 	Transformable();
 
-	const glm::vec3& GetPosition();
+	const glm::vec3& GetPosition() const;
 	void SetPosition(const glm::vec3& pos);
 	void Move(const glm::vec3& direction);
 
-	const glm::vec3 GetRotation();
+	const glm::vec3 GetRotation() const;
+	const glm::quat& GetQuaternion() const;
 	void SetRotation(const glm::vec3& axis, float angle);
 	void SetRotation(const glm::vec3& eulerAngles);
 	void Rotate(const glm::vec3& axis, float angle);
 
-	const glm::vec3& GetScale();
+	const glm::vec3& GetScale() const;
 	void SetScale(const glm::vec3& scale);
 	void Scale(const glm::vec3& factor);
 

backend/src/Shader.cpp

@@ -85,4 +85,13 @@ void AbstractShader::SetUniform(const std::string& name, const glm::mat4& value)
 		return;
 
 	glUniformMatrix4fv(location, 1, GL_FALSE, glm::value_ptr(value));												
+}
+
+void AbstractShader::SetUniform(const std::string& name, const glm::vec4& value)
+{
+	GLint location = glGetUniformLocation(id, name.c_str());
+	if (location == -1)
+		return;
+
+	glUniform4fv(location, 1, glm::value_ptr(value));
 }

backend/src/Transformable.cpp

@@ -6,7 +6,7 @@ Transformable::Transformable() :
 	CalculateTransformationMatrix();
 }
 
-const glm::vec3& Transformable::GetPosition()
+const glm::vec3& Transformable::GetPosition() const
 {
 	return position;
 }
@@ -23,11 +23,16 @@ void Transformable::Move(const glm::vec3& direction)
 	CalculateTransformationMatrix();
 }
 
-const glm::vec3 Transformable::GetRotation()
+const glm::vec3 Transformable::GetRotation() const
 {
 	return glm::eulerAngles(orientation);
 }
 
+const glm::quat& Transformable::GetQuaternion() const
+{
+	return orientation;
+}
+
 void Transformable::SetRotation(const glm::vec3& axis, float angle)
 {
 	orientation = glm::quat(glm::radians(angle), axis);
@@ -46,7 +51,7 @@ void Transformable::Rotate(const glm::vec3& axis, float angle)
 	CalculateTransformationMatrix();
 }
 
-const glm::vec3& Transformable::GetScale()
+const glm::vec3& Transformable::GetScale() const
 {
 	return scale;
 }

src/Application.cpp

@@ -19,8 +19,8 @@ Application::~Application()
 	ImGui_ImplGlfw_Shutdown();
 	ImGui::DestroyContext();
 
-	if (cube != nullptr)
+	if (grid != nullptr)
-		delete cube;
+		delete grid;
 
 	if (window != nullptr) 
 	{
@@ -129,7 +129,7 @@ void Application::Init(int width, int height, const std::string& title)
 
 	activeCamera = &camera;
 
-	cube = new Cuboid();
+	grid = new Grid(glm::vec2(5.0f, 4.0f), 25, 20);
 	cubePosition = glm::vec3(0.0f);
 	cubeOrientation = glm::vec3(0.0f);
 	cubeScale = glm::vec3(1.0f);
@@ -137,6 +137,10 @@ void Application::Init(int width, int height, const std::string& title)
 	data.camera = &camera;
 	data.orthoCam = &orthoCam;
 
+	glfwWindowHint(GLFW_SAMPLES, 4);
+
+	glEnable(GL_CULL_FACE);
+	glEnable(GL_MULTISAMPLE);
 }
 
 void Application::Launch()
@@ -145,9 +149,9 @@ void Application::Launch()
 	{
 		glfwPollEvents();
 
-		cube->SetPosition(cubePosition);
+		grid->SetPosition(cubePosition);
-		cube->SetRotation(cubeOrientation);
+		grid->SetRotation(cubeOrientation);
-		cube->SetScale(cubeScale);
+		grid->SetScale(cubeScale);
 
 		glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
 		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
@@ -156,11 +160,11 @@ void Application::Launch()
 		ImGui_ImplGlfw_NewFrame();
 		ImGui::NewFrame();
 
-		cube->Draw(*activeCamera);
+		grid->Draw(*activeCamera);
 
 		ImGui::Begin("Debug");
 
-		if (ImGui::CollapsingHeader("Cube"))
+		if (ImGui::CollapsingHeader("Grid"))
 		{
 			ImGui::SliderFloat3("Position", &(cubePosition[0]), -2.0f, 2.0f);
 			ImGui::SliderFloat3("Orientation", &(cubeOrientation[0]), 0.0f, glm::two_pi<float>());

src/Application.hpp

@@ -2,7 +2,7 @@
 
 #include <string>
 #include "backend/Camera.hpp"
-#include "Cuboid.hpp"
+#include "Grid.hpp"
 
 struct GLFWwindow;
 
@@ -47,5 +47,5 @@ private:
 	CameraBase* activeCamera;
 
 	glm::vec3 cubeOrientation, cubePosition, cubeScale;
-	Cuboid* cube;
+	Grid* grid;
 };

src/CMakeLists.txt

@@ -1,6 +1,6 @@
 add_executable(visualizer
 	"main.cpp" "Application.cpp" "Cuboid.cpp"
-)
+  "Grid.cpp")
 
 target_sources(visualizer PUBLIC 
 	${VENDOR_DIR}/imgui/backends/imgui_impl_opengl3.cpp

src/Cuboid.cpp

@@ -77,9 +77,6 @@ Cuboid::Cuboid()
 	}
 
 	type = PrimitiveType::Lines;
-
-	view = glm::lookAt(glm::vec3(2.0f, 2.0f, -3.5f), glm::vec3(0.0f), glm::vec3(0.0f, 1.0f, 0.0f));
-	perspective = glm::perspective(glm::radians(100.0f), 16.0f / 9.0f, 0.01f, 100.0f);
 }
 
 void Cuboid::InitializeShader(const CameraBase& camera) const

src/Cuboid.hpp

@@ -15,9 +15,4 @@ public:
 	Cuboid();
 
 	void InitializeShader(const CameraBase& camera) const override;
-
-private:
-
-	// TODO: Remove view and projection matrices from cube class
-	glm::mat4 view, perspective;
 };

src/Grid.cpp

@@ -0,0 +1,102 @@
+#include "Grid.hpp"
+
+#include <stdexcept>
+#include <vector>
+
+#include "backend/Camera.hpp"
+#include "backend/ObjectManager.hpp"
+#include "Util.hpp"
+
+Grid::Grid(const glm::vec2& size, unsigned int linesAlongWidth, unsigned int linesAlongHeight)
+{
+	std::vector<float> vertices;
+	std::vector<unsigned int> indices;
+
+	glm::vec2 halfSize = size / 2.0f;
+
+	// Unoptimized memory usage
+	for (unsigned int x = 0; x <= linesAlongWidth; x++)
+	{
+		vertices.push_back(-halfSize.x + (float)x * size.x / (float)linesAlongWidth);
+		vertices.push_back(-halfSize.y);
+
+		vertices.push_back(-halfSize.x + (float)x * size.x / (float)linesAlongWidth);
+		vertices.push_back(halfSize.y);
+
+		indices.push_back(2 * x);
+		indices.push_back(2 * x + 1);
+	}
+
+	unsigned int lastIndex = indices.back() + 1;
+	for (unsigned int y = 0; y <= linesAlongHeight; y++)
+	{
+		vertices.push_back(-halfSize.x);
+		vertices.push_back(-halfSize.y + (float)y * size.y / (float)linesAlongHeight);
+
+		vertices.push_back(halfSize.x);
+		vertices.push_back(-halfSize.y + (float)y * size.y / (float)linesAlongHeight);
+
+		indices.push_back(lastIndex + 2 * y);
+		indices.push_back(lastIndex + 2 * y + 1);
+	}
+
+	vao = VAOFactory::Produce(vertices, indices,
+		{
+			{ 2, GL_FLOAT, GL_FALSE, 2 * sizeof(float), (void*)0 }
+		}
+	);
+
+	shader = ShaderManager::GetInstance().Get(GRID_ID);
+	if (shader == nullptr)
+	{
+		shader = ShaderFactory::Produce(
+			R"(
+				#version 460 core
+
+				layout (location = 0) in vec2 aPos;
+
+				uniform mat4 model;
+				uniform mat4 view;
+				uniform mat4 perspective;
+
+				void main()
+				{
+					gl_Position = perspective * view * model * vec4(aPos, 0.0f, 1.0f);
+				}
+			)",
+			R"(
+				#version 460 core
+
+				out vec4 FragColor;
+
+				uniform vec4 gridColor;
+
+				void main()
+				{
+					FragColor = gridColor;
+				}
+			)"
+		);
+
+		if (!shader->Good())
+		{
+			throw std::runtime_error("Shader creation failed");
+		}
+
+		ShaderManager::GetInstance().Register(GRID_ID, shader);
+	}
+
+	type = PrimitiveType::Lines;
+}
+
+void Grid::InitializeShader(const CameraBase& camera) const
+{
+	if(glm::dot(glm::rotate(camera.GetQuaternion(), glm::vec3(0.0f, 0.0f, 1.0f)), glm::rotate(GetQuaternion(), glm::vec3(0.0f, 0.0f, 1.0f))) > 0)
+		shader->SetUniform("gridColor", glm::vec4(0.5f));
+	else
+		shader->SetUniform("gridColor", glm::vec4(0.0f));
+
+	shader->SetUniform("model", transformation);
+	shader->SetUniform("view", camera.GetView());
+	shader->SetUniform("perspective", camera.GetProjection());
+}

src/Grid.hpp

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "backend/Drawable.hpp"
+#include "backend/Transformable.hpp"
+
+class Grid : 
+	public Transformable, public Drawable
+{
+public:
+	Grid(const glm::vec2& size, unsigned int linesAlongWidth, unsigned int linesAlongHeight);
+
+	void InitializeShader(const CameraBase& camera) const override;
+};

src/Util.hpp

@@ -1,3 +1,4 @@
 #pragma once
 
-#define CUBOID_ID 0x1
+#define CUBOID_ID 0x1
+#define GRID_ID 0x2