benkyd/inferno-hart
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #1 from benkyd/rewrite

Browse Source 
Rewrite complete
This commit is contained in:
Benjamin Kyd
2023-10-16 11:51:00 +01:00
committed by GitHub
parent 923ff2fb65 6ffb9a5955
commit 874085bb81
32 changed files with 662 additions and 1011 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
CMakeLists.txt
View File

@@ -25,7 +25,8 @@ elseif (APPLE)
target_compile_options(inferno PRIVATE -O1) target_compile_options(inferno PRIVATE -O1)
endif() endif()
else() 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") if (CMAKE_BUILD_TYPE MATCHES "Debug")
target_compile_options(inferno PRIVATE -O1) target_compile_options(inferno PRIVATE -O1)
target_compile_options(inferno PRIVATE -Wall) target_compile_options(inferno PRIVATE -Wall)

45
libhart/scene/camera.hpp
View File

@@ -8,7 +8,10 @@
namespace inferno::graphics { namespace inferno::graphics {
struct _CameraImpl; typedef struct _CameraImpl {
bool DidUpdate;
std::mutex CamMutex;
} _CameraImpl;
typedef struct Viewport { typedef struct Viewport {
glm::ivec2 Raster; glm::ivec2 Raster;
@@ -20,7 +23,7 @@ typedef struct Camera {
glm::mat4 ProjectionMatrix; glm::mat4 ProjectionMatrix;
glm::mat4 LookMatrix; glm::mat4 LookMatrix;
std::shared_ptr<Viewport> Views; Viewport Views;
float MouseSensitivity = 0.4f; float MouseSensitivity = 0.4f;
float Speed = 0.1f; float Speed = 0.1f;
@@ -30,33 +33,35 @@ typedef struct Camera {
glm::vec3 Position = {}; glm::vec3 Position = {};
glm::vec3 LookDirection = {}; glm::vec3 LookDirection = {};
std::unique_ptr<_CameraImpl> _impl; _CameraImpl* _impl;
} Camera; } Camera;
std::unique_ptr<Camera> camera_create(); Camera* camera_create();
void camera_cleanup(std::unique_ptr<Camera>& camera); void camera_cleanup(Camera* camera);
void camera_update(std::unique_ptr<Camera>& camera); void camera_update(Camera* camera);
bool camera_did_update(std::unique_ptr<Camera>& camera); bool camera_did_update(Camera* camera);
void camera_new_frame(std::unique_ptr<Camera>& camera); void camera_new_frame(Camera* camera);
glm::mat4 camera_get_view(std::unique_ptr<Camera>& camera); glm::mat4 camera_get_view(Camera* camera);
glm::mat4 camera_get_projection(std::unique_ptr<Camera>& camera); glm::mat4 camera_get_projection(Camera* camera);
glm::mat4 camera_get_look(std::unique_ptr<Camera>& camera); glm::mat4 camera_get_look(Camera* camera);
void raster_set_viewport(std::unique_ptr<Camera>& camera, glm::ivec2 viewport); void raster_set_viewport(Camera* camera, glm::ivec2 viewport);
glm::ivec2 raster_get_viewport(std::unique_ptr<Camera>& camera); glm::ivec2 raster_get_viewport(Camera* camera);
void ray_set_viewport(std::unique_ptr<Camera>& camera, glm::ivec2 viewport); void ray_set_viewport(Camera* camera, glm::ivec2 viewport);
glm::ivec2 ray_get_viewport(std::unique_ptr<Camera>& camera); glm::ivec2 ray_get_viewport(Camera* camera);
void camera_move(std::unique_ptr<Camera>& camera, uint8_t movement_delta); void camera_move(Camera* camera, uint8_t movement_delta);
void camera_mouse_move(std::unique_ptr<Camera>& camera, glm::vec2 mouse_delta); void camera_mouse_move(Camera* camera, glm::vec2 mouse_delta);
void camera_set_position(std::unique_ptr<Camera>& camera, glm::vec3 position); void camera_set_position(Camera* camera, glm::vec3 position);
void camera_set_euler_look(std::unique_ptr<Camera>& camera, float roll, void camera_set_euler_look(Camera* camera, float roll,
float pitch, float yaw); float pitch, float yaw);
void camera_set_look(std::unique_ptr<Camera>& camera, void camera_set_look(Camera* camera,
glm::vec3 look_direction); glm::vec3 look_direction);
glm::vec3 camera_get_position(Camera* camera);
} // namespace inferno::graphics } // namespace inferno::graphics

185
src/hart_directory.cpp
View File

@@ -1,185 +0,0 @@
#include "hart_directory.hpp"
#include "inferno_hart.hpp"
#include <yolo/yolo.hpp>
#include <iostream>
using namespace inferno;
HARTModuleDirectory::HARTModuleDirectory()
{
}
HARTModuleDirectory::~HARTModuleDirectory()
{
}
std::vector<HARTModuleDirectory::discoveryEntry> 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<std::string> HARTModuleDirectory::getModules()
{
std::vector<std::string> 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<std::string> 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<std::string> 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;
}

71
src/hart_directory.hpp
View File

@@ -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 <inferno_hart.hpp>
#include <filesystem>
#include <string>
#include <vector>
#include <unordered_map>
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<discoveryEntry> discoverModules(std::filesystem::path path, bool recurse = false);
discoveryEntry registerModule(std::filesystem::path file);
std::vector<std::string> 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<std::string, moduleEntry> mEntries;
};
}

83
src/hart_module.cpp
View File

@@ -1,83 +0,0 @@
#include "hart_module.hpp"
#include <renderer/ray_source.hpp>
#include <renderer/renderer.hpp>
#include <scene/scene.hpp>
#include <scene/mesh.hpp>
#include <yolo/yolo.hpp>
#include <vector>
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<Mesh*> 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();
}

42
src/hart_module.hpp
View File

@@ -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 <vector>
#include <graphics.hpp>
#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;
};
}

138
src/inferno.cpp
View File

