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

need diff

Browse Source
This commit is contained in:
Ben Kyd
2023-12-19 13:30:48 +00:00
parent 2299b3f89c
commit b9a360cffa
21 changed files with 185 additions and 116 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
res/shaders/unused/lines_debug.frag → res/shaders/lines_debug.frag
View File

@@ -1,11 +1,11 @@
#version 450 core
in vec4 vFragPos;
layout (location = 0) in vec3 vFragPos;
layout(location = 0) out vec4 outColour;
void main()
{
outColour = vec4(vFragPos.xyz, 1.0);
outColour = vec4(1., 0., 0., 1.0);
}

BIN
res/shaders/lines_debug.frag.spv Normal file
View File

Binary file not shown.

19
res/shaders/lines_debug.vert Normal file
View File

@@ -0,0 +1,19 @@
#version 450 core
layout (location = 0) in vec3 position;
layout (binding = 0) uniform SceneUniformBufferObject {
mat4 proj;
mat4 view;
mat4 unused0;
mat4 unused1;
} ubo;
// mat4 model;
layout (location = 1) out vec3 vFragPos;
void main() {
vFragPos = vec3(vec4(position, 1.0));
gl_Position = ubo.proj * ubo.view * vec4(position, 1.0);
}

BIN
res/shaders/lines_debug.vert.spv Normal file
View File

Binary file not shown.

15
res/shaders/unused/lines_debug.vert
View File

@@ -1,15 +0,0 @@
#version 450 core
layout(location = 0) in vec4 position;
uniform mat4 model;
uniform mat4 view;
uniform mat4 proj;
out vec4 vFragPos;
void main()
{
vFragPos = model * position;
gl_Position = proj * view * model * position;
}

9
res/shaders/vulkan_test.frag
View File

@@ -1,9 +0,0 @@
#version 450 core
layout(location = 0) in vec3 fFragColour;
layout(location = 0) out vec4 outColour;
void main() {
outColour = vec4(fFragColour, 1.0);
}

BIN
res/shaders/vulkan_test.frag.spv
View File

Binary file not shown.

13
res/shaders/vulkan_test.vert
View File

@@ -1,13 +0,0 @@
#version 450 core
layout(location = 0) in vec3 vPosition;
layout(location = 1) in vec3 vColor;
layout(location = 0) out vec3 fFragColour;
void main() {
gl_Position = vec4(vPosition, 1.0);
fFragColour = vColor;
}

BIN
res/shaders/vulkan_test.vert.spv
View File

Binary file not shown.

43
src/graphics/buffer.cpp
View File

