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

It works again but there's some issues with the texture streching

Browse Source
This commit is contained in:
Ben Kyd
2024-01-03 12:11:04 +00:00
parent 2808defc94
commit 33a6592d41
11 changed files with 98 additions and 47 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
CMakeLists.txt
View File

@@ -1,6 +1,8 @@
cmake_minimum_required(VERSION 3.13)
project(inferno)
set(CMAKE_COMPILE_WARNING_AS_ERROR OFF)
# file(GLOB SRC "src/*.cpp" "src/graphics/*.cpp" "src/preview_renderer/*.cpp" "src/scene/*.cpp" "src/thirdparty/imgui/*.cpp" "src/preview_renderer/*.cpp")
file(GLOB_RECURSE SRC "src/*.cpp")
@@ -36,6 +38,13 @@ else()
target_compile_options(inferno PRIVATE -g)
target_compile_options(inferno PRIVATE -D_GLIBCXX_DEBUG)
endif()
if (CMAKE_BUILD_TYPE MATCHES "Release")
target_compile_options(inferno PRIVATE -O3)
target_compile_options(inferno PRIVATE -march=native)
target_compile_options(inferno PRIVATE -DNDEBUG)
# allow warnings
target_compile_options(inferno PRIVATE -Wall)
endif()
endif()
# Compile shaders first..

3
src/graphics/device.hpp
View File

