Tempest Render Engine (Vulkan 1.3 Render Engine) | Together C & C++ | Page 1

void swift Dec 6, 2023, 5:58 PM

#

Currently working on a rendering engine to try out various rendering techniques.
Implemented:

Buffers
Images, Image Views, Samplers
Graphics and Compute Shaders
Multidraw Indirect
Texture and Model Loading (GLTF)
ImGUI Integration

#

Currently, trying to work on some water rendering techniques. This is a really early test of some of the abstraction, but the mesh is completely generated in the shader (no vertex buffers needed). Next goals are going to be passing in wave descriptions to do vertex position deformation. Color above is determined by fmod by 1.0 of the time since start.

#

auto state_upload_pass = rgc->add_graph_pass(
    "sim_state_upload", graphics::queue_operation_type::TRANSFER, [&](graphics::graph_pass_builder& bldr) {
        bldr.add_transfer_source_buffer(graphics_device.get_staging_buffer())
            .add_transfer_destination_buffer(wave_data_buffer)
            .on_execute([&](graphics::command_list& cmds) {
                auto sb_ptr = graphics_device.map_buffer_frame(graphics_device.get_staging_buffer());
                std::memcpy(sb_ptr.data(), &sim_state, sizeof(water_sim_state));
                graphics_device.unmap_buffer(graphics_device.get_staging_buffer());
                cmds.copy(graphics_device.get_staging_buffer(), wave_data_buffer, 0, graphics_device.get_buffer_frame_offset(wave_data_buffer, 0));
            });
    });

auto water_sim_pass = rgc->add_graph_pass(
    "water_sim_pass", graphics::queue_operation_type::GRAPHICS, [&](graphics::graph_pass_builder& bldr) {
        bldr.add_color_attachment(color_buffer, graphics::resource_access_type::WRITE, graphics::load_op::CLEAR,
                                    graphics::store_op::STORE, math::vec4<float>(0.0f))
            .add_depth_attachment(depth_buffer, graphics::resource_access_type::READ_WRITE,
                                    graphics::load_op::CLEAR, graphics::store_op::STORE, 1.0f)
            .add_constant_buffer(camera_data_buffer, 0, 0)
            .add_constant_buffer(lighting_data_buffer, 0, 1)
            .add_constant_buffer(wave_data_buffer, 0, 2)
            .depends_on(state_upload_pass)
            .on_execute([&](graphics::command_list& cmds) {
                cmds.set_viewport(0, 0, 1920, 1080)
                    .set_scissor_region(0, 0, 1920, 1080)
                    .use_pipeline(water_pipeline)
                    .draw(8 * 8 * 6);
            });
    });

auto blit_pass =
    rgc->add_graph_pass("swapchain_target_blit_pass", graphics::queue_operation_type::GRAPHICS_AND_TRANSFER,
                        [&](graphics::graph_pass_builder& bldr) {
                            bldr.add_blit_source(color_buffer)
                                .add_external_blit_target(swapchain)
                                .depends_on(water_sim_pass)
                                .on_execute([&](graphics::command_list& cmds) {
                                    cmds.blit(color_buffer, graphics_device.fetch_current_image(swapchain));
                                });
                        });

void swift Dec 6, 2023, 10:20 PM

#

Using FBM to simulate water

void swift Dec 7, 2023, 12:45 PM

#

For some more context, the periodicity seen here is because this is till using sine waves with FBM. Techniques like this are fine for smaller water sources, but you're going to notice the tiling for large sources quickly. My next steps will be to use FFTs to implement a technique more suitable for large water sources.

void swift Dec 8, 2023, 7:48 PM

#

Okay, I think before I implemented FFT based water, I'm going to work on implementing ImGUI

void swift Dec 10, 2023, 6:08 AM

#

Updates! Got ImGUI integrated with this, and now I can tweak parameters on the fly. 256 wave FBM, 2m triangles, running at ~150fps typically (RTX 3090)

void swift Dec 28, 2023, 12:49 AM

#

Post Christmas Update: I'm currently integrating compute shaders into the render graph. It's going smoothly, and I'll be using them as a test platform for working on an FFT shader for oceans

void swift Dec 30, 2023, 4:29 AM