@@ -105,17 +105,20 @@ Buffer* vertex_buffer_create(GraphicsDevice* device, void* data, uint32_t size,
yolo::debug("Staging buffer size: {}", bufferSize);
buffer->NullableClientData = data;
void* mData;
vkMapMemory(device->VulkanDevice, buffer->StagingBuffer->DeviceData, 0, bufferSize, 0,
&mData);
memcpy(mData, data, bufferSize);
vkUnmapMemory(device->VulkanDevice, buffer->StagingBuffer->DeviceData);
if (size == 0) {
void* mData;
vkMapMemory(device->VulkanDevice, buffer->StagingBuffer->DeviceData, 0, bufferSize, 0,
&mData);
memcpy(mData, data, bufferSize);
vkUnmapMemory(device->VulkanDevice, buffer->StagingBuffer->DeviceData);
}
buffer->GenericBuffer = generic_buffer_create(device, size, bufferSize,
VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
buffer_copy(buffer, device);
if (size == 0)
buffer_copy(buffer, device);
return buffer;
}
@@ -127,6 +130,34 @@ void vertex_buffer_cleanup(Buffer* buffer)
delete buffer;
}
void vertex_buffer_update(Buffer* buffer, void* data, uint32_t size)
{
VkDeviceSize bufferSize = size * sizeof(scene::Vert);
if (buffer->StagingBuffer->Size < bufferSize) {
generic_buffer_cleanup(buffer->StagingBuffer);
generic_buffer_cleanup(buffer->GenericBuffer);
buffer->StagingBuffer = generic_buffer_create(buffer->GenericBuffer->Device,
size, bufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
buffer->GenericBuffer = generic_buffer_create(buffer->GenericBuffer->Device,
size, bufferSize,
VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
}
void* mData;
vkMapMemory(buffer->GenericBuffer->Device->VulkanDevice,
buffer->StagingBuffer->DeviceData, 0, bufferSize, 0, &mData);
memcpy(mData, data, bufferSize);
vkUnmapMemory(buffer->GenericBuffer->Device->VulkanDevice,
buffer->StagingBuffer->DeviceData);
buffer_copy(buffer, buffer->GenericBuffer->Device);
}
void vertex_buffer_bind(Buffer* buffer, VkCommandBuffer commandBuffer)
{
VkBuffer vertexBuffers[] = { buffer->GenericBuffer->Handle };

13
src/graphics/buffer.hpp
View File

@@ -38,16 +38,21 @@ void generic_buffer_cleanup(GenBuffer* buffer);
void buffer_copy(Buffer* buffer, GraphicsDevice* device);
Buffer* vertex_buffer_create(GraphicsDevice* device, void* data, uint32_t size, bool bind = false);
Buffer* vertex_buffer_create(
GraphicsDevice* device, void* data, uint32_t size, bool bind = false);
void vertex_buffer_cleanup(Buffer* buffer);
void vertex_buffer_update(Buffer* buffer, void* data, uint32_t size);
void vertex_buffer_bind(Buffer* buffer, VkCommandBuffer commandBuffer);
Buffer* index_buffer_create(GraphicsDevice* device, void* data, uint32_t size, bool bind = false);
Buffer* index_buffer_create(
GraphicsDevice* device, void* data, uint32_t size, bool bind = false);
void index_buffer_cleanup(Buffer* buffer);
void index_buffer_update(Buffer* buffer, void* data, uint32_t size);
void index_buffer_bind(Buffer* buffer, VkCommandBuffer commandBuffer);
// We *do* want universally mapped memory to act as a "uniform buffer"
template<typename T> GenBuffer* uniform_buffer_create(GraphicsDevice* device, bool bind = false)
template <typename T>
GenBuffer* uniform_buffer_create(GraphicsDevice* device, bool bind = false)
{
GenBuffer* buffer
= generic_buffer_create(device, 0, sizeof(T), VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
@@ -61,7 +66,7 @@ template<typename T> GenBuffer* uniform_buffer_create(GraphicsDevice* device, bo
inline void uniform_buffer_cleanup(GenBuffer* buffer) { generic_buffer_cleanup(buffer); }
template<typename T> void uniform_buffer_update(GenBuffer* buffer, T* data)
template <typename T> void uniform_buffer_update(GenBuffer* buffer, T* data)
{
memcpy(buffer->MappedData, (void*)data, sizeof(T));
}

4
src/graphics/pipeline.cpp
View File

@@ -44,6 +44,9 @@ Pipeline* pipeline_create(GraphicsDevice* device, SwapChain* swap, Shader* shade
inputAssembly.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
inputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
inputAssembly.primitiveRestartEnable = VK_FALSE;
if (type == PIPELINE_TYPE_GRAPHICS_LINE) {
inputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_LINE_LIST;
}
VkPipelineViewportStateCreateInfo viewportState {};
viewportState.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
@@ -53,7 +56,6 @@ Pipeline* pipeline_create(GraphicsDevice* device, SwapChain* swap, Shader* shade
VkPipelineRasterizationStateCreateInfo rasterizer {};
rasterizer.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
rasterizer.depthClampEnable = VK_FALSE; // NOTE: This is for shadow mapping
rasterizer.polygonMode = VK_POLYGON_MODE_LINE;
rasterizer.rasterizerDiscardEnable = VK_FALSE;
rasterizer.polygonMode = VK_POLYGON_MODE_FILL;
rasterizer.lineWidth = 1.3f;

19
src/graphics/shader.cpp
View File

@@ -21,11 +21,13 @@ std::string textFromFile(const std::filesystem::path& path)
(std::istreambuf_iterator<char>(input)), std::istreambuf_iterator<char>());
}
Shader* shader_create(GraphicsDevice* device, SwapChain* swapchain)
Shader* shader_create(
GraphicsDevice* device, SwapChain* swapchain, ShaderProgramType type)
{
Shader* shader = new Shader;
shader->Device = device;
shader->GraphicsSwapchain = swapchain;
shader->Type = type;
return shader;
}
@@ -173,8 +175,21 @@ void shader_build(Shader* shader)
yolo::error("failed to allocate descriptor sets!");
}
PipelineType pipelineType = PIPELINE_TYPE_GRAPHICS;
switch (shader->Type) {
case SHADER_PROGRAM_TYPE_GRAPHICS:
pipelineType = PIPELINE_TYPE_GRAPHICS;
break;
case SHADER_PROGRAM_TYPE_GRAPHICS_LINE:
pipelineType = PIPELINE_TYPE_GRAPHICS_LINE;
break;
default:
yolo::error("Shader type not supported");
break;
}
shader->GraphicsPipeline = pipeline_create(shader->Device, shader->GraphicsSwapchain,
shader, layouts.size(), layouts.data(), PIPELINE_TYPE_GRAPHICS);
shader, layouts.size(), layouts.data(), pipelineType);
shader->GlobalUniformBuffer
= uniform_buffer_create<scene::GlobalUniformObject>(shader->Device, true);
}

12
src/graphics/shader.hpp
View File

@@ -19,6 +19,13 @@ struct SwapChain;
struct Pipeline;
struct GenBuffer;
typedef enum ShaderProgramType {
SHADER_PROGRAM_TYPE_GRAPHICS,
SHADER_PROGRAM_TYPE_GRAPHICS_LINE,
SHADER_PROGRAM_TYPE_COMPUTE,
SHADER_PROGRAM_TYPE_RAYTRACING
} ShaderProgramType;
typedef struct ShaderPushConst {
union {
glm::mat4 mat[2]; // 64 bytes each
@@ -30,6 +37,8 @@ typedef struct ShaderPushConst {
typedef struct Shader {
GraphicsDevice* Device;
ShaderProgramType Type;
SwapChain* GraphicsSwapchain;
Pipeline* GraphicsPipeline;
@@ -45,7 +54,8 @@ typedef struct Shader {
VkPipelineVertexInputStateCreateInfo VertexInputInfo;
} Shader;
Shader* shader_create(GraphicsDevice* device, SwapChain* swapchain);
Shader* shader_create(
GraphicsDevice* device, SwapChain* swapchain, ShaderProgramType type);
void shader_cleanup(Shader* shader);
void shader_load(Shader* shader, std::filesystem::path path);

8
src/graphics/vkrenderer.cpp
View File

@@ -198,7 +198,7 @@ bool renderer_begin_frame(VulkanRenderer* renderer)
}
void renderer_begin_pass(
VulkanRenderer* renderer, RenderTarget* target, VkRect2D renderArea)
VulkanRenderer* renderer, RenderTarget* target, VkRect2D renderArea, bool clear)
{
VkImageMemoryBarrier imageMemoryBarrier {};
imageMemoryBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
@@ -224,6 +224,9 @@ void renderer_begin_pass(
attachmentInfo.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
attachmentInfo.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
attachmentInfo.clearValue = clearColor;
if (!clear) {
attachmentInfo.loadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
}
VkRenderingAttachmentInfo depthAttachmentInfo;
if (target->TargetDepth != nullptr) {
@@ -237,6 +240,9 @@ void renderer_begin_pass(
depthAttachmentInfo.resolveImageView = VK_NULL_HANDLE;
depthAttachmentInfo.resolveImageLayout = VK_IMAGE_LAYOUT_GENERAL;
depthAttachmentInfo.pNext = VK_NULL_HANDLE;
if (!clear) {
depthAttachmentInfo.loadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
}
}
VkRenderingInfo renderingInfo {};

4
src/graphics/vkrenderer.hpp
View File

@@ -67,8 +67,8 @@ void renderer_submit_now(VulkanRenderer* renderer,
bool renderer_begin_frame(VulkanRenderer* renderer);
void renderer_begin_pass(
VulkanRenderer* renderer, RenderTarget* target, VkRect2D renderArea);
void renderer_begin_pass(VulkanRenderer* renderer, RenderTarget* target,
VkRect2D renderArea, bool clear = true);
// this is for rendering to the swapchain / present image
void renderer_begin_pass(VulkanRenderer* renderer, VkRect2D renderArea);

5
src/inferno.cpp
View File

@@ -14,6 +14,7 @@
#include "graphics/shader.hpp"
#include "graphics/swapchain.hpp"
#include "graphics/vkrenderer.hpp"
#include "preview_renderer/debug.hpp"
#include "window.hpp"
// #include "preview_renderer/debug.hpp"
@@ -292,7 +293,7 @@ int inferno_run(InfernoApp* app)
ImGui::Checkbox("Show Preview", &showPreview);
graphics::preview_draw_ui(app->PreviewRenderer);
if (ImGui::TreeNode("Debug Overlay")) {
// graphics::debug_draw_ui();
graphics::debug_draw_ui();
ImGui::TreePop();
}
ImGui::TreePop();
@@ -323,6 +324,8 @@ int inferno_run(InfernoApp* app)
lastViewport = currentViewport;
graphics::preview_draw(app->PreviewRenderer, app->Scene);
// graphics::debug_draw_line({0, 0, 0}, {1, 1, 0}, {1, 1, 0});
// graphics::debug_draw_to_target(app->Scene);
ImTextureID texture
= (ImTextureID)graphics::preview_get_target(app->PreviewRenderer)

109
src/preview_renderer/debug.cpp
View File

@@ -1,9 +1,14 @@
#include "debug.hpp"
#include "preview_renderer/renderer.hpp"
#include "graphics/shader.hpp"
#include "graphics/buffer.hpp"
#include "graphics/rendertarget.hpp"
#include "graphics/shader.hpp"
#include "graphics/vkrenderer.hpp"
#include "preview_renderer/renderer.hpp"
#include "scene/camera.hpp"
#include "scene/mesh.hpp"
#include "scene/scene.hpp"
#include <graphics.hpp>
@@ -26,34 +31,31 @@ struct DebugTextBillboard {
struct _DebugInternal {
std::mutex DebugMutex;
Buffer* LineBuffer;
Buffer* LineBuffer = nullptr;
Shader* LineShader;
};
static DebugDrawer* DebugDrawerInstance = nullptr;
void debug_init()
void debug_init(PreviewRenderer* renderer)
{
DebugDrawerInstance = new DebugDrawer;
DebugDrawerInstance->Renderer = renderer;
DebugDrawerInstance->LineElements = std::vector<DebugLine>();
DebugDrawerInstance->BillboardElements = std::vector<DebugTextBillboard>();
// DebugDrawerInstance->BillboardElements = std::vector<DebugTextBillboard>();
DebugDrawerInstance->_Internal = new _DebugInternal;
// DebugDrawerInstance->_Internal->LineShader = shader_create();
// DebugDrawerInstance->_Internal->LineShader = shader_create(renderer->Renderer->Device,
// renderer->Renderer->Swap, SHADER_PROGRAM_TYPE_GRAPHICS_LINE);
// graphics::shader_load(
// DebugDrawerInstance->_Internal->LineShader, "res/shaders/lines_debug");
// graphics::shader_build(DebugDrawerInstance->_Internal->LineShader);
yolo::debug("DebugDrawer initialized");
}
void debug_cleanup()
{
delete DebugDrawerInstance;
}
void debug_attach_renderer(PreviewRenderer* renderer)
{
DebugDrawerInstance->Renderer = renderer;
}
void debug_cleanup() { delete DebugDrawerInstance; }
void debug_draw_line(glm::vec3 start, glm::vec3 end, glm::vec3 color)
{
@@ -61,55 +63,62 @@ void debug_draw_line(glm::vec3 start, glm::vec3 end, glm::vec3 color)
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_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_ui() { ImGui::Checkbox("Show Overlay", &DebugDrawerInstance->DoShow); }
void debug_draw_to_target(scene::Scene* scene)
{
if (!DebugDrawerInstance->DoShow)
return;
auto renderer = DebugDrawerInstance->Renderer;
uint32_t bufferSize
= DebugDrawerInstance->LineElements.size() * sizeof(DebugLine) * 2;
scene::DebugLineVert* bufferData = new scene::DebugLineVert[bufferSize];
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;
bufferData[i * 2] = { DebugDrawerInstance->LineElements[i].Start,
DebugDrawerInstance->LineElements[i].Color };
bufferData[i * 2 + 1] = { DebugDrawerInstance->LineElements[i].End,
DebugDrawerInstance->LineElements[i].Color };
}
if (bufferSize > 0 && DebugDrawerInstance->_Internal->LineBuffer == nullptr) {
DebugDrawerInstance->_Internal->LineBuffer = vertex_buffer_create(
DebugDrawerInstance->Renderer->Renderer->Device, bufferData, bufferSize);
}
// glDrawArrays(GL_LINES, 0, vertex_position_arr_size);
auto backend = DebugDrawerInstance->Renderer->Renderer;
VkCommandBuffer commandBuffer = *backend->CommandBufferInFlight;
graphics::renderer_begin_pass(backend,
DebugDrawerInstance->Renderer->PreviewRenderTarget,
DebugDrawerInstance->Renderer->Viewport, false);
graphics::shader_use(DebugDrawerInstance->_Internal->LineShader, commandBuffer,
DebugDrawerInstance->Renderer->Viewport);
scene::GlobalUniformObject GlobalUniformObject {
.Projection = graphics::camera_get_projection(scene->Camera),
.View = graphics::camera_get_view(scene->Camera),
};
graphics::shader_update_state(DebugDrawerInstance->_Internal->LineShader,
commandBuffer, GlobalUniformObject, backend->CurrentFrameIndex);
graphics::vertex_buffer_bind(
DebugDrawerInstance->_Internal->LineBuffer, commandBuffer);
vkCmdDraw(commandBuffer, DebugDrawerInstance->LineElements.size() * 2, 1, 0, 0);
graphics::renderer_end_pass(backend);
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();
delete[] bufferData;
}
}

11
src/preview_renderer/debug.hpp
View File

@@ -21,21 +21,20 @@ struct DebugTextBillboard;
struct _DebugInternal;
struct DebugDrawer {
PreviewRenderer* Renderer = nullptr;
_DebugInternal* _Internal = nullptr;
bool DoShow = true;
PreviewRenderer* Renderer = nullptr;
std::vector<DebugLine> LineElements;
std::vector<DebugTextBillboard> BillboardElements;
// std::vector<DebugTextBillboard> BillboardElements;
};
void debug_init();
void debug_init(PreviewRenderer* renderer);
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_text_billboard(glm::vec3 position, glm::vec3 color, std::string text);
void debug_draw_ui();

6
src/preview_renderer/renderer.cpp
View File

@@ -30,7 +30,8 @@ PreviewRenderer* preview_create(VulkanRenderer* vkrenderer)
PreviewRenderer* renderer = new PreviewRenderer;
renderer->Renderer = vkrenderer;
renderer->DrawShader = graphics::shader_create(vkrenderer->Device, vkrenderer->Swap);
renderer->DrawShader = graphics::shader_create(
vkrenderer->Device, vkrenderer->Swap, SHADER_PROGRAM_TYPE_GRAPHICS);
graphics::shader_load(renderer->DrawShader, "res/shaders/basic");
graphics::shader_build(renderer->DrawShader);
@@ -39,8 +40,7 @@ PreviewRenderer* preview_create(VulkanRenderer* vkrenderer)
renderer->Renderer->Device, { 1920, 1080 }, VK_FORMAT_R8G8B8A8_UNORM, true);
// bind preview renderer to debugdraw
debug_init();
debug_attach_renderer(renderer);
// debug_init(renderer);
return renderer;
}

7
src/scene/mesh.hpp
View File

@@ -21,8 +21,15 @@ struct Vert {
glm::vec3 Normal;
};
struct DebugLineVert {
glm::vec3 Position;
glm::vec3 Color;
};
using Index = uint32_t;
// NOTE: Out of coincidence, this is the same for both vert and debug line vert
// TODO: Make this a template // somehow
VkVertexInputBindingDescription get_vert_binding_description();
std::array<VkVertexInputAttributeDescription, 2> get_vert_attribute_descriptions();