@@ -2,19 +2,16 @@
#include <version.hpp> #include <version.hpp>
// #include "gui/layout.hpp" // #include "gui/layout.hpp"
#include "imgui/imgui.h"
#include "scene/scene.hpp"
#include "window.hpp" #include "window.hpp"
// #include "hart_module.hpp" #include "preview_renderer/renderer.hpp"
// #include "hart_directory.hpp" #include "preview_renderer/shader.hpp"
// #include "preview_renderer/renderer.hpp"
// #include "preview_renderer/shader.hpp"
// #include "renderer/dispatcher.hpp"
// #include "renderer/renderer.hpp"
#include "scene/camera.hpp" #include "scene/camera.hpp"
// #include "scene/scene.hpp" #include "scene/material.hpp"
// #include "scene/material.hpp" #include "scene/mesh.hpp"
// #include "scene/mesh.hpp" #include "scene/scene.hpp"
#include <yolo/yolo.hpp> #include <yolo/yolo.hpp>
@@ -25,24 +22,45 @@
namespace inferno { namespace inferno {
std::unique_ptr<InfernoApp> inferno_create() InfernoApp* inferno_create()
{ {
// MOTD // MOTD
yolo::info("INFERNO HART v" INFERNO_VERSION); yolo::info("INFERNO HART v" INFERNO_VERSION);
std::unique_ptr<InfernoApp> app = std::make_unique<InfernoApp>(); InfernoApp* app = new InfernoApp;
app->Input = std::make_unique<InfernoInput>(); app->Input = new InfernoInput;
app->Scene = scene::scene_create();
// Create window // Create window
graphics::window_create("Inferno v" INFERNO_VERSION, 1280, 720); graphics::window_create("Inferno v" INFERNO_VERSION, 1280, 720);
// setup the scene
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 = 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_add_object(app->Scene, object);
app->PreviewRenderer = graphics::preview_create();
return app; return app;
} }
void inferno_cleanup(std::unique_ptr<InfernoApp>& app) void inferno_cleanup(InfernoApp* app)
{ {
graphics::window_cleanup(); graphics::window_cleanup();
app.reset(); delete app;
} }
static void inferno_gui_help_marker(const char* desc) static void inferno_gui_help_marker(const char* desc)
@@ -57,7 +75,7 @@ static void inferno_gui_help_marker(const char* desc)
} }
} }
void inferno_preset_gui(std::unique_ptr<InfernoApp>& app) void inferno_preset_gui(InfernoApp* app)
{ {
ImGuiID dockspace_id = ImGui::GetID("main"); ImGuiID dockspace_id = ImGui::GetID("main");
@@ -65,7 +83,7 @@ void inferno_preset_gui(std::unique_ptr<InfernoApp>& app)
ImGui::DockBuilderAddNode(dockspace_id, ImGuiDockNodeFlags_DockSpace); // Add empty node ImGui::DockBuilderAddNode(dockspace_id, ImGuiDockNodeFlags_DockSpace); // Add empty node
ImGui::DockBuilderSetNodeSize(dockspace_id, { 1000, 1000 }); ImGui::DockBuilderSetNodeSize(dockspace_id, { 1000, 1000 });
ImGuiID dock_main_id = dockspace_id; // This variable will track the document node, however we are not using it here as we aren't docking anything into it. ImGuiID dock_main_id = dockspace_id;
ImGuiID dock_left = ImGui::DockBuilderSplitNode(dock_main_id, ImGuiDir_Left, 0.5f, NULL, &dock_main_id); ImGuiID dock_left = ImGui::DockBuilderSplitNode(dock_main_id, ImGuiDir_Left, 0.5f, NULL, &dock_main_id);
ImGui::DockBuilderDockWindow("Preview", dock_left); ImGui::DockBuilderDockWindow("Preview", dock_left);
ImGui::DockBuilderDockWindow("Render", dock_main_id); ImGui::DockBuilderDockWindow("Render", dock_main_id);
@@ -74,7 +92,7 @@ void inferno_preset_gui(std::unique_ptr<InfernoApp>& app)
yolo::info("LAYOUT SET TO DEFAULT"); yolo::info("LAYOUT SET TO DEFAULT");
} }
void inferno_move_input(std::unique_ptr<InfernoApp>& app) void inferno_move_input(InfernoApp* app)
{ {
static GLFWcursor* cursor = glfwCreateStandardCursor(GLFW_HAND_CURSOR); static GLFWcursor* cursor = glfwCreateStandardCursor(GLFW_HAND_CURSOR);
glfwSetCursor(graphics::window_get_glfw_window(), cursor); glfwSetCursor(graphics::window_get_glfw_window(), cursor);
@@ -113,15 +131,14 @@ void inferno_move_input(std::unique_ptr<InfernoApp>& app)
app->Input->MovementDelta |= 0b00000100; app->Input->MovementDelta |= 0b00000100;
} }
void inferno_stop_move_input(std::unique_ptr<InfernoApp>& app) void inferno_stop_move_input(InfernoApp* app)
{ {
app->Input->MovementDelta = 0x0; app->Input->MovementDelta = 0x0;
app->Input->MouseDelta = { 0.0f, 0.0f }; app->Input->MouseDelta = { 0.0f, 0.0f };
} }
int inferno_run(std::unique_ptr<InfernoApp>& app) int inferno_run(InfernoApp* app)
{ {
while (true) { while (true) {
if (!graphics::window_new_frame()) if (!graphics::window_new_frame())
break; break;
@@ -134,6 +151,11 @@ int inferno_run(std::unique_ptr<InfernoApp>& app)
} }
ImGui::DockSpace(dockspace_id, ImVec2(0.0f, 0.0f), dockspace_flags); 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 // Menu Bar
static bool showPreview = true; static bool showPreview = true;
static bool showRenderSettings = true; static bool showRenderSettings = true;
@@ -162,22 +184,78 @@ int inferno_run(std::unique_ptr<InfernoApp>& app)
} else { } else {
inferno_stop_move_input(app); 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 }); graphics::raster_set_viewport(scene::scene_get_camera(app->Scene),
mRasterRenderer->setTargetSize({ ImGui::GetWindowSize().x, ImGui::GetWindowSize().y }); { ImGui::GetWindowSize().x, ImGui::GetWindowSize().y });
mRasterRenderer->prepare(); graphics::preview_draw(app->PreviewRenderer, app->Scene);
mRasterRenderer->draw();
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)); ImVec2(0, 1), ImVec2(1, 0));
glBindFramebuffer(GL_FRAMEBUFFER, 0); glBindFramebuffer(GL_FRAMEBUFFER, 0);
ImGui::End(); 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 // clang-format off
GLenum err; GLenum err;
while((err = glGetError()) != GL_NO_ERROR) { while((err = glGetError()) != GL_NO_ERROR) {

32
src/inferno.hpp
View File

@@ -1,6 +1,10 @@
#pragma once #pragma once
#include "graphics.hpp" #include "graphics.hpp"
#include "scene/scene.hpp"
#include "scene/camera.hpp"
// #include "renderer/renderer.hpp"
#include "preview_renderer/renderer.hpp"
#include <memory> #include <memory>
@@ -10,21 +14,27 @@ namespace graphics {
struct Camera; struct Camera;
} }
namespace scene {
struct Scene;
}
typedef struct InfernoInput { typedef struct InfernoInput {
glm::vec2 MouseDelta; glm::vec2 MouseDelta = {0.0f, 0.0f};
uint8_t MovementDelta; uint8_t MovementDelta = 0;
} InfernoInput; } InfernoInput;
typedef struct InfernoApp { typedef struct InfernoApp {
std::unique_ptr<InfernoInput> Input; InfernoInput* Input;
std::unique_ptr<graphics::Camera> Camera; scene::Scene* Scene;
graphics::PreviewRenderer* PreviewRenderer;
// graphics::RayRenderer* RayRenderer;
} InfernoApp; } InfernoApp;
std::unique_ptr<InfernoApp> inferno_create(); InfernoApp* inferno_create();
void inferno_cleanup(std::unique_ptr<InfernoApp>& app); void inferno_cleanup(InfernoApp* app);
void inferno_preset_gui(std::unique_ptr<InfernoApp>& app); void inferno_preset_gui(InfernoApp* app);
void inferno_move_input(std::unique_ptr<InfernoApp>& app); void inferno_move_input(InfernoApp* app);
void inferno_stop_move_input(std::unique_ptr<InfernoApp>& app); void inferno_stop_move_input(InfernoApp* app);
int inferno_run(std::unique_ptr<InfernoApp>& app); int inferno_run(InfernoApp* app);
} } // namespace inferno

2
src/main.cpp
View File

@@ -5,6 +5,6 @@
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
std::unique_ptr<inferno::InfernoApp> inferno = inferno::inferno_create(); auto inferno = inferno::inferno_create();
return inferno::inferno_run(inferno); return inferno::inferno_run(inferno);
} }

84
src/preview_renderer/renderer.cpp
View File

