From 5fd66cfdfae7a3279557711fd2215c787eb71a73 Mon Sep 17 00:00:00 2001 From: Benjamin Kyd Date: Sat, 22 Apr 2023 17:50:21 +0100 Subject: [PATCH 01/30] refactor start: we are doing some epic procedural programming --- CMakeLists.txt | 3 +- src/inferno.cpp | 298 ++++++++---------------------------------------- src/inferno.hpp | 47 +++----- src/main.cpp | 12 +- src/window.cpp | 2 +- src/window.hpp | 2 +- 6 files changed, 72 insertions(+), 292 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 897b76d..4b5363a 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -10,7 +10,7 @@ target_include_directories(inferno PRIVATE "src/") target_include_directories(inferno PRIVATE "src/thirdparty") # Hardware Acceleration Modules (HART) -add_subdirectory("hart/inferno-hart-cpu") +#add_subdirectory("hart/inferno-hart-cpu") #add_subdirectory("hart/inferno-hart-opencl") # Compiler arguments @@ -66,3 +66,4 @@ else() OpenGL::GL ) endif() + diff --git a/src/inferno.cpp b/src/inferno.cpp index 4f0bce9..d0eaa3e 100644 --- a/src/inferno.cpp +++ b/src/inferno.cpp @@ -1,20 +1,20 @@ #include "inferno.hpp" #include -#include "gui/layout.hpp" +//#include "gui/layout.hpp" #include "window.hpp" -#include "hart_module.hpp" -#include "hart_directory.hpp" +//#include "hart_module.hpp" +//#include "hart_directory.hpp" -#include "preview_renderer/renderer.hpp" -#include "preview_renderer/shader.hpp" -#include "renderer/dispatcher.hpp" -#include "renderer/renderer.hpp" -#include "scene/camera.hpp" -#include "scene/scene.hpp" -#include "scene/material.hpp" -#include "scene/mesh.hpp" +//#include "preview_renderer/renderer.hpp" +//#include "preview_renderer/shader.hpp" +//#include "renderer/dispatcher.hpp" +//#include "renderer/renderer.hpp" +//#include "scene/camera.hpp" +//#include "scene/scene.hpp" +//#include "scene/material.hpp" +//#include "scene/mesh.hpp" #include @@ -23,28 +23,26 @@ #include #include -using namespace inferno; +namespace inferno::core { -Inferno::Inferno() +InfernoApp* create_inferno() { // MOTD yolo::info("INFERNO HART v" INFERNO_VERSION); + InfernoApp* app = new InfernoApp(); + // Create window - mWin = &Window::GetInstance(); - mWin->init("Inferno v" INFERNO_VERSION, 1280, 720); - - mRasterRenderer = new RasterizeRenderer(); - mRayRenderer = new RenderDispatcher(); - mScene = new Scene(); + app->Win = &Window::GetInstance(); + app->Win->init("Inferno v" INFERNO_VERSION, 1280, 720); + return app; } -Inferno::~Inferno() +void cleanup_inferno(InfernoApp* app) { - } -static void HelpMarker(const char* desc) +static void gui_help_marker(const char* desc) { ImGui::TextDisabled("(?)"); if (ImGui::IsItemHovered(ImGuiHoveredFlags_DelayShort)) @@ -57,7 +55,7 @@ static void HelpMarker(const char* desc) } } -void Inferno::uiPreset() +void preset_gui(InfernoApp *app) { ImGuiID dockspace_id = ImGui::GetID("main"); @@ -74,256 +72,58 @@ void Inferno::uiPreset() yolo::info("LAYOUT SET TO DEFAULT"); } -void Inferno::moveInput() +void move_input(InfernoApp *app) { static GLFWcursor* cursor = glfwCreateStandardCursor(GLFW_HAND_CURSOR); - glfwSetCursor(mWin->getGLFWWindow(), cursor); + glfwSetCursor(app->Win->getGLFWWindow(), cursor); // KBD & MOUSE // pan only get on hold static glm::dvec2 lastMousePos; static int firstClick = 0; - if (glfwGetMouseButton(mWin->getGLFWWindow(), GLFW_MOUSE_BUTTON_1) == GLFW_PRESS) + if (glfwGetMouseButton(app->Win->getGLFWWindow(), GLFW_MOUSE_BUTTON_1) == GLFW_PRESS) { firstClick++; if (firstClick == 1) { - glfwGetCursorPos(mWin->getGLFWWindow(), &lastMousePos.x, &lastMousePos.y); + glfwGetCursorPos(app->Win->getGLFWWindow(), &lastMousePos.x, &lastMousePos.y); } glm::dvec2 tempMousePos = { 0.0f, 0.0f }; - glfwGetCursorPos(mWin->getGLFWWindow(), &tempMousePos.x, &tempMousePos.y); - mouseDelta = lastMousePos - tempMousePos; + glfwGetCursorPos(app->Win->getGLFWWindow(), &tempMousePos.x, &tempMousePos.y); + app->Input->MouseDelta = lastMousePos - tempMousePos; lastMousePos = tempMousePos; } else { firstClick = 0; - mouseDelta = { 0.0f, 0.0f }; + app->Input->MouseDelta = { 0.0f, 0.0f }; lastMousePos = { 0.0f, 0.0f }; } - movementDelta = 0b00000000; - if (glfwGetKey(mWin->getGLFWWindow(), GLFW_KEY_W) == GLFW_PRESS) - movementDelta |= 0b10000000; - if (glfwGetKey(mWin->getGLFWWindow(), GLFW_KEY_A) == GLFW_PRESS) - movementDelta |= 0b01000000; - if (glfwGetKey(mWin->getGLFWWindow(), GLFW_KEY_S) == GLFW_PRESS) - movementDelta |= 0b00100000; - if (glfwGetKey(mWin->getGLFWWindow(), GLFW_KEY_D) == GLFW_PRESS) - movementDelta |= 0b00010000; - if (glfwGetKey(mWin->getGLFWWindow(), GLFW_KEY_SPACE) == GLFW_PRESS) - movementDelta |= 0b00001000; - if (glfwGetKey(mWin->getGLFWWindow(), GLFW_KEY_LEFT_SHIFT) == GLFW_PRESS) - movementDelta |= 0b00000100; + app->Input->MovementDelta = 0b00000000; + if (glfwGetKey(app->Win->getGLFWWindow(), GLFW_KEY_W) == GLFW_PRESS) + app->Input->MovementDelta |= 0b10000000; + if (glfwGetKey(app->Win->getGLFWWindow(), GLFW_KEY_A) == GLFW_PRESS) + app->Input->MovementDelta |= 0b01000000; + if (glfwGetKey(app->Win->getGLFWWindow(), GLFW_KEY_S) == GLFW_PRESS) + app->Input->MovementDelta |= 0b00100000; + if (glfwGetKey(app->Win->getGLFWWindow(), GLFW_KEY_D) == GLFW_PRESS) + app->Input->MovementDelta |= 0b00010000; + if (glfwGetKey(app->Win->getGLFWWindow(), GLFW_KEY_SPACE) == GLFW_PRESS) + app->Input->MovementDelta |= 0b00001000; + if (glfwGetKey(app->Win->getGLFWWindow(), GLFW_KEY_LEFT_SHIFT) == GLFW_PRESS) + app->Input->MovementDelta |= 0b00000100; } -void Inferno::stopMoveInput() +void stop_move_input(InfernoApp *app) { - movementDelta = 0x0; - mouseDelta = { 0.0f, 0.0f }; + app->Input->MovementDelta = 0x0; + app->Input->MouseDelta = { 0.0f, 0.0f }; } -int Inferno::run() +int run(InfernoApp *app) { - Material basicMaterial("basic"); - Shader basicShader; - basicShader.load("res/shaders/basic.glsl")->link(); - basicMaterial.setGlShader(&basicShader); - - Mesh cornell; - cornell.loadOBJ("res/cornell-box.obj"); - //cornell.loadOBJ("res/sponza.obj"); - cornell.ready(); - cornell.setMaterial(&basicMaterial); - mScene->addMesh(&cornell); - - // Mesh dragon; - // dragon.loadOBJ("res/dragon-cornell-size.obj"); - // dragon.ready(); - // dragon.setMaterial(&basicMaterial); - // mScene->addMesh(&dragon); - - Camera camera; - mScene->setCamera(&camera); - - mRasterRenderer->setScene(mScene); - mRayRenderer->getRenderer()->setScene(mScene); - - while (true) - { - if (!mWin->newFrame()) { break; } - camera.newFrame(); - - // set the main window to the dockspace and then on the first launch set the preset - ImGuiID dockspace_id = ImGui::GetID("main"); - static ImGuiDockNodeFlags dockspace_flags = ImGuiDockNodeFlags_PassthruCentralNode; - if (ImGui::DockBuilderGetNode(dockspace_id) == NULL) { this->uiPreset(); } - ImGui::DockSpace(dockspace_id, ImVec2(0.0f, 0.0f), dockspace_flags); - - // Menu Bar - static bool showPreview = true; - static bool showRenderSettings = true; - static bool showDemoWindow = false; - if (ImGui::BeginMenuBar()) - { - if (ImGui::BeginMenu("Menu")) - { - ImGui::EndMenu(); - } - if (ImGui::BeginMenu("View")) - { - ImGui::Checkbox("Show Preview", &showPreview); - ImGui::SameLine(); HelpMarker("Show the preview window"); - ImGui::Checkbox("Show Settings", &showRenderSettings); - ImGui::SameLine(); HelpMarker("Show the Inferno HART settings window"); - ImGui::Checkbox("Show Demo", &showDemoWindow); - - ImGui::EndMenu(); - } - ImGui::EndMenuBar(); - } - - if (showPreview && ImGui::Begin("Preview", nullptr, ImGuiWindowFlags_NoScrollbar)) - { - if (ImGui::IsWindowHovered()) - { - this->moveInput(); - } else - { - this->stopMoveInput(); - } - if (glm::length(mouseDelta) > 0.0f) camera.mouseMoved(mouseDelta); - if (movementDelta != 0b00000000) camera.moveCamera(movementDelta); - - camera.setRasterViewport({ImGui::GetWindowSize().x, ImGui::GetWindowSize().y}); - mRasterRenderer->setTargetSize({ImGui::GetWindowSize().x, ImGui::GetWindowSize().y}); - mRasterRenderer->prepare(); - mRasterRenderer->draw(); - ImGui::Image((ImTextureID)mRasterRenderer->getRenderedTexture(), - { mRasterRenderer->getTargetSize().x, mRasterRenderer->getTargetSize().y }, - ImVec2(0,1), ImVec2(1,0)); - glBindFramebuffer(GL_FRAMEBUFFER, 0); - ImGui::End(); - } - - if (ImGui::Begin("Render", nullptr, ImGuiWindowFlags_NoScrollbar)) - { - ImGui::Image((ImTextureID)mRayRenderer->getLatestTexture(), - { mRayRenderer->getRenderer()->getTargetSize().x, - mRayRenderer->getRenderer()->getTargetSize().y }, - ImVec2(0,1), ImVec2(1,0)); - glBindTexture(GL_TEXTURE_2D, 0); - ImGui::End(); - } - - if (showRenderSettings && ImGui::Begin("Inferno HART")) - { - // start/stop - bool isRenderRunning = mRayRenderer->progressionStatus(); - if (isRenderRunning) - { - ImGui::PushItemFlag(ImGuiItemFlags_Disabled, true); ImGui::PushStyleVar(ImGuiStyleVar_Alpha, ImGui::GetStyle().Alpha * 0.5f); - ImGui::Button("Start Render"); ImGui::SameLine(); - ImGui::PopItemFlag(); ImGui::PopStyleVar(); - if (ImGui::Button("Stop Render")) - mRayRenderer->stopProgression(); - } else { - if (ImGui::Button("Start Render")) - mRayRenderer->startProgression(); - ImGui::SameLine(); - ImGui::PushItemFlag(ImGuiItemFlags_Disabled, true); ImGui::PushStyleVar(ImGuiStyleVar_Alpha, ImGui::GetStyle().Alpha * 0.5f); - ImGui::Button("Stop Render"); - ImGui::PopItemFlag(); ImGui::PopStyleVar(); - } - - if (ImGui::TreeNode("Render")) - { - // modules - HHM* hhm = mRayRenderer->getTopModule(); - if (ImGui::TreeNode("Accelerator")) - { - ImGui::Button("Find Accelerator..."); - ImGui::Text("Select Accelerator:"); - if (ImGui::BeginListBox("", ImVec2(-FLT_MIN, 3 * ImGui::GetTextLineHeightWithSpacing()))) - { - std::vector moduleNames = hhm->getModuleDirectory()->getModules(); - int active = hhm->getModuleDirectory()->getActiveIndex(); - for (int n = 0; n < moduleNames.size(); n++) - { - const bool isSelected = (active == n); - if (ImGui::Selectable(moduleNames[n].c_str(), isSelected)) - hhm->getModuleDirectory()->setActiveIndex(n); - if (isSelected) - ImGui::SetItemDefaultFocus(); - } - ImGui::EndListBox(); - } - auto* activeCredit = hhm->getModuleDirectory()->getActiveCredit(); - ImGui::Text(activeCredit->ModuleName.c_str()); - ImGui::SameLine(); - ImGui::Text("v%i.%i.%i", activeCredit->VersionMajor, - activeCredit->VersionMinor, - activeCredit->VersionBuild); - ImGui::BulletText(activeCredit->ModuleDesc.c_str()); - ImGui::BulletText("Authored by %s", activeCredit->AuthorName.c_str()); - - ImGui::TreePop(); - } - ImGui::TreePop(); - } - - if (ImGui::TreeNode("Camera")) - { - ImGui::PushItemWidth(100); - ImGui::Text("Camera Position X,Y,Z"); - - bool positionUpdated = false; - ImGui::DragFloat("X", &camera.Position.x, 0.01f, -FLT_MAX, FLT_MAX, "%.2f", ImGuiSliderFlags_None); ImGui::SameLine(); if (ImGui::IsItemEdited()) positionUpdated = true; - ImGui::DragFloat("Y", &camera.Position.y, 0.01f, -FLT_MAX, FLT_MAX, "%.2f", ImGuiSliderFlags_None); ImGui::SameLine(); if (ImGui::IsItemEdited()) positionUpdated = true; - ImGui::DragFloat("Z", &camera.Position.z, 0.01f, -FLT_MAX, FLT_MAX, "%.2f", ImGuiSliderFlags_None); if (ImGui::IsItemEdited()) positionUpdated = true; - if (positionUpdated) camera.setPosition(camera.Position); - - bool viewUpdated = false; - ImGui::Text("Camera Look Yaw, Pitch, Roll"); - ImGui::DragFloat("Yaw", &camera.Yaw, 0.01f, -FLT_MAX, FLT_MAX, "%.2f", ImGuiSliderFlags_None); ImGui::SameLine(); if (ImGui::IsItemEdited()) viewUpdated = true; - ImGui::DragFloat("Pitch", &camera.Pitch, 0.01f, -FLT_MAX, FLT_MAX, "%.2f", ImGuiSliderFlags_None); ImGui::SameLine(); if (ImGui::IsItemEdited()) viewUpdated = true; - ImGui::DragFloat("Roll", &camera.Roll, 0.01f, -FLT_MAX, FLT_MAX, "%.2f", ImGuiSliderFlags_None); if (ImGui::IsItemEdited()) viewUpdated = true; - - ImGui::PopItemWidth(); - ImGui::PushItemWidth(300); - - ImGui::Text("Camera Zoom"); - ImGui::DragFloat("Zoom", &camera.FOV, -0.1f, 0.01f, 180.0f, "%.2f", ImGuiSliderFlags_None); ImGui::SameLine(); if (ImGui::IsItemEdited()) viewUpdated = true; - if (viewUpdated) camera.update(); - - ImGui::PopItemWidth(); - ImGui::TreePop(); - } - ImGui::End(); - } - - if (showDemoWindow) - { - ImGui::ShowDemoWindow(); - } - - GLenum err; - while((err = glGetError()) != GL_NO_ERROR) { - std::string error; - switch (err) { - case GL_INVALID_ENUM: error = "INVALID_ENUM"; break; - case GL_INVALID_VALUE: error = "INVALID_VALUE"; break; - case GL_INVALID_OPERATION: error = "INVALID_OPERATION"; break; - case GL_STACK_OVERFLOW: error = "STACK_OVERFLOW"; break; - case GL_STACK_UNDERFLOW: error = "STACK_UNDERFLOW"; break; - case GL_OUT_OF_MEMORY: error = "OUT_OF_MEMORY"; break; - case GL_INVALID_FRAMEBUFFER_OPERATION: error = "INVALID_FRAMEBUFFER_OPERATION"; break; - default: error = std::to_string((uint32_t)err); break; - } - yolo::error("[GL]: {} {}", err, error); - } - - mWin->render(); - } - - return 0; + return 1; } + +} + diff --git a/src/inferno.hpp b/src/inferno.hpp index 0eeb685..31f1e74 100644 --- a/src/inferno.hpp +++ b/src/inferno.hpp @@ -4,42 +4,27 @@ #include -namespace inferno { +namespace inferno::core { class Window; class HHM; -class RasterizeRenderer; -class RenderDispatcher; -class Scene; +typedef struct InfernoInput { + glm::vec2 MouseDelta; + uint8_t MovementDelta; +} InfernoInput; -class Inferno : public helpers::Singleton -{ -public: - Inferno(); - ~Inferno(); +typedef struct InfernoApp { + Window* Win; + InfernoInput* Input; +} InfernoApp; - void uiPreset(); - - void moveInput(); - void stopMoveInput(); - int run(); - -public: - glm::vec2 mouseDelta; - // 0b00000000 - // 0bFLBRUDxx - uint8_t movementDelta; - -private: - // need deffered init as they need an OpenGL context - // could and should be fixed with a static window - RasterizeRenderer* mRasterRenderer; - RenderDispatcher* mRayRenderer; - Scene* mScene; - -private: - Window* mWin; -}; +InfernoApp* create_inferno(); +void cleanup_inferno(InfernoApp* app); +void preset_gui(InfernoApp* app); +void move_input(InfernoApp* app); +void stop_move_input(InfernoApp* app); +int run(InfernoApp* app); } + diff --git a/src/main.cpp b/src/main.cpp index 2d7a693..d76ce3b 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -5,13 +5,7 @@ int main(int argc, char** argv) { - try - { - return inferno::Inferno::GetInstance().run(); - } - catch (std::exception e) - { - yolo::error(e.what()); - return -1; - } + auto* inferno = inferno::core::create_inferno(); + return inferno::core::run(inferno); } + diff --git a/src/window.cpp b/src/window.cpp index 121a470..87d6151 100644 --- a/src/window.cpp +++ b/src/window.cpp @@ -4,7 +4,7 @@ #include "yolo/yolo.hpp" -using namespace inferno; +using namespace inferno::core; Window::Window() {} diff --git a/src/window.hpp b/src/window.hpp index 6063da9..7bb1324 100644 --- a/src/window.hpp +++ b/src/window.hpp @@ -7,7 +7,7 @@ #define WINDOW_FLAGS ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoBringToFrontOnFocus | ImGuiWindowFlags_NoNavFocus | ImGuiWindowFlags_MenuBar | ImGuiWindowFlags_NoBackground | ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoCollapse -namespace inferno { +namespace inferno::core { typedef void (*KeyCallback)(int key, int scan, int action, int mod); typedef void (*MouseCallback)(double x, double y); From b4e7a5140033cc9f49444e0f6ff6e766923ef86e Mon Sep 17 00:00:00 2001 From: Ben Kyd Date: Sun, 23 Apr 2023 14:10:02 +0100 Subject: [PATCH 02/30] Refactor of the shader class into a cleaner more functional graphics namespace and a procedural builder-style shader --- src/inferno.cpp | 18 ++-- src/inferno.hpp | 16 +-- src/main.cpp | 4 +- src/preview_renderer/shader.cpp | 171 ++++++++++++++++---------------- src/preview_renderer/shader.hpp | 65 +++++------- src/window.cpp | 2 +- src/window.hpp | 2 +- 7 files changed, 133 insertions(+), 145 deletions(-) diff --git a/src/inferno.cpp b/src/inferno.cpp index d0eaa3e..3d9c24b 100644 --- a/src/inferno.cpp +++ b/src/inferno.cpp @@ -23,9 +23,9 @@ #include #include -namespace inferno::core { +using namespace inferno; -InfernoApp* create_inferno() +InfernoApp* inferno_create() { // MOTD yolo::info("INFERNO HART v" INFERNO_VERSION); @@ -38,11 +38,11 @@ InfernoApp* create_inferno() return app; } -void cleanup_inferno(InfernoApp* app) +void inferno_cleanup(InfernoApp* app) { } -static void gui_help_marker(const char* desc) +static void inferno_gui_help_marker(const char* desc) { ImGui::TextDisabled("(?)"); if (ImGui::IsItemHovered(ImGuiHoveredFlags_DelayShort)) @@ -55,7 +55,7 @@ static void gui_help_marker(const char* desc) } } -void preset_gui(InfernoApp *app) +void inferno_preset_gui(InfernoApp *app) { ImGuiID dockspace_id = ImGui::GetID("main"); @@ -72,7 +72,7 @@ void preset_gui(InfernoApp *app) yolo::info("LAYOUT SET TO DEFAULT"); } -void move_input(InfernoApp *app) +void inferno_move_input(InfernoApp *app) { static GLFWcursor* cursor = glfwCreateStandardCursor(GLFW_HAND_CURSOR); glfwSetCursor(app->Win->getGLFWWindow(), cursor); @@ -114,16 +114,14 @@ void move_input(InfernoApp *app) app->Input->MovementDelta |= 0b00000100; } -void stop_move_input(InfernoApp *app) +void inferno_stop_move_input(InfernoApp *app) { app->Input->MovementDelta = 0x0; app->Input->MouseDelta = { 0.0f, 0.0f }; } -int run(InfernoApp *app) +int inferno_run(InfernoApp *app) { return 1; } -} - diff --git a/src/inferno.hpp b/src/inferno.hpp index 31f1e74..a9192fa 100644 --- a/src/inferno.hpp +++ b/src/inferno.hpp @@ -2,9 +2,9 @@ #include "graphics.hpp" -#include +#include -namespace inferno::core { +namespace inferno { class Window; class HHM; @@ -19,12 +19,12 @@ typedef struct InfernoApp { InfernoInput* Input; } InfernoApp; -InfernoApp* create_inferno(); -void cleanup_inferno(InfernoApp* app); -void preset_gui(InfernoApp* app); -void move_input(InfernoApp* app); -void stop_move_input(InfernoApp* app); -int run(InfernoApp* app); +InfernoApp* inferno_create(); +void inferno_cleanup(InfernoApp* app); +void inferno_preset_gui(InfernoApp* app); +void inferno_move_input(InfernoApp* app); +void inferno_stop_move_input(InfernoApp* app); +int inferno_run(InfernoApp* app); } diff --git a/src/main.cpp b/src/main.cpp index d76ce3b..9ee8811 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -5,7 +5,7 @@ int main(int argc, char** argv) { - auto* inferno = inferno::core::create_inferno(); - return inferno::core::run(inferno); + auto* inferno = inferno::inferno_create(); + return inferno::inferno_run(inferno); } diff --git a/src/preview_renderer/shader.cpp b/src/preview_renderer/shader.cpp index 34f005f..c19160b 100644 --- a/src/preview_renderer/shader.cpp +++ b/src/preview_renderer/shader.cpp @@ -3,6 +3,14 @@ #include #include +using namespace inferno::graphics; + +static std::unordered_map shader2Index = { + {GL_VERTEX_SHADER, 0}, + {GL_GEOMETRY_SHADER, 1}, + {GL_FRAGMENT_SHADER, 2} +}; + inline std::string trim(std::string& str) { str.erase(str.find_last_not_of(' ')+1); //suffixing spaces @@ -10,35 +18,62 @@ inline std::string trim(std::string& str) return str; } -static std::unordered_map Shader2Index = { - {GL_VERTEX_SHADER, 0}, - {GL_GEOMETRY_SHADER, 1}, - {GL_FRAGMENT_SHADER, 2} -}; - -using namespace inferno; - std::string textFromFile(const std::filesystem::path& path) { std::ifstream input(path); - return std::string((std::istreambuf_iterator(input)), - std::istreambuf_iterator()); - + return std::string((std::istreambuf_iterator(input)), + std::istreambuf_iterator()); } -Shader::Shader() - : mShaders({ GL_NONE, GL_NONE, GL_NONE}) - , mProgram(0) { +std::vector getKeys(std::unique_ptr& shader, std::string key) { + std::vector ret; + for (const auto& p : shader->PreprocessorDefinitions) if (p.key == key) ret.push_back(&p); + return ret; +} + +bool checkShader(GLuint uid) { + GLint isCompiled = 0; + glGetShaderiv(uid, GL_COMPILE_STATUS, &isCompiled); + if(isCompiled == GL_FALSE) + { + GLint maxLength = 0; + glGetShaderiv(uid, GL_INFO_LOG_LENGTH, &maxLength); + + std::vector errorLog(maxLength); + glGetShaderInfoLog(uid, maxLength, &maxLength, &errorLog[0]); + + for (int i = 0; i < errorLog.size(); i++) { + std::cout << errorLog[i]; + } + + glDeleteShader(uid); + return false; + } + + return true; } -Shader::~Shader() { +std::unique_ptr shader_create() { + std::unique_ptr shader = std::make_unique(); + + shader->Program = 0; + shader->Shaders[0] = GL_NONE; + shader->Shaders[1] = GL_NONE; + shader->Shaders[2] = GL_NONE; + + return shader; +} + +void shader_cleanup(std::unique_ptr& shader) { for (int i = 0; i < 3; i++) { - if (mShaders[i] == GL_NONE) continue; - glDeleteShader(mShaders[i]); + if (shader->Shaders[i] == GL_NONE) continue; + glDeleteShader(shader->Shaders[i]); } + + glDeleteProgram(shader->Program); } -Shader* Shader::load(std::filesystem::path path) { +void shader_load(std::unique_ptr& shader, std::filesystem::path path) { assert(std::filesystem::exists(path)); @@ -47,7 +82,7 @@ Shader* Shader::load(std::filesystem::path path) { for (int i = 0; i < loadedShaderSource.length(); i++) { const char& c = loadedShaderSource[i]; if (c == '#') { - mPreprocessorDefinition def = { .start = i }; + ShaderPreprocessorDefinition def = { .start = i }; int j; for (j = ++i; loadedShaderSource[j] != ' '; j++) { def.key += loadedShaderSource[j]; @@ -58,16 +93,16 @@ Shader* Shader::load(std::filesystem::path path) { def.end = j; i = j; // advance i def.def = trim(def.def); def.key = trim(def.key); - mDefinitions.push_back(def); + shader->PreprocessorDefinitions.push_back(def); } } // now we have all of the key/value definitions // we can extract the relavent ones, for example // "type" - auto types = mGetKeys("type"); + std::vector types = getKeys(shader, "type"); int i = 0; - for (const mPreprocessorDefinition* type : types) { + for (const ShaderPreprocessorDefinition* type : types) { GLuint glType = GL_NONE; if (type->def == "vertex") glType = GL_VERTEX_SHADER; if (type->def == "geometry") glType = GL_GEOMETRY_SHADER; @@ -75,84 +110,54 @@ Shader* Shader::load(std::filesystem::path path) { assert(glType != GL_NONE); - mShaders[Shader2Index[glType]] = glCreateShader(glType); - + shader->Shaders[shader2Index[glType]] = glCreateShader(glType); + const char* source = loadedShaderSource.c_str() + type->end; int end = types.size() - 1 == i ? types.size(): types[i + 1]->start; int length = end - type->end; - - glShaderSource(mShaders[Shader2Index[glType]], 1, &source, &length); + + glShaderSource(shader->Shaders[shader2Index[glType]], 1, &source, &length); i++; } - - return this; } -Shader* Shader::link() { +void shader_link(std::unique_ptr &shader) { + shader->Program = glCreateProgram(); - mProgram = glCreateProgram(); - for (int i = 0; i < 3; i++) { - if (mShaders[i] == GL_NONE) continue; + if (shader->Shaders[i] == GL_NONE) continue; - glCompileShader(mShaders[i]); - if (!mCheckShader(mShaders[i])) continue; + glCompileShader(shader->Shaders[i]); + if (!checkShader(shader->Shaders[i])) continue; - glAttachShader(mProgram, mShaders[i]); + glAttachShader(shader->Program, shader->Shaders[i]); } - glLinkProgram(mProgram); - return this; + glLinkProgram(shader->Program); } -Shader* Shader::use() { - glUseProgram(mProgram); - return this; + +void shader_add_attribute(std::unique_ptr &shader, const std::string &attribute) { + shader->Attributes[attribute] = glGetAttribLocation(shader->Program, attribute.c_str()); } -Shader* Shader::unUse() { +void shader_add_uniform(std::unique_ptr &shader, const std::string &uniform) { + shader->Uniforms[uniform] = glGetUniformLocation(shader->Program, uniform.c_str()); +} + +GLuint shader_get_attribute(std::unique_ptr &shader, const std::string &attribute) { + return shader->Attributes[attribute]; +} + +GLuint shader_get_uniform(std::unique_ptr &shader, const std::string &uniform) { + return shader->Uniforms[uniform]; +} + +void shader_use(std::unique_ptr& shader) { + glUseProgram(shader->Program); +} + +void shader_unuse(std::unique_ptr& shader) { glUseProgram(0); - return this; } -GLuint Shader::getProgram() -{ - return mProgram; -} - - -void Shader::addAttribute(const std::string& attribute) { - mAttributes[attribute] = glGetAttribLocation(mProgram, attribute.c_str()); -} - -void Shader::addUniform(const std::string& uniform) { - mUniformLocations[uniform] = glGetUniformLocation(mProgram, uniform.c_str()); -} - -bool Shader::mCheckShader(GLuint uid) { - GLint isCompiled = 0; - glGetShaderiv(uid, GL_COMPILE_STATUS, &isCompiled); - if(isCompiled == GL_FALSE) - { - GLint maxLength = 0; - glGetShaderiv(uid, GL_INFO_LOG_LENGTH, &maxLength); - - std::vector errorLog(maxLength); - glGetShaderInfoLog(uid, maxLength, &maxLength, &errorLog[0]); - - for (int i = 0; i < errorLog.size(); i++) { - std::cout << errorLog[i]; - } - - glDeleteShader(uid); - return false; - } - - return true; -} - -std::vector Shader::mGetKeys(std::string key) { - std::vector ret; - for (const auto& p : mDefinitions) if (p.key == key) ret.push_back(&p); - return ret; -} diff --git a/src/preview_renderer/shader.hpp b/src/preview_renderer/shader.hpp index f2661e3..c43bd7f 100644 --- a/src/preview_renderer/shader.hpp +++ b/src/preview_renderer/shader.hpp @@ -8,52 +8,37 @@ #include #include -namespace inferno { +namespace inferno::graphics { -class Shader { -public: - Shader(); - ~Shader(); +typedef struct ShaderPreprocessorDefinition { + int start, end; + std::string key; + std::string def; +} shaderpreprocessordefinition; - Shader* preprocessorDefine(std::string statement); - Shader* load(std::filesystem::path path); - Shader* link(); +typedef struct Shader { + GLuint Shaders[3]; + GLuint Program; + std::unordered_map Attributes; + std::unordered_map Uniforms; + std::vector PreprocessorDefinitions; +} Shader; - Shader* use(); - Shader* unUse(); +std::unique_ptr shader_create(); +void shader_cleanup(std::unique_ptr& shader); - GLuint getProgram(); +void shader_load(std::unique_ptr& shader, std::filesystem::path path); +void shader_link(std::unique_ptr& shader); +// TODO: Implement shader_reload +void shader_add_attribute(std::unique_ptr& shader, const std::string& attribute); +void shader_add_uniform(std::unique_ptr& shader, const std::string& uniform); +GLuint shader_get_attribute(std::unique_ptr& shader, const std::string& attribute); +GLuint shader_get_uniform(std::unique_ptr& shader, const std::string& uniform); - void addAttribute(const std::string& attribute); - void addUniform(const std::string& uniform); - GLuint operator[](const std::string& attribute) { - return mAttributes[attribute]; - } - GLuint operator()(const std::string& uniform) { - return mUniformLocations[uniform]; - } +void shader_use(std::unique_ptr& shader); +void shader_unuse(std::unique_ptr& shader); -private: - GLuint mShaders[3]; - GLuint mProgram; - - std::unordered_map mAttributes; - std::unordered_map mUniformLocations; - bool mCheckShader(GLuint uid); - -private: - // preprocessor definitions can be defined by their - // start/end index, this is so that text can either be inserted - // in their place or for the "type" definition, the program - // can count until the next "type" definition per shader - struct mPreprocessorDefinition { - int start, end; - std::string key; - std::string def; - }; - std::vector mDefinitions; - std::vector mGetKeys(std::string key); -}; } + diff --git a/src/window.cpp b/src/window.cpp index 87d6151..121a470 100644 --- a/src/window.cpp +++ b/src/window.cpp @@ -4,7 +4,7 @@ #include "yolo/yolo.hpp" -using namespace inferno::core; +using namespace inferno; Window::Window() {} diff --git a/src/window.hpp b/src/window.hpp index 7bb1324..6063da9 100644 --- a/src/window.hpp +++ b/src/window.hpp @@ -7,7 +7,7 @@ #define WINDOW_FLAGS ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoBringToFrontOnFocus | ImGuiWindowFlags_NoNavFocus | ImGuiWindowFlags_MenuBar | ImGuiWindowFlags_NoBackground | ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoCollapse -namespace inferno::core { +namespace inferno { typedef void (*KeyCallback)(int key, int scan, int action, int mod); typedef void (*MouseCallback)(double x, double y); From 2e072d23f10426aa593d9112cb591b28fbe4c345 Mon Sep 17 00:00:00 2001 From: Ben Kyd Date: Mon, 24 Apr 2023 00:12:18 +0100 Subject: [PATCH 03/30] window refactor 50% --- src/preview_renderer/shader.hpp | 1 - src/window.cpp | 19 +++++++----- src/window.hpp | 54 +++++++++------------------------ 3 files changed, 27 insertions(+), 47 deletions(-) diff --git a/src/preview_renderer/shader.hpp b/src/preview_renderer/shader.hpp index c43bd7f..9d83457 100644 --- a/src/preview_renderer/shader.hpp +++ b/src/preview_renderer/shader.hpp @@ -39,6 +39,5 @@ GLuint shader_get_uniform(std::unique_ptr& shader, const std::string& un void shader_use(std::unique_ptr& shader); void shader_unuse(std::unique_ptr& shader); - } diff --git a/src/window.cpp b/src/window.cpp index 121a470..2eba72b 100644 --- a/src/window.cpp +++ b/src/window.cpp @@ -4,21 +4,26 @@ #include "yolo/yolo.hpp" -using namespace inferno; +using namespace inferno::graphics; -Window::Window() {} +static WINDOW_MODE WinMode = WINDOW_MODE::WIN_MODE_DEFAULT; +static KeyCallback KeyCallback = nullptr; +static int Width, Height; +static const char* GlslVersion; +static GLFWwindow* Gindow; -Window::~Window() { +static void glfwErrorCallback(int error, const char* description); + +void window_cleanup() { shutdownImGui(); shutdownGLFW(); } -void Window::init(std::string title, int width, int height) { - this->width = width; - this->height = height; +void window_create(std::string title, int width, int height) { + Width = width; + Height = height; setupGLFW(title); glfwSetKeyCallback(getGLFWWindow(), glfwKeyCallback); - setupImGui(); } diff --git a/src/window.hpp b/src/window.hpp index 6063da9..ab2bd57 100644 --- a/src/window.hpp +++ b/src/window.hpp @@ -7,7 +7,7 @@ #define WINDOW_FLAGS ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoBringToFrontOnFocus | ImGuiWindowFlags_NoNavFocus | ImGuiWindowFlags_MenuBar | ImGuiWindowFlags_NoBackground | ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoCollapse -namespace inferno { +namespace inferno::graphics { typedef void (*KeyCallback)(int key, int scan, int action, int mod); typedef void (*MouseCallback)(double x, double y); @@ -18,48 +18,24 @@ enum WINDOW_MODE WIN_MODE_FPS, }; -class Window : public helpers::Singleton -{ -public: - Window(); - ~Window(); +void window_create(std::string title, int width, int height); +void window_cleanup(); - void init(std::string title, int width, int height); +void window_set_title(std::string title); - bool newFrame(); - void render(); +void window_set_size(int w, int h); +void window_set_pos(int x, int y); +glm::vec2 window_get_size(); +void window_get_pos(int& x, int& y); - void setTitle(std::string title); - void setSize(int w, int h); - void setPos(int x, int y); +GLFWwindow* window_get_glfw_window(); +void window_set_fps_mode(); - glm::vec2 getSize(); - void getPos(int& x, int& y); - GLFWwindow* getGLFWWindow() { return window; } +void window_set_key_callback(KeyCallback callback); +KeyCallback window_get_key_callback(); - void setFPSMode(); - - void setKeyCallback(KeyCallback callback); - KeyCallback getKeyCallback(); - -private: - WINDOW_MODE mWinMode = WIN_MODE_DEFAULT; - -private: - void setupGLFW(std::string title); - void setupImGui(); - void shutdownImGui(); - void shutdownGLFW(); - - static void glfwKeyCallback(GLFWwindow* window, int key, int scancode, int action, int mods); - KeyCallback mKeyCallback = nullptr; - -private: - static void glfwErrorCallback(int error, const char* description); - - int width, height; - const char* glslVersion; - GLFWwindow* window; -}; +bool window_new_frame(); +void window_render(); } + From 54b2c2aab8145deac33943a0398e5b06b2c0b466 Mon Sep 17 00:00:00 2001 From: Ben Kyd Date: Mon, 24 Apr 2023 11:02:06 +0100 Subject: [PATCH 04/30] 100% done the window now --- src/window.cpp | 185 +++++++++++++++++++++++++------------------------ src/window.hpp | 2 +- 2 files changed, 94 insertions(+), 93 deletions(-) diff --git a/src/window.cpp b/src/window.cpp index 2eba72b..a01100f 100644 --- a/src/window.cpp +++ b/src/window.cpp @@ -1,94 +1,28 @@ #include "window.hpp" #include "gui/style.hpp" - #include "yolo/yolo.hpp" using namespace inferno::graphics; static WINDOW_MODE WinMode = WINDOW_MODE::WIN_MODE_DEFAULT; -static KeyCallback KeyCallback = nullptr; +static KeyCallback UserKeyCallback = nullptr; static int Width, Height; static const char* GlslVersion; -static GLFWwindow* Gindow; +static GLFWwindow* Window; -static void glfwErrorCallback(int error, const char* description); - -void window_cleanup() { - shutdownImGui(); - shutdownGLFW(); -} - -void window_create(std::string title, int width, int height) { - Width = width; - Height = height; - setupGLFW(title); - glfwSetKeyCallback(getGLFWWindow(), glfwKeyCallback); - setupImGui(); -} - -void Window::setTitle(std::string title) { - glfwSetWindowTitle(window, title.c_str()); -} - -void Window::setSize(int w, int h) { - width = w; - height = h; - glfwSetWindowSize(window, width, height); -} - -void Window::setPos(int x, int y) { glfwSetWindowPos(window, x, y); } - -glm::vec2 Window::getSize() { return {width, height}; } - -void Window::getPos(int &x, int &y) { glfwGetWindowPos(window, &x, &y); } - -void Window::setFPSMode() { - mWinMode = WIN_MODE_FPS; - glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_HIDDEN); -} - -void Window::setKeyCallback(KeyCallback callback) { mKeyCallback = callback; } - -KeyCallback Window::getKeyCallback() { return mKeyCallback; } - -bool Window::newFrame() { - glfwPollEvents(); - if (mWinMode == WIN_MODE_FPS) { - glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_HIDDEN); - glfwSetCursorPos(window, (double)width / 2, (double)height / 2); +void glfwKeyCallback(GLFWwindow *window, int key, int scancode, + int action, int mods) { + if (UserKeyCallback != nullptr) { + UserKeyCallback(key, scancode, action, mods); } - if (glfwWindowShouldClose(window)) { - return false; - } - - glfwGetWindowSize(window, &width, &height); - - glClearColor(0.1, 0.1, 0.1, 1.0); - glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); - - ImGui_ImplOpenGL3_NewFrame(); - ImGui_ImplGlfw_NewFrame(); - ImGui::NewFrame(); - - ImGui::Begin("main", nullptr, WINDOW_FLAGS); - ImGui::SetWindowPos(ImVec2(0, 0)); - ImGui::SetWindowSize(ImVec2(width, height)); - - return true; } -void Window::render() { - ImGui::End(); - ImGui::Render(); - auto io = ImGui::GetIO(); - glViewport(0, 0, (int)io.DisplaySize.x, (int)io.DisplaySize.y); - ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData()); - glfwSwapBuffers(window); - ImGui::UpdatePlatformWindows(); +void glfwErrorCallback(int error, const char *description) { + yolo::error("[GLFW {}] {}", error, description); } -void Window::setupGLFW(std::string title) { +void setupGLFW(std::string title) { glfwSetErrorCallback(glfwErrorCallback); if (!glfwInit()) throw std::runtime_error("Failed to initialize GLFW"); @@ -109,7 +43,7 @@ void Window::setupGLFW(std::string title) { glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // Required on Mac #else // GL 4.5 + GLSL 450 - glslVersion = "#version 450"; + GlslVersion = "#version 450"; glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 5); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); // 3.2+ only @@ -117,15 +51,15 @@ void Window::setupGLFW(std::string title) { #endif // Create window with graphics context - window = glfwCreateWindow(1280, 720, title.c_str(), NULL, NULL); - if (window == NULL) + Window = glfwCreateWindow(1280, 720, title.c_str(), NULL, NULL); + if (Window == NULL) throw std::runtime_error("Could not create window"); - glfwMakeContextCurrent(window); + glfwMakeContextCurrent(Window); gladLoadGLLoader((GLADloadproc)glfwGetProcAddress); glfwSwapInterval(1); // Enable vsync } -void Window::setupImGui() { +void setupImGui() { // Setup Dear ImGui context IMGUI_CHECKVERSION(); ImGui::CreateContext(); @@ -145,30 +79,97 @@ void Window::setupImGui() { // = true; // Setup Platform/Renderer backends - ImGui_ImplGlfw_InitForOpenGL(window, true); - ImGui_ImplOpenGL3_Init(glslVersion); + ImGui_ImplGlfw_InitForOpenGL(Window, true); + ImGui_ImplOpenGL3_Init(GlslVersion); - SetupImGuiStyle2(); + inferno::SetupImGuiStyle2(); } -void Window::shutdownImGui() { +void shutdownImGui() { ImGui_ImplOpenGL3_Shutdown(); ImGui_ImplGlfw_Shutdown(); ImGui::DestroyContext(); } -void Window::shutdownGLFW() { - glfwDestroyWindow(window); +void shutdownGLFW() { + glfwDestroyWindow(Window); glfwTerminate(); } -void Window::glfwKeyCallback(GLFWwindow *window, int key, int scancode, - int action, int mods) { - if (Window::GetInstance().getKeyCallback() != nullptr) { - Window::GetInstance().getKeyCallback()(key, scancode, action, mods); + +void window_create(std::string title, int width, int height) { + Width = width; + Height = height; + setupGLFW(title); + glfwSetKeyCallback(Window, glfwKeyCallback); + setupImGui(); +} + +void window_cleanup() { + shutdownImGui(); + shutdownGLFW(); +} + +void window_set_title(std::string title) { + glfwSetWindowTitle(Window, title.c_str()); +} + +void window_set_size(int w, int h) { + Width = w; + Height = h; + glfwSetWindowSize(Window, Width, Height); +} + +void window_set_pos(int x, int y) { glfwSetWindowPos(Window, x, y); } + +glm::vec2 window_get_size() { return { Width, Height }; } + +void window_get_pos(int& x, int& y) { glfwGetWindowPos(Window, &x, &y); } + +void window_set_mode(WINDOW_MODE mode) { + WinMode = mode; + if (mode == WINDOW_MODE::WIN_MODE_FPS) { + glfwSetInputMode(Window, GLFW_CURSOR, GLFW_CURSOR_HIDDEN); } } -void Window::glfwErrorCallback(int error, const char *description) { - yolo::error("[GLFW {}] {}", error, description); +void window_set_key_callback(KeyCallback callback) { UserKeyCallback = callback; } + +KeyCallback window_get_key_callback() { return UserKeyCallback; } + +bool window_new_frame() { + glfwPollEvents(); + if (WinMode == WIN_MODE_FPS) { + glfwSetInputMode(Window, GLFW_CURSOR, GLFW_CURSOR_HIDDEN); + glfwSetCursorPos(Window, (double)Width / 2, (double)Height / 2); + } + if (glfwWindowShouldClose(Window)) { + return false; + } + + glfwGetWindowSize(Window, &Width, &Height); + + glClearColor(0.1, 0.1, 0.1, 1.0); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + + ImGui_ImplOpenGL3_NewFrame(); + ImGui_ImplGlfw_NewFrame(); + ImGui::NewFrame(); + + ImGui::Begin("main", nullptr, WINDOW_FLAGS); + ImGui::SetWindowPos(ImVec2(0, 0)); + ImGui::SetWindowSize(ImVec2(Width, Height)); + + return true; } + +void window_render() { + ImGui::End(); + ImGui::Render(); + auto io = ImGui::GetIO(); + glViewport(0, 0, (int)io.DisplaySize.x, (int)io.DisplaySize.y); + ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData()); + glfwSwapBuffers(Window); + ImGui::UpdatePlatformWindows(); +} + diff --git a/src/window.hpp b/src/window.hpp index ab2bd57..9ccc1f7 100644 --- a/src/window.hpp +++ b/src/window.hpp @@ -29,7 +29,7 @@ glm::vec2 window_get_size(); void window_get_pos(int& x, int& y); GLFWwindow* window_get_glfw_window(); -void window_set_fps_mode(); +void window_set_mode(WINDOW_MODE mode); void window_set_key_callback(KeyCallback callback); KeyCallback window_get_key_callback(); From d166d6c4a316be5315783cca184fbb1c69d03d38 Mon Sep 17 00:00:00 2001 From: Ben Kyd Date: Mon, 24 Apr 2023 11:08:42 +0100 Subject: [PATCH 05/30] apply that --- src/inferno.cpp | 5 ++--- src/inferno.hpp | 1 - 2 files changed, 2 insertions(+), 4 deletions(-) diff --git a/src/inferno.cpp b/src/inferno.cpp index 3d9c24b..4af2dd7 100644 --- a/src/inferno.cpp +++ b/src/inferno.cpp @@ -33,8 +33,7 @@ InfernoApp* inferno_create() InfernoApp* app = new InfernoApp(); // Create window - app->Win = &Window::GetInstance(); - app->Win->init("Inferno v" INFERNO_VERSION, 1280, 720); + graphics::window_create("Inferno v" INFERNO_VERSION, 1280, 720); return app; } @@ -75,7 +74,7 @@ void inferno_preset_gui(InfernoApp *app) void inferno_move_input(InfernoApp *app) { static GLFWcursor* cursor = glfwCreateStandardCursor(GLFW_HAND_CURSOR); - glfwSetCursor(app->Win->getGLFWWindow(), cursor); + glfwSetCursor(graphics::window_get_glfw_window(), cursor); // KBD & MOUSE // pan only get on hold diff --git a/src/inferno.hpp b/src/inferno.hpp index a9192fa..02bbc0b 100644 --- a/src/inferno.hpp +++ b/src/inferno.hpp @@ -15,7 +15,6 @@ typedef struct InfernoInput { } InfernoInput; typedef struct InfernoApp { - Window* Win; InfernoInput* Input; } InfernoApp; From 2ed5212b351c002401ee975995fc2eb2588b9fa2 Mon Sep 17 00:00:00 2001 From: Ben Kyd Date: Mon, 24 Apr 2023 11:09:19 +0100 Subject: [PATCH 06/30] oops --- src/inferno.cpp | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/src/inferno.cpp b/src/inferno.cpp index 4af2dd7..d7a55f7 100644 --- a/src/inferno.cpp +++ b/src/inferno.cpp @@ -80,15 +80,15 @@ void inferno_move_input(InfernoApp *app) // pan only get on hold static glm::dvec2 lastMousePos; static int firstClick = 0; - if (glfwGetMouseButton(app->Win->getGLFWWindow(), GLFW_MOUSE_BUTTON_1) == GLFW_PRESS) + if (glfwGetMouseButton(graphics::window_get_glfw_window(), GLFW_MOUSE_BUTTON_1) == GLFW_PRESS) { firstClick++; if (firstClick == 1) { - glfwGetCursorPos(app->Win->getGLFWWindow(), &lastMousePos.x, &lastMousePos.y); + glfwGetCursorPos(graphics::window_get_glfw_window(), &lastMousePos.x, &lastMousePos.y); } glm::dvec2 tempMousePos = { 0.0f, 0.0f }; - glfwGetCursorPos(app->Win->getGLFWWindow(), &tempMousePos.x, &tempMousePos.y); + glfwGetCursorPos(graphics::window_get_glfw_window(), &tempMousePos.x, &tempMousePos.y); app->Input->MouseDelta = lastMousePos - tempMousePos; lastMousePos = tempMousePos; } else @@ -99,17 +99,17 @@ void inferno_move_input(InfernoApp *app) } app->Input->MovementDelta = 0b00000000; - if (glfwGetKey(app->Win->getGLFWWindow(), GLFW_KEY_W) == GLFW_PRESS) + if (glfwGetKey(graphics::window_get_glfw_window(), GLFW_KEY_W) == GLFW_PRESS) app->Input->MovementDelta |= 0b10000000; - if (glfwGetKey(app->Win->getGLFWWindow(), GLFW_KEY_A) == GLFW_PRESS) + if (glfwGetKey(graphics::window_get_glfw_window(), GLFW_KEY_A) == GLFW_PRESS) app->Input->MovementDelta |= 0b01000000; - if (glfwGetKey(app->Win->getGLFWWindow(), GLFW_KEY_S) == GLFW_PRESS) + if (glfwGetKey(graphics::window_get_glfw_window(), GLFW_KEY_S) == GLFW_PRESS) app->Input->MovementDelta |= 0b00100000; - if (glfwGetKey(app->Win->getGLFWWindow(), GLFW_KEY_D) == GLFW_PRESS) + if (glfwGetKey(graphics::window_get_glfw_window(), GLFW_KEY_D) == GLFW_PRESS) app->Input->MovementDelta |= 0b00010000; - if (glfwGetKey(app->Win->getGLFWWindow(), GLFW_KEY_SPACE) == GLFW_PRESS) + if (glfwGetKey(graphics::window_get_glfw_window(), GLFW_KEY_SPACE) == GLFW_PRESS) app->Input->MovementDelta |= 0b00001000; - if (glfwGetKey(app->Win->getGLFWWindow(), GLFW_KEY_LEFT_SHIFT) == GLFW_PRESS) + if (glfwGetKey(graphics::window_get_glfw_window(), GLFW_KEY_LEFT_SHIFT) == GLFW_PRESS) app->Input->MovementDelta |= 0b00000100; } From b3996b0a8da75210ea7611896325737c17afcf89 Mon Sep 17 00:00:00 2001 From: Ben Kyd Date: Mon, 24 Apr 2023 15:47:01 +0100 Subject: [PATCH 07/30] CLANG FORMAT LETS GOOO --- .clang-format | 192 ++++++++++++++++++++++++++++++ src/inferno.cpp | 49 ++++---- src/inferno.hpp | 1 - src/main.cpp | 1 - src/preview_renderer/renderer.cpp | 14 +-- src/preview_renderer/shader.cpp | 176 +++++++++++++++------------ src/preview_renderer/shader.hpp | 8 +- src/scene/material.cpp | 16 +-- src/scene/material.hpp | 8 +- src/window.cpp | 66 ++++++---- src/window.hpp | 6 +- 11 files changed, 376 insertions(+), 161 deletions(-) create mode 100644 .clang-format diff --git a/.clang-format b/.clang-format new file mode 100644 index 0000000..c8e7b33 --- /dev/null +++ b/.clang-format @@ -0,0 +1,192 @@ +--- +Language: Cpp +# BasedOnStyle: WebKit +AccessModifierOffset: -4 +AlignAfterOpenBracket: DontAlign +AlignArrayOfStructures: None +AlignConsecutiveMacros: None +AlignConsecutiveAssignments: None +AlignConsecutiveBitFields: None +AlignConsecutiveDeclarations: None +AlignEscapedNewlines: Right +AlignOperands: DontAlign +AlignTrailingComments: false +AllowAllArgumentsOnNextLine: true +AllowAllParametersOfDeclarationOnNextLine: true +AllowShortEnumsOnASingleLine: true +AllowShortBlocksOnASingleLine: Empty +AllowShortCaseLabelsOnASingleLine: false +AllowShortFunctionsOnASingleLine: All +AllowShortLambdasOnASingleLine: All +AllowShortIfStatementsOnASingleLine: Never +AllowShortLoopsOnASingleLine: false +AlwaysBreakAfterDefinitionReturnType: None +AlwaysBreakAfterReturnType: None +AlwaysBreakBeforeMultilineStrings: false +AlwaysBreakTemplateDeclarations: MultiLine +AttributeMacros: + - __capability +BinPackArguments: true +BinPackParameters: true +BraceWrapping: + AfterCaseLabel: false + AfterClass: false + AfterControlStatement: Never + AfterEnum: false + AfterFunction: true + AfterNamespace: false + AfterObjCDeclaration: false + AfterStruct: false + AfterUnion: false + AfterExternBlock: false + BeforeCatch: false + BeforeElse: false + BeforeLambdaBody: false + BeforeWhile: false + IndentBraces: false + SplitEmptyFunction: true + SplitEmptyRecord: true + SplitEmptyNamespace: true +BreakBeforeBinaryOperators: All +BreakBeforeConceptDeclarations: true +BreakBeforeBraces: WebKit +BreakBeforeInheritanceComma: false +BreakInheritanceList: BeforeColon +BreakBeforeTernaryOperators: true +BreakConstructorInitializersBeforeComma: false +BreakConstructorInitializers: BeforeComma +BreakAfterJavaFieldAnnotations: false +BreakStringLiterals: true +ColumnLimit: 0 +CommentPragmas: '^ IWYU pragma:' +QualifierAlignment: Leave +CompactNamespaces: false +ConstructorInitializerIndentWidth: 4 +ContinuationIndentWidth: 4 +Cpp11BracedListStyle: false +DeriveLineEnding: true +DerivePointerAlignment: false +DisableFormat: false +EmptyLineAfterAccessModifier: Never +EmptyLineBeforeAccessModifier: LogicalBlock +ExperimentalAutoDetectBinPacking: false +PackConstructorInitializers: BinPack +BasedOnStyle: '' +ConstructorInitializerAllOnOneLineOrOnePerLine: false +AllowAllConstructorInitializersOnNextLine: true +FixNamespaceComments: false +ForEachMacros: + - foreach + - Q_FOREACH + - BOOST_FOREACH +IfMacros: + - KJ_IF_MAYBE +IncludeBlocks: Preserve +IncludeCategories: + - Regex: '^"(llvm|llvm-c|clang|clang-c)/' + Priority: 2 + SortPriority: 0 + CaseSensitive: false + - Regex: '^(<|"(gtest|gmock|isl|json)/)' + Priority: 3 + SortPriority: 0 + CaseSensitive: false + - Regex: '.*' + Priority: 1 + SortPriority: 0 + CaseSensitive: false +IncludeIsMainRegex: '(Test)?$' +IncludeIsMainSourceRegex: '' +IndentAccessModifiers: false +IndentCaseLabels: false +IndentCaseBlocks: false +IndentGotoLabels: true +IndentPPDirectives: None +IndentExternBlock: AfterExternBlock +IndentRequires: false +IndentWidth: 4 +IndentWrappedFunctionNames: false +InsertTrailingCommas: None +JavaScriptQuotes: Leave +JavaScriptWrapImports: true +KeepEmptyLinesAtTheStartOfBlocks: true +LambdaBodyIndentation: Signature +MacroBlockBegin: '' +MacroBlockEnd: '' +MaxEmptyLinesToKeep: 1 +NamespaceIndentation: Inner +ObjCBinPackProtocolList: Auto +ObjCBlockIndentWidth: 4 +ObjCBreakBeforeNestedBlockParam: true +ObjCSpaceAfterProperty: true +ObjCSpaceBeforeProtocolList: true +PenaltyBreakAssignment: 2 +PenaltyBreakBeforeFirstCallParameter: 19 +PenaltyBreakComment: 300 +PenaltyBreakFirstLessLess: 120 +PenaltyBreakOpenParenthesis: 0 +PenaltyBreakString: 1000 +PenaltyBreakTemplateDeclaration: 10 +PenaltyExcessCharacter: 1000000 +PenaltyReturnTypeOnItsOwnLine: 60 +PenaltyIndentedWhitespace: 0 +PointerAlignment: Left +PPIndentWidth: -1 +ReferenceAlignment: Pointer +ReflowComments: true +RemoveBracesLLVM: false +SeparateDefinitionBlocks: Leave +ShortNamespaceLines: 1 +SortIncludes: CaseSensitive +SortJavaStaticImport: Before +SortUsingDeclarations: true +SpaceAfterCStyleCast: false +SpaceAfterLogicalNot: false +SpaceAfterTemplateKeyword: true +SpaceBeforeAssignmentOperators: true +SpaceBeforeCaseColon: false +SpaceBeforeCpp11BracedList: true +SpaceBeforeCtorInitializerColon: true +SpaceBeforeInheritanceColon: true +SpaceBeforeParens: ControlStatements +SpaceBeforeParensOptions: + AfterControlStatements: true + AfterForeachMacros: true + AfterFunctionDefinitionName: false + AfterFunctionDeclarationName: false + AfterIfMacros: true + AfterOverloadedOperator: false + BeforeNonEmptyParentheses: false +SpaceAroundPointerQualifiers: Default +SpaceBeforeRangeBasedForLoopColon: true +SpaceInEmptyBlock: true +SpaceInEmptyParentheses: false +SpacesBeforeTrailingComments: 1 +SpacesInAngles: Never +SpacesInConditionalStatement: false +SpacesInContainerLiterals: true +SpacesInCStyleCastParentheses: false +SpacesInLineCommentPrefix: + Minimum: 1 + Maximum: -1 +SpacesInParentheses: false +SpacesInSquareBrackets: false +SpaceBeforeSquareBrackets: false +BitFieldColonSpacing: Both +Standard: Latest +StatementAttributeLikeMacros: + - Q_EMIT +StatementMacros: + - Q_UNUSED + - QT_REQUIRE_VERSION +TabWidth: 8 +UseCRLF: false +UseTab: Never +WhitespaceSensitiveMacros: + - STRINGIZE + - PP_STRINGIZE + - BOOST_PP_STRINGIZE + - NS_SWIFT_NAME + - CF_SWIFT_NAME +... + diff --git a/src/inferno.cpp b/src/inferno.cpp index d7a55f7..1533c70 100644 --- a/src/inferno.cpp +++ b/src/inferno.cpp @@ -1,29 +1,29 @@ #include "inferno.hpp" #include -//#include "gui/layout.hpp" +// #include "gui/layout.hpp" #include "window.hpp" -//#include "hart_module.hpp" -//#include "hart_directory.hpp" +// #include "hart_module.hpp" +// #include "hart_directory.hpp" -//#include "preview_renderer/renderer.hpp" -//#include "preview_renderer/shader.hpp" -//#include "renderer/dispatcher.hpp" -//#include "renderer/renderer.hpp" -//#include "scene/camera.hpp" -//#include "scene/scene.hpp" -//#include "scene/material.hpp" -//#include "scene/mesh.hpp" +// #include "preview_renderer/renderer.hpp" +// #include "preview_renderer/shader.hpp" +// #include "renderer/dispatcher.hpp" +// #include "renderer/renderer.hpp" +// #include "scene/camera.hpp" +// #include "scene/scene.hpp" +// #include "scene/material.hpp" +// #include "scene/mesh.hpp" #include +#include #include #include -#include #include -using namespace inferno; +namespace inferno { InfernoApp* inferno_create() { @@ -44,8 +44,7 @@ void inferno_cleanup(InfernoApp* app) static void inferno_gui_help_marker(const char* desc) { ImGui::TextDisabled("(?)"); - if (ImGui::IsItemHovered(ImGuiHoveredFlags_DelayShort)) - { + if (ImGui::IsItemHovered(ImGuiHoveredFlags_DelayShort)) { ImGui::BeginTooltip(); ImGui::PushTextWrapPos(ImGui::GetFontSize() * 35.0f); ImGui::TextUnformatted(desc); @@ -54,13 +53,13 @@ static void inferno_gui_help_marker(const char* desc) } } -void inferno_preset_gui(InfernoApp *app) +void inferno_preset_gui(InfernoApp* app) { ImGuiID dockspace_id = ImGui::GetID("main"); ImGui::DockBuilderRemoveNode(dockspace_id); // Clear out existing layout ImGui::DockBuilderAddNode(dockspace_id, ImGuiDockNodeFlags_DockSpace); // Add empty node - ImGui::DockBuilderSetNodeSize(dockspace_id, {1000, 1000}); + ImGui::DockBuilderSetNodeSize(dockspace_id, { 1000, 1000 }); ImGuiID dock_main_id = dockspace_id; // This variable will track the document node, however we are not using it here as we aren't docking anything into it. ImGuiID dock_left = ImGui::DockBuilderSplitNode(dock_main_id, ImGuiDir_Left, 0.5f, NULL, &dock_main_id); @@ -71,7 +70,7 @@ void inferno_preset_gui(InfernoApp *app) yolo::info("LAYOUT SET TO DEFAULT"); } -void inferno_move_input(InfernoApp *app) +void inferno_move_input(InfernoApp* app) { static GLFWcursor* cursor = glfwCreateStandardCursor(GLFW_HAND_CURSOR); glfwSetCursor(graphics::window_get_glfw_window(), cursor); @@ -80,19 +79,16 @@ void inferno_move_input(InfernoApp *app) // pan only get on hold static glm::dvec2 lastMousePos; static int firstClick = 0; - if (glfwGetMouseButton(graphics::window_get_glfw_window(), GLFW_MOUSE_BUTTON_1) == GLFW_PRESS) - { + if (glfwGetMouseButton(graphics::window_get_glfw_window(), GLFW_MOUSE_BUTTON_1) == GLFW_PRESS) { firstClick++; - if (firstClick == 1) - { + if (firstClick == 1) { glfwGetCursorPos(graphics::window_get_glfw_window(), &lastMousePos.x, &lastMousePos.y); } glm::dvec2 tempMousePos = { 0.0f, 0.0f }; glfwGetCursorPos(graphics::window_get_glfw_window(), &tempMousePos.x, &tempMousePos.y); app->Input->MouseDelta = lastMousePos - tempMousePos; lastMousePos = tempMousePos; - } else - { + } else { firstClick = 0; app->Input->MouseDelta = { 0.0f, 0.0f }; lastMousePos = { 0.0f, 0.0f }; @@ -113,14 +109,15 @@ void inferno_move_input(InfernoApp *app) app->Input->MovementDelta |= 0b00000100; } -void inferno_stop_move_input(InfernoApp *app) +void inferno_stop_move_input(InfernoApp* app) { app->Input->MovementDelta = 0x0; app->Input->MouseDelta = { 0.0f, 0.0f }; } -int inferno_run(InfernoApp *app) +int inferno_run(InfernoApp* app) { return 1; } +} // namespace inferno diff --git a/src/inferno.hpp b/src/inferno.hpp index 02bbc0b..1b49a03 100644 --- a/src/inferno.hpp +++ b/src/inferno.hpp @@ -26,4 +26,3 @@ void inferno_stop_move_input(InfernoApp* app); int inferno_run(InfernoApp* app); } - diff --git a/src/main.cpp b/src/main.cpp index 9ee8811..b082c79 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -8,4 +8,3 @@ int main(int argc, char** argv) auto* inferno = inferno::inferno_create(); return inferno::inferno_run(inferno); } - diff --git a/src/preview_renderer/renderer.cpp b/src/preview_renderer/renderer.cpp index 4fdacdc..73904b2 100644 --- a/src/preview_renderer/renderer.cpp +++ b/src/preview_renderer/renderer.cpp @@ -94,15 +94,15 @@ void RasterizeRenderer::draw() for (Mesh* m : mCurrentScene->getRenderables()) { - m->getMaterial()->getGlShader()->use(); - GLint uniTrans = glGetUniformLocation(m->getMaterial()->getGlShader()->getProgram(), "model"); - glUniformMatrix4fv(uniTrans, 1, GL_FALSE, glm::value_ptr(glm::mat4(1.0f))); + //m->getMaterial()->getGlShader()->use(); + //GLint uniTrans = glGetUniformLocation(m->getMaterial()->getGlShader()->getProgram(), "model"); + //glUniformMatrix4fv(uniTrans, 1, GL_FALSE, glm::value_ptr(glm::mat4(1.0f))); - GLint uniView = glGetUniformLocation(m->getMaterial()->getGlShader()->getProgram(), "view"); - glUniformMatrix4fv(uniView, 1, GL_FALSE, glm::value_ptr(mCurrentScene->getCamera()->getViewMatrix())); + //GLint uniView = glGetUniformLocation(m->getMaterial()->getGlShader()->getProgram(), "view"); + //glUniformMatrix4fv(uniView, 1, GL_FALSE, glm::value_ptr(mCurrentScene->getCamera()->getViewMatrix())); - GLint uniProj = glGetUniformLocation(m->getMaterial()->getGlShader()->getProgram(), "proj"); - glUniformMatrix4fv(uniProj, 1, GL_FALSE, glm::value_ptr(mCurrentScene->getCamera()->getProjectionMatrix())); + //GLint uniProj = glGetUniformLocation(m->getMaterial()->getGlShader()->getProgram(), "proj"); + //glUniformMatrix4fv(uniProj, 1, GL_FALSE, glm::value_ptr(mCurrentScene->getCamera()->getProjectionMatrix())); glBindVertexArray(m->getVAO()); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m->getEBO()); diff --git a/src/preview_renderer/shader.cpp b/src/preview_renderer/shader.cpp index c19160b..8565189 100644 --- a/src/preview_renderer/shader.cpp +++ b/src/preview_renderer/shader.cpp @@ -1,40 +1,44 @@ #include "shader.hpp" -#include #include +#include using namespace inferno::graphics; static std::unordered_map shader2Index = { - {GL_VERTEX_SHADER, 0}, - {GL_GEOMETRY_SHADER, 1}, - {GL_FRAGMENT_SHADER, 2} + { GL_VERTEX_SHADER, 0 }, + { GL_GEOMETRY_SHADER, 1 }, + { GL_FRAGMENT_SHADER, 2 } }; inline std::string trim(std::string& str) { - str.erase(str.find_last_not_of(' ')+1); //suffixing spaces - str.erase(0, str.find_first_not_of(' ')); //prefixing spaces + str.erase(str.find_last_not_of(' ') + 1); // suffixing spaces + str.erase(0, str.find_first_not_of(' ')); // prefixing spaces return str; } -std::string textFromFile(const std::filesystem::path& path) { +std::string textFromFile(const std::filesystem::path& path) +{ std::ifstream input(path); return std::string((std::istreambuf_iterator(input)), - std::istreambuf_iterator()); + std::istreambuf_iterator()); } -std::vector getKeys(std::unique_ptr& shader, std::string key) { - std::vector ret; - for (const auto& p : shader->PreprocessorDefinitions) if (p.key == key) ret.push_back(&p); - return ret; +std::vector getKeys(std::unique_ptr& shader, std::string key) +{ + std::vector ret; + for (const auto& p : shader->PreprocessorDefinitions) + if (p.key == key) + ret.push_back(&p); + return ret; } -bool checkShader(GLuint uid) { +bool checkShader(GLuint uid) +{ GLint isCompiled = 0; glGetShaderiv(uid, GL_COMPILE_STATUS, &isCompiled); - if(isCompiled == GL_FALSE) - { + if (isCompiled == GL_FALSE) { GLint maxLength = 0; glGetShaderiv(uid, GL_INFO_LOG_LENGTH, &maxLength); @@ -52,8 +56,8 @@ bool checkShader(GLuint uid) { return true; } - -std::unique_ptr shader_create() { +std::unique_ptr shader_create() +{ std::unique_ptr shader = std::make_unique(); shader->Program = 0; @@ -64,100 +68,114 @@ std::unique_ptr shader_create() { return shader; } -void shader_cleanup(std::unique_ptr& shader) { - for (int i = 0; i < 3; i++) { - if (shader->Shaders[i] == GL_NONE) continue; - glDeleteShader(shader->Shaders[i]); - } +void shader_cleanup(std::unique_ptr& shader) +{ + for (int i = 0; i < 3; i++) { + if (shader->Shaders[i] == GL_NONE) + continue; + glDeleteShader(shader->Shaders[i]); + } glDeleteProgram(shader->Program); } -void shader_load(std::unique_ptr& shader, std::filesystem::path path) { +void shader_load(std::unique_ptr& shader, std::filesystem::path path) +{ - assert(std::filesystem::exists(path)); + assert(std::filesystem::exists(path)); - std::string loadedShaderSource = textFromFile(path); + std::string loadedShaderSource = textFromFile(path); - for (int i = 0; i < loadedShaderSource.length(); i++) { - const char& c = loadedShaderSource[i]; - if (c == '#') { - ShaderPreprocessorDefinition def = { .start = i }; - int j; - for (j = ++i; loadedShaderSource[j] != ' '; j++) { - def.key += loadedShaderSource[j]; - } - for (j++; loadedShaderSource[j] != '\n'; j++) { - def.def += loadedShaderSource[j]; - } - def.end = j; i = j; // advance i - def.def = trim(def.def); - def.key = trim(def.key); - shader->PreprocessorDefinitions.push_back(def); - } - } + for (int i = 0; i < loadedShaderSource.length(); i++) { + const char& c = loadedShaderSource[i]; + if (c == '#') { + ShaderPreprocessorDefinition def = { .start = i }; + int j; + for (j = ++i; loadedShaderSource[j] != ' '; j++) { + def.key += loadedShaderSource[j]; + } + for (j++; loadedShaderSource[j] != '\n'; j++) { + def.def += loadedShaderSource[j]; + } + def.end = j; + i = j; // advance i + def.def = trim(def.def); + def.key = trim(def.key); + shader->PreprocessorDefinitions.push_back(def); + } + } - // now we have all of the key/value definitions - // we can extract the relavent ones, for example - // "type" - std::vector types = getKeys(shader, "type"); - int i = 0; - for (const ShaderPreprocessorDefinition* type : types) { - GLuint glType = GL_NONE; - if (type->def == "vertex") glType = GL_VERTEX_SHADER; - if (type->def == "geometry") glType = GL_GEOMETRY_SHADER; - if (type->def == "fragment") glType = GL_FRAGMENT_SHADER; + // now we have all of the key/value definitions + // we can extract the relavent ones, for example + // "type" + std::vector types = getKeys(shader, "type"); + int i = 0; + for (const ShaderPreprocessorDefinition* type : types) { + GLuint glType = GL_NONE; + if (type->def == "vertex") + glType = GL_VERTEX_SHADER; + if (type->def == "geometry") + glType = GL_GEOMETRY_SHADER; + if (type->def == "fragment") + glType = GL_FRAGMENT_SHADER; - assert(glType != GL_NONE); + assert(glType != GL_NONE); - shader->Shaders[shader2Index[glType]] = glCreateShader(glType); + shader->Shaders[shader2Index[glType]] = glCreateShader(glType); - const char* source = loadedShaderSource.c_str() + type->end; - int end = types.size() - 1 == i ? types.size(): types[i + 1]->start; - int length = end - type->end; + const char* source = loadedShaderSource.c_str() + type->end; + int end = types.size() - 1 == i ? types.size() : types[i + 1]->start; + int length = end - type->end; - glShaderSource(shader->Shaders[shader2Index[glType]], 1, &source, &length); - i++; - } + glShaderSource(shader->Shaders[shader2Index[glType]], 1, &source, &length); + i++; + } } -void shader_link(std::unique_ptr &shader) { - shader->Program = glCreateProgram(); +void shader_link(std::unique_ptr& shader) +{ + shader->Program = glCreateProgram(); - for (int i = 0; i < 3; i++) { - if (shader->Shaders[i] == GL_NONE) continue; + for (int i = 0; i < 3; i++) { + if (shader->Shaders[i] == GL_NONE) + continue; - glCompileShader(shader->Shaders[i]); - if (!checkShader(shader->Shaders[i])) continue; + glCompileShader(shader->Shaders[i]); + if (!checkShader(shader->Shaders[i])) + continue; - glAttachShader(shader->Program, shader->Shaders[i]); - } + glAttachShader(shader->Program, shader->Shaders[i]); + } - glLinkProgram(shader->Program); + glLinkProgram(shader->Program); } - -void shader_add_attribute(std::unique_ptr &shader, const std::string &attribute) { +void shader_add_attribute(std::unique_ptr& shader, const std::string& attribute) +{ shader->Attributes[attribute] = glGetAttribLocation(shader->Program, attribute.c_str()); } -void shader_add_uniform(std::unique_ptr &shader, const std::string &uniform) { +void shader_add_uniform(std::unique_ptr& shader, const std::string& uniform) +{ shader->Uniforms[uniform] = glGetUniformLocation(shader->Program, uniform.c_str()); } -GLuint shader_get_attribute(std::unique_ptr &shader, const std::string &attribute) { +GLuint shader_get_attribute(std::unique_ptr& shader, const std::string& attribute) +{ return shader->Attributes[attribute]; } -GLuint shader_get_uniform(std::unique_ptr &shader, const std::string &uniform) { +GLuint shader_get_uniform(std::unique_ptr& shader, const std::string& uniform) +{ return shader->Uniforms[uniform]; } -void shader_use(std::unique_ptr& shader) { - glUseProgram(shader->Program); +void shader_use(std::unique_ptr& shader) +{ + glUseProgram(shader->Program); } -void shader_unuse(std::unique_ptr& shader) { - glUseProgram(0); +void shader_unuse(std::unique_ptr& shader) +{ + glUseProgram(0); } - diff --git a/src/preview_renderer/shader.hpp b/src/preview_renderer/shader.hpp index 9d83457..766269a 100644 --- a/src/preview_renderer/shader.hpp +++ b/src/preview_renderer/shader.hpp @@ -2,11 +2,11 @@ #include "../graphics.hpp" -#include -#include -#include #include +#include +#include #include +#include namespace inferno::graphics { @@ -16,7 +16,6 @@ typedef struct ShaderPreprocessorDefinition { std::string def; } shaderpreprocessordefinition; - typedef struct Shader { GLuint Shaders[3]; GLuint Program; @@ -40,4 +39,3 @@ void shader_use(std::unique_ptr& shader); void shader_unuse(std::unique_ptr& shader); } - diff --git a/src/scene/material.cpp b/src/scene/material.cpp index 95918fc..bcdba1c 100644 --- a/src/scene/material.cpp +++ b/src/scene/material.cpp @@ -15,12 +15,12 @@ Material::~Material() } -void Material::setGlShader(Shader* shader) -{ - mGlShader = shader; -} +//void Material::setGlShader(Shader* shader) +//{ + //mGlShader = shader; +//} -Shader* Material::getGlShader() -{ - return mGlShader; -} +//Shader* Material::getGlShader() +//{ + //return mGlShader; +//} diff --git a/src/scene/material.hpp b/src/scene/material.hpp index 482a48e..05a0fff 100644 --- a/src/scene/material.hpp +++ b/src/scene/material.hpp @@ -6,7 +6,7 @@ namespace inferno { -class Shader; +//class Shader; class HitInfo; class Material { @@ -15,14 +15,14 @@ public: ~Material(); std::string getName(); - void setGlShader(Shader* shader); - Shader* getGlShader(); + //void setGlShader(Shader* shader); + //Shader* getGlShader(); glm::vec3 sample(HitInfo* hit); private: std::string mName; - Shader* mGlShader; + //Shader* mGlShader; }; } diff --git a/src/window.cpp b/src/window.cpp index a01100f..2be7262 100644 --- a/src/window.cpp +++ b/src/window.cpp @@ -1,9 +1,9 @@ -#include "window.hpp" +#include "window.hpp" #include "gui/style.hpp" #include "yolo/yolo.hpp" -using namespace inferno::graphics; +namespace inferno::graphics { static WINDOW_MODE WinMode = WINDOW_MODE::WIN_MODE_DEFAULT; static KeyCallback UserKeyCallback = nullptr; @@ -11,23 +11,26 @@ static int Width, Height; static const char* GlslVersion; static GLFWwindow* Window; -void glfwKeyCallback(GLFWwindow *window, int key, int scancode, - int action, int mods) { +void glfwKeyCallback(GLFWwindow* window, int key, int scancode, + int action, int mods) +{ if (UserKeyCallback != nullptr) { UserKeyCallback(key, scancode, action, mods); } } -void glfwErrorCallback(int error, const char *description) { +void glfwErrorCallback(int error, const char* description) +{ yolo::error("[GLFW {}] {}", error, description); } -void setupGLFW(std::string title) { +void setupGLFW(std::string title) +{ glfwSetErrorCallback(glfwErrorCallback); if (!glfwInit()) throw std::runtime_error("Failed to initialize GLFW"); - // Decide GL+GLSL versions + // Decide GL+GLSL versions #if defined(IMGUI_IMPL_OPENGL_ES2) // GL ES 2.0 + GLSL 100 glslVersion = "#version 100"; @@ -40,14 +43,14 @@ void setupGLFW(std::string title) { glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); // 3.2+ only - glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // Required on Mac + glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // Required on Mac #else // GL 4.5 + GLSL 450 GlslVersion = "#version 450"; glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 5); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); // 3.2+ only - glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // 3.0+ only + glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // 3.0+ only #endif // Create window with graphics context @@ -59,7 +62,8 @@ void setupGLFW(std::string title) { glfwSwapInterval(1); // Enable vsync } -void setupImGui() { +void setupImGui() +{ // Setup Dear ImGui context IMGUI_CHECKVERSION(); ImGui::CreateContext(); @@ -67,37 +71,38 @@ void setupImGui() { // Setup Dear ImGui style ImGui::StyleColorsDark(); - ImGuiIO &io = ImGui::GetIO(); + ImGuiIO& io = ImGui::GetIO(); (void)io; io.ConfigFlags |= ImGuiConfigFlags_DockingEnable; // Enable Docking - io.ConfigFlags |= - ImGuiConfigFlags_DpiEnableScaleFonts; // FIXME-DPI: THIS CURRENTLY DOESN'T - // WORK AS EXPECTED. DON'T USE IN - // USER APP! + io.ConfigFlags |= ImGuiConfigFlags_DpiEnableScaleFonts; // FIXME-DPI: THIS CURRENTLY DOESN'T + // WORK AS EXPECTED. DON'T USE IN + // USER APP! io.ConfigFlags |= ImGuiConfigFlags_DpiEnableScaleViewports; // FIXME-DPI // io.ConfigDockingWithShift // = true; - // Setup Platform/Renderer backends + // Setup Platform/Renderer backends ImGui_ImplGlfw_InitForOpenGL(Window, true); ImGui_ImplOpenGL3_Init(GlslVersion); inferno::SetupImGuiStyle2(); } -void shutdownImGui() { +void shutdownImGui() +{ ImGui_ImplOpenGL3_Shutdown(); ImGui_ImplGlfw_Shutdown(); ImGui::DestroyContext(); } -void shutdownGLFW() { +void shutdownGLFW() +{ glfwDestroyWindow(Window); glfwTerminate(); } - -void window_create(std::string title, int width, int height) { +void window_create(std::string title, int width, int height) +{ Width = width; Height = height; setupGLFW(title); @@ -105,16 +110,19 @@ void window_create(std::string title, int width, int height) { setupImGui(); } -void window_cleanup() { +void window_cleanup() +{ shutdownImGui(); shutdownGLFW(); } -void window_set_title(std::string title) { +void window_set_title(std::string title) +{ glfwSetWindowTitle(Window, title.c_str()); } -void window_set_size(int w, int h) { +void window_set_size(int w, int h) +{ Width = w; Height = h; glfwSetWindowSize(Window, Width, Height); @@ -126,7 +134,10 @@ glm::vec2 window_get_size() { return { Width, Height }; } void window_get_pos(int& x, int& y) { glfwGetWindowPos(Window, &x, &y); } -void window_set_mode(WINDOW_MODE mode) { +GLFWwindow* window_get_glfw_window() { return Window; } + +void window_set_mode(WINDOW_MODE mode) +{ WinMode = mode; if (mode == WINDOW_MODE::WIN_MODE_FPS) { glfwSetInputMode(Window, GLFW_CURSOR, GLFW_CURSOR_HIDDEN); @@ -137,7 +148,8 @@ void window_set_key_callback(KeyCallback callback) { UserKeyCallback = callback; KeyCallback window_get_key_callback() { return UserKeyCallback; } -bool window_new_frame() { +bool window_new_frame() +{ glfwPollEvents(); if (WinMode == WIN_MODE_FPS) { glfwSetInputMode(Window, GLFW_CURSOR, GLFW_CURSOR_HIDDEN); @@ -163,7 +175,8 @@ bool window_new_frame() { return true; } -void window_render() { +void window_render() +{ ImGui::End(); ImGui::Render(); auto io = ImGui::GetIO(); @@ -173,3 +186,4 @@ void window_render() { ImGui::UpdatePlatformWindows(); } +} diff --git a/src/window.hpp b/src/window.hpp index 9ccc1f7..3f9e7fd 100644 --- a/src/window.hpp +++ b/src/window.hpp @@ -2,8 +2,8 @@ #include -#include "singleton.hpp" #include "graphics.hpp" +#include "singleton.hpp" #define WINDOW_FLAGS ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoBringToFrontOnFocus | ImGuiWindowFlags_NoNavFocus | ImGuiWindowFlags_MenuBar | ImGuiWindowFlags_NoBackground | ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoCollapse @@ -12,8 +12,7 @@ namespace inferno::graphics { typedef void (*KeyCallback)(int key, int scan, int action, int mod); typedef void (*MouseCallback)(double x, double y); -enum WINDOW_MODE -{ +enum WINDOW_MODE { WIN_MODE_DEFAULT, WIN_MODE_FPS, }; @@ -38,4 +37,3 @@ bool window_new_frame(); void window_render(); } - From cc564e7fa8a77f4b6c8c6905f39bc2407e88c4e3 Mon Sep 17 00:00:00 2001 From: Ben Kyd Date: Tue, 25 Apr 2023 00:33:00 +0100 Subject: [PATCH 08/30] STRUCTURE PEOPLE STRUCTURE --- src/inferno.cpp | 78 +++++++++++++++++++++++++++++++++++++++++++++++ src/singleton.hpp | 21 ------------- 2 files changed, 78 insertions(+), 21 deletions(-) delete mode 100644 src/singleton.hpp diff --git a/src/inferno.cpp b/src/inferno.cpp index 1533c70..dec8014 100644 --- a/src/inferno.cpp +++ b/src/inferno.cpp @@ -117,6 +117,84 @@ void inferno_stop_move_input(InfernoApp* app) int inferno_run(InfernoApp* app) { + + while (true) { + if (!graphics::window_new_frame()) + break; + + // set the main window to the dockspace and then on the first launch set the preset + ImGuiID dockspace_id = ImGui::GetID("main"); + static ImGuiDockNodeFlags dockspace_flags = ImGuiDockNodeFlags_PassthruCentralNode; + if (ImGui::DockBuilderGetNode(dockspace_id) == NULL) { + inferno_preset_gui(app); + } + ImGui::DockSpace(dockspace_id, ImVec2(0.0f, 0.0f), dockspace_flags); + + // Menu Bar + static bool showPreview = true; + static bool showRenderSettings = true; + static bool showDemoWindow = false; + if (ImGui::BeginMenuBar()) { + if (ImGui::BeginMenu("Menu")) { + ImGui::EndMenu(); + } + if (ImGui::BeginMenu("View")) { + ImGui::Checkbox("Show Preview", &showPreview); + ImGui::SameLine(); + inferno_gui_help_marker("Show the preview window"); + ImGui::Checkbox("Show Settings", &showRenderSettings); + ImGui::SameLine(); + inferno_gui_help_marker("Show the Inferno HART settings window"); + ImGui::Checkbox("Show Demo", &showDemoWindow); + + ImGui::EndMenu(); + } + ImGui::EndMenuBar(); + } + + if (showPreview && ImGui::Begin("Preview", nullptr, ImGuiWindowFlags_NoScrollbar)) + { + if (ImGui::IsWindowHovered()) + { + inferno_move_input(app); + } else + { + inferno_stop_move_input(app); + } + if (glm::length(mouseDelta) > 0.0f) camera.mouseMoved(mouseDelta); + if (movementDelta != 0b00000000) camera.moveCamera(movementDelta); + + camera.setRasterViewport({ImGui::GetWindowSize().x, ImGui::GetWindowSize().y}); + mRasterRenderer->setTargetSize({ImGui::GetWindowSize().x, ImGui::GetWindowSize().y}); + mRasterRenderer->prepare(); + mRasterRenderer->draw(); + ImGui::Image((ImTextureID)mRasterRenderer->getRenderedTexture(), + { mRasterRenderer->getTargetSize().x, mRasterRenderer->getTargetSize().y }, + ImVec2(0,1), ImVec2(1,0)); + glBindFramebuffer(GL_FRAMEBUFFER, 0); + ImGui::End(); + } + + // clang-format off + GLenum err; + while((err = glGetError()) != GL_NO_ERROR) { + std::string error; + switch (err) { + case GL_INVALID_ENUM: error = "INVALID_ENUM"; break; + case GL_INVALID_VALUE: error = "INVALID_VALUE"; break; + case GL_INVALID_OPERATION: error = "INVALID_OPERATION"; break; + case GL_STACK_OVERFLOW: error = "STACK_OVERFLOW"; break; + case GL_STACK_UNDERFLOW: error = "STACK_UNDERFLOW"; break; + case GL_OUT_OF_MEMORY: error = "OUT_OF_MEMORY"; break; + case GL_INVALID_FRAMEBUFFER_OPERATION: error = "INVALID_FRAMEBUFFER_OPERATION"; break; + default: error = std::to_string((uint32_t)err); break; + } + yolo::error("[GL]: {} {}", err, error); + } + + graphics::window_render(); + } + return 1; } diff --git a/src/singleton.hpp b/src/singleton.hpp deleted file mode 100644 index 4f63e80..0000000 --- a/src/singleton.hpp +++ /dev/null @@ -1,21 +0,0 @@ -#pragma once - -namespace inferno::helpers { - -template -class Singleton -{ -public: - static T& GetInstance() - { - static T instance; - return instance; - } - - Singleton( Singleton const& ) = delete; - void operator=( Singleton const& ) = delete; -protected: - Singleton() = default; -}; - -} From 9ec4536fdf255529c826c38d4a609d4ee40127e2 Mon Sep 17 00:00:00 2001 From: Ben Kyd Date: Wed, 26 Apr 2023 15:27:53 +0100 Subject: [PATCH 09/30] commit to change dev machine --- src/inferno.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/inferno.cpp b/src/inferno.cpp index dec8014..43900ad 100644 --- a/src/inferno.cpp +++ b/src/inferno.cpp @@ -161,7 +161,7 @@ int inferno_run(InfernoApp* app) { inferno_stop_move_input(app); } - if (glm::length(mouseDelta) > 0.0f) camera.mouseMoved(mouseDelta); + if (glm::length(app->Input->MouseDelta) > 0.0f) camera.mouseMoved(mouseDelta); if (movementDelta != 0b00000000) camera.moveCamera(movementDelta); camera.setRasterViewport({ImGui::GetWindowSize().x, ImGui::GetWindowSize().y}); From 1d0ec3330cee03b77b97da2d898b4c33782968b1 Mon Sep 17 00:00:00 2001 From: Benjamin Kyd Date: Sat, 29 Apr 2023 22:42:19 +0100 Subject: [PATCH 10/30] camera refactor --- libhart/scene/camera.hpp | 75 ++++++------ src/inferno.cpp | 42 ++++--- src/inferno.hpp | 17 ++- src/main.cpp | 2 +- src/scene/camera.cpp | 247 ++++++++++++++++++++------------------- 5 files changed, 194 insertions(+), 189 deletions(-) diff --git a/libhart/scene/camera.hpp b/libhart/scene/camera.hpp index 77213a0..3da09fe 100644 --- a/libhart/scene/camera.hpp +++ b/libhart/scene/camera.hpp @@ -3,56 +3,51 @@ #include #include +#include #include -namespace inferno { +namespace inferno::graphics { -class Camera { -public: - Camera(); - Camera(int w, int h); +struct _CameraImpl; - void update(); - bool didUpdate(); - void newFrame(); +typedef struct Camera { + glm::mat4 ViewMatrix; + glm::mat4 ProjectionMatrix; + glm::mat4 LookMatrix; + float MouseSensitivity = 0.4f; + float CameraSpeed = 0.1f; + float Roll, Pitch, Yaw; + float FOV = 45.0f; + glm::vec3 Position = {}; + glm::vec3 LookDirection = {}; - glm::mat4 getViewMatrix(); - glm::mat4 getProjectionMatrix(); - glm::mat4 getCameraLook(); + std::unique_ptr<_CameraImpl> _impl; +} Camera; - void setRasterViewport(glm::vec2 viewport); +std::unique_ptr camera_create(); +void camera_cleanup(std::unique_ptr& camera); - // Keyboard - void moveCamera(uint8_t posDelta); - // Mouse Delta - void mouseMoved(glm::vec2 mouseDelta); +void camera_update(std::unique_ptr& camera); +void camera_did_update(std::unique_ptr& camera); +void camera_new_frame(std::unique_ptr& camera); - void setPosition(glm::vec3 position); - void setEulerLook(float roll, float pitch, float yaw); - void setLook(glm::vec3 lookDirection); +glm::mat4 camera_get_view(std::unique_ptr& camera); +glm::mat4 camera_get_projection(std::unique_ptr& camera); +glm::mat4 camera_get_look(std::unique_ptr& camera); -public: - void setRayViewport(glm::vec2 viewport); - glm::vec2 getRayViewport(); +void raster_set_viewport(std::unique_ptr& camera, glm::ivec2 viewport); +glm::ivec2 raster_get_viewport(std::unique_ptr& camera); -public: - // necessary evil - float MouseSensitivity = 0.4f; - float CameraSpeed = 0.1f; - float Roll, Pitch, Yaw; - float FOV = 45.0f; - glm::vec3 Position = {}; - glm::vec3 LookDirection = {}; +void ray_set_viewport(std::unique_ptr& camera, glm::ivec2 viewport); +glm::ivec2 ray_get_viewport(std::unique_ptr& camera); -private: - glm::vec2 mViewport = { 100.0f, 100.0f }; - glm::vec2 mRayViewport = { 200.0f, 200.0f }; - glm::mat4 mViewMatrix = {}; - glm::mat4 mProjMatrix = {}; - glm::mat4 mCameraLook = {}; - bool mDidUpdate; +void camera_move(std::unique_ptr& camera, uint8_t movement_delta); +void camera_mouse_move(std::unique_ptr& camera, glm::vec2 mouse_delta); - std::mutex _mCam; -}; +void camera_set_position(std::unique_ptr& camera, glm::vec3 position); +void camera_set_euler_look(std::unique_ptr& camera, float roll, + float pitch, float yaw); +void camera_set_look(std::unique_ptr& camera, + glm::vec3 look_direction); -} +} // namespace inferno::graphics diff --git a/src/inferno.cpp b/src/inferno.cpp index 43900ad..ec10ab1 100644 --- a/src/inferno.cpp +++ b/src/inferno.cpp @@ -25,20 +25,24 @@ namespace inferno { -InfernoApp* inferno_create() +std::unique_ptr inferno_create() { // MOTD yolo::info("INFERNO HART v" INFERNO_VERSION); - InfernoApp* app = new InfernoApp(); + std::unique_ptr app = std::make_unique(); + app->Input = std::make_unique(); // Create window graphics::window_create("Inferno v" INFERNO_VERSION, 1280, 720); + return app; } -void inferno_cleanup(InfernoApp* app) +void inferno_cleanup(std::unique_ptr& app) { + graphics::window_cleanup(); + app.reset(); } static void inferno_gui_help_marker(const char* desc) @@ -53,7 +57,7 @@ static void inferno_gui_help_marker(const char* desc) } } -void inferno_preset_gui(InfernoApp* app) +void inferno_preset_gui(std::unique_ptr& app) { ImGuiID dockspace_id = ImGui::GetID("main"); @@ -70,7 +74,7 @@ void inferno_preset_gui(InfernoApp* app) yolo::info("LAYOUT SET TO DEFAULT"); } -void inferno_move_input(InfernoApp* app) +void inferno_move_input(std::unique_ptr& app) { static GLFWcursor* cursor = glfwCreateStandardCursor(GLFW_HAND_CURSOR); glfwSetCursor(graphics::window_get_glfw_window(), cursor); @@ -109,13 +113,13 @@ void inferno_move_input(InfernoApp* app) app->Input->MovementDelta |= 0b00000100; } -void inferno_stop_move_input(InfernoApp* app) +void inferno_stop_move_input(std::unique_ptr& app) { app->Input->MovementDelta = 0x0; app->Input->MouseDelta = { 0.0f, 0.0f }; } -int inferno_run(InfernoApp* app) +int inferno_run(std::unique_ptr& app) { while (true) { @@ -152,25 +156,25 @@ int inferno_run(InfernoApp* app) ImGui::EndMenuBar(); } - if (showPreview && ImGui::Begin("Preview", nullptr, ImGuiWindowFlags_NoScrollbar)) - { - if (ImGui::IsWindowHovered()) - { + if (showPreview && ImGui::Begin("Preview", nullptr, ImGuiWindowFlags_NoScrollbar)) { + if (ImGui::IsWindowHovered()) { inferno_move_input(app); - } else - { + } else { inferno_stop_move_input(app); } - if (glm::length(app->Input->MouseDelta) > 0.0f) camera.mouseMoved(mouseDelta); - if (movementDelta != 0b00000000) camera.moveCamera(movementDelta); + if (glm::length(app->Input->MouseDelta) > 0.0f) + camera.mouseMoved(app->Input->MouseDelta); + if (app->Input->MovementDelta != 0b00000000) + camera.moveCamera(app->Input->MovementDelta); - camera.setRasterViewport({ImGui::GetWindowSize().x, ImGui::GetWindowSize().y}); - mRasterRenderer->setTargetSize({ImGui::GetWindowSize().x, ImGui::GetWindowSize().y}); + camera.setRasterViewport({ ImGui::GetWindowSize().x, ImGui::GetWindowSize().y }); + mRasterRenderer->setTargetSize({ ImGui::GetWindowSize().x, ImGui::GetWindowSize().y }); mRasterRenderer->prepare(); mRasterRenderer->draw(); - ImGui::Image((ImTextureID)mRasterRenderer->getRenderedTexture(), + + ImGui::Image((ImTextureID)mRasterRenderer->getRenderedTexture(),inderno { mRasterRenderer->getTargetSize().x, mRasterRenderer->getTargetSize().y }, - ImVec2(0,1), ImVec2(1,0)); + ImVec2(0, 1), ImVec2(1, 0)); glBindFramebuffer(GL_FRAMEBUFFER, 0); ImGui::End(); } diff --git a/src/inferno.hpp b/src/inferno.hpp index 1b49a03..df8b222 100644 --- a/src/inferno.hpp +++ b/src/inferno.hpp @@ -6,23 +6,20 @@ namespace inferno { -class Window; -class HHM; - typedef struct InfernoInput { glm::vec2 MouseDelta; uint8_t MovementDelta; } InfernoInput; typedef struct InfernoApp { - InfernoInput* Input; + std::unique_ptr Input; } InfernoApp; -InfernoApp* inferno_create(); -void inferno_cleanup(InfernoApp* app); -void inferno_preset_gui(InfernoApp* app); -void inferno_move_input(InfernoApp* app); -void inferno_stop_move_input(InfernoApp* app); -int inferno_run(InfernoApp* app); +std::unique_ptr inferno_create(); +void inferno_cleanup(std::unique_ptr& app); +void inferno_preset_gui(std::unique_ptr& app); +void inferno_move_input(std::unique_ptr& app); +void inferno_stop_move_input(std::unique_ptr& app); +int inferno_run(std::unique_ptr& app); } diff --git a/src/main.cpp b/src/main.cpp index b082c79..85bd1d1 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -5,6 +5,6 @@ int main(int argc, char** argv) { - auto* inferno = inferno::inferno_create(); + std::unique_ptr inferno = inferno::inferno_create(); return inferno::inferno_run(inferno); } diff --git a/src/scene/camera.cpp b/src/scene/camera.cpp index 2d37c2a..76def99 100644 --- a/src/scene/camera.cpp +++ b/src/scene/camera.cpp @@ -1,205 +1,214 @@ #include -using namespace inferno; +namespace inferno::graphics { -Camera::Camera() +typedef struct _CameraImpl { + glm::ivec2 Viewport = { 100, 100 }; + glm::ivec2 RayViewport = { 200, 200 }; + bool DidUpdate; + std::mutex CamMutex; +} _CameraImpl; + +std::unique_ptr camera_create() { - mProjMatrix = glm::perspective( glm::radians(FOV), 1.0f, 0.1f, 1000.0f ); + std::unique_ptr camera = std::make_unique(); + camera->_impl = std::make_unique<_CameraImpl>(); - Roll = 0.0f; - Pitch = 0.0f; - Yaw = 0.0f; + camera->ProjectionMatrix = glm::perspective( + glm::radians(camera->FOV), + 1.0f, + 0.1f, + 1000.0f); + camera->ViewMatrix = {}; - Position = {}; - LookDirection = {}; + camera->Roll = 0.0f; + camera->Pitch = 0.0f; + camera->Yaw = 0.0f; - mViewMatrix = {}; + camera->Position = {}; + camera->LookDirection = {}; - update(); + camera_update(camera); + return camera; } -Camera::Camera(int w, int h) +void camera_cleanup(std::unique_ptr& camera) { - mProjMatrix = glm::perspective(glm::radians(FOV), (float)w / (float)h, 0.1f, 1000.0f); - - Roll = 0.0f; - Pitch = 0.0f; - Yaw = 0.0f; - - Position = {}; - LookDirection = {}; - - mViewMatrix = {}; - - update(); + camera->_impl.reset(); + camera.reset(); } -void Camera::update() +void camera_update(std::unique_ptr& camera) { - glm::mat4 matRoll = glm::mat4(1.0f); - glm::mat4 matPitch = glm::mat4(1.0f); - glm::mat4 matYaw = glm::mat4(1.0f); + glm::mat4 matRoll = glm::mat4(1.0f); + glm::mat4 matPitch = glm::mat4(1.0f); + glm::mat4 matYaw = glm::mat4(1.0f); - matRoll = glm::rotate(matRoll, Roll, glm::vec3(0.0f, 0.0f, 1.0f)); - matPitch = glm::rotate(matPitch, Pitch, glm::vec3(1.0f, 0.0f, 0.0f)); - matYaw = glm::rotate(matYaw, Yaw, glm::vec3( 0.0f, 1.0f, 0.0f)); + matRoll = glm::rotate(matRoll, Roll, glm::vec3(0.0f, 0.0f, 1.0f)); + matPitch = glm::rotate(matPitch, Pitch, glm::vec3(1.0f, 0.0f, 0.0f)); + matYaw = glm::rotate(matYaw, Yaw, glm::vec3(0.0f, 1.0f, 0.0f)); - glm::mat4 rotate = matRoll * matPitch * matYaw; - mCameraLook = rotate; + glm::mat4 rotate = matRoll * matPitch * matYaw; + mCameraLook = rotate; - glm::mat4 translate = glm::mat4(1.0f); - translate = glm::translate(translate, -Position); + glm::mat4 translate = glm::mat4(1.0f); + translate = glm::translate(translate, -Position); - std::lock_guard lock(this->_mCam); + std::lock_guard lock(this->_mCam); - mViewMatrix = rotate * translate; - mProjMatrix = glm::perspective(glm::radians(FOV), mViewport.x / mViewport.y, 0.1f, 1000.0f); + mViewMatrix = rotate * translate; + mProjMatrix = glm::perspective(glm::radians(FOV), mViewport.x / mViewport.y, 0.1f, 1000.0f); - // Work out Look Vector - glm::mat4 inverseView = glm::inverse(mViewMatrix); + // Work out Look Vector + glm::mat4 inverseView = glm::inverse(mViewMatrix); - LookDirection.x = inverseView[2][0]; - LookDirection.y = inverseView[2][1]; - LookDirection.z = inverseView[2][2]; + LookDirection.x = inverseView[2][0]; + LookDirection.y = inverseView[2][1]; + LookDirection.z = inverseView[2][2]; - mDidUpdate = true; + mDidUpdate = true; } bool Camera::didUpdate() { - std::lock_guard lock(this->_mCam); - return mDidUpdate; + std::lock_guard lock(this->_mCam); + return mDidUpdate; } void Camera::newFrame() { - std::lock_guard lock(this->_mCam); - mDidUpdate = false; + std::lock_guard lock(this->_mCam); + mDidUpdate = false; } glm::mat4 Camera::getViewMatrix() { - std::lock_guard lock(this->_mCam); - return mViewMatrix; + std::lock_guard lock(this->_mCam); + return mViewMatrix; } glm::mat4 Camera::getProjectionMatrix() { - std::lock_guard lock(this->_mCam); - return mProjMatrix; + std::lock_guard lock(this->_mCam); + return mProjMatrix; } glm::mat4 Camera::getCameraLook() { - std::lock_guard lock(this->_mCam); - return mCameraLook; + std::lock_guard lock(this->_mCam); + return mCameraLook; } void Camera::setRasterViewport(glm::vec2 viewport) { - std::lock_guard lock(this->_mCam); - mViewport = viewport; - mProjMatrix = glm::perspective(glm::radians(FOV), (float)viewport.x / (float)viewport.y, 0.1f, 1000.0f); + std::lock_guard lock(this->_mCam); + mViewport = viewport; + mProjMatrix = glm::perspective(glm::radians(FOV), (float)viewport.x / (float)viewport.y, 0.1f, 1000.0f); } void Camera::moveCamera(uint8_t posDelta) { - if (posDelta == 0) return; + if (posDelta == 0) + return; - // Rotate by camera direction - glm::vec3 delta(0.0f); - - glm::mat2 rotate { - cos(Yaw), -sin(Yaw), - sin(Yaw), cos(Yaw) - }; + // Rotate by camera direction + glm::vec3 delta(0.0f); - glm::vec2 f(0.0, 1.0); - f = f * rotate; + glm::mat2 rotate { + cos(Yaw), -sin(Yaw), + sin(Yaw), cos(Yaw) + }; - if (posDelta & 0x80) { - delta.z -= f.y; - delta.x -= f.x; - } - if (posDelta & 0x20) { - delta.z += f.y; - delta.x += f.x; - } - if (posDelta & 0x40) { - delta.z += f.x; - delta.x += -f.y; - } - if (posDelta & 0x10) { - delta.z -= f.x; - delta.x -= -f.y; - } - if (posDelta & 0x8) { - delta.y += 1; - } - if (posDelta & 0x4) { - delta.y -= 1; - } + glm::vec2 f(0.0, 1.0); + f = f * rotate; - // get current view matrix - glm::mat4 mat = getViewMatrix(); - glm::vec3 forward(mat[0][2], mat[1][2], mat[2][2]); - glm::vec3 strafe(mat[0][0], mat[1][0], mat[2][0]); + if (posDelta & 0x80) { + delta.z -= f.y; + delta.x -= f.x; + } + if (posDelta & 0x20) { + delta.z += f.y; + delta.x += f.x; + } + if (posDelta & 0x40) { + delta.z += f.x; + delta.x += -f.y; + } + if (posDelta & 0x10) { + delta.z -= f.x; + delta.x -= -f.y; + } + if (posDelta & 0x8) { + delta.y += 1; + } + if (posDelta & 0x4) { + delta.y -= 1; + } - // forward vector must be negative to look forward. - // read :http://in2gpu.com/2015/05/17/view-matrix/ - Position += delta * CameraSpeed; + // get current view matrix + glm::mat4 mat = getViewMatrix(); + glm::vec3 forward(mat[0][2], mat[1][2], mat[2][2]); + glm::vec3 strafe(mat[0][0], mat[1][0], mat[2][0]); - // update the view matrix - update(); + // forward vector must be negative to look forward. + // read :http://in2gpu.com/2015/05/17/view-matrix/ + Position += delta * CameraSpeed; + + // update the view matrix + update(); } void Camera::mouseMoved(glm::vec2 mouseDelta) { - if (glm::length(mouseDelta) == 0) return; - // note that yaw and pitch must be converted to radians. - // this is done in update() by glm::rotate - Yaw += MouseSensitivity * (mouseDelta.x / 100); - Pitch += MouseSensitivity * (mouseDelta.y / 100); - Pitch = glm::clamp(Pitch, -M_PI / 2, M_PI / 2); + if (glm::length(mouseDelta) == 0) + return; + // note that yaw and pitch must be converted to radians. + // this is done in update() by glm::rotate + Yaw += MouseSensitivity * (mouseDelta.x / 100); + Pitch += MouseSensitivity * (mouseDelta.y / 100); + Pitch = glm::clamp(Pitch, -M_PI / 2, M_PI / 2); - update(); + update(); } void Camera::setPosition(glm::vec3 position) { - Position = position; + Position = position; - update(); + update(); } void Camera::setEulerLook(float roll, float pitch, float yaw) { - Roll = roll; Pitch = pitch; Yaw = yaw; - LookDirection.x = cos(Yaw) * cos(Pitch); - LookDirection.y = sin(Yaw) * cos(Pitch); - LookDirection.z = sin(Pitch); + Roll = roll; + Pitch = pitch; + Yaw = yaw; + LookDirection.x = cos(Yaw) * cos(Pitch); + LookDirection.y = sin(Yaw) * cos(Pitch); + LookDirection.z = sin(Pitch); - update(); + update(); } void Camera::setLook(glm::vec3 lookDirection) { - LookDirection = lookDirection; - Pitch = asin(-lookDirection.y); - Yaw = atan2(lookDirection.x, lookDirection.z); + LookDirection = lookDirection; + Pitch = asin(-lookDirection.y); + Yaw = atan2(lookDirection.x, lookDirection.z); - update(); + update(); } void Camera::setRayViewport(glm::vec2 viewport) { - std::lock_guard lock(this->_mCam); - mRayViewport = viewport; + std::lock_guard lock(this->_mCam); + mRayViewport = viewport; } glm::vec2 Camera::getRayViewport() { - std::lock_guard lock(this->_mCam); - return mRayViewport; + std::lock_guard lock(this->_mCam); + return mRayViewport; } +} From 2f506b12248aa97439c85f528c715972fe255f4c Mon Sep 17 00:00:00 2001 From: Benjamin Kyd Date: Thu, 4 May 2023 15:49:24 +0100 Subject: [PATCH 11/30] camera refactor completed --- libhart/scene/camera.hpp | 13 ++- src/scene/camera.cpp | 175 +++++++++++++++++++++------------------ src/window.cpp | 4 +- 3 files changed, 108 insertions(+), 84 deletions(-) diff --git a/libhart/scene/camera.hpp b/libhart/scene/camera.hpp index 3da09fe..1a67c78 100644 --- a/libhart/scene/camera.hpp +++ b/libhart/scene/camera.hpp @@ -10,14 +10,23 @@ namespace inferno::graphics { struct _CameraImpl; +typedef struct Viewports { + glm::ivec2 Raster; + glm::ivec2 Ray; +} Viewports; + typedef struct Camera { glm::mat4 ViewMatrix; glm::mat4 ProjectionMatrix; glm::mat4 LookMatrix; + + std::shared_ptr Viewports; + float MouseSensitivity = 0.4f; - float CameraSpeed = 0.1f; + float Speed = 0.1f; float Roll, Pitch, Yaw; float FOV = 45.0f; + glm::vec3 Position = {}; glm::vec3 LookDirection = {}; @@ -28,7 +37,7 @@ std::unique_ptr camera_create(); void camera_cleanup(std::unique_ptr& camera); void camera_update(std::unique_ptr& camera); -void camera_did_update(std::unique_ptr& camera); +bool camera_did_update(std::unique_ptr& camera); void camera_new_frame(std::unique_ptr& camera); glm::mat4 camera_get_view(std::unique_ptr& camera); diff --git a/src/scene/camera.cpp b/src/scene/camera.cpp index 76def99..bdd15d3 100644 --- a/src/scene/camera.cpp +++ b/src/scene/camera.cpp @@ -3,8 +3,7 @@ namespace inferno::graphics { typedef struct _CameraImpl { - glm::ivec2 Viewport = { 100, 100 }; - glm::ivec2 RayViewport = { 200, 200 }; + bool DidUpdate; std::mutex CamMutex; } _CameraImpl; @@ -13,6 +12,9 @@ std::unique_ptr camera_create() { std::unique_ptr camera = std::make_unique(); camera->_impl = std::make_unique<_CameraImpl>(); + camera->Viewports = std::make_shared(); + camera->Viewports->Raster = glm::ivec2(800, 600); + camera->Viewports->Ray = glm::ivec2(800, 600); camera->ProjectionMatrix = glm::perspective( glm::radians(camera->FOV), @@ -44,71 +46,97 @@ void camera_update(std::unique_ptr& camera) glm::mat4 matPitch = glm::mat4(1.0f); glm::mat4 matYaw = glm::mat4(1.0f); - matRoll = glm::rotate(matRoll, Roll, glm::vec3(0.0f, 0.0f, 1.0f)); - matPitch = glm::rotate(matPitch, Pitch, glm::vec3(1.0f, 0.0f, 0.0f)); - matYaw = glm::rotate(matYaw, Yaw, glm::vec3(0.0f, 1.0f, 0.0f)); + matRoll = glm::rotate(matRoll, camera->Roll, glm::vec3(0.0f, 0.0f, 1.0f)); + matPitch = glm::rotate(matPitch, camera->Pitch, glm::vec3(1.0f, 0.0f, 0.0f)); + matYaw = glm::rotate(matYaw, camera->Yaw, glm::vec3(0.0f, 1.0f, 0.0f)); glm::mat4 rotate = matRoll * matPitch * matYaw; - mCameraLook = rotate; + camera->LookMatrix = rotate; glm::mat4 translate = glm::mat4(1.0f); - translate = glm::translate(translate, -Position); + translate = glm::translate(translate, -camera->Position); - std::lock_guard lock(this->_mCam); + std::lock_guard lock(camera->_impl->CamMutex); - mViewMatrix = rotate * translate; - mProjMatrix = glm::perspective(glm::radians(FOV), mViewport.x / mViewport.y, 0.1f, 1000.0f); + camera->ViewMatrix = rotate * translate; + camera->ProjectionMatrix = glm::perspective( + glm::radians(camera->FOV), + static_cast(camera->Viewports->Raster.x) / static_cast(camera->Viewports->Raster.y), + 0.1f, + 1000.0f); // Work out Look Vector - glm::mat4 inverseView = glm::inverse(mViewMatrix); + glm::mat4 inverseView = glm::inverse(camera->ViewMatrix); - LookDirection.x = inverseView[2][0]; - LookDirection.y = inverseView[2][1]; - LookDirection.z = inverseView[2][2]; + camera->LookDirection.x = inverseView[2][0]; + camera->LookDirection.y = inverseView[2][1]; + camera->LookDirection.z = inverseView[2][2]; - mDidUpdate = true; + camera->_impl->DidUpdate = true; } -bool Camera::didUpdate() +bool camera_did_update(std::unique_ptr& camera) { - std::lock_guard lock(this->_mCam); - return mDidUpdate; + std::lock_guard lock(camera->_impl->CamMutex); + return camera->_impl->DidUpdate; } -void Camera::newFrame() +void camera_new_frame(std::unique_ptr& camera) { - std::lock_guard lock(this->_mCam); - mDidUpdate = false; + std::lock_guard lock(camera->_impl->CamMutex); + camera->_impl->DidUpdate = false; } -glm::mat4 Camera::getViewMatrix() +glm::mat4 camera_get_view(std::unique_ptr& camera) { - std::lock_guard lock(this->_mCam); - return mViewMatrix; + std::lock_guard lock(camera->_impl->CamMutex); + return camera->ViewMatrix; } -glm::mat4 Camera::getProjectionMatrix() +glm::mat4 camera_get_projection(std::unique_ptr& camera) { - std::lock_guard lock(this->_mCam); - return mProjMatrix; + std::lock_guard lock(camera->_impl->CamMutex); + return camera->ProjectionMatrix; } -glm::mat4 Camera::getCameraLook() +glm::mat4 camera_get_look(std::unique_ptr& camera) { - std::lock_guard lock(this->_mCam); - return mCameraLook; + std::lock_guard lock(camera->_impl->CamMutex); + return camera->LookMatrix; } -void Camera::setRasterViewport(glm::vec2 viewport) +void raster_set_viewport(std::unique_ptr& camera, glm::ivec2 viewport) { - std::lock_guard lock(this->_mCam); - mViewport = viewport; - mProjMatrix = glm::perspective(glm::radians(FOV), (float)viewport.x / (float)viewport.y, 0.1f, 1000.0f); + std::lock_guard lock(camera->_impl->CamMutex); + camera->Viewports->Raster = viewport; + camera->ProjectionMatrix = glm::perspective( + glm::radians(camera->FOV), + static_cast(viewport.x) / static_cast(viewport.y), + 0.1f, + 1000.0f); } -void Camera::moveCamera(uint8_t posDelta) +glm::ivec2 raster_get_viewport(std::unique_ptr& camera) { - if (posDelta == 0) + std::lock_guard lock(camera->_impl->CamMutex); + return camera->Viewports->Raster; +} + +void ray_set_viewport(std::unique_ptr& camera, glm::ivec2 viewport) +{ + std::lock_guard lock(camera->_impl->CamMutex); + camera->Viewports->Ray = viewport; +} + +glm::ivec2 ray_get_viewport(std::unique_ptr& camera) +{ + std::lock_guard lock(camera->_impl->CamMutex); + return camera->Viewports->Ray; +} + +void camera_move(std::unique_ptr& camera, uint8_t movement_delta) +{ + if (movement_delta == 0) return; // Rotate by camera direction @@ -122,93 +150,80 @@ void Camera::moveCamera(uint8_t posDelta) glm::vec2 f(0.0, 1.0); f = f * rotate; - if (posDelta & 0x80) { + if (movement_delta & 0x80) { delta.z -= f.y; delta.x -= f.x; } - if (posDelta & 0x20) { + if (movement_delta & 0x20) { delta.z += f.y; delta.x += f.x; } - if (posDelta & 0x40) { + if (movement_delta & 0x40) { delta.z += f.x; delta.x += -f.y; } - if (posDelta & 0x10) { + if (movement_delta & 0x10) { delta.z -= f.x; delta.x -= -f.y; } - if (posDelta & 0x8) { + if (movement_delta & 0x8) { delta.y += 1; } - if (posDelta & 0x4) { + if (movement_delta & 0x4) { delta.y -= 1; } // get current view matrix - glm::mat4 mat = getViewMatrix(); + glm::mat4 mat = camera_get_view(camera); glm::vec3 forward(mat[0][2], mat[1][2], mat[2][2]); glm::vec3 strafe(mat[0][0], mat[1][0], mat[2][0]); // forward vector must be negative to look forward. // read :http://in2gpu.com/2015/05/17/view-matrix/ - Position += delta * CameraSpeed; + camera->Position += delta * camera->Speed; // update the view matrix - update(); + camera_update(camera); } -void Camera::mouseMoved(glm::vec2 mouseDelta) +void camera_mouse_move(std::unique_ptr &camera, glm::vec2 mouse_delta) { - if (glm::length(mouseDelta) == 0) + if (glm::length(mouse_delta) == 0) return; // note that yaw and pitch must be converted to radians. // this is done in update() by glm::rotate - Yaw += MouseSensitivity * (mouseDelta.x / 100); - Pitch += MouseSensitivity * (mouseDelta.y / 100); - Pitch = glm::clamp(Pitch, -M_PI / 2, M_PI / 2); + camera->Yaw += camera->MouseSensitivity * (mouse_delta.x / 100); + camera->Pitch += camera->MouseSensitivity * (mouse_delta.y / 100); + camera->Pitch = glm::clamp(camera->Pitch, -M_PI / 2, M_PI / 2); - update(); + camera_update(camera); } -void Camera::setPosition(glm::vec3 position) +void camera_set_position(std::unique_ptr& camera, glm::vec3 position) { - Position = position; - - update(); + camera->Position = position; + camera_update(camera); } -void Camera::setEulerLook(float roll, float pitch, float yaw) +void camera_set_euler_look(std::unique_ptr &camera, float roll, float pitch, float yaw) { - Roll = roll; - Pitch = pitch; - Yaw = yaw; - LookDirection.x = cos(Yaw) * cos(Pitch); - LookDirection.y = sin(Yaw) * cos(Pitch); - LookDirection.z = sin(Pitch); + camera->Roll = roll; + camera->Pitch = pitch; + camera->Yaw = yaw; + camera->LookDirection.x = cos(camera->Yaw) * cos(camera->Pitch); + camera->LookDirection.y = sin(camera->Yaw) * cos(camera->Pitch); + camera->LookDirection.z = sin(camera->Pitch); - update(); + camera_update(camera); } -void Camera::setLook(glm::vec3 lookDirection) +void camera_set_look(std::unique_ptr &camera, glm::vec3 look_direction) { - LookDirection = lookDirection; - Pitch = asin(-lookDirection.y); - Yaw = atan2(lookDirection.x, lookDirection.z); + camera->LookDirection = look_direction; + camera->Pitch = asin(-look_direction.y); + camera->Yaw = atan2(look_direction.x, look_direction.z); - update(); -} - -void Camera::setRayViewport(glm::vec2 viewport) -{ - std::lock_guard lock(this->_mCam); - mRayViewport = viewport; -} - -glm::vec2 Camera::getRayViewport() -{ - std::lock_guard lock(this->_mCam); - return mRayViewport; + camera_update(camera); } } diff --git a/src/window.cpp b/src/window.cpp index 2be7262..41758e5 100644 --- a/src/window.cpp +++ b/src/window.cpp @@ -33,13 +33,13 @@ void setupGLFW(std::string title) // Decide GL+GLSL versions #if defined(IMGUI_IMPL_OPENGL_ES2) // GL ES 2.0 + GLSL 100 - glslVersion = "#version 100"; + GlslVersion = "#version 100"; glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0); glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_ES_API); #elif defined(__APPLE__) // GL 3.2 + GLSL 150 - glslVersion = "#version 150"; + GlslVersion = "#version 150"; glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); // 3.2+ only From 2f022e936143878f785bd3448857c41fa25245de Mon Sep 17 00:00:00 2001 From: Benjamin Kyd Date: Thu, 4 May 2023 16:14:58 +0100 Subject: [PATCH 12/30] use those epic edits --- src/inferno.cpp | 11 +++++------ src/inferno.hpp | 5 +++++ src/scene/camera.cpp | 10 +++++----- src/window.hpp | 1 - 4 files changed, 15 insertions(+), 12 deletions(-) diff --git a/src/inferno.cpp b/src/inferno.cpp index ec10ab1..a46154a 100644 --- a/src/inferno.cpp +++ b/src/inferno.cpp @@ -11,7 +11,7 @@ // #include "preview_renderer/shader.hpp" // #include "renderer/dispatcher.hpp" // #include "renderer/renderer.hpp" -// #include "scene/camera.hpp" +#include "scene/camera.hpp" // #include "scene/scene.hpp" // #include "scene/material.hpp" // #include "scene/mesh.hpp" @@ -163,17 +163,16 @@ int inferno_run(std::unique_ptr& app) inferno_stop_move_input(app); } if (glm::length(app->Input->MouseDelta) > 0.0f) - camera.mouseMoved(app->Input->MouseDelta); + graphics::camera_mouse_move(app->Camera, app->Input->MouseDelta); if (app->Input->MovementDelta != 0b00000000) - camera.moveCamera(app->Input->MovementDelta); + graphics::camera_move(app->Camera, app->Input->MovementDelta); - camera.setRasterViewport({ ImGui::GetWindowSize().x, ImGui::GetWindowSize().y }); + graphics::raster_set_viewport({ ImGui::GetWindowSize().x, ImGui::GetWindowSize().y }); mRasterRenderer->setTargetSize({ ImGui::GetWindowSize().x, ImGui::GetWindowSize().y }); mRasterRenderer->prepare(); mRasterRenderer->draw(); - ImGui::Image((ImTextureID)mRasterRenderer->getRenderedTexture(),inderno - { mRasterRenderer->getTargetSize().x, mRasterRenderer->getTargetSize().y }, + ImGui::Image((ImTextureID)mRasterRenderer->getRenderedTexture(), inderno { mRasterRenderer->getTargetSize().x, mRasterRenderer->getTargetSize().y }, ImVec2(0, 1), ImVec2(1, 0)); glBindFramebuffer(GL_FRAMEBUFFER, 0); ImGui::End(); diff --git a/src/inferno.hpp b/src/inferno.hpp index df8b222..99ad928 100644 --- a/src/inferno.hpp +++ b/src/inferno.hpp @@ -6,6 +6,10 @@ namespace inferno { +namespace graphics { + struct Camera; +} + typedef struct InfernoInput { glm::vec2 MouseDelta; uint8_t MovementDelta; @@ -13,6 +17,7 @@ typedef struct InfernoInput { typedef struct InfernoApp { std::unique_ptr Input; + std::unique_ptr Camera; } InfernoApp; std::unique_ptr inferno_create(); diff --git a/src/scene/camera.cpp b/src/scene/camera.cpp index bdd15d3..0958452 100644 --- a/src/scene/camera.cpp +++ b/src/scene/camera.cpp @@ -143,8 +143,8 @@ void camera_move(std::unique_ptr& camera, uint8_t movement_delta) glm::vec3 delta(0.0f); glm::mat2 rotate { - cos(Yaw), -sin(Yaw), - sin(Yaw), cos(Yaw) + cos(camera->Yaw), -sin(camera->Yaw), + sin(camera->Yaw), cos(camera->Yaw) }; glm::vec2 f(0.0, 1.0); @@ -186,7 +186,7 @@ void camera_move(std::unique_ptr& camera, uint8_t movement_delta) camera_update(camera); } -void camera_mouse_move(std::unique_ptr &camera, glm::vec2 mouse_delta) +void camera_mouse_move(std::unique_ptr& camera, glm::vec2 mouse_delta) { if (glm::length(mouse_delta) == 0) return; @@ -205,7 +205,7 @@ void camera_set_position(std::unique_ptr& camera, glm::vec3 position) camera_update(camera); } -void camera_set_euler_look(std::unique_ptr &camera, float roll, float pitch, float yaw) +void camera_set_euler_look(std::unique_ptr& camera, float roll, float pitch, float yaw) { camera->Roll = roll; camera->Pitch = pitch; @@ -217,7 +217,7 @@ void camera_set_euler_look(std::unique_ptr &camera, float roll, float pi camera_update(camera); } -void camera_set_look(std::unique_ptr &camera, glm::vec3 look_direction) +void camera_set_look(std::unique_ptr& camera, glm::vec3 look_direction) { camera->LookDirection = look_direction; camera->Pitch = asin(-look_direction.y); diff --git a/src/window.hpp b/src/window.hpp index 3f9e7fd..aee839f 100644 --- a/src/window.hpp +++ b/src/window.hpp @@ -3,7 +3,6 @@ #include #include "graphics.hpp" -#include "singleton.hpp" #define WINDOW_FLAGS ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoBringToFrontOnFocus | ImGuiWindowFlags_NoNavFocus | ImGuiWindowFlags_MenuBar | ImGuiWindowFlags_NoBackground | ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoCollapse From 97476996e8a2c069ae6b6c255d92c436c8a3af5f Mon Sep 17 00:00:00 2001 From: Benjamin Kyd Date: Wed, 17 May 2023 12:40:50 +0100 Subject: [PATCH 13/30] based wtf --- libhart/scene/camera.hpp | 4 +- src/hart_directory.hpp | 2 +- src/inferno.cpp | 2 +- src/preview_renderer/renderer.cpp | 122 ++++++++++++++++++------------ src/preview_renderer/renderer.hpp | 55 +++++++------- src/scene/camera.cpp | 16 ++-- src/scene/scene.hpp | 7 +- 7 files changed, 117 insertions(+), 91 deletions(-) diff --git a/libhart/scene/camera.hpp b/libhart/scene/camera.hpp index 1a67c78..2557b24 100644 --- a/libhart/scene/camera.hpp +++ b/libhart/scene/camera.hpp @@ -10,7 +10,7 @@ namespace inferno::graphics { struct _CameraImpl; -typedef struct Viewports { +typedef struct Viewport { glm::ivec2 Raster; glm::ivec2 Ray; } Viewports; @@ -20,7 +20,7 @@ typedef struct Camera { glm::mat4 ProjectionMatrix; glm::mat4 LookMatrix; - std::shared_ptr Viewports; + std::shared_ptr Views; float MouseSensitivity = 0.4f; float Speed = 0.1f; diff --git a/src/hart_directory.hpp b/src/hart_directory.hpp index 6ddf462..a837582 100644 --- a/src/hart_directory.hpp +++ b/src/hart_directory.hpp @@ -53,7 +53,7 @@ public: void setActive(std::string moduleName); void setActiveIndex(int index); - + HARTModule* getActiveModule(); std::string getActive(); int getActiveIndex(); diff --git a/src/inferno.cpp b/src/inferno.cpp index a46154a..7ce559a 100644 --- a/src/inferno.cpp +++ b/src/inferno.cpp @@ -1,4 +1,4 @@ -#include "inferno.hpp" +#include "infergo.hpp" #include // #include "gui/layout.hpp" diff --git a/src/preview_renderer/renderer.cpp b/src/preview_renderer/renderer.cpp index 73904b2..17574ef 100644 --- a/src/preview_renderer/renderer.cpp +++ b/src/preview_renderer/renderer.cpp @@ -3,112 +3,134 @@ #include "shader.hpp" #include -#include #include #include +#include #include -using namespace inferno; +namespace inferno::graphics { -RasterizeRenderer::RasterizeRenderer() +std::unique_ptr preview_create() { - glGenFramebuffers(1, &mRenderTarget); - glBindFramebuffer(GL_FRAMEBUFFER, mRenderTarget); + std::unique_ptr renderer = std::make_unique(); + glGenFramebuffers(1, &renderer->RenderTarget); + glBindFramebuffer(GL_FRAMEBUFFER, renderer->RenderTarget); - glGenTextures(1, &mRenderTargetTexture); - glBindTexture(GL_TEXTURE_2D, mRenderTargetTexture); + glGenTextures(1, &renderer->RenderTargetTexture); + glBindTexture(GL_TEXTURE_2D, renderer->RenderTargetTexture); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 800, 600, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); - - glGenTextures(1, &mRenderTargetDepthTexture ); - glBindTexture(GL_TEXTURE_2D, mRenderTargetDepthTexture ); - glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH24_STENCIL8, 800, 600, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL); + glGenTextures(1, &renderer->RenderTargetDepthTexture); + glBindTexture(GL_TEXTURE_2D, renderer->RenderTargetDepthTexture); + glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH24_STENCIL8, 800, 600, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); - // Attach the texture to the framebuffer. - glFramebufferTexture2D( GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, mRenderTargetDepthTexture, 0 ); - glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, mRenderTargetTexture, 0); + // Attach the texture to the framebuffer. + glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, renderer->RenderTargetDepthTexture, 0); + glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, renderer->RenderTargetTexture, 0); assert(glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE); - glBindFramebuffer(GL_FRAMEBUFFER, 0); + glBindFramebuffer(GL_FRAMEBUFFER, 0); + + return renderer; } -RasterizeRenderer::~RasterizeRenderer() +void preview_cleanup(std::unique_ptr& renderer) { - } -void RasterizeRenderer::setScene(Scene* scene) +void preview_set_scene(std::unique_ptr& renderer, std::shared_ptr scene) { - mCurrentScene = scene; + renderer->CurrentScene = scene; } -void RasterizeRenderer::setTargetSize(glm::ivec2 size) +void preview_set_viewport(std::unique_ptr& renderer, std::shared_ptr viewport) { - glBindFramebuffer(GL_FRAMEBUFFER, mRenderTarget); + renderer->RenderTargetSize = viewport; + glBindFramebuffer(GL_FRAMEBUFFER, renderer->RenderTarget); - glBindTexture(GL_TEXTURE_2D, mRenderTargetTexture); - glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, size.x, size.y, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL); + glBindTexture(GL_TEXTURE_2D, renderer->RenderTargetTexture); + glTexImage2D( + GL_TEXTURE_2D, + 0, + GL_RGB, + viewport->Raster.x, + viewport->Raster.y, + 0, + GL_RGB, + GL_UNSIGNED_BYTE, + NULL); - glBindTexture(GL_TEXTURE_2D, mRenderTargetDepthTexture); - glTexImage2D( GL_TEXTURE_2D, 0, GL_DEPTH24_STENCIL8, size.x, size.y, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL ); + glBindTexture(GL_TEXTURE_2D, renderer->RenderTargetDepthTexture); + glTexImage2D(GL_TEXTURE_2D, + 0, + GL_DEPTH24_STENCIL8, + viewport->Raster.x, + viewport->Raster.y, + 0, + GL_DEPTH_COMPONENT, + GL_FLOAT, + NULL); glBindFramebuffer(GL_FRAMEBUFFER, 0); - mRenderTargetSize = size; } -GLuint RasterizeRenderer::getRenderedTexture() +const glm::ivec2& preview_get_viewport(std::unique_ptr& renderer) { - glBindFramebuffer(GL_FRAMEBUFFER, mRenderTarget); - return mRenderTargetTexture; + return renderer->RenderTargetSize->Raster; } -glm::ivec2 RasterizeRenderer::getTargetSize() +GLuint preview_get_rendered_texture(std::unique_ptr& renderer) { - return mRenderTargetSize; + glBindFramebuffer(GL_FRAMEBUFFER, renderer->RenderTarget); + return renderer->RenderTargetTexture; } -void RasterizeRenderer::prepare() +void preview_prepare(std::unique_ptr& renderer) { - glBindFramebuffer(GL_FRAMEBUFFER, mRenderTarget); + glBindFramebuffer(GL_FRAMEBUFFER, renderer->RenderTarget); glClearColor(0.1, 0.1, 0.1, 1.0); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glBindFramebuffer(GL_FRAMEBUFFER, 0); } -void RasterizeRenderer::draw() +void preview_draw(std::unique_ptr& renderer) { - glBindFramebuffer(GL_FRAMEBUFFER, mRenderTarget); - glViewport(0, 0, mRenderTargetSize.x, mRenderTargetSize.y); + glBindFramebuffer(GL_FRAMEBUFFER, renderer->RenderTarget); + glViewport(0, + 0, + renderer->RenderTargetSize->Raster.x, + renderer->RenderTargetSize->Raster.y); - glEnable(GL_DEPTH_TEST); - - for (Mesh* m : mCurrentScene->getRenderables()) - { - //m->getMaterial()->getGlShader()->use(); - //GLint uniTrans = glGetUniformLocation(m->getMaterial()->getGlShader()->getProgram(), "model"); - //glUniformMatrix4fv(uniTrans, 1, GL_FALSE, glm::value_ptr(glm::mat4(1.0f))); + glEnable(GL_DEPTH_TEST); - //GLint uniView = glGetUniformLocation(m->getMaterial()->getGlShader()->getProgram(), "view"); - //glUniformMatrix4fv(uniView, 1, GL_FALSE, glm::value_ptr(mCurrentScene->getCamera()->getViewMatrix())); + for (Mesh* m : renderer->CurrentScene->getRenderables()) { + // m->getMaterial()->getGlShader()->use(); + // GLint uniTrans = glGetUniformLocation(m->getMaterial()->getGlShader()->getProgram(), "model"); + // glUniformMatrix4fv(uniTrans, 1, GL_FALSE, glm::value_ptr(glm::mat4(1.0f))); + + // GLint uniView = glGetUniformLocation(m->getMaterial()->getGlShader()->getProgram(), "view"); + // glUniformMatrix4fv(uniView, 1, GL_FALSE, glm::value_ptr(renderer->CurrentScene->getCamera()->getViewMatrix())); + + // GLint uniProj = glGetUniformLocation(m->getMaterial()->getGlShader()->getProgram(), "proj"); + // glUniformMatrix4fv(uniProj, 1, GL_FALSE, glm::value_ptr(renderer->CurrentScene->getCamera()->getProjectionMatrix())); - //GLint uniProj = glGetUniformLocation(m->getMaterial()->getGlShader()->getProgram(), "proj"); - //glUniformMatrix4fv(uniProj, 1, GL_FALSE, glm::value_ptr(mCurrentScene->getCamera()->getProjectionMatrix())); - glBindVertexArray(m->getVAO()); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m->getEBO()); glDrawElements(GL_TRIANGLES, m->getIndexCount() * sizeof(uint32_t), GL_UNSIGNED_INT, 0); } - + glBindFramebuffer(GL_FRAMEBUFFER, 0); } + +} diff --git a/src/preview_renderer/renderer.hpp b/src/preview_renderer/renderer.hpp index 4d0c059..b0090c7 100644 --- a/src/preview_renderer/renderer.hpp +++ b/src/preview_renderer/renderer.hpp @@ -2,32 +2,33 @@ #include -namespace inferno { - -class Scene; - -class RasterizeRenderer -{ -public: - RasterizeRenderer(); - ~RasterizeRenderer(); - - void setScene(Scene* scene); - - void setTargetSize(glm::ivec2 size); - glm::ivec2 getTargetSize(); - GLuint getRenderedTexture(); - - void prepare(); - void draw(); - -private: - GLuint mRenderTarget = 0; - GLuint mRenderTargetTexture = 0; - GLuint mRenderTargetDepthTexture = 0; - glm::ivec2 mRenderTargetSize = {1920, 1080}; - - Scene* mCurrentScene; -}; +#include +namespace inferno::scene { +struct Scene; } + +namespace inferno::graphics { + +struct Viewport; + +typedef struct PreviewRenderer { + GLuint RenderTarget = 0; + GLuint RenderTargetTexture = 0; + GLuint RenderTargetDepthTexture = 0; + std::shared_ptr CurrentScene; + std::shared_ptr RenderTargetSize; +} PreviewRenderer; + +std::unique_ptr preview_create(); +void preview_cleanup(std::unique_ptr& renderer); + +void preview_set_scene(std::unique_ptr& renderer, std::shared_ptr scene); +void preview_set_viewport(std::unique_ptr& renderer, std::shared_ptr viewports); +const glm::ivec2& preview_get_viewport(std::unique_ptr& renderer); +GLuint preview_get_rendered_texture(std::unique_ptr& renderer); + +void preview_prepare(std::unique_ptr& renderer); +void preview_draw(std::unique_ptr& renderer); + +} // namespace inferno::graphics diff --git a/src/scene/camera.cpp b/src/scene/camera.cpp index 0958452..0720029 100644 --- a/src/scene/camera.cpp +++ b/src/scene/camera.cpp @@ -12,9 +12,9 @@ std::unique_ptr camera_create() { std::unique_ptr camera = std::make_unique(); camera->_impl = std::make_unique<_CameraImpl>(); - camera->Viewports = std::make_shared(); - camera->Viewports->Raster = glm::ivec2(800, 600); - camera->Viewports->Ray = glm::ivec2(800, 600); + camera->Views = std::make_shared(); + camera->Views->Raster = glm::ivec2(800, 600); + camera->Views->Ray = glm::ivec2(800, 600); camera->ProjectionMatrix = glm::perspective( glm::radians(camera->FOV), @@ -61,7 +61,7 @@ void camera_update(std::unique_ptr& camera) camera->ViewMatrix = rotate * translate; camera->ProjectionMatrix = glm::perspective( glm::radians(camera->FOV), - static_cast(camera->Viewports->Raster.x) / static_cast(camera->Viewports->Raster.y), + static_cast(camera->Views->Raster.x) / static_cast(camera->Views->Raster.y), 0.1f, 1000.0f); @@ -108,7 +108,7 @@ glm::mat4 camera_get_look(std::unique_ptr& camera) void raster_set_viewport(std::unique_ptr& camera, glm::ivec2 viewport) { std::lock_guard lock(camera->_impl->CamMutex); - camera->Viewports->Raster = viewport; + camera->Views->Raster = viewport; camera->ProjectionMatrix = glm::perspective( glm::radians(camera->FOV), static_cast(viewport.x) / static_cast(viewport.y), @@ -119,19 +119,19 @@ void raster_set_viewport(std::unique_ptr& camera, glm::ivec2 viewport) glm::ivec2 raster_get_viewport(std::unique_ptr& camera) { std::lock_guard lock(camera->_impl->CamMutex); - return camera->Viewports->Raster; + return camera->Views->Raster; } void ray_set_viewport(std::unique_ptr& camera, glm::ivec2 viewport) { std::lock_guard lock(camera->_impl->CamMutex); - camera->Viewports->Ray = viewport; + camera->Views->Ray = viewport; } glm::ivec2 ray_get_viewport(std::unique_ptr& camera) { std::lock_guard lock(camera->_impl->CamMutex); - return camera->Viewports->Ray; + return camera->Views->Ray; } void camera_move(std::unique_ptr& camera, uint8_t movement_delta) diff --git a/src/scene/scene.hpp b/src/scene/scene.hpp index 0935348..795d2c6 100644 --- a/src/scene/scene.hpp +++ b/src/scene/scene.hpp @@ -2,14 +2,17 @@ #include -namespace inferno { +namespace inferno::scene { class SceneObject; class Camera; class Mesh; class Sky; -class Scene +typedef struct Scene { + +} Scene; + { public: Scene(); From db42b0df8240496fdb241e4d7f1d28c0e2b1af1e Mon Sep 17 00:00:00 2001 From: Benjamin Kyd Date: Thu, 27 Jul 2023 13:29:14 +0100 Subject: [PATCH 14/30] epic scne --- src/inferno.cpp | 2 +- src/scene/scene.cpp | 84 ++++++++++++++++++++++++--------------------- src/scene/scene.hpp | 43 +++++++++-------------- 3 files changed, 63 insertions(+), 66 deletions(-) diff --git a/src/inferno.cpp b/src/inferno.cpp index 7ce559a..a46154a 100644 --- a/src/inferno.cpp +++ b/src/inferno.cpp @@ -1,4 +1,4 @@ -#include "infergo.hpp" +#include "inferno.hpp" #include // #include "gui/layout.hpp" diff --git a/src/scene/scene.cpp b/src/scene/scene.cpp index 75e451a..b3ec889 100644 --- a/src/scene/scene.cpp +++ b/src/scene/scene.cpp @@ -1,49 +1,55 @@ #include "scene.hpp" -#include #include #include +#include -using namespace inferno; +namespace inferno::scene { -Scene::Scene() +std::unique_ptr scene_create() { + std::unique_ptr scene = std::make_unique(); + scene->Camera = std::make_shared(); + return scene; +} + +void scene_cleanup(std::unique_ptr& scene) +{ +} + +void scene_set_camera(std::unique_ptr& scene, std::shared_ptr camera) +{ + scene->Camera = camera; + scene->DidUpdate = true; +} + +void scene_add_object(std::unique_ptr& scene, std::unique_ptr object) +{ + scene->Objects.push_back(std::move(object)); + scene->DidUpdate = true; +} + +std::vector>& get_renderables(std::unique_ptr& scene) +{ + return scene->Objects; +} + +bool did_update(std::unique_ptr& scene) +{ + return scene->DidUpdate; +} + +void frame_tick(std::unique_ptr& scene) +{ + scene->DidUpdate = false; +} + +void tick(std::unique_ptr& scene) +{ + for (auto& object : scene->Objects) { + // object->tick(); + } +} } -Scene::~Scene() -{ - -} - -void Scene::setCamera(Camera* camera) -{ - mCurrentCamera = camera; - mDidUpdate = true; -} - -Camera* Scene::getCamera() -{ - return mCurrentCamera; -} - -void Scene::addMesh(Mesh* mesh) -{ - mMeshs.push_back(mesh); - mDidUpdate = true; -} - -bool Scene::didUpdate() -{ - return mDidUpdate; -} - -void Scene::newFrame() -{ - mDidUpdate = false; -} - -const std::vector& Scene::getRenderables() -{ - return mMeshs; -} diff --git a/src/scene/scene.hpp b/src/scene/scene.hpp index 795d2c6..a9d5757 100644 --- a/src/scene/scene.hpp +++ b/src/scene/scene.hpp @@ -1,40 +1,31 @@ #pragma once +#include #include +namespace inferno::graphics { +class Camera; +} + namespace inferno::scene { class SceneObject; -class Camera; class Mesh; -class Sky; typedef struct Scene { - + std::shared_ptr Camera; + std::vector> Objects; + bool DidUpdate = false; } Scene; -{ -public: - Scene(); - ~Scene(); - - void setCamera(Camera* camera); - Camera* getCamera(); - void addMesh(Mesh* mesh); - - bool didUpdate(); - void newFrame(); - - const std::vector& getRenderables(); - -private: - std::vector mMeshs; - - Camera* mCurrentCamera; - Sky* mCurrentSky; - -private: - bool mDidUpdate = false; -}; +std::unique_ptr scene_create(); +void scene_cleanup(std::unique_ptr& scene); +void scene_set_camera(std::unique_ptr& scene, std::shared_ptr camera); +void scene_add_object(std::unique_ptr& scene, std::unique_ptr object); +std::unique_ptr& get_camera(std::unique_ptr& scene); +std::vector>& get_renderables(std::unique_ptr& scene); +bool did_update(std::unique_ptr& scene); +void frame_tick(std::unique_ptr& scene); +void tick(std::unique_ptr& scene); } From 4012464bc59cf27f1dbed53f8003a4535861387b Mon Sep 17 00:00:00 2001 From: Ben Kyd Date: Sun, 6 Aug 2023 23:38:39 +0100 Subject: [PATCH 15/30] ray renderer --- src/renderer/renderer.cpp | 72 +++++++++++++++++++++++---------------- src/renderer/renderer.hpp | 68 ++++++++++++++++-------------------- src/scene/scene.cpp | 8 ++--- src/scene/scene.hpp | 10 +++--- 4 files changed, 81 insertions(+), 77 deletions(-) diff --git a/src/renderer/renderer.cpp b/src/renderer/renderer.cpp index 0cd3230..8356f89 100644 --- a/src/renderer/renderer.cpp +++ b/src/renderer/renderer.cpp @@ -15,15 +15,16 @@ #include -using namespace inferno; +namespace inferno::graphics { -RayRenderer::RayRenderer(HHM* accelIface) - : mIface(accelIface) +std::unique_ptr rayr_create(glm::ivec2 viewport, HHM* accelIface) { - mTarget = new glm::fvec4[mRenderTargetSize.x * mRenderTargetSize.y]; + std::unique_ptr renderer = std::make_unique(); + renderer->RenderTargetSize = viewport; + renderer->RenderData = new glm::fvec4[renderer->RenderTargetSize.x * renderer->RenderTargetSize.y]; - glGenTextures(1, &mRenderTargetTexture); - glBindTexture(GL_TEXTURE_2D, mRenderTargetTexture); + glGenTextures(1, &renderer->RenderTargetTexture); + glBindTexture(GL_TEXTURE_2D, renderer->RenderTargetTexture); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); @@ -31,66 +32,72 @@ RayRenderer::RayRenderer(HHM* accelIface) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glPixelStorei(GL_UNPACK_ROW_LENGTH, 0); - glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, mRenderTargetSize.x, mRenderTargetSize.y, 0, GL_RGBA, GL_FLOAT, mTarget); + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, renderer->RenderTargetSize.x, renderer->RenderTargetSize.y, 0, GL_RGBA, GL_FLOAT, renderer->RenderData); glBindTexture(GL_TEXTURE_2D, 0); + + return renderer; } -RayRenderer::~RayRenderer() +void rayr_cleanup(std::unique_ptr& renderer) { - delete[] mTarget; + delete[] renderer->RenderData; } -void RayRenderer::setScene(Scene* scene) +void rayr_set_scene(std::unique_ptr& renderer, std::shared_ptr scene) { - mCurrentScene = scene; - if (mRaySource != nullptr) + renderer->CurrentScene = scene; + if (renderer->RaySource != nullptr) { - delete mRaySource; + delete renderer->RaySource; } - mRaySource = new RaySource(scene->getCamera()); + // renderer->RaySource = new RaySource(scene->getCamera()); // the scene will be sent to the module on prepare // as it did update during initialisation // mIface->newScene(scene); } -void RayRenderer::setTargetSize(glm::ivec2 size) +void rayr_set_viewport(std::unique_ptr &renderer, glm::ivec2 size) { - mRenderTargetSize = size; + renderer->RenderTargetSize = size; } -glm::ivec2 RayRenderer::getTargetSize() +glm::ivec2 rayr_get_viewport(std::unique_ptr &renderer) { - return mRenderTargetSize; + return renderer->RenderTargetSize; } -GLuint RayRenderer::getRenderedTexture() +GLuint rayr_get_rendered_texture(std::unique_ptr &renderer) { - std::lock_guard lock(this->_RenderData); + std::lock_guard lock(renderer->RenderDataMutex); glBindFramebuffer(GL_FRAMEBUFFER, 0); - glBindTexture(GL_TEXTURE_2D, mRenderTargetTexture); - return mRenderTargetTexture; + glBindTexture(GL_TEXTURE_2D, renderer->RenderTargetTexture); + return renderer->RenderTargetTexture; } -glm::fvec4* RayRenderer::getRenderData() +glm::fvec4* rayr_get_render_data(std::unique_ptr &renderer) { - return mTarget; + std::lock_guard lock(renderer->RenderDataMutex); + return renderer->RenderData; } -void RayRenderer::prepare() +void rayr_prepare(std::unique_ptr &renderer) { - assert(mCurrentScene != nullptr); - if (mCurrentScene->didUpdate()) + assert(renderer->CurrentScene != nullptr); + // here, scene_did_update takes a unique_ptr, but we have a shared_ptr + // so we need to call unique() to get the unique_ptr but that will error + // with non-const ltype so we need to const_cast it + if (scene::scene_did_update(renderer->CurrentScene.unique())) { yolo::debug("New Scene!"); - mIface->newScene(mCurrentScene); + // renderer->AccelerationInterface->newScene(renderer->CurrentScene); } } -void RayRenderer::draw() +void rayr_draw(std::unique_ptr &renderer) { - mCurrentScene->newFrame(); + scene::scene_frame_tick(renderer->CurrentScene.unique()); // TODO: Rays should definately be bump allocated if possible, this is KBs of // ray data and nothing else being reallocated every frame for no reason ReferencedRayField startRays = mRaySource->getInitialRays(true); @@ -129,4 +136,9 @@ void RayRenderer::computeHit(HitInfo* info) if (d > maxd) maxd = d; float n = (d - mind) / (maxd - mind); mTarget[pos.y * mRenderTargetSize.x + pos.x] = { n, n, n, 1.0f}; +} + void mHaultWait(); + std::unordered_map* mCurrentRefTable; + + } diff --git a/src/renderer/renderer.hpp b/src/renderer/renderer.hpp index ca3ad45..5d30657 100644 --- a/src/renderer/renderer.hpp +++ b/src/renderer/renderer.hpp @@ -2,58 +2,50 @@ #include +#include #include #include -#include -namespace inferno { +namespace inferno::scene { +struct Scene; +} + +namespace inferno::graphics { class HHM; -class Scene; class HitInfo; class RaySource; class RenderDispatcher; -class RayRenderer -{ -public: - RayRenderer(HHM* accelIface); - ~RayRenderer(); +typedef struct RayRenderer { + glm::fvec4* RenderData = nullptr; + GLuint RenderTargetTexture = 0; - void setScene(Scene* scene); + // TODO: Put this inside an internal struct + std::mutex RenderDataMutex; + std::condition_variable RenderPause; + // TODO: End - void setTargetSize(glm::ivec2 size); - glm::ivec2 getTargetSize(); - GLuint getRenderedTexture(); - glm::fvec4* getRenderData(); + std::shared_ptr CurrentScene; + // std::shared_ptr RenderTargetSize; + glm::ivec2 RenderTargetSize; - void prepare(); - void draw(); + HHM* AccelerationInterface = nullptr; + RenderDispatcher* Dispatcher = nullptr; + RaySource* RaySource = nullptr; +} RayRenderer; -public: - void computeHit(HitInfo* info); +std::unique_ptr rayr_create(glm::ivec2 viewport, HHM* accelIface); +void rayr_cleanup(std::unique_ptr& renderer); +void rayr_set_scene(std::unique_ptr& renderer, std::shared_ptr scene); +void rayr_set_viewport(std::unique_ptr& renderer, glm::ivec2 size); +glm::ivec2 rayr_get_viewport(std::unique_ptr& renderer); +GLuint rayr_get_rendered_texture(std::unique_ptr& renderer); +glm::fvec4* rayr_get_render_data(std::unique_ptr& renderer); +void rayr_prepare(std::unique_ptr& renderer); +void rayr_draw(std::unique_ptr& renderer); -private: - void mHaultWait(); - - std::unordered_map* mCurrentRefTable; - -private: - GLuint mRenderTargetTexture = 0; - glm::fvec4* mTarget; - - std::mutex _RenderData; - std::condition_variable _RenderPause; - - glm::ivec2 mRenderTargetSize = {200, 200}; - - Scene* mCurrentScene = nullptr; - RaySource* mRaySource = nullptr; - - friend class RenderDispatcher; -private: - HHM* mIface; -}; +void raryr_compute_hit(HitInfo* info); } diff --git a/src/scene/scene.cpp b/src/scene/scene.cpp index b3ec889..5c25f86 100644 --- a/src/scene/scene.cpp +++ b/src/scene/scene.cpp @@ -29,22 +29,22 @@ void scene_add_object(std::unique_ptr& scene, std::unique_ptrDidUpdate = true; } -std::vector>& get_renderables(std::unique_ptr& scene) +std::vector>& scene_get_renderables(std::unique_ptr& scene) { return scene->Objects; } -bool did_update(std::unique_ptr& scene) +bool scene_did_update(std::unique_ptr& scene) { return scene->DidUpdate; } -void frame_tick(std::unique_ptr& scene) +void scene_frame_tick(std::unique_ptr& scene) { scene->DidUpdate = false; } -void tick(std::unique_ptr& scene) +void scene_tick(std::unique_ptr& scene) { for (auto& object : scene->Objects) { // object->tick(); diff --git a/src/scene/scene.hpp b/src/scene/scene.hpp index a9d5757..3849999 100644 --- a/src/scene/scene.hpp +++ b/src/scene/scene.hpp @@ -22,10 +22,10 @@ std::unique_ptr scene_create(); void scene_cleanup(std::unique_ptr& scene); void scene_set_camera(std::unique_ptr& scene, std::shared_ptr camera); void scene_add_object(std::unique_ptr& scene, std::unique_ptr object); -std::unique_ptr& get_camera(std::unique_ptr& scene); -std::vector>& get_renderables(std::unique_ptr& scene); -bool did_update(std::unique_ptr& scene); -void frame_tick(std::unique_ptr& scene); -void tick(std::unique_ptr& scene); +std::unique_ptr& scene_get_camera(std::unique_ptr& scene); +std::vector>& scene_get_renderables(std::unique_ptr& scene); +bool scene_did_update(std::unique_ptr& scene); +void scene_frame_tick(std::unique_ptr& scene); +void scene_tick(std::unique_ptr& scene); } From f413cd88bfaaad39adae46ca1b3596924abea1bf Mon Sep 17 00:00:00 2001 From: Benjamin Kyd Date: Thu, 24 Aug 2023 14:53:23 +0100 Subject: [PATCH 16/30] push --- src/renderer/ray_source.hpp | 4 ++-- src/renderer/renderer.cpp | 4 ++-- src/renderer/renderer.hpp | 5 +++-- 3 files changed, 7 insertions(+), 6 deletions(-) diff --git a/src/renderer/ray_source.hpp b/src/renderer/ray_source.hpp index 0b3ae52..fbf6d07 100644 --- a/src/renderer/ray_source.hpp +++ b/src/renderer/ray_source.hpp @@ -11,12 +11,12 @@ namespace inferno { class Camera; -struct ReferencedRayField -{ +struct ReferencedRayField { RayField Field; std::unordered_map Reference; }; + class RaySource { public: diff --git a/src/renderer/renderer.cpp b/src/renderer/renderer.cpp index 8356f89..3589a5e 100644 --- a/src/renderer/renderer.cpp +++ b/src/renderer/renderer.cpp @@ -88,7 +88,7 @@ void rayr_prepare(std::unique_ptr &renderer) // here, scene_did_update takes a unique_ptr, but we have a shared_ptr // so we need to call unique() to get the unique_ptr but that will error // with non-const ltype so we need to const_cast it - if (scene::scene_did_update(renderer->CurrentScene.unique())) + if (scene::scene_did_update(renderer->CurrentScene)) { yolo::debug("New Scene!"); // renderer->AccelerationInterface->newScene(renderer->CurrentScene); @@ -97,7 +97,7 @@ void rayr_prepare(std::unique_ptr &renderer) void rayr_draw(std::unique_ptr &renderer) { - scene::scene_frame_tick(renderer->CurrentScene.unique()); + scene::scene_frame_tick(renderer->CurrentScene); // TODO: Rays should definately be bump allocated if possible, this is KBs of // ray data and nothing else being reallocated every frame for no reason ReferencedRayField startRays = mRaySource->getInitialRays(true); diff --git a/src/renderer/renderer.hpp b/src/renderer/renderer.hpp index 5d30657..c5ea574 100644 --- a/src/renderer/renderer.hpp +++ b/src/renderer/renderer.hpp @@ -3,6 +3,7 @@ #include #include +#include #include #include @@ -27,7 +28,7 @@ typedef struct RayRenderer { std::condition_variable RenderPause; // TODO: End - std::shared_ptr CurrentScene; + std::unique_ptr CurrentScene; // std::shared_ptr RenderTargetSize; glm::ivec2 RenderTargetSize; @@ -38,7 +39,7 @@ typedef struct RayRenderer { std::unique_ptr rayr_create(glm::ivec2 viewport, HHM* accelIface); void rayr_cleanup(std::unique_ptr& renderer); -void rayr_set_scene(std::unique_ptr& renderer, std::shared_ptr scene); +void rayr_set_scene(std::unique_ptr& renderer, std::unique_ptr scene); void rayr_set_viewport(std::unique_ptr& renderer, glm::ivec2 size); glm::ivec2 rayr_get_viewport(std::unique_ptr& renderer); GLuint rayr_get_rendered_texture(std::unique_ptr& renderer); From 923ff2fb65df4b2c7e767279bb01b62aba16101c Mon Sep 17 00:00:00 2001 From: Ben Kyd Date: Mon, 18 Sep 2023 23:07:50 +0100 Subject: [PATCH 17/30] what --- src/inferno.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/inferno.cpp b/src/inferno.cpp index a46154a..b04c240 100644 --- a/src/inferno.cpp +++ b/src/inferno.cpp @@ -167,7 +167,7 @@ int inferno_run(std::unique_ptr& app) if (app->Input->MovementDelta != 0b00000000) graphics::camera_move(app->Camera, app->Input->MovementDelta); - graphics::raster_set_viewport({ ImGui::GetWindowSize().x, ImGui::GetWindowSize().y }); + graphics::raster_set_viewport(app->Camera, { ImGui::GetWindowSize().x, ImGui::GetWindowSize().y }); mRasterRenderer->setTargetSize({ ImGui::GetWindowSize().x, ImGui::GetWindowSize().y }); mRasterRenderer->prepare(); mRasterRenderer->draw(); From 298fe984e3fedf804a5fdb9a84f374fcbc08afa9 Mon Sep 17 00:00:00 2001 From: Benjamin Kyd Date: Thu, 28 Sep 2023 13:29:39 +0100 Subject: [PATCH 18/30] remove lots of things --- src/hart_directory.cpp | 185 ----------------------------------------- src/hart_directory.hpp | 71 ---------------- src/hart_module.cpp | 83 ------------------ src/hart_module.hpp | 42 ---------- 4 files changed, 381 deletions(-) delete mode 100644 src/hart_directory.cpp delete mode 100644 src/hart_directory.hpp delete mode 100644 src/hart_module.cpp delete mode 100644 src/hart_module.hpp diff --git a/src/hart_directory.cpp b/src/hart_directory.cpp deleted file mode 100644 index 571a7f7..0000000 --- a/src/hart_directory.cpp +++ /dev/null @@ -1,185 +0,0 @@ -#include "hart_directory.hpp" - -#include "inferno_hart.hpp" - -#include - -#include - -using namespace inferno; - -HARTModuleDirectory::HARTModuleDirectory() -{ - -} - -HARTModuleDirectory::~HARTModuleDirectory() -{ - -} - -std::vector HARTModuleDirectory::discoverModules(std::filesystem::path folder, bool recurse) -{ - if (!std::filesystem::exists(folder)) return { }; - if (!std::filesystem::is_directory(folder)) - { - return { this->registerModule(folder) }; - } - - std::error_code err; - if (recurse) - { - for (const auto& file : std::filesystem::recursive_directory_iterator(folder, err)) - { - if (file.path().extension() == HART_EXTENSION) - { - this->registerModule(file); - } - } - } else - { - for (const auto& file : std::filesystem::directory_iterator(folder, err)) - { - if (file.path().extension() == HART_EXTENSION) - { - this->registerModule(file); - } - } - } - - return { }; -} - -HARTModuleDirectory::discoveryEntry HARTModuleDirectory::registerModule(std::filesystem::path file) -{ - yolo::info("Registering module at {}", file.c_str()); - - discoveryEntry entry; - entry.Location = file; - -#ifdef _WIN32 - entry.Handle = LoadLibraryA(file.c_str()); - if (entry.Handle == NULL) - { - yolo::error("Cannot load module at {}.", file.c_str()); - entry.Handle = NULL; entry.DidLink = false; - return entry; - } - HART_CREDIT_F credit = (HART_CREDIT_F)GetProcAddress(entry.Handle, "_CREDIT"); - entry.InitCallback = (HART_INIT_F)GetProcAddress(entry.Handle, "_GET"); - entry.DestroyCallback = (HART_DESTROY_F)GetProcAddress(entry.Handle, "_DESTROY"); -#else // UNIX-Like - entry.Handle = dlopen(file.c_str(), RTLD_NOW | RTLD_LOCAL); - if (entry.Handle == NULL) - { - yolo::error("Cannot load module at ", dlerror()); - entry.Handle = NULL; entry.DidLink = false; - return entry; - } - HART_CREDIT_F credit = (HART_CREDIT_F)dlsym(entry.Handle, "_CREDIT"); - entry.InitCallback = (HART_INIT_F)dlsym(entry.Handle, "_GET"); - entry.DestroyCallback = (HART_DESTROY_F)dlsym(entry.Handle, "_DESTROY"); -#endif - - if (credit == NULL) - { - yolo::error("Cannot load module at {}... No credit...", file.c_str()); - entry.Handle = NULL; entry.DidLink = false; - return entry; - } - if (entry.InitCallback == NULL) - { - yolo::error("Cannot load module at {}... No get...", file.c_str()); - entry.Handle = NULL; entry.DidLink = false; - return entry; - } - if (entry.DestroyCallback == NULL) - { - yolo::error("Cannot load module at {}... No destroy...", file.c_str()); - entry.Handle = NULL; entry.DidLink = false; - return entry; - } - - entry.Credit = (ModuleCredit*)credit(); - - yolo::info("Module {} v{}.{}.{} by {}", entry.Credit->ModuleName, - entry.Credit->VersionMajor, - entry.Credit->VersionMinor, - entry.Credit->VersionBuild, - entry.Credit->AuthorName); - - entry.DidLink = true; - mEntries[entry.Credit->ModuleName] = { entry, nullptr }; - - if (mEntries.size() == 1) - { - // this is the first, make it active - or else - mActiveModule = entry.Credit->ModuleName; - this->load(mActiveModule); - } - - return entry; -} - -std::vector HARTModuleDirectory::getModules() -{ - std::vector keys; - for(auto kv : mEntries) - { - keys.push_back(kv.first); - } - return keys; -} - -void HARTModuleDirectory::setActive(std::string moduleName) -{ - if (moduleName == mActiveModule) return; - this->destroy(mActiveModule); - mActiveModule = moduleName; - this->load(mActiveModule); -} - -void HARTModuleDirectory::setActiveIndex(int index) -{ - std::vector keys = this->getModules(); - this->setActive(keys[index]); -} - -HARTModule* HARTModuleDirectory::getActiveModule() -{ - return mEntries[mActiveModule].Module; -} - -std::string HARTModuleDirectory::getActive() -{ - return mActiveModule; -} - -int HARTModuleDirectory::getActiveIndex() -{ - std::vector keys = this->getModules(); - for (int i = 0; i < keys.size(); i++) - { - if (keys[i] == mActiveModule) return i; - } - return -1; // this should never happen -} - -ModuleCredit* HARTModuleDirectory::getActiveCredit() -{ - return mEntries[mActiveModule].Discovery.Credit; -} - -void HARTModuleDirectory::load(std::string moduleName) -{ - HARTModule* mod = (HARTModule*)mEntries[moduleName].Discovery.InitCallback(); - mEntries[moduleName].Module = mod; - mEntries[moduleName].Active = true; -} - -void HARTModuleDirectory::destroy(std::string moduleName) -{ - mEntries[moduleName].Discovery.DestroyCallback(mEntries[moduleName].Module); - mEntries[moduleName].Module = nullptr; - mEntries[moduleName].Active = false; -} diff --git a/src/hart_directory.hpp b/src/hart_directory.hpp deleted file mode 100644 index a837582..0000000 --- a/src/hart_directory.hpp +++ /dev/null @@ -1,71 +0,0 @@ -#pragma once - -// INFERNO-HART Modules -// _GET returns derived HARTModule -// _DESTROY returns void but takes derived HARTModule -// _CREDIT returns ModuleCredit - -// THIS IS SHARED DO __NOT__ REINCLUDE libhart/thirdparty -#include - -#include -#include -#include -#include - -namespace inferno { - -class HARTModule; -struct ModuleCredit; - -class HARTModuleDirectory -{ -public: - HARTModuleDirectory(); - ~HARTModuleDirectory(); - - struct discoveryEntry - { - std::filesystem::path Location; - bool DidLink = false; -#ifdef _WIN32 - HMODULE Handle; -#else // UNIX-Like - void* Handle; -#endif - ModuleCredit* Credit; - HART_INIT_F InitCallback; - HART_DESTROY_F DestroyCallback; - }; - - struct moduleEntry - { - discoveryEntry Discovery; - HARTModule* Module; - bool Active; - }; - - // This can take a file or a directory, and inside the directory discover recursively or not - std::vector discoverModules(std::filesystem::path path, bool recurse = false); - discoveryEntry registerModule(std::filesystem::path file); - - std::vector getModules(); - - void setActive(std::string moduleName); - void setActiveIndex(int index); - - HARTModule* getActiveModule(); - std::string getActive(); - int getActiveIndex(); - ModuleCredit* getActiveCredit(); - - void load(std::string moduleName); - void destroy(std::string moduleName); - -private: - std::string mActiveModule; - std::unordered_map mEntries; -}; - -} - diff --git a/src/hart_module.cpp b/src/hart_module.cpp deleted file mode 100644 index 3b14733..0000000 --- a/src/hart_module.cpp +++ /dev/null @@ -1,83 +0,0 @@ -#include "hart_module.hpp" - -#include -#include - -#include -#include - -#include - -#include - -using namespace inferno; - -HHM::HHM() - : mDirectory() -{ - mDirectory.discoverModules("./hart/", true); -} - -HHM::~HHM() -{ - -} - -HARTModuleDirectory* HHM::getModuleDirectory() -{ - return &mDirectory; -} - -HARTModule::EModuleState HHM::getModuleState() -{ - HARTModule* mod = mDirectory.getActiveModule(); - return mod->getState(); -} - -void HHM::newScene(Scene* scene) -{ - HARTModule* mod = mDirectory.getActiveModule(); - std::vector meshs = scene->getRenderables(); - // TODO: This may not be the way i want to approach it - // as submitTris should take maybe a mesh ID and then the mesh data - // as it is now, submitTris assumes it's getting the whole scene - // which would involve a lot of mesh copying (avoid!) if i were to chain them - for (auto* mesh : meshs) { - void* verticies; void* normals; void* indicies; - int vertexCount = mesh->getVerticies(&verticies, &normals); - int indexCount = mesh->getIndicies(&indicies); - yolo::debug("Mesh for module ready... {} {}", verticies, normals); - mod->submitTris(verticies, normals, vertexCount, indicies, indexCount); - } -} - -void HHM::notifySceneUpdate() -{ - HARTModule* mod = mDirectory.getActiveModule(); - mod->updateTris(); -} - -void rayHitCallback(void* hhm, HitInfo* hit) -{ - ((HHM*)hhm)->rayReturn(hit); -} - -void HHM::rayReturn(HitInfo* hit) -{ - Renderer->computeHit(hit); -} - -void HHM::bounce(Ray* newRay) -{ - -} - -void HHM::startTrace(RayField sourceScatter) -{ - // TODO: Signal start - HARTModule* mod = mDirectory.getActiveModule(); - mod->passContext((void*)this, &rayHitCallback); - yolo::debug("SubmitQueue {}", sourceScatter.size()); - mod->submitQueue(sourceScatter); - mod->start(); -} diff --git a/src/hart_module.hpp b/src/hart_module.hpp deleted file mode 100644 index 9317c8d..0000000 --- a/src/hart_module.hpp +++ /dev/null @@ -1,42 +0,0 @@ -#pragma once - -// the HHM (Hamlin Hamlin McGill) aka the Head HART Module keeps track of the module -// and gives the renderer a cleaner interface to talk to a HART Module - -#include - -#include -#include "hart_directory.hpp" - -namespace inferno { - -class Scene; -class Ray; -class HitInfo; -class HARTModule; -class RayRenderer; - -class HHM -{ -public: - HHM(); - ~HHM(); - - HARTModuleDirectory* getModuleDirectory(); - HARTModule::EModuleState getModuleState(); - - void newScene(Scene* scene); - void notifySceneUpdate(); - - void rayReturn(HitInfo* hit); - void bounce(Ray* newRay); - - void startTrace(RayField sourceScatter); - - RayRenderer* Renderer; - -private: - HARTModuleDirectory mDirectory; -}; - -} From ad033e445952689de56ffa1113824e22fd514220 Mon Sep 17 00:00:00 2001 From: Benjamin Kyd Date: Thu, 28 Sep 2023 13:30:11 +0100 Subject: [PATCH 19/30] bump --- src/version.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/version.hpp b/src/version.hpp index 9e5aad7..d9a5fcc 100644 --- a/src/version.hpp +++ b/src/version.hpp @@ -1,3 +1,3 @@ #pragma once -#define INFERNO_VERSION "3.0.1_alpha" +#define INFERNO_VERSION "3.0.13_alpha" From 26510cb091f67831555c29171cf790e0d02ea5cc Mon Sep 17 00:00:00 2001 From: Benjamin Kyd Date: Mon, 2 Oct 2023 16:30:35 +0100 Subject: [PATCH 20/30] switching pc --- src/inferno.hpp | 5 ++++- src/scene/scene.hpp | 3 +-- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/src/inferno.hpp b/src/inferno.hpp index 99ad928..926a616 100644 --- a/src/inferno.hpp +++ b/src/inferno.hpp @@ -1,6 +1,7 @@ #pragma once #include "graphics.hpp" +#include "preview_renderer/renderer.hpp" #include @@ -17,7 +18,9 @@ typedef struct InfernoInput { typedef struct InfernoApp { std::unique_ptr Input; - std::unique_ptr Camera; + std::unique_ptr Scene; + std::unique_ptr PreviewRenderer; + std::unique_ptr RayRenderer; } InfernoApp; std::unique_ptr inferno_create(); diff --git a/src/scene/scene.hpp b/src/scene/scene.hpp index 3849999..424b74f 100644 --- a/src/scene/scene.hpp +++ b/src/scene/scene.hpp @@ -13,14 +13,13 @@ class SceneObject; class Mesh; typedef struct Scene { - std::shared_ptr Camera; + std::unique_ptr Camera; std::vector> Objects; bool DidUpdate = false; } Scene; std::unique_ptr scene_create(); void scene_cleanup(std::unique_ptr& scene); -void scene_set_camera(std::unique_ptr& scene, std::shared_ptr camera); void scene_add_object(std::unique_ptr& scene, std::unique_ptr object); std::unique_ptr& scene_get_camera(std::unique_ptr& scene); std::vector>& scene_get_renderables(std::unique_ptr& scene); From 3a9a07005aad452c5650d8431baed0d82a14e067 Mon Sep 17 00:00:00 2001 From: Ben Kyd Date: Tue, 3 Oct 2023 19:12:52 +0100 Subject: [PATCH 21/30] WHY DOESIT SEGFAULT --- libhart/scene/camera.hpp | 7 +- src/inferno.cpp | 59 +++--- src/inferno.hpp | 11 +- src/main.cpp | 2 +- src/preview_renderer/renderer.cpp | 68 +++---- src/preview_renderer/renderer.hpp | 10 +- src/preview_renderer/shader.cpp | 4 +- src/renderer/dispatcher.cpp | 75 -------- src/renderer/dispatcher.hpp | 42 ----- src/renderer/ray_source.cpp | 140 +++++++-------- src/renderer/ray_source.hpp | 66 +++---- src/renderer/renderer.cpp | 287 +++++++++++++++--------------- src/renderer/renderer.hpp | 25 +-- src/scene/camera.cpp | 23 +-- src/scene/material.cpp | 3 +- src/scene/material.hpp | 2 +- src/scene/mesh.cpp | 12 +- src/scene/mesh.hpp | 7 +- src/scene/object.cpp | 29 +++ src/scene/object.hpp | 21 +-- src/scene/objloader.cpp | 4 +- src/scene/objloader.hpp | 2 +- src/scene/scene.cpp | 19 +- src/scene/scene.hpp | 10 +- 24 files changed, 426 insertions(+), 502 deletions(-) delete mode 100644 src/renderer/dispatcher.cpp delete mode 100644 src/renderer/dispatcher.hpp diff --git a/libhart/scene/camera.hpp b/libhart/scene/camera.hpp index 2557b24..d756533 100644 --- a/libhart/scene/camera.hpp +++ b/libhart/scene/camera.hpp @@ -8,7 +8,10 @@ namespace inferno::graphics { -struct _CameraImpl; +typedef struct _CameraImpl { + bool DidUpdate; + std::mutex CamMutex; +} _CameraImpl; typedef struct Viewport { glm::ivec2 Raster; @@ -20,7 +23,7 @@ typedef struct Camera { glm::mat4 ProjectionMatrix; glm::mat4 LookMatrix; - std::shared_ptr Views; + Viewport Views; float MouseSensitivity = 0.4f; float Speed = 0.1f; diff --git a/src/inferno.cpp b/src/inferno.cpp index b04c240..2900a47 100644 --- a/src/inferno.cpp +++ b/src/inferno.cpp @@ -2,19 +2,16 @@ #include // #include "gui/layout.hpp" +#include "imgui/imgui.h" +#include "scene/scene.hpp" #include "window.hpp" -// #include "hart_module.hpp" -// #include "hart_directory.hpp" - -// #include "preview_renderer/renderer.hpp" -// #include "preview_renderer/shader.hpp" -// #include "renderer/dispatcher.hpp" -// #include "renderer/renderer.hpp" +#include "preview_renderer/renderer.hpp" +#include "preview_renderer/shader.hpp" +#include "scene/scene.hpp" #include "scene/camera.hpp" -// #include "scene/scene.hpp" -// #include "scene/material.hpp" -// #include "scene/mesh.hpp" +#include "scene/material.hpp" +#include "scene/mesh.hpp" #include @@ -36,6 +33,24 @@ std::unique_ptr inferno_create() // Create window graphics::window_create("Inferno v" INFERNO_VERSION, 1280, 720); + // setup the scene + scene::Material basicMaterial("basic"); + + std::unique_ptr basicShader = graphics::shader_create(); + graphics::shader_load(basicShader, "res/shaders/basic.glsl"); + graphics::shader_link(basicShader); + + std::unique_ptr object = scene::scene_object_create(); + + scene::Mesh cornell; + cornell.loadOBJ("res/cornell-box.obj"); + // cornell.loadOBJ("res/sponza.obj"); + cornell.ready(); + cornell.setMaterial(&basicMaterial); + + scene::scene_object_add_mesh(object, &cornell); + scene::scene_add_object(app->Scene, object); + return app; } @@ -65,7 +80,7 @@ void inferno_preset_gui(std::unique_ptr& app) ImGui::DockBuilderAddNode(dockspace_id, ImGuiDockNodeFlags_DockSpace); // Add empty node ImGui::DockBuilderSetNodeSize(dockspace_id, { 1000, 1000 }); - ImGuiID dock_main_id = dockspace_id; // This variable will track the document node, however we are not using it here as we aren't docking anything into it. + ImGuiID dock_main_id = dockspace_id; ImGuiID dock_left = ImGui::DockBuilderSplitNode(dock_main_id, ImGuiDir_Left, 0.5f, NULL, &dock_main_id); ImGui::DockBuilderDockWindow("Preview", dock_left); ImGui::DockBuilderDockWindow("Render", dock_main_id); @@ -121,7 +136,6 @@ void inferno_stop_move_input(std::unique_ptr& app) int inferno_run(std::unique_ptr& app) { - while (true) { if (!graphics::window_new_frame()) break; @@ -134,6 +148,11 @@ int inferno_run(std::unique_ptr& app) } ImGui::DockSpace(dockspace_id, ImVec2(0.0f, 0.0f), dockspace_flags); + if (glm::length(app->Input->MouseDelta) > 0.0f) + graphics::camera_mouse_move(app->Scene->Camera, app->Input->MouseDelta); + if (app->Input->MovementDelta != 0b00000000) + graphics::camera_move(app->Scene->Camera, app->Input->MovementDelta); + // Menu Bar static bool showPreview = true; static bool showRenderSettings = true; @@ -162,18 +181,16 @@ int inferno_run(std::unique_ptr& app) } else { inferno_stop_move_input(app); } - if (glm::length(app->Input->MouseDelta) > 0.0f) - graphics::camera_mouse_move(app->Camera, app->Input->MouseDelta); - if (app->Input->MovementDelta != 0b00000000) - graphics::camera_move(app->Camera, app->Input->MovementDelta); - graphics::raster_set_viewport(app->Camera, { ImGui::GetWindowSize().x, ImGui::GetWindowSize().y }); - mRasterRenderer->setTargetSize({ ImGui::GetWindowSize().x, ImGui::GetWindowSize().y }); - mRasterRenderer->prepare(); - mRasterRenderer->draw(); + graphics::raster_set_viewport(scene::scene_get_camera(app->Scene), { ImGui::GetWindowSize().x, ImGui::GetWindowSize().y }); + graphics::preview_draw(app->PreviewRenderer, app->Scene); - ImGui::Image((ImTextureID)mRasterRenderer->getRenderedTexture(), inderno { mRasterRenderer->getTargetSize().x, mRasterRenderer->getTargetSize().y }, + ImTextureID texture = (ImTextureID)graphics::preview_get_rendered_texture(app->PreviewRenderer); + ImGui::Image( + texture, + { ImGui::GetWindowSize().x, ImGui::GetWindowSize().y }, ImVec2(0, 1), ImVec2(1, 0)); + glBindFramebuffer(GL_FRAMEBUFFER, 0); ImGui::End(); } diff --git a/src/inferno.hpp b/src/inferno.hpp index 926a616..1edab48 100644 --- a/src/inferno.hpp +++ b/src/inferno.hpp @@ -1,6 +1,9 @@ #pragma once #include "graphics.hpp" +#include "scene/scene.hpp" +#include "scene/camera.hpp" +// #include "renderer/renderer.hpp" #include "preview_renderer/renderer.hpp" #include @@ -11,6 +14,10 @@ namespace graphics { struct Camera; } +namespace scene { + struct Scene; +} + typedef struct InfernoInput { glm::vec2 MouseDelta; uint8_t MovementDelta; @@ -20,7 +27,7 @@ typedef struct InfernoApp { std::unique_ptr Input; std::unique_ptr Scene; std::unique_ptr PreviewRenderer; - std::unique_ptr RayRenderer; + // std::unique_ptr RayRenderer; } InfernoApp; std::unique_ptr inferno_create(); @@ -30,4 +37,4 @@ void inferno_move_input(std::unique_ptr& app); void inferno_stop_move_input(std::unique_ptr& app); int inferno_run(std::unique_ptr& app); -} +} // namespace inferno diff --git a/src/main.cpp b/src/main.cpp index 85bd1d1..0ffa398 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -5,6 +5,6 @@ int main(int argc, char** argv) { - std::unique_ptr inferno = inferno::inferno_create(); + auto inferno = inferno::inferno_create(); return inferno::inferno_run(inferno); } diff --git a/src/preview_renderer/renderer.cpp b/src/preview_renderer/renderer.cpp index 17574ef..669a294 100644 --- a/src/preview_renderer/renderer.cpp +++ b/src/preview_renderer/renderer.cpp @@ -1,11 +1,14 @@ #include "renderer.hpp" +#include "scene/object.hpp" #include "shader.hpp" +#include #include #include -#include #include +#include +#include #include @@ -48,14 +51,19 @@ void preview_cleanup(std::unique_ptr& renderer) { } -void preview_set_scene(std::unique_ptr& renderer, std::shared_ptr scene) +void preview_set_viewport(std::unique_ptr& renderer, std::unique_ptr viewport) { - renderer->CurrentScene = scene; } -void preview_set_viewport(std::unique_ptr& renderer, std::shared_ptr viewport) +GLuint preview_get_rendered_texture(std::unique_ptr& renderer) { - renderer->RenderTargetSize = viewport; + glBindFramebuffer(GL_FRAMEBUFFER, renderer->RenderTarget); + return renderer->RenderTargetTexture; +} + +void preview_draw(std::unique_ptr& renderer, std::unique_ptr& scene) +{ + const glm::ivec2& viewport = graphics::raster_get_viewport(scene::scene_get_camera(scene)); glBindFramebuffer(GL_FRAMEBUFFER, renderer->RenderTarget); glBindTexture(GL_TEXTURE_2D, renderer->RenderTargetTexture); @@ -63,8 +71,8 @@ void preview_set_viewport(std::unique_ptr& renderer, std::share GL_TEXTURE_2D, 0, GL_RGB, - viewport->Raster.x, - viewport->Raster.y, + viewport.x, + viewport.y, 0, GL_RGB, GL_UNSIGNED_BYTE, @@ -74,60 +82,40 @@ void preview_set_viewport(std::unique_ptr& renderer, std::share glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH24_STENCIL8, - viewport->Raster.x, - viewport->Raster.y, + viewport.x, + viewport.y, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL); glBindFramebuffer(GL_FRAMEBUFFER, 0); -} -const glm::ivec2& preview_get_viewport(std::unique_ptr& renderer) -{ - return renderer->RenderTargetSize->Raster; -} + // clear -GLuint preview_get_rendered_texture(std::unique_ptr& renderer) -{ - glBindFramebuffer(GL_FRAMEBUFFER, renderer->RenderTarget); - return renderer->RenderTargetTexture; -} - -void preview_prepare(std::unique_ptr& renderer) -{ glBindFramebuffer(GL_FRAMEBUFFER, renderer->RenderTarget); glClearColor(0.1, 0.1, 0.1, 1.0); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glBindFramebuffer(GL_FRAMEBUFFER, 0); -} -void preview_draw(std::unique_ptr& renderer) -{ + // draw + glBindFramebuffer(GL_FRAMEBUFFER, renderer->RenderTarget); glViewport(0, 0, - renderer->RenderTargetSize->Raster.x, - renderer->RenderTargetSize->Raster.y); + renderer->Viewport.x, + renderer->Viewport.y); glEnable(GL_DEPTH_TEST); - for (Mesh* m : renderer->CurrentScene->getRenderables()) { - // m->getMaterial()->getGlShader()->use(); - // GLint uniTrans = glGetUniformLocation(m->getMaterial()->getGlShader()->getProgram(), "model"); - // glUniformMatrix4fv(uniTrans, 1, GL_FALSE, glm::value_ptr(glm::mat4(1.0f))); + for (std::unique_ptr& o : scene::scene_get_renderables(scene)) { + for (scene::Mesh* m : scene::scene_object_get_meshs(o)) { + glBindVertexArray(m->getVAO()); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m->getEBO()); - // GLint uniView = glGetUniformLocation(m->getMaterial()->getGlShader()->getProgram(), "view"); - // glUniformMatrix4fv(uniView, 1, GL_FALSE, glm::value_ptr(renderer->CurrentScene->getCamera()->getViewMatrix())); + glDrawElements(GL_TRIANGLES, m->getIndexCount() * sizeof(uint32_t), GL_UNSIGNED_INT, 0); - // GLint uniProj = glGetUniformLocation(m->getMaterial()->getGlShader()->getProgram(), "proj"); - // glUniformMatrix4fv(uniProj, 1, GL_FALSE, glm::value_ptr(renderer->CurrentScene->getCamera()->getProjectionMatrix())); - - glBindVertexArray(m->getVAO()); - glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m->getEBO()); - - glDrawElements(GL_TRIANGLES, m->getIndexCount() * sizeof(uint32_t), GL_UNSIGNED_INT, 0); + } } glBindFramebuffer(GL_FRAMEBUFFER, 0); diff --git a/src/preview_renderer/renderer.hpp b/src/preview_renderer/renderer.hpp index b0090c7..b0def88 100644 --- a/src/preview_renderer/renderer.hpp +++ b/src/preview_renderer/renderer.hpp @@ -13,22 +13,18 @@ namespace inferno::graphics { struct Viewport; typedef struct PreviewRenderer { + glm::ivec2 Viewport; + GLuint RenderTarget = 0; GLuint RenderTargetTexture = 0; GLuint RenderTargetDepthTexture = 0; - std::shared_ptr CurrentScene; - std::shared_ptr RenderTargetSize; } PreviewRenderer; std::unique_ptr preview_create(); void preview_cleanup(std::unique_ptr& renderer); -void preview_set_scene(std::unique_ptr& renderer, std::shared_ptr scene); -void preview_set_viewport(std::unique_ptr& renderer, std::shared_ptr viewports); -const glm::ivec2& preview_get_viewport(std::unique_ptr& renderer); GLuint preview_get_rendered_texture(std::unique_ptr& renderer); -void preview_prepare(std::unique_ptr& renderer); -void preview_draw(std::unique_ptr& renderer); +void preview_draw(std::unique_ptr& renderer, std::unique_ptr& scene); } // namespace inferno::graphics diff --git a/src/preview_renderer/shader.cpp b/src/preview_renderer/shader.cpp index 8565189..b665724 100644 --- a/src/preview_renderer/shader.cpp +++ b/src/preview_renderer/shader.cpp @@ -3,7 +3,7 @@ #include #include -using namespace inferno::graphics; +namespace inferno::graphics { static std::unordered_map shader2Index = { { GL_VERTEX_SHADER, 0 }, @@ -179,3 +179,5 @@ void shader_unuse(std::unique_ptr& shader) { glUseProgram(0); } + +} diff --git a/src/renderer/dispatcher.cpp b/src/renderer/dispatcher.cpp deleted file mode 100644 index bc1515e..0000000 --- a/src/renderer/dispatcher.cpp +++ /dev/null @@ -1,75 +0,0 @@ -#include "dispatcher.hpp" - -#include "hart_module.hpp" -#include "renderer.hpp" - -#include -#include - -using namespace inferno; - -RenderDispatcher::RenderDispatcher() - : mRenderWorker{} -{ - mHHM = new HHM(); - mRenderer = new RayRenderer(mHHM); - mHHM->Renderer = mRenderer; -} - -RenderDispatcher::~RenderDispatcher() -{ - mDoWork = false; - mJoin = true; - mRenderWorker.join(); -} - -RayRenderer* RenderDispatcher::getRenderer() -{ - return mRenderer; -} - -HHM* RenderDispatcher::getTopModule() -{ - return mHHM; -} - -void renderWorker(RayRenderer* renderer, std::atomic* doWork, std::atomic* join) -{ - while (!*join) - { - if (!*doWork) { - std::this_thread::sleep_for(std::chrono::milliseconds(100)); - continue; // stall - } - renderer->prepare(); - renderer->draw(); - } -} - -void RenderDispatcher::startProgression() -{ - if (!mRenderWorker.joinable()) - { - mRenderWorker = std::thread{ &renderWorker, this->mRenderer, &mDoWork, &mJoin }; - } - mDoWork = true; -} - -void RenderDispatcher::stopProgression() -{ - mDoWork = false; -} - -bool RenderDispatcher::progressionStatus() -{ - return mDoWork; -} - -GLuint RenderDispatcher::getLatestTexture() -{ - std::lock_guard lock(mRenderer->_RenderData); - glBindTexture(GL_TEXTURE_2D, mRenderer->mRenderTargetTexture); - glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, mRenderer->mRenderTargetSize.x, mRenderer->mRenderTargetSize.y, 0, GL_RGBA, GL_FLOAT, mRenderer->mTarget); - glBindTexture(GL_TEXTURE_2D, 0); - return mRenderer->mRenderTargetTexture; -} diff --git a/src/renderer/dispatcher.hpp b/src/renderer/dispatcher.hpp deleted file mode 100644 index fd18921..0000000 --- a/src/renderer/dispatcher.hpp +++ /dev/null @@ -1,42 +0,0 @@ -#pragma once - -#include - -#include -#include -#include - -namespace inferno { - -// Thread dispatcher keeps track of the thread that calls the -// copy function because OpenGL is a nightmare - -class HHM; -class Scene; -class RayRenderer; - -class RenderDispatcher -{ -public: - RenderDispatcher(); - ~RenderDispatcher(); - - RayRenderer* getRenderer(); - HHM* getTopModule(); - - void startProgression(); - void stopProgression(); - bool progressionStatus(); - GLuint getLatestTexture(); - -private: - HHM* mHHM; - RayRenderer* mRenderer; - -private: - std::thread mRenderWorker; - std::atomic mDoWork = false; - std::atomic mJoin = false; -}; - -} diff --git a/src/renderer/ray_source.cpp b/src/renderer/ray_source.cpp index f5e376e..62393e2 100644 --- a/src/renderer/ray_source.cpp +++ b/src/renderer/ray_source.cpp @@ -1,70 +1,70 @@ -#include "ray_source.hpp" - -#include - -#include - -#include - -#include - -using namespace inferno; - -RaySource::RaySource(Camera* camera) - : mReferenceCamera(camera) -{ - this->generate(); -} - -RaySource::~RaySource() -{ - -} - -void RaySource::generate() -{ - // const float aspect = mReferenceCamera->getRayViewport().x / mReferenceCamera->getRayViewport().y; - // float scale = tan(mReferenceCamera->FOV / 2.0f * helpers::PI / 180.0f); -} - -ReferencedRayField RaySource::getInitialRays(bool MSAA) -{ - if (mReferenceCamera->didUpdate()) - { - this->generate(); - } - - RayField field; - field.reserve(mReferenceCamera->getRayViewport().x * mReferenceCamera->getRayViewport().y); - - const float aspect = mReferenceCamera->getRayViewport().x / mReferenceCamera->getRayViewport().y; - float scale = tan(mReferenceCamera->FOV / 2.0f * helpers::PI / 180.0f); - - glm::mat4 cameraToWorld = mReferenceCamera->getCameraLook(); - glm::vec3 origin = mReferenceCamera->Position; - - std::unordered_map reference; - - uint32_t i = 0; - for (int x = 0; x < mReferenceCamera->getRayViewport().x; x++) - for (int y = 0; y < mReferenceCamera->getRayViewport().y; y++) - { - float Px = (2.0f * ((x + 0.5f) / mReferenceCamera->getRayViewport().x) - 1.0f) * scale * aspect; - float Py = (2.0f * ((y + 0.5f) / mReferenceCamera->getRayViewport().y) - 1.0f) * scale; - - Ray* ray = new Ray{}; - - glm::vec4 dir4 = glm::vec4(Px, Py, -1.0f, 1.0f) * cameraToWorld; - glm::vec3 dir3 = glm::vec3(dir4) / dir4.w; - ray->Direction = glm::normalize(dir3); - - ray->Origin = origin; - ray->Reference = i; - reference[i] = {x, y}; - - field.push_back(ray); - i++; - } - - return { field, reference }; -} +// #include "ray_source.hpp" +// +// #include +// +// #include +// +// #include +// +// #include +// +// using namespace inferno; +// +// RaySource::RaySource(Camera* camera) +// : mReferenceCamera(camera) +// { +// this->generate(); +// } +// +// RaySource::~RaySource() +// { +// +// } +// +// void RaySource::generate() +// { +// // const float aspect = mReferenceCamera->getRayViewport().x / mReferenceCamera->getRayViewport().y; +// // float scale = tan(mReferenceCamera->FOV / 2.0f * helpers::PI / 180.0f); +// } +// +// ReferencedRayField RaySource::getInitialRays(bool MSAA) +// { +// if (mReferenceCamera->didUpdate()) +// { +// this->generate(); +// } +// +// RayField field; +// field.reserve(mReferenceCamera->getRayViewport().x * mReferenceCamera->getRayViewport().y); +// +// const float aspect = mReferenceCamera->getRayViewport().x / mReferenceCamera->getRayViewport().y; +// float scale = tan(mReferenceCamera->FOV / 2.0f * helpers::PI / 180.0f); +// +// glm::mat4 cameraToWorld = mReferenceCamera->getCameraLook(); +// glm::vec3 origin = mReferenceCamera->Position; +// +// std::unordered_map reference; +// +// uint32_t i = 0; +// for (int x = 0; x < mReferenceCamera->getRayViewport().x; x++) +// for (int y = 0; y < mReferenceCamera->getRayViewport().y; y++) +// { +// float Px = (2.0f * ((x + 0.5f) / mReferenceCamera->getRayViewport().x) - 1.0f) * scale * aspect; +// float Py = (2.0f * ((y + 0.5f) / mReferenceCamera->getRayViewport().y) - 1.0f) * scale; +// +// Ray* ray = new Ray{}; +// +// glm::vec4 dir4 = glm::vec4(Px, Py, -1.0f, 1.0f) * cameraToWorld; +// glm::vec3 dir3 = glm::vec3(dir4) / dir4.w; +// ray->Direction = glm::normalize(dir3); +// +// ray->Origin = origin; +// ray->Reference = i; +// reference[i] = {x, y}; +// +// field.push_back(ray); +// i++; +// } +// +// return { field, reference }; +// } diff --git a/src/renderer/ray_source.hpp b/src/renderer/ray_source.hpp index fbf6d07..9ccce94 100644 --- a/src/renderer/ray_source.hpp +++ b/src/renderer/ray_source.hpp @@ -1,33 +1,33 @@ -#pragma once - -#include -#include - -#include - -#include - -namespace inferno { - -class Camera; - -struct ReferencedRayField { - RayField Field; - std::unordered_map Reference; -}; - - -class RaySource -{ -public: - RaySource(Camera* camera); - ~RaySource(); - - void generate(); - ReferencedRayField getInitialRays(bool MSAA); - -private: - Camera* mReferenceCamera; -}; - -} +// #pragma once +// +// #include +// #include +// +// #include +// +// #include +// +// namespace inferno { +// +// class Camera; +// +// struct ReferencedRayField { +// RayField Field; +// std::unordered_map Reference; +// }; +// +// +// class RaySource +// { +// public: +// RaySource(Camera* camera); +// ~RaySource(); +// +// void generate(); +// ReferencedRayField getInitialRays(bool MSAA); +// +// private: +// Camera* mReferenceCamera; +// }; +// +// } diff --git a/src/renderer/renderer.cpp b/src/renderer/renderer.cpp index 3589a5e..5317657 100644 --- a/src/renderer/renderer.cpp +++ b/src/renderer/renderer.cpp @@ -1,144 +1,143 @@ -#include "renderer.hpp" - -#include - -#include -#include -#include -#include -#include - -#include "hart_module.hpp" -#include "ray_source.hpp" - -#include - -#include - -namespace inferno::graphics { - -std::unique_ptr rayr_create(glm::ivec2 viewport, HHM* accelIface) -{ - std::unique_ptr renderer = std::make_unique(); - renderer->RenderTargetSize = viewport; - renderer->RenderData = new glm::fvec4[renderer->RenderTargetSize.x * renderer->RenderTargetSize.y]; - - glGenTextures(1, &renderer->RenderTargetTexture); - glBindTexture(GL_TEXTURE_2D, renderer->RenderTargetTexture); - - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); - - glPixelStorei(GL_UNPACK_ROW_LENGTH, 0); - glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, renderer->RenderTargetSize.x, renderer->RenderTargetSize.y, 0, GL_RGBA, GL_FLOAT, renderer->RenderData); - - glBindTexture(GL_TEXTURE_2D, 0); - - return renderer; -} - -void rayr_cleanup(std::unique_ptr& renderer) -{ - delete[] renderer->RenderData; -} - -void rayr_set_scene(std::unique_ptr& renderer, std::shared_ptr scene) -{ - renderer->CurrentScene = scene; - if (renderer->RaySource != nullptr) - { - delete renderer->RaySource; - } - // renderer->RaySource = new RaySource(scene->getCamera()); - // the scene will be sent to the module on prepare - // as it did update during initialisation - - // mIface->newScene(scene); -} - -void rayr_set_viewport(std::unique_ptr &renderer, glm::ivec2 size) -{ - renderer->RenderTargetSize = size; -} - -glm::ivec2 rayr_get_viewport(std::unique_ptr &renderer) -{ - return renderer->RenderTargetSize; -} - -GLuint rayr_get_rendered_texture(std::unique_ptr &renderer) -{ - std::lock_guard lock(renderer->RenderDataMutex); - glBindFramebuffer(GL_FRAMEBUFFER, 0); - glBindTexture(GL_TEXTURE_2D, renderer->RenderTargetTexture); - return renderer->RenderTargetTexture; -} - -glm::fvec4* rayr_get_render_data(std::unique_ptr &renderer) -{ - std::lock_guard lock(renderer->RenderDataMutex); - return renderer->RenderData; -} - -void rayr_prepare(std::unique_ptr &renderer) -{ - assert(renderer->CurrentScene != nullptr); - // here, scene_did_update takes a unique_ptr, but we have a shared_ptr - // so we need to call unique() to get the unique_ptr but that will error - // with non-const ltype so we need to const_cast it - if (scene::scene_did_update(renderer->CurrentScene)) - { - yolo::debug("New Scene!"); - // renderer->AccelerationInterface->newScene(renderer->CurrentScene); - } -} - -void rayr_draw(std::unique_ptr &renderer) -{ - scene::scene_frame_tick(renderer->CurrentScene); - // TODO: Rays should definately be bump allocated if possible, this is KBs of - // ray data and nothing else being reallocated every frame for no reason - ReferencedRayField startRays = mRaySource->getInitialRays(true); - - for (int x = 0; x < mRenderTargetSize.x; x++) - for (int y = 0; y < mRenderTargetSize.y; y++) - { - mTarget[y * mRenderTargetSize.x + x] = { 0.1f, 0.1f, 0.1f, 1.0f }; - } - mCurrentRefTable = &startRays.Reference; - - // before we start we now want to check that it hasn't been force-stopped - mIface->startTrace(startRays.Field); - - yolo::info("Sample complete"); - - for (auto* ray : startRays.Field) - { - delete ray; - } -} - -void RayRenderer::computeHit(HitInfo* info) -{ - static float mind = 100000.0f; - static float maxd = 0.0f; - // TODO: Make sure signal is started - if (!(*mCurrentRefTable).count(info->Caller->Reference)) - { - yolo::warn("Why is the ray not in the map?!"); - return; - } - glm::ivec2 pos = (*mCurrentRefTable)[info->Caller->Reference]; - float d = info->Distance; - if (d < mind) mind = d; - if (d > maxd) maxd = d; - float n = (d - mind) / (maxd - mind); - mTarget[pos.y * mRenderTargetSize.x + pos.x] = { n, n, n, 1.0f}; -} - void mHaultWait(); - std::unordered_map* mCurrentRefTable; - - -} +// #include "renderer.hpp" +// +// #include +// +// #include +// #include +// #include +// #include +// #include +// +// #include "ray_source.hpp" +// +// #include +// +// #include +// +// namespace inferno::graphics { +// +// std::unique_ptr rayr_create(glm::ivec2 viewport, HHM* accelIface) +// { +// std::unique_ptr renderer = std::make_unique(); +// renderer->RenderTargetSize = viewport; +// renderer->RenderData = new glm::fvec4[renderer->RenderTargetSize.x * renderer->RenderTargetSize.y]; +// +// glGenTextures(1, &renderer->RenderTargetTexture); +// glBindTexture(GL_TEXTURE_2D, renderer->RenderTargetTexture); +// +// glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); +// glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); +// glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); +// glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); +// +// glPixelStorei(GL_UNPACK_ROW_LENGTH, 0); +// glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, renderer->RenderTargetSize.x, renderer->RenderTargetSize.y, 0, GL_RGBA, GL_FLOAT, renderer->RenderData); +// +// glBindTexture(GL_TEXTURE_2D, 0); +// +// return renderer; +// } +// +// void rayr_cleanup(std::unique_ptr& renderer) +// { +// delete[] renderer->RenderData; +// } +// +// void rayr_set_scene(std::unique_ptr& renderer, std::shared_ptr scene) +// { +// renderer->CurrentScene = scene; +// if (renderer->RaySource != nullptr) +// { +// delete renderer->RaySource; +// } +// // renderer->RaySource = new RaySource(scene->getCamera()); +// // the scene will be sent to the module on prepare +// // as it did update during initialisation +// +// // mIface->newScene(scene); +// } +// +// void rayr_set_viewport(std::unique_ptr &renderer, glm::ivec2 size) +// { +// renderer->RenderTargetSize = size; +// } +// +// glm::ivec2 rayr_get_viewport(std::unique_ptr &renderer) +// { +// return renderer->RenderTargetSize; +// } +// +// GLuint rayr_get_rendered_texture(std::unique_ptr &renderer) +// { +// std::lock_guard lock(renderer->RenderDataMutex); +// glBindFramebuffer(GL_FRAMEBUFFER, 0); +// glBindTexture(GL_TEXTURE_2D, renderer->RenderTargetTexture); +// return renderer->RenderTargetTexture; +// } +// +// glm::fvec4* rayr_get_render_data(std::unique_ptr &renderer) +// { +// std::lock_guard lock(renderer->RenderDataMutex); +// return renderer->RenderData; +// } +// +// void rayr_prepare(std::unique_ptr &renderer) +// { +// assert(renderer->CurrentScene != nullptr); +// // here, scene_did_update takes a unique_ptr, but we have a shared_ptr +// // so we need to call unique() to get the unique_ptr but that will error +// // with non-const ltype so we need to const_cast it +// if (scene::scene_did_update(renderer->CurrentScene)) +// { +// yolo::debug("New Scene!"); +// // renderer->AccelerationInterface->newScene(renderer->CurrentScene); +// } +// } +// +// void rayr_draw(std::unique_ptr &renderer) +// { +// scene::scene_frame_tick(renderer->CurrentScene); +// // TODO: Rays should definately be bump allocated if possible, this is KBs of +// // ray data and nothing else being reallocated every frame for no reason +// ReferencedRayField startRays = mRaySource->getInitialRays(true); +// +// for (int x = 0; x < mRenderTargetSize.x; x++) +// for (int y = 0; y < mRenderTargetSize.y; y++) +// { +// mTarget[y * mRenderTargetSize.x + x] = { 0.1f, 0.1f, 0.1f, 1.0f }; +// } +// mCurrentRefTable = &startRays.Reference; +// +// // before we start we now want to check that it hasn't been force-stopped +// mIface->startTrace(startRays.Field); +// +// yolo::info("Sample complete"); +// +// for (auto* ray : startRays.Field) +// { +// delete ray; +// } +// } +// +// void RayRenderer::computeHit(HitInfo* info) +// { +// static float mind = 100000.0f; +// static float maxd = 0.0f; +// // TODO: Make sure signal is started +// if (!(*mCurrentRefTable).count(info->Caller->Reference)) +// { +// yolo::warn("Why is the ray not in the map?!"); +// return; +// } +// glm::ivec2 pos = (*mCurrentRefTable)[info->Caller->Reference]; +// float d = info->Distance; +// if (d < mind) mind = d; +// if (d > maxd) maxd = d; +// float n = (d - mind) / (maxd - mind); +// mTarget[pos.y * mRenderTargetSize.x + pos.x] = { n, n, n, 1.0f}; +// } +// void mHaultWait(); +// std::unordered_map* mCurrentRefTable; +// +// +// } diff --git a/src/renderer/renderer.hpp b/src/renderer/renderer.hpp index c5ea574..692bceb 100644 --- a/src/renderer/renderer.hpp +++ b/src/renderer/renderer.hpp @@ -20,33 +20,26 @@ class RaySource; class RenderDispatcher; typedef struct RayRenderer { + std::unique_ptr Viewport; + + // TODO: Can this be direct 2 GPU? glm::fvec4* RenderData = nullptr; GLuint RenderTargetTexture = 0; - // TODO: Put this inside an internal struct - std::mutex RenderDataMutex; - std::condition_variable RenderPause; - // TODO: End - - std::unique_ptr CurrentScene; - // std::shared_ptr RenderTargetSize; - glm::ivec2 RenderTargetSize; - - HHM* AccelerationInterface = nullptr; - RenderDispatcher* Dispatcher = nullptr; + // Internal stuffs RaySource* RaySource = nullptr; } RayRenderer; std::unique_ptr rayr_create(glm::ivec2 viewport, HHM* accelIface); void rayr_cleanup(std::unique_ptr& renderer); -void rayr_set_scene(std::unique_ptr& renderer, std::unique_ptr scene); + void rayr_set_viewport(std::unique_ptr& renderer, glm::ivec2 size); -glm::ivec2 rayr_get_viewport(std::unique_ptr& renderer); + GLuint rayr_get_rendered_texture(std::unique_ptr& renderer); glm::fvec4* rayr_get_render_data(std::unique_ptr& renderer); -void rayr_prepare(std::unique_ptr& renderer); -void rayr_draw(std::unique_ptr& renderer); + +void rayr_draw(std::unique_ptr& renderer, std::unique_ptr scene); void raryr_compute_hit(HitInfo* info); -} +} // namespace inferno::graphics diff --git a/src/scene/camera.cpp b/src/scene/camera.cpp index 0720029..a3173d3 100644 --- a/src/scene/camera.cpp +++ b/src/scene/camera.cpp @@ -2,19 +2,14 @@ namespace inferno::graphics { -typedef struct _CameraImpl { - - bool DidUpdate; - std::mutex CamMutex; -} _CameraImpl; - std::unique_ptr camera_create() { std::unique_ptr camera = std::make_unique(); camera->_impl = std::make_unique<_CameraImpl>(); - camera->Views = std::make_shared(); - camera->Views->Raster = glm::ivec2(800, 600); - camera->Views->Ray = glm::ivec2(800, 600); + + camera->Views = Viewports(); + camera->Views.Raster = glm::ivec2(800, 600); + camera->Views.Ray = glm::ivec2(800, 600); camera->ProjectionMatrix = glm::perspective( glm::radians(camera->FOV), @@ -61,7 +56,7 @@ void camera_update(std::unique_ptr& camera) camera->ViewMatrix = rotate * translate; camera->ProjectionMatrix = glm::perspective( glm::radians(camera->FOV), - static_cast(camera->Views->Raster.x) / static_cast(camera->Views->Raster.y), + static_cast(camera->Views.Raster.x) / static_cast(camera->Views.Raster.y), 0.1f, 1000.0f); @@ -108,7 +103,7 @@ glm::mat4 camera_get_look(std::unique_ptr& camera) void raster_set_viewport(std::unique_ptr& camera, glm::ivec2 viewport) { std::lock_guard lock(camera->_impl->CamMutex); - camera->Views->Raster = viewport; + camera->Views.Raster = viewport; camera->ProjectionMatrix = glm::perspective( glm::radians(camera->FOV), static_cast(viewport.x) / static_cast(viewport.y), @@ -119,19 +114,19 @@ void raster_set_viewport(std::unique_ptr& camera, glm::ivec2 viewport) glm::ivec2 raster_get_viewport(std::unique_ptr& camera) { std::lock_guard lock(camera->_impl->CamMutex); - return camera->Views->Raster; + return camera->Views.Raster; } void ray_set_viewport(std::unique_ptr& camera, glm::ivec2 viewport) { std::lock_guard lock(camera->_impl->CamMutex); - camera->Views->Ray = viewport; + camera->Views.Ray = viewport; } glm::ivec2 ray_get_viewport(std::unique_ptr& camera) { std::lock_guard lock(camera->_impl->CamMutex); - return camera->Views->Ray; + return camera->Views.Ray; } void camera_move(std::unique_ptr& camera, uint8_t movement_delta) diff --git a/src/scene/material.cpp b/src/scene/material.cpp index bcdba1c..e429162 100644 --- a/src/scene/material.cpp +++ b/src/scene/material.cpp @@ -2,7 +2,7 @@ #include "preview_renderer/shader.hpp" -using namespace inferno; +namespace inferno::scene { Material::Material(std::string name) : mName(name) @@ -24,3 +24,4 @@ Material::~Material() //{ //return mGlShader; //} +} diff --git a/src/scene/material.hpp b/src/scene/material.hpp index 05a0fff..6c92e85 100644 --- a/src/scene/material.hpp +++ b/src/scene/material.hpp @@ -4,7 +4,7 @@ #include -namespace inferno { +namespace inferno::scene { //class Shader; class HitInfo; diff --git a/src/scene/mesh.cpp b/src/scene/mesh.cpp index 03f4bca..b81da20 100644 --- a/src/scene/mesh.cpp +++ b/src/scene/mesh.cpp @@ -6,7 +6,7 @@ #include -using namespace inferno; +namespace inferno::scene { Mesh::Mesh() { @@ -27,7 +27,7 @@ void Mesh::loadOBJ(std::filesystem::path file) for (int i = 0; i < vertCount * 3; i += 3) { Vert vert; - vert.Position = { + vert.Position = { mObjLoader->getPositions()[i], mObjLoader->getPositions()[i+1], mObjLoader->getPositions()[i+2], @@ -53,17 +53,17 @@ void Mesh::ready() // load data into vertex buffers glBindBuffer(GL_ARRAY_BUFFER, mVBO); - glBufferData(GL_ARRAY_BUFFER, mVerticies.size() * sizeof(Vert), &mVerticies[0], GL_STATIC_DRAW); + glBufferData(GL_ARRAY_BUFFER, mVerticies.size() * sizeof(Vert), &mVerticies[0], GL_STATIC_DRAW); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mEBO); glBufferData(GL_ELEMENT_ARRAY_BUFFER, mObjLoader->getIndexCount() * sizeof(uint32_t), &mObjLoader->getFaces()[0], GL_STATIC_DRAW); // set the vertex attribute pointers // vertex Positions - glEnableVertexAttribArray(0); + glEnableVertexAttribArray(0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vert), (void*)0); // vertex normals - glEnableVertexAttribArray(1); + glEnableVertexAttribArray(1); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(Vert), (void*)offsetof(Vert, Normal)); // vertex UV glEnableVertexAttribArray(2); @@ -116,3 +116,5 @@ GLuint Mesh::getEBO() { return mEBO; } + +} diff --git a/src/scene/mesh.hpp b/src/scene/mesh.hpp index 05fc01c..de53991 100644 --- a/src/scene/mesh.hpp +++ b/src/scene/mesh.hpp @@ -5,11 +5,12 @@ #include -namespace inferno { +namespace inferno::scene { class ObjLoader; class Material; +// TODO: This should be procedural like everything else struct Vert { glm::vec3 Position; @@ -17,7 +18,7 @@ struct Vert glm::vec2 UV; }; -class Mesh +class Mesh { public: Mesh(); @@ -49,7 +50,7 @@ private: private: ObjLoader* mObjLoader; Material* mMaterial; - + std::vector mVerticies; }; diff --git a/src/scene/object.cpp b/src/scene/object.cpp index e69de29..3e83d37 100644 --- a/src/scene/object.cpp +++ b/src/scene/object.cpp @@ -0,0 +1,29 @@ +#include "object.hpp" + +#include "mesh.hpp" + +namespace inferno::scene { + +std::unique_ptr scene_object_create() +{ + std::unique_ptr object = std::make_unique(); + return object; +} + +void scene_object_cleanup(std::unique_ptr& object) +{ + +} + +void scene_object_add_mesh(std::unique_ptr& object, Mesh* mesh) +{ + object->Meshs.push_back(mesh); +} + +std::vector& scene_object_get_meshs(std::unique_ptr& object) +{ + return object->Meshs; +} + +} + diff --git a/src/scene/object.hpp b/src/scene/object.hpp index 2c82f5e..ed0d2a3 100644 --- a/src/scene/object.hpp +++ b/src/scene/object.hpp @@ -1,19 +1,20 @@ #pragma once +#include #include -namespace inferno { +namespace inferno::scene { class Mesh; -class Object -{ -public: - Object(); - ~Object(); +typedef struct SceneObject { + std::vector Meshs; +} SceneObject; -private: - std::vector mMeshs; -}; +std::unique_ptr scene_object_create(); +void scene_object_cleanup(std::unique_ptr& object); -} +void scene_object_add_mesh(std::unique_ptr& object, Mesh* mesh); +std::vector& scene_object_get_meshs(std::unique_ptr& object); + +} // namespace inferno::scene diff --git a/src/scene/objloader.cpp b/src/scene/objloader.cpp index 8a0367a..873659d 100644 --- a/src/scene/objloader.cpp +++ b/src/scene/objloader.cpp @@ -10,7 +10,7 @@ #include #include -using namespace inferno; +namespace inferno::scene { struct FaceVert { @@ -263,3 +263,5 @@ const float* ObjLoader::getTexCoords(int multiTexCoordLayer) assert(multiTexCoordLayer < mTexCoordLayers); return (const float*)&mTexCoords[0]; } + +} diff --git a/src/scene/objloader.hpp b/src/scene/objloader.hpp index ce7b008..4141544 100644 --- a/src/scene/objloader.hpp +++ b/src/scene/objloader.hpp @@ -5,7 +5,7 @@ #include -namespace inferno { +namespace inferno::scene { struct Face { diff --git a/src/scene/scene.cpp b/src/scene/scene.cpp index 5c25f86..b13f1a0 100644 --- a/src/scene/scene.cpp +++ b/src/scene/scene.cpp @@ -1,5 +1,6 @@ #include "scene.hpp" +#include #include #include #include @@ -9,7 +10,7 @@ namespace inferno::scene { std::unique_ptr scene_create() { std::unique_ptr scene = std::make_unique(); - scene->Camera = std::make_shared(); + scene->Camera = std::make_unique(); return scene; } @@ -17,18 +18,17 @@ void scene_cleanup(std::unique_ptr& scene) { } -void scene_set_camera(std::unique_ptr& scene, std::shared_ptr camera) -{ - scene->Camera = camera; - scene->DidUpdate = true; -} - -void scene_add_object(std::unique_ptr& scene, std::unique_ptr object) +void scene_add_object(std::unique_ptr& scene, std::unique_ptr& object) { scene->Objects.push_back(std::move(object)); scene->DidUpdate = true; } +std::unique_ptr& scene_get_camera(std::unique_ptr& scene) +{ + return scene->Camera; +} + std::vector>& scene_get_renderables(std::unique_ptr& scene) { return scene->Objects; @@ -47,9 +47,8 @@ void scene_frame_tick(std::unique_ptr& scene) void scene_tick(std::unique_ptr& scene) { for (auto& object : scene->Objects) { - // object->tick(); + // Shit here like animation idk } } } - diff --git a/src/scene/scene.hpp b/src/scene/scene.hpp index 424b74f..686c321 100644 --- a/src/scene/scene.hpp +++ b/src/scene/scene.hpp @@ -1,5 +1,7 @@ #pragma once +#include "scene/object.hpp" + #include #include @@ -20,11 +22,15 @@ typedef struct Scene { std::unique_ptr scene_create(); void scene_cleanup(std::unique_ptr& scene); -void scene_add_object(std::unique_ptr& scene, std::unique_ptr object); + +void scene_add_object(std::unique_ptr& scene, std::unique_ptr& object); + std::unique_ptr& scene_get_camera(std::unique_ptr& scene); std::vector>& scene_get_renderables(std::unique_ptr& scene); + bool scene_did_update(std::unique_ptr& scene); + void scene_frame_tick(std::unique_ptr& scene); void scene_tick(std::unique_ptr& scene); -} +} // namespace inferno::scene From a21880ff63bd7b89383c2107d7a98acbfd8e99b4 Mon Sep 17 00:00:00 2001 From: Ben Kyd Date: Tue, 3 Oct 2023 22:17:56 +0100 Subject: [PATCH 22/30] saftey commit incase i fuck up making eveyrhing pointers --- src/scene/scene.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/scene/scene.cpp b/src/scene/scene.cpp index b13f1a0..3da825f 100644 --- a/src/scene/scene.cpp +++ b/src/scene/scene.cpp @@ -20,7 +20,7 @@ void scene_cleanup(std::unique_ptr& scene) void scene_add_object(std::unique_ptr& scene, std::unique_ptr& object) { - scene->Objects.push_back(std::move(object)); + scene->Objects.emplace_back(std::move(object)); scene->DidUpdate = true; } From 98e0adc416623df62767bec0885a9c2e2da277be Mon Sep 17 00:00:00 2001 From: Ben Kyd Date: Tue, 3 Oct 2023 23:09:36 +0100 Subject: [PATCH 23/30] well that broke a lot - sounds like a tomorrow problem --- src/inferno.cpp | 4 ++-- src/inferno.hpp | 20 ++++++++-------- src/preview_renderer/renderer.cpp | 2 +- src/preview_renderer/renderer.hpp | 8 +++---- src/preview_renderer/shader.cpp | 24 +++++++++---------- src/preview_renderer/shader.hpp | 20 ++++++++-------- src/renderer/renderer.cpp | 20 ++++++++-------- src/renderer/renderer.hpp | 14 ++++++------ src/scene/camera.cpp | 38 +++++++++++++++---------------- src/scene/object.cpp | 10 ++++---- src/scene/object.hpp | 8 +++---- src/scene/scene.cpp | 20 ++++++++-------- src/scene/scene.hpp | 20 ++++++++-------- 13 files changed, 104 insertions(+), 104 deletions(-) diff --git a/src/inferno.cpp b/src/inferno.cpp index 2900a47..cb67def 100644 --- a/src/inferno.cpp +++ b/src/inferno.cpp @@ -27,8 +27,8 @@ std::unique_ptr inferno_create() // MOTD yolo::info("INFERNO HART v" INFERNO_VERSION); - std::unique_ptr app = std::make_unique(); - app->Input = std::make_unique(); + std::unique_ptr app = new InfernoApp; + app->Input = new InfernoInput; // Create window graphics::window_create("Inferno v" INFERNO_VERSION, 1280, 720); diff --git a/src/inferno.hpp b/src/inferno.hpp index 1edab48..d74b59a 100644 --- a/src/inferno.hpp +++ b/src/inferno.hpp @@ -24,17 +24,17 @@ typedef struct InfernoInput { } InfernoInput; typedef struct InfernoApp { - std::unique_ptr Input; - std::unique_ptr Scene; - std::unique_ptr PreviewRenderer; - // std::unique_ptr RayRenderer; + InfernoInput* Input; + scene::Scene* Scene; + graphics::PreviewRenderer* PreviewRenderer; + // graphics::RayRenderer* RayRenderer; } InfernoApp; -std::unique_ptr inferno_create(); -void inferno_cleanup(std::unique_ptr& app); -void inferno_preset_gui(std::unique_ptr& app); -void inferno_move_input(std::unique_ptr& app); -void inferno_stop_move_input(std::unique_ptr& app); -int inferno_run(std::unique_ptr& app); +InfernoApp* inferno_create(); +void inferno_cleanup(InfernoApp* app); +void inferno_preset_gui(InfernoApp* app); +void inferno_move_input(InfernoApp* app); +void inferno_stop_move_input(InfernoApp* app); +int inferno_run(InfernoApp* app); } // namespace inferno diff --git a/src/preview_renderer/renderer.cpp b/src/preview_renderer/renderer.cpp index 669a294..8fb5e1f 100644 --- a/src/preview_renderer/renderer.cpp +++ b/src/preview_renderer/renderer.cpp @@ -16,7 +16,7 @@ namespace inferno::graphics { std::unique_ptr preview_create() { - std::unique_ptr renderer = std::make_unique(); + std::unique_ptr renderer = new PreviewRenderer; glGenFramebuffers(1, &renderer->RenderTarget); glBindFramebuffer(GL_FRAMEBUFFER, renderer->RenderTarget); diff --git a/src/preview_renderer/renderer.hpp b/src/preview_renderer/renderer.hpp index b0def88..4120d8b 100644 --- a/src/preview_renderer/renderer.hpp +++ b/src/preview_renderer/renderer.hpp @@ -20,11 +20,11 @@ typedef struct PreviewRenderer { GLuint RenderTargetDepthTexture = 0; } PreviewRenderer; -std::unique_ptr preview_create(); -void preview_cleanup(std::unique_ptr& renderer); +PreviewRenderer* preview_create(); +void preview_cleanup(PreviewRenderer* renderer); -GLuint preview_get_rendered_texture(std::unique_ptr& renderer); +GLuint preview_get_rendered_texture(PreviewRenderer* renderer); -void preview_draw(std::unique_ptr& renderer, std::unique_ptr& scene); +void preview_draw(PreviewRenderer* renderer, scene::Scene* scene); } // namespace inferno::graphics diff --git a/src/preview_renderer/shader.cpp b/src/preview_renderer/shader.cpp index b665724..551b93f 100644 --- a/src/preview_renderer/shader.cpp +++ b/src/preview_renderer/shader.cpp @@ -25,7 +25,7 @@ std::string textFromFile(const std::filesystem::path& path) std::istreambuf_iterator()); } -std::vector getKeys(std::unique_ptr& shader, std::string key) +std::vector getKeys(Shader* shader, std::string key) { std::vector ret; for (const auto& p : shader->PreprocessorDefinitions) @@ -56,9 +56,9 @@ bool checkShader(GLuint uid) return true; } -std::unique_ptr shader_create() +Shader* shader_create() { - std::unique_ptr shader = std::make_unique(); + Shader* shader = new Shader; shader->Program = 0; shader->Shaders[0] = GL_NONE; @@ -68,7 +68,7 @@ std::unique_ptr shader_create() return shader; } -void shader_cleanup(std::unique_ptr& shader) +void shader_cleanup(Shader* shader) { for (int i = 0; i < 3; i++) { if (shader->Shaders[i] == GL_NONE) @@ -79,7 +79,7 @@ void shader_cleanup(std::unique_ptr& shader) glDeleteProgram(shader->Program); } -void shader_load(std::unique_ptr& shader, std::filesystem::path path) +void shader_load(Shader* shader, std::filesystem::path path) { assert(std::filesystem::exists(path)); @@ -132,7 +132,7 @@ void shader_load(std::unique_ptr& shader, std::filesystem::path path) } } -void shader_link(std::unique_ptr& shader) +void shader_link(Shader* shader) { shader->Program = glCreateProgram(); @@ -150,32 +150,32 @@ void shader_link(std::unique_ptr& shader) glLinkProgram(shader->Program); } -void shader_add_attribute(std::unique_ptr& shader, const std::string& attribute) +void shader_add_attribute(Shader* shader, const std::string& attribute) { shader->Attributes[attribute] = glGetAttribLocation(shader->Program, attribute.c_str()); } -void shader_add_uniform(std::unique_ptr& shader, const std::string& uniform) +void shader_add_uniform(Shader* shader, const std::string& uniform) { shader->Uniforms[uniform] = glGetUniformLocation(shader->Program, uniform.c_str()); } -GLuint shader_get_attribute(std::unique_ptr& shader, const std::string& attribute) +GLuint shader_get_attribute(Shader* shader, const std::string& attribute) { return shader->Attributes[attribute]; } -GLuint shader_get_uniform(std::unique_ptr& shader, const std::string& uniform) +GLuint shader_get_uniform(Shader* shader, const std::string& uniform) { return shader->Uniforms[uniform]; } -void shader_use(std::unique_ptr& shader) +void shader_use(Shader* shader) { glUseProgram(shader->Program); } -void shader_unuse(std::unique_ptr& shader) +void shader_unuse(Shader* shader) { glUseProgram(0); } diff --git a/src/preview_renderer/shader.hpp b/src/preview_renderer/shader.hpp index 766269a..977734d 100644 --- a/src/preview_renderer/shader.hpp +++ b/src/preview_renderer/shader.hpp @@ -24,18 +24,18 @@ typedef struct Shader { std::vector PreprocessorDefinitions; } Shader; -std::unique_ptr shader_create(); -void shader_cleanup(std::unique_ptr& shader); +Shader* shader_create(); +void shader_cleanup(Shader* shader); -void shader_load(std::unique_ptr& shader, std::filesystem::path path); -void shader_link(std::unique_ptr& shader); +void shader_load(Shader* shader, std::filesystem::path path); +void shader_link(Shader* shader); // TODO: Implement shader_reload -void shader_add_attribute(std::unique_ptr& shader, const std::string& attribute); -void shader_add_uniform(std::unique_ptr& shader, const std::string& uniform); -GLuint shader_get_attribute(std::unique_ptr& shader, const std::string& attribute); -GLuint shader_get_uniform(std::unique_ptr& shader, const std::string& uniform); +void shader_add_attribute(Shader* shader, const std::string& attribute); +void shader_add_uniform(Shader* shader, const std::string& uniform); +GLuint shader_get_attribute(Shader* shader, const std::string& attribute); +GLuint shader_get_uniform(Shader* shader, const std::string& uniform); -void shader_use(std::unique_ptr& shader); -void shader_unuse(std::unique_ptr& shader); +void shader_use(Shader* shader); +void shader_unuse(Shader* shader); } diff --git a/src/renderer/renderer.cpp b/src/renderer/renderer.cpp index 5317657..628aeae 100644 --- a/src/renderer/renderer.cpp +++ b/src/renderer/renderer.cpp @@ -16,9 +16,9 @@ // // namespace inferno::graphics { // -// std::unique_ptr rayr_create(glm::ivec2 viewport, HHM* accelIface) +// RayRenderer* rayr_create(glm::ivec2 viewport, HHM* accelIface) // { -// std::unique_ptr renderer = std::make_unique(); +// RayRenderer* renderer = new RayRenderer; // renderer->RenderTargetSize = viewport; // renderer->RenderData = new glm::fvec4[renderer->RenderTargetSize.x * renderer->RenderTargetSize.y]; // @@ -38,12 +38,12 @@ // return renderer; // } // -// void rayr_cleanup(std::unique_ptr& renderer) +// void rayr_cleanup(RayRenderer* renderer) // { // delete[] renderer->RenderData; // } // -// void rayr_set_scene(std::unique_ptr& renderer, std::shared_ptr scene) +// void rayr_set_scene(RayRenderer* renderer, std::shared_ptr scene) // { // renderer->CurrentScene = scene; // if (renderer->RaySource != nullptr) @@ -57,17 +57,17 @@ // // mIface->newScene(scene); // } // -// void rayr_set_viewport(std::unique_ptr &renderer, glm::ivec2 size) +// void rayr_set_viewport(RayRenderer* &renderer, glm::ivec2 size) // { // renderer->RenderTargetSize = size; // } // -// glm::ivec2 rayr_get_viewport(std::unique_ptr &renderer) +// glm::ivec2 rayr_get_viewport(RayRenderer* &renderer) // { // return renderer->RenderTargetSize; // } // -// GLuint rayr_get_rendered_texture(std::unique_ptr &renderer) +// GLuint rayr_get_rendered_texture(RayRenderer* &renderer) // { // std::lock_guard lock(renderer->RenderDataMutex); // glBindFramebuffer(GL_FRAMEBUFFER, 0); @@ -75,13 +75,13 @@ // return renderer->RenderTargetTexture; // } // -// glm::fvec4* rayr_get_render_data(std::unique_ptr &renderer) +// glm::fvec4* rayr_get_render_data(RayRenderer* &renderer) // { // std::lock_guard lock(renderer->RenderDataMutex); // return renderer->RenderData; // } // -// void rayr_prepare(std::unique_ptr &renderer) +// void rayr_prepare(RayRenderer* &renderer) // { // assert(renderer->CurrentScene != nullptr); // // here, scene_did_update takes a unique_ptr, but we have a shared_ptr @@ -94,7 +94,7 @@ // } // } // -// void rayr_draw(std::unique_ptr &renderer) +// void rayr_draw(RayRenderer* &renderer) // { // scene::scene_frame_tick(renderer->CurrentScene); // // TODO: Rays should definately be bump allocated if possible, this is KBs of diff --git a/src/renderer/renderer.hpp b/src/renderer/renderer.hpp index 692bceb..d3ac31d 100644 --- a/src/renderer/renderer.hpp +++ b/src/renderer/renderer.hpp @@ -20,7 +20,7 @@ class RaySource; class RenderDispatcher; typedef struct RayRenderer { - std::unique_ptr Viewport; + glm::ivec2* Viewport; // TODO: Can this be direct 2 GPU? glm::fvec4* RenderData = nullptr; @@ -30,15 +30,15 @@ typedef struct RayRenderer { RaySource* RaySource = nullptr; } RayRenderer; -std::unique_ptr rayr_create(glm::ivec2 viewport, HHM* accelIface); -void rayr_cleanup(std::unique_ptr& renderer); +RayRenderer* rayr_create(glm::ivec2 viewport, HHM* accelIface); +void rayr_cleanup(RayRenderer* renderer); -void rayr_set_viewport(std::unique_ptr& renderer, glm::ivec2 size); +void rayr_set_viewport(RayRenderer* renderer, glm::ivec2 size); -GLuint rayr_get_rendered_texture(std::unique_ptr& renderer); -glm::fvec4* rayr_get_render_data(std::unique_ptr& renderer); +GLuint rayr_get_rendered_texture(RayRenderer* renderer); +glm::fvec4* rayr_get_render_data(RayRenderer* renderer); -void rayr_draw(std::unique_ptr& renderer, std::unique_ptr scene); +void rayr_draw(RayRenderer* renderer, scene::Scene* scene); void raryr_compute_hit(HitInfo* info); diff --git a/src/scene/camera.cpp b/src/scene/camera.cpp index a3173d3..4f77f37 100644 --- a/src/scene/camera.cpp +++ b/src/scene/camera.cpp @@ -2,10 +2,10 @@ namespace inferno::graphics { -std::unique_ptr camera_create() +Camera* camera_create() { - std::unique_ptr camera = std::make_unique(); - camera->_impl = std::make_unique<_CameraImpl>(); + Camera* camera = new Camera; + camera->_impl = new _CameraImpl; camera->Views = Viewports(); camera->Views.Raster = glm::ivec2(800, 600); @@ -29,13 +29,13 @@ std::unique_ptr camera_create() return camera; } -void camera_cleanup(std::unique_ptr& camera) +void camera_cleanup(Camera* camera) { camera->_impl.reset(); camera.reset(); } -void camera_update(std::unique_ptr& camera) +void camera_update(Camera* camera) { glm::mat4 matRoll = glm::mat4(1.0f); glm::mat4 matPitch = glm::mat4(1.0f); @@ -70,37 +70,37 @@ void camera_update(std::unique_ptr& camera) camera->_impl->DidUpdate = true; } -bool camera_did_update(std::unique_ptr& camera) +bool camera_did_update(Camera* camera) { std::lock_guard lock(camera->_impl->CamMutex); return camera->_impl->DidUpdate; } -void camera_new_frame(std::unique_ptr& camera) +void camera_new_frame(Camera* camera) { std::lock_guard lock(camera->_impl->CamMutex); camera->_impl->DidUpdate = false; } -glm::mat4 camera_get_view(std::unique_ptr& camera) +glm::mat4 camera_get_view(Camera* camera) { std::lock_guard lock(camera->_impl->CamMutex); return camera->ViewMatrix; } -glm::mat4 camera_get_projection(std::unique_ptr& camera) +glm::mat4 camera_get_projection(Camera* camera) { std::lock_guard lock(camera->_impl->CamMutex); return camera->ProjectionMatrix; } -glm::mat4 camera_get_look(std::unique_ptr& camera) +glm::mat4 camera_get_look(Camera* camera) { std::lock_guard lock(camera->_impl->CamMutex); return camera->LookMatrix; } -void raster_set_viewport(std::unique_ptr& camera, glm::ivec2 viewport) +void raster_set_viewport(Camera* camera, glm::ivec2 viewport) { std::lock_guard lock(camera->_impl->CamMutex); camera->Views.Raster = viewport; @@ -111,25 +111,25 @@ void raster_set_viewport(std::unique_ptr& camera, glm::ivec2 viewport) 1000.0f); } -glm::ivec2 raster_get_viewport(std::unique_ptr& camera) +glm::ivec2 raster_get_viewport(Camera* camera) { std::lock_guard lock(camera->_impl->CamMutex); return camera->Views.Raster; } -void ray_set_viewport(std::unique_ptr& camera, glm::ivec2 viewport) +void ray_set_viewport(Camera* camera, glm::ivec2 viewport) { std::lock_guard lock(camera->_impl->CamMutex); camera->Views.Ray = viewport; } -glm::ivec2 ray_get_viewport(std::unique_ptr& camera) +glm::ivec2 ray_get_viewport(Camera* camera) { std::lock_guard lock(camera->_impl->CamMutex); return camera->Views.Ray; } -void camera_move(std::unique_ptr& camera, uint8_t movement_delta) +void camera_move(Camera* camera, uint8_t movement_delta) { if (movement_delta == 0) return; @@ -181,7 +181,7 @@ void camera_move(std::unique_ptr& camera, uint8_t movement_delta) camera_update(camera); } -void camera_mouse_move(std::unique_ptr& camera, glm::vec2 mouse_delta) +void camera_mouse_move(Camera* camera, glm::vec2 mouse_delta) { if (glm::length(mouse_delta) == 0) return; @@ -194,13 +194,13 @@ void camera_mouse_move(std::unique_ptr& camera, glm::vec2 mouse_delta) camera_update(camera); } -void camera_set_position(std::unique_ptr& camera, glm::vec3 position) +void camera_set_position(Camera* camera, glm::vec3 position) { camera->Position = position; camera_update(camera); } -void camera_set_euler_look(std::unique_ptr& camera, float roll, float pitch, float yaw) +void camera_set_euler_look(Camera* camera, float roll, float pitch, float yaw) { camera->Roll = roll; camera->Pitch = pitch; @@ -212,7 +212,7 @@ void camera_set_euler_look(std::unique_ptr& camera, float roll, float pi camera_update(camera); } -void camera_set_look(std::unique_ptr& camera, glm::vec3 look_direction) +void camera_set_look(Camera* camera, glm::vec3 look_direction) { camera->LookDirection = look_direction; camera->Pitch = asin(-look_direction.y); diff --git a/src/scene/object.cpp b/src/scene/object.cpp index 3e83d37..25e8981 100644 --- a/src/scene/object.cpp +++ b/src/scene/object.cpp @@ -4,23 +4,23 @@ namespace inferno::scene { -std::unique_ptr scene_object_create() +SceneObject* scene_object_create() { - std::unique_ptr object = std::make_unique(); + SceneObject* object = new SceneObject; return object; } -void scene_object_cleanup(std::unique_ptr& object) +void scene_object_cleanup(SceneObject* object) { } -void scene_object_add_mesh(std::unique_ptr& object, Mesh* mesh) +void scene_object_add_mesh(SceneObject* object, Mesh* mesh) { object->Meshs.push_back(mesh); } -std::vector& scene_object_get_meshs(std::unique_ptr& object) +std::vector& scene_object_get_meshs(SceneObject* object) { return object->Meshs; } diff --git a/src/scene/object.hpp b/src/scene/object.hpp index ed0d2a3..973b868 100644 --- a/src/scene/object.hpp +++ b/src/scene/object.hpp @@ -11,10 +11,10 @@ typedef struct SceneObject { std::vector Meshs; } SceneObject; -std::unique_ptr scene_object_create(); -void scene_object_cleanup(std::unique_ptr& object); +SceneObject* scene_object_create(); +void scene_object_cleanup(SceneObject* object); -void scene_object_add_mesh(std::unique_ptr& object, Mesh* mesh); -std::vector& scene_object_get_meshs(std::unique_ptr& object); +void scene_object_add_mesh(SceneObject* object, Mesh* mesh); +std::vector& scene_object_get_meshs(SceneObject* object); } // namespace inferno::scene diff --git a/src/scene/scene.cpp b/src/scene/scene.cpp index 3da825f..50bb3a2 100644 --- a/src/scene/scene.cpp +++ b/src/scene/scene.cpp @@ -7,44 +7,44 @@ namespace inferno::scene { -std::unique_ptr scene_create() +Scene* scene_create() { - std::unique_ptr scene = std::make_unique(); - scene->Camera = std::make_unique(); + Scene* scene = new Scene; + scene->Camera = new graphics::Camera; return scene; } -void scene_cleanup(std::unique_ptr& scene) +void scene_cleanup(Scene* scene) { } -void scene_add_object(std::unique_ptr& scene, std::unique_ptr& object) +void scene_add_object(Scene* scene, SceneObject* object) { scene->Objects.emplace_back(std::move(object)); scene->DidUpdate = true; } -std::unique_ptr& scene_get_camera(std::unique_ptr& scene) +graphics::Camera* scene_get_camera(Scene* scene) { return scene->Camera; } -std::vector>& scene_get_renderables(std::unique_ptr& scene) +std::vector& scene_get_renderables(Scene* scene) { return scene->Objects; } -bool scene_did_update(std::unique_ptr& scene) +bool scene_did_update(Scene* scene) { return scene->DidUpdate; } -void scene_frame_tick(std::unique_ptr& scene) +void scene_frame_tick(Scene* scene) { scene->DidUpdate = false; } -void scene_tick(std::unique_ptr& scene) +void scene_tick(Scene* scene) { for (auto& object : scene->Objects) { // Shit here like animation idk diff --git a/src/scene/scene.hpp b/src/scene/scene.hpp index 686c321..6004da2 100644 --- a/src/scene/scene.hpp +++ b/src/scene/scene.hpp @@ -15,22 +15,22 @@ class SceneObject; class Mesh; typedef struct Scene { - std::unique_ptr Camera; - std::vector> Objects; + std::vector Objects; + graphics::Camera* Camera; bool DidUpdate = false; } Scene; -std::unique_ptr scene_create(); -void scene_cleanup(std::unique_ptr& scene); +Scene* scene_create(); +void scene_cleanup(Scene* scene); -void scene_add_object(std::unique_ptr& scene, std::unique_ptr& object); +void scene_add_object(Scene* scene, SceneObject* object); -std::unique_ptr& scene_get_camera(std::unique_ptr& scene); -std::vector>& scene_get_renderables(std::unique_ptr& scene); +graphics::Camera* scene_get_camera(Scene* scene); +std::vector& scene_get_renderables(Scene* scene); -bool scene_did_update(std::unique_ptr& scene); +bool scene_did_update(Scene* scene); -void scene_frame_tick(std::unique_ptr& scene); -void scene_tick(std::unique_ptr& scene); +void scene_frame_tick(Scene* scene); +void scene_tick(Scene* scene); } // namespace inferno::scene From c0ea84d90a9f2b34da53001ece6f8620f4d43b07 Mon Sep 17 00:00:00 2001 From: Ben Kyd Date: Tue, 3 Oct 2023 23:13:08 +0100 Subject: [PATCH 24/30] turms out :cdo isn't the best --- src/inferno.cpp | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/src/inferno.cpp b/src/inferno.cpp index cb67def..d9a35c6 100644 --- a/src/inferno.cpp +++ b/src/inferno.cpp @@ -22,12 +22,12 @@ namespace inferno { -std::unique_ptr inferno_create() +InfernoApp* inferno_create() { // MOTD yolo::info("INFERNO HART v" INFERNO_VERSION); - std::unique_ptr app = new InfernoApp; + InfernoApp* app = new InfernoApp; app->Input = new InfernoInput; // Create window @@ -36,11 +36,11 @@ std::unique_ptr inferno_create() // setup the scene scene::Material basicMaterial("basic"); - std::unique_ptr basicShader = graphics::shader_create(); + graphics::Shader* basicShader = graphics::shader_create(); graphics::shader_load(basicShader, "res/shaders/basic.glsl"); graphics::shader_link(basicShader); - std::unique_ptr object = scene::scene_object_create(); + scene::SceneObject* object = scene::scene_object_create(); scene::Mesh cornell; cornell.loadOBJ("res/cornell-box.obj"); @@ -54,7 +54,7 @@ std::unique_ptr inferno_create() return app; } -void inferno_cleanup(std::unique_ptr& app) +void inferno_cleanup(InfernoApp* app) { graphics::window_cleanup(); app.reset(); @@ -72,7 +72,7 @@ static void inferno_gui_help_marker(const char* desc) } } -void inferno_preset_gui(std::unique_ptr& app) +void inferno_preset_gui(InfernoApp* app) { ImGuiID dockspace_id = ImGui::GetID("main"); @@ -89,7 +89,7 @@ void inferno_preset_gui(std::unique_ptr& app) yolo::info("LAYOUT SET TO DEFAULT"); } -void inferno_move_input(std::unique_ptr& app) +void inferno_move_input(InfernoApp* app) { static GLFWcursor* cursor = glfwCreateStandardCursor(GLFW_HAND_CURSOR); glfwSetCursor(graphics::window_get_glfw_window(), cursor); @@ -128,13 +128,13 @@ void inferno_move_input(std::unique_ptr& app) app->Input->MovementDelta |= 0b00000100; } -void inferno_stop_move_input(std::unique_ptr& app) +void inferno_stop_move_input(InfernoApp* app) { app->Input->MovementDelta = 0x0; app->Input->MouseDelta = { 0.0f, 0.0f }; } -int inferno_run(std::unique_ptr& app) +int inferno_run(InfernoApp* app) { while (true) { if (!graphics::window_new_frame()) From 88921241f18c7a9e4e19b20badde290518c7cf31 Mon Sep 17 00:00:00 2001 From: Benjamin Kyd Date: Wed, 4 Oct 2023 13:09:24 +0100 Subject: [PATCH 25/30] past me is a dumbass --- libhart/scene/camera.hpp | 36 +++++++++++++++---------------- src/preview_renderer/renderer.cpp | 14 ++++++------ 2 files changed, 25 insertions(+), 25 deletions(-) diff --git a/libhart/scene/camera.hpp b/libhart/scene/camera.hpp index d756533..36bf152 100644 --- a/libhart/scene/camera.hpp +++ b/libhart/scene/camera.hpp @@ -33,33 +33,33 @@ typedef struct Camera { glm::vec3 Position = {}; glm::vec3 LookDirection = {}; - std::unique_ptr<_CameraImpl> _impl; + _CameraImpl* _impl; } Camera; -std::unique_ptr camera_create(); -void camera_cleanup(std::unique_ptr& camera); +Camera* camera_create(); +void camera_cleanup(Camera* camera); -void camera_update(std::unique_ptr& camera); -bool camera_did_update(std::unique_ptr& camera); -void camera_new_frame(std::unique_ptr& camera); +void camera_update(Camera* camera); +bool camera_did_update(Camera* camera); +void camera_new_frame(Camera* camera); -glm::mat4 camera_get_view(std::unique_ptr& camera); -glm::mat4 camera_get_projection(std::unique_ptr& camera); -glm::mat4 camera_get_look(std::unique_ptr& camera); +glm::mat4 camera_get_view(Camera* camera); +glm::mat4 camera_get_projection(Camera* camera); +glm::mat4 camera_get_look(Camera* camera); -void raster_set_viewport(std::unique_ptr& camera, glm::ivec2 viewport); -glm::ivec2 raster_get_viewport(std::unique_ptr& camera); +void raster_set_viewport(Camera* camera, glm::ivec2 viewport); +glm::ivec2 raster_get_viewport(Camera* camera); -void ray_set_viewport(std::unique_ptr& camera, glm::ivec2 viewport); -glm::ivec2 ray_get_viewport(std::unique_ptr& camera); +void ray_set_viewport(Camera* camera, glm::ivec2 viewport); +glm::ivec2 ray_get_viewport(Camera* camera); -void camera_move(std::unique_ptr& camera, uint8_t movement_delta); -void camera_mouse_move(std::unique_ptr& camera, glm::vec2 mouse_delta); +void camera_move(Camera* camera, uint8_t movement_delta); +void camera_mouse_move(Camera* camera, glm::vec2 mouse_delta); -void camera_set_position(std::unique_ptr& camera, glm::vec3 position); -void camera_set_euler_look(std::unique_ptr& camera, float roll, +void camera_set_position(Camera* camera, glm::vec3 position); +void camera_set_euler_look(Camera* camera, float roll, float pitch, float yaw); -void camera_set_look(std::unique_ptr& camera, +void camera_set_look(Camera* camera, glm::vec3 look_direction); } // namespace inferno::graphics diff --git a/src/preview_renderer/renderer.cpp b/src/preview_renderer/renderer.cpp index 8fb5e1f..e7e5aea 100644 --- a/src/preview_renderer/renderer.cpp +++ b/src/preview_renderer/renderer.cpp @@ -14,9 +14,9 @@ namespace inferno::graphics { -std::unique_ptr preview_create() +PreviewRenderer* preview_create() { - std::unique_ptr renderer = new PreviewRenderer; + PreviewRenderer* renderer = new PreviewRenderer; glGenFramebuffers(1, &renderer->RenderTarget); glBindFramebuffer(GL_FRAMEBUFFER, renderer->RenderTarget); @@ -47,21 +47,21 @@ std::unique_ptr preview_create() return renderer; } -void preview_cleanup(std::unique_ptr& renderer) +void preview_cleanup(PreviewRenderer* renderer) { } -void preview_set_viewport(std::unique_ptr& renderer, std::unique_ptr viewport) +void preview_set_viewport(PreviewRenderer* renderer, Viewport* viewport) { } -GLuint preview_get_rendered_texture(std::unique_ptr& renderer) +GLuint preview_get_rendered_texture(PreviewRenderer* renderer) { glBindFramebuffer(GL_FRAMEBUFFER, renderer->RenderTarget); return renderer->RenderTargetTexture; } -void preview_draw(std::unique_ptr& renderer, std::unique_ptr& scene) +void preview_draw(PreviewRenderer* renderer, scene::Scene* scene) { const glm::ivec2& viewport = graphics::raster_get_viewport(scene::scene_get_camera(scene)); glBindFramebuffer(GL_FRAMEBUFFER, renderer->RenderTarget); @@ -108,7 +108,7 @@ void preview_draw(std::unique_ptr& renderer, std::unique_ptr& o : scene::scene_get_renderables(scene)) { + for (scene::SceneObject* o : scene::scene_get_renderables(scene)) { for (scene::Mesh* m : scene::scene_object_get_meshs(o)) { glBindVertexArray(m->getVAO()); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m->getEBO()); From f272e33d4ee64259efa679891444b608d0395b6f Mon Sep 17 00:00:00 2001 From: Benjamin Kyd Date: Thu, 12 Oct 2023 16:18:58 +0100 Subject: [PATCH 26/30] it just segfaults and does nothing else git --- src/inferno.cpp | 141 ++++++++++++++++++++++--------------------- src/inferno.hpp | 4 +- src/scene/camera.cpp | 4 +- src/window.cpp | 4 ++ 4 files changed, 79 insertions(+), 74 deletions(-) diff --git a/src/inferno.cpp b/src/inferno.cpp index d9a35c6..c857780 100644 --- a/src/inferno.cpp +++ b/src/inferno.cpp @@ -57,7 +57,7 @@ InfernoApp* inferno_create() void inferno_cleanup(InfernoApp* app) { graphics::window_cleanup(); - app.reset(); + delete app; } static void inferno_gui_help_marker(const char* desc) @@ -140,78 +140,79 @@ int inferno_run(InfernoApp* app) if (!graphics::window_new_frame()) break; - // set the main window to the dockspace and then on the first launch set the preset - ImGuiID dockspace_id = ImGui::GetID("main"); - static ImGuiDockNodeFlags dockspace_flags = ImGuiDockNodeFlags_PassthruCentralNode; - if (ImGui::DockBuilderGetNode(dockspace_id) == NULL) { - inferno_preset_gui(app); - } - ImGui::DockSpace(dockspace_id, ImVec2(0.0f, 0.0f), dockspace_flags); + // // set the main window to the dockspace and then on the first launch set the preset + // ImGuiID dockspace_id = ImGui::GetID("main"); + // static ImGuiDockNodeFlags dockspace_flags = ImGuiDockNodeFlags_PassthruCentralNode; + // if (ImGui::DockBuilderGetNode(dockspace_id) == NULL) { + // inferno_preset_gui(app); + // } + // ImGui::DockSpace(dockspace_id, ImVec2(0.0f, 0.0f), dockspace_flags); + // + // yolo::debug("{} {} {}", app->Scene->Camera, app->Input, app->Input->MouseDelta.x); + // if (glm::length(app->Input->MouseDelta) > 0.0f) + // graphics::camera_mouse_move(app->Scene->Camera, app->Input->MouseDelta); + // if (app->Input->MovementDelta != 0b00000000) + // graphics::camera_move(app->Scene->Camera, app->Input->MovementDelta); - if (glm::length(app->Input->MouseDelta) > 0.0f) - graphics::camera_mouse_move(app->Scene->Camera, app->Input->MouseDelta); - if (app->Input->MovementDelta != 0b00000000) - graphics::camera_move(app->Scene->Camera, app->Input->MovementDelta); - - // Menu Bar - static bool showPreview = true; - static bool showRenderSettings = true; - static bool showDemoWindow = false; - if (ImGui::BeginMenuBar()) { - if (ImGui::BeginMenu("Menu")) { - ImGui::EndMenu(); - } - if (ImGui::BeginMenu("View")) { - ImGui::Checkbox("Show Preview", &showPreview); - ImGui::SameLine(); - inferno_gui_help_marker("Show the preview window"); - ImGui::Checkbox("Show Settings", &showRenderSettings); - ImGui::SameLine(); - inferno_gui_help_marker("Show the Inferno HART settings window"); - ImGui::Checkbox("Show Demo", &showDemoWindow); - - ImGui::EndMenu(); - } - ImGui::EndMenuBar(); - } - - if (showPreview && ImGui::Begin("Preview", nullptr, ImGuiWindowFlags_NoScrollbar)) { - if (ImGui::IsWindowHovered()) { - inferno_move_input(app); - } else { - inferno_stop_move_input(app); - } - - graphics::raster_set_viewport(scene::scene_get_camera(app->Scene), { ImGui::GetWindowSize().x, ImGui::GetWindowSize().y }); - graphics::preview_draw(app->PreviewRenderer, app->Scene); - - ImTextureID texture = (ImTextureID)graphics::preview_get_rendered_texture(app->PreviewRenderer); - ImGui::Image( - texture, - { ImGui::GetWindowSize().x, ImGui::GetWindowSize().y }, - ImVec2(0, 1), ImVec2(1, 0)); - - glBindFramebuffer(GL_FRAMEBUFFER, 0); - ImGui::End(); - } + // // Menu Bar + // static bool showPreview = true; + // static bool showRenderSettings = true; + // static bool showDemoWindow = false; + // if (ImGui::BeginMenuBar()) { + // if (ImGui::BeginMenu("Menu")) { + // ImGui::EndMenu(); + // } + // if (ImGui::BeginMenu("View")) { + // ImGui::Checkbox("Show Preview", &showPreview); + // ImGui::SameLine(); + // inferno_gui_help_marker("Show the preview window"); + // ImGui::Checkbox("Show Settings", &showRenderSettings); + // ImGui::SameLine(); + // inferno_gui_help_marker("Show the Inferno HART settings window"); + // ImGui::Checkbox("Show Demo", &showDemoWindow); + // + // ImGui::EndMenu(); + // } + // ImGui::EndMenuBar(); + // } + // + // if (showPreview && ImGui::Begin("Preview", nullptr, ImGuiWindowFlags_NoScrollbar)) { + // if (ImGui::IsWindowHovered()) { + // inferno_move_input(app); + // } else { + // inferno_stop_move_input(app); + // } + // + // graphics::raster_set_viewport(scene::scene_get_camera(app->Scene), { ImGui::GetWindowSize().x, ImGui::GetWindowSize().y }); + // graphics::preview_draw(app->PreviewRenderer, app->Scene); + // + // ImTextureID texture = (ImTextureID)graphics::preview_get_rendered_texture(app->PreviewRenderer); + // ImGui::Image( + // texture, + // { ImGui::GetWindowSize().x, ImGui::GetWindowSize().y }, + // ImVec2(0, 1), ImVec2(1, 0)); + // + // glBindFramebuffer(GL_FRAMEBUFFER, 0); + // ImGui::End(); + // } // clang-format off - GLenum err; - while((err = glGetError()) != GL_NO_ERROR) { - std::string error; - switch (err) { - case GL_INVALID_ENUM: error = "INVALID_ENUM"; break; - case GL_INVALID_VALUE: error = "INVALID_VALUE"; break; - case GL_INVALID_OPERATION: error = "INVALID_OPERATION"; break; - case GL_STACK_OVERFLOW: error = "STACK_OVERFLOW"; break; - case GL_STACK_UNDERFLOW: error = "STACK_UNDERFLOW"; break; - case GL_OUT_OF_MEMORY: error = "OUT_OF_MEMORY"; break; - case GL_INVALID_FRAMEBUFFER_OPERATION: error = "INVALID_FRAMEBUFFER_OPERATION"; break; - default: error = std::to_string((uint32_t)err); break; - } - yolo::error("[GL]: {} {}", err, error); - } - + // GLenum err; + // while((err = glGetError()) != GL_NO_ERROR) { + // std::string error; + // switch (err) { + // case GL_INVALID_ENUM: error = "INVALID_ENUM"; break; + // case GL_INVALID_VALUE: error = "INVALID_VALUE"; break; + // case GL_INVALID_OPERATION: error = "INVALID_OPERATION"; break; + // case GL_STACK_OVERFLOW: error = "STACK_OVERFLOW"; break; + // case GL_STACK_UNDERFLOW: error = "STACK_UNDERFLOW"; break; + // case GL_OUT_OF_MEMORY: error = "OUT_OF_MEMORY"; break; + // case GL_INVALID_FRAMEBUFFER_OPERATION: error = "INVALID_FRAMEBUFFER_OPERATION"; break; + // default: error = std::to_string((uint32_t)err); break; + // } + // yolo::error("[GL]: {} {}", err, error); + // } + // graphics::window_render(); } diff --git a/src/inferno.hpp b/src/inferno.hpp index d74b59a..5d895bf 100644 --- a/src/inferno.hpp +++ b/src/inferno.hpp @@ -19,8 +19,8 @@ namespace scene { } typedef struct InfernoInput { - glm::vec2 MouseDelta; - uint8_t MovementDelta; + glm::vec2 MouseDelta = {0.0f, 0.0f}; + uint8_t MovementDelta = 0; } InfernoInput; typedef struct InfernoApp { diff --git a/src/scene/camera.cpp b/src/scene/camera.cpp index 4f77f37..9e6b380 100644 --- a/src/scene/camera.cpp +++ b/src/scene/camera.cpp @@ -31,8 +31,8 @@ Camera* camera_create() void camera_cleanup(Camera* camera) { - camera->_impl.reset(); - camera.reset(); + delete camera->_impl; + delete camera; } void camera_update(Camera* camera) diff --git a/src/window.cpp b/src/window.cpp index 41758e5..fd99e83 100644 --- a/src/window.cpp +++ b/src/window.cpp @@ -60,6 +60,10 @@ void setupGLFW(std::string title) glfwMakeContextCurrent(Window); gladLoadGLLoader((GLADloadproc)glfwGetProcAddress); glfwSwapInterval(1); // Enable vsync + yolo::info("GLFW {} initialized", glfwGetVersionString()); + yolo::info("OpenGL {} initialized", glGetString(GL_VERSION)); + yolo::info("GLSL {} initialized", glGetString(GL_SHADING_LANGUAGE_VERSION)); + yolo::info("INFERNO HART Running on ", glGetString(GL_RENDERER)); } void setupImGui() From 3dcea96b94254a7be28118f52f6e24494b7212f8 Mon Sep 17 00:00:00 2001 From: Ben Kyd Date: Fri, 13 Oct 2023 21:52:35 +0100 Subject: [PATCH 27/30] that just fixed it's self ? --- src/inferno.cpp | 36 ++++++++++++++++++------------------ 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/src/inferno.cpp b/src/inferno.cpp index c857780..d07c2c3 100644 --- a/src/inferno.cpp +++ b/src/inferno.cpp @@ -33,24 +33,24 @@ InfernoApp* inferno_create() // Create window graphics::window_create("Inferno v" INFERNO_VERSION, 1280, 720); - // setup the scene - scene::Material basicMaterial("basic"); - - graphics::Shader* basicShader = graphics::shader_create(); - graphics::shader_load(basicShader, "res/shaders/basic.glsl"); - graphics::shader_link(basicShader); - - scene::SceneObject* object = scene::scene_object_create(); - - scene::Mesh cornell; - cornell.loadOBJ("res/cornell-box.obj"); - // cornell.loadOBJ("res/sponza.obj"); - cornell.ready(); - cornell.setMaterial(&basicMaterial); - - scene::scene_object_add_mesh(object, &cornell); - scene::scene_add_object(app->Scene, object); - + // // setup the scene + // scene::Material basicMaterial("basic"); + // + // graphics::Shader* basicShader = graphics::shader_create(); + // graphics::shader_load(basicShader, "res/shaders/basic.glsl"); + // graphics::shader_link(basicShader); + // + // scene::SceneObject* object = scene::scene_object_create(); + // + // scene::Mesh cornell; + // cornell.loadOBJ("res/cornell-box.obj"); + // // cornell.loadOBJ("res/sponza.obj"); + // cornell.ready(); + // cornell.setMaterial(&basicMaterial); + // + // scene::scene_object_add_mesh(object, &cornell); + // scene::scene_add_object(app->Scene, object); + // return app; } From 6d80f1e4e258d69eb2e47c9bd46e0697bfe17aec Mon Sep 17 00:00:00 2001 From: Ben Kyd Date: Sat, 14 Oct 2023 13:36:34 +0100 Subject: [PATCH 28/30] when you pass a null ptr, the ptr is null?! who'd a thought --- CMakeLists.txt | 3 ++- src/inferno.cpp | 37 +++++++++++++++++++------------------ src/scene/scene.cpp | 8 +++++++- 3 files changed, 28 insertions(+), 20 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 4b5363a..33edf86 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -25,7 +25,8 @@ elseif (APPLE) target_compile_options(inferno PRIVATE -O1) endif() else() - target_compile_options(inferno PRIVATE -std=c++17) + target_compile_options(inferno PRIVATE -std=c++20) + target_compile_options(inferno PRIVATE -m64) if (CMAKE_BUILD_TYPE MATCHES "Debug") target_compile_options(inferno PRIVATE -O1) target_compile_options(inferno PRIVATE -Wall) diff --git a/src/inferno.cpp b/src/inferno.cpp index d07c2c3..a08349a 100644 --- a/src/inferno.cpp +++ b/src/inferno.cpp @@ -33,24 +33,25 @@ InfernoApp* inferno_create() // Create window graphics::window_create("Inferno v" INFERNO_VERSION, 1280, 720); - // // setup the scene - // scene::Material basicMaterial("basic"); - // - // graphics::Shader* basicShader = graphics::shader_create(); - // graphics::shader_load(basicShader, "res/shaders/basic.glsl"); - // graphics::shader_link(basicShader); - // - // scene::SceneObject* object = scene::scene_object_create(); - // - // scene::Mesh cornell; - // cornell.loadOBJ("res/cornell-box.obj"); - // // cornell.loadOBJ("res/sponza.obj"); - // cornell.ready(); - // cornell.setMaterial(&basicMaterial); - // - // scene::scene_object_add_mesh(object, &cornell); - // scene::scene_add_object(app->Scene, object); - // + // setup the scene + scene::Material basicMaterial("basic"); + graphics::Shader* basicShader = graphics::shader_create(); + graphics::shader_load(basicShader, "res/shaders/basic.glsl"); + graphics::shader_link(basicShader); + + app->Scene = scene::scene_create(); + scene::SceneObject* object = scene::scene_object_create(); + + scene::Mesh cornell; + cornell.loadOBJ("res/cornell-box.obj"); + // cornell.loadOBJ("res/sponza.obj"); + cornell.ready(); + cornell.setMaterial(&basicMaterial); + scene::scene_object_add_mesh(object, &cornell); + + yolo::info("{} {}", app->Scene, object); + scene::scene_add_object(app->Scene, object); + return app; } diff --git a/src/scene/scene.cpp b/src/scene/scene.cpp index 50bb3a2..843d0d2 100644 --- a/src/scene/scene.cpp +++ b/src/scene/scene.cpp @@ -1,5 +1,7 @@ #include "scene.hpp" +#include + #include #include #include @@ -10,7 +12,9 @@ namespace inferno::scene { Scene* scene_create() { Scene* scene = new Scene; + scene->Objects = std::vector(); scene->Camera = new graphics::Camera; + yolo::debug("Created scene {}", scene); return scene; } @@ -20,7 +24,9 @@ void scene_cleanup(Scene* scene) void scene_add_object(Scene* scene, SceneObject* object) { - scene->Objects.emplace_back(std::move(object)); + yolo::debug("Using scene {}", scene); + yolo::debug("Adding object to scene, no Objects: {}, adding to pool of: {}", object->Meshs.size(), scene->Objects.size()); + scene->Objects.push_back(object); scene->DidUpdate = true; } From 163d784f5fcd4a11477b329bd9c815943267fe10 Mon Sep 17 00:00:00 2001 From: Ben Kyd Date: Sat, 14 Oct 2023 22:10:36 +0100 Subject: [PATCH 29/30] for some reason the face count is uninitialised --- src/inferno.cpp | 161 +++++++++++++++--------------- src/preview_renderer/renderer.cpp | 7 +- src/scene/objloader.cpp | 23 +++-- src/scene/scene.cpp | 4 +- 4 files changed, 101 insertions(+), 94 deletions(-) diff --git a/src/inferno.cpp b/src/inferno.cpp index a08349a..31127e7 100644 --- a/src/inferno.cpp +++ b/src/inferno.cpp @@ -8,10 +8,10 @@ #include "preview_renderer/renderer.hpp" #include "preview_renderer/shader.hpp" -#include "scene/scene.hpp" #include "scene/camera.hpp" #include "scene/material.hpp" #include "scene/mesh.hpp" +#include "scene/scene.hpp" #include @@ -29,6 +29,7 @@ InfernoApp* inferno_create() InfernoApp* app = new InfernoApp; app->Input = new InfernoInput; + app->Scene = scene::scene_create(); // Create window graphics::window_create("Inferno v" INFERNO_VERSION, 1280, 720); @@ -39,19 +40,19 @@ InfernoApp* inferno_create() graphics::shader_load(basicShader, "res/shaders/basic.glsl"); graphics::shader_link(basicShader); - app->Scene = scene::scene_create(); + scene::Mesh mesh; + mesh.loadOBJ("res/cornell-box.obj"); + // mesh.loadOBJ("res/sponza.obj"); + mesh.ready(); + mesh.setMaterial(&basicMaterial); + scene::SceneObject* object = scene::scene_object_create(); + scene::scene_object_add_mesh(object, &mesh); - scene::Mesh cornell; - cornell.loadOBJ("res/cornell-box.obj"); - // cornell.loadOBJ("res/sponza.obj"); - cornell.ready(); - cornell.setMaterial(&basicMaterial); - scene::scene_object_add_mesh(object, &cornell); - - yolo::info("{} {}", app->Scene, object); scene::scene_add_object(app->Scene, object); + app->PreviewRenderer = graphics::preview_create(); + return app; } @@ -141,79 +142,79 @@ int inferno_run(InfernoApp* app) if (!graphics::window_new_frame()) break; - // // set the main window to the dockspace and then on the first launch set the preset - // ImGuiID dockspace_id = ImGui::GetID("main"); - // static ImGuiDockNodeFlags dockspace_flags = ImGuiDockNodeFlags_PassthruCentralNode; - // if (ImGui::DockBuilderGetNode(dockspace_id) == NULL) { - // inferno_preset_gui(app); - // } - // ImGui::DockSpace(dockspace_id, ImVec2(0.0f, 0.0f), dockspace_flags); - // - // yolo::debug("{} {} {}", app->Scene->Camera, app->Input, app->Input->MouseDelta.x); - // if (glm::length(app->Input->MouseDelta) > 0.0f) - // graphics::camera_mouse_move(app->Scene->Camera, app->Input->MouseDelta); - // if (app->Input->MovementDelta != 0b00000000) - // graphics::camera_move(app->Scene->Camera, app->Input->MovementDelta); + // set the main window to the dockspace and then on the first launch set the preset + ImGuiID dockspace_id = ImGui::GetID("main"); + static ImGuiDockNodeFlags dockspace_flags = ImGuiDockNodeFlags_PassthruCentralNode; + if (ImGui::DockBuilderGetNode(dockspace_id) == NULL) { + inferno_preset_gui(app); + } + ImGui::DockSpace(dockspace_id, ImVec2(0.0f, 0.0f), dockspace_flags); - // // Menu Bar - // static bool showPreview = true; - // static bool showRenderSettings = true; - // static bool showDemoWindow = false; - // if (ImGui::BeginMenuBar()) { - // if (ImGui::BeginMenu("Menu")) { - // ImGui::EndMenu(); - // } - // if (ImGui::BeginMenu("View")) { - // ImGui::Checkbox("Show Preview", &showPreview); - // ImGui::SameLine(); - // inferno_gui_help_marker("Show the preview window"); - // ImGui::Checkbox("Show Settings", &showRenderSettings); - // ImGui::SameLine(); - // inferno_gui_help_marker("Show the Inferno HART settings window"); - // ImGui::Checkbox("Show Demo", &showDemoWindow); - // - // ImGui::EndMenu(); - // } - // ImGui::EndMenuBar(); - // } - // - // if (showPreview && ImGui::Begin("Preview", nullptr, ImGuiWindowFlags_NoScrollbar)) { - // if (ImGui::IsWindowHovered()) { - // inferno_move_input(app); - // } else { - // inferno_stop_move_input(app); - // } - // - // graphics::raster_set_viewport(scene::scene_get_camera(app->Scene), { ImGui::GetWindowSize().x, ImGui::GetWindowSize().y }); - // graphics::preview_draw(app->PreviewRenderer, app->Scene); - // - // ImTextureID texture = (ImTextureID)graphics::preview_get_rendered_texture(app->PreviewRenderer); - // ImGui::Image( - // texture, - // { ImGui::GetWindowSize().x, ImGui::GetWindowSize().y }, - // ImVec2(0, 1), ImVec2(1, 0)); - // - // glBindFramebuffer(GL_FRAMEBUFFER, 0); - // ImGui::End(); - // } + if (glm::length(app->Input->MouseDelta) > 0.0f) + graphics::camera_mouse_move(app->Scene->Camera, app->Input->MouseDelta); + if (app->Input->MovementDelta != 0b00000000) + graphics::camera_move(app->Scene->Camera, app->Input->MovementDelta); + + // Menu Bar + static bool showPreview = true; + static bool showRenderSettings = true; + static bool showDemoWindow = false; + if (ImGui::BeginMenuBar()) { + if (ImGui::BeginMenu("Menu")) { + ImGui::EndMenu(); + } + if (ImGui::BeginMenu("View")) { + ImGui::Checkbox("Show Preview", &showPreview); + ImGui::SameLine(); + inferno_gui_help_marker("Show the preview window"); + ImGui::Checkbox("Show Settings", &showRenderSettings); + ImGui::SameLine(); + inferno_gui_help_marker("Show the Inferno HART settings window"); + ImGui::Checkbox("Show Demo", &showDemoWindow); + + ImGui::EndMenu(); + } + ImGui::EndMenuBar(); + } + + if (showPreview && ImGui::Begin("Preview", nullptr, ImGuiWindowFlags_NoScrollbar)) { + if (ImGui::IsWindowHovered()) { + inferno_move_input(app); + } else { + inferno_stop_move_input(app); + } + + graphics::raster_set_viewport(scene::scene_get_camera(app->Scene), + { ImGui::GetWindowSize().x, ImGui::GetWindowSize().y }); + graphics::preview_draw(app->PreviewRenderer, app->Scene); + + ImTextureID texture = (ImTextureID)graphics::preview_get_rendered_texture(app->PreviewRenderer); + ImGui::Image( + texture, + { ImGui::GetWindowSize().x, ImGui::GetWindowSize().y }, + ImVec2(0, 1), ImVec2(1, 0)); + + glBindFramebuffer(GL_FRAMEBUFFER, 0); + ImGui::End(); + } // clang-format off - // GLenum err; - // while((err = glGetError()) != GL_NO_ERROR) { - // std::string error; - // switch (err) { - // case GL_INVALID_ENUM: error = "INVALID_ENUM"; break; - // case GL_INVALID_VALUE: error = "INVALID_VALUE"; break; - // case GL_INVALID_OPERATION: error = "INVALID_OPERATION"; break; - // case GL_STACK_OVERFLOW: error = "STACK_OVERFLOW"; break; - // case GL_STACK_UNDERFLOW: error = "STACK_UNDERFLOW"; break; - // case GL_OUT_OF_MEMORY: error = "OUT_OF_MEMORY"; break; - // case GL_INVALID_FRAMEBUFFER_OPERATION: error = "INVALID_FRAMEBUFFER_OPERATION"; break; - // default: error = std::to_string((uint32_t)err); break; - // } - // yolo::error("[GL]: {} {}", err, error); - // } - // + GLenum err; + while((err = glGetError()) != GL_NO_ERROR) { + std::string error; + switch (err) { + case GL_INVALID_ENUM: error = "INVALID_ENUM"; break; + case GL_INVALID_VALUE: error = "INVALID_VALUE"; break; + case GL_INVALID_OPERATION: error = "INVALID_OPERATION"; break; + case GL_STACK_OVERFLOW: error = "STACK_OVERFLOW"; break; + case GL_STACK_UNDERFLOW: error = "STACK_UNDERFLOW"; break; + case GL_OUT_OF_MEMORY: error = "OUT_OF_MEMORY"; break; + case GL_INVALID_FRAMEBUFFER_OPERATION: error = "INVALID_FRAMEBUFFER_OPERATION"; break; + default: error = std::to_string((uint32_t)err); break; + } + yolo::error("[GL]: {} {}", err, error); + } + graphics::window_render(); } diff --git a/src/preview_renderer/renderer.cpp b/src/preview_renderer/renderer.cpp index e7e5aea..d58827c 100644 --- a/src/preview_renderer/renderer.cpp +++ b/src/preview_renderer/renderer.cpp @@ -3,6 +3,8 @@ #include "scene/object.hpp" #include "shader.hpp" +#include + #include #include #include @@ -109,12 +111,15 @@ void preview_draw(PreviewRenderer* renderer, scene::Scene* scene) glEnable(GL_DEPTH_TEST); for (scene::SceneObject* o : scene::scene_get_renderables(scene)) { + yolo::info("Rendering object: {}", o); for (scene::Mesh* m : scene::scene_object_get_meshs(o)) { + yolo::info("Rendering mesh: {}", m); + yolo::debug("Mesh VAO: {}, EBO: {}, Indicies: {}", m->getVAO(), m->getEBO(), m->getIndexCount()); + glBindVertexArray(m->getVAO()); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m->getEBO()); glDrawElements(GL_TRIANGLES, m->getIndexCount() * sizeof(uint32_t), GL_UNSIGNED_INT, 0); - } } diff --git a/src/scene/objloader.cpp b/src/scene/objloader.cpp index 873659d..5074ca2 100644 --- a/src/scene/objloader.cpp +++ b/src/scene/objloader.cpp @@ -60,7 +60,7 @@ void ObjLoader::load(std::filesystem::path file) std::ifstream inf; inf.open(file.c_str(), std::ios_base::in); - if (!inf.is_open()) + if (!inf.is_open()) { yolo::error("Failed to open OBJ file ", file.string()); return; @@ -82,7 +82,7 @@ void ObjLoader::load(std::filesystem::path file) std::map uniqueverts; unsigned int vert_count = 0; - while (inf.good()) + while (inf.good()) { memset( (void*)line, 0, CHARACTER_COUNT); inf.getline(line, CHARACTER_COUNT); @@ -94,7 +94,7 @@ void ObjLoader::load(std::filesystem::path file) // verts look like: // v float float float - if (strcmp(token, "v") == 0) + if (strcmp(token, "v") == 0) { float x=0, y=0, z=0, w=1; sscanf(line+2, "%f %f %f %f", &x, &y, &z, &w); @@ -110,7 +110,7 @@ void ObjLoader::load(std::filesystem::path file) } // texcoords: // vt float float - else if (strcmp(token, "vt") == 0) + else if (strcmp(token, "vt") == 0) { float x=0, y=0, z=0; sscanf(line+3, "%f %f %f", &x, &y, &z); @@ -119,14 +119,14 @@ void ObjLoader::load(std::filesystem::path file) // keep track of smoothing groups // s [number|off] - else if (strcmp(token, "s") == 0) + else if (strcmp(token, "s") == 0) { } // faces start with: // f - else if (strcmp(token, "f") == 0) + else if (strcmp(token, "f") == 0) { std::vector vindices; @@ -164,7 +164,7 @@ void ObjLoader::load(std::filesystem::path file) // being that some exporters can export either 3 or 4 sided polygon's // convert what ever was exported into triangles - for (size_t i=1; i::iterator iter; - for (iter = uniqueverts.begin(); iter != uniqueverts.end(); ++iter) + for (iter = uniqueverts.begin(); iter != uniqueverts.end(); ++iter) { mPositions[iter->second] = verts[iter->first.vert]; - if ( norms.size() > 0 ) + if ( norms.size() > 0 ) { mNormals[iter->second] = norms[iter->first.norm]; } - if ( texcoords.size() > 0) + if ( texcoords.size() > 0) { mTexCoords[iter->second] = texcoords[iter->first.coord]; } - } + } } int ObjLoader::getIndexCount() { + yolo::debug("Face count: {}", mFaces.size()); return (int)mFaces.size() * 3; } diff --git a/src/scene/scene.cpp b/src/scene/scene.cpp index 843d0d2..32e9c6c 100644 --- a/src/scene/scene.cpp +++ b/src/scene/scene.cpp @@ -13,8 +13,8 @@ Scene* scene_create() { Scene* scene = new Scene; scene->Objects = std::vector(); - scene->Camera = new graphics::Camera; - yolo::debug("Created scene {}", scene); + scene->Camera = graphics::camera_create(); + yolo::debug("Created scene {} and camera {}", scene, scene->Camera); return scene; } From 6ffb9a595516bf3b7ea84453246a3de38644544d Mon Sep 17 00:00:00 2001 From: Benjamin Kyd Date: Mon, 16 Oct 2023 11:43:46 +0100 Subject: [PATCH 30/30] preview renderer working, FINALLY --- libhart/scene/camera.hpp | 2 + src/inferno.cpp | 72 ++++++++++++++++++++++++++++--- src/preview_renderer/renderer.cpp | 21 ++++++--- src/preview_renderer/shader.cpp | 5 +++ src/preview_renderer/shader.hpp | 3 ++ src/scene/camera.cpp | 5 +++ src/scene/material.cpp | 18 ++++---- src/scene/material.hpp | 11 +++-- src/scene/mesh.hpp | 1 - src/scene/objloader.cpp | 1 - src/scene/scene.cpp | 1 + 11 files changed, 113 insertions(+), 27 deletions(-) diff --git a/libhart/scene/camera.hpp b/libhart/scene/camera.hpp index 36bf152..83e3267 100644 --- a/libhart/scene/camera.hpp +++ b/libhart/scene/camera.hpp @@ -62,4 +62,6 @@ void camera_set_euler_look(Camera* camera, float roll, void camera_set_look(Camera* camera, glm::vec3 look_direction); +glm::vec3 camera_get_position(Camera* camera); + } // namespace inferno::graphics diff --git a/src/inferno.cpp b/src/inferno.cpp index 31127e7..e16e0e3 100644 --- a/src/inferno.cpp +++ b/src/inferno.cpp @@ -35,19 +35,20 @@ InfernoApp* inferno_create() graphics::window_create("Inferno v" INFERNO_VERSION, 1280, 720); // setup the scene - scene::Material basicMaterial("basic"); + scene::Material* basicMaterial = new scene::Material("basic"); graphics::Shader* basicShader = graphics::shader_create(); graphics::shader_load(basicShader, "res/shaders/basic.glsl"); graphics::shader_link(basicShader); + basicMaterial->setGlShader(basicShader); - scene::Mesh mesh; - mesh.loadOBJ("res/cornell-box.obj"); - // mesh.loadOBJ("res/sponza.obj"); - mesh.ready(); - mesh.setMaterial(&basicMaterial); + scene::Mesh* mesh = new scene::Mesh; + // mesh->loadOBJ("res/cornell-box.obj"); + mesh->loadOBJ("res/sponza.obj"); + mesh->ready(); + mesh->setMaterial(basicMaterial); scene::SceneObject* object = scene::scene_object_create(); - scene::scene_object_add_mesh(object, &mesh); + scene::scene_object_add_mesh(object, mesh); scene::scene_add_object(app->Scene, object); @@ -198,6 +199,63 @@ int inferno_run(InfernoApp* app) ImGui::End(); } + if (showRenderSettings && ImGui::Begin("Inferno HART")) { + if (ImGui::TreeNode("Camera")) { + ImGui::PushItemWidth(100); + ImGui::Text("Camera Position X,Y,Z"); + + graphics::Camera* camera = scene::scene_get_camera(app->Scene); + + bool positionUpdated = false; + ImGui::DragFloat("X", &camera->Position.x, 0.01f, -FLT_MAX, FLT_MAX, "%.2f", ImGuiSliderFlags_None); + ImGui::SameLine(); + if (ImGui::IsItemEdited()) + positionUpdated = true; + ImGui::DragFloat("Y", &camera->Position.y, 0.01f, -FLT_MAX, FLT_MAX, "%.2f", ImGuiSliderFlags_None); + ImGui::SameLine(); + if (ImGui::IsItemEdited()) + positionUpdated = true; + ImGui::DragFloat("Z", &camera->Position.z, 0.01f, -FLT_MAX, FLT_MAX, "%.2f", ImGuiSliderFlags_None); + if (ImGui::IsItemEdited()) + positionUpdated = true; + if (positionUpdated) + graphics::camera_set_position(camera, graphics::camera_get_position(camera)); + + bool viewUpdated = false; + ImGui::Text("Camera Look Yaw, Pitch, Roll"); + ImGui::DragFloat("Yaw", &camera->Yaw, 0.01f, -FLT_MAX, FLT_MAX, "%.2f", ImGuiSliderFlags_None); + ImGui::SameLine(); + if (ImGui::IsItemEdited()) + viewUpdated = true; + ImGui::DragFloat("Pitch", &camera->Pitch, 0.01f, -FLT_MAX, FLT_MAX, "%.2f", ImGuiSliderFlags_None); + ImGui::SameLine(); + if (ImGui::IsItemEdited()) + viewUpdated = true; + ImGui::DragFloat("Roll", &camera->Roll, 0.01f, -FLT_MAX, FLT_MAX, "%.2f", ImGuiSliderFlags_None); + if (ImGui::IsItemEdited()) + viewUpdated = true; + + ImGui::PopItemWidth(); + ImGui::PushItemWidth(300); + + ImGui::Text("Camera Zoom"); + ImGui::DragFloat("Zoom", &camera->FOV, -0.1f, 0.01f, 180.0f, "%.2f", ImGuiSliderFlags_None); + ImGui::SameLine(); + if (ImGui::IsItemEdited()) + viewUpdated = true; + if (viewUpdated) + graphics::camera_update(camera); + + ImGui::PopItemWidth(); + ImGui::TreePop(); + } + ImGui::End(); + } + + if (showDemoWindow) { + ImGui::ShowDemoWindow(); + } + // clang-format off GLenum err; while((err = glGetError()) != GL_NO_ERROR) { diff --git a/src/preview_renderer/renderer.cpp b/src/preview_renderer/renderer.cpp index d58827c..0036a97 100644 --- a/src/preview_renderer/renderer.cpp +++ b/src/preview_renderer/renderer.cpp @@ -8,9 +8,9 @@ #include #include #include -#include -#include #include +#include +#include #include @@ -111,10 +111,21 @@ void preview_draw(PreviewRenderer* renderer, scene::Scene* scene) glEnable(GL_DEPTH_TEST); for (scene::SceneObject* o : scene::scene_get_renderables(scene)) { - yolo::info("Rendering object: {}", o); for (scene::Mesh* m : scene::scene_object_get_meshs(o)) { - yolo::info("Rendering mesh: {}", m); - yolo::debug("Mesh VAO: {}, EBO: {}, Indicies: {}", m->getVAO(), m->getEBO(), m->getIndexCount()); + graphics::Shader* shader = m->getMaterial()->getGlShader(); + graphics::shader_use(shader); + + auto viewMatrix = graphics::camera_get_view(scene::scene_get_camera(scene)); + auto projMatrix = graphics::camera_get_projection(scene::scene_get_camera(scene)); + + GLint uniTrans = glGetUniformLocation(graphics::shader_get_program(shader), "model"); + glUniformMatrix4fv(uniTrans, 1, GL_FALSE, glm::value_ptr(glm::mat4(1.0f))); + + GLint uniView = glGetUniformLocation(graphics::shader_get_program(shader), "view"); + glUniformMatrix4fv(uniView, 1, GL_FALSE, glm::value_ptr(viewMatrix)); + + GLint uniProj = glGetUniformLocation(graphics::shader_get_program(shader), "proj"); + glUniformMatrix4fv(uniProj, 1, GL_FALSE, glm::value_ptr(projMatrix)); glBindVertexArray(m->getVAO()); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m->getEBO()); diff --git a/src/preview_renderer/shader.cpp b/src/preview_renderer/shader.cpp index 551b93f..e085ff2 100644 --- a/src/preview_renderer/shader.cpp +++ b/src/preview_renderer/shader.cpp @@ -150,6 +150,11 @@ void shader_link(Shader* shader) glLinkProgram(shader->Program); } +GLuint shader_get_program(Shader* shader) +{ + return shader->Program; +} + void shader_add_attribute(Shader* shader, const std::string& attribute) { shader->Attributes[attribute] = glGetAttribLocation(shader->Program, attribute.c_str()); diff --git a/src/preview_renderer/shader.hpp b/src/preview_renderer/shader.hpp index 977734d..ae8a56f 100644 --- a/src/preview_renderer/shader.hpp +++ b/src/preview_renderer/shader.hpp @@ -29,6 +29,9 @@ void shader_cleanup(Shader* shader); void shader_load(Shader* shader, std::filesystem::path path); void shader_link(Shader* shader); + +GLuint shader_get_program(Shader* shader); + // TODO: Implement shader_reload void shader_add_attribute(Shader* shader, const std::string& attribute); void shader_add_uniform(Shader* shader, const std::string& uniform); diff --git a/src/scene/camera.cpp b/src/scene/camera.cpp index 9e6b380..90c30b3 100644 --- a/src/scene/camera.cpp +++ b/src/scene/camera.cpp @@ -221,4 +221,9 @@ void camera_set_look(Camera* camera, glm::vec3 look_direction) camera_update(camera); } +glm::vec3 camera_get_position(Camera* camera) +{ + return camera->Position; +} + } diff --git a/src/scene/material.cpp b/src/scene/material.cpp index e429162..6d21036 100644 --- a/src/scene/material.cpp +++ b/src/scene/material.cpp @@ -15,13 +15,13 @@ Material::~Material() } -//void Material::setGlShader(Shader* shader) -//{ - //mGlShader = shader; -//} - -//Shader* Material::getGlShader() -//{ - //return mGlShader; -//} +void Material::setGlShader(graphics::Shader* shader) +{ + mGlShader = shader; +} + +graphics::Shader* Material::getGlShader() +{ + return mGlShader; +} } diff --git a/src/scene/material.hpp b/src/scene/material.hpp index 6c92e85..ed70756 100644 --- a/src/scene/material.hpp +++ b/src/scene/material.hpp @@ -4,9 +4,12 @@ #include +namespace inferno::graphics { + class Shader; +}; + namespace inferno::scene { -//class Shader; class HitInfo; class Material { @@ -15,14 +18,14 @@ public: ~Material(); std::string getName(); - //void setGlShader(Shader* shader); - //Shader* getGlShader(); + void setGlShader(graphics::Shader* shader); + graphics::Shader* getGlShader(); glm::vec3 sample(HitInfo* hit); private: std::string mName; - //Shader* mGlShader; + graphics::Shader* mGlShader; }; } diff --git a/src/scene/mesh.hpp b/src/scene/mesh.hpp index de53991..fc585b2 100644 --- a/src/scene/mesh.hpp +++ b/src/scene/mesh.hpp @@ -1,5 +1,4 @@ #pragma once - #include #include diff --git a/src/scene/objloader.cpp b/src/scene/objloader.cpp index 5074ca2..7f0cec5 100644 --- a/src/scene/objloader.cpp +++ b/src/scene/objloader.cpp @@ -230,7 +230,6 @@ void ObjLoader::load(std::filesystem::path file) int ObjLoader::getIndexCount() { - yolo::debug("Face count: {}", mFaces.size()); return (int)mFaces.size() * 3; } diff --git a/src/scene/scene.cpp b/src/scene/scene.cpp index 32e9c6c..d518bd1 100644 --- a/src/scene/scene.cpp +++ b/src/scene/scene.cpp @@ -26,6 +26,7 @@ void scene_add_object(Scene* scene, SceneObject* object) { yolo::debug("Using scene {}", scene); yolo::debug("Adding object to scene, no Objects: {}, adding to pool of: {}", object->Meshs.size(), scene->Objects.size()); + yolo::debug("Object Mesh 0 is {}", object->Meshs[0]); scene->Objects.push_back(object); scene->DidUpdate = true; }