improved orbitals object

src/Camera.cpp

@@ -2,15 +2,12 @@
 
 #include <glm/gtc/matrix_transform.hpp>
 
-Camera::Camera() :
-	viewMatrix(1.0f), position(0.0f), front({ 0.0f, 0.0f, -1.0f }), up({ 0.0f, 1.0f, 0.0f }), yawPitchRoll({ -90.0f, 0.0f, 0.0f })
+Camera::Camera(float fov, float aspectRatio) :
+	viewMatrix(1.0f), position(0.0f), 
+	front({ 0.0f, 0.0f, -1.0f }), up({ 0.0f, 1.0f, 0.0f }), 
+	yawPitchRoll({ -90.0f, 0.0f, 0.0f })
 {
-}
-
-float* Camera::GetViewMatrix()
-{
-	viewMatrix = glm::lookAt(position, position + front, up);
-	return &viewMatrix[0][0];
+	projectionMatrix = glm::perspective(glm::radians(fov), aspectRatio, 0.1f, 100.0f);
 }
 
 void Camera::SetPosition(const glm::vec3& position)
@@ -18,6 +15,11 @@ void Camera::SetPosition(const glm::vec3& position)
 	this->position = position;
 }
 
+void Camera::UpdatePerspective(float fov, float aspectRatio)
+{
+	projectionMatrix = glm::perspective(glm::radians(fov), aspectRatio, 0.1f, 100.0f);
+}
+
 void Camera::MoveForward(float amount, float frametime)
 {
 	position += amount * front * frametime;
@@ -52,3 +54,14 @@ void Camera::HandleMouseMoved(double deltaX, double deltaY, float sensitivity, f
 	direction.z = sin(glm::radians(yawPitchRoll.x)) * cos(glm::radians(yawPitchRoll.y));
 	front = glm::normalize(direction);
 }
+
+const glm::mat4& Camera::GetViewMatrix()
+{
+	viewMatrix = glm::lookAt(position, position + front, up);
+	return viewMatrix;
+}
+
+const glm::mat4& Camera::GetProjectionMatrix() const
+{
+	return projectionMatrix;
+}

src/Camera.hpp

@@ -5,11 +5,10 @@
 class Camera
 {
 public:
-	Camera();
-
-	float* GetViewMatrix();
+	Camera(float fov, float aspectRatio);
 
 	void SetPosition(const glm::vec3& position);
+	void UpdatePerspective(float fov, float aspectRatio);
 
 	void MoveForward(float amount, float frametime);
 	void MoveRight(float amount, float frametime);
@@ -17,8 +16,13 @@ public:
 
 	void HandleMouseMoved(double deltaX, double deltaY, float sensitivity, float frametime);
 
+	const glm::mat4& GetViewMatrix();
+	const glm::mat4& GetProjectionMatrix() const;
+
 private:
 	glm::mat4 viewMatrix;
+	glm::mat4 projectionMatrix;
+
 	glm::vec3 position;
 	glm::vec3 front;
 	glm::vec3 up;

src/Model.cpp

@@ -3,7 +3,7 @@
 #include <glad/glad.h>
 
 Model::Model() :
-	vertices({}), indices({}), vao(0), ebo(0), vbo(0)
+	vertices({}), indices({}), vao(0), ebo(0), vbo(0), modelMatrix({1.0f})
 {
 }
 

src/Model.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <vector>
+#include <glm/matrix.hpp>
 
 class Model
 {
@@ -20,6 +21,7 @@ protected:
 protected:
 	std::vector<float> vertices;
 	std::vector<unsigned int> indices;
+	glm::mat4 modelMatrix;
 
 private:
 	unsigned int vbo, ebo, vao;

src/Orbital.cpp

@@ -1,21 +1,76 @@
 #include "Orbital.hpp"
 
-#include <glad/glad.h>
-
 #define TWO_PI       6.28318530718
 #define PI           3.14159265359
 
 #include <cmath>
 #include <complex>
 
+#include <glad/glad.h>
+#include <glm/gtc/matrix_transform.hpp>
+#include <glm/gtc/type_ptr.hpp>
+
+#include "Shader.hpp"
+#include "Camera.hpp"
+
+// Write some shaders to display the orbitals (too lazy to put them in files)
+Shader* Orbital::defaultShader = nullptr; 
+
 std::complex<double> SphericalHarmonic(unsigned int l, unsigned int m, float theta, float phi);
 unsigned int Fac(unsigned int n);
 
 Orbital::Orbital(unsigned int l, unsigned int m) :
 	l(l), m(m)
 {
+	if (defaultShader == nullptr)
+	{
+		defaultShader = new Shader(
+			R"(
+			#version 460 core
+
+			layout(location = 0) in vec3 position;
+			layout(location = 1) in vec3 color;
+
+			out vec3 outColor;
+
+			uniform mat4 model;
+			uniform mat4 view;
+			uniform mat4 projection;
+
+			void main()
+			{
+				outColor = color;
+				gl_Position = projection * view * model * vec4(position, 1.0f);
+			}	
+		)",
+
+			R"(
+			#version 460 core
+			
+			in vec3 outColor;
+			out vec4 FragColor;
+
+			void main()
+			{	
+				FragColor = vec4(outColor, 1.0f);
+			}
+		)"
+		);
+	}
+
 	UpdateModel();
 	CreateVAO();
+
+	modelMatrix = glm::rotate(modelMatrix, glm::radians(90.0f), glm::vec3(1.0f, 0.0f, 0.0f));
+	modelMatrix = glm::scale(modelMatrix, glm::vec3(3.0f));
+}
+
+void Orbital::BindDefaultShader(Camera& camera)
+{
+	defaultShader->Bind();
+	defaultShader->SetMatrix("model", glm::value_ptr(modelMatrix));
+	defaultShader->SetMatrix("view", glm::value_ptr(camera.GetViewMatrix()));
+	defaultShader->SetMatrix("projection", glm::value_ptr(camera.GetProjectionMatrix()));
 }
 
 void Orbital::UpdateModel()

src/Orbital.hpp

@@ -2,15 +2,21 @@
 
 #include "Model.hpp"
 
+class Shader;
+class Camera;
+
 class Orbital : public Model
 {
 public:
 	Orbital(unsigned int l, unsigned int m);
 
+	void BindDefaultShader(Camera& camera);
+
 private:
 	void UpdateModel();
 	void DefineVAOLayout() final override;
 
 private:
 	unsigned int l, m;
+	static Shader* defaultShader;
 };

src/main.cpp

@@ -13,7 +13,6 @@
 
 struct UserData
 {
-	glm::mat4* projectionMatrix;
 	Camera* camera;
 	float frametime;
 	double lastX, lastY;
@@ -82,48 +81,11 @@ int main(int argc, char** argv)
 
 	// Set up a camera 
 	// TODO: should the projection matrix be part of the camera?
-	Camera camera;
+	Camera camera(110.0f, 1200.0f / 800.0f);
 	camera.SetPosition(glm::vec3(0.0f, 0.0f, 3.0f));
 
-	glm::mat4 projectionMatrix = glm::perspective(glm::radians(110.0f), 1200.0f / 800.0f, 0.1f, 100.0f);
-
-	// Write some shaders to display the orbitals (too lazy to put them in files)
-	Shader shader(
-		R"(
-			#version 460 core
-
-			layout(location = 0) in vec3 position;
-			layout(location = 1) in vec3 color;
-
-			out vec3 outColor;
-
-			uniform mat4 model;
-			uniform mat4 view;
-			uniform mat4 projection;
-
-			void main()
-			{
-				outColor = color;
-				gl_Position = projection * view * model * vec4(position, 1.0f);
-			}	
-		)",
-
-		R"(
-			#version 460 core
-			
-			in vec3 outColor;
-			out vec4 FragColor;
-
-			void main()
-			{	
-				FragColor = vec4(outColor, 1.0f);
-			}
-		)"
-	);
-
 	// Data that we want to be able to access from anywhere
 	UserData data = {
-		&projectionMatrix,	// Projection matrix
 		&camera,			// The camera object
 		0.0,				// Duration of the last frame
 		0.0, 0.0,			// Mouse position of the last frame
@@ -158,13 +120,7 @@ int main(int argc, char** argv)
 		ImGui_ImplGlfw_NewFrame();
 		ImGui::NewFrame();
 
-		// Use our shader and set the matrices
-		shader.Bind();
-		shader.SetMatrix("model", &modelMatrix[0][0]);
-		shader.SetMatrix("view", camera.GetViewMatrix());
-		shader.SetMatrix("projection", &projectionMatrix[0][0]);
-
-		// Finally draw the orbital
+		orbital.BindDefaultShader(camera);
 		orbital.Draw();
 
 		ImGui::Begin("Test Window");
@@ -192,7 +148,7 @@ void OnFramebufferResize(GLFWwindow* window, int width, int height)
 {
 	glViewport(0, 0, width, height);
 	UserData* data = (UserData*)glfwGetWindowUserPointer(window);
-	*(data->projectionMatrix) = glm::perspective(glm::radians(110.0f), (float)width / (float)height, 0.1f, 100.0f);
+	data->camera->UpdatePerspective(110.0f, (float)width / (float)height);
 }
 
 void OnMouseMoved(GLFWwindow* window, double xpos, double ypos)