@@ -1,19 +1,24 @@
#include "renderer.hpp" #include "renderer.hpp"
#include "scene/object.hpp"
#include "shader.hpp" #include "shader.hpp"
#include <yolo/yolo.hpp>
#include <algorithm>
#include <scene/camera.hpp> #include <scene/camera.hpp>
#include <scene/material.hpp> #include <scene/material.hpp>
#include <scene/mesh.hpp> #include <scene/mesh.hpp>
#include <scene/object.hpp>
#include <scene/scene.hpp> #include <scene/scene.hpp>
#include <iostream> #include <iostream>
namespace inferno::graphics { namespace inferno::graphics {
std::unique_ptr<PreviewRenderer> preview_create() PreviewRenderer* preview_create()
{ {
std::unique_ptr<PreviewRenderer> renderer = std::make_unique<PreviewRenderer>(); PreviewRenderer* renderer = new PreviewRenderer;
glGenFramebuffers(1, &renderer->RenderTarget); glGenFramebuffers(1, &renderer->RenderTarget);
glBindFramebuffer(GL_FRAMEBUFFER, renderer->RenderTarget); glBindFramebuffer(GL_FRAMEBUFFER, renderer->RenderTarget);
@@ -44,18 +49,23 @@ std::unique_ptr<PreviewRenderer> preview_create()
return renderer; return renderer;
} }
void preview_cleanup(std::unique_ptr<PreviewRenderer>& renderer) void preview_cleanup(PreviewRenderer* renderer)
{ {
} }
void preview_set_scene(std::unique_ptr<PreviewRenderer>& renderer, std::shared_ptr<Scene> scene) void preview_set_viewport(PreviewRenderer* renderer, Viewport* viewport)
{ {
renderer->CurrentScene = scene;
} }
void preview_set_viewport(std::unique_ptr<PreviewRenderer>& renderer, std::shared_ptr<const Viewport> viewport) GLuint preview_get_rendered_texture(PreviewRenderer* renderer)
{ {
renderer->RenderTargetSize = viewport; glBindFramebuffer(GL_FRAMEBUFFER, renderer->RenderTarget);
return renderer->RenderTargetTexture;
}
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); glBindFramebuffer(GL_FRAMEBUFFER, renderer->RenderTarget);
glBindTexture(GL_TEXTURE_2D, renderer->RenderTargetTexture); glBindTexture(GL_TEXTURE_2D, renderer->RenderTargetTexture);
@@ -63,8 +73,8 @@ void preview_set_viewport(std::unique_ptr<PreviewRenderer>& renderer, std::share
GL_TEXTURE_2D, GL_TEXTURE_2D,
0, 0,
GL_RGB, GL_RGB,
viewport->Raster.x, viewport.x,
viewport->Raster.y, viewport.y,
0, 0,
GL_RGB, GL_RGB,
GL_UNSIGNED_BYTE, GL_UNSIGNED_BYTE,
@@ -74,60 +84,54 @@ void preview_set_viewport(std::unique_ptr<PreviewRenderer>& renderer, std::share
glTexImage2D(GL_TEXTURE_2D, glTexImage2D(GL_TEXTURE_2D,
0, 0,
GL_DEPTH24_STENCIL8, GL_DEPTH24_STENCIL8,
viewport->Raster.x, viewport.x,
viewport->Raster.y, viewport.y,
0, 0,
GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT,
GL_FLOAT, GL_FLOAT,
NULL); NULL);
glBindFramebuffer(GL_FRAMEBUFFER, 0); glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
const glm::ivec2& preview_get_viewport(std::unique_ptr<PreviewRenderer>& renderer) // clear
{
return renderer->RenderTargetSize->Raster;
}
GLuint preview_get_rendered_texture(std::unique_ptr<PreviewRenderer>& renderer)
{
glBindFramebuffer(GL_FRAMEBUFFER, renderer->RenderTarget);
return renderer->RenderTargetTexture;
}
void preview_prepare(std::unique_ptr<PreviewRenderer>& renderer)
{
glBindFramebuffer(GL_FRAMEBUFFER, renderer->RenderTarget); glBindFramebuffer(GL_FRAMEBUFFER, renderer->RenderTarget);
glClearColor(0.1, 0.1, 0.1, 1.0); glClearColor(0.1, 0.1, 0.1, 1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glBindFramebuffer(GL_FRAMEBUFFER, 0); glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
void preview_draw(std::unique_ptr<PreviewRenderer>& renderer) // draw
{
glBindFramebuffer(GL_FRAMEBUFFER, renderer->RenderTarget); glBindFramebuffer(GL_FRAMEBUFFER, renderer->RenderTarget);
glViewport(0, glViewport(0,
0, 0,
renderer->RenderTargetSize->Raster.x, renderer->Viewport.x,
renderer->RenderTargetSize->Raster.y); renderer->Viewport.y);
glEnable(GL_DEPTH_TEST); glEnable(GL_DEPTH_TEST);
for (Mesh* m : renderer->CurrentScene->getRenderables()) { for (scene::SceneObject* o : scene::scene_get_renderables(scene)) {
// m->getMaterial()->getGlShader()->use(); for (scene::Mesh* m : scene::scene_object_get_meshs(o)) {
// GLint uniTrans = glGetUniformLocation(m->getMaterial()->getGlShader()->getProgram(), "model"); graphics::Shader* shader = m->getMaterial()->getGlShader();
// glUniformMatrix4fv(uniTrans, 1, GL_FALSE, glm::value_ptr(glm::mat4(1.0f))); graphics::shader_use(shader);
// GLint uniView = glGetUniformLocation(m->getMaterial()->getGlShader()->getProgram(), "view"); auto viewMatrix = graphics::camera_get_view(scene::scene_get_camera(scene));
// glUniformMatrix4fv(uniView, 1, GL_FALSE, glm::value_ptr(renderer->CurrentScene->getCamera()->getViewMatrix())); auto projMatrix = graphics::camera_get_projection(scene::scene_get_camera(scene));
// GLint uniProj = glGetUniformLocation(m->getMaterial()->getGlShader()->getProgram(), "proj"); GLint uniTrans = glGetUniformLocation(graphics::shader_get_program(shader), "model");
// glUniformMatrix4fv(uniProj, 1, GL_FALSE, glm::value_ptr(renderer->CurrentScene->getCamera()->getProjectionMatrix())); glUniformMatrix4fv(uniTrans, 1, GL_FALSE, glm::value_ptr(glm::mat4(1.0f)));
glBindVertexArray(m->getVAO()); GLint uniView = glGetUniformLocation(graphics::shader_get_program(shader), "view");
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m->getEBO()); glUniformMatrix4fv(uniView, 1, GL_FALSE, glm::value_ptr(viewMatrix));
glDrawElements(GL_TRIANGLES, m->getIndexCount() * sizeof(uint32_t), GL_UNSIGNED_INT, 0); 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());
glDrawElements(GL_TRIANGLES, m->getIndexCount() * sizeof(uint32_t), GL_UNSIGNED_INT, 0);
}
} }
glBindFramebuffer(GL_FRAMEBUFFER, 0); glBindFramebuffer(GL_FRAMEBUFFER, 0);

16
src/preview_renderer/renderer.hpp
View File

@@ -13,22 +13,18 @@ namespace inferno::graphics {
struct Viewport; struct Viewport;
typedef struct PreviewRenderer { typedef struct PreviewRenderer {
glm::ivec2 Viewport;
GLuint RenderTarget = 0; GLuint RenderTarget = 0;
GLuint RenderTargetTexture = 0; GLuint RenderTargetTexture = 0;
GLuint RenderTargetDepthTexture = 0; GLuint RenderTargetDepthTexture = 0;
std::shared_ptr<scene::Scene> CurrentScene;
std::shared_ptr<const Viewport> RenderTargetSize;
} PreviewRenderer; } PreviewRenderer;
std::unique_ptr<PreviewRenderer> preview_create(); PreviewRenderer* preview_create();
void preview_cleanup(std::unique_ptr<PreviewRenderer>& renderer); void preview_cleanup(PreviewRenderer* renderer);
void preview_set_scene(std::unique_ptr<PreviewRenderer>& renderer, std::shared_ptr<scene::Scene> scene); GLuint preview_get_rendered_texture(PreviewRenderer* renderer);
void preview_set_viewport(std::unique_ptr<PreviewRenderer>& renderer, std::shared_ptr<const Viewport> viewports);
const glm::ivec2& preview_get_viewport(std::unique_ptr<PreviewRenderer>& renderer);
GLuint preview_get_rendered_texture(std::unique_ptr<PreviewRenderer>& renderer);
void preview_prepare(std::unique_ptr<PreviewRenderer>& renderer); void preview_draw(PreviewRenderer* renderer, scene::Scene* scene);
void preview_draw(std::unique_ptr<PreviewRenderer>& renderer);
} // namespace inferno::graphics } // namespace inferno::graphics

33
src/preview_renderer/shader.cpp
View File

@@ -3,7 +3,7 @@
#include <fstream> #include <fstream>
#include <iostream> #include <iostream>
using namespace inferno::graphics; namespace inferno::graphics {
static std::unordered_map<GLuint, int> shader2Index = { static std::unordered_map<GLuint, int> shader2Index = {
{ GL_VERTEX_SHADER, 0 }, { GL_VERTEX_SHADER, 0 },
@@ -25,7 +25,7 @@ std::string textFromFile(const std::filesystem::path& path)
std::istreambuf_iterator<char>()); std::istreambuf_iterator<char>());
} }
std::vector<const ShaderPreprocessorDefinition*> getKeys(std::unique_ptr<Shader>& shader, std::string key) std::vector<const ShaderPreprocessorDefinition*> getKeys(Shader* shader, std::string key)
{ {
std::vector<const ShaderPreprocessorDefinition*> ret; std::vector<const ShaderPreprocessorDefinition*> ret;
for (const auto& p : shader->PreprocessorDefinitions) for (const auto& p : shader->PreprocessorDefinitions)
@@ -56,9 +56,9 @@ bool checkShader(GLuint uid)
return true; return true;
} }
std::unique_ptr<Shader> shader_create() Shader* shader_create()
{ {
std::unique_ptr<Shader> shader = std::make_unique<Shader>(); Shader* shader = new Shader;
shader->Program = 0; shader->Program = 0;
shader->Shaders[0] = GL_NONE; shader->Shaders[0] = GL_NONE;
@@ -68,7 +68,7 @@ std::unique_ptr<Shader> shader_create()
return shader; return shader;
} }
void shader_cleanup(std::unique_ptr<Shader>& shader) void shader_cleanup(Shader* shader)
{ {
for (int i = 0; i < 3; i++) { for (int i = 0; i < 3; i++) {
if (shader->Shaders[i] == GL_NONE) if (shader->Shaders[i] == GL_NONE)
@@ -79,7 +79,7 @@ void shader_cleanup(std::unique_ptr<Shader>& shader)
glDeleteProgram(shader->Program); glDeleteProgram(shader->Program);
} }
void shader_load(std::unique_ptr<Shader>& shader, std::filesystem::path path) void shader_load(Shader* shader, std::filesystem::path path)
{ {
assert(std::filesystem::exists(path)); assert(std::filesystem::exists(path));
@@ -132,7 +132,7 @@ void shader_load(std::unique_ptr<Shader>& shader, std::filesystem::path path)
} }
} }
void shader_link(std::unique_ptr<Shader>& shader) void shader_link(Shader* shader)
{ {
shader->Program = glCreateProgram(); shader->Program = glCreateProgram();
@@ -150,32 +150,39 @@ void shader_link(std::unique_ptr<Shader>& shader)
glLinkProgram(shader->Program); glLinkProgram(shader->Program);
} }
void shader_add_attribute(std::unique_ptr<Shader>& shader, const std::string& attribute) 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()); shader->Attributes[attribute] = glGetAttribLocation(shader->Program, attribute.c_str());
} }
void shader_add_uniform(std::unique_ptr<Shader>& shader, const std::string& uniform) void shader_add_uniform(Shader* shader, const std::string& uniform)
{ {
shader->Uniforms[uniform] = glGetUniformLocation(shader->Program, uniform.c_str()); shader->Uniforms[uniform] = glGetUniformLocation(shader->Program, uniform.c_str());
} }
GLuint shader_get_attribute(std::unique_ptr<Shader>& shader, const std::string& attribute) GLuint shader_get_attribute(Shader* shader, const std::string& attribute)
{ {
return shader->Attributes[attribute]; return shader->Attributes[attribute];
} }
GLuint shader_get_uniform(std::unique_ptr<Shader>& shader, const std::string& uniform) GLuint shader_get_uniform(Shader* shader, const std::string& uniform)
{ {
return shader->Uniforms[uniform]; return shader->Uniforms[uniform];
} }
void shader_use(std::unique_ptr<Shader>& shader) void shader_use(Shader* shader)
{ {
glUseProgram(shader->Program); glUseProgram(shader->Program);
} }
void shader_unuse(std::unique_ptr<Shader>& shader) void shader_unuse(Shader* shader)
{ {
glUseProgram(0); glUseProgram(0);
} }
}

