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

what even did i do i forgot

Browse Source
This commit is contained in:
Ben Kyd
2023-11-22 00:09:35 +00:00
parent 3f44d56597
commit e76455f902
11 changed files with 432 additions and 420 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
CMakeLists.txt
View File

@@ -1,7 +1,7 @@
cmake_minimum_required(VERSION 3.13)
project(inferno)
file(GLOB SRC "src/*.cpp" "src/graphics/*.cpp")
file(GLOB SRC "src/*.cpp" "src/graphics/*.cpp" "src/preview_renderer/*.cpp")
add_executable(inferno ${SRC})
target_include_directories(inferno PRIVATE "libhart/thirdparty")
@@ -48,7 +48,6 @@ foreach(SHADER ${SHADERS})
list(APPEND SPIRV_BINARY_FILES ${SPIRV})
endforeach(SHADER)
# ..then link them
add_custom_target(
shaders
DEPENDS ${SPIRV_BINARY_FILES}

50
src/graphics/pipeline.cpp
View File

@@ -5,8 +5,9 @@
#include "renderpass.hpp"
#include "swapchain.hpp"
#include <cstdint>
#include "yolo/yolo.hpp"
#include <vulkan/vulkan_core.h>
namespace inferno::graphics {
@@ -17,15 +18,15 @@ Pipeline* pipeline_create(GraphicsDevice* device)
pipeline->Device = device;
pipeline->Swap = swapchain_create(device, device->SurfaceSize);
std::vector<VkDynamicState> dynamicStates = {
VK_DYNAMIC_STATE_VIEWPORT,
VK_DYNAMIC_STATE_SCISSOR,
};
pipeline->DynamicStateCreateInfo.sType
= VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
pipeline->DynamicStateCreateInfo.dynamicStateCount = dynamicStates.size();
pipeline->DynamicStateCreateInfo.pDynamicStates = dynamicStates.data();
// std::vector<VkDynamicState> dynamicStates = {
// VK_DYNAMIC_STATE_VIEWPORT,
// VK_DYNAMIC_STATE_SCISSOR,
// };
//
// pipeline->DynamicStateCreateInfo.sType
// = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
// pipeline->DynamicStateCreateInfo.dynamicStateCount = (uint32_t)dynamicStates.size();
// pipeline->DynamicStateCreateInfo.pDynamicStates = dynamicStates.data();
pipeline->VertexInputInfo.sType
= VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
@@ -43,21 +44,24 @@ Pipeline* pipeline_create(GraphicsDevice* device)
// NOTE: This is where the viewport and scissor are set
// In reality, these should be dynamic, so they can be changed
// VkViewport viewport = {};
// viewport.x = 0.f;
// viewport.y = 0.f;
// viewport.width = (float)pipeline->Swap->Extent.width;
// viewport.height = (float)pipeline->Swap->Extent.height;
// viewport.minDepth = 0.f
// viewport.maxDepth = 1.f;
//
// VkRect2D scissor = {};
// scissor.offset = { 0, 0 };
// scissor.extent = pipeline->Swap->Extent;
VkViewport viewport = {};
viewport.x = 0.f;
viewport.y = 0.f;
viewport.width = (float)pipeline->Swap->Extent.width;
viewport.height = (float)pipeline->Swap->Extent.height;
viewport.minDepth = 0.f;
viewport.maxDepth = 1.f;
yolo::debug("Viewport size: {}x{}", viewport.width, viewport.height);
VkRect2D scissor = {};
scissor.offset = { 0, 0 };
scissor.extent = pipeline->Swap->Extent;
pipeline->ViewportState.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
pipeline->ViewportState.viewportCount = 1;
pipeline->ViewportState.pViewports = &viewport;
pipeline->ViewportState.scissorCount = 1;
pipeline->ViewportState.pScissors = &scissor;
pipeline->Rasterizer.sType
= VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
@@ -143,7 +147,7 @@ void pipeline_configure_to_renderpass(
pipelineInfo.pMultisampleState = &pipeline->Multisampling;
pipelineInfo.pDepthStencilState = nullptr; // Optional
pipelineInfo.pColorBlendState = &pipeline->ColorBlending;
pipelineInfo.pDynamicState = &pipeline->DynamicStateCreateInfo;
// pipelineInfo.pDynamicState = &pipeline->DynamicStateCreateInfo;
pipelineInfo.layout = pipeline->Layout;
pipelineInfo.renderPass = renderpass->RenderPass;
@@ -157,6 +161,8 @@ void pipeline_configure_to_renderpass(
!= VK_SUCCESS) {
yolo::error("failed to create graphics pipeline!");
}
yolo::info("Created graphics pipeline");
}
} // namespace inferno::graphics

3
src/graphics/renderpass.cpp
View File

@@ -14,6 +14,7 @@ RenderPass* renderpass_create(GraphicsDevice* device)
{
RenderPass* renderpass = new RenderPass;
renderpass->Device = device;
// TODO: this can be done at the end to reduce the complexity of the pipeline creation
renderpass->RenderPipeline = pipeline_create(device);
VkAttachmentDescription colorAttachment = {};
@@ -49,7 +50,7 @@ RenderPass* renderpass_create(GraphicsDevice* device)
return nullptr;
}
Shader* shader = shader_create(device->VulkanDevice);
Shader* shader = shader_create(device);
shader_load(shader, "res/shaders/vulkan_test");
pipeline_configure_to_renderpass(renderpass->RenderPipeline, shader, renderpass);

6
src/graphics/swapchain.cpp
View File

@@ -71,9 +71,12 @@ VkExtent2D device_choose_swap_extent(
const VkSurfaceCapabilitiesKHR& capabilities, int width, int height)
{
if (capabilities.currentExtent.width != UINT32_MAX) {
yolo::info("Surface size: {}x{}", capabilities.currentExtent.width,
capabilities.currentExtent.height);
return capabilities.currentExtent;
} else {
VkExtent2D actualExtent = { (uint32_t)width, (uint32_t)height };
yolo::info("Surface size: {}x{}", width, height);
actualExtent.width = std::max(capabilities.minImageExtent.width,
std::min(capabilities.maxImageExtent.width, actualExtent.width));
@@ -96,8 +99,10 @@ SwapChain* swapchain_create(GraphicsDevice* device, glm::ivec2 surface_size)
= device_choose_swap_surface_format(swapChainSupport.Formats);
VkPresentModeKHR presentMode
= device_choose_swap_present_mode(swapChainSupport.PresentModes);
yolo::debug("Surface format: {}", surfaceFormat.format);
VkExtent2D extent = device_choose_swap_extent(
swapChainSupport.Capabilities, surface_size.x, surface_size.y);
swapchain->Extent = extent;
uint32_t imageCount = swapChainSupport.Capabilities.minImageCount + 1;
if (swapChainSupport.Capabilities.maxImageCount > 0
@@ -152,7 +157,6 @@ SwapChain* swapchain_create(GraphicsDevice* device, glm::ivec2 surface_size)
device->VulkanDevice, swapchain->Handle, &imageCount, swapchain->Images.data());
swapchain->ImageFormat = surfaceFormat.format;
swapchain->Extent = extent;
swapchain->Device = device;
swapchain_image_view_create(swapchain);

2
src/inferno.hpp
View File

@@ -49,7 +49,7 @@ typedef struct InfernoInput {
typedef struct InfernoApp {
InfernoInput* Input;
scene::Scene* Scene;
graphics::PreviewRenderer* PreviewRenderer;
// graphics::PreviewRenderer* PreviewRenderer;
graphics::RayRenderer* RayRenderer;
InfernoTimer* MainTimer;

306
src/preview_renderer/debug.cpp
View File

@@ -1,153 +1,153 @@
#include "debug.hpp"
#include "preview_renderer/renderer.hpp"
#include "preview_renderer/shader.hpp"
#include "scene/camera.hpp"
#include "scene/scene.hpp"
#include <graphics.hpp>
#include <yolo/yolo.hpp>
namespace inferno::graphics {
struct DebugLine {
glm::vec3 Start;
glm::vec3 End;
glm::vec3 Color;
};
struct DebugTextBillboard {
glm::vec3 Position;
glm::vec3 Color;
std::string Text;
};
struct _DebugInternal {
std::mutex DebugMutex;
GLuint VAO;
GLuint VBO;
Shader* LineShader;
};
static DebugDrawer* DebugDrawerInstance = nullptr;
void debug_init()
{
DebugDrawerInstance = new DebugDrawer;
DebugDrawerInstance->LineElements = std::vector<DebugLine>();
DebugDrawerInstance->BillboardElements = std::vector<DebugTextBillboard>();
DebugDrawerInstance->_Internal = new _DebugInternal;
DebugDrawerInstance->_Internal->LineShader = shader_create();
shader_load(DebugDrawerInstance->_Internal->LineShader, "res/shaders/lines_debug.glsl");
shader_link(DebugDrawerInstance->_Internal->LineShader);
glGenVertexArrays(1, &DebugDrawerInstance->_Internal->VAO);
glBindVertexArray(DebugDrawerInstance->_Internal->VAO);
glGenBuffers(1, &DebugDrawerInstance->_Internal->VBO);
glBindBuffer(GL_ARRAY_BUFFER, DebugDrawerInstance->_Internal->VBO);
yolo::debug("DebugDrawer initialized");
}
void debug_cleanup()
{
delete DebugDrawerInstance;
}
void debug_attach_renderer(PreviewRenderer* renderer)
{
DebugDrawerInstance->Renderer = renderer;
}
void debug_draw_line(glm::vec3 start, glm::vec3 end, glm::vec3 color)
{
std::lock_guard<std::mutex> lock(DebugDrawerInstance->_Internal->DebugMutex);
DebugDrawerInstance->LineElements.push_back({ start, end, color });
}
void debug_draw_text_billboard(glm::vec3 position, glm::vec3 color, std::string text)
{
std::lock_guard<std::mutex> lock(DebugDrawerInstance->_Internal->DebugMutex);
DebugDrawerInstance->BillboardElements.push_back({ position, color, text });
}
void debug_draw_ui()
{
ImGui::Checkbox("Show Overlay", &DebugDrawerInstance->DoShow);
}
void debug_draw_to_target(scene::Scene* scene)
{
if (!DebugDrawerInstance->DoShow)
return;
auto renderer = DebugDrawerInstance->Renderer;
glBindFramebuffer(GL_FRAMEBUFFER, renderer->RenderTarget);
glDisable(GL_DEPTH_TEST);
glBindBuffer(GL_ARRAY_BUFFER, DebugDrawerInstance->_Internal->VBO);
glBindVertexArray(DebugDrawerInstance->_Internal->VAO);
GLuint vertex_position_arr_size = DebugDrawerInstance->LineElements.size() * 2 * 3;
GLfloat vertex_position_arr[vertex_position_arr_size];
for (int i = 0; i < DebugDrawerInstance->LineElements.size(); i++) {
auto line = DebugDrawerInstance->LineElements[i];
vertex_position_arr[i * 6 + 0] = line.Start.x;
vertex_position_arr[i * 6 + 1] = line.Start.y;
vertex_position_arr[i * 6 + 2] = line.Start.z;
vertex_position_arr[i * 6 + 3] = line.End.x;
vertex_position_arr[i * 6 + 4] = line.End.y;
vertex_position_arr[i * 6 + 5] = line.End.z;
}
glBufferData(GL_ARRAY_BUFFER, vertex_position_arr_size * sizeof(GLfloat), vertex_position_arr, GL_STATIC_DRAW);
Shader* shader = DebugDrawerInstance->_Internal->LineShader;
shader_use(shader);
GLint posAttrib = glGetAttribLocation(graphics::shader_get_program(shader), "position");
glVertexAttribPointer(posAttrib, 3, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(posAttrib);
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));
glDrawArrays(GL_LINES, 0, vertex_position_arr_size);
DebugDrawerInstance->LineElements.clear();
// glEnable(GL_TEXTURE_2D);
// glEnable(GL_BLEND);
// glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
//
// for (auto& billboard : DebugDrawerInstance->BillboardElements) {
// glColor3f(billboard.Color.x, billboard.Color.y, billboard.Color.z);
// glRasterPos3f(billboard.Position.x, billboard.Position.y, billboard.Position.z);
//
// for (auto& c : billboard.Text) {
// glutBitmapCharacter(GL_BITMAP, c);
// }
// }
DebugDrawerInstance->BillboardElements.clear();
glEnable(GL_DEPTH_TEST);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
}
// #include "debug.hpp"
//
// #include "preview_renderer/renderer.hpp"
// #include "preview_renderer/shader.hpp"
// #include "scene/camera.hpp"
// #include "scene/scene.hpp"
//
// #include <graphics.hpp>
// #include <yolo/yolo.hpp>
//
// namespace inferno::graphics {
//
// struct DebugLine {
// glm::vec3 Start;
// glm::vec3 End;
// glm::vec3 Color;
// };
//
// struct DebugTextBillboard {
// glm::vec3 Position;
// glm::vec3 Color;
// std::string Text;
// };
//
// struct _DebugInternal {
// std::mutex DebugMutex;
//
// GLuint VAO;
// GLuint VBO;
// Shader* LineShader;
// };
//
// static DebugDrawer* DebugDrawerInstance = nullptr;
//
// void debug_init()
// {
// DebugDrawerInstance = new DebugDrawer;
//
// DebugDrawerInstance->LineElements = std::vector<DebugLine>();
// DebugDrawerInstance->BillboardElements = std::vector<DebugTextBillboard>();
//
// DebugDrawerInstance->_Internal = new _DebugInternal;
// DebugDrawerInstance->_Internal->LineShader = shader_create();
// shader_load(DebugDrawerInstance->_Internal->LineShader, "res/shaders/lines_debug.glsl");
// shader_link(DebugDrawerInstance->_Internal->LineShader);
//
// glGenVertexArrays(1, &DebugDrawerInstance->_Internal->VAO);
// glBindVertexArray(DebugDrawerInstance->_Internal->VAO);
//
// glGenBuffers(1, &DebugDrawerInstance->_Internal->VBO);
// glBindBuffer(GL_ARRAY_BUFFER, DebugDrawerInstance->_Internal->VBO);
//
// yolo::debug("DebugDrawer initialized");
// }
//
// void debug_cleanup()
// {
// delete DebugDrawerInstance;
// }
//
// void debug_attach_renderer(PreviewRenderer* renderer)
// {
// DebugDrawerInstance->Renderer = renderer;
// }
//
// void debug_draw_line(glm::vec3 start, glm::vec3 end, glm::vec3 color)
// {
// std::lock_guard<std::mutex> lock(DebugDrawerInstance->_Internal->DebugMutex);
// DebugDrawerInstance->LineElements.push_back({ start, end, color });
// }
//
// void debug_draw_text_billboard(glm::vec3 position, glm::vec3 color, std::string text)
// {
// std::lock_guard<std::mutex> lock(DebugDrawerInstance->_Internal->DebugMutex);
// DebugDrawerInstance->BillboardElements.push_back({ position, color, text });
// }
//
// void debug_draw_ui()
// {
// ImGui::Checkbox("Show Overlay", &DebugDrawerInstance->DoShow);
// }
//
// void debug_draw_to_target(scene::Scene* scene)
// {
// if (!DebugDrawerInstance->DoShow)
// return;
//
// auto renderer = DebugDrawerInstance->Renderer;
//
// glBindFramebuffer(GL_FRAMEBUFFER, renderer->RenderTarget);
//
// glDisable(GL_DEPTH_TEST);
//
// glBindBuffer(GL_ARRAY_BUFFER, DebugDrawerInstance->_Internal->VBO);
// glBindVertexArray(DebugDrawerInstance->_Internal->VAO);
//
// GLuint vertex_position_arr_size = DebugDrawerInstance->LineElements.size() * 2 * 3;
// GLfloat vertex_position_arr[vertex_position_arr_size];
// for (int i = 0; i < DebugDrawerInstance->LineElements.size(); i++) {
// auto line = DebugDrawerInstance->LineElements[i];
// vertex_position_arr[i * 6 + 0] = line.Start.x;
// vertex_position_arr[i * 6 + 1] = line.Start.y;
// vertex_position_arr[i * 6 + 2] = line.Start.z;
// vertex_position_arr[i * 6 + 3] = line.End.x;
// vertex_position_arr[i * 6 + 4] = line.End.y;
// vertex_position_arr[i * 6 + 5] = line.End.z;
// }
//
// glBufferData(GL_ARRAY_BUFFER, vertex_position_arr_size * sizeof(GLfloat), vertex_position_arr, GL_STATIC_DRAW);
//
// Shader* shader = DebugDrawerInstance->_Internal->LineShader;
// shader_use(shader);
//
// GLint posAttrib = glGetAttribLocation(graphics::shader_get_program(shader), "position");
// glVertexAttribPointer(posAttrib, 3, GL_FLOAT, GL_FALSE, 0, 0);
// glEnableVertexAttribArray(posAttrib);
//
// 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));
//
// glDrawArrays(GL_LINES, 0, vertex_position_arr_size);
//
// DebugDrawerInstance->LineElements.clear();
//
// // glEnable(GL_TEXTURE_2D);
// // glEnable(GL_BLEND);
// // glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// //
// // for (auto& billboard : DebugDrawerInstance->BillboardElements) {
// // glColor3f(billboard.Color.x, billboard.Color.y, billboard.Color.z);
// // glRasterPos3f(billboard.Position.x, billboard.Position.y, billboard.Position.z);
// //
// // for (auto& c : billboard.Text) {
// // glutBitmapCharacter(GL_BITMAP, c);
// // }
// // }
//
// DebugDrawerInstance->BillboardElements.clear();
//
// glEnable(GL_DEPTH_TEST);
// glBindFramebuffer(GL_FRAMEBUFFER, 0);
// }
//
// }

88
src/preview_renderer/debug.hpp
View File

@@ -1,44 +1,44 @@
#pragma once
#include <graphics.hpp>
#include <string>
#include <optional>
#include <vector>
#include <mutex>
namespace inferno::scene {
struct Scene;
}
namespace inferno::graphics {
struct PreviewRenderer;
struct DebugLine;
struct DebugTextBillboard;
struct _DebugInternal;
struct DebugDrawer {
_DebugInternal* _Internal = nullptr;
bool DoShow = true;
PreviewRenderer* Renderer = nullptr;
std::vector<DebugLine> LineElements;
std::vector<DebugTextBillboard> BillboardElements;
};
void debug_init();
void debug_cleanup();
void debug_attach_renderer(PreviewRenderer* renderer);
void debug_draw_line(glm::vec3 start, glm::vec3 end, glm::vec3 color);
void debug_draw_text_billboard(glm::vec3 position, glm::vec3 color, std::string text);
void debug_draw_ui();
void debug_draw_to_target(scene::Scene* scene);
}
// #pragma once
//
// #include <graphics.hpp>
//
// #include <string>
// #include <optional>
// #include <vector>
// #include <mutex>
//
// namespace inferno::scene {
// struct Scene;
// }
//
// namespace inferno::graphics {
//
// struct PreviewRenderer;
//
// struct DebugLine;
// struct DebugTextBillboard;
//
// struct _DebugInternal;
//
// struct DebugDrawer {
// _DebugInternal* _Internal = nullptr;
//
// bool DoShow = true;
// PreviewRenderer* Renderer = nullptr;
// std::vector<DebugLine> LineElements;
// std::vector<DebugTextBillboard> BillboardElements;
// };
//
// void debug_init();
// void debug_cleanup();
//
// void debug_attach_renderer(PreviewRenderer* renderer);
//
// void debug_draw_line(glm::vec3 start, glm::vec3 end, glm::vec3 color);
// void debug_draw_text_billboard(glm::vec3 position, glm::vec3 color, std::string text);
//
// void debug_draw_ui();
//
// void debug_draw_to_target(scene::Scene* scene);
//
// }

300
src/preview_renderer/renderer.cpp
View File

@@ -1,150 +1,150 @@
#include "renderer.hpp"
#include <graphics.hpp>
#include "preview_renderer/debug.hpp"
#include "scene/object.hpp"
#include "shader.hpp"
#include <yolo/yolo.hpp>
#include <algorithm>
#include <scene/camera.hpp>
#include <scene/material.hpp>
#include <scene/mesh.hpp>
#include <scene/object.hpp>
#include <scene/scene.hpp>
#include <iostream>
namespace inferno::graphics {
PreviewRenderer* preview_create()
{
PreviewRenderer* renderer = new PreviewRenderer;
glGenFramebuffers(1, &renderer->RenderTarget);
glBindFramebuffer(GL_FRAMEBUFFER, renderer->RenderTarget);
glGenTextures(1, &renderer->RenderTargetTexture);
glBindTexture(GL_TEXTURE_2D, renderer->RenderTargetTexture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 800, 600, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glGenTextures(1, &renderer->RenderTargetDepthTexture);
glBindTexture(GL_TEXTURE_2D, renderer->RenderTargetDepthTexture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH24_STENCIL8, 800, 600, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
// Attach the texture to the framebuffer.
glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, renderer->RenderTargetDepthTexture, 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, renderer->RenderTargetTexture, 0);
assert(glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
// bind preview renderer to debugdraw
debug_init();
debug_attach_renderer(renderer);
return renderer;
}
void preview_cleanup(PreviewRenderer* renderer)
{
}
void preview_draw_ui(PreviewRenderer* renderer)
{
}
void preview_set_viewport(PreviewRenderer* renderer, Camera* camera)
{
auto viewport = camera_raster_get_viewport(camera);
renderer->Viewport = viewport;
glBindFramebuffer(GL_FRAMEBUFFER, renderer->RenderTarget);
glBindTexture(GL_TEXTURE_2D, renderer->RenderTargetTexture);
glTexImage2D(
GL_TEXTURE_2D,
0,
GL_RGB,
renderer->Viewport.x,
renderer->Viewport.y,
0,
GL_RGB,
GL_UNSIGNED_BYTE,
NULL);
glBindTexture(GL_TEXTURE_2D, renderer->RenderTargetDepthTexture);
glTexImage2D(GL_TEXTURE_2D,
0,
GL_DEPTH24_STENCIL8,
renderer->Viewport.x,
renderer->Viewport.y,
0,
GL_DEPTH_COMPONENT,
GL_FLOAT,
NULL);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
GLuint preview_get_rendered_texture(PreviewRenderer* renderer)
{
glBindFramebuffer(GL_FRAMEBUFFER, renderer->RenderTarget);
return renderer->RenderTargetTexture;
}
void preview_draw(PreviewRenderer* renderer, scene::Scene* scene)
{
// clear
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);
// draw
glBindFramebuffer(GL_FRAMEBUFFER, renderer->RenderTarget);
glViewport(0,
0,
renderer->Viewport.x,
renderer->Viewport.y);
glEnable(GL_DEPTH_TEST);
for (scene::SceneObject* o : scene::scene_get_renderables(scene)) {
for (scene::Mesh* m : scene::scene_object_get_meshs(o)) {
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());
glDrawElements(GL_TRIANGLES, m->getIndexCount() * sizeof(uint32_t), GL_UNSIGNED_INT, 0);
}
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
}
// #include "renderer.hpp"
//
// #include <graphics.hpp>
//
// #include "preview_renderer/debug.hpp"
// #include "scene/object.hpp"
// #include "shader.hpp"
//
// #include <yolo/yolo.hpp>
//
// #include <algorithm>
// #include <scene/camera.hpp>
// #include <scene/material.hpp>
// #include <scene/mesh.hpp>
// #include <scene/object.hpp>
// #include <scene/scene.hpp>
//
// #include <iostream>
//
// namespace inferno::graphics {
//
// PreviewRenderer* preview_create()
// {
// PreviewRenderer* renderer = new PreviewRenderer;
//
// glGenFramebuffers(1, &renderer->RenderTarget);
// glBindFramebuffer(GL_FRAMEBUFFER, renderer->RenderTarget);
//
// glGenTextures(1, &renderer->RenderTargetTexture);
// glBindTexture(GL_TEXTURE_2D, renderer->RenderTargetTexture);
// glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 800, 600, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
//
// glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
// glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
//
// glGenTextures(1, &renderer->RenderTargetDepthTexture);
// glBindTexture(GL_TEXTURE_2D, renderer->RenderTargetDepthTexture);
// glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH24_STENCIL8, 800, 600, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
//
// glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
// glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
// glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
// glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
//
// // Attach the texture to the framebuffer.
// glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, renderer->RenderTargetDepthTexture, 0);
// glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, renderer->RenderTargetTexture, 0);
//
// assert(glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE);
// glBindFramebuffer(GL_FRAMEBUFFER, 0);
//
// // bind preview renderer to debugdraw
// debug_init();
// debug_attach_renderer(renderer);
//
// return renderer;
// }
//
// void preview_cleanup(PreviewRenderer* renderer)
// {
// }
//
// void preview_draw_ui(PreviewRenderer* renderer)
// {
// }
//
// void preview_set_viewport(PreviewRenderer* renderer, Camera* camera)
// {
// auto viewport = camera_raster_get_viewport(camera);
// renderer->Viewport = viewport;
//
// glBindFramebuffer(GL_FRAMEBUFFER, renderer->RenderTarget);
//
// glBindTexture(GL_TEXTURE_2D, renderer->RenderTargetTexture);
// glTexImage2D(
// GL_TEXTURE_2D,
// 0,
// GL_RGB,
// renderer->Viewport.x,
// renderer->Viewport.y,
// 0,
// GL_RGB,
// GL_UNSIGNED_BYTE,
// NULL);
//
// glBindTexture(GL_TEXTURE_2D, renderer->RenderTargetDepthTexture);
// glTexImage2D(GL_TEXTURE_2D,
// 0,
// GL_DEPTH24_STENCIL8,
// renderer->Viewport.x,
// renderer->Viewport.y,
// 0,
// GL_DEPTH_COMPONENT,
// GL_FLOAT,
// NULL);
//
// glBindFramebuffer(GL_FRAMEBUFFER, 0);
// }
//
// GLuint preview_get_rendered_texture(PreviewRenderer* renderer)
// {
// glBindFramebuffer(GL_FRAMEBUFFER, renderer->RenderTarget);
// return renderer->RenderTargetTexture;
// }
//
// void preview_draw(PreviewRenderer* renderer, scene::Scene* scene)
// {
// // clear
// 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);
//
// // draw
// glBindFramebuffer(GL_FRAMEBUFFER, renderer->RenderTarget);
// glViewport(0,
// 0,
// renderer->Viewport.x,
// renderer->Viewport.y);
//
// glEnable(GL_DEPTH_TEST);
//
// for (scene::SceneObject* o : scene::scene_get_renderables(scene)) {
// for (scene::Mesh* m : scene::scene_object_get_meshs(o)) {
// 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());
//
// glDrawElements(GL_TRIANGLES, m->getIndexCount() * sizeof(uint32_t), GL_UNSIGNED_INT, 0);
// }
// }
//
// glBindFramebuffer(GL_FRAMEBUFFER, 0);
// }
//
// }

74
src/preview_renderer/renderer.hpp
View File

@@ -1,37 +1,37 @@
#pragma once
#include <graphics.hpp>
#include <memory>
namespace inferno::scene {
struct Scene;
}
namespace inferno::graphics {
struct Viewport;
struct Camera;
struct DebugDraw;
typedef struct PreviewRenderer {
glm::ivec2 Viewport;
GLuint RenderTarget = 0;
GLuint RenderTargetTexture = 0;
GLuint RenderTargetDepthTexture = 0;
} PreviewRenderer;
PreviewRenderer* preview_create();
void preview_cleanup(PreviewRenderer* renderer);
void preview_draw_debug_ui(PreviewRenderer* renderer);
void preview_draw_ui(PreviewRenderer* renderer);
void preview_set_viewport(PreviewRenderer* renderer, Camera* camera);
GLuint preview_get_rendered_texture(PreviewRenderer* renderer);
void preview_draw(PreviewRenderer* renderer, scene::Scene* scene);
} // namespace inferno::graphics
// #pragma once
//
// #include <graphics.hpp>
//
// #include <memory>
//
// namespace inferno::scene {
// struct Scene;
// }
//
// namespace inferno::graphics {
//
// struct Viewport;
// struct Camera;
// struct DebugDraw;
//
// typedef struct PreviewRenderer {
// glm::ivec2 Viewport;
//
// GLuint RenderTarget = 0;
// GLuint RenderTargetTexture = 0;
// GLuint RenderTargetDepthTexture = 0;
// } PreviewRenderer;
//
// PreviewRenderer* preview_create();
// void preview_cleanup(PreviewRenderer* renderer);
//
// void preview_draw_debug_ui(PreviewRenderer* renderer);
//
// void preview_draw_ui(PreviewRenderer* renderer);
// void preview_set_viewport(PreviewRenderer* renderer, Camera* camera);
//
// GLuint preview_get_rendered_texture(PreviewRenderer* renderer);
//
// void preview_draw(PreviewRenderer* renderer, scene::Scene* scene);
//
// } // namespace inferno::graphics

14
src/preview_renderer/shader.cpp
View File

@@ -1,5 +1,7 @@
#include "shader.hpp"
#include "graphics/device.hpp"
#include <fstream>
#include <iostream>
@@ -45,7 +47,7 @@ bool checkShader(GLuint uid)
return true;
}
Shader* shader_create(VkDevice device)
Shader* shader_create(GraphicsDevice* device)
{
Shader* shader = new Shader;
shader->Device = device;
@@ -55,14 +57,12 @@ Shader* shader_create(VkDevice device)
void shader_cleanup(Shader* shader)
{
vkDestroyShaderModule(shader->Device, shader->VertexShader, nullptr);
vkDestroyShaderModule(shader->Device, shader->FragmentShader, nullptr);
vkDestroyShaderModule(shader->Device->VulkanDevice, shader->VertexShader, nullptr);
vkDestroyShaderModule(shader->Device->VulkanDevice, shader->FragmentShader, nullptr);
}
void shader_load(Shader* shader, std::filesystem::path path)
{
assert(std::filesystem::exists(path));
// path is the filename, code needs to add .vert.spv or .frag.spv
// std::string shaderPath = "shaders/" + path + ".spv";
@@ -80,7 +80,7 @@ void shader_load(Shader* shader, std::filesystem::path path)
= reinterpret_cast<const uint32_t*>(vertexLoadedShaderCode.data());
if (vkCreateShaderModule(
shader->Device, &createInfo, nullptr, &shader->VertexShader)
shader->Device->VulkanDevice, &createInfo, nullptr, &shader->VertexShader)
!= VK_SUCCESS) {
yolo::error("failed to create shader module");
}
@@ -99,7 +99,7 @@ void shader_load(Shader* shader, std::filesystem::path path)
= reinterpret_cast<const uint32_t*>(fragmentLoadedShaderCode.data());
if (vkCreateShaderModule(
shader->Device, &createInfo2, nullptr, &shader->FragmentShader)
shader->Device->VulkanDevice, &createInfo2, nullptr, &shader->FragmentShader)
!= VK_SUCCESS) {
yolo::error("failed to create shader module");
}

6
src/preview_renderer/shader.hpp
View File

@@ -10,16 +10,18 @@
namespace inferno::graphics {
struct GraphicsDevice;
// TODO: Make general
typedef struct Shader {
VkDevice Device;
GraphicsDevice* Device;
VkShaderModule VertexShader;
VkShaderModule FragmentShader;
VkPipelineShaderStageCreateInfo ShaderStages[2];
VkPipelineVertexInputStateCreateInfo VertexInputInfo;
} Shader;
Shader* shader_create(VkDevice device);
Shader* shader_create(GraphicsDevice* device);
void shader_cleanup(Shader* shader);
void shader_load(Shader* shader, std::filesystem::path path);