@@ -6,7 +6,7 @@
namespace inferno::graphics {
#define VALIDATION_LAYERS_ENABLED 1
// #define VALIDATION_LAYERS_ENABLED 1
#ifdef VALIDATION_LAYERS_ENABLED
const std::vector<const char*> VALIDATION_LAYERS = {
"VK_LAYER_KHRONOS_validation",
@@ -16,6 +16,7 @@ const std::vector<const char*> VALIDATION_LAYERS = {
const std::vector<const char*> DEVICE_EXTENSIONS = {
VK_KHR_SWAPCHAIN_EXTENSION_NAME,
VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME,
VK_EXT_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_EXTENSION_NAME,
};
struct VulkanRenderer;

61
src/graphics/rendertarget.cpp
View File

@@ -129,30 +129,6 @@ void rendertarget_recreate(RenderTarget* target, VkExtent2D extent, VkFormat for
target->Extent = extent;
target->Format = format;
VkSamplerCreateInfo samplerInfo {};
samplerInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
samplerInfo.magFilter = VK_FILTER_LINEAR;
samplerInfo.minFilter = VK_FILTER_LINEAR;
samplerInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT;
samplerInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_REPEAT;
samplerInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT;
samplerInfo.anisotropyEnable = VK_FALSE;
samplerInfo.maxAnisotropy = 1.0f;
samplerInfo.borderColor = VK_BORDER_COLOR_INT_OPAQUE_BLACK;
samplerInfo.unnormalizedCoordinates = VK_FALSE;
samplerInfo.compareEnable = VK_FALSE;
samplerInfo.compareOp = VK_COMPARE_OP_ALWAYS;
samplerInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
samplerInfo.mipLodBias = 0.0f;
samplerInfo.minLod = 0.0f;
samplerInfo.maxLod = 0.0f;
if (vkCreateSampler(
target->Device->VulkanDevice, &samplerInfo, nullptr, &target->Sampler)
!= VK_SUCCESS) {
yolo::error("failed to create texture sampler!");
}
target->TargetImage = new ImageAttachment();
create_image(target->Device, extent.width, extent.height, format,
@@ -233,7 +209,14 @@ DynamicCPUTarget* dynamic_rendertarget_create(
return target;
}
void dynamic_rendertarget_cleanup(DynamicCPUTarget* target) { }
void dynamic_rendertarget_cleanup(DynamicCPUTarget* target)
{
vkDestroyImageView(target->Device->VulkanDevice, target->ImageView, nullptr);
vkDestroyImage(target->Device->VulkanDevice, target->Image, nullptr);
vkFreeMemory(target->Device->VulkanDevice, target->Memory, nullptr);
vkDestroySampler(target->Device->VulkanDevice, target->Sampler, nullptr);
delete target;
}
// TODO: We should do this with a double buffer but whatever
void dynamic_rendertarget_update(DynamicCPUTarget* target, void* data, VkExtent2D size)
@@ -283,4 +266,32 @@ void dynamic_rendertarget_update(DynamicCPUTarget* target, void* data, VkExtent2
VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
}
void dynamic_rendertarget_recreate(DynamicCPUTarget* target, VkExtent2D extent)
{
vkDestroyImageView(target->Device->VulkanDevice, target->ImageView, nullptr);
vkDestroyImage(target->Device->VulkanDevice, target->Image, nullptr);
vkFreeMemory(target->Device->VulkanDevice, target->Memory, nullptr);
target->Extent = extent;
// Create VkImage with Undefined
create_image(target->Device, extent.width, extent.height, target->Format, VK_IMAGE_TILING_OPTIMAL,
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT
| VK_IMAGE_USAGE_SAMPLED_BIT,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, target->Image, target->Memory);
target->ImageView
= create_image_view(target->Device, target->Image, target->Format, VK_IMAGE_ASPECT_COLOR_BIT);
target->DescriptorSet = ImGui_ImplVulkan_AddTexture(
target->Sampler, target->ImageView, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
// NOTE: This assumes that the image is in the UNDEFINED LAYOUT
// And also assumes that the cpu layout is floating point (4 bytes) and the image is
// RGBA
target->StagingBuffer = generic_buffer_create(target->Device, 0,
extent.width * extent.height * 4, VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
}
}

2
src/graphics/rendertarget.hpp
View File

@@ -67,4 +67,6 @@ void dynamic_rendertarget_cleanup(DynamicCPUTarget* target);
void dynamic_rendertarget_update(DynamicCPUTarget* target, void* data, VkExtent2D size);
void dynamic_rendertarget_recreate(DynamicCPUTarget* target, VkExtent2D extent);
}

3
src/graphics/vkrenderer.cpp
View File

@@ -204,9 +204,6 @@ void renderer_begin_pass(
if (target == nullptr || target->TargetImage == nullptr) {
yolo::error("Target image is null");
}
// print target details
yo::info("Target: {} {} {}", target->TargetImage->Image, target->TargetImage->Memory,
target->TargetImage->ImageView);
VkImageMemoryBarrier imageMemoryBarrier {};
imageMemoryBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;

21
src/inferno.cpp
View File

@@ -90,6 +90,7 @@ InfernoApp* inferno_create()
app->Input = new InfernoInput;
app->Scene = scene::scene_create();
app->MainTimer = inferno_timer_create();
app->FrameCount = 0;
graphics::camera_set_position(app->Scene->Camera, { 0.0f, 1.0f, 3.1f });
@@ -128,11 +129,11 @@ InfernoApp* inferno_create()
// scene::scene_object_load(object, "res/sponza.obj");
scene::scene_object_load(object, "res/cornell-box.obj");
scene::scene_add_object(app->Scene, object);
scene::SceneObject* lucy = scene::scene_object_create(app->Device);
scene::scene_object_load(lucy, "res/lucy.obj");
scene::scene_object_optimize(lucy);
scene::scene_add_object(app->Scene, lucy);
//
// scene::SceneObject* lucy = scene::scene_object_create(app->Device);
// scene::scene_object_load(lucy, "res/lucy.obj");
// scene::scene_object_optimize(lucy);
// scene::scene_add_object(app->Scene, lucy);
app->RayRenderer = graphics::rayr_create(app->Renderer, app->Scene);
@@ -352,6 +353,16 @@ int inferno_run(InfernoApp* app)
}
if (ImGui::Begin("Render")) {
// static ImVec2 lastViewport = { 0, 0 };
// ImVec2 currentViewport = ImGui::GetWindowSize();
// if (lastViewport.x != currentViewport.x
// || lastViewport.y != currentViewport.y) {
// graphics::camera_ray_set_viewport(scene::scene_get_camera(app->Scene),
// { ImGui::GetWindowSize().x, ImGui::GetWindowSize().y });
// graphics::rayr_set_viewport(app->RayRenderer, app->Scene->Camera);
// }
// lastViewport = currentViewport;
graphics::rayr_draw(app->RayRenderer);
ImTextureID texture

1
src/preview/renderer.cpp
View File

@@ -77,7 +77,6 @@ void preview_draw(PreviewRenderer* renderer, scene::Scene* scene)
renderer->Viewport.extent, VK_FORMAT_R8G8B8A8_UNORM);
}
yolo::info("Drawing preview");
graphics::renderer_begin_pass(
renderer->Renderer, renderer->PreviewRenderTarget, renderer->Viewport);

10
src/raytracing/object_tracer.cpp
View File

@@ -50,12 +50,12 @@ HitInfo* object_ray_collide(scene::SceneObject* object, Ray* ray)
const uint32_t* ind;
const float* verts;
const float* norms;
// mesh->getIndicies(&ind);
// mesh->getVerticies(&verts, &norms);
scene::mesh_get_indicies(mesh, &ind);
scene::mesh_get_verticies(mesh, &verts, &norms);
float t = INFINITY;
int i ;
// for (int i = 0; i < mesh->getIndexCount(); i += 3) {
int i;
for (int i = 0; i < scene::mesh_get_index_count(mesh); i += 3) {
uint32_t indexa = ind[i + 0];
uint32_t indexb = ind[i + 1];
uint32_t indexc = ind[i + 2];
@@ -72,7 +72,7 @@ HitInfo* object_ray_collide(scene::SceneObject* object, Ray* ray)
t = temp_t;
info->Distance = t;
}
// }
}
}
return info;
}

26
src/raytracing/renderer.cpp
View File

@@ -32,18 +32,21 @@ RayRenderer* rayr_create(VulkanRenderer* renderer, scene::Scene* scene)
ray->Renderer = renderer;
auto camera = scene::scene_get_camera(scene);
rayr_set_viewport(ray, camera);
ray->Viewport.offset.x = 0;
ray->Viewport.offset.y = 0;
ray->Viewport.extent.width = camera_ray_get_viewport(camera).x;
ray->Viewport.extent.height = camera_ray_get_viewport(camera).y;
ray->HasViewportChanged = true;
ray->RenderData
= new glm::fvec4[ray->Viewport.extent.width * ray->Viewport.extent.height];
memset(ray->RenderData, 0,
ray->Viewport.extent.width * ray->Viewport.extent.height * sizeof(glm::fvec4));
// TODO: We need to upload RenderData to the GPU / maybe do a quad pass ? I think
// ImGui handels that
ray->RayRenderTarget = graphics::dynamic_rendertarget_create(
renderer->Device, ray->Viewport.extent, VK_FORMAT_R32G32B32A32_SFLOAT);
rayr_set_viewport(ray, camera);
return ray;
}
@@ -60,6 +63,16 @@ void rayr_set_viewport(RayRenderer* renderer, Camera* camera)
renderer->Viewport.extent.width = viewport.x;
renderer->Viewport.extent.height = viewport.y;
renderer->HasViewportChanged = true;
delete[] renderer->RenderData;
renderer->RenderData
= new glm::fvec4[renderer->Viewport.extent.width * renderer->Viewport.extent.height];
memset(renderer->RenderData, 0,
renderer->Viewport.extent.width * renderer->Viewport.extent.height * sizeof(glm::fvec4));
// Now resize the rendertarget
graphics::dynamic_rendertarget_recreate(
renderer->RayRenderTarget, renderer->Viewport.extent);
}
DynamicCPUTarget* rayr_get_target(RayRenderer* renderer)
@@ -72,7 +85,7 @@ glm::fvec4* rayr_get_render_data(RayRenderer* renderer) { return renderer->Rende
void rayr_prepare(RayRenderer* renderer)
{
// TODO: This is TEMP
memset(renderer->RenderData, 0,
memset(renderer->RenderData, 1,
renderer->Viewport.extent.width * renderer->Viewport.extent.height
* sizeof(glm::fvec4));
@@ -97,7 +110,8 @@ void rayr_draw(RayRenderer* renderer)
for (int x = 0; x < renderer->Viewport.extent.width; x++) {
for (int y = 0; y < renderer->Viewport.extent.height; y++) {
rays::Ray* ray = startRays.Field[x * renderer->Viewport.extent.height + y];
renderer->RenderData[y * renderer->Viewport.extent.width + x] = glm::vec4(ray->Direction, 1.0);
renderer->RenderData[y * renderer->Viewport.extent.width + x]
= { ray->Direction.x, ray->Direction.y, ray->Direction.z, 1.0 };
// rays::HitInfo* closest_hit = nullptr;
//
// for (auto& obj : scene::scene_get_renderables(renderer->Scene)) {

5
src/scene/mesh.cpp
View File

@@ -62,6 +62,8 @@ void mesh_process(Mesh* out, aiMesh* mesh)
= glm::vec3(mesh->mNormals[i].x, mesh->mNormals[i].y, mesh->mNormals[i].z),
};
out->Positions.push_back(vertex.Position);
out->Normals.push_back(vertex.Normal);
out->Verticies.push_back(vertex);
}
@@ -91,9 +93,10 @@ void mesh_ready(Mesh* mesh)
yolo::debug("Mesh for preview ready...");
}
// TODO: Extract vertex and normal data from internal mesh
uint32_t mesh_get_verticies(Mesh* mesh, const float** v, const float** n)
{
*v = (float*)mesh->Positions.data();
*n = (float*)mesh->Normals.data();
return mesh->Verticies.size();
}

4
src/scene/mesh.hpp
View File

@@ -39,6 +39,10 @@ typedef struct Mesh {
glm::mat4 ModelMatrix;
std::vector<Vert> Verticies;
std::vector<glm::vec3> Positions;
std::vector<glm::vec3> Normals;
std::vector<uint32_t> Indicies;
graphics::Buffer* VertexBuffer;