23
src/preview_renderer/shader.hpp
View File

@@ -24,18 +24,21 @@ typedef struct Shader {
std::vector<ShaderPreprocessorDefinition> PreprocessorDefinitions; std::vector<ShaderPreprocessorDefinition> PreprocessorDefinitions;
} Shader; } Shader;
std::unique_ptr<Shader> shader_create(); Shader* shader_create();
void shader_cleanup(std::unique_ptr<Shader>& shader); 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);
void shader_load(std::unique_ptr<Shader>& shader, std::filesystem::path path);
void shader_link(std::unique_ptr<Shader>& shader);
// TODO: Implement shader_reload // TODO: Implement shader_reload
void shader_add_attribute(std::unique_ptr<Shader>& shader, const std::string& attribute); void shader_add_attribute(Shader* shader, const std::string& attribute);
void shader_add_uniform(std::unique_ptr<Shader>& shader, const std::string& uniform); void shader_add_uniform(Shader* shader, const std::string& uniform);
GLuint shader_get_attribute(std::unique_ptr<Shader>& shader, const std::string& attribute); GLuint shader_get_attribute(Shader* shader, const std::string& attribute);
GLuint shader_get_uniform(std::unique_ptr<Shader>& shader, const std::string& uniform); GLuint shader_get_uniform(Shader* shader, const std::string& uniform);
void shader_use(std::unique_ptr<Shader>& shader); void shader_use(Shader* shader);
void shader_unuse(std::unique_ptr<Shader>& shader); void shader_unuse(Shader* shader);
} }

75
src/renderer/dispatcher.cpp
View File

@@ -1,75 +0,0 @@
#include "dispatcher.hpp"
#include "hart_module.hpp"
#include "renderer.hpp"
#include <mutex>
#include <chrono>
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<bool>* doWork, std::atomic<bool>* 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<std::mutex> 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;
}

42
src/renderer/dispatcher.hpp
View File

@@ -1,42 +0,0 @@
#pragma once
#include <graphics.hpp>
#include <thread>
#include <mutex>
#include <atomic>
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<bool> mDoWork = false;
std::atomic<bool> mJoin = false;
};
}

140
src/renderer/ray_source.cpp
View File

@@ -1,70 +1,70 @@
#include "ray_source.hpp" // #include "ray_source.hpp"
//
#include <iostream> // #include <iostream>
//
#include <maths.hpp> // #include <maths.hpp>
//
#include <scene/camera.hpp> // #include <scene/camera.hpp>
//
#include <tracing/ray.hpp> // #include <tracing/ray.hpp>
//
using namespace inferno; // using namespace inferno;
//
RaySource::RaySource(Camera* camera) // RaySource::RaySource(Camera* camera)
: mReferenceCamera(camera) // : mReferenceCamera(camera)
{ // {
this->generate(); // this->generate();
} // }
//
RaySource::~RaySource() // RaySource::~RaySource()
{ // {
//
} // }
//
void RaySource::generate() // void RaySource::generate()
{ // {
// const float aspect = 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); // // float scale = tan(mReferenceCamera->FOV / 2.0f * helpers::PI / 180.0f);
} // }
//
ReferencedRayField RaySource::getInitialRays(bool MSAA) // ReferencedRayField RaySource::getInitialRays(bool MSAA)
{ // {
if (mReferenceCamera->didUpdate()) // if (mReferenceCamera->didUpdate())
{ // {
this->generate(); // this->generate();
} // }
//
RayField field; // RayField field;
field.reserve(mReferenceCamera->getRayViewport().x * mReferenceCamera->getRayViewport().y); // field.reserve(mReferenceCamera->getRayViewport().x * mReferenceCamera->getRayViewport().y);
//
const float aspect = 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); // float scale = tan(mReferenceCamera->FOV / 2.0f * helpers::PI / 180.0f);
//
glm::mat4 cameraToWorld = mReferenceCamera->getCameraLook(); // glm::mat4 cameraToWorld = mReferenceCamera->getCameraLook();
glm::vec3 origin = mReferenceCamera->Position; // glm::vec3 origin = mReferenceCamera->Position;
//
std::unordered_map<uint32_t, glm::ivec2> reference; // std::unordered_map<uint32_t, glm::ivec2> reference;
//
uint32_t i = 0; // uint32_t i = 0;
for (int x = 0; x < mReferenceCamera->getRayViewport().x; x++) // for (int x = 0; x < mReferenceCamera->getRayViewport().x; x++)
for (int y = 0; y < mReferenceCamera->getRayViewport().y; y++) // for (int y = 0; y < mReferenceCamera->getRayViewport().y; y++)
{ // {
float Px = (2.0f * ((x + 0.5f) / mReferenceCamera->getRayViewport().x) - 1.0f) * scale * aspect; // 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; // float Py = (2.0f * ((y + 0.5f) / mReferenceCamera->getRayViewport().y) - 1.0f) * scale;
//
Ray* ray = new Ray{}; // Ray* ray = new Ray{};
//
glm::vec4 dir4 = glm::vec4(Px, Py, -1.0f, 1.0f) * cameraToWorld; // glm::vec4 dir4 = glm::vec4(Px, Py, -1.0f, 1.0f) * cameraToWorld;
glm::vec3 dir3 = glm::vec3(dir4) / dir4.w; // glm::vec3 dir3 = glm::vec3(dir4) / dir4.w;
ray->Direction = glm::normalize(dir3); // ray->Direction = glm::normalize(dir3);
//
ray->Origin = origin; // ray->Origin = origin;
ray->Reference = i; // ray->Reference = i;
reference[i] = {x, y}; // reference[i] = {x, y};
//
field.push_back(ray); // field.push_back(ray);
i++; // i++;
} // }
//
return { field, reference }; // return { field, reference };
} // }

66
src/renderer/ray_source.hpp
View File

@@ -1,33 +1,33 @@
#pragma once // #pragma once
//
#include <vector> // #include <vector>
#include <unordered_map> // #include <unordered_map>
//
#include <graphics.hpp> // #include <graphics.hpp>
//
#include <tracing/ray.hpp> // #include <tracing/ray.hpp>
//
namespace inferno { // namespace inferno {
//
class Camera; // class Camera;
//
struct ReferencedRayField { // struct ReferencedRayField {
RayField Field; // RayField Field;
std::unordered_map<uint32_t, glm::ivec2> Reference; // std::unordered_map<uint32_t, glm::ivec2> Reference;
}; // };
//
//
class RaySource // class RaySource
{ // {
public: // public:
RaySource(Camera* camera); // RaySource(Camera* camera);
~RaySource(); // ~RaySource();
//
void generate(); // void generate();
ReferencedRayField getInitialRays(bool MSAA); // ReferencedRayField getInitialRays(bool MSAA);
//
private: // private:
Camera* mReferenceCamera; // Camera* mReferenceCamera;
}; // };
//
} // }

