lauchmelder/Visualizer
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

added 3d plotting

Browse source
This commit is contained in:
Lauchmelder 2021-12-22 15:45:52 +01:00
parent 5f0e8f9c6e
commit 918f51dc14
16 changed files with 301 additions and 248 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
CMakeLists.txt
View file

@ -5,6 +5,8 @@ cmake_minimum_required (VERSION 3.8)
project ("Visualizer")
set(CMAKE_CXX_STANDARD 17)
set(VENDOR_DIR ${CMAKE_SOURCE_DIR}/vendor)
find_package(GLFW3)

15
backend/include/backend/BoundingBox.hpp Normal file
View file

@ -0,0 +1,15 @@
#pragma once
struct Rect
{
float x, y;
float w, h;
};
struct BoundingBox
{
float x, y, z;
float w, h, d;
};
typedef BoundingBox BBox;

15
backend/include/backend/Camera.hpp
View file

@ -13,6 +13,11 @@ public:
void SetScale(const glm::vec3&) = delete;
void Scale(const glm::vec3&) = delete;
inline void LookAt(const glm::vec3& target)
{
transformation = glm::lookAt(position, target, glm::vec3(0.0f, 1.0f, 0.0f));
}
inline const glm::mat4& GetView() const
{
return transformation;
@ -40,6 +45,11 @@ public:
{
projection = glm::perspective(glm::radians(fov), aspect, zNear, zFar);
}
inline void Update(float fov, float aspect, float zNear, float zFar)
{
projection = glm::perspective(glm::radians(fov), aspect, zNear, zFar);
}
};
class OrthogonalCamera : public CameraBase
@ -49,4 +59,9 @@ public:
{
projection = glm::ortho(left, right, bottom, top, zNear, zFar);
}
inline void Update(float left, float right, float bottom, float top, float zNear, float zFar)
{
projection = glm::ortho(left, right, bottom, top, zNear, zFar);
}
};

2
backend/include/backend/Drawable.hpp
View file

@ -23,7 +23,7 @@ public:
Drawable(const Drawable& other) = delete;
void operator=(const Drawable& other) = delete;
virtual void InitializeShader(const CameraBase& camera) const = 0;
virtual void PreRender(const CameraBase& camera) const { };
void Draw(const CameraBase& camera) const;
void SetPrimitiveType(PrimitiveType type);

2
backend/src/Drawable.cpp
View file

@ -3,7 +3,7 @@
void Drawable::Draw(const CameraBase& camera) const
{
shader->Use();
InitializeShader(camera);
PreRender(camera);
vao->Render(static_cast<unsigned int>(type));
}

11
backend/src/Transformable.cpp
View file

@ -1,7 +1,7 @@
#include "backend/Transformable.hpp"
Transformable::Transformable() :
position(0.0f), scale(1.0f), orientation(0.0, 0.0, 0.0, 1.0)
position(0.0f), scale(1.0f), orientation(glm::vec3(0.0, 0.0, 0.0))
{
CalculateTransformationMatrix();
}
@ -41,6 +41,11 @@ void Transformable::SetRotation(const glm::vec3& axis, float angle)
void Transformable::SetRotation(const glm::vec3& eulerAngles)
{
/*orientation = glm::quat(0.0f, 0.0f, 0.0f, 1.0f);
orientation = glm::rotate(orientation, eulerAngles.x, glm::vec3(1.0f, 0.0f, 0.0f));
orientation = glm::rotate(orientation, eulerAngles.y, glm::vec3(0.0f, 1.0f, 0.0f));
orientation = glm::rotate(orientation, eulerAngles.z, glm::vec3(0.0f, 0.0f, 1.0f));*/
orientation = glm::quat(eulerAngles);
CalculateTransformationMatrix();
}
@ -71,7 +76,7 @@ void Transformable::Scale(const glm::vec3& factor)
void Transformable::CalculateTransformationMatrix()
{
transformation = glm::mat4(1.0f);
transformation = glm::translate(transformation, -position);
transformation *= glm::toMat4(orientation);
transformation = glm::translate(transformation, position);
transformation *= glm::mat4(orientation);
transformation = glm::scale(transformation, scale);
}

37
src/Application.cpp
View file

