introduced new bugs

src/Application.cpp

@@ -19,8 +19,8 @@ Application::~Application()
 	ImGui_ImplGlfw_Shutdown();
 	ImGui::DestroyContext();
 
-	if (plot != nullptr)
-		delete plot;
+	for (Shape* shape : shapes)
+		delete shape;
 
 	if (window != nullptr) 
 	{
@@ -121,16 +121,23 @@ void Application::Init(int width, int height, const std::string& title)
 
 	float aspectRatio = (float)windowWidth / (float)windowHeight;
 	camera = OrbitingCamera(glm::vec3(0.0f, 0.0f, 0.0f), 6.0f);
+	camera.Update(100.0f, aspectRatio, 0.01f, 100.0f);
 	pitch = camera.GetAngles().x;
 	yaw = camera.GetAngles().y;
 
-	plot = new Plot3D({ -glm::two_pi<float>(), -glm::two_pi<float>(), -1.5f, glm::two_pi<float>(), glm::two_pi<float>(), 1.5f }, 0.5f, 0.1f,
-		[](float x, float y)
-		{
-			return (cos(x) + cos(y)) * 0.5f;
-			// return cos(x);
-		}
-		);
+	Shape* shape = new Cube();
+	shape->Move(glm::vec3(0.0f, -2.0f, 0.0f));
+	shape->Rotate(glm::vec3(1.0f, 1.0f, 1.0f), 60);
+	// shapes.push_back(shape);
+
+	shape = new Cube();
+	shape->Move(glm::vec3(0.0f, 2.0f, 0.0f));
+	shape->Rotate(glm::vec3(0.5f, 1.0f, 1.2f), 60);
+	shapes.push_back(shape);
+
+	shape = new Pyramid();
+	shape->Move(glm::vec3(-2.0f, 0.0f, 0.0f));
+	shapes.push_back(shape);		// TODO: FIX: Creating a new VAO corrupts the other one????? how?? check if all bind calls are correct
 
 	cubePosition = glm::vec3(0.0f);
 	cubeOrientation = glm::vec3(0.0f);
@@ -150,9 +157,9 @@ void Application::Launch()
 	{
 		glfwPollEvents();
 
-		plot->SetPosition(cubePosition);
-		plot->SetRotation(cubeOrientation);
-		plot->SetScale(cubeScale);
+		// plot->SetPosition(cubePosition);
+		// plot->SetRotation(cubeOrientation);
+		// plot->SetScale(cubeScale);
 
 		camera.SetPosition(pitch, yaw);
 
@@ -163,7 +170,8 @@ void Application::Launch()
 		ImGui_ImplGlfw_NewFrame();
 		ImGui::NewFrame();
 
-		plot->Draw(camera);
+		for (Shape* shape : shapes)
+			camera.Draw(*shape);
 
 		ImGui::Begin("Debug");
 

src/Application.hpp

@@ -2,7 +2,7 @@
 
 #include <string>
 #include "OrbitingCamera.hpp"
-#include "Plot3D.hpp"
+#include "Shapes.hpp"
 
 struct GLFWwindow;
 
@@ -45,5 +45,5 @@ private:
 	float pitch, yaw;
 
 	glm::vec3 cubeOrientation, cubePosition, cubeScale;
-	Plot3D* plot;
+	std::vector<Shape*> shapes;
 };

src/CMakeLists.txt

@@ -1,6 +1,6 @@
 add_executable(visualizer
 	"main.cpp" "Application.cpp" 
-   "Plot3D.cpp" "OrbitingCamera.cpp"
+    "OrbitingCamera.cpp" "Shape.cpp"
 )
 
 target_sources(visualizer PUBLIC 

src/Plot3D.cpp

@@ -1,251 +0,0 @@
-#include "Plot3D.hpp"
-
-#include <optional>
-#include <array>
-#include <iostream>
-
-#include <lol/lol.hpp>
-#include "Util.hpp"
-
-inline float Map(const glm::vec2& from, const glm::vec2& to, float val)
-{
-	return (val - from.x) * (to.y - to.x) / (from.y - from.x) + to.x;
-}
-
-/**
- * Creates the list of vertices for this plot.
- * 
- * @param[in]  domainAndRange The domain in which to plot the function and the maximum allowed range (values outside are clipped)
- * @param[in]  scale          Scale of the plot
- * @param[in]  resolution     Step size in which to scan over the function
- * @param[in]  func           Function to plot
- * @param[out] functionValues Values of the function at each point (if any)
- * @param[out] vertices       Vertices of the function
- * 
- * @return Number of vertices per slice in the plot
- */
-unsigned int CreateVertexList(const lol::BBox& domainAndRange, float scale, float resolution, PlottableFunction func, std::vector<std::optional<unsigned int>>& functionValues, std::vector<float>& vertices);
-
-/**
- * Triangulate the set of vertices to create the plot
- * 
- * @param[in]  functionValues Values of the function at each point (if any)
- * @param[in]  sliceLength    Number of vertices per slice in the plot
- * @param[out] indices        The indices for the mesh
- */
-void Triangulate(const std::vector<std::optional<unsigned int>>& functionValues, unsigned int sliceLength, std::vector<unsigned int>& indices);
-
-Plot3D::Plot3D(const lol::BBox& domainAndRange, float scale, float resolution, PlottableFunction func)
-{
-	// magic epsilon
-	if (resolution < 0.0001f) return;
-
-	std::vector<float> vertices;
-	std::vector<unsigned int> indices;
-
-	std::vector<std::optional<unsigned int>> functionValues;
-
-	unsigned int sliceLength = CreateVertexList(domainAndRange, scale, resolution, func, functionValues, vertices);
-	Triangulate(functionValues, sliceLength, indices);
-
-	vao = lol::UniqueVertexArrayObject::Share(vertices, indices,
-		lol::Layout {
-			{ 3, GL_FLOAT, GL_FALSE, sizeof(float) * 4, (void*)0 },
-			{ 1, GL_FLOAT, GL_FALSE, sizeof(float) * 4, (void*)(3 * sizeof(float))}
-		}
-	);
-
-	shader = lol::ShaderManager::GetInstance().Get(PLOT3D_ID);
-	if (shader == nullptr)
-	{
-		shader = lol::UniqueShader::Share(
-			R"(
-				#version 440 core
-			
-				layout (location = 0) in vec3 aPosition;
-				layout (location = 1) in float aU;
-
-				out float u;
-
-				uniform mat4 model;
-				uniform mat4 view;
-				uniform mat4 projection;
-
-				void main()
-				{
-					u = aU;
-					gl_Position = projection * view * model * vec4(aPosition, 1.0f);
-				}
-			)",
-				R"(
-				#version 440 core
-
-				in float u;
-
-				out vec4 FragColor;
-
-				void main()
-				{
-					FragColor = vec4(1.0f - u, 0.0f, u, 1.0f);
-				}
-			)"
-		);
-
-		lol::ShaderManager::GetInstance().Register(PLOT3D_ID, shader);
-	}
-}
-
-void Plot3D::PreRender(const lol::CameraBase& camera) const
-{
-	shader->SetUniform("model", transformation);
-	shader->SetUniform("view", camera.GetView());
-	shader->SetUniform("projection", camera.GetProjection());
-}
-
-unsigned int CreateVertexList(const lol::BBox& domainAndRange, float scale, float resolution, PlottableFunction func, std::vector<std::optional<unsigned int>>& functionValues, std::vector<float>& vertices)
-{
-	unsigned int sliceLength = 0;
-
-	// Intervals of the domain and (desired) range
-	glm::vec2 xInterval(domainAndRange.x, domainAndRange.w);
-	glm::vec2 yInterval(domainAndRange.y, domainAndRange.h);
-	glm::vec2 zInterval(domainAndRange.z, domainAndRange.d);
-
-	// Bounding box of the graph in 3D space (centered at (0, 0, 0)
-	glm::vec2 xBounds = glm::vec2(-0.5f, 0.5f) * ((xInterval.y - xInterval.x) * scale);
-	glm::vec2 yBounds = glm::vec2(-0.5f, 0.5f) * ((yInterval.y - yInterval.x) * scale);
-
-	// Calculate function values
-	unsigned int index = 0;
-	float minFunctionValue = std::numeric_limits<float>::max();
-	float maxFunctionValue = std::numeric_limits<float>::min();
-
-	// Loop over the function and query function values at each point
-	for (float y = yInterval.x; y <= yInterval.y; y += resolution)
-	{
-		sliceLength = 0;	// Length of the current slice
-
-		for (float x = xInterval.x; x <= xInterval.y; x += resolution)
-		{
-			float val = func(x, y);
-			std::optional<unsigned int> pointIndex;
-
-			// If function value is in bbox
-			if (val >= zInterval.x && val <= zInterval.y)
-			{
-				// Set vertex x and y coordinate
-				// z is still left in "function space"
-				// The fourth value is later gonna be the "normalized z", it is set to 0.0 here to avoid resizing and inserting into the vector later
-				vertices.push_back(Map(xInterval, xBounds, x));
-				vertices.push_back(val);	// Will be corrected later!
-				vertices.push_back(Map(yInterval, yBounds, y));
-				vertices.push_back(0.0f);
-
-				// Update the min/max vals
-				minFunctionValue = std::min(minFunctionValue, val);
-				maxFunctionValue = std::max(maxFunctionValue, val);
-
-				pointIndex = index;
-				index++;
-			}
-
-			// Insert the value of this function into the function value array
-			functionValues.push_back(pointIndex);
-			sliceLength++;
-		}
-
-	}
-
-	// Update z interval, so the function is scaled properly later
-	zInterval = glm::vec2(minFunctionValue, maxFunctionValue);
-	glm::vec2 zBounds = glm::vec2(-0.5f, 0.5f) * ((zInterval.y - zInterval.x) * scale);
-
-	for (unsigned int i = 3; i < vertices.size(); i += 4)
-	{
-		// Go over array and replace the normalized z with the actual value, and update z
-		vertices[i] = Map(zInterval, glm::vec2(0.0f, 1.0f), vertices[i - 2]);
-		vertices[i - 2] = Map(zInterval, zBounds, vertices[i - 2]);
-	}
-
-	return sliceLength;
-}
-
-void Triangulate(const std::vector<std::optional<unsigned int>>& functionValues, unsigned int sliceLength, std::vector<unsigned int>& indices)
-{
-
-	/*
-	* This is what the desired meshing should look like
-	*                                                               +y
-	* CurrentSlice    o---o---o---o---o---o---o---o   x   o          ^
-	*                 | /   \ | / | / | /       \ | \   / |          |
-	* PreviousSlice   o   x   o---o---o   x   x   o---o---o          +---> +x
-	*
-	*
-	* Possible fragment constellations
-	* +---------+---------+---------+---------+---------+---------+
-	* |  2---1  |  o---o  |  o---o  |  x   o  |  o---o  |  o   x  |
-	* |  |   |  |  | / |  |  | /    |    / |  |    \ |  |  | \    |
-	* |  3---4  |  o---o  |  o   x  |  o---o  |  x   o  |  o---o  |
-	* +---------+---------+---------+---------+---------+---------+
-	*
-	*                      123,      134,      124,      234
-	*
-	* o = Function value inside bbox
-	* x = Function value outside bbox
-	*
-	* By default OpenGL treats triangles defined in couter-clockwise order as "front facing". So the algorithm
-	* should construct the triangles in that way (even if we're not culling faces, just to not have any funny bugs in the future)
-	*
-	* The algorithm works as follows:
-	*  1. Pick a patch of 4 points from the value list, and label them like in the diagram above
-	*  2. Attempt to connect the 123 constellation.
-	*  3. Attempt to connect the next constellation, until none are left
-	*    -> Success: Go to 1
-	*    -> Failure: Go to 3
-	*/
-
-	struct Constellation {
-		unsigned int i, j, k;
-	};
-
-	// Possible constellations
-	std::array<Constellation, 4> constellations = {
-		Constellation {0, 1, 2},
-		Constellation {0, 2, 3},
-		Constellation {0, 1, 3},
-		Constellation {1, 2, 3}
-	};
-	std::array<const std::optional<unsigned int>*, 4> points;
-
-	// Loop over vertices, starting at (1, 1)
-	for (unsigned int y = 1; y * sliceLength < functionValues.size(); y++)
-	{
-		for (unsigned int x = 1; x < sliceLength; x++)
-		{
-			// "Overlay the square", basically assigns a number to the vertices according to the diagram above
-			points = {
-				&functionValues[y * sliceLength + x],
-				&functionValues[y * sliceLength + (x - 1)],
-				&functionValues[(y - 1) * sliceLength + (x - 1)],
-				&functionValues[(y - 1) * sliceLength + x],
-			};
-
-			// Try and match the first two constellations
-			int matches = 0;
-			for (Constellation& constellation : constellations)
-			{
-				// This constellation doesnt match
-				if (!(points[constellation.i]->has_value() && points[constellation.j]->has_value() && points[constellation.k]->has_value()))
-					continue;
-
-				indices.push_back(points[constellation.i]->value());
-				indices.push_back(points[constellation.j]->value());
-				indices.push_back(points[constellation.k]->value());
-
-				matches++;
-				if (matches == 2)
-					break;
-			}
-		}
-	}
-}

