jack
/
terravisor
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add FBO class. Still need to add functionality

This commit is contained in:
Jack Christensen 2024-08-13 17:47:16 -04:00
parent 07eb172464
commit 590982cde3
4 changed files with 112 additions and 189 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
include/fbo.h Normal file
View File

@ -0,0 +1,22 @@
#ifndef FBO_H_
#define FBO_H_
#include <GLFW/glfw3.h>
class FBO {
public:
FBO();
~FBO();
GLuint fbo_id_;
GLuint color_texture_id_;
GLuint depth_rbo_id_;
void Init(int width, int height);
void Bind();
void Unbind();
void Cleanup();
GLuint GetColorTexture() const;
};
#endif // FBO_H_

19
include/scene.h
View File

@ -4,6 +4,8 @@
#include <GLFW/glfw3.h> #include <GLFW/glfw3.h>
#include <glm/glm.hpp> #include <glm/glm.hpp>
#include "fbo.h"
class Scene { class Scene {
public: public:
Scene(); Scene();
@ -15,10 +17,14 @@ class Scene {
void Idle(); void Idle();
void ReloadShader(); void ReloadShader();
int window_width;
int window_height;
private: private:
void InitBuffers(); void InitBuffers();
void InitShaders(); void InitShaders();
FBO fbo_;
GLuint shader_program_; GLuint shader_program_;
GLuint vao_; GLuint vao_;
float angle_; float angle_;
@ -32,19 +38,6 @@ class Scene {
glm::mat4 projection_matrix_; glm::mat4 projection_matrix_;
void UpdateCamera(); void UpdateCamera();
}; };
#endif // SCENE_H_ #endif // SCENE_H_
// namespace scene
// {
// extern const int kInitWindowWidth;
// extern const int kInitWindowHeight;
// void Display(GLFWwindow* window);
// void DrawGUI(GLFWwindow* window);
// void Idle();
// void ReloadShader();
// void Init();
// } // namespace scene

62
source/fbo.cpp Normal file
View File

@ -0,0 +1,62 @@
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <iostream>
#include "fbo.h"
FBO::FBO() : fbo_id_(-1), color_texture_id_(-1), depth_rbo_id_(-1) {}
FBO::~FBO() {
Cleanup();
}
void FBO::Init(int width, int height) {
// Generate the framebuffer
glGenFramebuffers(1, &fbo_id_);
glBindFramebuffer(GL_FRAMEBUFFER, fbo_id_);
// Generate the color texture
glGenTextures(1, &color_texture_id_);
glBindTexture(GL_TEXTURE_2D, color_texture_id_);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, nullptr);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, color_texture_id_, 0);
// Generate the Depth renderbuffer
glGenRenderbuffers(1, &depth_rbo_id_);
glBindRenderbuffer(GL_RENDERBUFFER, depth_rbo_id_);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, width, height);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depth_rbo_id_);
// Check if the framebuffer is complete
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
std::cerr << "Error: Framebuffer is not complete!" << std::endl;
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
void FBO::Bind() {
glBindFramebuffer(GL_FRAMEBUFFER, fbo_id_);
}
void FBO::Unbind() {
glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
void FBO::Cleanup() {
if (color_texture_id_ != -1) {
glDeleteTextures(1, &color_texture_id_);
}
if (depth_rbo_id_ != -1) {
glDeleteTextures(1, &depth_rbo_id_);
}
if (fbo_id_ != -1) {
glDeleteFramebuffers(1, &fbo_id_);
}
}
GLuint FBO::GetColorTexture() const {
return color_texture_id_;
}

194
source/scene.cpp
View File

@ -29,11 +29,22 @@ const std::string kFragmentShaderPath = "shaders/fragment.glsl";
} // namespace } // namespace
Scene::Scene() : shader_program_(-1), vao_(-1), angle_(0.0f), scale_(1.0f), aspect_(1280.0f / 720.0f), near_z_(0.1f), far_z_(100.0f), fov_(glm::pi<float>() / 4.0f) {}; Scene::Scene() : window_width(1280),
window_height(720),
shader_program_(-1),
vao_(-1),
angle_(0.0f),
scale_(1.0f),
aspect_(1280.0f / 720.0f),
near_z_(0.1f), far_z_(100.0f),
fov_(glm::pi<float>() / 4.0f)
{};
Scene::~Scene() { Scene::~Scene() {
glDeleteProgram(shader_program_); glDeleteProgram(shader_program_);
glDeleteVertexArrays(1, &vao_); glDeleteVertexArrays(1, &vao_);
fbo_.~FBO();
} }
void Scene::Init() { void Scene::Init() {
@ -42,7 +53,8 @@ void Scene::Init() {
glEnable(GL_DEPTH_TEST); glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE); glEnable(GL_CULL_FACE);
//InitTri(); fbo_.Init(window_width, window_height);
InitBuffers(); InitBuffers();
ReloadShader(); ReloadShader();
@ -50,6 +62,7 @@ void Scene::Init() {
Uniforms::Init(); Uniforms::Init();
} }
// Currently creates a test triangle and initializes its buffers
void Scene::InitBuffers() { void Scene::InitBuffers() {
GLuint vbo; GLuint vbo;
float vertices[] = { float vertices[] = {
@ -68,6 +81,7 @@ void Scene::InitBuffers() {
glEnableVertexAttribArray(0); glEnableVertexAttribArray(0);
} }
// Allows for runtime shader updates
void Scene::ReloadShader() { void Scene::ReloadShader() {
GLuint new_shader = InitShader(kVertexShaderPath.c_str(), kFragmentShaderPath.c_str()); GLuint new_shader = InitShader(kVertexShaderPath.c_str(), kFragmentShaderPath.c_str());
if (new_shader == -1) { if (new_shader == -1) {
@ -85,6 +99,8 @@ void Scene::ReloadShader() {
void Scene::Display(GLFWwindow* window) { void Scene::Display(GLFWwindow* window) {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
fbo_.Bind();
view_matrix_ = glm::lookAt(glm::vec3(Uniforms::SceneData.eye_w), glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f)); view_matrix_ = glm::lookAt(glm::vec3(Uniforms::SceneData.eye_w), glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f));
Uniforms::SceneData.PV = projection_matrix_ * view_matrix_; // Projection-View matrix Uniforms::SceneData.PV = projection_matrix_ * view_matrix_; // Projection-View matrix
Uniforms::BufferSceneData(); Uniforms::BufferSceneData();
@ -96,6 +112,8 @@ void Scene::Display(GLFWwindow* window) {
glBindVertexArray(vao_); glBindVertexArray(vao_);
glDrawArrays(GL_TRIANGLES, 0, 3); glDrawArrays(GL_TRIANGLES, 0, 3);
fbo_.Unbind();
DrawGui(window); DrawGui(window);
glfwSwapBuffers(window); glfwSwapBuffers(window);
} }
@ -169,175 +187,3 @@ void Scene::Idle() {
void Scene::UpdateCamera() { void Scene::UpdateCamera() {
projection_matrix_ = glm::perspective(fov_, aspect_, near_z_, far_z_); projection_matrix_ = glm::perspective(fov_, aspect_, near_z_, far_z_);
} }
// namespace scene {
// const int kInitWindowWidth = 1280;
// const int kInitWindowHeight = 720;
// static const std::string kVertexShader("shaders/vertex.glsl");
// static const std::string kFragmentShader("shaders/fragment.glsl");
// GLuint shader_program = -1;
// // Vertex data for a basic triangle. Testing use only
// float vertices[] = {
// -0.5f, -0.5f, 0.0f,
// 0.5f, -0.5f, 0.0f,
// 0.0f, 0.5f, 0.0f
// };
// unsigned int VAO = -1;
// float angle = 0.0f;
// float scale = 1.0f;
// namespace camera {
// glm::mat4 V, P;
// float aspect = static_cast<float>(kInitWindowWidth) / static_cast<float>(kInitWindowHeight);
// float near_z = 0.1f;
// float far_z = 100.0f;
// float fov = glm::pi<float>() / 4.0f;
// void UpdateP() {
// P = glm::perspective(fov, aspect, near_z, far_z);
// }
// } // namespace camera
// // Temp function to test shader pipline with basic triangle
// void InitTri() {
// unsigned int vbo;
// glGenBuffers(1, &vbo);
// glBindBuffer(GL_ARRAY_BUFFER, vbo);
// glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
// glGenVertexArrays(1, &VAO);
// glBindVertexArray(VAO);
// glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
// glEnableVertexAttribArray(0);
// }
// void Display(GLFWwindow* window) {
// // Clear the color and depth buffers
// glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// camera::V = glm::lookAt(glm::vec3(Uniforms::SceneData.eye_w), glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f));
// Uniforms::SceneData.PV = camera::P * camera::V; // Projection-View matrix
// Uniforms::BufferSceneData();
// // Model matrix
// glm::mat4 M = glm::rotate(angle, glm::vec3(0.0f, 1.0f, 0.0f)) * glm::scale(glm::vec3(scale));
// glUniformMatrix4fv(Uniforms::UniformLocs::M, 1, false, glm::value_ptr(M));
// glUseProgram(shader_program);
// glBindVertexArray(VAO);
// glDrawArrays(GL_TRIANGLES, 0, 3);
// DrawGUI(window);
// glfwSwapBuffers(window);
// }
// void DrawGUI(GLFWwindow* window) {
// // Begin ImGui frame
// ImGui_ImplOpenGL3_NewFrame();
// ImGui_ImplGlfw_NewFrame();
// // Enable docking
// ImGuiIO& io = ImGui::GetIO();
// io.ConfigFlags |= ImGuiConfigFlags_DockingEnable;
// ImGui::NewFrame();
// static ImGuiDockNodeFlags dockspace_flags = ImGuiDockNodeFlags_PassthruCentralNode;
// // Add menu bar
// ImGuiWindowFlags window_flags = ImGuiWindowFlags_MenuBar | ImGuiWindowFlags_NoDocking;
// // Style windows
// const ImGuiViewport* viewport = ImGui::GetMainViewport();
// ImGui::SetNextWindowPos(viewport->WorkPos);
// ImGui::SetNextWindowSize(viewport->WorkSize);
// ImGui::SetNextWindowViewport(viewport->ID);
// ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 0.0f);
// ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
// window_flags |= ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove;
// window_flags |= ImGuiWindowFlags_NoBringToFrontOnFocus | ImGuiWindowFlags_NoNavFocus;
// window_flags |= ImGuiWindowFlags_NoBackground;
// ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0.0f, 0.0f));
// ImGui::Begin("TerraVisor", nullptr, window_flags);
// ImGui::PopStyleVar(3);
// // Submit the DockSpace
// if (io.ConfigFlags & ImGuiConfigFlags_DockingEnable) {
// ImGuiID dockspace_id = ImGui::GetID("MyDockSpace");
// ImGui::DockSpace(dockspace_id, ImVec2(0.0f, 0.0f), dockspace_flags);
// }
// if (ImGui::BeginMenuBar()) {
// if (ImGui::BeginMenu("Options")) {
// ImGui::Text("Nothing Here Yet, Check Back Later!");
// ImGui::EndMenu();
// }
// ImGui::EndMenuBar();
// }
// ImGui::End();
// //Draw Gui
// ImGui::Begin("Terrain Controls");
// if (ImGui::Button("Quit")) {
// glfwSetWindowShouldClose(window, GLFW_TRUE);
// }
// ImGui::Text("Application average %.3f ms/frame (%.1f FPS)", 1000.0f / ImGui::GetIO().Framerate, ImGui::GetIO().Framerate);
// ImGui::End();
// ImGui::Render();
// ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
// }
// void Idle() {
// // Idle function to update the scene when no rendering is performed.
// }
// void ReloadShader()
// {
// GLuint new_shader = InitShader(kVertexShader.c_str(), kFragmentShader.c_str());
// if (new_shader == -1) { // loading failed
// DEBUG_BREAK(); //alert user by breaking and showing debugger
// glClearColor(1.0f, 0.0f, 1.0f, 0.0f); //change clear color if shader can't be compiled
// }
// else {
// glClearColor(0.35f, 0.35f, 0.35f, 0.0f);
// if (shader_program != -1) {
// glDeleteProgram(shader_program);
// }
// shader_program = new_shader;
// }
// }
// void Init() {
// glewInit();
// glEnable(GL_DEPTH_TEST);
// glEnable(GL_CULL_FACE);
// InitTri();
// ReloadShader();
// camera::UpdateP();
// Uniforms::Init();
// }
// } // namespace scene