From 298fe984e3fedf804a5fdb9a84f374fcbc08afa9 Mon Sep 17 00:00:00 2001 From: Benjamin Kyd Date: Thu, 28 Sep 2023 13:29:39 +0100 Subject: [PATCH 01/13] 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 02/13] 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 03/13] 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 04/13] 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 05/13] 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 06/13] 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 07/13] 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 08/13] 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 09/13] 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 10/13] 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 11/13] 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 12/13] 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 13/13] 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; }