src/Plot3D.hpp

@@ -1,17 +0,0 @@
-#pragma once
-
-#include <functional>
-
-#include <lol/lol.hpp>
-
-typedef std::function<float(float, float)> PlottableFunction;
-
-class Plot3D :
-	public lol::Transformable, public lol::Drawable
-{
-public:
-	Plot3D(const lol::BBox& domainAndRange, float scale, float resolution, PlottableFunction func);
-
-private:
-	void PreRender(const lol::CameraBase& camera) const override;
-};

src/Shape.cpp

@@ -0,0 +1,113 @@
+#include "Shapes.hpp"
+
+#include "Util.hpp"
+
+Shape::Shape()
+{
+	shader = lol::ShaderManager::GetInstance().Get(SHAPE_ID);
+	if (shader == nullptr)
+	{
+		shader = std::make_shared<lol::Shader>(
+			R"(
+				#version 460 core
+	
+				layout (location = 0) in vec3 pos;
+				
+				uniform mat4 model;
+				uniform mat4 view;
+				uniform mat4 projection;
+
+				void main()
+				{
+					gl_Position = projection * view * model * vec4(pos, 1.0f);
+				}
+			)",
+			R"(
+				#version 460 core
+	
+				out vec4 FragColor;
+				
+				void main()
+				{
+					FragColor = vec4(1.0f);
+				}
+			)"
+			);
+
+		lol::ShaderManager::GetInstance().Register(SHAPE_ID, shader);
+	}
+}
+
+void Shape::PreRender(const lol::CameraBase& camera) const
+{
+	shader->SetUniform("model", transformation);
+	shader->SetUniform("view", camera.GetView());
+	shader->SetUniform("projection", camera.GetProjection());
+}
+
+Cube::Cube()
+{
+	vao = lol::VAOManager::GetInstance().Get(CUBE_ID);
+	if (vao == nullptr)
+	{
+		std::shared_ptr<lol::VertexBuffer> vbo = std::make_shared<lol::VertexBuffer>(8 * 3,
+			std::vector<float> {
+				-1.0f, -1.0f, -1.0f,
+				 1.0f, -1.0f, -1.0f,
+				 1.0f,  1.0f, -1.0f,
+				-1.0f,  1.0f, -1.0f,
+				-1.0f, -1.0f,  1.0f,
+				 1.0f, -1.0f,  1.0f,
+				 1.0f,  1.0f,  1.0f,
+				-1.0f,  1.0f,  1.0f
+			}
+		);
+		vbo->SetLayout({{lol::Type::Float, 3, false}});
+
+		std::shared_ptr<lol::ElementBuffer> ebo = std::make_shared<lol::ElementBuffer>(6 * 3 * 2,
+			std::vector<unsigned int> {
+				0, 1, 3, 3, 1, 2,
+				1, 5, 2, 2, 5, 6,
+				5, 4, 6, 6, 4, 7,
+				4, 0, 7, 7, 0, 3,
+				3, 2, 7, 7, 2, 6,
+				4, 5, 0, 0, 5, 1
+			}
+		);
+
+		vao = std::make_shared<lol::VertexArray>(vbo, ebo);
+		lol::VAOManager::GetInstance().Register(CUBE_ID, vao);
+	}
+}
+
+Pyramid::Pyramid()
+{
+	vao = lol::VAOManager::GetInstance().Get(PYRAMID_ID);
+	if (vao == nullptr)
+	{
+		std::shared_ptr<lol::VertexBuffer> vbo = std::make_shared<lol::VertexBuffer>(5 * 3,
+			std::vector<float> {
+				-1.0f, -0.86f, 1.0f,
+				1.0f, -0.86f, 1.0f,
+				-1.0f, -0.86f, -1.0f,
+				1.0f, -0.86f, -1.0f,
+				0.0f, 0.86f, 0.0f,
+		}
+		);
+		vbo->SetLayout({ {lol::Type::Float, 3, false} });
+
+		std::shared_ptr<lol::ElementBuffer> ebo = std::make_shared<lol::ElementBuffer>(18,
+			std::vector<unsigned int> {
+				0, 2, 1,
+				1, 2, 3,
+				0, 1, 4,
+				1, 3, 4,
+				3, 2, 4,
+				2, 0, 4,
+		}
+		);
+
+		vao = std::make_shared<lol::VertexArray>(vbo, ebo);
+		lol::VAOManager::GetInstance().Register(PYRAMID_ID, vao);
+	}
+}

src/Shapes.hpp

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <lol/lol.hpp>
+
+class Shape : public lol::Drawable, public lol::Transformable 
+{
+public:
+	Shape();
+	void PreRender(const lol::CameraBase& camera) const override;
+};
+
+class Cube : public Shape
+	
+{
+public:
+	Cube();
+};
+
+class Pyramid : public Shape
+{
+public:
+	Pyramid();
+};

src/Util.hpp

@@ -1,3 +1,5 @@
 #pragma once
 
-#define PLOT3D_ID 0x1
+#define SHAPE_ID 0x0
+#define CUBE_ID 0x1
+#define PYRAMID_ID 0x2

vendor/lol

@@ -1 +1 @@
-Subproject commit 5875f1246f642950af7fdf3c3c7f5a9d603a76cc
+Subproject commit 988a429f16fc8a7eddb6050e4f6ce09ba9ccddbc