@ -19,8 +19,8 @@ Application::~Application()
ImGui_ImplGlfw_Shutdown();
ImGui::DestroyContext();
if (grid != nullptr)
delete grid;
if (plot != nullptr)
delete plot;
if (window != nullptr)
{
@ -90,9 +90,8 @@ void Application::Init(int width, int height, const std::string& title)
WindowData* data = (WindowData*)glfwGetWindowUserPointer(window);
float aspectRatio = (float)width / (float)height;
*(data->camera) = Camera(100.0f, aspectRatio);
data->camera->Move(glm::vec3(0.0f, 0.0f, -4.0f));
*(data->orthoCam) = OrthogonalCamera(-3.0f * aspectRatio, 3.0f * aspectRatio, -3.0f, 3.0f);
data->camera->Update(100.0f, aspectRatio, 0.01f, 100.0f);
data->orthoCam->Update(-3.0f * aspectRatio, 3.0f * aspectRatio, -3.0f, 3.0f, -100.0f, 100.0f);
glViewport(0, 0, width, height);
}
@ -123,13 +122,23 @@ void Application::Init(int width, int height, const std::string& title)
float aspectRatio = (float)windowWidth / (float)windowHeight;
camera = Camera(100.0f, aspectRatio);
camera.Move(glm::vec3(0.0f, 0.0f, 4.0f));
camera.Move(glm::vec3(0.0f, 4.0f, -4.0f));
camera.LookAt(glm::vec3(0.0f));
orthoCam = OrthogonalCamera(-3.0f * aspectRatio, 3.0f * aspectRatio, -3.0f, 3.0f);
orthoCam.Move(glm::vec3(0.0f, 4.0f, -4.0f));
orthoCam.LookAt(glm::vec3(0.0f));
activeCamera = &camera;
grid = new Grid(glm::vec2(5.0f, 4.0f), 25, 20);
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);
}
);
cubePosition = glm::vec3(0.0f);
cubeOrientation = glm::vec3(0.0f);
cubeScale = glm::vec3(1.0f);
@ -139,7 +148,7 @@ void Application::Init(int width, int height, const std::string& title)
glfwWindowHint(GLFW_SAMPLES, 4);
glEnable(GL_CULL_FACE);
// glEnable(GL_CULL_FACE);
glEnable(GL_MULTISAMPLE);
}
@ -149,9 +158,9 @@ void Application::Launch()
{
glfwPollEvents();
grid->SetPosition(cubePosition);
grid->SetRotation(cubeOrientation);
grid->SetScale(cubeScale);
plot->SetPosition(cubePosition);
plot->SetRotation(cubeOrientation);
plot->SetScale(cubeScale);
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
@ -160,14 +169,14 @@ void Application::Launch()
ImGui_ImplGlfw_NewFrame();
ImGui::NewFrame();
grid->Draw(*activeCamera);
plot->Draw(*activeCamera);
ImGui::Begin("Debug");
if (ImGui::CollapsingHeader("Grid"))
if (ImGui::CollapsingHeader("Plot"))
{
ImGui::SliderFloat3("Position", &(cubePosition[0]), -2.0f, 2.0f);
ImGui::SliderFloat3("Orientation", &(cubeOrientation[0]), 0.0f, glm::two_pi<float>());
ImGui::SliderFloat3("Orientation", &(cubeOrientation[0]), -glm::pi<float>(), glm::pi<float>());
ImGui::SliderFloat3("Scale", &(cubeScale[0]), 0.0f, 2.0f);
}

4
src/Application.hpp
View file

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

4
src/CMakeLists.txt
View file

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

87
src/Cuboid.cpp
View file

@ -1,87 +0,0 @@
#include "Cuboid.hpp"
#include <stdexcept>
#include <glad/glad.h>
#include <glm/gtc/matrix_transform.hpp>
#include "backend/ObjectManager.hpp"
#include "backend/Camera.hpp"
#include "Util.hpp"
Cuboid::Cuboid()
{
vao = VAOManager::GetInstance().Get(CUBOID_ID);
if (vao == nullptr)
{
vao = VAOFactory::Produce(
{
-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
},
{
0, 1, 1, 2, 2, 3, 3, 0, // Front
4, 5, 5, 6, 6, 7, 7, 4, // Back
0, 4, 1, 5, 2, 6, 3, 7
},
{
{ 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0 }
}
);
VAOManager::GetInstance().Register(CUBOID_ID, vao);
}
shader = ShaderManager::GetInstance().Get(CUBOID_ID);
if (shader == nullptr)
{
shader = ShaderFactory::Produce(
R"(
#version 460 core
layout (location = 0) in vec3 aPos;
uniform mat4 model;
uniform mat4 view;
uniform mat4 perspective;
void main()
{
gl_Position = perspective * view * model * vec4(aPos, 1.0f);
}
)",
R"(
#version 460 core
out vec4 FragColor;
void main()
{
FragColor = vec4(1.0f, 1.0f, 1.0f, 1.0f);
}
)"
);
if (!shader->Good())
{
throw std::runtime_error("Shader creation failed");
}
ShaderManager::GetInstance().Register(CUBOID_ID, shader);
}
type = PrimitiveType::Lines;
}
void Cuboid::InitializeShader(const CameraBase& camera) const
{
shader->SetUniform("model", transformation);
shader->SetUniform("view", camera.GetView());
shader->SetUniform("perspective", camera.GetProjection());
}