287
src/renderer/renderer.cpp
View File

@@ -1,144 +1,143 @@
#include "renderer.hpp" // #include "renderer.hpp"
//
#include <graphics.hpp> // #include <graphics.hpp>
//
#include <scene/camera.hpp> // #include <scene/camera.hpp>
#include <scene/scene.hpp> // #include <scene/scene.hpp>
#include <scene/mesh.hpp> // #include <scene/mesh.hpp>
#include <tracing/ray.hpp> // #include <tracing/ray.hpp>
#include <tracing/hit.hpp> // #include <tracing/hit.hpp>
//
#include "hart_module.hpp" // #include "ray_source.hpp"
#include "ray_source.hpp" //
// #include <yolo/yolo.hpp>
#include <yolo/yolo.hpp> //
// #include <iostream>
#include <iostream> //
// namespace inferno::graphics {
namespace inferno::graphics { //
// RayRenderer* rayr_create(glm::ivec2 viewport, HHM* accelIface)
std::unique_ptr<RayRenderer> rayr_create(glm::ivec2 viewport, HHM* accelIface) // {
{ // RayRenderer* renderer = new RayRenderer;
std::unique_ptr<RayRenderer> renderer = std::make_unique<RayRenderer>(); // renderer->RenderTargetSize = viewport;
renderer->RenderTargetSize = viewport; // renderer->RenderData = new glm::fvec4[renderer->RenderTargetSize.x * renderer->RenderTargetSize.y];
renderer->RenderData = new glm::fvec4[renderer->RenderTargetSize.x * renderer->RenderTargetSize.y]; //
// glGenTextures(1, &renderer->RenderTargetTexture);
glGenTextures(1, &renderer->RenderTargetTexture); // glBindTexture(GL_TEXTURE_2D, renderer->RenderTargetTexture);
glBindTexture(GL_TEXTURE_2D, renderer->RenderTargetTexture); //
// glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); // glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); // glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); //
// glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
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);
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);
glBindTexture(GL_TEXTURE_2D, 0); //
// return renderer;
return renderer; // }
} //
// void rayr_cleanup(RayRenderer* renderer)
void rayr_cleanup(std::unique_ptr<RayRenderer>& renderer) // {
{ // delete[] renderer->RenderData;
delete[] renderer->RenderData; // }
} //
// void rayr_set_scene(RayRenderer* renderer, std::shared_ptr<scene::Scene> scene)
void rayr_set_scene(std::unique_ptr<RayRenderer>& renderer, std::shared_ptr<scene::Scene> scene) // {
{ // renderer->CurrentScene = scene;
renderer->CurrentScene = scene; // if (renderer->RaySource != nullptr)
if (renderer->RaySource != nullptr) // {
{ // delete renderer->RaySource;
delete renderer->RaySource; // }
} // // renderer->RaySource = new RaySource(scene->getCamera());
// renderer->RaySource = new RaySource(scene->getCamera()); // // the scene will be sent to the module on prepare
// the scene will be sent to the module on prepare // // as it did update during initialisation
// as it did update during initialisation //
// // mIface->newScene(scene);
// mIface->newScene(scene); // }
} //
// void rayr_set_viewport(RayRenderer* &renderer, glm::ivec2 size)
void rayr_set_viewport(std::unique_ptr<RayRenderer> &renderer, glm::ivec2 size) // {
{ // renderer->RenderTargetSize = size;
renderer->RenderTargetSize = size; // }
} //
// glm::ivec2 rayr_get_viewport(RayRenderer* &renderer)
glm::ivec2 rayr_get_viewport(std::unique_ptr<RayRenderer> &renderer) // {
{ // return renderer->RenderTargetSize;
return renderer->RenderTargetSize; // }
} //
// GLuint rayr_get_rendered_texture(RayRenderer* &renderer)
GLuint rayr_get_rendered_texture(std::unique_ptr<RayRenderer> &renderer) // {
{ // std::lock_guard<std::mutex> lock(renderer->RenderDataMutex);
std::lock_guard<std::mutex> lock(renderer->RenderDataMutex); // glBindFramebuffer(GL_FRAMEBUFFER, 0);
glBindFramebuffer(GL_FRAMEBUFFER, 0); // glBindTexture(GL_TEXTURE_2D, renderer->RenderTargetTexture);
glBindTexture(GL_TEXTURE_2D, renderer->RenderTargetTexture); // return renderer->RenderTargetTexture;
return renderer->RenderTargetTexture; // }
} //
// glm::fvec4* rayr_get_render_data(RayRenderer* &renderer)
glm::fvec4* rayr_get_render_data(std::unique_ptr<RayRenderer> &renderer) // {
{ // std::lock_guard<std::mutex> lock(renderer->RenderDataMutex);
std::lock_guard<std::mutex> lock(renderer->RenderDataMutex); // return renderer->RenderData;
return renderer->RenderData; // }
} //
// void rayr_prepare(RayRenderer* &renderer)
void rayr_prepare(std::unique_ptr<RayRenderer> &renderer) // {
{ // assert(renderer->CurrentScene != nullptr);
assert(renderer->CurrentScene != nullptr); // // here, scene_did_update takes a unique_ptr, but we have a shared_ptr
// 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
// 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
// with non-const ltype so we need to const_cast it // if (scene::scene_did_update(renderer->CurrentScene))
if (scene::scene_did_update(renderer->CurrentScene)) // {
{ // yolo::debug("New Scene!");
yolo::debug("New Scene!"); // // renderer->AccelerationInterface->newScene(renderer->CurrentScene);
// renderer->AccelerationInterface->newScene(renderer->CurrentScene); // }
} // }
} //
// void rayr_draw(RayRenderer* &renderer)
void rayr_draw(std::unique_ptr<RayRenderer> &renderer) // {
{ // scene::scene_frame_tick(renderer->CurrentScene);
scene::scene_frame_tick(renderer->CurrentScene); // // TODO: Rays should definately be bump allocated if possible, this is KBs of
// 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
// ray data and nothing else being reallocated every frame for no reason // ReferencedRayField startRays = mRaySource->getInitialRays(true);
ReferencedRayField startRays = mRaySource->getInitialRays(true); //
// for (int x = 0; x < mRenderTargetSize.x; x++)
for (int x = 0; x < mRenderTargetSize.x; x++) // for (int y = 0; y < mRenderTargetSize.y; y++)
for (int y = 0; y < mRenderTargetSize.y; y++) // {
{ // mTarget[y * mRenderTargetSize.x + x] = { 0.1f, 0.1f, 0.1f, 1.0f };
mTarget[y * mRenderTargetSize.x + x] = { 0.1f, 0.1f, 0.1f, 1.0f }; // }
} // mCurrentRefTable = &startRays.Reference;
mCurrentRefTable = &startRays.Reference; //
// // before we start we now want to check that it hasn't been force-stopped
// before we start we now want to check that it hasn't been force-stopped // mIface->startTrace(startRays.Field);
mIface->startTrace(startRays.Field); //
// yolo::info("Sample complete");
yolo::info("Sample complete"); //
// for (auto* ray : startRays.Field)
for (auto* ray : startRays.Field) // {
{ // delete ray;
delete ray; // }
} // }
} //
// void RayRenderer::computeHit(HitInfo* info)
void RayRenderer::computeHit(HitInfo* info) // {
{ // static float mind = 100000.0f;
static float mind = 100000.0f; // static float maxd = 0.0f;
static float maxd = 0.0f; // // TODO: Make sure signal is started
// TODO: Make sure signal is started // if (!(*mCurrentRefTable).count(info->Caller->Reference))
if (!(*mCurrentRefTable).count(info->Caller->Reference)) // {
{ // yolo::warn("Why is the ray not in the map?!");
yolo::warn("Why is the ray not in the map?!"); // return;
return; // }
} // glm::ivec2 pos = (*mCurrentRefTable)[info->Caller->Reference];
glm::ivec2 pos = (*mCurrentRefTable)[info->Caller->Reference]; // float d = info->Distance;
float d = info->Distance; // if (d < mind) mind = d;
if (d < mind) mind = d; // if (d > maxd) maxd = d;
if (d > maxd) maxd = d; // float n = (d - mind) / (maxd - mind);
float n = (d - mind) / (maxd - mind); // mTarget[pos.y * mRenderTargetSize.x + pos.x] = { n, n, n, 1.0f};
mTarget[pos.y * mRenderTargetSize.x + pos.x] = { n, n, n, 1.0f}; // }
} // void mHaultWait();
void mHaultWait(); // std::unordered_map<uint32_t, glm::ivec2>* mCurrentRefTable;
std::unordered_map<uint32_t, glm::ivec2>* mCurrentRefTable; //
//
// }
}