#

Working on generating noise for the initial state of the FFT water. This is noise + complex conjugate generated in a compute shader. This will be consumed statically by further steps in the pipeline to generate wave movement and heights

void swift Jan 1, 2024, 11:33 PM

#

Small demo of the ocean FFT water

#

I need to do some mip chain generation on the textures, but it's all there 🙂

void swift Jan 4, 2024, 1:21 AM

#

Runtime mipmap generation, sponza loading (no lighting, just base textures)

real vortex Jan 4, 2024, 6:59 PM

#

GET THEE BACK INTO THE TEMPEST AND THE NIGHT'S PLUTONIAN SHORE

void swift Jan 4, 2024, 9:31 PM

#

PBR sponza

void swift Jan 5, 2024, 4:26 AM

#

Updates since last post (measurements on RTX 3090 and Intel 10900KF):

Implemented a z pre pass (2800 -> 3600 fps)
Utilized a dedicated index buffer instead of using a single SSBO for indices and vertices (3600 -> 4000 fps)

Potential Directions for Investigation:

Use the same buffer for SSBO (for vertices) and Index Buffer. This would potentially allow memory reads to be more local

void swift Jan 6, 2024, 12:05 AM

#

Better PBR, merged SSBO and IBO. No improvements to performance.

void swift Jan 8, 2024, 7:16 PM

#

Update: SSAO

void swift Mar 29, 2024, 4:37 AM

#

I've significantly simplified the user-code abstractions I present. I can now present sponza with this:

#include <tempest/tempest.hpp>

int main()
{
    auto eng = tempest::engine::initialize();

    auto [win, input_group] = eng.add_window(tempest::graphics::window_factory::create({
        .title = "Tempest",
        .width = 1920,
        .height = 1080,
    }));

    auto camera = eng.get_registry().acquire_entity();
    eng.get_registry().assign(camera, tempest::graphics::camera_component{});

    eng.on_initialize([](tempest::engine& eng) {
        auto sponza = eng.load_asset("assets/glTF-Sample-Assets/Models/Sponza/glTF/Sponza.gltf");
    });

    eng.run();

    return 0;
}

void swift Mar 29, 2024, 5:30 AM

#

No transmission yet, but progress is getting made on the rendering

void swift Mar 29, 2024, 10:40 PM

#

Made some progress today:

Burley BRDF implemented
Emissive texture support

void swift Apr 11, 2024, 2:49 AM

#

Taking some time to discuss what I've done since the last screenshot:

Z Pre Pass - Forward pass to write out a z buffer of opaque and masked geometry to reduce overdraw in future passes. This is also writing out a geometry normal texture for usage in post processing effects later.
Hierarchical Z Buffer - Compute shader that consumes the depth buffer built by the depth pre pass to build a mipmapped version of the depth buffer. I plan to use this when implementing TAA and other post processing effects that require depth buffer access.

void swift Apr 13, 2024, 9:06 PM

#

TAA has been implemented

void swift May 15, 2024, 12:35 AM

#

Doing some editor work

void swift Jul 20, 2024, 11:13 PM

#

Working a bit on timings and measurement

odd notch Aug 8, 2024, 4:11 PM

#

void swift ```cpp auto state_upload_pass = rgc->add_graph_pass( "sim_state_upload", gra...

#include <vulkan.hpp>?

void swift Aug 8, 2024, 4:27 PM

#

odd notch `#include <vulkan.hpp>`?

in my abstraction, vulkan is not exposed

void swift Sep 26, 2024, 7:42 PM

#

Continued work on asset loading and the editor

void swift Dec 28, 2024, 1:14 AM

#

CSMs with hard edges

#

Only had to add one thing to my abstraction: A mechanism to expose push constants (though I could have just used UBOs instead, this felt more applicable and a good reason to expose them)

void swift Aug 25, 2025, 11:06 PM

#

Tonemapping

#

I'm no longer blind looking at it

hasty mirage Aug 26, 2025, 11:59 PM

#

looks sick

void swift Aug 27, 2025, 1:10 AM

#

I need to get some GI up and going. That'll make it look significantly better

#Tempest Render Engine (Vulkan 1.3 Render Engine)