18
src/Cuboid.hpp
View file

@ -1,18 +0,0 @@
#pragma once
#include <glm/glm.hpp>
#include "backend/Drawable.hpp"
#include "backend/Transformable.hpp"
/**
* A cuboid that sits at a position and expands into all
* three spatial directions
*/
class Cuboid :
public Drawable, public Transformable
{
public:
Cuboid();
void InitializeShader(const CameraBase& camera) const override;
};

102
src/Grid.cpp
View file

@ -1,102 +0,0 @@
#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(GetPosition() - camera.GetPosition(), glm::rotate(glm::inverse(GetQuaternion()), normal)) < 0.0f)
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());
}

16
src/Grid.hpp
View file

@ -1,16 +0,0 @@
#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;
private:
glm::vec3 normal = glm::vec3(0.0f, 0.0f, 1.0f);
};

209
src/Plot3D.cpp Normal file
View file

@ -0,0 +1,209 @@
#include "Plot3D.hpp"
#include <optional>
#include <array>
#include <iostream>
#include "backend/Camera.hpp"
#include "backend/ObjectManager.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;
}
Plot3D::Plot3D(const 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 = 0;
unsigned int slices = 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();
for (float y = yInterval.x; y <= yInterval.y; y += resolution)
{
sliceLength = 0;
for (float x = xInterval.x; x <= xInterval.y; x += resolution)
{
if (std::abs(x) < 0.05f && std::abs(y) < 0.05f)
volatile int sjdks = 3;
float val = func(x, y);
std::optional<unsigned int> pointIndex;
// If function value is in bbox
if (val >= zInterval.x && val <= zInterval.y)
{
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);
minFunctionValue = std::min(minFunctionValue, val);
maxFunctionValue = std::max(maxFunctionValue, val);
pointIndex = index;
index++;
}
functionValues.push_back(pointIndex);
sliceLength++;
}
slices++;
}
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)
{
vertices[i] = Map(zInterval, glm::vec2(0.0f, 1.0f), vertices[i - 2]);
vertices[i - 2] = Map(zInterval, zBounds, vertices[i - 2]);
}
/*
* 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;
};
std::array<Constellation, 4> constellations = {
Constellation {0, 1, 2},
Constellation {0, 2, 3},
Constellation {0, 1, 3},
Constellation {1, 2, 3}
};
std::array<std::optional<unsigned int>*, 4> points;
for (unsigned int y = 1; y < slices; y++)
{
for (unsigned int x = 1; x < sliceLength; x++)
{
points = {
&functionValues[y * sliceLength + x],
&functionValues[y * sliceLength + (x - 1)],
&functionValues[(y - 1) * sliceLength + (x - 1)],
&functionValues[(y - 1) * sliceLength + x],
};
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;
}
}
}
vao = VAOFactory::Produce(vertices, indices,
{
{ 3, GL_FLOAT, GL_FALSE, sizeof(float) * 4, (void*)0 },
{ 1, GL_FLOAT, GL_FALSE, sizeof(float) * 4, (void*)(3 * sizeof(float))}
}
);
shader = ShaderManager::GetInstance().Get(PLOT3D_ID);
if (shader == nullptr)
{
shader = ShaderFactory::Produce(
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);
}
)"
);
ShaderManager::GetInstance().Register(PLOT3D_ID, shader);
}
}
void Plot3D::PreRender(const CameraBase& camera) const
{
shader->SetUniform("model", transformation);
shader->SetUniform("view", camera.GetView());
shader->SetUniform("projection", camera.GetProjection());
}

22
src/Plot3D.hpp Normal file
View file

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

3
src/Util.hpp
View file

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