35
src/renderer/renderer.hpp
View File

@@ -20,33 +20,26 @@ class RaySource;
class RenderDispatcher; class RenderDispatcher;
typedef struct RayRenderer { typedef struct RayRenderer {
glm::ivec2* Viewport;
// TODO: Can this be direct 2 GPU?
glm::fvec4* RenderData = nullptr; glm::fvec4* RenderData = nullptr;
GLuint RenderTargetTexture = 0; GLuint RenderTargetTexture = 0;
// TODO: Put this inside an internal struct // Internal stuffs
std::mutex RenderDataMutex;
std::condition_variable RenderPause;
// TODO: End
std::unique_ptr<scene::Scene> CurrentScene;
// std::shared_ptr<const Viewport> RenderTargetSize;
glm::ivec2 RenderTargetSize;
HHM* AccelerationInterface = nullptr;
RenderDispatcher* Dispatcher = nullptr;
RaySource* RaySource = nullptr; RaySource* RaySource = nullptr;
} RayRenderer; } RayRenderer;
std::unique_ptr<RayRenderer> rayr_create(glm::ivec2 viewport, HHM* accelIface); RayRenderer* rayr_create(glm::ivec2 viewport, HHM* accelIface);
void rayr_cleanup(std::unique_ptr<RayRenderer>& renderer); void rayr_cleanup(RayRenderer* renderer);
void rayr_set_scene(std::unique_ptr<RayRenderer>& renderer, std::unique_ptr<scene::Scene> scene);
void rayr_set_viewport(std::unique_ptr<RayRenderer>& renderer, glm::ivec2 size); void rayr_set_viewport(RayRenderer* renderer, glm::ivec2 size);
glm::ivec2 rayr_get_viewport(std::unique_ptr<RayRenderer>& renderer);
GLuint rayr_get_rendered_texture(std::unique_ptr<RayRenderer>& renderer); GLuint rayr_get_rendered_texture(RayRenderer* renderer);
glm::fvec4* rayr_get_render_data(std::unique_ptr<RayRenderer>& renderer); glm::fvec4* rayr_get_render_data(RayRenderer* renderer);
void rayr_prepare(std::unique_ptr<RayRenderer>& renderer);
void rayr_draw(std::unique_ptr<RayRenderer>& renderer); void rayr_draw(RayRenderer* renderer, scene::Scene* scene);
void raryr_compute_hit(HitInfo* info); void raryr_compute_hit(HitInfo* info);
} } // namespace inferno::graphics

70
src/scene/camera.cpp
View File

@@ -2,19 +2,14 @@
namespace inferno::graphics { namespace inferno::graphics {
typedef struct _CameraImpl { Camera* camera_create()
bool DidUpdate;
std::mutex CamMutex;
} _CameraImpl;
std::unique_ptr<Camera> camera_create()
{ {
std::unique_ptr<Camera> camera = std::make_unique<Camera>(); Camera* camera = new Camera;
camera->_impl = std::make_unique<_CameraImpl>(); camera->_impl = new _CameraImpl;
camera->Views = std::make_shared<Viewports>();
camera->Views->Raster = glm::ivec2(800, 600); camera->Views = Viewports();
camera->Views->Ray = glm::ivec2(800, 600); camera->Views.Raster = glm::ivec2(800, 600);
camera->Views.Ray = glm::ivec2(800, 600);
camera->ProjectionMatrix = glm::perspective( camera->ProjectionMatrix = glm::perspective(
glm::radians(camera->FOV), glm::radians(camera->FOV),
@@ -34,13 +29,13 @@ std::unique_ptr<Camera> camera_create()
return camera; return camera;
} }
void camera_cleanup(std::unique_ptr<Camera>& camera) void camera_cleanup(Camera* camera)
{ {
camera->_impl.reset(); delete camera->_impl;
camera.reset(); delete camera;
} }
void camera_update(std::unique_ptr<Camera>& camera) void camera_update(Camera* camera)
{ {
glm::mat4 matRoll = glm::mat4(1.0f); glm::mat4 matRoll = glm::mat4(1.0f);
glm::mat4 matPitch = glm::mat4(1.0f); glm::mat4 matPitch = glm::mat4(1.0f);
@@ -61,7 +56,7 @@ void camera_update(std::unique_ptr<Camera>& camera)
camera->ViewMatrix = rotate * translate; camera->ViewMatrix = rotate * translate;
camera->ProjectionMatrix = glm::perspective( camera->ProjectionMatrix = glm::perspective(
glm::radians(camera->FOV), glm::radians(camera->FOV),
static_cast<float>(camera->Views->Raster.x) / static_cast<float>(camera->Views->Raster.y), static_cast<float>(camera->Views.Raster.x) / static_cast<float>(camera->Views.Raster.y),
0.1f, 0.1f,
1000.0f); 1000.0f);
@@ -75,40 +70,40 @@ void camera_update(std::unique_ptr<Camera>& camera)
camera->_impl->DidUpdate = true; camera->_impl->DidUpdate = true;
} }
bool camera_did_update(std::unique_ptr<Camera>& camera) bool camera_did_update(Camera* camera)
{ {
std::lock_guard<std::mutex> lock(camera->_impl->CamMutex); std::lock_guard<std::mutex> lock(camera->_impl->CamMutex);
return camera->_impl->DidUpdate; return camera->_impl->DidUpdate;
} }
void camera_new_frame(std::unique_ptr<Camera>& camera) void camera_new_frame(Camera* camera)
{ {
std::lock_guard<std::mutex> lock(camera->_impl->CamMutex); std::lock_guard<std::mutex> lock(camera->_impl->CamMutex);
camera->_impl->DidUpdate = false; camera->_impl->DidUpdate = false;
} }
glm::mat4 camera_get_view(std::unique_ptr<Camera>& camera) glm::mat4 camera_get_view(Camera* camera)
{ {
std::lock_guard<std::mutex> lock(camera->_impl->CamMutex); std::lock_guard<std::mutex> lock(camera->_impl->CamMutex);
return camera->ViewMatrix; return camera->ViewMatrix;
} }
glm::mat4 camera_get_projection(std::unique_ptr<Camera>& camera) glm::mat4 camera_get_projection(Camera* camera)
{ {
std::lock_guard<std::mutex> lock(camera->_impl->CamMutex); std::lock_guard<std::mutex> lock(camera->_impl->CamMutex);
return camera->ProjectionMatrix; return camera->ProjectionMatrix;
} }
glm::mat4 camera_get_look(std::unique_ptr<Camera>& camera) glm::mat4 camera_get_look(Camera* camera)
{ {
std::lock_guard<std::mutex> lock(camera->_impl->CamMutex); std::lock_guard<std::mutex> lock(camera->_impl->CamMutex);
return camera->LookMatrix; return camera->LookMatrix;
} }
void raster_set_viewport(std::unique_ptr<Camera>& camera, glm::ivec2 viewport) void raster_set_viewport(Camera* camera, glm::ivec2 viewport)
{ {
std::lock_guard<std::mutex> lock(camera->_impl->CamMutex); std::lock_guard<std::mutex> lock(camera->_impl->CamMutex);
camera->Views->Raster = viewport; camera->Views.Raster = viewport;
camera->ProjectionMatrix = glm::perspective( camera->ProjectionMatrix = glm::perspective(
glm::radians(camera->FOV), glm::radians(camera->FOV),
static_cast<float>(viewport.x) / static_cast<float>(viewport.y), static_cast<float>(viewport.x) / static_cast<float>(viewport.y),
@@ -116,25 +111,25 @@ void raster_set_viewport(std::unique_ptr<Camera>& camera, glm::ivec2 viewport)
1000.0f); 1000.0f);
} }
glm::ivec2 raster_get_viewport(std::unique_ptr<Camera>& camera) glm::ivec2 raster_get_viewport(Camera* camera)
{ {
std::lock_guard<std::mutex> lock(camera->_impl->CamMutex); std::lock_guard<std::mutex> lock(camera->_impl->CamMutex);
return camera->Views->Raster; return camera->Views.Raster;
} }
void ray_set_viewport(std::unique_ptr<Camera>& camera, glm::ivec2 viewport) void ray_set_viewport(Camera* camera, glm::ivec2 viewport)
{ {
std::lock_guard<std::mutex> lock(camera->_impl->CamMutex); std::lock_guard<std::mutex> lock(camera->_impl->CamMutex);
camera->Views->Ray = viewport; camera->Views.Ray = viewport;
} }
glm::ivec2 ray_get_viewport(std::unique_ptr<Camera>& camera) glm::ivec2 ray_get_viewport(Camera* camera)
{ {
std::lock_guard<std::mutex> lock(camera->_impl->CamMutex); std::lock_guard<std::mutex> lock(camera->_impl->CamMutex);
return camera->Views->Ray; return camera->Views.Ray;
} }
void camera_move(std::unique_ptr<Camera>& camera, uint8_t movement_delta) void camera_move(Camera* camera, uint8_t movement_delta)
{ {
if (movement_delta == 0) if (movement_delta == 0)
return; return;
@@ -186,7 +181,7 @@ void camera_move(std::unique_ptr<Camera>& camera, uint8_t movement_delta)
camera_update(camera); camera_update(camera);
} }
void camera_mouse_move(std::unique_ptr<Camera>& camera, glm::vec2 mouse_delta) void camera_mouse_move(Camera* camera, glm::vec2 mouse_delta)
{ {
if (glm::length(mouse_delta) == 0) if (glm::length(mouse_delta) == 0)
return; return;
@@ -199,13 +194,13 @@ void camera_mouse_move(std::unique_ptr<Camera>& camera, glm::vec2 mouse_delta)
camera_update(camera); camera_update(camera);
} }
void camera_set_position(std::unique_ptr<Camera>& camera, glm::vec3 position) void camera_set_position(Camera* camera, glm::vec3 position)
{ {
camera->Position = position; camera->Position = position;
camera_update(camera); camera_update(camera);
} }
void camera_set_euler_look(std::unique_ptr<Camera>& camera, float roll, float pitch, float yaw) void camera_set_euler_look(Camera* camera, float roll, float pitch, float yaw)
{ {
camera->Roll = roll; camera->Roll = roll;
camera->Pitch = pitch; camera->Pitch = pitch;
@@ -217,7 +212,7 @@ void camera_set_euler_look(std::unique_ptr<Camera>& camera, float roll, float pi
camera_update(camera); camera_update(camera);
} }
void camera_set_look(std::unique_ptr<Camera>& camera, glm::vec3 look_direction) void camera_set_look(Camera* camera, glm::vec3 look_direction)
{ {
camera->LookDirection = look_direction; camera->LookDirection = look_direction;
camera->Pitch = asin(-look_direction.y); camera->Pitch = asin(-look_direction.y);
@@ -226,4 +221,9 @@ void camera_set_look(std::unique_ptr<Camera>& camera, glm::vec3 look_direction)
camera_update(camera); camera_update(camera);
} }
glm::vec3 camera_get_position(Camera* camera)
{
return camera->Position;
}
} }

19
src/scene/material.cpp
View File

@@ -2,7 +2,7 @@
#include "preview_renderer/shader.hpp" #include "preview_renderer/shader.hpp"
using namespace inferno; namespace inferno::scene {
Material::Material(std::string name) Material::Material(std::string name)
: mName(name) : mName(name)
@@ -15,12 +15,13 @@ Material::~Material()
} }
//void Material::setGlShader(Shader* shader) void Material::setGlShader(graphics::Shader* shader)
//{ {
//mGlShader = shader; mGlShader = shader;
//} }
//Shader* Material::getGlShader() graphics::Shader* Material::getGlShader()
//{ {
//return mGlShader; return mGlShader;
//} }
}

13
src/scene/material.hpp
View File

@@ -4,9 +4,12 @@
#include <hart_graphics.hpp> #include <hart_graphics.hpp>
namespace inferno { namespace inferno::graphics {
class Shader;
};
namespace inferno::scene {
//class Shader;
class HitInfo; class HitInfo;
class Material { class Material {
@@ -15,14 +18,14 @@ public:
~Material(); ~Material();
std::string getName(); std::string getName();
//void setGlShader(Shader* shader); void setGlShader(graphics::Shader* shader);
//Shader* getGlShader(); graphics::Shader* getGlShader();
glm::vec3 sample(HitInfo* hit); glm::vec3 sample(HitInfo* hit);
private: private:
std::string mName; std::string mName;
//Shader* mGlShader; graphics::Shader* mGlShader;
}; };
} }

12
src/scene/mesh.cpp
View File

@@ -6,7 +6,7 @@
#include <iostream> #include <iostream>
using namespace inferno; namespace inferno::scene {
Mesh::Mesh() Mesh::Mesh()
{ {
@@ -27,7 +27,7 @@ void Mesh::loadOBJ(std::filesystem::path file)
for (int i = 0; i < vertCount * 3; i += 3) for (int i = 0; i < vertCount * 3; i += 3)
{ {
Vert vert; Vert vert;
vert.Position = { vert.Position = {
mObjLoader->getPositions()[i], mObjLoader->getPositions()[i],
mObjLoader->getPositions()[i+1], mObjLoader->getPositions()[i+1],
mObjLoader->getPositions()[i+2], mObjLoader->getPositions()[i+2],
@@ -53,17 +53,17 @@ void Mesh::ready()
// load data into vertex buffers // load data into vertex buffers
glBindBuffer(GL_ARRAY_BUFFER, mVBO); 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); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mEBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, mObjLoader->getIndexCount() * sizeof(uint32_t), &mObjLoader->getFaces()[0], GL_STATIC_DRAW); glBufferData(GL_ELEMENT_ARRAY_BUFFER, mObjLoader->getIndexCount() * sizeof(uint32_t), &mObjLoader->getFaces()[0], GL_STATIC_DRAW);
// set the vertex attribute pointers // set the vertex attribute pointers
// vertex Positions // vertex Positions
glEnableVertexAttribArray(0); glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vert), (void*)0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vert), (void*)0);
// vertex normals // vertex normals
glEnableVertexAttribArray(1); glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(Vert), (void*)offsetof(Vert, Normal)); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(Vert), (void*)offsetof(Vert, Normal));
// vertex UV // vertex UV
glEnableVertexAttribArray(2); glEnableVertexAttribArray(2);
@@ -116,3 +116,5 @@ GLuint Mesh::getEBO()
{ {
return mEBO; return mEBO;
} }
}

8
src/scene/mesh.hpp
View File

@@ -1,15 +1,15 @@
#pragma once #pragma once
#include <vector> #include <vector>
#include <filesystem> #include <filesystem>
#include <hart_graphics.hpp> #include <hart_graphics.hpp>
namespace inferno { namespace inferno::scene {
class ObjLoader; class ObjLoader;
class Material; class Material;
// TODO: This should be procedural like everything else
struct Vert struct Vert
{ {
glm::vec3 Position; glm::vec3 Position;
@@ -17,7 +17,7 @@ struct Vert
glm::vec2 UV; glm::vec2 UV;
}; };
class Mesh class Mesh
{ {
public: public:
Mesh(); Mesh();
@@ -49,7 +49,7 @@ private:
private: private:
ObjLoader* mObjLoader; ObjLoader* mObjLoader;
Material* mMaterial; Material* mMaterial;
std::vector<Vert> mVerticies; std::vector<Vert> mVerticies;
}; };

29
src/scene/object.cpp
View File

@@ -0,0 +1,29 @@
#include "object.hpp"
#include "mesh.hpp"
namespace inferno::scene {
SceneObject* scene_object_create()
{
SceneObject* object = new SceneObject;
return object;
}
void scene_object_cleanup(SceneObject* object)
{
}
void scene_object_add_mesh(SceneObject* object, Mesh* mesh)
{
object->Meshs.push_back(mesh);
}
std::vector<Mesh*>& scene_object_get_meshs(SceneObject* object)
{
return object->Meshs;
}
}

21
src/scene/object.hpp
View File

@@ -1,19 +1,20 @@
#pragma once #pragma once
#include <memory>
#include <vector> #include <vector>
namespace inferno { namespace inferno::scene {
class Mesh; class Mesh;
class Object typedef struct SceneObject {
{ std::vector<Mesh*> Meshs;
public: } SceneObject;
Object();
~Object();
private: SceneObject* scene_object_create();
std::vector<Mesh*> mMeshs; void scene_object_cleanup(SceneObject* object);
};
} void scene_object_add_mesh(SceneObject* object, Mesh* mesh);
std::vector<Mesh*>& scene_object_get_meshs(SceneObject* object);
} // namespace inferno::scene

26
src/scene/objloader.cpp
View File

@@ -10,7 +10,7 @@
#include <assert.h> #include <assert.h>
#include <map> #include <map>
using namespace inferno; namespace inferno::scene {
struct FaceVert struct FaceVert
{ {
@@ -60,7 +60,7 @@ void ObjLoader::load(std::filesystem::path file)
std::ifstream inf; std::ifstream inf;
inf.open(file.c_str(), std::ios_base::in); 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()); yolo::error("Failed to open OBJ file ", file.string());
return; return;
@@ -82,7 +82,7 @@ void ObjLoader::load(std::filesystem::path file)
std::map<FaceVert, int, vert_less> uniqueverts; std::map<FaceVert, int, vert_less> uniqueverts;
unsigned int vert_count = 0; unsigned int vert_count = 0;
while (inf.good()) while (inf.good())
{ {
memset( (void*)line, 0, CHARACTER_COUNT); memset( (void*)line, 0, CHARACTER_COUNT);
inf.getline(line, CHARACTER_COUNT); inf.getline(line, CHARACTER_COUNT);
@@ -94,7 +94,7 @@ void ObjLoader::load(std::filesystem::path file)
// verts look like: // verts look like:
// v float float float // v float float float
if (strcmp(token, "v") == 0) if (strcmp(token, "v") == 0)
{ {
float x=0, y=0, z=0, w=1; float x=0, y=0, z=0, w=1;
sscanf(line+2, "%f %f %f %f", &x, &y, &z, &w); sscanf(line+2, "%f %f %f %f", &x, &y, &z, &w);
@@ -110,7 +110,7 @@ void ObjLoader::load(std::filesystem::path file)
} }
// texcoords: // texcoords:
// vt float float // vt float float
else if (strcmp(token, "vt") == 0) else if (strcmp(token, "vt") == 0)
{ {
float x=0, y=0, z=0; float x=0, y=0, z=0;
sscanf(line+3, "%f %f %f", &x, &y, &z); 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 // keep track of smoothing groups
// s [number|off] // s [number|off]
else if (strcmp(token, "s") == 0) else if (strcmp(token, "s") == 0)
{ {
} }
// faces start with: // faces start with:
// f // f
else if (strcmp(token, "f") == 0) else if (strcmp(token, "f") == 0)
{ {
std::vector<int> vindices; std::vector<int> 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 // being that some exporters can export either 3 or 4 sided polygon's
// convert what ever was exported into triangles // convert what ever was exported into triangles
for (size_t i=1; i<vindices.size()-1; ++i) for (size_t i=1; i<vindices.size()-1; ++i)
{ {
Face face; Face face;
FaceVert tri; FaceVert tri;
@@ -211,21 +211,21 @@ void ObjLoader::load(std::filesystem::path file)
mTexCoords.resize(vert_count); mTexCoords.resize(vert_count);
std::map<FaceVert, int, vert_less>::iterator iter; std::map<FaceVert, int, vert_less>::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]; mPositions[iter->second] = verts[iter->first.vert];
if ( norms.size() > 0 ) if ( norms.size() > 0 )
{ {
mNormals[iter->second] = norms[iter->first.norm]; mNormals[iter->second] = norms[iter->first.norm];
} }
if ( texcoords.size() > 0) if ( texcoords.size() > 0)
{ {
mTexCoords[iter->second] = texcoords[iter->first.coord]; mTexCoords[iter->second] = texcoords[iter->first.coord];
} }
} }
} }
int ObjLoader::getIndexCount() int ObjLoader::getIndexCount()
@@ -263,3 +263,5 @@ const float* ObjLoader::getTexCoords(int multiTexCoordLayer)
assert(multiTexCoordLayer < mTexCoordLayers); assert(multiTexCoordLayer < mTexCoordLayers);
return (const float*)&mTexCoords[0]; return (const float*)&mTexCoords[0];
} }
}

2
src/scene/objloader.hpp
View File

@@ -5,7 +5,7 @@
#include <hart_graphics.hpp> #include <hart_graphics.hpp>
namespace inferno { namespace inferno::scene {
struct Face struct Face
{ {

36
src/scene/scene.cpp
View File

@@ -1,55 +1,61 @@
#include "scene.hpp" #include "scene.hpp"
#include <yolo/yolo.hpp>
#include <memory>
#include <scene/camera.hpp> #include <scene/camera.hpp>
#include <scene/mesh.hpp> #include <scene/mesh.hpp>
#include <scene/object.hpp> #include <scene/object.hpp>
namespace inferno::scene { namespace inferno::scene {
std::unique_ptr<Scene> scene_create() Scene* scene_create()
{ {
std::unique_ptr<Scene> scene = std::make_unique<Scene>(); Scene* scene = new Scene;
scene->Camera = std::make_shared<graphics::Camera>(); scene->Objects = std::vector<SceneObject*>();
scene->Camera = graphics::camera_create();
yolo::debug("Created scene {} and camera {}", scene, scene->Camera);
return scene; return scene;
} }
void scene_cleanup(std::unique_ptr<Scene>& scene) void scene_cleanup(Scene* scene)
{ {
} }
void scene_set_camera(std::unique_ptr<Scene>& scene, std::shared_ptr<graphics::Camera> camera) void scene_add_object(Scene* scene, SceneObject* object)
{ {
scene->Camera = camera; 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; scene->DidUpdate = true;
} }
void scene_add_object(std::unique_ptr<Scene>& scene, std::unique_ptr<SceneObject> object) graphics::Camera* scene_get_camera(Scene* scene)
{ {
scene->Objects.push_back(std::move(object)); return scene->Camera;
scene->DidUpdate = true;
} }
std::vector<std::unique_ptr<SceneObject>>& scene_get_renderables(std::unique_ptr<Scene>& scene) std::vector<SceneObject*>& scene_get_renderables(Scene* scene)
{ {
return scene->Objects; return scene->Objects;
} }
bool scene_did_update(std::unique_ptr<Scene>& scene) bool scene_did_update(Scene* scene)
{ {
return scene->DidUpdate; return scene->DidUpdate;
} }
void scene_frame_tick(std::unique_ptr<Scene>& scene) void scene_frame_tick(Scene* scene)
{ {
scene->DidUpdate = false; scene->DidUpdate = false;
} }
void scene_tick(std::unique_ptr<Scene>& scene) void scene_tick(Scene* scene)
{ {
for (auto& object : scene->Objects) { for (auto& object : scene->Objects) {
// object->tick(); // Shit here like animation idk
} }
} }
} }

29
src/scene/scene.hpp
View File

@@ -1,5 +1,7 @@
#pragma once #pragma once
#include "scene/object.hpp"
#include <memory> #include <memory>
#include <vector> #include <vector>
@@ -13,19 +15,22 @@ class SceneObject;
class Mesh; class Mesh;
typedef struct Scene { typedef struct Scene {
std::shared_ptr<graphics::Camera> Camera; std::vector<SceneObject*> Objects;
std::vector<std::unique_ptr<SceneObject>> Objects; graphics::Camera* Camera;
bool DidUpdate = false; bool DidUpdate = false;
} Scene; } Scene;
std::unique_ptr<Scene> scene_create(); Scene* scene_create();
void scene_cleanup(std::unique_ptr<Scene>& scene); void scene_cleanup(Scene* scene);
void scene_set_camera(std::unique_ptr<Scene>& scene, std::shared_ptr<graphics::Camera> camera);
void scene_add_object(std::unique_ptr<Scene>& scene, std::unique_ptr<SceneObject> object);
std::unique_ptr<graphics::Camera>& scene_get_camera(std::unique_ptr<Scene>& scene);
std::vector<std::unique_ptr<SceneObject>>& scene_get_renderables(std::unique_ptr<Scene>& scene);
bool scene_did_update(std::unique_ptr<Scene>& scene);
void scene_frame_tick(std::unique_ptr<Scene>& scene);
void scene_tick(std::unique_ptr<Scene>& scene);
} void scene_add_object(Scene* scene, SceneObject* object);
graphics::Camera* scene_get_camera(Scene* scene);
std::vector<SceneObject*>& scene_get_renderables(Scene* scene);
bool scene_did_update(Scene* scene);
void scene_frame_tick(Scene* scene);
void scene_tick(Scene* scene);
} // namespace inferno::scene

2
src/version.hpp
View File

@@ -1,3 +1,3 @@
#pragma once #pragma once
#define INFERNO_VERSION "3.0.1_alpha" #define INFERNO_VERSION "3.0.13_alpha"

4
src/window.cpp
View File

@@ -60,6 +60,10 @@ void setupGLFW(std::string title)
glfwMakeContextCurrent(Window); glfwMakeContextCurrent(Window);
gladLoadGLLoader((GLADloadproc)glfwGetProcAddress); gladLoadGLLoader((GLADloadproc)glfwGetProcAddress);
glfwSwapInterval(1); // Enable vsync 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() void setupImGui()