aboutsummaryrefslogtreecommitdiff
path: root/src/platform
diff options
context:
space:
mode:
Diffstat (limited to 'src/platform')
-rw-r--r--src/platform/metal/metal_context.h16
-rw-r--r--src/platform/metal/metal_context.mm124
-rw-r--r--src/platform/opengl/opengl_device.cpp279
-rw-r--r--src/platform/opengl/opengl_device.h11
-rw-r--r--src/platform/opengl/opengl_renderer.cpp377
-rw-r--r--src/platform/opengl/opengl_renderer.h72
-rw-r--r--src/platform/vulkan/vulkan_context.cpp789
-rw-r--r--src/platform/vulkan/vulkan_context.h41
-rw-r--r--src/platform/vulkan/vulkan_device.cpp1254
-rw-r--r--src/platform/vulkan/vulkan_device.h17
-rw-r--r--src/platform/vulkan/vulkan_renderer.cpp2038
-rw-r--r--src/platform/vulkan/vulkan_renderer.h50
12 files changed, 1561 insertions, 3507 deletions
diff --git a/src/platform/metal/metal_context.h b/src/platform/metal/metal_context.h
deleted file mode 100644
index f1e376b..0000000
--- a/src/platform/metal/metal_context.h
+++ /dev/null
@@ -1,16 +0,0 @@
-#pragma once
-
-// Pure-C++ interface to the Metal backend (no Objective-C leaks into the rest
-// of the engine). Implemented in MetalContext.mm.
-namespace Donut
-{
- // Phase 1 bring-up: creates the default Metal device + command queue and
- // logs its capabilities, proving the Metal toolchain and build integration
- // work natively on Apple Silicon. This grows into the Metal compute island
- // that runs the geodesic ray tracer in real time.
- auto metal_probe() -> bool;
-
- // Compiles + dispatches a trivial compute kernel and validates the read-back,
- // proving the Metal compute path the geodesic ray tracer will run on.
- auto metal_compute_self_test() -> bool;
-}
diff --git a/src/platform/metal/metal_context.mm b/src/platform/metal/metal_context.mm
deleted file mode 100644
index 71e8551..0000000
--- a/src/platform/metal/metal_context.mm
+++ /dev/null
@@ -1,124 +0,0 @@
-#import <Metal/Metal.h>
-#import <Foundation/Foundation.h>
-
-#include "metal_context.h"
-#include "core/log.h"
-
-#include <vector>
-
-namespace Donut
-{
- bool metal_probe()
- {
- @autoreleasepool
- {
- id<MTLDevice> device = MTLCreateSystemDefaultDevice();
- if (device == nil)
- {
- DONUT_ERROR("Metal: no default device available");
- return false;
- }
-
- id<MTLCommandQueue> queue = [device newCommandQueue];
- const char* name = [[device name] UTF8String];
-
- DONUT_INFO("Metal device: {}", name ? name : "(unknown)");
- DONUT_INFO("Metal: unified memory = {}, max threads/threadgroup = {}",
- device.hasUnifiedMemory ? "yes" : "no",
- (unsigned long)device.maxThreadsPerThreadgroup.width);
-
- if (queue == nil)
- {
- DONUT_WARN("Metal: failed to create command queue");
- return false;
- }
-
- return true;
- }
- }
-
- // Compiles a trivial compute kernel, dispatches it over a small texture, and
- // reads the result back to confirm the full Metal compute path works: source
- // compilation, pipeline state, command encoding, dispatch, and shared-memory
- // read-back. This is the mechanism the geodesic ray tracer will run on.
- bool metal_compute_self_test()
- {
- @autoreleasepool
- {
- id<MTLDevice> device = MTLCreateSystemDefaultDevice();
- id<MTLCommandQueue> queue = [device newCommandQueue];
- if (device == nil || queue == nil)
- return false;
-
- NSString* src =
- @"#include <metal_stdlib>\n"
- "using namespace metal;\n"
- "kernel void selfTest(texture2d<float, access::write> outTex [[texture(0)]],\n"
- " uint2 gid [[thread_position_in_grid]])\n"
- "{\n"
- " uint w = outTex.get_width();\n"
- " uint h = outTex.get_height();\n"
- " if (gid.x >= w || gid.y >= h) return;\n"
- " outTex.write(float4(float(gid.x) / float(w - 1),\n"
- " float(gid.y) / float(h - 1), 0.5, 1.0), gid);\n"
- "}\n";
-
- NSError* err = nil;
- id<MTLLibrary> lib = [device newLibraryWithSource:src options:nil error:&err];
- if (lib == nil)
- {
- DONUT_ERROR("Metal self-test: kernel compile failed: {}",
- err ? [[err localizedDescription] UTF8String] : "unknown");
- return false;
- }
-
- id<MTLFunction> fn = [lib newFunctionWithName:@"selfTest"];
- id<MTLComputePipelineState> pipeline =
- [device newComputePipelineStateWithFunction:fn error:&err];
- if (pipeline == nil)
- {
- DONUT_ERROR("Metal self-test: pipeline creation failed");
- return false;
- }
-
- const uint32_t W = 64, H = 64;
- MTLTextureDescriptor* desc =
- [MTLTextureDescriptor texture2DDescriptorWithPixelFormat:MTLPixelFormatRGBA8Unorm
- width:W
- height:H
- mipmapped:NO];
- desc.usage = MTLTextureUsageShaderWrite | MTLTextureUsageShaderRead;
- desc.storageMode = MTLStorageModeShared;
- id<MTLTexture> tex = [device newTextureWithDescriptor:desc];
-
- id<MTLCommandBuffer> cb = [queue commandBuffer];
- id<MTLComputeCommandEncoder> enc = [cb computeCommandEncoder];
- [enc setComputePipelineState:pipeline];
- [enc setTexture:tex atIndex:0];
-
- MTLSize tg = MTLSizeMake(16, 16, 1);
- MTLSize grid = MTLSizeMake(W, H, 1);
- [enc dispatchThreads:grid threadsPerThreadgroup:tg];
- [enc endEncoding];
- [cb commit];
- [cb waitUntilCompleted];
-
- // Read back the far corner; the kernel writes (~1, ~1, 0.5, 1) there.
- std::vector<uint8_t> px(W * H * 4);
- [tex getBytes:px.data()
- bytesPerRow:W * 4
- fromRegion:MTLRegionMake2D(0, 0, W, H)
- mipmapLevel:0];
-
- size_t corner = ((size_t)(H - 1) * W + (W - 1)) * 4;
- DONUT_INFO("Metal compute self-test: corner pixel RGBA = ({}, {}, {}, {})",
- (int)px[corner + 0], (int)px[corner + 1],
- (int)px[corner + 2], (int)px[corner + 3]);
-
- bool ok = px[corner + 0] > 250 && px[corner + 1] > 250 &&
- px[corner + 3] == 255;
- DONUT_INFO("Metal compute self-test: {}", ok ? "PASS" : "FAIL");
- return ok;
- }
- }
-}
diff --git a/src/platform/opengl/opengl_device.cpp b/src/platform/opengl/opengl_device.cpp
new file mode 100644
index 0000000..3d45d24
--- /dev/null
+++ b/src/platform/opengl/opengl_device.cpp
@@ -0,0 +1,279 @@
+#include "opengl_device.h"
+
+#include "core/log.h"
+#include "core/hdri_manager.h"
+#include "rendering/shader.h"
+#include "rendering/texture.h"
+
+#include <glad/glad.h>
+#include <GLFW/glfw3.h>
+#include <imgui.h>
+#include <imgui_impl_glfw.h>
+#include <imgui_impl_opengl3.h>
+
+namespace Donut::RHI
+{
+ namespace
+ {
+ auto gl_topology(Topology t) -> GLenum { return t == Topology::Lines ? GL_LINES : GL_TRIANGLES; }
+ auto gl_compare(CompareOp o) -> GLenum { return o == CompareOp::Always ? GL_ALWAYS : o == CompareOp::LessEqual ? GL_LEQUAL : GL_LESS; }
+ auto gl_filter(Filter f) -> GLint { return f == Filter::Nearest ? GL_NEAREST : GL_LINEAR; }
+ auto gl_internal(Format f) -> GLint { return f == Format::RGBA16F ? GL_RGBA16F : f == Format::D32 ? GL_DEPTH_COMPONENT32F : GL_RGBA8; }
+
+ // ---- Buffer -------------------------------------------------------
+ class GLBuffer : public Buffer
+ {
+ public:
+ GLBuffer(BufferType type, size_t size, const void* data)
+ {
+ m_target = type == BufferType::Index ? GL_ELEMENT_ARRAY_BUFFER
+ : type == BufferType::Uniform ? GL_UNIFORM_BUFFER : GL_ARRAY_BUFFER;
+ glGenBuffers(1, &m_id);
+ glBindBuffer(m_target, m_id);
+ glBufferData(m_target, (GLsizeiptr)size, data, GL_DYNAMIC_DRAW);
+ }
+ ~GLBuffer() override { if (m_id) glDeleteBuffers(1, &m_id); }
+ auto update(const void* data, size_t size) -> void override
+ {
+ glBindBuffer(m_target, m_id);
+ glBufferSubData(m_target, 0, (GLsizeiptr)size, data);
+ }
+ GLuint m_id = 0; GLenum m_target = GL_ARRAY_BUFFER;
+ };
+
+ // ---- Texture ------------------------------------------------------
+ class GLTexture : public Texture
+ {
+ public:
+ GLTexture(int w, int h, Format fmt, Filter filter, const void* data)
+ {
+ glGenTextures(1, &m_id); m_own = true; m_target = GL_TEXTURE_2D;
+ glBindTexture(GL_TEXTURE_2D, m_id);
+ GLenum ext = fmt == Format::D32 ? GL_DEPTH_COMPONENT : GL_RGBA;
+ GLenum type = fmt == Format::RGBA8 ? GL_UNSIGNED_BYTE : GL_FLOAT;
+ glTexImage2D(GL_TEXTURE_2D, 0, gl_internal(fmt), w, h, 0, ext, type, data);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter(filter));
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter(filter));
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+ }
+ explicit GLTexture(Ref<CubemapTexture> cube)
+ : m_cube(std::move(cube))
+ {
+ m_target = GL_TEXTURE_CUBE_MAP;
+ m_id = m_cube ? m_cube->get_renderer_id() : 0;
+ }
+ ~GLTexture() override { if (m_own && m_id) glDeleteTextures(1, &m_id); }
+ GLuint m_id = 0; GLenum m_target = GL_TEXTURE_2D; bool m_own = false;
+ Ref<CubemapTexture> m_cube; // keepalive for cubemaps
+ };
+
+ // ---- RenderTarget -------------------------------------------------
+ class GLRenderTarget : public RenderTarget
+ {
+ public:
+ GLRenderTarget(int w, int h, Format color, bool depth, Filter filter)
+ : m_w(w), m_h(h)
+ {
+ m_color = create_scope<GLTexture>(w, h, color, filter, nullptr);
+ glGenFramebuffers(1, &m_fbo);
+ glBindFramebuffer(GL_FRAMEBUFFER, m_fbo);
+ glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_color->m_id, 0);
+ if (depth)
+ {
+ glGenRenderbuffers(1, &m_depth);
+ glBindRenderbuffer(GL_RENDERBUFFER, m_depth);
+ glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24, w, h);
+ glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_depth);
+ }
+ if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
+ DONUT_ERROR("GL RHI: render target incomplete");
+ glBindFramebuffer(GL_FRAMEBUFFER, 0);
+ }
+ ~GLRenderTarget() override
+ {
+ if (m_depth) glDeleteRenderbuffers(1, &m_depth);
+ if (m_fbo) glDeleteFramebuffers(1, &m_fbo);
+ }
+ auto width() const -> int override { return m_w; }
+ auto height() const -> int override { return m_h; }
+ auto color_texture() -> Texture* override { return m_color.get(); }
+ GLuint m_fbo = 0, m_depth = 0; int m_w, m_h; Scope<GLTexture> m_color;
+ };
+
+ // ---- Pipeline -----------------------------------------------------
+ class GLPipeline : public Pipeline
+ {
+ public:
+ explicit GLPipeline(const PipelineDesc& d) : m_desc(d)
+ {
+ std::string path = "assets/shaders/generated/" + d.shader + ".glsl";
+ m_shader = Ref<Shader>(Shader::create(path));
+ m_prog = m_shader ? m_shader->get_renderer_id() : 0;
+ if (!m_prog) { DONUT_ERROR("GL RHI: shader '{}' failed", d.shader); return; }
+
+ glUseProgram(m_prog);
+ for (const auto& r : d.resources)
+ {
+ if (r.kind == ResourceKind::UniformBuffer)
+ {
+ GLuint bi = glGetUniformBlockIndex(m_prog, r.name.c_str());
+ if (bi != GL_INVALID_INDEX) glUniformBlockBinding(m_prog, bi, r.binding);
+ }
+ else // Texture: point the sampler at texture unit == binding
+ {
+ GLint loc = glGetUniformLocation(m_prog, r.name.c_str());
+ if (loc >= 0) glUniform1i(loc, (GLint)r.binding);
+ }
+ }
+ glUseProgram(0);
+ }
+ PipelineDesc m_desc; Ref<Shader> m_shader; GLuint m_prog = 0;
+ };
+
+ // ---- CommandList (immediate) --------------------------------------
+ class GLCommandList : public CommandList
+ {
+ public:
+ explicit GLCommandList(GLuint vao) : m_vao(vao) {}
+
+ auto begin_render_pass(RenderTarget* target, const glm::vec4& clear) -> void override
+ {
+ auto* rt = static_cast<GLRenderTarget*>(target);
+ glBindFramebuffer(GL_FRAMEBUFFER, rt ? rt->m_fbo : 0);
+ int w = rt ? rt->m_w : m_default_w, h = rt ? rt->m_h : m_default_h;
+ glViewport(0, 0, w, h);
+ glDisable(GL_SCISSOR_TEST);
+ glDepthMask(GL_TRUE);
+ glClearColor(clear.r, clear.g, clear.b, clear.a);
+ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+ }
+ auto end_render_pass() -> void override {}
+
+ auto bind_pipeline(Pipeline* p) -> void override
+ {
+ m_pipe = static_cast<GLPipeline*>(p);
+ glUseProgram(m_pipe->m_prog);
+ const auto& d = m_pipe->m_desc;
+ if (d.depth_test) { glEnable(GL_DEPTH_TEST); glDepthFunc(gl_compare(d.depth_op)); }
+ else glDisable(GL_DEPTH_TEST);
+ glDepthMask(d.depth_write ? GL_TRUE : GL_FALSE);
+ if (d.cull == CullMode::None) glDisable(GL_CULL_FACE);
+ else { glEnable(GL_CULL_FACE); glCullFace(d.cull == CullMode::Back ? GL_BACK : GL_FRONT); }
+ if (d.blend == BlendMode::AlphaBlend) { glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); }
+ else glDisable(GL_BLEND);
+ }
+ auto set_viewport(int x, int y, int w, int h, bool /*flip_y*/) -> void override { glViewport(x, y, w, h); }
+ auto bind_uniform(uint32_t binding, Buffer* ubo) -> void override
+ {
+ glBindBufferBase(GL_UNIFORM_BUFFER, binding, static_cast<GLBuffer*>(ubo)->m_id);
+ }
+ auto bind_texture(uint32_t binding, Texture* tex) -> void override
+ {
+ auto* t = static_cast<GLTexture*>(tex);
+ glActiveTexture(GL_TEXTURE0 + binding);
+ glBindTexture(t->m_target, t->m_id);
+ }
+ auto bind_vertex_buffer(Buffer* vb) -> void override
+ {
+ glBindBuffer(GL_ARRAY_BUFFER, static_cast<GLBuffer*>(vb)->m_id);
+ const auto& layout = m_pipe->m_desc.vertex_layout;
+ for (const auto& a : layout.attributes)
+ {
+ glEnableVertexAttribArray(a.location);
+ glVertexAttribPointer(a.location, (GLint)a.components, GL_FLOAT, GL_FALSE,
+ (GLsizei)layout.stride, (const void*)(uintptr_t)a.offset);
+ }
+ }
+ auto bind_index_buffer(Buffer* ib) -> void override
+ {
+ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, static_cast<GLBuffer*>(ib)->m_id);
+ }
+ auto draw(uint32_t count) -> void override
+ {
+ glDrawArrays(gl_topology(m_pipe->m_desc.topology), 0, (GLsizei)count);
+ }
+ auto draw_indexed(uint32_t count) -> void override
+ {
+ glDrawElements(gl_topology(m_pipe->m_desc.topology), (GLsizei)count, GL_UNSIGNED_INT, nullptr);
+ }
+
+ GLuint m_vao; GLPipeline* m_pipe = nullptr; int m_default_w = 1, m_default_h = 1;
+ };
+
+ // ---- Device -------------------------------------------------------
+ class GLDevice : public Device
+ {
+ public:
+ auto init(void* window, int width, int height) -> bool override
+ {
+ m_window = window;
+ glfwMakeContextCurrent(static_cast<GLFWwindow*>(window));
+ if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) { DONUT_ERROR("GL RHI: GLAD load failed"); return false; }
+ m_width = width; m_height = height;
+ const char* name = (const char*)glGetString(GL_RENDERER);
+ m_name = name ? name : "OpenGL";
+ glGenVertexArrays(1, &m_vao); glBindVertexArray(m_vao); // GL core needs one bound VAO
+ m_cmds = create_scope<GLCommandList>(m_vao);
+ DONUT_INFO("GL RHI device: {} ({}x{})", m_name, width, height);
+ return true;
+ }
+ auto shutdown() -> void override
+ {
+ if (m_imgui) { ImGui_ImplOpenGL3_Shutdown(); ImGui_ImplGlfw_Shutdown(); ImGui::DestroyContext(); m_imgui = false; }
+ if (m_vao) { glDeleteVertexArrays(1, &m_vao); m_vao = 0; }
+ }
+ auto resize(int w, int h) -> void override { m_width = w; m_height = h; }
+ auto wait_idle() -> void override { glFinish(); }
+
+ auto create_buffer(BufferType t, size_t size, const void* data) -> Ref<Buffer> override
+ { return create_ref<GLBuffer>(t, size, data); }
+ auto create_texture(int w, int h, Format f, Filter fl, const void* data) -> Ref<Texture> override
+ { return create_ref<GLTexture>(w, h, f, fl, data); }
+ auto create_cubemap_from_hdri(const std::string& path) -> Ref<Texture> override
+ {
+ HDRIManager::get().set_current_hdri(path);
+ return create_ref<GLTexture>(HDRIManager::get().get_current_hdri());
+ }
+ auto create_render_target(int w, int h, Format color, bool depth, Filter fl, int /*mips*/) -> Ref<RenderTarget> override
+ { return create_ref<GLRenderTarget>(w, h, color, depth, fl); }
+ auto create_pipeline(const PipelineDesc& d) -> Ref<Pipeline> override
+ { return create_ref<GLPipeline>(d); }
+
+ auto begin_frame(const glm::vec4& /*clear*/) -> CommandList* override
+ {
+ glfwGetFramebufferSize(static_cast<GLFWwindow*>(m_window), &m_width, &m_height);
+ m_cmds->m_default_w = m_width; m_cmds->m_default_h = m_height;
+ glBindVertexArray(m_vao);
+ return m_cmds.get();
+ }
+ auto end_frame() -> void override { glfwSwapBuffers(static_cast<GLFWwindow*>(m_window)); }
+
+ auto init_imgui() -> void override
+ {
+ IMGUI_CHECKVERSION(); ImGui::CreateContext();
+ ImGui::GetIO().ConfigFlags |= ImGuiConfigFlags_DockingEnable;
+ ImGui_ImplGlfw_InitForOpenGL(static_cast<GLFWwindow*>(m_window), true);
+ ImGui_ImplOpenGL3_Init("#version 410");
+ m_imgui = true;
+ DONUT_INFO("GL RHI: ImGui backend initialized");
+ }
+ auto imgui_new_frame() -> void override
+ {
+ ImGui_ImplOpenGL3_NewFrame(); ImGui_ImplGlfw_NewFrame(); ImGui::NewFrame();
+ }
+ auto imgui_render(CommandList&) -> void override
+ {
+ ImGui::Render(); ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
+ }
+ auto device_name() const -> const std::string& override { return m_name; }
+
+ private:
+ void* m_window = nullptr; std::string m_name; GLuint m_vao = 0;
+ int m_width = 0, m_height = 0; bool m_imgui = false;
+ Scope<GLCommandList> m_cmds;
+ };
+ }
+
+ auto create_opengl_device() -> Scope<Device> { return create_scope<GLDevice>(); }
+}
diff --git a/src/platform/opengl/opengl_device.h b/src/platform/opengl/opengl_device.h
new file mode 100644
index 0000000..4004396
--- /dev/null
+++ b/src/platform/opengl/opengl_device.h
@@ -0,0 +1,11 @@
+#pragma once
+
+#include "rendering/rhi.h"
+
+namespace Donut::RHI
+{
+ // OpenGL implementation of the RHI Device: emulates the explicit model with
+ // immediate-mode GL 4.1 (one global VAO, glBindBufferBase for UBOs, FBOs for
+ // render targets, per-draw attribute setup, bindings assigned by name).
+ auto create_opengl_device() -> Scope<Device>;
+}
diff --git a/src/platform/opengl/opengl_renderer.cpp b/src/platform/opengl/opengl_renderer.cpp
deleted file mode 100644
index ae12f10..0000000
--- a/src/platform/opengl/opengl_renderer.cpp
+++ /dev/null
@@ -1,377 +0,0 @@
-#include "opengl_renderer.h"
-
-#include "engine/engine.h"
-#include "core/log.h"
-#include "core/camera.h"
-#include "core/hdri_manager.h"
-#include "rendering/renderer.h" // Renderer::init / RenderCommand
-
-#include <glad/glad.h>
-#include <GLFW/glfw3.h>
-#include <imgui.h>
-#include <imgui_impl_glfw.h>
-#include <imgui_impl_opengl3.h>
-#include <glm/glm.hpp>
-#include <glm/gtc/matrix_transform.hpp>
-#include <cmath>
-#include <vector>
-
-#include "core/hdri_manager.h"
-#include "rendering/texture.h" // CubemapTexture::bind
-
-namespace Donut
-{
- // Scroll is accumulated through a chained GLFW callback (keeps ImGui's scroll
- // handling intact), consumed once per frame for orbital zoom.
- static double g_scroll_accum = 0.0;
- static GLFWscrollfun g_prev_scroll = nullptr;
- static void gl_scroll_cb(GLFWwindow* w, double x, double y)
- {
- if (g_prev_scroll) g_prev_scroll(w, x, y);
- g_scroll_accum += y;
- }
-
- OpenGLRenderer::OpenGLRenderer() = default;
- OpenGLRenderer::~OpenGLRenderer() = default;
-
- auto OpenGLRenderer::init(void* glfwWindow, int width, int height) -> bool
- {
- m_window = glfwWindow;
- auto* win = static_cast<GLFWwindow*>(glfwWindow);
- glfwMakeContextCurrent(win);
-
- Renderer::init(); // GLAD load + default GL state
- RenderCommand::set_face_culling(false);
-
- const GLubyte* name = glGetString(GL_RENDERER);
- m_device_name = name ? reinterpret_cast<const char*>(name) : "OpenGL";
-
- m_engine = create_scope<Engine>();
- m_engine->set_window_dimensions(width, height);
-#ifdef __APPLE__
- m_engine->set_compute_height(256); // capped for the macOS watchdog (tiled fragment pass)
-#else
- m_engine->set_compute_height(540);
-#endif
- m_engine->update_compute_dimensions();
-
- // Match the Vulkan framing exactly (camera sits outside the disk).
- Camera& cam = m_engine->get_camera();
- cam.set_camera_mode(CameraMode::Orbital);
- cam.set_orbital_target(glm::vec3(0.0f));
- cam.set_orbital_radius(4e11);
- cam.set_orbital_limits(2.2e11, 1.5e12);
- cam.set_orbital_speed(0.01f);
- cam.set_zoom_speed(3e10);
- cam.set_azimuth(0.0f);
- cam.set_elevation(1.25f);
-
- m_hdri_path = "assets/hdri/HDR_blue_nebulae-1.hdr";
- HDRIManager::get().set_current_hdri(m_hdri_path);
-
- create_scene_resources();
-
- DONUT_INFO("OpenGL renderer ready: {} ({}x{})", m_device_name, width, height);
- return true;
- }
-
- auto OpenGLRenderer::init_ui() -> bool
- {
- IMGUI_CHECKVERSION();
- ImGui::CreateContext();
- ImGui::GetIO().ConfigFlags |= ImGuiConfigFlags_DockingEnable;
- ImGui::StyleColorsDark();
- ImGui_ImplGlfw_InitForOpenGL(static_cast<GLFWwindow*>(m_window), true);
- ImGui_ImplOpenGL3_Init("#version 410");
- g_prev_scroll = glfwSetScrollCallback(static_cast<GLFWwindow*>(m_window), gl_scroll_cb);
- m_ui_ready = true;
- DONUT_INFO("OpenGL: ImGui backend initialized");
- return true;
- }
-
- auto OpenGLRenderer::shutdown() -> void
- {
- if (m_ui_ready)
- {
- ImGui_ImplOpenGL3_Shutdown();
- ImGui_ImplGlfw_Shutdown();
- ImGui::DestroyContext();
- m_ui_ready = false;
- }
- m_engine.reset();
- }
-
- auto OpenGLRenderer::resize(int width, int height) -> void
- {
- if (m_engine) m_engine->set_window_dimensions(width, height);
- }
-
- auto OpenGLRenderer::process_input() -> void
- {
- auto* win = static_cast<GLFWwindow*>(m_window);
- Camera& cam = m_scene_mode ? m_scene_camera : m_engine->get_camera();
- bool over_ui = m_ui_ready && ImGui::GetIO().WantCaptureMouse;
-
- double now = glfwGetTime();
- float dt = m_last_frame_time > 0.0 ? static_cast<float>(now - m_last_frame_time) : 0.0f;
- m_last_frame_time = now;
-
- double mx = 0, my = 0; glfwGetCursorPos(win, &mx, &my);
- bool left_down = glfwGetMouseButton(win, GLFW_MOUSE_BUTTON_LEFT) == GLFW_PRESS;
-
- if (!m_scene_mode && cam.get_camera_mode() == CameraMode::FPS)
- {
- if (left_down && !m_left_was_down) { m_last_x = mx; m_last_y = my; }
- if (left_down && !over_ui)
- cam.on_mouse_move(static_cast<float>(mx - m_last_x), static_cast<float>(m_last_y - my));
- m_last_x = mx; m_last_y = my; m_left_was_down = left_down;
-
- bool over_kb = m_ui_ready && ImGui::GetIO().WantCaptureKeyboard;
- if (!over_kb && dt > 0.0f)
- {
- float mdt = dt * (glfwGetKey(win, GLFW_KEY_LEFT_SHIFT) == GLFW_PRESS ? 4.0f : 1.0f);
- if (glfwGetKey(win, GLFW_KEY_W) == GLFW_PRESS) cam.move_forward(mdt);
- if (glfwGetKey(win, GLFW_KEY_S) == GLFW_PRESS) cam.move_backward(mdt);
- if (glfwGetKey(win, GLFW_KEY_A) == GLFW_PRESS) cam.move_left(mdt);
- if (glfwGetKey(win, GLFW_KEY_D) == GLFW_PRESS) cam.move_right(mdt);
- if (glfwGetKey(win, GLFW_KEY_E) == GLFW_PRESS) cam.move_up(mdt);
- if (glfwGetKey(win, GLFW_KEY_Q) == GLFW_PRESS) cam.move_down(mdt);
- }
- g_scroll_accum = 0.0; // scroll unused in free-fly
- }
- else
- {
- if (left_down && !m_left_was_down && !over_ui)
- cam.process_orbital_mouse_button(GLFW_MOUSE_BUTTON_LEFT, GLFW_PRESS, 0);
- else if (!left_down && m_left_was_down)
- cam.process_orbital_mouse_button(GLFW_MOUSE_BUTTON_LEFT, GLFW_RELEASE, 0);
- m_left_was_down = left_down;
-
- cam.process_orbital_mouse_move(mx, my);
- double scroll = g_scroll_accum; g_scroll_accum = 0.0;
- if (scroll != 0.0 && !over_ui) cam.process_orbital_scroll(0.0, scroll);
- }
- }
-
- // 36-vertex unit cube for the skybox (positions only; the shader forces depth=1).
- static const float SKYBOX_CUBE[] = {
- -1, 1,-1, -1,-1,-1, 1,-1,-1, 1,-1,-1, 1, 1,-1, -1, 1,-1,
- -1,-1, 1, -1,-1,-1, -1, 1,-1, -1, 1,-1, -1, 1, 1, -1,-1, 1,
- 1,-1,-1, 1,-1, 1, 1, 1, 1, 1, 1, 1, 1, 1,-1, 1,-1,-1,
- -1,-1, 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1,-1, 1, -1,-1, 1,
- -1, 1,-1, 1, 1,-1, 1, 1, 1, 1, 1, 1, -1, 1, 1, -1, 1,-1,
- -1,-1,-1, -1,-1, 1, 1,-1,-1, 1,-1,-1, -1,-1, 1, 1,-1, 1,
- };
-
- auto OpenGLRenderer::create_scene_resources() -> void
- {
- const float PI = 3.14159265358979f;
-
- m_grid_shader = Ref<Shader>(Shader::create("assets/shaders/Grid.glsl"));
- m_sphere_shader = Ref<Shader>(Shader::create("assets/shaders/Sphere.glsl"));
- m_skybox_shader = Ref<Shader>(Shader::create("assets/shaders/Skybox.glsl"));
-
- m_scene_camera.set_camera_mode(CameraMode::Orbital);
- m_scene_camera.set_orbital_target(glm::vec3(0.0f));
- m_scene_camera.set_orbital_radius(15.0);
- m_scene_camera.set_orbital_limits(2.0, 200.0);
- m_scene_camera.set_orbital_speed(0.01f);
- m_scene_camera.set_zoom_speed(2.0);
- m_scene_camera.set_azimuth(0.0f);
- m_scene_camera.set_elevation(PI / 3.0f);
-
- // Grid: +/-50 lines on the XZ plane (Grid shader scales by u_GridSize/50).
- std::vector<glm::vec3> lines;
- for (int i = -50; i <= 50; ++i)
- {
- lines.push_back({ (float)i, 0.0f, -50.0f }); lines.push_back({ (float)i, 0.0f, 50.0f });
- lines.push_back({ -50.0f, 0.0f, (float)i }); lines.push_back({ 50.0f, 0.0f, (float)i });
- }
- m_grid_vertex_count = (int)lines.size();
- glGenVertexArrays(1, &m_grid_vao); glGenBuffers(1, &m_grid_vbo);
- glBindVertexArray(m_grid_vao); glBindBuffer(GL_ARRAY_BUFFER, m_grid_vbo);
- glBufferData(GL_ARRAY_BUFFER, lines.size() * sizeof(glm::vec3), lines.data(), GL_STATIC_DRAW);
- glEnableVertexAttribArray(0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(glm::vec3), (void*)0);
-
- // Sphere: indexed UV sphere (position + normal), unit radius.
- const int RINGS = 24, SECT = 48;
- std::vector<float> sv; std::vector<unsigned int> si;
- for (int r = 0; r <= RINGS; ++r)
- {
- float th = PI * r / RINGS;
- for (int s = 0; s <= SECT; ++s)
- {
- float ph = 2.0f * PI * s / SECT;
- glm::vec3 p(sinf(th) * cosf(ph), cosf(th), sinf(th) * sinf(ph));
- sv.insert(sv.end(), { p.x, p.y, p.z, p.x, p.y, p.z }); // pos, normal (unit sphere)
- }
- }
- for (int r = 0; r < RINGS; ++r)
- for (int s = 0; s < SECT; ++s)
- {
- int a = r * (SECT + 1) + s, b = a + SECT + 1;
- si.insert(si.end(), { (unsigned)a, (unsigned)b, (unsigned)(a + 1),
- (unsigned)(a + 1), (unsigned)b, (unsigned)(b + 1) });
- }
- m_sphere_index_count = (int)si.size();
- glGenVertexArrays(1, &m_sphere_vao); glGenBuffers(1, &m_sphere_vbo); glGenBuffers(1, &m_sphere_ebo);
- glBindVertexArray(m_sphere_vao);
- glBindBuffer(GL_ARRAY_BUFFER, m_sphere_vbo);
- glBufferData(GL_ARRAY_BUFFER, sv.size() * sizeof(float), sv.data(), GL_STATIC_DRAW);
- glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_sphere_ebo);
- glBufferData(GL_ELEMENT_ARRAY_BUFFER, si.size() * sizeof(unsigned), si.data(), GL_STATIC_DRAW);
- glEnableVertexAttribArray(0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)0);
- glEnableVertexAttribArray(1); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)(3 * sizeof(float)));
-
- // Skybox cube.
- glGenVertexArrays(1, &m_skybox_vao); glGenBuffers(1, &m_skybox_vbo);
- glBindVertexArray(m_skybox_vao); glBindBuffer(GL_ARRAY_BUFFER, m_skybox_vbo);
- glBufferData(GL_ARRAY_BUFFER, sizeof(SKYBOX_CUBE), SKYBOX_CUBE, GL_STATIC_DRAW);
- glEnableVertexAttribArray(0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
-
- glBindVertexArray(0);
- m_scene_ready = true;
- }
-
- auto OpenGLRenderer::render_scene(int w, int h) -> void
- {
- if (!m_grid_shader || !m_sphere_shader || !m_skybox_shader) return;
- glViewport(0, 0, w, h);
- glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
- glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-
- float aspect = h > 0 ? (float)w / (float)h : 1.0f;
- m_scene_camera.set_projection(45.0f, aspect, 0.1f, 1000.0f);
- glm::mat4 proj = m_scene_camera.get_projection_matrix();
- glm::mat4 view = m_scene_camera.get_view_matrix();
- glm::mat4 vp = proj * view;
- glm::vec3 cam = m_scene_camera.get_orbital_position();
-
- // Skybox behind everything (depth test on, write off; shader forces depth=1).
- glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); glDepthMask(GL_FALSE);
- m_skybox_shader->bind();
- m_skybox_shader->set_mat4("u_Projection", proj);
- m_skybox_shader->set_mat4("u_View", glm::mat4(glm::mat3(view))); // strip translation
- auto hdri = HDRIManager::get().get_current_hdri();
- if (hdri) { hdri->bind(0); m_skybox_shader->set_int("u_Skybox", 0); }
- glBindVertexArray(m_skybox_vao); glDrawArrays(GL_TRIANGLES, 0, 36);
-
- // Lit spheres.
- glDepthFunc(GL_LESS); glDepthMask(GL_TRUE);
- m_sphere_shader->bind(); glBindVertexArray(m_sphere_vao);
- for (int i = 0; i < (int)m_scene_objects.size(); ++i)
- {
- const SceneObject& o = m_scene_objects[i];
- m_sphere_shader->set_mat4("u_ViewProjection", vp);
- m_sphere_shader->set_mat4("u_Transform",
- glm::translate(glm::mat4(1.0f), o.position) * glm::scale(glm::mat4(1.0f), glm::vec3(o.radius)));
- m_sphere_shader->set_float3("u_Color", o.color);
- m_sphere_shader->set_float("u_Specular", 0.6f);
- m_sphere_shader->set_float("u_Emission", 0.0f);
- m_sphere_shader->set_float3("u_LightPos", glm::vec3(10.0f, 20.0f, 10.0f));
- m_sphere_shader->set_float3("u_CameraPos", cam);
- m_sphere_shader->set_int("u_IsSelected", i == m_selected_object ? 1 : 0);
- m_sphere_shader->set_float3("u_OutlineColor", glm::vec3(1.0f, 1.0f, 0.0f));
- m_sphere_shader->set_float("u_OutlineWidth", 0.15f);
- glDrawElements(GL_TRIANGLES, m_sphere_index_count, GL_UNSIGNED_INT, 0);
- }
-
- // Transparent grid on top (test, no depth write).
- glDepthMask(GL_FALSE); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
- m_grid_shader->bind();
- m_grid_shader->set_mat4("u_ViewProjection", vp);
- m_grid_shader->set_mat4("u_Transform", glm::mat4(1.0f));
- m_grid_shader->set_float("u_GridSize", 50.0f);
- m_grid_shader->set_float3("u_GridColor", glm::vec3(0.55f, 0.55f, 0.6f));
- m_grid_shader->set_float("u_GridAlpha", 0.75f);
- m_grid_shader->set_float3("u_CameraPos", cam);
- glBindVertexArray(m_grid_vao); glDrawArrays(GL_LINES, 0, m_grid_vertex_count);
- glDisable(GL_BLEND); glDepthMask(GL_TRUE); glBindVertexArray(0);
- }
-
- auto OpenGLRenderer::draw_frame(const glm::vec4& clear_color,
- const std::function<void()>& build_ui) -> void
- {
- auto* win = static_cast<GLFWwindow*>(m_window);
- process_input();
-
- int w = 0, h = 0; glfwGetFramebufferSize(win, &w, &h);
-
- if (m_scene_mode)
- {
- render_scene(w, h);
- }
- else
- {
- m_engine->set_window_dimensions(w, h);
- // Geodesic pass -> low-res texture (watchdog-tiled on macOS), then
- // upscale to the window. Disk/camera come from the shared BlackHoleParams.
- m_engine->dispatch_compute(m_engine->get_camera());
- RenderCommand::set_viewport(0, 0, w, h);
- RenderCommand::set_clear_color(clear_color);
- RenderCommand::clear();
- m_engine->draw_full_screen_quad();
- }
-
- if (m_ui_ready)
- {
- ImGui_ImplOpenGL3_NewFrame();
- ImGui_ImplGlfw_NewFrame();
- ImGui::NewFrame();
- if (build_ui) build_ui();
- ImGui::Render();
- ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
- }
- glfwSwapBuffers(win);
- }
-
- auto OpenGLRenderer::set_scene_mode(bool enabled) -> void { m_scene_mode = enabled; }
- auto OpenGLRenderer::is_scene_mode() const -> bool { return m_scene_mode; }
-
- auto OpenGLRenderer::set_free_fly(bool enabled) -> void
- {
- Camera& cam = m_engine->get_camera();
- if (enabled && cam.get_camera_mode() != CameraMode::FPS)
- {
- glm::vec3 pos = cam.get_orbital_position();
- glm::vec3 fwd = glm::normalize(cam.get_orbital_target() - pos);
- float pitch = glm::degrees(asinf(glm::clamp(fwd.y, -1.0f, 1.0f)));
- float yaw = glm::degrees(atan2f(fwd.z, fwd.x));
- cam.set_position(pos);
- cam.set_rotation(glm::vec3(pitch, yaw, 0.0f));
- cam.set_movement_speed(2.0e10f);
- cam.set_mouse_sensitivity(0.15f);
- cam.set_camera_mode(CameraMode::FPS);
- }
- else if (!enabled)
- {
- cam.set_camera_mode(CameraMode::Orbital);
- }
- }
-
- auto OpenGLRenderer::is_free_fly() const -> bool
- {
- return m_engine->get_camera().get_camera_mode() == CameraMode::FPS;
- }
-
- auto OpenGLRenderer::reset_camera() -> void
- {
- Camera& cam = m_engine->get_camera();
- cam.set_camera_mode(CameraMode::Orbital);
- cam.set_orbital_radius(4e11);
- cam.set_azimuth(0.0f);
- cam.set_elevation(1.25f);
- }
-
- auto OpenGLRenderer::set_hdri(const std::string& path) -> void
- {
- HDRIManager::get().set_current_hdri(path); // the Engine re-reads it each frame
- m_hdri_path = path;
- }
-
- auto OpenGLRenderer::current_hdri() const -> const std::string& { return m_hdri_path; }
- auto OpenGLRenderer::scene_objects() -> std::vector<SceneObject>& { return m_scene_objects; }
- auto OpenGLRenderer::set_selected_object(int index) -> void { m_selected_object = index; }
- auto OpenGLRenderer::black_hole_params() -> BlackHoleParams& { return m_engine->black_hole_params(); }
- auto OpenGLRenderer::device_name() const -> const std::string& { return m_device_name; }
-}
diff --git a/src/platform/opengl/opengl_renderer.h b/src/platform/opengl/opengl_renderer.h
deleted file mode 100644
index 4258f40..0000000
--- a/src/platform/opengl/opengl_renderer.h
+++ /dev/null
@@ -1,72 +0,0 @@
-#pragma once
-
-#include "rendering/renderer_backend.h"
-#include "core/memory.h"
-#include "core/camera.h"
-#include "rendering/shader.h"
-
-// OpenGL implementation of the shared RendererBackend interface. It renders the
-// SAME cross-compiled Geodesic shader the Vulkan backend does (driven by the
-// same BlackHoleParams + camera), so the application behaves identically on
-// either backend. Wraps the Engine, which owns the GL geodesic/present passes
-// and the macOS watchdog-safe tiled rendering.
-namespace Donut
-{
- class Engine;
-
- class OpenGLRenderer : public RendererBackend
- {
- public:
- OpenGLRenderer();
- ~OpenGLRenderer() override;
-
- auto init(void* glfwWindow, int width, int height) -> bool override;
- auto init_ui() -> bool override;
- auto shutdown() -> void override;
- auto resize(int width, int height) -> void override;
- auto draw_frame(const glm::vec4& clear_color,
- const std::function<void()>& build_ui) -> void override;
-
- auto set_scene_mode(bool enabled) -> void override;
- auto is_scene_mode() const -> bool override;
- auto set_free_fly(bool enabled) -> void override;
- auto is_free_fly() const -> bool override;
- auto reset_camera() -> void override;
-
- auto set_hdri(const std::string& path) -> void override;
- auto current_hdri() const -> const std::string& override;
- auto scene_objects() -> std::vector<SceneObject>& override;
- auto set_selected_object(int index) -> void override;
- auto black_hole_params() -> BlackHoleParams& override;
-
- auto device_name() const -> const std::string& override;
-
- private:
- auto process_input() -> void;
- auto create_scene_resources() -> void; // grid + sphere + skybox meshes/shaders
- auto render_scene(int width, int height) -> void;
-
- void* m_window = nullptr;
- Scope<Engine> m_engine;
-
- // World-builder scene view (normal-scale): mirrors the Vulkan scene view
- // with the same shared Grid/Sphere/Skybox shaders.
- Camera m_scene_camera{ 45.0f, 16.0f / 9.0f, 0.1f, 1000.0f };
- Ref<Shader> m_grid_shader, m_sphere_shader, m_skybox_shader;
- unsigned int m_grid_vao = 0, m_grid_vbo = 0;
- unsigned int m_sphere_vao = 0, m_sphere_vbo = 0, m_sphere_ebo = 0;
- unsigned int m_skybox_vao = 0, m_skybox_vbo = 0;
- int m_grid_vertex_count = 0, m_sphere_index_count = 0;
- bool m_scene_ready = false;
- std::vector<SceneObject> m_scene_objects{ SceneObject{} };
- int m_selected_object = 0;
- std::string m_hdri_path;
- std::string m_device_name;
- bool m_scene_mode = false;
- bool m_ui_ready = false;
-
- double m_last_x = 0.0, m_last_y = 0.0;
- bool m_left_was_down = false;
- double m_last_frame_time = 0.0;
- };
-}
diff --git a/src/platform/vulkan/vulkan_context.cpp b/src/platform/vulkan/vulkan_context.cpp
deleted file mode 100644
index ece7700..0000000
--- a/src/platform/vulkan/vulkan_context.cpp
+++ /dev/null
@@ -1,789 +0,0 @@
-#include "vulkan_context.h"
-#include "core/log.h"
-
-#include <vulkan/vulkan.h>
-
-#include <glm/glm.hpp>
-#include <glm/gtc/type_ptr.hpp>
-#include "stb_image_write.h"
-
-#include <vector>
-#include <cstring>
-#include <cstdlib>
-#include <fstream>
-
-namespace Donut
-{
- // Logs and returns false from the enclosing function on any non-success result.
- #define VK_CHECK(expr) \
- do { \
- VkResult _r = (expr); \
- if (_r != VK_SUCCESS) { \
- DONUT_ERROR("Vulkan: {} failed ({})", #expr, (int)_r); \
- return false; \
- } \
- } while (0)
-
- struct VulkanContext::Impl
- {
- VkInstance instance = VK_NULL_HANDLE;
- VkPhysicalDevice physical = VK_NULL_HANDLE;
- VkDevice device = VK_NULL_HANDLE;
- VkQueue graphics_queue = VK_NULL_HANDLE;
- uint32_t graphics_family = 0;
- VkPhysicalDeviceMemoryProperties mem_props{};
-
- auto find_memory_type(uint32_t type_filter, VkMemoryPropertyFlags flags) const -> uint32_t
- {
- for (uint32_t i = 0; i < mem_props.memoryTypeCount; ++i)
- if ((type_filter & (1u << i)) &&
- (mem_props.memoryTypes[i].propertyFlags & flags) == flags)
- return i;
- return UINT32_MAX;
- }
-
- bool create_buffer(VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags props,
- VkBuffer& buf, VkDeviceMemory& mem) const
- {
- VkBufferCreateInfo bci{ VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
- bci.size = size; bci.usage = usage; bci.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
- if (vkCreateBuffer(device, &bci, nullptr, &buf) != VK_SUCCESS) return false;
- VkMemoryRequirements req{}; vkGetBufferMemoryRequirements(device, buf, &req);
- VkMemoryAllocateInfo ai{ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
- ai.allocationSize = req.size;
- ai.memoryTypeIndex = find_memory_type(req.memoryTypeBits, props);
- if (vkAllocateMemory(device, &ai, nullptr, &mem) != VK_SUCCESS) return false;
- vkBindBufferMemory(device, buf, mem, 0);
- return true;
- }
- };
-
- VulkanContext::VulkanContext() { m_impl = new Impl(); }
- VulkanContext::~VulkanContext() { shutdown(); delete m_impl; m_impl = nullptr; }
-
- auto VulkanContext::init() -> bool
- {
- Impl& v = *m_impl;
-
-#ifdef __APPLE__
- // The Homebrew Vulkan loader does not auto-discover MoltenVK or the
- // validation layers; point it at both unless already configured.
- if (!getenv("VK_ICD_FILENAMES"))
- setenv("VK_ICD_FILENAMES", "/opt/homebrew/etc/vulkan/icd.d/MoltenVK_icd.json", 0);
- if (!getenv("VK_LAYER_PATH"))
- setenv("VK_LAYER_PATH", "/opt/homebrew/share/vulkan/explicit_layer.d", 0);
-#endif
-
- // Instance
- VkApplicationInfo app{ VK_STRUCTURE_TYPE_APPLICATION_INFO };
- app.pApplicationName = "Donut";
- app.apiVersion = VK_API_VERSION_1_2;
-
- // MoltenVK is a portability driver: without the portability-enumeration
- // extension + flag, vkEnumeratePhysicalDevices returns zero devices.
- std::vector<const char*> exts = {
- VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME,
- VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME,
- };
-
- // Enable validation layers when they are installed (optional).
- std::vector<const char*> layers;
- uint32_t layer_count = 0;
- vkEnumerateInstanceLayerProperties(&layer_count, nullptr);
- std::vector<VkLayerProperties> avail(layer_count);
- vkEnumerateInstanceLayerProperties(&layer_count, avail.data());
- for (const auto& l : avail)
- if (std::strcmp(l.layerName, "VK_LAYER_KHRONOS_validation") == 0)
- layers.push_back("VK_LAYER_KHRONOS_validation");
-
- VkInstanceCreateInfo ici{ VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO };
- ici.flags = VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR;
- ici.pApplicationInfo = &app;
- ici.enabledExtensionCount = (uint32_t)exts.size();
- ici.ppEnabledExtensionNames = exts.data();
- ici.enabledLayerCount = (uint32_t)layers.size();
- ici.ppEnabledLayerNames = layers.data();
- VK_CHECK(vkCreateInstance(&ici, nullptr, &v.instance));
-
- // Physical device
- uint32_t device_count = 0;
- vkEnumeratePhysicalDevices(v.instance, &device_count, nullptr);
- if (device_count == 0) { DONUT_ERROR("Vulkan: no physical devices"); return false; }
- std::vector<VkPhysicalDevice> devices(device_count);
- vkEnumeratePhysicalDevices(v.instance, &device_count, devices.data());
- v.physical = devices[0];
-
- VkPhysicalDeviceProperties props{};
- vkGetPhysicalDeviceProperties(v.physical, &props);
- vkGetPhysicalDeviceMemoryProperties(v.physical, &v.mem_props);
-
- // Graphics queue family
- uint32_t q_count = 0;
- vkGetPhysicalDeviceQueueFamilyProperties(v.physical, &q_count, nullptr);
- std::vector<VkQueueFamilyProperties> qfams(q_count);
- vkGetPhysicalDeviceQueueFamilyProperties(v.physical, &q_count, qfams.data());
- bool found = false;
- for (uint32_t i = 0; i < q_count; ++i)
- if (qfams[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) { v.graphics_family = i; found = true; break; }
- if (!found) { DONUT_ERROR("Vulkan: no graphics queue family"); return false; }
-
- // Logical device
- // MoltenVK requires VK_KHR_portability_subset to be enabled if present.
- std::vector<const char*> dev_exts;
- uint32_t dev_ext_count = 0;
- vkEnumerateDeviceExtensionProperties(v.physical, nullptr, &dev_ext_count, nullptr);
- std::vector<VkExtensionProperties> dev_ext_props(dev_ext_count);
- vkEnumerateDeviceExtensionProperties(v.physical, nullptr, &dev_ext_count, dev_ext_props.data());
- for (const auto& e : dev_ext_props)
- if (std::strcmp(e.extensionName, "VK_KHR_portability_subset") == 0)
- dev_exts.push_back("VK_KHR_portability_subset");
-
- float priority = 1.0f;
- VkDeviceQueueCreateInfo qci{ VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO };
- qci.queueFamilyIndex = v.graphics_family;
- qci.queueCount = 1;
- qci.pQueuePriorities = &priority;
-
- VkDeviceCreateInfo dci{ VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO };
- dci.queueCreateInfoCount = 1;
- dci.pQueueCreateInfos = &qci;
- dci.enabledExtensionCount = (uint32_t)dev_exts.size();
- dci.ppEnabledExtensionNames = dev_exts.data();
- VK_CHECK(vkCreateDevice(v.physical, &dci, nullptr, &v.device));
- vkGetDeviceQueue(v.device, v.graphics_family, 0, &v.graphics_queue);
-
- DONUT_INFO("Vulkan device: {} (API {}.{}.{}, validation {})",
- props.deviceName,
- VK_API_VERSION_MAJOR(props.apiVersion),
- VK_API_VERSION_MINOR(props.apiVersion),
- VK_API_VERSION_PATCH(props.apiVersion),
- layers.empty() ? "off" : "on");
- return true;
- }
-
- auto VulkanContext::self_test_clear() -> bool
- {
- Impl& v = *m_impl;
- if (v.device == VK_NULL_HANDLE) return false;
-
- const uint32_t W = 64, H = 64;
- const VkFormat fmt = VK_FORMAT_R8G8B8A8_UNORM;
-
- // Offscreen colour image
- VkImage image = VK_NULL_HANDLE; VkDeviceMemory image_mem = VK_NULL_HANDLE;
- VkImageCreateInfo ici{ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
- ici.imageType = VK_IMAGE_TYPE_2D;
- ici.format = fmt;
- ici.extent = { W, H, 1 };
- ici.mipLevels = 1;
- ici.arrayLayers = 1;
- ici.samples = VK_SAMPLE_COUNT_1_BIT;
- ici.tiling = VK_IMAGE_TILING_OPTIMAL;
- ici.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
- ici.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
- VK_CHECK(vkCreateImage(v.device, &ici, nullptr, &image));
-
- VkMemoryRequirements im_req{};
- vkGetImageMemoryRequirements(v.device, image, &im_req);
- VkMemoryAllocateInfo im_alloc{ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
- im_alloc.allocationSize = im_req.size;
- im_alloc.memoryTypeIndex = v.find_memory_type(im_req.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
- VK_CHECK(vkAllocateMemory(v.device, &im_alloc, nullptr, &image_mem));
- VK_CHECK(vkBindImageMemory(v.device, image, image_mem, 0));
-
- VkImageView view = VK_NULL_HANDLE;
- VkImageViewCreateInfo vci{ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO };
- vci.image = image;
- vci.viewType = VK_IMAGE_VIEW_TYPE_2D;
- vci.format = fmt;
- vci.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
- VK_CHECK(vkCreateImageView(v.device, &vci, nullptr, &view));
-
- // Render pass (clear -> store, leave in TRANSFER_SRC for readback)
- VkAttachmentDescription color{};
- color.format = fmt;
- color.samples = VK_SAMPLE_COUNT_1_BIT;
- color.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
- color.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
- color.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
- color.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
- color.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
- color.finalLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
-
- VkAttachmentReference color_ref{ 0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL };
- VkSubpassDescription subpass{};
- subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
- subpass.colorAttachmentCount = 1;
- subpass.pColorAttachments = &color_ref;
-
- // Ensure colour writes finish before the read-back copy.
- VkSubpassDependency dep{};
- dep.srcSubpass = 0;
- dep.dstSubpass = VK_SUBPASS_EXTERNAL;
- dep.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
- dep.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
- dep.dstStageMask = VK_PIPELINE_STAGE_TRANSFER_BIT;
- dep.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
-
- VkRenderPass render_pass = VK_NULL_HANDLE;
- VkRenderPassCreateInfo rpci{ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO };
- rpci.attachmentCount = 1; rpci.pAttachments = &color;
- rpci.subpassCount = 1; rpci.pSubpasses = &subpass;
- rpci.dependencyCount = 1; rpci.pDependencies = &dep;
- VK_CHECK(vkCreateRenderPass(v.device, &rpci, nullptr, &render_pass));
-
- VkFramebuffer fb = VK_NULL_HANDLE;
- VkFramebufferCreateInfo fbci{ VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO };
- fbci.renderPass = render_pass;
- fbci.attachmentCount = 1; fbci.pAttachments = &view;
- fbci.width = W; fbci.height = H; fbci.layers = 1;
- VK_CHECK(vkCreateFramebuffer(v.device, &fbci, nullptr, &fb));
-
- // Host-visible staging buffer for read-back
- VkBuffer staging = VK_NULL_HANDLE; VkDeviceMemory staging_mem = VK_NULL_HANDLE;
- VkBufferCreateInfo bci{ VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
- bci.size = (VkDeviceSize)W * H * 4;
- bci.usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT;
- bci.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
- VK_CHECK(vkCreateBuffer(v.device, &bci, nullptr, &staging));
- VkMemoryRequirements b_req{};
- vkGetBufferMemoryRequirements(v.device, staging, &b_req);
- VkMemoryAllocateInfo b_alloc{ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
- b_alloc.allocationSize = b_req.size;
- b_alloc.memoryTypeIndex = v.find_memory_type(b_req.memoryTypeBits,
- VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
- VK_CHECK(vkAllocateMemory(v.device, &b_alloc, nullptr, &staging_mem));
- VK_CHECK(vkBindBufferMemory(v.device, staging, staging_mem, 0));
-
- // Command buffer: clear via render pass, then copy image -> buffer
- VkCommandPool pool = VK_NULL_HANDLE;
- VkCommandPoolCreateInfo pci{ VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO };
- pci.queueFamilyIndex = v.graphics_family;
- VK_CHECK(vkCreateCommandPool(v.device, &pci, nullptr, &pool));
-
- VkCommandBuffer cmd = VK_NULL_HANDLE;
- VkCommandBufferAllocateInfo cbai{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO };
- cbai.commandPool = pool; cbai.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; cbai.commandBufferCount = 1;
- VK_CHECK(vkAllocateCommandBuffers(v.device, &cbai, &cmd));
-
- VkCommandBufferBeginInfo begin{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO };
- begin.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
- VK_CHECK(vkBeginCommandBuffer(cmd, &begin));
-
- VkClearValue clear{};
- clear.color = { { 0.2f, 0.4f, 0.8f, 1.0f } }; // -> RGBA8 (51, 102, 204, 255)
- VkRenderPassBeginInfo rpbi{ VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO };
- rpbi.renderPass = render_pass; rpbi.framebuffer = fb;
- rpbi.renderArea = { { 0, 0 }, { W, H } };
- rpbi.clearValueCount = 1; rpbi.pClearValues = &clear;
- vkCmdBeginRenderPass(cmd, &rpbi, VK_SUBPASS_CONTENTS_INLINE);
- vkCmdEndRenderPass(cmd);
-
- VkBufferImageCopy region{};
- region.imageSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1 };
- region.imageExtent = { W, H, 1 };
- vkCmdCopyImageToBuffer(cmd, image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, staging, 1, &region);
- VK_CHECK(vkEndCommandBuffer(cmd));
-
- VkFence fence = VK_NULL_HANDLE;
- VkFenceCreateInfo fci{ VK_STRUCTURE_TYPE_FENCE_CREATE_INFO };
- VK_CHECK(vkCreateFence(v.device, &fci, nullptr, &fence));
- VkSubmitInfo submit{ VK_STRUCTURE_TYPE_SUBMIT_INFO };
- submit.commandBufferCount = 1; submit.pCommandBuffers = &cmd;
- VK_CHECK(vkQueueSubmit(v.graphics_queue, 1, &submit, fence));
- VK_CHECK(vkWaitForFences(v.device, 1, &fence, VK_TRUE, UINT64_MAX));
-
- // Read back + verify
- void* mapped = nullptr;
- VK_CHECK(vkMapMemory(v.device, staging_mem, 0, bci.size, 0, &mapped));
- const uint8_t* px = (const uint8_t*)mapped;
- DONUT_INFO("Vulkan clear self-test: pixel RGBA = ({}, {}, {}, {})",
- (int)px[0], (int)px[1], (int)px[2], (int)px[3]);
- bool ok = px[0] > 45 && px[0] < 60 && px[1] > 95 && px[1] < 110 &&
- px[2] > 195 && px[2] < 210 && px[3] == 255;
- vkUnmapMemory(v.device, staging_mem);
- DONUT_INFO("Vulkan clear self-test: {}", ok ? "PASS" : "FAIL");
-
- // Cleanup
- vkDestroyFence(v.device, fence, nullptr);
- vkDestroyCommandPool(v.device, pool, nullptr);
- vkDestroyBuffer(v.device, staging, nullptr);
- vkFreeMemory(v.device, staging_mem, nullptr);
- vkDestroyFramebuffer(v.device, fb, nullptr);
- vkDestroyRenderPass(v.device, render_pass, nullptr);
- vkDestroyImageView(v.device, view, nullptr);
- vkDestroyImage(v.device, image, nullptr);
- vkFreeMemory(v.device, image_mem, nullptr);
- return ok;
- }
-
- static std::vector<uint32_t> load_spirv(const std::string& path)
- {
- std::ifstream f(path, std::ios::binary | std::ios::ate);
- if (!f) return {};
- size_t size = (size_t)f.tellg();
- std::vector<uint32_t> data(size / 4);
- f.seekg(0);
- f.read((char*)data.data(), (std::streamsize)size);
- return data;
- }
-
- auto VulkanContext::self_test_triangle() -> bool
- {
- Impl& v = *m_impl;
- if (v.device == VK_NULL_HANDLE) return false;
-
- const uint32_t W = 64, H = 64;
- const VkFormat fmt = VK_FORMAT_R8G8B8A8_UNORM;
-
- // Offscreen image + view (as in the clear test)
- VkImage image = VK_NULL_HANDLE; VkDeviceMemory image_mem = VK_NULL_HANDLE;
- VkImageCreateInfo ici{ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
- ici.imageType = VK_IMAGE_TYPE_2D; ici.format = fmt; ici.extent = { W, H, 1 };
- ici.mipLevels = 1; ici.arrayLayers = 1; ici.samples = VK_SAMPLE_COUNT_1_BIT;
- ici.tiling = VK_IMAGE_TILING_OPTIMAL;
- ici.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
- VK_CHECK(vkCreateImage(v.device, &ici, nullptr, &image));
- VkMemoryRequirements im_req{}; vkGetImageMemoryRequirements(v.device, image, &im_req);
- VkMemoryAllocateInfo im_alloc{ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
- im_alloc.allocationSize = im_req.size;
- im_alloc.memoryTypeIndex = v.find_memory_type(im_req.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
- VK_CHECK(vkAllocateMemory(v.device, &im_alloc, nullptr, &image_mem));
- VK_CHECK(vkBindImageMemory(v.device, image, image_mem, 0));
- VkImageView view = VK_NULL_HANDLE;
- VkImageViewCreateInfo vci{ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO };
- vci.image = image; vci.viewType = VK_IMAGE_VIEW_TYPE_2D; vci.format = fmt;
- vci.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
- VK_CHECK(vkCreateImageView(v.device, &vci, nullptr, &view));
-
- // Render pass + framebuffer
- VkAttachmentDescription color{};
- color.format = fmt; color.samples = VK_SAMPLE_COUNT_1_BIT;
- color.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; color.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
- color.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; color.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
- color.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; color.finalLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
- VkAttachmentReference color_ref{ 0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL };
- VkSubpassDescription subpass{};
- subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
- subpass.colorAttachmentCount = 1; subpass.pColorAttachments = &color_ref;
- VkSubpassDependency dep{};
- dep.srcSubpass = 0; dep.dstSubpass = VK_SUBPASS_EXTERNAL;
- dep.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; dep.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
- dep.dstStageMask = VK_PIPELINE_STAGE_TRANSFER_BIT; dep.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
- VkRenderPass render_pass = VK_NULL_HANDLE;
- VkRenderPassCreateInfo rpci{ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO };
- rpci.attachmentCount = 1; rpci.pAttachments = &color;
- rpci.subpassCount = 1; rpci.pSubpasses = &subpass;
- rpci.dependencyCount = 1; rpci.pDependencies = &dep;
- VK_CHECK(vkCreateRenderPass(v.device, &rpci, nullptr, &render_pass));
- VkFramebuffer fb = VK_NULL_HANDLE;
- VkFramebufferCreateInfo fbci{ VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO };
- fbci.renderPass = render_pass; fbci.attachmentCount = 1; fbci.pAttachments = &view;
- fbci.width = W; fbci.height = H; fbci.layers = 1;
- VK_CHECK(vkCreateFramebuffer(v.device, &fbci, nullptr, &fb));
-
- // Shader modules from Slang SPIR-V
- auto vspv = load_spirv("assets/shaders/generated/VkPipelineTest.vertexMain.spv");
- auto fspv = load_spirv("assets/shaders/generated/VkPipelineTest.fragmentMain.spv");
- if (vspv.empty() || fspv.empty()) { DONUT_ERROR("Vulkan: VkPipelineTest SPIR-V not found"); return false; }
- VkShaderModule vmod = VK_NULL_HANDLE, fmod = VK_NULL_HANDLE;
- VkShaderModuleCreateInfo smci{ VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO };
- smci.codeSize = vspv.size() * 4; smci.pCode = vspv.data();
- VK_CHECK(vkCreateShaderModule(v.device, &smci, nullptr, &vmod));
- smci.codeSize = fspv.size() * 4; smci.pCode = fspv.data();
- VK_CHECK(vkCreateShaderModule(v.device, &smci, nullptr, &fmod));
-
- // Graphics pipeline
- VkPipelineShaderStageCreateInfo stages[2]{};
- stages[0].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
- stages[0].stage = VK_SHADER_STAGE_VERTEX_BIT; stages[0].module = vmod; stages[0].pName = "main";
- stages[1].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
- stages[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT; stages[1].module = fmod; stages[1].pName = "main";
-
- VkPipelineVertexInputStateCreateInfo vin{ VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO };
- VkPipelineInputAssemblyStateCreateInfo ia{ VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO };
- ia.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
- VkViewport vp{ 0, 0, (float)W, (float)H, 0, 1 };
- VkRect2D scissor{ { 0, 0 }, { W, H } };
- VkPipelineViewportStateCreateInfo vps{ VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO };
- vps.viewportCount = 1; vps.pViewports = &vp; vps.scissorCount = 1; vps.pScissors = &scissor;
- VkPipelineRasterizationStateCreateInfo rs{ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO };
- rs.polygonMode = VK_POLYGON_MODE_FILL; rs.cullMode = VK_CULL_MODE_NONE; rs.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE; rs.lineWidth = 1.0f;
- VkPipelineMultisampleStateCreateInfo ms{ VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO };
- ms.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
- VkPipelineColorBlendAttachmentState cba{};
- cba.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
- VkPipelineColorBlendStateCreateInfo cb{ VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO };
- cb.attachmentCount = 1; cb.pAttachments = &cba;
-
- VkPipelineLayout layout = VK_NULL_HANDLE;
- VkPipelineLayoutCreateInfo plci{ VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO };
- VK_CHECK(vkCreatePipelineLayout(v.device, &plci, nullptr, &layout));
-
- VkPipeline pipeline = VK_NULL_HANDLE;
- VkGraphicsPipelineCreateInfo gpci{ VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO };
- gpci.stageCount = 2; gpci.pStages = stages;
- gpci.pVertexInputState = &vin; gpci.pInputAssemblyState = &ia;
- gpci.pViewportState = &vps; gpci.pRasterizationState = &rs;
- gpci.pMultisampleState = &ms; gpci.pColorBlendState = &cb;
- gpci.layout = layout; gpci.renderPass = render_pass; gpci.subpass = 0;
- VK_CHECK(vkCreateGraphicsPipelines(v.device, VK_NULL_HANDLE, 1, &gpci, nullptr, &pipeline));
-
- // Readback staging buffer
- VkBuffer staging = VK_NULL_HANDLE; VkDeviceMemory staging_mem = VK_NULL_HANDLE;
- VkBufferCreateInfo bci{ VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
- bci.size = (VkDeviceSize)W * H * 4; bci.usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT;
- VK_CHECK(vkCreateBuffer(v.device, &bci, nullptr, &staging));
- VkMemoryRequirements b_req{}; vkGetBufferMemoryRequirements(v.device, staging, &b_req);
- VkMemoryAllocateInfo b_alloc{ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
- b_alloc.allocationSize = b_req.size;
- b_alloc.memoryTypeIndex = v.find_memory_type(b_req.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
- VK_CHECK(vkAllocateMemory(v.device, &b_alloc, nullptr, &staging_mem));
- VK_CHECK(vkBindBufferMemory(v.device, staging, staging_mem, 0));
-
- // Record + submit
- VkCommandPool pool = VK_NULL_HANDLE;
- VkCommandPoolCreateInfo pci{ VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO };
- pci.queueFamilyIndex = v.graphics_family;
- VK_CHECK(vkCreateCommandPool(v.device, &pci, nullptr, &pool));
- VkCommandBuffer cmd = VK_NULL_HANDLE;
- VkCommandBufferAllocateInfo cbai{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO };
- cbai.commandPool = pool; cbai.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; cbai.commandBufferCount = 1;
- VK_CHECK(vkAllocateCommandBuffers(v.device, &cbai, &cmd));
- VkCommandBufferBeginInfo begin{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO };
- begin.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
- VK_CHECK(vkBeginCommandBuffer(cmd, &begin));
- VkClearValue clear{}; clear.color = { { 0.0f, 0.0f, 0.0f, 1.0f } };
- VkRenderPassBeginInfo rpbi{ VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO };
- rpbi.renderPass = render_pass; rpbi.framebuffer = fb;
- rpbi.renderArea = { { 0, 0 }, { W, H } };
- rpbi.clearValueCount = 1; rpbi.pClearValues = &clear;
- vkCmdBeginRenderPass(cmd, &rpbi, VK_SUBPASS_CONTENTS_INLINE);
- vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
- vkCmdDraw(cmd, 3, 1, 0, 0);
- vkCmdEndRenderPass(cmd);
- VkBufferImageCopy region{};
- region.imageSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1 };
- region.imageExtent = { W, H, 1 };
- vkCmdCopyImageToBuffer(cmd, image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, staging, 1, &region);
- VK_CHECK(vkEndCommandBuffer(cmd));
-
- VkFence fence = VK_NULL_HANDLE;
- VkFenceCreateInfo fci{ VK_STRUCTURE_TYPE_FENCE_CREATE_INFO };
- VK_CHECK(vkCreateFence(v.device, &fci, nullptr, &fence));
- VkSubmitInfo submit{ VK_STRUCTURE_TYPE_SUBMIT_INFO };
- submit.commandBufferCount = 1; submit.pCommandBuffers = &cmd;
- VK_CHECK(vkQueueSubmit(v.graphics_queue, 1, &submit, fence));
- VK_CHECK(vkWaitForFences(v.device, 1, &fence, VK_TRUE, UINT64_MAX));
-
- // Verify: centre pixel should be the mid-gradient (not black)
- void* mapped = nullptr;
- VK_CHECK(vkMapMemory(v.device, staging_mem, 0, bci.size, 0, &mapped));
- const uint8_t* px = (const uint8_t*)mapped;
- size_t c = ((size_t)(H / 2) * W + (W / 2)) * 4;
- DONUT_INFO("Vulkan triangle self-test: centre pixel RGBA = ({}, {}, {}, {})",
- (int)px[c + 0], (int)px[c + 1], (int)px[c + 2], (int)px[c + 3]);
- bool ok = (px[c + 0] > 40 || px[c + 1] > 40) && px[c + 3] == 255;
- vkUnmapMemory(v.device, staging_mem);
- DONUT_INFO("Vulkan triangle self-test: {}", ok ? "PASS" : "FAIL");
-
- // Cleanup
- vkDestroyFence(v.device, fence, nullptr);
- vkDestroyCommandPool(v.device, pool, nullptr);
- vkDestroyBuffer(v.device, staging, nullptr);
- vkFreeMemory(v.device, staging_mem, nullptr);
- vkDestroyPipeline(v.device, pipeline, nullptr);
- vkDestroyPipelineLayout(v.device, layout, nullptr);
- vkDestroyShaderModule(v.device, vmod, nullptr);
- vkDestroyShaderModule(v.device, fmod, nullptr);
- vkDestroyFramebuffer(v.device, fb, nullptr);
- vkDestroyRenderPass(v.device, render_pass, nullptr);
- vkDestroyImageView(v.device, view, nullptr);
- vkDestroyImage(v.device, image, nullptr);
- vkFreeMemory(v.device, image_mem, nullptr);
- return ok;
- }
-
- auto VulkanContext::render_geodesic(const char* png_path) -> bool
- {
- Impl& v = *m_impl;
- if (v.device == VK_NULL_HANDLE) return false;
-
- const uint32_t W = 384, H = 216;
- const VkFormat fmt = VK_FORMAT_R8G8B8A8_UNORM;
- const float SagA_rs = 1.269e10f;
-
- // Offscreen colour target
- VkImage image = VK_NULL_HANDLE; VkDeviceMemory image_mem = VK_NULL_HANDLE;
- VkImageCreateInfo ici{ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
- ici.imageType = VK_IMAGE_TYPE_2D; ici.format = fmt; ici.extent = { W, H, 1 };
- ici.mipLevels = 1; ici.arrayLayers = 1; ici.samples = VK_SAMPLE_COUNT_1_BIT;
- ici.tiling = VK_IMAGE_TILING_OPTIMAL;
- ici.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
- VK_CHECK(vkCreateImage(v.device, &ici, nullptr, &image));
- VkMemoryRequirements im_req{}; vkGetImageMemoryRequirements(v.device, image, &im_req);
- VkMemoryAllocateInfo im_alloc{ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
- im_alloc.allocationSize = im_req.size;
- im_alloc.memoryTypeIndex = v.find_memory_type(im_req.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
- VK_CHECK(vkAllocateMemory(v.device, &im_alloc, nullptr, &image_mem));
- VK_CHECK(vkBindImageMemory(v.device, image, image_mem, 0));
- VkImageView view = VK_NULL_HANDLE;
- VkImageViewCreateInfo vci{ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO };
- vci.image = image; vci.viewType = VK_IMAGE_VIEW_TYPE_2D; vci.format = fmt;
- vci.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
- VK_CHECK(vkCreateImageView(v.device, &vci, nullptr, &view));
-
- VkAttachmentDescription color{};
- color.format = fmt; color.samples = VK_SAMPLE_COUNT_1_BIT;
- color.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; color.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
- color.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; color.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
- color.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; color.finalLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
- VkAttachmentReference color_ref{ 0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL };
- VkSubpassDescription subpass{}; subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
- subpass.colorAttachmentCount = 1; subpass.pColorAttachments = &color_ref;
- VkSubpassDependency dep{};
- dep.srcSubpass = 0; dep.dstSubpass = VK_SUBPASS_EXTERNAL;
- dep.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; dep.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
- dep.dstStageMask = VK_PIPELINE_STAGE_TRANSFER_BIT; dep.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
- VkRenderPass render_pass = VK_NULL_HANDLE;
- VkRenderPassCreateInfo rpci{ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO };
- rpci.attachmentCount = 1; rpci.pAttachments = &color;
- rpci.subpassCount = 1; rpci.pSubpasses = &subpass;
- rpci.dependencyCount = 1; rpci.pDependencies = &dep;
- VK_CHECK(vkCreateRenderPass(v.device, &rpci, nullptr, &render_pass));
- VkFramebuffer fb = VK_NULL_HANDLE;
- VkFramebufferCreateInfo fbci{ VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO };
- fbci.renderPass = render_pass; fbci.attachmentCount = 1; fbci.pAttachments = &view;
- fbci.width = W; fbci.height = H; fbci.layers = 1;
- VK_CHECK(vkCreateFramebuffer(v.device, &fbci, nullptr, &fb));
-
- // Uniform buffers (host-visible), filled to match the shader's std140 layout
- const VkMemoryPropertyFlags host_vis = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
- VkBuffer cam_buf, disk_buf, obj_buf, sim_buf;
- VkDeviceMemory cam_mem, disk_mem, obj_mem, sim_mem;
- v.create_buffer(128, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, host_vis, cam_buf, cam_mem);
- v.create_buffer(32, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, host_vis, disk_buf, disk_mem);
- v.create_buffer(800, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, host_vis, obj_buf, obj_mem);
- v.create_buffer(16, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, host_vis, sim_buf, sim_mem);
-
- struct CamUBO {
- glm::vec3 pos; float p0; glm::vec3 right; float p1;
- glm::vec3 up; float p2; glm::vec3 fwd; float p3;
- float tan_half_fov; float aspect; uint32_t moving; int p4;
- } cam{};
- glm::vec3 cam_pos(1e11f, 0.32e11f, 0.0f);
- glm::vec3 fwd = glm::normalize(glm::vec3(0.0f) - cam_pos);
- glm::vec3 right = glm::normalize(glm::cross(fwd, glm::vec3(0, 1, 0)));
- glm::vec3 up = glm::cross(right, fwd);
- cam.pos = cam_pos; cam.right = right; cam.up = up; cam.fwd = fwd;
- cam.tan_half_fov = 0.57735f; cam.aspect = (float)W / (float)H; cam.moving = 0;
- void* p = nullptr;
- vkMapMemory(v.device, cam_mem, 0, 128, 0, &p); memcpy(p, &cam, sizeof(cam)); vkUnmapMemory(v.device, cam_mem);
-
- float disk[8] = { SagA_rs * 2.2f, SagA_rs * 5.2f, 2.0f, SagA_rs * 0.1f, 0.1f, 0, 0, 0 };
- vkMapMemory(v.device, disk_mem, 0, 32, 0, &p); memcpy(p, disk, sizeof(disk)); vkUnmapMemory(v.device, disk_mem);
-
- std::vector<uint8_t> obj_data(800, 0);
- int num_objects = 1; memcpy(obj_data.data(), &num_objects, 4);
- float pos_radius[4] = { 0, 0, 0, SagA_rs }; memcpy(obj_data.data() + 16, pos_radius, 16);
- float obj_color[4] = { 0, 0, 0, 1 }; memcpy(obj_data.data() + 272, obj_color, 16);
- vkMapMemory(v.device, obj_mem, 0, 800, 0, &p); memcpy(p, obj_data.data(), 800); vkUnmapMemory(v.device, obj_mem);
-
- struct SimUBO { int steps_moving; int steps_static; float early_exit; float time; } sim{ 6000, 6000, 5e12f, 0.0f };
- vkMapMemory(v.device, sim_mem, 0, 16, 0, &p); memcpy(p, &sim, sizeof(sim)); vkUnmapMemory(v.device, sim_mem);
-
- // Dark cubemap (stands in for the HDRI for now)
- VkImage cube = VK_NULL_HANDLE; VkDeviceMemory cube_mem = VK_NULL_HANDLE;
- VkImageCreateInfo cci{ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
- cci.flags = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
- cci.imageType = VK_IMAGE_TYPE_2D; cci.format = fmt; cci.extent = { 1, 1, 1 };
- cci.mipLevels = 1; cci.arrayLayers = 6; cci.samples = VK_SAMPLE_COUNT_1_BIT;
- cci.tiling = VK_IMAGE_TILING_OPTIMAL;
- cci.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
- VK_CHECK(vkCreateImage(v.device, &cci, nullptr, &cube));
- VkMemoryRequirements cube_req{}; vkGetImageMemoryRequirements(v.device, cube, &cube_req);
- VkMemoryAllocateInfo cube_alloc{ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
- cube_alloc.allocationSize = cube_req.size;
- cube_alloc.memoryTypeIndex = v.find_memory_type(cube_req.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
- VK_CHECK(vkAllocateMemory(v.device, &cube_alloc, nullptr, &cube_mem));
- VK_CHECK(vkBindImageMemory(v.device, cube, cube_mem, 0));
- VkImageView cube_view = VK_NULL_HANDLE;
- VkImageViewCreateInfo cvci{ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO };
- cvci.image = cube; cvci.viewType = VK_IMAGE_VIEW_TYPE_CUBE; cvci.format = fmt;
- cvci.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 6 };
- VK_CHECK(vkCreateImageView(v.device, &cvci, nullptr, &cube_view));
- VkSampler sampler = VK_NULL_HANDLE;
- VkSamplerCreateInfo smci{ VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO };
- smci.magFilter = VK_FILTER_LINEAR; smci.minFilter = VK_FILTER_LINEAR;
- smci.addressModeU = smci.addressModeV = smci.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
- VK_CHECK(vkCreateSampler(v.device, &smci, nullptr, &sampler));
-
- VkBuffer cube_staging; VkDeviceMemory cube_staging_mem;
- v.create_buffer(6 * 4, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, host_vis, cube_staging, cube_staging_mem);
- uint8_t cube_pixels[6 * 4];
- for (int i = 0; i < 6; ++i) { cube_pixels[i * 4 + 0] = 6; cube_pixels[i * 4 + 1] = 6; cube_pixels[i * 4 + 2] = 14; cube_pixels[i * 4 + 3] = 255; }
- vkMapMemory(v.device, cube_staging_mem, 0, 24, 0, &p); memcpy(p, cube_pixels, 24); vkUnmapMemory(v.device, cube_staging_mem);
-
- // Descriptor set: 4 UBOs (bindings 0-3) + cubemap sampler (binding 4)
- VkDescriptorSetLayoutBinding binds[5]{};
- for (int i = 0; i < 4; ++i) { binds[i].binding = i; binds[i].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; binds[i].descriptorCount = 1; binds[i].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT; }
- binds[4].binding = 4; binds[4].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; binds[4].descriptorCount = 1; binds[4].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
- VkDescriptorSetLayout set_layout = VK_NULL_HANDLE;
- VkDescriptorSetLayoutCreateInfo dslci{ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO };
- dslci.bindingCount = 5; dslci.pBindings = binds;
- VK_CHECK(vkCreateDescriptorSetLayout(v.device, &dslci, nullptr, &set_layout));
- VkDescriptorPoolSize psizes[2] = { { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 4 }, { VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1 } };
- VkDescriptorPool pool = VK_NULL_HANDLE;
- VkDescriptorPoolCreateInfo dpci{ VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO };
- dpci.maxSets = 1; dpci.poolSizeCount = 2; dpci.pPoolSizes = psizes;
- VK_CHECK(vkCreateDescriptorPool(v.device, &dpci, nullptr, &pool));
- VkDescriptorSet set = VK_NULL_HANDLE;
- VkDescriptorSetAllocateInfo dsai{ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO };
- dsai.descriptorPool = pool; dsai.descriptorSetCount = 1; dsai.pSetLayouts = &set_layout;
- VK_CHECK(vkAllocateDescriptorSets(v.device, &dsai, &set));
-
- // load geodesic SPIR-V + build the pipeline
- auto vspv = load_spirv("assets/shaders/generated/Geodesic.vertexMain.spv");
- auto fspv = load_spirv("assets/shaders/generated/Geodesic.fragmentMain.spv");
- if (vspv.empty() || fspv.empty()) { DONUT_ERROR("Vulkan: geodesic SPIR-V not found"); return false; }
- VkShaderModule vmod, fmod;
- VkShaderModuleCreateInfo smci2{ VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO };
- smci2.codeSize = vspv.size() * 4; smci2.pCode = vspv.data(); VK_CHECK(vkCreateShaderModule(v.device, &smci2, nullptr, &vmod));
- smci2.codeSize = fspv.size() * 4; smci2.pCode = fspv.data(); VK_CHECK(vkCreateShaderModule(v.device, &smci2, nullptr, &fmod));
-
- VkPipelineLayout layout = VK_NULL_HANDLE;
- VkPipelineLayoutCreateInfo plci{ VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO };
- plci.setLayoutCount = 1; plci.pSetLayouts = &set_layout;
- VK_CHECK(vkCreatePipelineLayout(v.device, &plci, nullptr, &layout));
-
- VkPipelineShaderStageCreateInfo stages[2]{};
- stages[0].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; stages[0].stage = VK_SHADER_STAGE_VERTEX_BIT; stages[0].module = vmod; stages[0].pName = "main";
- stages[1].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; stages[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT; stages[1].module = fmod; stages[1].pName = "main";
- VkVertexInputBindingDescription vib{ 0, 16, VK_VERTEX_INPUT_RATE_VERTEX };
- VkVertexInputAttributeDescription via[2] = { { 0, 0, VK_FORMAT_R32G32_SFLOAT, 0 }, { 1, 0, VK_FORMAT_R32G32_SFLOAT, 8 } };
- VkPipelineVertexInputStateCreateInfo vin{ VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO };
- vin.vertexBindingDescriptionCount = 1; vin.pVertexBindingDescriptions = &vib;
- vin.vertexAttributeDescriptionCount = 2; vin.pVertexAttributeDescriptions = via;
- VkPipelineInputAssemblyStateCreateInfo ia{ VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO }; ia.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
- VkViewport vp{ 0, 0, (float)W, (float)H, 0, 1 }; VkRect2D sc{ { 0, 0 }, { W, H } };
- VkPipelineViewportStateCreateInfo vps{ VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO }; vps.viewportCount = 1; vps.pViewports = &vp; vps.scissorCount = 1; vps.pScissors = &sc;
- VkPipelineRasterizationStateCreateInfo rs{ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO }; rs.polygonMode = VK_POLYGON_MODE_FILL; rs.cullMode = VK_CULL_MODE_NONE; rs.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE; rs.lineWidth = 1.0f;
- VkPipelineMultisampleStateCreateInfo ms{ VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO }; ms.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
- VkPipelineColorBlendAttachmentState cba{}; cba.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
- VkPipelineColorBlendStateCreateInfo cb{ VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO }; cb.attachmentCount = 1; cb.pAttachments = &cba;
- VkPipeline pipeline = VK_NULL_HANDLE;
- VkGraphicsPipelineCreateInfo gpci{ VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO };
- gpci.stageCount = 2; gpci.pStages = stages;
- gpci.pVertexInputState = &vin; gpci.pInputAssemblyState = &ia; gpci.pViewportState = &vps;
- gpci.pRasterizationState = &rs; gpci.pMultisampleState = &ms; gpci.pColorBlendState = &cb;
- gpci.layout = layout; gpci.renderPass = render_pass; gpci.subpass = 0;
- VK_CHECK(vkCreateGraphicsPipelines(v.device, VK_NULL_HANDLE, 1, &gpci, nullptr, &pipeline));
-
- // Fullscreen quad (position.xy, texcoord.uv)
- float quad[] = {
- -1.f, 1.f, 0.f, 1.f, -1.f, -1.f, 0.f, 0.f, 1.f, -1.f, 1.f, 0.f,
- -1.f, 1.f, 0.f, 1.f, 1.f, -1.f, 1.f, 0.f, 1.f, 1.f, 1.f, 1.f,
- };
- VkBuffer vbuf; VkDeviceMemory vbuf_mem;
- v.create_buffer(sizeof(quad), VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, host_vis, vbuf, vbuf_mem);
- vkMapMemory(v.device, vbuf_mem, 0, sizeof(quad), 0, &p); memcpy(p, quad, sizeof(quad)); vkUnmapMemory(v.device, vbuf_mem);
-
- // Write the descriptor set
- VkDescriptorBufferInfo bi[4] = {
- { cam_buf, 0, VK_WHOLE_SIZE }, { disk_buf, 0, VK_WHOLE_SIZE }, { obj_buf, 0, VK_WHOLE_SIZE }, { sim_buf, 0, VK_WHOLE_SIZE } };
- VkDescriptorImageInfo ii{ sampler, cube_view, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL };
- VkWriteDescriptorSet writes[5]{};
- for (int i = 0; i < 4; ++i) { writes[i].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; writes[i].dstSet = set; writes[i].dstBinding = i; writes[i].descriptorCount = 1; writes[i].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; writes[i].pBufferInfo = &bi[i]; }
- writes[4].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; writes[4].dstSet = set; writes[4].dstBinding = 4; writes[4].descriptorCount = 1; writes[4].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; writes[4].pImageInfo = &ii;
- vkUpdateDescriptorSets(v.device, 5, writes, 0, nullptr);
-
- VkBuffer readback; VkDeviceMemory readback_mem;
- v.create_buffer((VkDeviceSize)W * H * 4, VK_BUFFER_USAGE_TRANSFER_DST_BIT, host_vis, readback, readback_mem);
-
- // Record + submit
- VkCommandPool cpool = VK_NULL_HANDLE;
- VkCommandPoolCreateInfo pci{ VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO }; pci.queueFamilyIndex = v.graphics_family;
- VK_CHECK(vkCreateCommandPool(v.device, &pci, nullptr, &cpool));
- VkCommandBuffer cmd = VK_NULL_HANDLE;
- VkCommandBufferAllocateInfo cbai{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO }; cbai.commandPool = cpool; cbai.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; cbai.commandBufferCount = 1;
- VK_CHECK(vkAllocateCommandBuffers(v.device, &cbai, &cmd));
- VkCommandBufferBeginInfo begin{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO }; begin.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
- VK_CHECK(vkBeginCommandBuffer(cmd, &begin));
-
- VkImageMemoryBarrier to_dst{ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER };
- to_dst.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED; to_dst.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
- to_dst.image = cube; to_dst.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 6 };
- to_dst.srcAccessMask = 0; to_dst.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
- vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &to_dst);
- VkBufferImageCopy cube_copy{}; cube_copy.imageSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 6 }; cube_copy.imageExtent = { 1, 1, 1 };
- vkCmdCopyBufferToImage(cmd, cube_staging, cube, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &cube_copy);
- VkImageMemoryBarrier to_read = to_dst;
- to_read.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; to_read.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
- to_read.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; to_read.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
- vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, 0, nullptr, 0, nullptr, 1, &to_read);
-
- VkClearValue clear{}; clear.color = { { 0, 0, 0, 1 } };
- VkRenderPassBeginInfo rpbi{ VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO };
- rpbi.renderPass = render_pass; rpbi.framebuffer = fb; rpbi.renderArea = { { 0, 0 }, { W, H } };
- rpbi.clearValueCount = 1; rpbi.pClearValues = &clear;
- vkCmdBeginRenderPass(cmd, &rpbi, VK_SUBPASS_CONTENTS_INLINE);
- vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
- vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, layout, 0, 1, &set, 0, nullptr);
- VkDeviceSize voff = 0; vkCmdBindVertexBuffers(cmd, 0, 1, &vbuf, &voff);
- vkCmdDraw(cmd, 6, 1, 0, 0);
- vkCmdEndRenderPass(cmd);
- VkBufferImageCopy region{}; region.imageSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1 }; region.imageExtent = { W, H, 1 };
- vkCmdCopyImageToBuffer(cmd, image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, readback, 1, &region);
- VK_CHECK(vkEndCommandBuffer(cmd));
-
- VkFence fence = VK_NULL_HANDLE; VkFenceCreateInfo fci{ VK_STRUCTURE_TYPE_FENCE_CREATE_INFO };
- VK_CHECK(vkCreateFence(v.device, &fci, nullptr, &fence));
- VkSubmitInfo submit{ VK_STRUCTURE_TYPE_SUBMIT_INFO }; submit.commandBufferCount = 1; submit.pCommandBuffers = &cmd;
- VK_CHECK(vkQueueSubmit(v.graphics_queue, 1, &submit, fence));
- VK_CHECK(vkWaitForFences(v.device, 1, &fence, VK_TRUE, UINT64_MAX));
-
- vkMapMemory(v.device, readback_mem, 0, (VkDeviceSize)W * H * 4, 0, &p);
- stbi_write_png(png_path, W, H, 4, p, W * 4);
- vkUnmapMemory(v.device, readback_mem);
- DONUT_INFO("Vulkan geodesic render written to {}", png_path);
-
- vkDestroyFence(v.device, fence, nullptr);
- vkDestroyCommandPool(v.device, cpool, nullptr);
- vkDestroyBuffer(v.device, readback, nullptr); vkFreeMemory(v.device, readback_mem, nullptr);
- vkDestroyBuffer(v.device, vbuf, nullptr); vkFreeMemory(v.device, vbuf_mem, nullptr);
- vkDestroyPipeline(v.device, pipeline, nullptr); vkDestroyPipelineLayout(v.device, layout, nullptr);
- vkDestroyShaderModule(v.device, vmod, nullptr); vkDestroyShaderModule(v.device, fmod, nullptr);
- vkDestroyDescriptorPool(v.device, pool, nullptr); vkDestroyDescriptorSetLayout(v.device, set_layout, nullptr);
- vkDestroySampler(v.device, sampler, nullptr); vkDestroyImageView(v.device, cube_view, nullptr);
- vkDestroyImage(v.device, cube, nullptr); vkFreeMemory(v.device, cube_mem, nullptr);
- vkDestroyBuffer(v.device, cube_staging, nullptr); vkFreeMemory(v.device, cube_staging_mem, nullptr);
- vkDestroyBuffer(v.device, cam_buf, nullptr); vkFreeMemory(v.device, cam_mem, nullptr);
- vkDestroyBuffer(v.device, disk_buf, nullptr); vkFreeMemory(v.device, disk_mem, nullptr);
- vkDestroyBuffer(v.device, obj_buf, nullptr); vkFreeMemory(v.device, obj_mem, nullptr);
- vkDestroyBuffer(v.device, sim_buf, nullptr); vkFreeMemory(v.device, sim_mem, nullptr);
- vkDestroyFramebuffer(v.device, fb, nullptr); vkDestroyRenderPass(v.device, render_pass, nullptr);
- vkDestroyImageView(v.device, view, nullptr); vkDestroyImage(v.device, image, nullptr); vkFreeMemory(v.device, image_mem, nullptr);
- return true;
- }
-
- auto VulkanContext::shutdown() -> void
- {
- Impl& v = *m_impl;
- if (v.device) { vkDestroyDevice(v.device, nullptr); v.device = VK_NULL_HANDLE; }
- if (v.instance) { vkDestroyInstance(v.instance, nullptr); v.instance = VK_NULL_HANDLE; }
- }
-
- auto vulkan_self_test() -> bool
- {
- VulkanContext ctx;
- if (!ctx.init())
- {
- DONUT_ERROR("Vulkan: initialization failed");
- return false;
- }
- bool ok = ctx.self_test_clear();
- ok = ctx.self_test_triangle() && ok;
- ctx.shutdown();
- return ok;
- }
-}
diff --git a/src/platform/vulkan/vulkan_context.h b/src/platform/vulkan/vulkan_context.h
deleted file mode 100644
index de57c90..0000000
--- a/src/platform/vulkan/vulkan_context.h
+++ /dev/null
@@ -1,41 +0,0 @@
-#pragma once
-
-// Pure-C++ interface to the Vulkan backend (no vulkan.h leaks into the rest of
-// the engine; the implementation lives in VulkanContext.cpp). On macOS Vulkan
-// runs through MoltenVK (Vulkan -> Metal).
-namespace Donut
-{
- class VulkanContext
- {
- public:
- VulkanContext();
- ~VulkanContext();
-
- // Creates the instance, picks a physical device, and creates the logical
- // device + graphics queue. Returns false (and logs) on failure.
- auto init() -> bool;
- auto shutdown() -> void;
-
- // Phase 1 verification: renders a known clear colour into an offscreen
- // image and reads it back, confirming instance -> device -> render pass
- // -> command buffer -> submit -> read-back all work end to end.
- auto self_test_clear() -> bool;
-
- // Phase 2/3 verification: builds a graphics pipeline from Slang-compiled
- // SPIR-V and draws a full-screen gradient triangle into the offscreen
- // image, confirming the SPIR-V -> pipeline -> draw path works.
- auto self_test_triangle() -> bool;
-
- // B-3: renders the geodesic (black hole) fragment shader through Vulkan
- // into an offscreen image and writes it to pngPath. Exercises UBOs,
- // descriptor sets, a cubemap sampler and the geodesic pipeline.
- auto render_geodesic(const char* pngPath) -> bool;
-
- private:
- struct Impl;
- Impl* m_impl = nullptr;
- };
-
- // Convenience one-shot: init() + self_test_clear() + shutdown(). Logs results.
- auto vulkan_self_test() -> bool;
-}
diff --git a/src/platform/vulkan/vulkan_device.cpp b/src/platform/vulkan/vulkan_device.cpp
new file mode 100644
index 0000000..4311d0c
--- /dev/null
+++ b/src/platform/vulkan/vulkan_device.cpp
@@ -0,0 +1,1254 @@
+#include "vulkan_device.h"
+
+#include "core/log.h"
+
+#define GLFW_INCLUDE_VULKAN
+#include <GLFW/glfw3.h>
+
+#include <imgui.h>
+#include <imgui_impl_glfw.h>
+#include <imgui_impl_vulkan.h>
+
+#include <glm/glm.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+#include "stb_image.h"
+
+#include <vector>
+#include <array>
+#include <algorithm>
+#include <cstring>
+#include <cstdlib>
+#include <fstream>
+
+namespace Donut::RHI
+{
+ namespace
+ {
+ constexpr int MAX_FRAMES_IN_FLIGHT = 2;
+ constexpr uint32_t MAX_BINDINGS = 8;
+
+ #define VKD_CHECK(expr) \
+ do { \
+ VkResult _r = (expr); \
+ if (_r != VK_SUCCESS) { \
+ DONUT_ERROR("Vulkan RHI: {} failed ({})", #expr, (int)_r); \
+ return false; \
+ } \
+ } while (0)
+
+ auto vk_format(Format f) -> VkFormat
+ {
+ switch (f) {
+ case Format::RGBA16F: return VK_FORMAT_R16G16B16A16_SFLOAT;
+ case Format::D32: return VK_FORMAT_D32_SFLOAT;
+ default: return VK_FORMAT_R8G8B8A8_UNORM;
+ }
+ }
+ auto vk_attr_format(uint32_t comps) -> VkFormat
+ {
+ switch (comps) {
+ case 1: return VK_FORMAT_R32_SFLOAT;
+ case 2: return VK_FORMAT_R32G32_SFLOAT;
+ case 3: return VK_FORMAT_R32G32B32_SFLOAT;
+ default: return VK_FORMAT_R32G32B32A32_SFLOAT;
+ }
+ }
+ auto vk_topology(Topology t) -> VkPrimitiveTopology
+ { return t == Topology::Lines ? VK_PRIMITIVE_TOPOLOGY_LINE_LIST : VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; }
+ auto vk_compare(CompareOp o) -> VkCompareOp
+ { return o == CompareOp::Always ? VK_COMPARE_OP_ALWAYS : o == CompareOp::LessEqual ? VK_COMPARE_OP_LESS_OR_EQUAL : VK_COMPARE_OP_LESS; }
+ auto vk_filter(Filter f) -> VkFilter { return f == Filter::Nearest ? VK_FILTER_NEAREST : VK_FILTER_LINEAR; }
+ auto vk_cull(CullMode c) -> VkCullModeFlags
+ { return c == CullMode::None ? VK_CULL_MODE_NONE : c == CullMode::Back ? VK_CULL_MODE_BACK_BIT : VK_CULL_MODE_FRONT_BIT; }
+
+ class VulkanDevice;
+
+ // ---- Buffer: host-visible + coherent, persistently mapped -----------
+ class VkBufferR : public Buffer
+ {
+ public:
+ VkBufferR(VkDevice d, VkBuffer b, VkDeviceMemory m, void* mapped, size_t size)
+ : m_device(d), m_buf(b), m_mem(m), m_mapped(mapped), m_size(size) {}
+ ~VkBufferR() override
+ {
+ if (m_mapped) vkUnmapMemory(m_device, m_mem);
+ if (m_buf) vkDestroyBuffer(m_device, m_buf, nullptr);
+ if (m_mem) vkFreeMemory(m_device, m_mem, nullptr);
+ }
+ auto update(const void* data, size_t size) -> void override
+ { if (m_mapped) std::memcpy(m_mapped, data, std::min(size, m_size)); }
+
+ VkDevice m_device; VkBuffer m_buf; VkDeviceMemory m_mem; void* m_mapped; size_t m_size;
+ };
+
+ // ---- Texture: sampled image (2D or cube). Owns its handles unless it is
+ // a borrowed wrapper around a render-target view. ------------------
+ class VkTextureR : public Texture
+ {
+ public:
+ VkTextureR() = default;
+ ~VkTextureR() override
+ {
+ if (!m_owns) return;
+ if (m_sampler) vkDestroySampler(m_device, m_sampler, nullptr);
+ if (m_view) vkDestroyImageView(m_device, m_view, nullptr);
+ if (m_image) vkDestroyImage(m_device, m_image, nullptr);
+ if (m_mem) vkFreeMemory(m_device, m_mem, nullptr);
+ }
+ VkDevice m_device = VK_NULL_HANDLE;
+ VkImage m_image = VK_NULL_HANDLE;
+ VkDeviceMemory m_mem = VK_NULL_HANDLE;
+ VkImageView m_view = VK_NULL_HANDLE;
+ VkSampler m_sampler = VK_NULL_HANDLE;
+ bool m_owns = true;
+ };
+
+ // ---- RenderTarget: off-screen colour image + framebuffer ------------
+ class VkRenderTargetR : public RenderTarget
+ {
+ public:
+ ~VkRenderTargetR() override
+ {
+ if (m_fb) vkDestroyFramebuffer(m_device, m_fb, nullptr);
+ if (m_sampler) vkDestroySampler(m_device, m_sampler, nullptr);
+ if (m_view) vkDestroyImageView(m_device, m_view, nullptr);
+ if (m_image) vkDestroyImage(m_device, m_image, nullptr);
+ if (m_mem) vkFreeMemory(m_device, m_mem, nullptr);
+ }
+ auto width() const -> int override { return m_w; }
+ auto height() const -> int override { return m_h; }
+ auto color_texture() -> Texture* override { return &m_color; }
+
+ VkDevice m_device = VK_NULL_HANDLE;
+ int m_w = 0, m_h = 0;
+ VkImage m_image = VK_NULL_HANDLE;
+ VkDeviceMemory m_mem = VK_NULL_HANDLE;
+ VkImageView m_view = VK_NULL_HANDLE;
+ VkSampler m_sampler = VK_NULL_HANDLE;
+ VkFramebuffer m_fb = VK_NULL_HANDLE;
+ VkTextureR m_color; // borrowed wrapper (view+sampler) for sampling
+ };
+
+ // ---- Pipeline -------------------------------------------------------
+ class VkPipelineR : public Pipeline
+ {
+ public:
+ ~VkPipelineR() override
+ {
+ if (m_pipeline) vkDestroyPipeline(m_device, m_pipeline, nullptr);
+ if (m_layout) vkDestroyPipelineLayout(m_device, m_layout, nullptr);
+ if (m_set_layout) vkDestroyDescriptorSetLayout(m_device, m_set_layout, nullptr);
+ }
+ VkDevice m_device = VK_NULL_HANDLE;
+ VkPipeline m_pipeline = VK_NULL_HANDLE;
+ VkPipelineLayout m_layout = VK_NULL_HANDLE;
+ VkDescriptorSetLayout m_set_layout = VK_NULL_HANDLE;
+ std::vector<ResourceSlot> m_resources;
+ };
+
+ // ---- CommandList ----------------------------------------------------
+ class VkCommandListR : public CommandList
+ {
+ public:
+ auto begin_render_pass(RenderTarget* target, const glm::vec4& clear) -> void override
+ {
+ VkClearValue cvs[2]{};
+ cvs[0].color = { { clear.r, clear.g, clear.b, clear.a } };
+ cvs[1].depthStencil = { 1.0f, 0 };
+ VkRenderPassBeginInfo rpbi{ VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO };
+ if (target)
+ {
+ auto* rt = static_cast<VkRenderTargetR*>(target);
+ rpbi.renderPass = m_offscreen_rp; rpbi.framebuffer = rt->m_fb;
+ rpbi.renderArea = { { 0, 0 }, { (uint32_t)rt->m_w, (uint32_t)rt->m_h } };
+ rpbi.clearValueCount = 1; rpbi.pClearValues = cvs;
+ }
+ else
+ {
+ rpbi.renderPass = m_swapchain_rp; rpbi.framebuffer = m_swapchain_fb;
+ rpbi.renderArea = { { 0, 0 }, m_extent };
+ rpbi.clearValueCount = 2; rpbi.pClearValues = cvs;
+ }
+ vkCmdBeginRenderPass(m_cmd, &rpbi, VK_SUBPASS_CONTENTS_INLINE);
+ }
+ auto end_render_pass() -> void override { vkCmdEndRenderPass(m_cmd); }
+
+ auto bind_pipeline(Pipeline* p) -> void override
+ {
+ m_pipe = static_cast<VkPipelineR*>(p);
+ vkCmdBindPipeline(m_cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, m_pipe->m_pipeline);
+ }
+ auto set_viewport(int x, int y, int w, int h, bool flip_y) -> void override
+ {
+ VkViewport vp{ (float)x, flip_y ? (float)(y + h) : (float)y,
+ (float)w, flip_y ? -(float)h : (float)h, 0.0f, 1.0f };
+ VkRect2D sc{ { x, y }, { (uint32_t)w, (uint32_t)h } };
+ vkCmdSetViewport(m_cmd, 0, 1, &vp);
+ vkCmdSetScissor(m_cmd, 0, 1, &sc);
+ }
+ auto bind_uniform(uint32_t binding, Buffer* ubo) -> void override
+ {
+ if (binding >= MAX_BINDINGS) return;
+ m_buf_info[binding] = { static_cast<VkBufferR*>(ubo)->m_buf, 0, VK_WHOLE_SIZE };
+ }
+ auto bind_texture(uint32_t binding, Texture* texture) -> void override
+ {
+ if (binding >= MAX_BINDINGS) return;
+ auto* t = static_cast<VkTextureR*>(texture);
+ m_img_info[binding] = { t->m_sampler, t->m_view, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL };
+ }
+ auto bind_vertex_buffer(Buffer* vb) -> void override
+ {
+ VkBuffer b = static_cast<VkBufferR*>(vb)->m_buf; VkDeviceSize off = 0;
+ vkCmdBindVertexBuffers(m_cmd, 0, 1, &b, &off);
+ }
+ auto bind_index_buffer(Buffer* ib) -> void override
+ { vkCmdBindIndexBuffer(m_cmd, static_cast<VkBufferR*>(ib)->m_buf, 0, VK_INDEX_TYPE_UINT32); }
+ auto draw(uint32_t vertex_count) -> void override
+ { flush_descriptors(); vkCmdDraw(m_cmd, vertex_count, 1, 0, 0); }
+ auto draw_indexed(uint32_t index_count) -> void override
+ { flush_descriptors(); vkCmdDrawIndexed(m_cmd, index_count, 1, 0, 0, 0); }
+
+ // Allocate + write + bind a descriptor set for the current pipeline's
+ // declared resources, using whatever was bound since bind_pipeline.
+ auto flush_descriptors() -> void
+ {
+ if (!m_pipe || m_pipe->m_resources.empty()) return;
+ VkDescriptorSetAllocateInfo ai{ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO };
+ ai.descriptorPool = m_frame_pool; ai.descriptorSetCount = 1; ai.pSetLayouts = &m_pipe->m_set_layout;
+ VkDescriptorSet set = VK_NULL_HANDLE;
+ if (vkAllocateDescriptorSets(m_device, &ai, &set) != VK_SUCCESS)
+ { DONUT_ERROR("Vulkan RHI: descriptor set allocation failed"); return; }
+
+ std::array<VkWriteDescriptorSet, MAX_BINDINGS> writes{};
+ uint32_t n = 0;
+ for (const auto& r : m_pipe->m_resources)
+ {
+ VkWriteDescriptorSet& w = writes[n++];
+ w.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+ w.dstSet = set; w.dstBinding = r.binding; w.descriptorCount = 1;
+ if (r.kind == ResourceKind::UniformBuffer)
+ { w.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; w.pBufferInfo = &m_buf_info[r.binding]; }
+ else
+ { w.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; w.pImageInfo = &m_img_info[r.binding]; }
+ }
+ vkUpdateDescriptorSets(m_device, n, writes.data(), 0, nullptr);
+ vkCmdBindDescriptorSets(m_cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, m_pipe->m_layout, 0, 1, &set, 0, nullptr);
+ }
+
+ // Set by the device at begin_frame:
+ VkDevice m_device = VK_NULL_HANDLE;
+ VkCommandBuffer m_cmd = VK_NULL_HANDLE;
+ VkRenderPass m_swapchain_rp = VK_NULL_HANDLE;
+ VkRenderPass m_offscreen_rp = VK_NULL_HANDLE;
+ VkFramebuffer m_swapchain_fb = VK_NULL_HANDLE;
+ VkExtent2D m_extent{};
+ VkDescriptorPool m_frame_pool = VK_NULL_HANDLE;
+
+ VkPipelineR* m_pipe = nullptr;
+ VkDescriptorBufferInfo m_buf_info[MAX_BINDINGS]{};
+ VkDescriptorImageInfo m_img_info[MAX_BINDINGS]{};
+ };
+
+ // ---- Device ---------------------------------------------------------
+ class VulkanDevice : public Device
+ {
+ public:
+ auto init(void* glfwWindow, int width, int height) -> bool override;
+ auto shutdown() -> void override;
+ auto resize(int width, int height) -> void override { m_framebuffer_resized = true; m_width = width; m_height = height; }
+ auto wait_idle() -> void override { if (m_device) vkDeviceWaitIdle(m_device); }
+
+ auto create_buffer(BufferType type, size_t size, const void* data) -> Ref<Buffer> override;
+ auto create_texture(int w, int h, Format format, Filter filter, const void* data) -> Ref<Texture> override;
+ auto create_cubemap_from_hdri(const std::string& path) -> Ref<Texture> override;
+ auto create_render_target(int w, int h, Format color, bool with_depth, Filter filter, int mips) -> Ref<RenderTarget> override;
+ auto create_pipeline(const PipelineDesc& desc) -> Ref<Pipeline> override;
+
+ auto begin_frame(const glm::vec4& clear) -> CommandList* override;
+ auto end_frame() -> void override;
+
+ auto init_imgui() -> void override;
+ auto imgui_new_frame() -> void override;
+ auto imgui_render(CommandList& cmds) -> void override;
+
+ auto device_name() const -> const std::string& override { return m_gpu_name; }
+
+ // --- internals ---
+ auto find_memory_type(uint32_t filter, VkMemoryPropertyFlags flags) const -> uint32_t;
+ auto create_buffer_raw(VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags props, VkBuffer& buf, VkDeviceMemory& mem) const -> bool;
+ auto load_spirv(const std::string& path) const -> std::vector<uint32_t>;
+ auto create_shader_module(const std::string& path, VkShaderModule& out) const -> bool;
+
+ auto create_instance() -> bool;
+ auto pick_physical_and_device() -> bool;
+ auto create_swapchain() -> bool;
+ auto create_image_views() -> bool;
+ auto create_swapchain_render_pass() -> bool;
+ auto create_offscreen_render_pass() -> bool;
+ auto create_depth_and_framebuffers() -> bool;
+ auto create_command_and_sync() -> bool;
+ auto recreate_swapchain() -> bool;
+ auto cleanup_swapchain() -> void;
+
+ GLFWwindow* m_window = nullptr;
+ int m_width = 0, m_height = 0;
+ bool m_framebuffer_resized = false;
+ std::string m_gpu_name;
+
+ VkInstance m_instance = VK_NULL_HANDLE;
+ VkSurfaceKHR m_surface = VK_NULL_HANDLE;
+ VkPhysicalDevice m_physical = VK_NULL_HANDLE;
+ VkDevice m_device = VK_NULL_HANDLE;
+ uint32_t m_graphics_family = 0, m_present_family = 0;
+ VkQueue m_graphics_queue = VK_NULL_HANDLE, m_present_queue = VK_NULL_HANDLE;
+ VkPhysicalDeviceMemoryProperties m_mem_props{};
+
+ VkSwapchainKHR m_swapchain = VK_NULL_HANDLE;
+ VkFormat m_swapchain_format = VK_FORMAT_B8G8R8A8_UNORM;
+ VkExtent2D m_extent{};
+ std::vector<VkImage> m_images;
+ std::vector<VkImageView> m_image_views;
+ VkRenderPass m_swapchain_rp = VK_NULL_HANDLE;
+ VkRenderPass m_offscreen_rp = VK_NULL_HANDLE;
+ std::vector<VkFramebuffer> m_framebuffers;
+ VkImage m_depth_image = VK_NULL_HANDLE; VkDeviceMemory m_depth_mem = VK_NULL_HANDLE; VkImageView m_depth_view = VK_NULL_HANDLE;
+
+ VkCommandPool m_command_pool = VK_NULL_HANDLE;
+ std::vector<VkCommandBuffer> m_command_buffers;
+ std::vector<VkSemaphore> m_image_available;
+ std::vector<VkSemaphore> m_render_finished;
+ std::vector<VkFence> m_in_flight;
+ std::vector<VkFence> m_images_in_flight;
+ VkFence m_geo_in_use = VK_NULL_HANDLE;
+ uint32_t m_current_frame = 0, m_image_index = 0;
+
+ std::vector<VkDescriptorPool> m_frame_pools; // one per frame in flight
+ VkDescriptorPool m_imgui_pool = VK_NULL_HANDLE;
+ bool m_imgui = false;
+
+ VkCommandListR m_cmds;
+ };
+
+ // ==================================================================
+ auto VulkanDevice::find_memory_type(uint32_t filter, VkMemoryPropertyFlags flags) const -> uint32_t
+ {
+ for (uint32_t i = 0; i < m_mem_props.memoryTypeCount; ++i)
+ if ((filter & (1u << i)) && (m_mem_props.memoryTypes[i].propertyFlags & flags) == flags)
+ return i;
+ return UINT32_MAX;
+ }
+
+ auto VulkanDevice::create_buffer_raw(VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags props,
+ VkBuffer& buf, VkDeviceMemory& mem) const -> bool
+ {
+ VkBufferCreateInfo bci{ VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
+ bci.size = size; bci.usage = usage; bci.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
+ if (vkCreateBuffer(m_device, &bci, nullptr, &buf) != VK_SUCCESS) return false;
+ VkMemoryRequirements req{}; vkGetBufferMemoryRequirements(m_device, buf, &req);
+ VkMemoryAllocateInfo ai{ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
+ ai.allocationSize = req.size; ai.memoryTypeIndex = find_memory_type(req.memoryTypeBits, props);
+ if (vkAllocateMemory(m_device, &ai, nullptr, &mem) != VK_SUCCESS) return false;
+ vkBindBufferMemory(m_device, buf, mem, 0);
+ return true;
+ }
+
+ auto VulkanDevice::load_spirv(const std::string& path) const -> std::vector<uint32_t>
+ {
+ std::ifstream file(path, std::ios::ate | std::ios::binary);
+ if (!file.is_open()) return {};
+ size_t size = (size_t)file.tellg();
+ std::vector<uint32_t> data(size / 4);
+ file.seekg(0); file.read(reinterpret_cast<char*>(data.data()), size);
+ return data;
+ }
+
+ auto VulkanDevice::create_shader_module(const std::string& path, VkShaderModule& out) const -> bool
+ {
+ auto spv = load_spirv(path);
+ if (spv.empty()) { DONUT_ERROR("Vulkan RHI: failed to load SPIR-V {}", path); return false; }
+ VkShaderModuleCreateInfo ci{ VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO };
+ ci.codeSize = spv.size() * 4; ci.pCode = spv.data();
+ return vkCreateShaderModule(m_device, &ci, nullptr, &out) == VK_SUCCESS;
+ }
+
+ auto VulkanDevice::create_instance() -> bool
+ {
+ VkApplicationInfo app{ VK_STRUCTURE_TYPE_APPLICATION_INFO };
+ app.pApplicationName = "Donut"; app.apiVersion = VK_API_VERSION_1_2;
+
+ uint32_t glfwExtCount = 0;
+ const char** glfwExts = glfwGetRequiredInstanceExtensions(&glfwExtCount);
+ if (!glfwExts) { DONUT_ERROR("Vulkan RHI: GLFW reports no surface support"); return false; }
+ std::vector<const char*> exts(glfwExts, glfwExts + glfwExtCount);
+ exts.push_back(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME);
+ exts.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
+
+ std::vector<const char*> layers;
+ uint32_t layer_count = 0; vkEnumerateInstanceLayerProperties(&layer_count, nullptr);
+ std::vector<VkLayerProperties> avail(layer_count);
+ vkEnumerateInstanceLayerProperties(&layer_count, avail.data());
+ for (const auto& l : avail)
+ if (std::strcmp(l.layerName, "VK_LAYER_KHRONOS_validation") == 0)
+ layers.push_back("VK_LAYER_KHRONOS_validation");
+
+ VkInstanceCreateInfo ici{ VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO };
+ ici.flags = VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR;
+ ici.pApplicationInfo = &app;
+ ici.enabledExtensionCount = (uint32_t)exts.size(); ici.ppEnabledExtensionNames = exts.data();
+ ici.enabledLayerCount = (uint32_t)layers.size(); ici.ppEnabledLayerNames = layers.data();
+ VkResult r = vkCreateInstance(&ici, nullptr, &m_instance);
+ if (r != VK_SUCCESS && !layers.empty())
+ {
+ DONUT_WARN("Vulkan RHI: validation layer unavailable, continuing without it");
+ ici.enabledLayerCount = 0; ici.ppEnabledLayerNames = nullptr;
+ r = vkCreateInstance(&ici, nullptr, &m_instance);
+ }
+ if (r != VK_SUCCESS) { DONUT_ERROR("Vulkan RHI: vkCreateInstance failed ({})", (int)r); return false; }
+ VKD_CHECK(glfwCreateWindowSurface(m_instance, m_window, nullptr, &m_surface));
+ DONUT_INFO("Vulkan RHI: instance + surface created (validation {})", layers.empty() ? "off" : "on");
+ return true;
+ }
+
+ auto VulkanDevice::pick_physical_and_device() -> bool
+ {
+ uint32_t count = 0; vkEnumeratePhysicalDevices(m_instance, &count, nullptr);
+ if (count == 0) { DONUT_ERROR("Vulkan RHI: no physical devices"); return false; }
+ std::vector<VkPhysicalDevice> devices(count);
+ vkEnumeratePhysicalDevices(m_instance, &count, devices.data());
+ m_physical = devices[0];
+
+ uint32_t q = 0; vkGetPhysicalDeviceQueueFamilyProperties(m_physical, &q, nullptr);
+ std::vector<VkQueueFamilyProperties> qfams(q);
+ vkGetPhysicalDeviceQueueFamilyProperties(m_physical, &q, qfams.data());
+ bool fg = false, fp = false;
+ for (uint32_t i = 0; i < q; ++i)
+ {
+ if (!fg && (qfams[i].queueFlags & VK_QUEUE_GRAPHICS_BIT)) { m_graphics_family = i; fg = true; }
+ VkBool32 present = VK_FALSE; vkGetPhysicalDeviceSurfaceSupportKHR(m_physical, i, m_surface, &present);
+ if (!fp && present) { m_present_family = i; fp = true; }
+ }
+ if (!fg || !fp) { DONUT_ERROR("Vulkan RHI: no graphics/present queue"); return false; }
+
+ std::vector<const char*> dev_exts = { VK_KHR_SWAPCHAIN_EXTENSION_NAME };
+ uint32_t dec = 0; vkEnumerateDeviceExtensionProperties(m_physical, nullptr, &dec, nullptr);
+ std::vector<VkExtensionProperties> dep(dec);
+ vkEnumerateDeviceExtensionProperties(m_physical, nullptr, &dec, dep.data());
+ for (const auto& e : dep)
+ if (std::strcmp(e.extensionName, "VK_KHR_portability_subset") == 0)
+ dev_exts.push_back("VK_KHR_portability_subset");
+
+ float priority = 1.0f;
+ std::vector<VkDeviceQueueCreateInfo> qcis;
+ uint32_t families[2] = { m_graphics_family, m_present_family };
+ for (uint32_t i = 0; i < (m_graphics_family == m_present_family ? 1u : 2u); ++i)
+ {
+ VkDeviceQueueCreateInfo qci{ VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO };
+ qci.queueFamilyIndex = families[i]; qci.queueCount = 1; qci.pQueuePriorities = &priority;
+ qcis.push_back(qci);
+ }
+ VkDeviceCreateInfo dci{ VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO };
+ dci.queueCreateInfoCount = (uint32_t)qcis.size(); dci.pQueueCreateInfos = qcis.data();
+ dci.enabledExtensionCount = (uint32_t)dev_exts.size(); dci.ppEnabledExtensionNames = dev_exts.data();
+ VKD_CHECK(vkCreateDevice(m_physical, &dci, nullptr, &m_device));
+ vkGetDeviceQueue(m_device, m_graphics_family, 0, &m_graphics_queue);
+ vkGetDeviceQueue(m_device, m_present_family, 0, &m_present_queue);
+
+ VkPhysicalDeviceProperties props{}; vkGetPhysicalDeviceProperties(m_physical, &props);
+ vkGetPhysicalDeviceMemoryProperties(m_physical, &m_mem_props);
+ m_gpu_name = props.deviceName;
+ DONUT_INFO("Vulkan RHI device: {}", m_gpu_name);
+ return true;
+ }
+
+ auto VulkanDevice::create_swapchain() -> bool
+ {
+ VkSurfaceCapabilitiesKHR caps{};
+ vkGetPhysicalDeviceSurfaceCapabilitiesKHR(m_physical, m_surface, &caps);
+ uint32_t fc = 0; vkGetPhysicalDeviceSurfaceFormatsKHR(m_physical, m_surface, &fc, nullptr);
+ std::vector<VkSurfaceFormatKHR> formats(fc);
+ vkGetPhysicalDeviceSurfaceFormatsKHR(m_physical, m_surface, &fc, formats.data());
+ VkSurfaceFormatKHR chosen = formats[0];
+ for (const auto& f : formats)
+ if (f.format == VK_FORMAT_B8G8R8A8_UNORM && f.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) chosen = f;
+ m_swapchain_format = chosen.format;
+
+ if (caps.currentExtent.width != UINT32_MAX) m_extent = caps.currentExtent;
+ else {
+ m_extent.width = std::clamp((uint32_t)m_width, caps.minImageExtent.width, caps.maxImageExtent.width);
+ m_extent.height = std::clamp((uint32_t)m_height, caps.minImageExtent.height, caps.maxImageExtent.height);
+ }
+ uint32_t image_count = caps.minImageCount + 1;
+ if (caps.maxImageCount > 0 && image_count > caps.maxImageCount) image_count = caps.maxImageCount;
+
+ VkSwapchainCreateInfoKHR sci{ VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR };
+ sci.surface = m_surface; sci.minImageCount = image_count;
+ sci.imageFormat = chosen.format; sci.imageColorSpace = chosen.colorSpace;
+ sci.imageExtent = m_extent; sci.imageArrayLayers = 1;
+ sci.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+ sci.preTransform = caps.currentTransform; sci.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
+ sci.presentMode = VK_PRESENT_MODE_FIFO_KHR; sci.clipped = VK_TRUE;
+ uint32_t fam[2] = { m_graphics_family, m_present_family };
+ if (m_graphics_family != m_present_family)
+ { sci.imageSharingMode = VK_SHARING_MODE_CONCURRENT; sci.queueFamilyIndexCount = 2; sci.pQueueFamilyIndices = fam; }
+ else sci.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
+ VKD_CHECK(vkCreateSwapchainKHR(m_device, &sci, nullptr, &m_swapchain));
+ uint32_t n = 0; vkGetSwapchainImagesKHR(m_device, m_swapchain, &n, nullptr);
+ m_images.resize(n); vkGetSwapchainImagesKHR(m_device, m_swapchain, &n, m_images.data());
+ return true;
+ }
+
+ auto VulkanDevice::create_image_views() -> bool
+ {
+ m_image_views.resize(m_images.size());
+ for (size_t i = 0; i < m_images.size(); ++i)
+ {
+ VkImageViewCreateInfo vci{ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO };
+ vci.image = m_images[i]; vci.viewType = VK_IMAGE_VIEW_TYPE_2D; vci.format = m_swapchain_format;
+ vci.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
+ VKD_CHECK(vkCreateImageView(m_device, &vci, nullptr, &m_image_views[i]));
+ }
+ return true;
+ }
+
+ // Swapchain pass: colour + depth. Scene geometry uses the depth; the
+ // black-hole present + ImGui simply don't test it.
+ auto VulkanDevice::create_swapchain_render_pass() -> bool
+ {
+ VkAttachmentDescription atts[2]{};
+ atts[0].format = m_swapchain_format; atts[0].samples = VK_SAMPLE_COUNT_1_BIT;
+ atts[0].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; atts[0].storeOp = VK_ATTACHMENT_STORE_OP_STORE;
+ atts[0].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; atts[0].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
+ atts[0].initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; atts[0].finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
+ atts[1].format = VK_FORMAT_D32_SFLOAT; atts[1].samples = VK_SAMPLE_COUNT_1_BIT;
+ atts[1].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; atts[1].storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
+ atts[1].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; atts[1].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
+ atts[1].initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; atts[1].finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
+ VkAttachmentReference color_ref{ 0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL };
+ VkAttachmentReference depth_ref{ 1, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL };
+ VkSubpassDescription subpass{}; subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
+ subpass.colorAttachmentCount = 1; subpass.pColorAttachments = &color_ref; subpass.pDepthStencilAttachment = &depth_ref;
+ VkSubpassDependency dep{};
+ dep.srcSubpass = VK_SUBPASS_EXTERNAL; dep.dstSubpass = 0;
+ dep.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
+ dep.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
+ dep.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
+ VkRenderPassCreateInfo rpci{ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO };
+ rpci.attachmentCount = 2; rpci.pAttachments = atts; rpci.subpassCount = 1; rpci.pSubpasses = &subpass;
+ rpci.dependencyCount = 1; rpci.pDependencies = &dep;
+ VKD_CHECK(vkCreateRenderPass(m_device, &rpci, nullptr, &m_swapchain_rp));
+ return true;
+ }
+
+ // Off-screen colour pass (RGBA8), leaving the image SHADER_READ_ONLY so the
+ // present pass can sample it. Shared by every render target.
+ auto VulkanDevice::create_offscreen_render_pass() -> bool
+ {
+ VkAttachmentDescription color{};
+ color.format = VK_FORMAT_R8G8B8A8_UNORM; color.samples = VK_SAMPLE_COUNT_1_BIT;
+ color.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; color.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
+ color.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; color.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
+ color.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; color.finalLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+ VkAttachmentReference ref{ 0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL };
+ VkSubpassDescription subpass{}; subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
+ subpass.colorAttachmentCount = 1; subpass.pColorAttachments = &ref;
+ VkSubpassDependency deps[2]{};
+ deps[0].srcSubpass = VK_SUBPASS_EXTERNAL; deps[0].dstSubpass = 0;
+ deps[0].srcStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT; deps[0].srcAccessMask = VK_ACCESS_SHADER_READ_BIT;
+ deps[0].dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; deps[0].dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+ deps[1].srcSubpass = 0; deps[1].dstSubpass = VK_SUBPASS_EXTERNAL;
+ deps[1].srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; deps[1].srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+ deps[1].dstStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT; deps[1].dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
+ VkRenderPassCreateInfo rpci{ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO };
+ rpci.attachmentCount = 1; rpci.pAttachments = &color; rpci.subpassCount = 1; rpci.pSubpasses = &subpass;
+ rpci.dependencyCount = 2; rpci.pDependencies = deps;
+ VKD_CHECK(vkCreateRenderPass(m_device, &rpci, nullptr, &m_offscreen_rp));
+ return true;
+ }
+
+ auto VulkanDevice::create_depth_and_framebuffers() -> bool
+ {
+ VkImageCreateInfo dici{ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
+ dici.imageType = VK_IMAGE_TYPE_2D; dici.format = VK_FORMAT_D32_SFLOAT;
+ dici.extent = { m_extent.width, m_extent.height, 1 };
+ dici.mipLevels = 1; dici.arrayLayers = 1; dici.samples = VK_SAMPLE_COUNT_1_BIT;
+ dici.tiling = VK_IMAGE_TILING_OPTIMAL; dici.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
+ VKD_CHECK(vkCreateImage(m_device, &dici, nullptr, &m_depth_image));
+ VkMemoryRequirements dreq{}; vkGetImageMemoryRequirements(m_device, m_depth_image, &dreq);
+ VkMemoryAllocateInfo dai{ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
+ dai.allocationSize = dreq.size; dai.memoryTypeIndex = find_memory_type(dreq.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
+ VKD_CHECK(vkAllocateMemory(m_device, &dai, nullptr, &m_depth_mem));
+ VKD_CHECK(vkBindImageMemory(m_device, m_depth_image, m_depth_mem, 0));
+ VkImageViewCreateInfo dvci{ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO };
+ dvci.image = m_depth_image; dvci.viewType = VK_IMAGE_VIEW_TYPE_2D; dvci.format = VK_FORMAT_D32_SFLOAT;
+ dvci.subresourceRange = { VK_IMAGE_ASPECT_DEPTH_BIT, 0, 1, 0, 1 };
+ VKD_CHECK(vkCreateImageView(m_device, &dvci, nullptr, &m_depth_view));
+
+ m_framebuffers.resize(m_image_views.size());
+ for (size_t i = 0; i < m_image_views.size(); ++i)
+ {
+ VkImageView att[2] = { m_image_views[i], m_depth_view };
+ VkFramebufferCreateInfo fbci{ VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO };
+ fbci.renderPass = m_swapchain_rp; fbci.attachmentCount = 2; fbci.pAttachments = att;
+ fbci.width = m_extent.width; fbci.height = m_extent.height; fbci.layers = 1;
+ VKD_CHECK(vkCreateFramebuffer(m_device, &fbci, nullptr, &m_framebuffers[i]));
+ }
+ return true;
+ }
+
+ auto VulkanDevice::create_command_and_sync() -> bool
+ {
+ VkCommandPoolCreateInfo pci{ VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO };
+ pci.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT; pci.queueFamilyIndex = m_graphics_family;
+ VKD_CHECK(vkCreateCommandPool(m_device, &pci, nullptr, &m_command_pool));
+ m_command_buffers.resize(MAX_FRAMES_IN_FLIGHT);
+ VkCommandBufferAllocateInfo cbai{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO };
+ cbai.commandPool = m_command_pool; cbai.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; cbai.commandBufferCount = MAX_FRAMES_IN_FLIGHT;
+ VKD_CHECK(vkAllocateCommandBuffers(m_device, &cbai, m_command_buffers.data()));
+
+ m_image_available.resize(MAX_FRAMES_IN_FLIGHT);
+ m_in_flight.resize(MAX_FRAMES_IN_FLIGHT);
+ m_render_finished.resize(m_images.size());
+ m_images_in_flight.assign(m_images.size(), VK_NULL_HANDLE);
+ VkSemaphoreCreateInfo sci{ VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO };
+ VkFenceCreateInfo fci{ VK_STRUCTURE_TYPE_FENCE_CREATE_INFO }; fci.flags = VK_FENCE_CREATE_SIGNALED_BIT;
+ for (int i = 0; i < MAX_FRAMES_IN_FLIGHT; ++i)
+ { VKD_CHECK(vkCreateSemaphore(m_device, &sci, nullptr, &m_image_available[i])); VKD_CHECK(vkCreateFence(m_device, &fci, nullptr, &m_in_flight[i])); }
+ for (size_t i = 0; i < m_images.size(); ++i)
+ VKD_CHECK(vkCreateSemaphore(m_device, &sci, nullptr, &m_render_finished[i]));
+
+ m_frame_pools.resize(MAX_FRAMES_IN_FLIGHT);
+ VkDescriptorPoolSize sizes[2] = {
+ { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 512 },
+ { VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 256 },
+ };
+ for (int i = 0; i < MAX_FRAMES_IN_FLIGHT; ++i)
+ {
+ VkDescriptorPoolCreateInfo dpci{ VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO };
+ dpci.maxSets = 256; dpci.poolSizeCount = 2; dpci.pPoolSizes = sizes;
+ VKD_CHECK(vkCreateDescriptorPool(m_device, &dpci, nullptr, &m_frame_pools[i]));
+ }
+ return true;
+ }
+
+ auto VulkanDevice::init(void* glfwWindow, int width, int height) -> bool
+ {
+ m_window = (GLFWwindow*)glfwWindow; m_width = width; m_height = height;
+ if (!create_instance()) return false;
+ if (!pick_physical_and_device()) return false;
+ if (!create_swapchain()) return false;
+ if (!create_image_views()) return false;
+ if (!create_swapchain_render_pass()) return false;
+ if (!create_offscreen_render_pass()) return false;
+ if (!create_depth_and_framebuffers())return false;
+ if (!create_command_and_sync()) return false;
+ DONUT_INFO("Vulkan RHI device ready: {} swapchain images, {}x{}", (int)m_images.size(), m_extent.width, m_extent.height);
+ return true;
+ }
+
+ auto VulkanDevice::cleanup_swapchain() -> void
+ {
+ for (auto fb : m_framebuffers) vkDestroyFramebuffer(m_device, fb, nullptr);
+ m_framebuffers.clear();
+ if (m_depth_view) { vkDestroyImageView(m_device, m_depth_view, nullptr); m_depth_view = VK_NULL_HANDLE; }
+ if (m_depth_image) { vkDestroyImage(m_device, m_depth_image, nullptr); m_depth_image = VK_NULL_HANDLE; }
+ if (m_depth_mem) { vkFreeMemory(m_device, m_depth_mem, nullptr); m_depth_mem = VK_NULL_HANDLE; }
+ for (auto iv : m_image_views) vkDestroyImageView(m_device, iv, nullptr);
+ m_image_views.clear();
+ if (m_swapchain) { vkDestroySwapchainKHR(m_device, m_swapchain, nullptr); m_swapchain = VK_NULL_HANDLE; }
+ }
+
+ auto VulkanDevice::recreate_swapchain() -> bool
+ {
+ int w = 0, h = 0; glfwGetFramebufferSize(m_window, &w, &h);
+ while (w == 0 || h == 0) { glfwGetFramebufferSize(m_window, &w, &h); glfwWaitEvents(); }
+ m_width = w; m_height = h;
+ vkDeviceWaitIdle(m_device);
+ cleanup_swapchain();
+ if (!create_swapchain()) return false;
+ if (!create_image_views()) return false;
+ if (!create_depth_and_framebuffers())return false;
+ m_images_in_flight.assign(m_images.size(), VK_NULL_HANDLE);
+ return true;
+ }
+
+ auto VulkanDevice::create_buffer(BufferType type, size_t size, const void* data) -> Ref<Buffer>
+ {
+ VkBufferUsageFlags usage = type == BufferType::Index ? VK_BUFFER_USAGE_INDEX_BUFFER_BIT
+ : type == BufferType::Uniform ? VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT
+ : VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
+ VkBuffer buf = VK_NULL_HANDLE; VkDeviceMemory mem = VK_NULL_HANDLE;
+ create_buffer_raw(size, usage, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, buf, mem);
+ void* mapped = nullptr; vkMapMemory(m_device, mem, 0, size, 0, &mapped);
+ if (data && mapped) std::memcpy(mapped, data, size);
+ return create_ref<VkBufferR>(m_device, buf, mem, mapped, size);
+ }
+
+ auto VulkanDevice::create_texture(int w, int h, Format format, Filter filter, const void* data) -> Ref<Texture>
+ {
+ auto tex = create_ref<VkTextureR>(); tex->m_device = m_device;
+ VkFormat fmt = vk_format(format);
+ VkImageCreateInfo ici{ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
+ ici.imageType = VK_IMAGE_TYPE_2D; ici.format = fmt; ici.extent = { (uint32_t)w, (uint32_t)h, 1 };
+ ici.mipLevels = 1; ici.arrayLayers = 1; ici.samples = VK_SAMPLE_COUNT_1_BIT;
+ ici.tiling = VK_IMAGE_TILING_OPTIMAL; ici.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
+ vkCreateImage(m_device, &ici, nullptr, &tex->m_image);
+ VkMemoryRequirements req{}; vkGetImageMemoryRequirements(m_device, tex->m_image, &req);
+ VkMemoryAllocateInfo ai{ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
+ ai.allocationSize = req.size; ai.memoryTypeIndex = find_memory_type(req.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
+ vkAllocateMemory(m_device, &ai, nullptr, &tex->m_mem);
+ vkBindImageMemory(m_device, tex->m_image, tex->m_mem, 0);
+
+ size_t bpp = format == Format::RGBA16F ? 8 : 4;
+ VkDeviceSize sz = (VkDeviceSize)w * h * bpp;
+ VkBuffer staging = VK_NULL_HANDLE; VkDeviceMemory staging_mem = VK_NULL_HANDLE;
+ create_buffer_raw(sz, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, staging, staging_mem);
+ void* mp = nullptr; vkMapMemory(m_device, staging_mem, 0, sz, 0, &mp);
+ if (data) std::memcpy(mp, data, sz); else std::memset(mp, 0, sz);
+ vkUnmapMemory(m_device, staging_mem);
+
+ VkCommandBufferAllocateInfo cbai{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO };
+ cbai.commandPool = m_command_pool; cbai.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; cbai.commandBufferCount = 1;
+ VkCommandBuffer cmd; vkAllocateCommandBuffers(m_device, &cbai, &cmd);
+ VkCommandBufferBeginInfo bi{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO }; bi.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
+ vkBeginCommandBuffer(cmd, &bi);
+ VkImageMemoryBarrier b{ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER };
+ b.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED; b.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+ b.image = tex->m_image; b.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
+ b.srcAccessMask = 0; b.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
+ vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &b);
+ VkBufferImageCopy copy{}; copy.imageSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1 }; copy.imageExtent = { (uint32_t)w, (uint32_t)h, 1 };
+ vkCmdCopyBufferToImage(cmd, staging, tex->m_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &copy);
+ VkImageMemoryBarrier r = b; r.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; r.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+ r.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; r.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
+ vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, 0, nullptr, 0, nullptr, 1, &r);
+ vkEndCommandBuffer(cmd);
+ VkSubmitInfo si{ VK_STRUCTURE_TYPE_SUBMIT_INFO }; si.commandBufferCount = 1; si.pCommandBuffers = &cmd;
+ vkQueueSubmit(m_graphics_queue, 1, &si, VK_NULL_HANDLE); vkQueueWaitIdle(m_graphics_queue);
+ vkFreeCommandBuffers(m_device, m_command_pool, 1, &cmd);
+ vkDestroyBuffer(m_device, staging, nullptr); vkFreeMemory(m_device, staging_mem, nullptr);
+
+ VkImageViewCreateInfo vci{ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO };
+ vci.image = tex->m_image; vci.viewType = VK_IMAGE_VIEW_TYPE_2D; vci.format = fmt;
+ vci.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
+ vkCreateImageView(m_device, &vci, nullptr, &tex->m_view);
+ VkSamplerCreateInfo smci{ VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO };
+ smci.magFilter = vk_filter(filter); smci.minFilter = vk_filter(filter);
+ smci.addressModeU = smci.addressModeV = smci.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
+ vkCreateSampler(m_device, &smci, nullptr, &tex->m_sampler);
+ return tex;
+ }
+
+ auto VulkanDevice::create_render_target(int w, int h, Format color, bool /*with_depth*/, Filter filter, int /*mips*/) -> Ref<RenderTarget>
+ {
+ auto rt = create_ref<VkRenderTargetR>();
+ rt->m_device = m_device; rt->m_w = w; rt->m_h = h;
+ VkFormat fmt = vk_format(color);
+ VkImageCreateInfo ici{ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
+ ici.imageType = VK_IMAGE_TYPE_2D; ici.format = fmt; ici.extent = { (uint32_t)w, (uint32_t)h, 1 };
+ ici.mipLevels = 1; ici.arrayLayers = 1; ici.samples = VK_SAMPLE_COUNT_1_BIT;
+ ici.tiling = VK_IMAGE_TILING_OPTIMAL; ici.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
+ vkCreateImage(m_device, &ici, nullptr, &rt->m_image);
+ VkMemoryRequirements req{}; vkGetImageMemoryRequirements(m_device, rt->m_image, &req);
+ VkMemoryAllocateInfo ai{ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
+ ai.allocationSize = req.size; ai.memoryTypeIndex = find_memory_type(req.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
+ vkAllocateMemory(m_device, &ai, nullptr, &rt->m_mem);
+ vkBindImageMemory(m_device, rt->m_image, rt->m_mem, 0);
+ VkImageViewCreateInfo vci{ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO };
+ vci.image = rt->m_image; vci.viewType = VK_IMAGE_VIEW_TYPE_2D; vci.format = fmt;
+ vci.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
+ vkCreateImageView(m_device, &vci, nullptr, &rt->m_view);
+ VkSamplerCreateInfo smci{ VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO };
+ smci.magFilter = vk_filter(filter); smci.minFilter = vk_filter(filter);
+ smci.addressModeU = smci.addressModeV = smci.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
+ vkCreateSampler(m_device, &smci, nullptr, &rt->m_sampler);
+ VkFramebufferCreateInfo fbci{ VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO };
+ fbci.renderPass = m_offscreen_rp; fbci.attachmentCount = 1; fbci.pAttachments = &rt->m_view;
+ fbci.width = w; fbci.height = h; fbci.layers = 1;
+ vkCreateFramebuffer(m_device, &fbci, nullptr, &rt->m_fb);
+
+ rt->m_color.m_device = m_device; rt->m_color.m_view = rt->m_view; rt->m_color.m_sampler = rt->m_sampler; rt->m_color.m_owns = false;
+ return rt;
+ }
+
+ // Builds an environment cubemap from an equirectangular HDRI: render the 6
+ // faces with the EquirectToCubemap pipeline, then a full mip chain by
+ // linear down-blits (so divergence-based LOD reads a blurred sky). Returns
+ // a Texture owning the cube image/view/sampler.
+ auto VulkanDevice::create_cubemap_from_hdri(const std::string& path) -> Ref<Texture>
+ {
+ auto tex = create_ref<VkTextureR>(); tex->m_device = m_device;
+ const VkMemoryPropertyFlags host_vis = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
+ const uint32_t FACE = 1024;
+ const VkFormat cube_fmt = VK_FORMAT_R16G16B16A16_SFLOAT;
+ uint32_t CUBE_MIPS = 1; for (uint32_t s = FACE; s > 1; s >>= 1) ++CUBE_MIPS;
+
+ VkImageCreateInfo cci{ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
+ cci.flags = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
+ cci.imageType = VK_IMAGE_TYPE_2D; cci.format = cube_fmt; cci.extent = { FACE, FACE, 1 };
+ cci.mipLevels = CUBE_MIPS; cci.arrayLayers = 6; cci.samples = VK_SAMPLE_COUNT_1_BIT;
+ cci.tiling = VK_IMAGE_TILING_OPTIMAL;
+ cci.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT
+ | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
+ vkCreateImage(m_device, &cci, nullptr, &tex->m_image);
+ VkMemoryRequirements creq{}; vkGetImageMemoryRequirements(m_device, tex->m_image, &creq);
+ VkMemoryAllocateInfo cai{ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
+ cai.allocationSize = creq.size; cai.memoryTypeIndex = find_memory_type(creq.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
+ vkAllocateMemory(m_device, &cai, nullptr, &tex->m_mem);
+ vkBindImageMemory(m_device, tex->m_image, tex->m_mem, 0);
+ VkImageViewCreateInfo cvci{ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO };
+ cvci.image = tex->m_image; cvci.viewType = VK_IMAGE_VIEW_TYPE_CUBE; cvci.format = cube_fmt;
+ cvci.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, CUBE_MIPS, 0, 6 };
+ vkCreateImageView(m_device, &cvci, nullptr, &tex->m_view);
+ VkSamplerCreateInfo csm{ VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO };
+ csm.magFilter = VK_FILTER_LINEAR; csm.minFilter = VK_FILTER_LINEAR;
+ csm.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR; csm.minLod = 0.0f; csm.maxLod = (float)CUBE_MIPS;
+ csm.addressModeU = csm.addressModeV = csm.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
+ vkCreateSampler(m_device, &csm, nullptr, &tex->m_sampler);
+
+ int w = 0, h = 0, ch = 0;
+ float* pixels = stbi_loadf(path.c_str(), &w, &h, &ch, 4);
+ if (!pixels)
+ {
+ DONUT_WARN("Vulkan RHI: HDRI '{}' could not be loaded; using a dark background", path);
+ VkCommandBufferAllocateInfo cbai{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO };
+ cbai.commandPool = m_command_pool; cbai.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; cbai.commandBufferCount = 1;
+ VkCommandBuffer cmd; vkAllocateCommandBuffers(m_device, &cbai, &cmd);
+ VkCommandBufferBeginInfo bi{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO }; bi.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
+ vkBeginCommandBuffer(cmd, &bi);
+ VkImageMemoryBarrier tb{ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER };
+ tb.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED; tb.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+ tb.image = tex->m_image; tb.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, CUBE_MIPS, 0, 6 };
+ tb.srcAccessMask = 0; tb.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
+ vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &tb);
+ VkClearColorValue dark{}; dark.float32[0] = 0.02f; dark.float32[1] = 0.02f; dark.float32[2] = 0.05f; dark.float32[3] = 1.0f;
+ VkImageSubresourceRange rng{ VK_IMAGE_ASPECT_COLOR_BIT, 0, CUBE_MIPS, 0, 6 };
+ vkCmdClearColorImage(cmd, tex->m_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &dark, 1, &rng);
+ VkImageMemoryBarrier rb = tb; rb.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; rb.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+ rb.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; rb.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
+ vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, 0, nullptr, 0, nullptr, 1, &rb);
+ vkEndCommandBuffer(cmd);
+ VkSubmitInfo si{ VK_STRUCTURE_TYPE_SUBMIT_INFO }; si.commandBufferCount = 1; si.pCommandBuffers = &cmd;
+ vkQueueSubmit(m_graphics_queue, 1, &si, VK_NULL_HANDLE); vkQueueWaitIdle(m_graphics_queue);
+ vkFreeCommandBuffers(m_device, m_command_pool, 1, &cmd);
+ return tex;
+ }
+
+ const VkFormat eq_fmt = VK_FORMAT_R16G16B16A16_SFLOAT;
+ size_t texel_count = (size_t)w * h * 4;
+ VkDeviceSize eq_size = (VkDeviceSize)texel_count * sizeof(uint16_t);
+ VkBuffer eq_staging; VkDeviceMemory eq_staging_mem;
+ create_buffer_raw(eq_size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, host_vis, eq_staging, eq_staging_mem);
+ void* mp = nullptr; vkMapMemory(m_device, eq_staging_mem, 0, eq_size, 0, &mp);
+ uint16_t* dst = (uint16_t*)mp;
+ for (size_t i = 0; i < texel_count; ++i) { __fp16 hf = (__fp16)pixels[i]; std::memcpy(&dst[i], &hf, sizeof(uint16_t)); }
+ vkUnmapMemory(m_device, eq_staging_mem);
+ stbi_image_free(pixels);
+
+ VkImage eq_image; VkDeviceMemory eq_mem;
+ VkImageCreateInfo eci{ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
+ eci.imageType = VK_IMAGE_TYPE_2D; eci.format = eq_fmt; eci.extent = { (uint32_t)w, (uint32_t)h, 1 };
+ eci.mipLevels = 1; eci.arrayLayers = 1; eci.samples = VK_SAMPLE_COUNT_1_BIT;
+ eci.tiling = VK_IMAGE_TILING_OPTIMAL; eci.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
+ vkCreateImage(m_device, &eci, nullptr, &eq_image);
+ VkMemoryRequirements ereq{}; vkGetImageMemoryRequirements(m_device, eq_image, &ereq);
+ VkMemoryAllocateInfo eai{ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
+ eai.allocationSize = ereq.size; eai.memoryTypeIndex = find_memory_type(ereq.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
+ vkAllocateMemory(m_device, &eai, nullptr, &eq_mem);
+ vkBindImageMemory(m_device, eq_image, eq_mem, 0);
+ VkImageView eq_view;
+ VkImageViewCreateInfo evci{ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO };
+ evci.image = eq_image; evci.viewType = VK_IMAGE_VIEW_TYPE_2D; evci.format = eq_fmt;
+ evci.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
+ vkCreateImageView(m_device, &evci, nullptr, &eq_view);
+ VkSampler eq_sampler;
+ VkSamplerCreateInfo esm{ VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO };
+ esm.magFilter = VK_FILTER_LINEAR; esm.minFilter = VK_FILTER_LINEAR;
+ esm.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT;
+ esm.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
+ esm.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
+ vkCreateSampler(m_device, &esm, nullptr, &eq_sampler);
+
+ VkImageView face_views[6];
+ for (uint32_t i = 0; i < 6; ++i)
+ {
+ VkImageViewCreateInfo fvci{ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO };
+ fvci.image = tex->m_image; fvci.viewType = VK_IMAGE_VIEW_TYPE_2D; fvci.format = cube_fmt;
+ fvci.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, i, 1 };
+ vkCreateImageView(m_device, &fvci, nullptr, &face_views[i]);
+ }
+
+ VkAttachmentDescription color{};
+ color.format = cube_fmt; color.samples = VK_SAMPLE_COUNT_1_BIT;
+ color.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; color.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
+ color.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; color.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
+ color.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; color.finalLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+ VkAttachmentReference ref{ 0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL };
+ VkSubpassDescription subpass{}; subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS; subpass.colorAttachmentCount = 1; subpass.pColorAttachments = &ref;
+ VkSubpassDependency dep{}; dep.srcSubpass = 0; dep.dstSubpass = VK_SUBPASS_EXTERNAL;
+ dep.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; dep.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+ dep.dstStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT; dep.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
+ VkRenderPass rp;
+ VkRenderPassCreateInfo rpci{ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO };
+ rpci.attachmentCount = 1; rpci.pAttachments = &color; rpci.subpassCount = 1; rpci.pSubpasses = &subpass; rpci.dependencyCount = 1; rpci.pDependencies = &dep;
+ vkCreateRenderPass(m_device, &rpci, nullptr, &rp);
+ VkFramebuffer face_fb[6];
+ for (uint32_t i = 0; i < 6; ++i)
+ {
+ VkFramebufferCreateInfo fbci{ VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO };
+ fbci.renderPass = rp; fbci.attachmentCount = 1; fbci.pAttachments = &face_views[i]; fbci.width = FACE; fbci.height = FACE; fbci.layers = 1;
+ vkCreateFramebuffer(m_device, &fbci, nullptr, &face_fb[i]);
+ }
+
+ VkDescriptorSetLayoutBinding binds[2]{};
+ binds[0].binding = 0; binds[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; binds[0].descriptorCount = 1; binds[0].stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
+ binds[1].binding = 1; binds[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; binds[1].descriptorCount = 1; binds[1].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
+ VkDescriptorSetLayout set_layout;
+ VkDescriptorSetLayoutCreateInfo dslci{ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO }; dslci.bindingCount = 2; dslci.pBindings = binds;
+ vkCreateDescriptorSetLayout(m_device, &dslci, nullptr, &set_layout);
+ VkDescriptorPoolSize psizes[2] = { { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 6 }, { VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 6 } };
+ VkDescriptorPool pool;
+ VkDescriptorPoolCreateInfo dpci{ VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO }; dpci.maxSets = 6; dpci.poolSizeCount = 2; dpci.pPoolSizes = psizes;
+ vkCreateDescriptorPool(m_device, &dpci, nullptr, &pool);
+
+ VkShaderModule vmod, fmod;
+ create_shader_module("assets/shaders/generated/equirect_to_cubemap.vertexMain.spv", vmod);
+ create_shader_module("assets/shaders/generated/equirect_to_cubemap.fragmentMain.spv", fmod);
+ VkPipelineLayout playout;
+ VkPipelineLayoutCreateInfo plci{ VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO }; plci.setLayoutCount = 1; plci.pSetLayouts = &set_layout;
+ vkCreatePipelineLayout(m_device, &plci, nullptr, &playout);
+ VkPipelineShaderStageCreateInfo stages[2]{};
+ stages[0].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; stages[0].stage = VK_SHADER_STAGE_VERTEX_BIT; stages[0].module = vmod; stages[0].pName = "main";
+ stages[1].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; stages[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT; stages[1].module = fmod; stages[1].pName = "main";
+ VkVertexInputBindingDescription vib{ 0, 12, VK_VERTEX_INPUT_RATE_VERTEX };
+ VkVertexInputAttributeDescription via{ 0, 0, VK_FORMAT_R32G32B32_SFLOAT, 0 };
+ VkPipelineVertexInputStateCreateInfo vin{ VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO };
+ vin.vertexBindingDescriptionCount = 1; vin.pVertexBindingDescriptions = &vib; vin.vertexAttributeDescriptionCount = 1; vin.pVertexAttributeDescriptions = &via;
+ VkPipelineInputAssemblyStateCreateInfo ia{ VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO }; ia.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
+ VkViewport vp{ 0, 0, (float)FACE, (float)FACE, 0, 1 }; VkRect2D sc{ { 0, 0 }, { FACE, FACE } };
+ VkPipelineViewportStateCreateInfo vps{ VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO }; vps.viewportCount = 1; vps.pViewports = &vp; vps.scissorCount = 1; vps.pScissors = &sc;
+ VkPipelineRasterizationStateCreateInfo rs{ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO }; rs.polygonMode = VK_POLYGON_MODE_FILL; rs.cullMode = VK_CULL_MODE_NONE; rs.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE; rs.lineWidth = 1.0f;
+ VkPipelineMultisampleStateCreateInfo ms{ VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO }; ms.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
+ VkPipelineColorBlendAttachmentState cba{}; cba.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
+ VkPipelineColorBlendStateCreateInfo cb{ VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO }; cb.attachmentCount = 1; cb.pAttachments = &cba;
+ VkPipeline pipeline;
+ VkGraphicsPipelineCreateInfo gpci{ VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO };
+ gpci.stageCount = 2; gpci.pStages = stages; gpci.pVertexInputState = &vin; gpci.pInputAssemblyState = &ia; gpci.pViewportState = &vps;
+ gpci.pRasterizationState = &rs; gpci.pMultisampleState = &ms; gpci.pColorBlendState = &cb; gpci.layout = playout; gpci.renderPass = rp; gpci.subpass = 0;
+ vkCreateGraphicsPipelines(m_device, VK_NULL_HANDLE, 1, &gpci, nullptr, &pipeline);
+ vkDestroyShaderModule(m_device, vmod, nullptr); vkDestroyShaderModule(m_device, fmod, nullptr);
+
+ float cube_verts[] = {
+ -1,1,-1, -1,-1,-1, 1,-1,-1, 1,-1,-1, 1,1,-1, -1,1,-1,
+ -1,-1,1, -1,-1,-1, -1,1,-1, -1,1,-1, -1,1,1, -1,-1,1,
+ 1,-1,-1, 1,-1,1, 1,1,1, 1,1,1, 1,1,-1, 1,-1,-1,
+ -1,-1,1, -1,1,1, 1,1,1, 1,1,1, 1,-1,1, -1,-1,1,
+ -1,1,-1, 1,1,-1, 1,1,1, 1,1,1, -1,1,1, -1,1,-1,
+ -1,-1,-1, -1,-1,1, 1,-1,-1, 1,-1,-1, -1,-1,1, 1,-1,1,
+ };
+ VkBuffer cube_vb; VkDeviceMemory cube_vb_mem;
+ create_buffer_raw(sizeof(cube_verts), VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, host_vis, cube_vb, cube_vb_mem);
+ vkMapMemory(m_device, cube_vb_mem, 0, sizeof(cube_verts), 0, &mp); std::memcpy(mp, cube_verts, sizeof(cube_verts)); vkUnmapMemory(m_device, cube_vb_mem);
+
+ glm::mat4 proj = glm::perspective(glm::radians(90.0f), 1.0f, 0.1f, 10.0f);
+ proj[1][1] *= -1.0f;
+ glm::mat4 views[6] = {
+ glm::lookAt(glm::vec3(0), glm::vec3( 1, 0, 0), glm::vec3(0, -1, 0)),
+ glm::lookAt(glm::vec3(0), glm::vec3(-1, 0, 0), glm::vec3(0, -1, 0)),
+ glm::lookAt(glm::vec3(0), glm::vec3( 0, 1, 0), glm::vec3(0, 0, 1)),
+ glm::lookAt(glm::vec3(0), glm::vec3( 0, -1, 0), glm::vec3(0, 0, -1)),
+ glm::lookAt(glm::vec3(0), glm::vec3( 0, 0, 1), glm::vec3(0, -1, 0)),
+ glm::lookAt(glm::vec3(0), glm::vec3( 0, 0, -1), glm::vec3(0, -1, 0)),
+ };
+ VkBuffer ubo[6]; VkDeviceMemory ubo_mem[6]; VkDescriptorSet sets[6];
+ for (uint32_t i = 0; i < 6; ++i)
+ {
+ create_buffer_raw(128, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, host_vis, ubo[i], ubo_mem[i]);
+ glm::mat4 mats[2] = { glm::transpose(proj), glm::transpose(views[i]) };
+ vkMapMemory(m_device, ubo_mem[i], 0, 128, 0, &mp); std::memcpy(mp, mats, 128); vkUnmapMemory(m_device, ubo_mem[i]);
+ VkDescriptorSetAllocateInfo dsai{ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO }; dsai.descriptorPool = pool; dsai.descriptorSetCount = 1; dsai.pSetLayouts = &set_layout;
+ vkAllocateDescriptorSets(m_device, &dsai, &sets[i]);
+ VkDescriptorBufferInfo buf_info{ ubo[i], 0, VK_WHOLE_SIZE };
+ VkDescriptorImageInfo img_info{ eq_sampler, eq_view, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL };
+ VkWriteDescriptorSet ws[2]{};
+ ws[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; ws[0].dstSet = sets[i]; ws[0].dstBinding = 0; ws[0].descriptorCount = 1; ws[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; ws[0].pBufferInfo = &buf_info;
+ ws[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; ws[1].dstSet = sets[i]; ws[1].dstBinding = 1; ws[1].descriptorCount = 1; ws[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; ws[1].pImageInfo = &img_info;
+ vkUpdateDescriptorSets(m_device, 2, ws, 0, nullptr);
+ }
+
+ VkCommandBufferAllocateInfo cbai{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO };
+ cbai.commandPool = m_command_pool; cbai.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; cbai.commandBufferCount = 1;
+ VkCommandBuffer cmd; vkAllocateCommandBuffers(m_device, &cbai, &cmd);
+ VkCommandBufferBeginInfo bi{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO }; bi.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
+ vkBeginCommandBuffer(cmd, &bi);
+ VkImageMemoryBarrier to_dst{ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER };
+ to_dst.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED; to_dst.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+ to_dst.image = eq_image; to_dst.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
+ to_dst.srcAccessMask = 0; to_dst.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
+ vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &to_dst);
+ VkBufferImageCopy copy{}; copy.imageSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1 }; copy.imageExtent = { (uint32_t)w, (uint32_t)h, 1 };
+ vkCmdCopyBufferToImage(cmd, eq_staging, eq_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &copy);
+ VkImageMemoryBarrier to_read = to_dst; to_read.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; to_read.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+ to_read.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; to_read.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
+ vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, 0, nullptr, 0, nullptr, 1, &to_read);
+
+ VkClearValue clear{}; clear.color = { { 0, 0, 0, 1 } };
+ for (uint32_t i = 0; i < 6; ++i)
+ {
+ VkRenderPassBeginInfo rpbi{ VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO };
+ rpbi.renderPass = rp; rpbi.framebuffer = face_fb[i]; rpbi.renderArea = { { 0, 0 }, { FACE, FACE } }; rpbi.clearValueCount = 1; rpbi.pClearValues = &clear;
+ vkCmdBeginRenderPass(cmd, &rpbi, VK_SUBPASS_CONTENTS_INLINE);
+ vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
+ vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, playout, 0, 1, &sets[i], 0, nullptr);
+ VkDeviceSize off = 0; vkCmdBindVertexBuffers(cmd, 0, 1, &cube_vb, &off);
+ vkCmdDraw(cmd, 36, 1, 0, 0);
+ vkCmdEndRenderPass(cmd);
+ }
+
+ {
+ VkImageMemoryBarrier src0{ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER };
+ src0.image = tex->m_image; src0.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 6 };
+ src0.oldLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; src0.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
+ src0.srcAccessMask = VK_ACCESS_SHADER_READ_BIT; src0.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
+ vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &src0);
+ int32_t mipW = (int32_t)FACE, mipH = (int32_t)FACE;
+ for (uint32_t m = 1; m < CUBE_MIPS; ++m)
+ {
+ int32_t nW = mipW > 1 ? mipW / 2 : 1, nH = mipH > 1 ? mipH / 2 : 1;
+ VkImageMemoryBarrier bd{ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER };
+ bd.image = tex->m_image; bd.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, m, 1, 0, 6 };
+ bd.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED; bd.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+ bd.srcAccessMask = 0; bd.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
+ vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &bd);
+ VkImageBlit blit{};
+ blit.srcOffsets[1] = { mipW, mipH, 1 }; blit.srcSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, m - 1, 0, 6 };
+ blit.dstOffsets[1] = { nW, nH, 1 }; blit.dstSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, m, 0, 6 };
+ vkCmdBlitImage(cmd, tex->m_image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, tex->m_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &blit, VK_FILTER_LINEAR);
+ VkImageMemoryBarrier bs{ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER };
+ bs.image = tex->m_image; bs.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, m, 1, 0, 6 };
+ bs.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; bs.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
+ bs.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; bs.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
+ vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &bs);
+ mipW = nW; mipH = nH;
+ }
+ VkImageMemoryBarrier fin{ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER };
+ fin.image = tex->m_image; fin.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, CUBE_MIPS, 0, 6 };
+ fin.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL; fin.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+ fin.srcAccessMask = VK_ACCESS_TRANSFER_READ_BIT; fin.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
+ vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, 0, nullptr, 0, nullptr, 1, &fin);
+ }
+
+ vkEndCommandBuffer(cmd);
+ VkSubmitInfo si{ VK_STRUCTURE_TYPE_SUBMIT_INFO }; si.commandBufferCount = 1; si.pCommandBuffers = &cmd;
+ vkQueueSubmit(m_graphics_queue, 1, &si, VK_NULL_HANDLE); vkQueueWaitIdle(m_graphics_queue);
+
+ vkFreeCommandBuffers(m_device, m_command_pool, 1, &cmd);
+ for (uint32_t i = 0; i < 6; ++i) { vkDestroyBuffer(m_device, ubo[i], nullptr); vkFreeMemory(m_device, ubo_mem[i], nullptr); vkDestroyFramebuffer(m_device, face_fb[i], nullptr); vkDestroyImageView(m_device, face_views[i], nullptr); }
+ vkDestroyBuffer(m_device, cube_vb, nullptr); vkFreeMemory(m_device, cube_vb_mem, nullptr);
+ vkDestroyPipeline(m_device, pipeline, nullptr); vkDestroyPipelineLayout(m_device, playout, nullptr);
+ vkDestroyDescriptorPool(m_device, pool, nullptr); vkDestroyDescriptorSetLayout(m_device, set_layout, nullptr);
+ vkDestroyRenderPass(m_device, rp, nullptr);
+ vkDestroySampler(m_device, eq_sampler, nullptr); vkDestroyImageView(m_device, eq_view, nullptr);
+ vkDestroyImage(m_device, eq_image, nullptr); vkFreeMemory(m_device, eq_mem, nullptr);
+ vkDestroyBuffer(m_device, eq_staging, nullptr); vkFreeMemory(m_device, eq_staging_mem, nullptr);
+ DONUT_INFO("Vulkan RHI: HDRI cubemap built from {} ({}x{} equirect -> {}^2 cube)", path, w, h, (int)FACE);
+ return tex;
+ }
+
+ auto VulkanDevice::create_pipeline(const PipelineDesc& desc) -> Ref<Pipeline>
+ {
+ auto p = create_ref<VkPipelineR>(); p->m_device = m_device; p->m_resources = desc.resources;
+
+ std::vector<VkDescriptorSetLayoutBinding> binds;
+ for (const auto& r : desc.resources)
+ {
+ VkDescriptorSetLayoutBinding b{};
+ b.binding = r.binding; b.descriptorCount = 1;
+ b.descriptorType = r.kind == ResourceKind::UniformBuffer ? VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER : VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+ b.stageFlags = VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT;
+ binds.push_back(b);
+ }
+ VkDescriptorSetLayoutCreateInfo dslci{ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO };
+ dslci.bindingCount = (uint32_t)binds.size(); dslci.pBindings = binds.data();
+ vkCreateDescriptorSetLayout(m_device, &dslci, nullptr, &p->m_set_layout);
+ VkPipelineLayoutCreateInfo plci{ VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO };
+ plci.setLayoutCount = 1; plci.pSetLayouts = &p->m_set_layout;
+ vkCreatePipelineLayout(m_device, &plci, nullptr, &p->m_layout);
+
+ VkShaderModule vmod = VK_NULL_HANDLE, fmod = VK_NULL_HANDLE;
+ if (!create_shader_module("assets/shaders/generated/" + desc.shader + ".vertexMain.spv", vmod) ||
+ !create_shader_module("assets/shaders/generated/" + desc.shader + ".fragmentMain.spv", fmod))
+ { DONUT_ERROR("Vulkan RHI: shader '{}' modules failed", desc.shader); return p; }
+ VkPipelineShaderStageCreateInfo stages[2]{};
+ stages[0].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; stages[0].stage = VK_SHADER_STAGE_VERTEX_BIT; stages[0].module = vmod; stages[0].pName = "main";
+ stages[1].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; stages[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT; stages[1].module = fmod; stages[1].pName = "main";
+
+ VkVertexInputBindingDescription vib{ 0, desc.vertex_layout.stride, VK_VERTEX_INPUT_RATE_VERTEX };
+ std::vector<VkVertexInputAttributeDescription> vias;
+ for (const auto& a : desc.vertex_layout.attributes)
+ vias.push_back({ a.location, 0, vk_attr_format(a.components), a.offset });
+ VkPipelineVertexInputStateCreateInfo vin{ VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO };
+ vin.vertexBindingDescriptionCount = desc.vertex_layout.stride ? 1 : 0; vin.pVertexBindingDescriptions = &vib;
+ vin.vertexAttributeDescriptionCount = (uint32_t)vias.size(); vin.pVertexAttributeDescriptions = vias.data();
+
+ VkPipelineInputAssemblyStateCreateInfo ia{ VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO }; ia.topology = vk_topology(desc.topology);
+ VkPipelineViewportStateCreateInfo vps{ VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO }; vps.viewportCount = 1; vps.scissorCount = 1;
+ VkDynamicState dyn[2] = { VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR };
+ VkPipelineDynamicStateCreateInfo dsci{ VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO }; dsci.dynamicStateCount = 2; dsci.pDynamicStates = dyn;
+ VkPipelineRasterizationStateCreateInfo rs{ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO };
+ rs.polygonMode = VK_POLYGON_MODE_FILL; rs.cullMode = vk_cull(desc.cull); rs.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE; rs.lineWidth = 1.0f;
+ VkPipelineMultisampleStateCreateInfo ms{ VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO }; ms.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
+ VkPipelineDepthStencilStateCreateInfo ds{ VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO };
+ ds.depthTestEnable = desc.depth_test ? VK_TRUE : VK_FALSE; ds.depthWriteEnable = desc.depth_write ? VK_TRUE : VK_FALSE; ds.depthCompareOp = vk_compare(desc.depth_op);
+ VkPipelineColorBlendAttachmentState cba{};
+ cba.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
+ if (desc.blend == BlendMode::AlphaBlend)
+ {
+ cba.blendEnable = VK_TRUE;
+ cba.srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA; cba.dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA; cba.colorBlendOp = VK_BLEND_OP_ADD;
+ cba.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE; cba.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO; cba.alphaBlendOp = VK_BLEND_OP_ADD;
+ }
+ VkPipelineColorBlendStateCreateInfo cb{ VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO }; cb.attachmentCount = 1; cb.pAttachments = &cba;
+
+ VkGraphicsPipelineCreateInfo gpci{ VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO };
+ gpci.stageCount = 2; gpci.pStages = stages;
+ gpci.pVertexInputState = &vin; gpci.pInputAssemblyState = &ia; gpci.pViewportState = &vps;
+ gpci.pRasterizationState = &rs; gpci.pMultisampleState = &ms; gpci.pColorBlendState = &cb; gpci.pDynamicState = &dsci;
+ if (desc.has_depth) gpci.pDepthStencilState = &ds;
+ gpci.layout = p->m_layout;
+ gpci.renderPass = desc.has_depth ? m_swapchain_rp : m_offscreen_rp;
+ gpci.subpass = 0;
+ VkResult pr = vkCreateGraphicsPipelines(m_device, VK_NULL_HANDLE, 1, &gpci, nullptr, &p->m_pipeline);
+ vkDestroyShaderModule(m_device, vmod, nullptr); vkDestroyShaderModule(m_device, fmod, nullptr);
+ if (pr != VK_SUCCESS) DONUT_ERROR("Vulkan RHI: pipeline '{}' creation failed ({})", desc.shader, (int)pr);
+ return p;
+ }
+
+ auto VulkanDevice::begin_frame(const glm::vec4&) -> CommandList*
+ {
+ if (m_device == VK_NULL_HANDLE) return nullptr;
+ vkWaitForFences(m_device, 1, &m_in_flight[m_current_frame], VK_TRUE, UINT64_MAX);
+ VkResult r = vkAcquireNextImageKHR(m_device, m_swapchain, UINT64_MAX, m_image_available[m_current_frame], VK_NULL_HANDLE, &m_image_index);
+ if (r == VK_ERROR_OUT_OF_DATE_KHR) { recreate_swapchain(); return nullptr; }
+ if (r != VK_SUCCESS && r != VK_SUBOPTIMAL_KHR) { DONUT_ERROR("Vulkan RHI: acquire failed ({})", (int)r); return nullptr; }
+ if (m_images_in_flight[m_image_index] != VK_NULL_HANDLE)
+ vkWaitForFences(m_device, 1, &m_images_in_flight[m_image_index], VK_TRUE, UINT64_MAX);
+ m_images_in_flight[m_image_index] = m_in_flight[m_current_frame];
+ if (m_geo_in_use != VK_NULL_HANDLE)
+ vkWaitForFences(m_device, 1, &m_geo_in_use, VK_TRUE, UINT64_MAX);
+
+ vkResetDescriptorPool(m_device, m_frame_pools[m_current_frame], 0);
+ VkCommandBuffer cmd = m_command_buffers[m_current_frame];
+ vkResetCommandBuffer(cmd, 0);
+ VkCommandBufferBeginInfo bi{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO };
+ vkBeginCommandBuffer(cmd, &bi);
+
+ m_cmds.m_device = m_device; m_cmds.m_cmd = cmd;
+ m_cmds.m_swapchain_rp = m_swapchain_rp; m_cmds.m_offscreen_rp = m_offscreen_rp;
+ m_cmds.m_swapchain_fb = m_framebuffers[m_image_index]; m_cmds.m_extent = m_extent;
+ m_cmds.m_frame_pool = m_frame_pools[m_current_frame]; m_cmds.m_pipe = nullptr;
+ return &m_cmds;
+ }
+
+ auto VulkanDevice::end_frame() -> void
+ {
+ VkCommandBuffer cmd = m_command_buffers[m_current_frame];
+ vkEndCommandBuffer(cmd);
+ VkPipelineStageFlags wait_stage = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+ VkSubmitInfo submit{ VK_STRUCTURE_TYPE_SUBMIT_INFO };
+ submit.waitSemaphoreCount = 1; submit.pWaitSemaphores = &m_image_available[m_current_frame]; submit.pWaitDstStageMask = &wait_stage;
+ submit.commandBufferCount = 1; submit.pCommandBuffers = &cmd;
+ submit.signalSemaphoreCount = 1; submit.pSignalSemaphores = &m_render_finished[m_image_index];
+ vkResetFences(m_device, 1, &m_in_flight[m_current_frame]);
+ if (vkQueueSubmit(m_graphics_queue, 1, &submit, m_in_flight[m_current_frame]) != VK_SUCCESS)
+ { DONUT_ERROR("Vulkan RHI: queue submit failed"); return; }
+ m_geo_in_use = m_in_flight[m_current_frame];
+
+ VkPresentInfoKHR present{ VK_STRUCTURE_TYPE_PRESENT_INFO_KHR };
+ present.waitSemaphoreCount = 1; present.pWaitSemaphores = &m_render_finished[m_image_index];
+ present.swapchainCount = 1; present.pSwapchains = &m_swapchain; present.pImageIndices = &m_image_index;
+ VkResult r = vkQueuePresentKHR(m_present_queue, &present);
+ if (r == VK_ERROR_OUT_OF_DATE_KHR || r == VK_SUBOPTIMAL_KHR || m_framebuffer_resized)
+ { m_framebuffer_resized = false; recreate_swapchain(); }
+ m_current_frame = (m_current_frame + 1) % MAX_FRAMES_IN_FLIGHT;
+ }
+
+ auto VulkanDevice::init_imgui() -> void
+ {
+ VkDescriptorPoolSize pool_size{ VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1000 };
+ VkDescriptorPoolCreateInfo dpci{ VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO };
+ dpci.flags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT; dpci.maxSets = 1000;
+ dpci.poolSizeCount = 1; dpci.pPoolSizes = &pool_size;
+ vkCreateDescriptorPool(m_device, &dpci, nullptr, &m_imgui_pool);
+
+ IMGUI_CHECKVERSION(); ImGui::CreateContext();
+ ImGui::GetIO().ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;
+ ImGui::GetIO().ConfigFlags |= ImGuiConfigFlags_DockingEnable;
+ ImGui::StyleColorsDark();
+ ImGui_ImplGlfw_InitForVulkan(m_window, true);
+ ImGui_ImplVulkan_InitInfo info{};
+ info.ApiVersion = VK_API_VERSION_1_2; info.Instance = m_instance; info.PhysicalDevice = m_physical;
+ info.Device = m_device; info.QueueFamily = m_graphics_family; info.Queue = m_graphics_queue;
+ info.DescriptorPool = m_imgui_pool; info.RenderPass = m_swapchain_rp;
+ info.MinImageCount = 2; info.ImageCount = (uint32_t)m_images.size(); info.MSAASamples = VK_SAMPLE_COUNT_1_BIT;
+ if (!ImGui_ImplVulkan_Init(&info)) { DONUT_ERROR("Vulkan RHI: ImGui_ImplVulkan_Init failed"); return; }
+ m_imgui = true;
+ DONUT_INFO("Vulkan RHI: ImGui backend initialized");
+ }
+
+ auto VulkanDevice::imgui_new_frame() -> void
+ {
+ if (!m_imgui) return;
+ ImGui_ImplVulkan_NewFrame(); ImGui_ImplGlfw_NewFrame(); ImGui::NewFrame();
+ }
+
+ auto VulkanDevice::imgui_render(CommandList& cmds) -> void
+ {
+ if (!m_imgui) return;
+ ImGui::Render();
+ ImGui_ImplVulkan_RenderDrawData(ImGui::GetDrawData(), static_cast<VkCommandListR&>(cmds).m_cmd);
+ }
+
+ auto VulkanDevice::shutdown() -> void
+ {
+ if (m_device == VK_NULL_HANDLE)
+ {
+ if (m_instance && m_surface) { vkDestroySurfaceKHR(m_instance, m_surface, nullptr); m_surface = VK_NULL_HANDLE; }
+ if (m_instance) { vkDestroyInstance(m_instance, nullptr); m_instance = VK_NULL_HANDLE; }
+ return;
+ }
+ vkDeviceWaitIdle(m_device);
+ if (m_imgui) { ImGui_ImplVulkan_Shutdown(); ImGui_ImplGlfw_Shutdown(); ImGui::DestroyContext(); m_imgui = false; }
+ if (m_imgui_pool) vkDestroyDescriptorPool(m_device, m_imgui_pool, nullptr);
+ for (auto p : m_frame_pools) vkDestroyDescriptorPool(m_device, p, nullptr);
+ m_frame_pools.clear();
+ for (auto s : m_render_finished) vkDestroySemaphore(m_device, s, nullptr);
+ for (auto s : m_image_available) vkDestroySemaphore(m_device, s, nullptr);
+ for (auto f : m_in_flight) vkDestroyFence(m_device, f, nullptr);
+ m_render_finished.clear(); m_image_available.clear(); m_in_flight.clear();
+ if (m_command_pool) vkDestroyCommandPool(m_device, m_command_pool, nullptr);
+ if (m_offscreen_rp) vkDestroyRenderPass(m_device, m_offscreen_rp, nullptr);
+ if (m_swapchain_rp) vkDestroyRenderPass(m_device, m_swapchain_rp, nullptr);
+ cleanup_swapchain();
+ vkDestroyDevice(m_device, nullptr); m_device = VK_NULL_HANDLE;
+ if (m_surface) vkDestroySurfaceKHR(m_instance, m_surface, nullptr);
+ if (m_instance) vkDestroyInstance(m_instance, nullptr);
+ m_surface = VK_NULL_HANDLE; m_instance = VK_NULL_HANDLE;
+ }
+ }
+
+ auto create_vulkan_device() -> Scope<Device> { return create_scope<VulkanDevice>(); }
+
+ auto vulkan_prepare_glfw() -> void
+ {
+#ifdef __APPLE__
+ if (!getenv("VK_ICD_FILENAMES"))
+ setenv("VK_ICD_FILENAMES", "/opt/homebrew/etc/vulkan/icd.d/MoltenVK_icd.json", 0);
+ if (!getenv("VK_LAYER_PATH"))
+ setenv("VK_LAYER_PATH", "/opt/homebrew/share/vulkan/explicit_layer.d", 0);
+ if (!getenv("DYLD_LIBRARY_PATH"))
+ setenv("DYLD_LIBRARY_PATH", "/opt/homebrew/lib", 0);
+#endif
+ glfwInitVulkanLoader(vkGetInstanceProcAddr);
+ }
+}
diff --git a/src/platform/vulkan/vulkan_device.h b/src/platform/vulkan/vulkan_device.h
new file mode 100644
index 0000000..efc2433
--- /dev/null
+++ b/src/platform/vulkan/vulkan_device.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include "rendering/rhi.h"
+
+namespace Donut::RHI
+{
+ // Vulkan implementation of the RHI Device (MoltenVK on macOS). Owns the
+ // instance/device/swapchain and translates the RHI's baked pipelines +
+ // recorded command lists into native Vulkan; the geometry it draws is the
+ // shared SceneRenderer / BlackHoleRenderer, identical to every other backend.
+ auto create_vulkan_device() -> Scope<Device>;
+
+ // Must run BEFORE glfwInit() when Vulkan is the selected API: points GLFW at
+ // the loader the app links against (its own dlopen fails on macOS/Homebrew)
+ // and configures the MoltenVK ICD / layer paths.
+ auto vulkan_prepare_glfw() -> void;
+}
diff --git a/src/platform/vulkan/vulkan_renderer.cpp b/src/platform/vulkan/vulkan_renderer.cpp
deleted file mode 100644
index 8b0d0c0..0000000
--- a/src/platform/vulkan/vulkan_renderer.cpp
+++ /dev/null
@@ -1,2038 +0,0 @@
-#include "vulkan_renderer.h"
-#include "core/log.h"
-#include "core/camera.h"
-#include "core/settings_manager.h"
-
-#define GLFW_INCLUDE_VULKAN
-#include <GLFW/glfw3.h>
-
-#include <imgui.h>
-#include <imgui_impl_glfw.h>
-#include <imgui_impl_vulkan.h>
-
-#include <glm/glm.hpp>
-#include <glm/gtc/matrix_transform.hpp>
-#include "stb_image.h"
-
-#include <vector>
-#include <algorithm>
-#include <cstring>
-#include <cstdlib>
-#include <fstream>
-
-namespace Donut
-{
- #define VK_CHECK(expr) \
- do { \
- VkResult _r = (expr); \
- if (_r != VK_SUCCESS) { \
- DONUT_ERROR("Vulkan: {} failed ({})", #expr, (int)_r); \
- return false; \
- } \
- } while (0)
-
- static constexpr int MAX_FRAMES_IN_FLIGHT = 2;
-
- auto vulkan_prepare_glfw() -> void
- {
-#ifdef __APPLE__
- if (!getenv("VK_ICD_FILENAMES"))
- setenv("VK_ICD_FILENAMES", "/opt/homebrew/etc/vulkan/icd.d/MoltenVK_icd.json", 0);
- if (!getenv("VK_LAYER_PATH"))
- setenv("VK_LAYER_PATH", "/opt/homebrew/share/vulkan/explicit_layer.d", 0);
- if (!getenv("DYLD_LIBRARY_PATH"))
- setenv("DYLD_LIBRARY_PATH", "/opt/homebrew/lib", 0);
-#endif
- // GLFW dlopen's the Vulkan loader by bare name, which fails on
- // mac_os/Homebrew; hand it the loader entry point we already link against.
- glfwInitVulkanLoader(vkGetInstanceProcAddr);
- }
-
- struct VulkanRenderer::Impl
- {
- GLFWwindow* window = nullptr;
- int width = 0, height = 0;
- bool framebuffer_resized = false;
-
- VkInstance instance = VK_NULL_HANDLE;
- VkSurfaceKHR surface = VK_NULL_HANDLE;
- VkPhysicalDevice physical = VK_NULL_HANDLE;
- VkDevice device = VK_NULL_HANDLE;
- uint32_t graphics_family = 0, present_family = 0;
- VkQueue graphics_queue = VK_NULL_HANDLE, present_queue = VK_NULL_HANDLE;
-
- VkSwapchainKHR swapchain = VK_NULL_HANDLE;
- VkFormat swapchain_format = VK_FORMAT_B8G8R8A8_UNORM;
- VkExtent2D swapchain_extent{};
- std::vector<VkImage> images;
- std::vector<VkImageView> image_views;
- VkRenderPass render_pass = VK_NULL_HANDLE;
- std::vector<VkFramebuffer> framebuffers;
-
- VkCommandPool command_pool = VK_NULL_HANDLE;
- std::vector<VkCommandBuffer> command_buffers; // MAX_FRAMES_IN_FLIGHT
-
- std::vector<VkSemaphore> image_available; // per frame in flight
- std::vector<VkSemaphore> render_finished; // per swapchain image
- std::vector<VkFence> in_flight; // per frame in flight
- std::vector<VkFence> images_in_flight; // per swapchain image
- uint32_t current_frame = 0;
-
- VkDescriptorPool imgui_pool = VK_NULL_HANDLE;
- bool imgui_init = false;
-
- VkPhysicalDeviceMemoryProperties mem_props{};
-
- // The geodesic is rendered every frame into an offscreen image, then
- // upscaled onto the swapchain by the present pass. Progressive resolution:
- // low-res while the camera moves (keeps dragging responsive and each draw
- // well under the Metal GPU watchdog) and high-res once it settles (resolves
- // the photon ring cleanly). Both are 16:9 so the camera aspect is shared.
- static constexpr uint32_t GEO_LO_W = 480, GEO_LO_H = 270;
- static constexpr uint32_t GEO_HI_W = 960, GEO_HI_H = 540;
- struct GeoTarget
- {
- uint32_t w = 0, h = 0;
- VkImage image = VK_NULL_HANDLE;
- VkDeviceMemory mem = VK_NULL_HANDLE;
- VkImageView view = VK_NULL_HANDLE;
- VkFramebuffer fb = VK_NULL_HANDLE;
- VkDescriptorSet present_set = VK_NULL_HANDLE; // present pass samples this target
- };
- GeoTarget geo_lo, geo_hi;
- VkRenderPass geo_render_pass = VK_NULL_HANDLE; // shared (resolution-independent)
- VkBuffer cam_buf = VK_NULL_HANDLE, disk_buf = VK_NULL_HANDLE, obj_buf = VK_NULL_HANDLE, sim_buf = VK_NULL_HANDLE;
- VkDeviceMemory cam_mem = VK_NULL_HANDLE, disk_mem = VK_NULL_HANDLE, obj_mem = VK_NULL_HANDLE, sim_mem = VK_NULL_HANDLE;
- void* cam_mapped = nullptr;
- void* sim_mapped = nullptr;
- void* disk_mapped = nullptr; // disk UBO, refilled from bh_params each frame
- BlackHoleParams bh_params; // live UI-tunable disk/camera parameters
- std::string gpu_name; // physical device name for the UI
- Camera camera{ 60.0f, (float)GEO_HI_W / (float)GEO_HI_H, 0.1f, 100.0f };
- bool left_was_down = false;
- double last_frame_time = 0.0; // for free-fly dt
- double fps_last_x = 0.0, fps_last_y = 0.0; // cursor tracking for free-fly look
- bool user_moving = false; // camera moved/looked this frame (drives step count)
- VkImage cube_image = VK_NULL_HANDLE; VkDeviceMemory cube_mem = VK_NULL_HANDLE;
- VkImageView cube_view = VK_NULL_HANDLE; VkSampler cube_sampler = VK_NULL_HANDLE;
- std::string hdri_path; // path backing the current cubemap (UI display + no-op switch guard)
- VkDescriptorSetLayout geo_set_layout = VK_NULL_HANDLE;
- VkDescriptorPool geo_pool = VK_NULL_HANDLE;
- VkDescriptorSet geo_set = VK_NULL_HANDLE;
- VkPipelineLayout geo_pipeline_layout = VK_NULL_HANDLE;
- VkPipeline geo_pipeline = VK_NULL_HANDLE;
- VkBuffer quad_vb = VK_NULL_HANDLE; VkDeviceMemory quad_vb_mem = VK_NULL_HANDLE;
- double start_time = 0.0;
- VkFence geo_in_use = VK_NULL_HANDLE; // previous frame's fence; guards the shared geodesic image
-
- // Present pass: samples the geodesic image with a full-screen textured
- // quad, drawn into the swapchain render pass just before the ImGui UI.
- VkSampler present_sampler = VK_NULL_HANDLE;
- VkDescriptorSetLayout present_set_layout = VK_NULL_HANDLE;
- VkDescriptorPool present_pool = VK_NULL_HANDLE;
- VkPipelineLayout present_pipeline_layout = VK_NULL_HANDLE;
- VkPipeline present_pipeline = VK_NULL_HANDLE;
-
- // World-builder scene view (grid now; sphere/skybox next). Normal-scale
- // orbital camera; geometry drawn straight into the swapchain render pass.
- bool scene_mode = false;
- Camera scene_camera{ 45.0f, (float)GEO_HI_W / (float)GEO_HI_H, 0.1f, 1000.0f };
- VkBuffer grid_vb = VK_NULL_HANDLE; VkDeviceMemory grid_vb_mem = VK_NULL_HANDLE;
- uint32_t grid_vertex_count = 0;
- VkBuffer grid_ubo = VK_NULL_HANDLE; VkDeviceMemory grid_ubo_mem = VK_NULL_HANDLE;
- void* grid_ubo_mapped = nullptr;
- VkDescriptorSetLayout grid_set_layout = VK_NULL_HANDLE;
- VkDescriptorPool grid_pool = VK_NULL_HANDLE;
- VkDescriptorSet grid_set = VK_NULL_HANDLE;
- VkPipelineLayout grid_pipeline_layout = VK_NULL_HANDLE;
- VkPipeline grid_pipeline = VK_NULL_HANDLE;
-
- // Scene color+depth pass into the swapchain (the grid is coplanar, but the
- // sphere needs real depth). Depth image + framebuffers track the swapchain.
- VkImage scene_depth_image = VK_NULL_HANDLE; VkDeviceMemory scene_depth_mem = VK_NULL_HANDLE;
- VkImageView scene_depth_view = VK_NULL_HANDLE;
- VkRenderPass scene_render_pass = VK_NULL_HANDLE;
- std::vector<VkFramebuffer> scene_framebuffers;
-
- // Lit sphere (Sphere.slang): pos+normal indexed mesh; samples the HDRI
- // cubemap for ambient at binding 1 (shares the geodesic cube).
- VkBuffer sphere_vb = VK_NULL_HANDLE; VkDeviceMemory sphere_vb_mem = VK_NULL_HANDLE;
- VkBuffer sphere_ib = VK_NULL_HANDLE; VkDeviceMemory sphere_ib_mem = VK_NULL_HANDLE;
- uint32_t sphere_index_count = 0;
- static constexpr uint32_t MAX_SCENE_OBJECTS = 64;
- std::vector<SceneObject> scene_objects{ SceneObject{} }; // one default sphere
- int selected_object = 0;
- VkDeviceSize sphere_ubo_stride = 0; // aligned per-object UBO slot (dynamic offset)
- VkBuffer sphere_ubo = VK_NULL_HANDLE; VkDeviceMemory sphere_ubo_mem = VK_NULL_HANDLE;
- void* sphere_ubo_mapped = nullptr;
- VkDescriptorSetLayout sphere_set_layout = VK_NULL_HANDLE;
- VkDescriptorPool sphere_pool = VK_NULL_HANDLE;
- VkDescriptorSet sphere_set = VK_NULL_HANDLE;
- VkPipelineLayout sphere_pipeline_layout = VK_NULL_HANDLE;
- VkPipeline sphere_pipeline = VK_NULL_HANDLE;
-
- // Skybox (Skybox.slang): a cube sampling the HDRI cubemap at the far plane
- // (pos.xyww -> depth 1), drawn first as the scene background.
- VkBuffer skybox_vb = VK_NULL_HANDLE; VkDeviceMemory skybox_vb_mem = VK_NULL_HANDLE;
- VkBuffer skybox_ubo = VK_NULL_HANDLE; VkDeviceMemory skybox_ubo_mem = VK_NULL_HANDLE;
- void* skybox_ubo_mapped = nullptr;
- VkDescriptorSetLayout skybox_set_layout = VK_NULL_HANDLE;
- VkDescriptorPool skybox_pool = VK_NULL_HANDLE;
- VkDescriptorSet skybox_set = VK_NULL_HANDLE;
- VkPipelineLayout skybox_pipeline_layout = VK_NULL_HANDLE;
- VkPipeline skybox_pipeline = VK_NULL_HANDLE;
-
- auto find_memory_type(uint32_t type_filter, VkMemoryPropertyFlags flags) const -> uint32_t;
- auto create_buffer(VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags props, VkBuffer& buf, VkDeviceMemory& mem) const -> bool;
- static auto load_spirv(const std::string& path) -> std::vector<uint32_t>;
- auto create_shader_module(const std::string& path, VkShaderModule& out) const -> bool;
-
- auto create_instance() -> bool;
- auto pick_physical_and_device() -> bool;
- auto create_swapchain() -> bool;
- auto create_image_views() -> bool;
- auto create_render_pass() -> bool;
- auto create_framebuffers() -> bool;
- auto create_command_buffers() -> bool;
- auto create_sync_objects() -> bool;
- auto create_geodesic_resources() -> bool;
- auto create_geo_target(GeoTarget& target, uint32_t w, uint32_t h) -> bool;
- auto create_hdri_cubemap(const char* path) -> bool;
- auto rebuild_hdri_cubemap(const char* path) -> void;
- auto create_present_resources() -> bool;
- auto create_scene_resources() -> bool;
- auto create_scene_targets() -> bool;
- auto destroy_scene_targets() -> void;
- auto process_input() -> void;
- auto update_geodesic_uniforms() -> void;
- auto update_scene_uniforms() -> void;
- auto destroy_geodesic_resources() -> void;
- auto recreate_swapchain() -> bool;
- auto cleanup_swapchain() -> void;
- auto record_command_buffer(VkCommandBuffer cmd, uint32_t image_index, const glm::vec4& clear, ImDrawData* draw_data) -> bool;
- };
-
- auto VulkanRenderer::Impl::create_instance() -> bool
- {
-#ifdef __APPLE__
- if (!getenv("VK_ICD_FILENAMES"))
- setenv("VK_ICD_FILENAMES", "/opt/homebrew/etc/vulkan/icd.d/MoltenVK_icd.json", 0);
- if (!getenv("VK_LAYER_PATH"))
- setenv("VK_LAYER_PATH", "/opt/homebrew/share/vulkan/explicit_layer.d", 0);
- // The Homebrew validation-layer manifest names the dylib without a path;
- // let dlopen find it in the Homebrew lib dir.
- if (!getenv("DYLD_LIBRARY_PATH"))
- setenv("DYLD_LIBRARY_PATH", "/opt/homebrew/lib", 0);
-#endif
- VkApplicationInfo app{ VK_STRUCTURE_TYPE_APPLICATION_INFO };
- app.pApplicationName = "Donut";
- app.apiVersion = VK_API_VERSION_1_2;
-
- uint32_t glfwExtCount = 0;
- const char** glfwExts = glfwGetRequiredInstanceExtensions(&glfwExtCount);
- if (!glfwExts) { DONUT_ERROR("Vulkan: GLFW reports no surface support"); return false; }
- std::vector<const char*> exts;
- for (uint32_t i = 0; i < glfwExtCount; ++i) exts.push_back(glfwExts[i]);
- exts.push_back(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME);
- exts.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
-
- std::vector<const char*> layers;
- uint32_t layer_count = 0;
- vkEnumerateInstanceLayerProperties(&layer_count, nullptr);
- std::vector<VkLayerProperties> avail(layer_count);
- vkEnumerateInstanceLayerProperties(&layer_count, avail.data());
- for (const auto& l : avail)
- if (std::strcmp(l.layerName, "VK_LAYER_KHRONOS_validation") == 0)
- layers.push_back("VK_LAYER_KHRONOS_validation");
-
- VkInstanceCreateInfo ici{ VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO };
- ici.flags = VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR;
- ici.pApplicationInfo = &app;
- ici.enabledExtensionCount = (uint32_t)exts.size();
- ici.ppEnabledExtensionNames = exts.data();
- ici.enabledLayerCount = (uint32_t)layers.size();
- ici.ppEnabledLayerNames = layers.data();
-
- VkResult r = vkCreateInstance(&ici, nullptr, &instance);
- if (r != VK_SUCCESS && !layers.empty())
- {
- // The validation layer failed to load (its dylib isn't on the loader
- // search path); it is optional, so retry without it.
- DONUT_WARN("Vulkan: validation layer unavailable, continuing without it");
- layers.clear();
- ici.enabledLayerCount = 0;
- ici.ppEnabledLayerNames = nullptr;
- r = vkCreateInstance(&ici, nullptr, &instance);
- }
- if (r != VK_SUCCESS) { DONUT_ERROR("Vulkan: vkCreateInstance failed ({})", (int)r); return false; }
-
- VK_CHECK(glfwCreateWindowSurface(instance, window, nullptr, &surface));
- DONUT_INFO("Vulkan: instance + surface created (validation {})", layers.empty() ? "off" : "on");
- return true;
- }
-
- auto VulkanRenderer::Impl::pick_physical_and_device() -> bool
- {
- uint32_t count = 0;
- vkEnumeratePhysicalDevices(instance, &count, nullptr);
- if (count == 0) { DONUT_ERROR("Vulkan: no physical devices"); return false; }
- std::vector<VkPhysicalDevice> devices(count);
- vkEnumeratePhysicalDevices(instance, &count, devices.data());
- physical = devices[0];
-
- uint32_t q_count = 0;
- vkGetPhysicalDeviceQueueFamilyProperties(physical, &q_count, nullptr);
- std::vector<VkQueueFamilyProperties> qfams(q_count);
- vkGetPhysicalDeviceQueueFamilyProperties(physical, &q_count, qfams.data());
- bool found_g = false, found_p = false;
- for (uint32_t i = 0; i < q_count; ++i)
- {
- if (!found_g && (qfams[i].queueFlags & VK_QUEUE_GRAPHICS_BIT)) { graphics_family = i; found_g = true; }
- VkBool32 present = VK_FALSE;
- vkGetPhysicalDeviceSurfaceSupportKHR(physical, i, surface, &present);
- if (!found_p && present) { present_family = i; found_p = true; }
- }
- if (!found_g || !found_p) { DONUT_ERROR("Vulkan: no graphics/present queue"); return false; }
-
- std::vector<const char*> dev_exts = { VK_KHR_SWAPCHAIN_EXTENSION_NAME };
- uint32_t dev_ext_count = 0;
- vkEnumerateDeviceExtensionProperties(physical, nullptr, &dev_ext_count, nullptr);
- std::vector<VkExtensionProperties> dev_ext_props(dev_ext_count);
- vkEnumerateDeviceExtensionProperties(physical, nullptr, &dev_ext_count, dev_ext_props.data());
- for (const auto& e : dev_ext_props)
- if (std::strcmp(e.extensionName, "VK_KHR_portability_subset") == 0)
- dev_exts.push_back("VK_KHR_portability_subset");
-
- float priority = 1.0f;
- std::vector<VkDeviceQueueCreateInfo> qcis;
- uint32_t families[2] = { graphics_family, present_family };
- for (uint32_t i = 0; i < (graphics_family == present_family ? 1u : 2u); ++i)
- {
- VkDeviceQueueCreateInfo qci{ VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO };
- qci.queueFamilyIndex = families[i];
- qci.queueCount = 1;
- qci.pQueuePriorities = &priority;
- qcis.push_back(qci);
- }
- VkDeviceCreateInfo dci{ VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO };
- dci.queueCreateInfoCount = (uint32_t)qcis.size();
- dci.pQueueCreateInfos = qcis.data();
- dci.enabledExtensionCount = (uint32_t)dev_exts.size();
- dci.ppEnabledExtensionNames = dev_exts.data();
- VK_CHECK(vkCreateDevice(physical, &dci, nullptr, &device));
- vkGetDeviceQueue(device, graphics_family, 0, &graphics_queue);
- vkGetDeviceQueue(device, present_family, 0, &present_queue);
-
- VkPhysicalDeviceProperties props{};
- vkGetPhysicalDeviceProperties(physical, &props);
- vkGetPhysicalDeviceMemoryProperties(physical, &mem_props);
- gpu_name = props.deviceName;
- DONUT_INFO("Vulkan device: {}", gpu_name);
- return true;
- }
-
- auto VulkanRenderer::Impl::create_swapchain() -> bool
- {
- VkSurfaceCapabilitiesKHR caps{};
- vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physical, surface, &caps);
-
- uint32_t fmt_count = 0;
- vkGetPhysicalDeviceSurfaceFormatsKHR(physical, surface, &fmt_count, nullptr);
- std::vector<VkSurfaceFormatKHR> formats(fmt_count);
- vkGetPhysicalDeviceSurfaceFormatsKHR(physical, surface, &fmt_count, formats.data());
- VkSurfaceFormatKHR chosen = formats[0];
- for (const auto& f : formats)
- if (f.format == VK_FORMAT_B8G8R8A8_UNORM && f.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR)
- chosen = f;
- swapchain_format = chosen.format;
-
- if (caps.currentExtent.width != UINT32_MAX)
- swapchain_extent = caps.currentExtent;
- else
- {
- swapchain_extent.width = std::clamp((uint32_t)width, caps.minImageExtent.width, caps.maxImageExtent.width);
- swapchain_extent.height = std::clamp((uint32_t)height, caps.minImageExtent.height, caps.maxImageExtent.height);
- }
-
- uint32_t image_count = caps.minImageCount + 1;
- if (caps.maxImageCount > 0 && image_count > caps.maxImageCount)
- image_count = caps.maxImageCount;
-
- VkSwapchainCreateInfoKHR sci{ VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR };
- sci.surface = surface;
- sci.minImageCount = image_count;
- sci.imageFormat = chosen.format;
- sci.imageColorSpace = chosen.colorSpace;
- sci.imageExtent = swapchain_extent;
- sci.imageArrayLayers = 1;
- sci.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
- sci.preTransform = caps.currentTransform;
- sci.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
- sci.presentMode = VK_PRESENT_MODE_FIFO_KHR; // always supported, vsync
- sci.clipped = VK_TRUE;
-
- uint32_t fam_idx[2] = { graphics_family, present_family };
- if (graphics_family != present_family)
- {
- sci.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
- sci.queueFamilyIndexCount = 2;
- sci.pQueueFamilyIndices = fam_idx;
- }
- else
- sci.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
-
- VK_CHECK(vkCreateSwapchainKHR(device, &sci, nullptr, &swapchain));
- uint32_t n = 0;
- vkGetSwapchainImagesKHR(device, swapchain, &n, nullptr);
- images.resize(n);
- vkGetSwapchainImagesKHR(device, swapchain, &n, images.data());
- return true;
- }
-
- auto VulkanRenderer::Impl::create_image_views() -> bool
- {
- image_views.resize(images.size());
- for (size_t i = 0; i < images.size(); ++i)
- {
- VkImageViewCreateInfo vci{ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO };
- vci.image = images[i];
- vci.viewType = VK_IMAGE_VIEW_TYPE_2D;
- vci.format = swapchain_format;
- vci.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
- VK_CHECK(vkCreateImageView(device, &vci, nullptr, &image_views[i]));
- }
- return true;
- }
-
- auto VulkanRenderer::Impl::create_render_pass() -> bool
- {
- VkAttachmentDescription color{};
- color.format = swapchain_format;
- color.samples = VK_SAMPLE_COUNT_1_BIT;
- color.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
- color.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
- color.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
- color.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
- color.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
- color.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
-
- VkAttachmentReference ref{ 0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL };
- VkSubpassDescription subpass{};
- subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
- subpass.colorAttachmentCount = 1;
- subpass.pColorAttachments = &ref;
-
- VkSubpassDependency dep{};
- dep.srcSubpass = VK_SUBPASS_EXTERNAL;
- dep.dstSubpass = 0;
- dep.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
- dep.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
- dep.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
-
- VkRenderPassCreateInfo rpci{ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO };
- rpci.attachmentCount = 1; rpci.pAttachments = &color;
- rpci.subpassCount = 1; rpci.pSubpasses = &subpass;
- rpci.dependencyCount = 1; rpci.pDependencies = &dep;
- VK_CHECK(vkCreateRenderPass(device, &rpci, nullptr, &render_pass));
- return true;
- }
-
- auto VulkanRenderer::Impl::create_framebuffers() -> bool
- {
- framebuffers.resize(image_views.size());
- for (size_t i = 0; i < image_views.size(); ++i)
- {
- VkFramebufferCreateInfo fbci{ VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO };
- fbci.renderPass = render_pass;
- fbci.attachmentCount = 1; fbci.pAttachments = &image_views[i];
- fbci.width = swapchain_extent.width; fbci.height = swapchain_extent.height; fbci.layers = 1;
- VK_CHECK(vkCreateFramebuffer(device, &fbci, nullptr, &framebuffers[i]));
- }
- return true;
- }
-
- // Depth image + a color+depth render pass + per-image framebuffers for the
- // scene view. Swapchain-sized, so recreated alongside the swapchain.
- auto VulkanRenderer::Impl::create_scene_targets() -> bool
- {
- const VkFormat depth_fmt = VK_FORMAT_D32_SFLOAT;
-
- VkImageCreateInfo dici{ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
- dici.imageType = VK_IMAGE_TYPE_2D; dici.format = depth_fmt;
- dici.extent = { swapchain_extent.width, swapchain_extent.height, 1 };
- dici.mipLevels = 1; dici.arrayLayers = 1; dici.samples = VK_SAMPLE_COUNT_1_BIT;
- dici.tiling = VK_IMAGE_TILING_OPTIMAL; dici.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
- VK_CHECK(vkCreateImage(device, &dici, nullptr, &scene_depth_image));
- VkMemoryRequirements dreq{}; vkGetImageMemoryRequirements(device, scene_depth_image, &dreq);
- VkMemoryAllocateInfo dai{ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
- dai.allocationSize = dreq.size; dai.memoryTypeIndex = find_memory_type(dreq.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
- VK_CHECK(vkAllocateMemory(device, &dai, nullptr, &scene_depth_mem));
- VK_CHECK(vkBindImageMemory(device, scene_depth_image, scene_depth_mem, 0));
- VkImageViewCreateInfo dvci{ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO };
- dvci.image = scene_depth_image; dvci.viewType = VK_IMAGE_VIEW_TYPE_2D; dvci.format = depth_fmt;
- dvci.subresourceRange = { VK_IMAGE_ASPECT_DEPTH_BIT, 0, 1, 0, 1 };
- VK_CHECK(vkCreateImageView(device, &dvci, nullptr, &scene_depth_view));
-
- VkAttachmentDescription atts[2]{};
- atts[0].format = swapchain_format; atts[0].samples = VK_SAMPLE_COUNT_1_BIT;
- atts[0].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; atts[0].storeOp = VK_ATTACHMENT_STORE_OP_STORE;
- atts[0].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; atts[0].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
- atts[0].initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; atts[0].finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
- atts[1].format = depth_fmt; atts[1].samples = VK_SAMPLE_COUNT_1_BIT;
- atts[1].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; atts[1].storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
- atts[1].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; atts[1].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
- atts[1].initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; atts[1].finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
- VkAttachmentReference color_ref{ 0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL };
- VkAttachmentReference depth_ref{ 1, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL };
- VkSubpassDescription subpass{}; subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
- subpass.colorAttachmentCount = 1; subpass.pColorAttachments = &color_ref; subpass.pDepthStencilAttachment = &depth_ref;
- VkSubpassDependency dep{};
- dep.srcSubpass = VK_SUBPASS_EXTERNAL; dep.dstSubpass = 0;
- dep.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
- dep.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
- dep.srcAccessMask = 0;
- dep.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
- VkRenderPassCreateInfo rpci{ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO };
- rpci.attachmentCount = 2; rpci.pAttachments = atts; rpci.subpassCount = 1; rpci.pSubpasses = &subpass;
- rpci.dependencyCount = 1; rpci.pDependencies = &dep;
- VK_CHECK(vkCreateRenderPass(device, &rpci, nullptr, &scene_render_pass));
-
- scene_framebuffers.resize(image_views.size());
- for (size_t i = 0; i < image_views.size(); ++i)
- {
- VkImageView att[2] = { image_views[i], scene_depth_view };
- VkFramebufferCreateInfo fbci{ VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO };
- fbci.renderPass = scene_render_pass; fbci.attachmentCount = 2; fbci.pAttachments = att;
- fbci.width = swapchain_extent.width; fbci.height = swapchain_extent.height; fbci.layers = 1;
- VK_CHECK(vkCreateFramebuffer(device, &fbci, nullptr, &scene_framebuffers[i]));
- }
- return true;
- }
-
- auto VulkanRenderer::Impl::destroy_scene_targets() -> void
- {
- for (auto fb : scene_framebuffers) vkDestroyFramebuffer(device, fb, nullptr);
- scene_framebuffers.clear();
- if (scene_render_pass) { vkDestroyRenderPass(device, scene_render_pass, nullptr); scene_render_pass = VK_NULL_HANDLE; }
- if (scene_depth_view) { vkDestroyImageView(device, scene_depth_view, nullptr); scene_depth_view = VK_NULL_HANDLE; }
- if (scene_depth_image) { vkDestroyImage(device, scene_depth_image, nullptr); scene_depth_image = VK_NULL_HANDLE; }
- if (scene_depth_mem) { vkFreeMemory(device, scene_depth_mem, nullptr); scene_depth_mem = VK_NULL_HANDLE; }
- }
-
- auto VulkanRenderer::Impl::create_command_buffers() -> bool
- {
- VkCommandPoolCreateInfo pci{ VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO };
- pci.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
- pci.queueFamilyIndex = graphics_family;
- VK_CHECK(vkCreateCommandPool(device, &pci, nullptr, &command_pool));
-
- command_buffers.resize(MAX_FRAMES_IN_FLIGHT);
- VkCommandBufferAllocateInfo cbai{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO };
- cbai.commandPool = command_pool;
- cbai.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
- cbai.commandBufferCount = MAX_FRAMES_IN_FLIGHT;
- VK_CHECK(vkAllocateCommandBuffers(device, &cbai, command_buffers.data()));
- return true;
- }
-
- auto VulkanRenderer::Impl::create_sync_objects() -> bool
- {
- image_available.resize(MAX_FRAMES_IN_FLIGHT);
- in_flight.resize(MAX_FRAMES_IN_FLIGHT);
- render_finished.resize(images.size());
- images_in_flight.assign(images.size(), VK_NULL_HANDLE);
-
- VkSemaphoreCreateInfo sci{ VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO };
- VkFenceCreateInfo fci{ VK_STRUCTURE_TYPE_FENCE_CREATE_INFO };
- fci.flags = VK_FENCE_CREATE_SIGNALED_BIT;
- for (int i = 0; i < MAX_FRAMES_IN_FLIGHT; ++i)
- {
- VK_CHECK(vkCreateSemaphore(device, &sci, nullptr, &image_available[i]));
- VK_CHECK(vkCreateFence(device, &fci, nullptr, &in_flight[i]));
- }
- for (size_t i = 0; i < images.size(); ++i)
- VK_CHECK(vkCreateSemaphore(device, &sci, nullptr, &render_finished[i]));
- return true;
- }
-
- auto VulkanRenderer::Impl::find_memory_type(uint32_t type_filter, VkMemoryPropertyFlags flags) const -> uint32_t
- {
- for (uint32_t i = 0; i < mem_props.memoryTypeCount; ++i)
- if ((type_filter & (1u << i)) && (mem_props.memoryTypes[i].propertyFlags & flags) == flags)
- return i;
- return UINT32_MAX;
- }
-
- auto VulkanRenderer::Impl::create_buffer(VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags props,
- VkBuffer& buf, VkDeviceMemory& mem) const -> bool
- {
- VkBufferCreateInfo bci{ VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
- bci.size = size; bci.usage = usage; bci.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
- if (vkCreateBuffer(device, &bci, nullptr, &buf) != VK_SUCCESS) return false;
- VkMemoryRequirements req{}; vkGetBufferMemoryRequirements(device, buf, &req);
- VkMemoryAllocateInfo ai{ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
- ai.allocationSize = req.size;
- ai.memoryTypeIndex = find_memory_type(req.memoryTypeBits, props);
- if (vkAllocateMemory(device, &ai, nullptr, &mem) != VK_SUCCESS) return false;
- vkBindBufferMemory(device, buf, mem, 0);
- return true;
- }
-
- auto VulkanRenderer::Impl::load_spirv(const std::string& path) -> std::vector<uint32_t>
- {
- std::ifstream file(path, std::ios::ate | std::ios::binary);
- if (!file.is_open()) return {};
- size_t size = (size_t)file.tellg();
- std::vector<uint32_t> data(size / 4);
- file.seekg(0);
- file.read(reinterpret_cast<char*>(data.data()), size);
- return data;
- }
-
- auto VulkanRenderer::Impl::create_shader_module(const std::string& path, VkShaderModule& out) const -> bool
- {
- auto spv = load_spirv(path);
- if (spv.empty()) { DONUT_ERROR("Vulkan: failed to load SPIR-V {}", path); return false; }
- VkShaderModuleCreateInfo ci{ VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO };
- ci.codeSize = spv.size() * 4; ci.pCode = spv.data();
- return vkCreateShaderModule(device, &ci, nullptr, &out) == VK_SUCCESS;
- }
-
- // Creates one geodesic render target (image + memory + view + framebuffer)
- // at w x h against the shared geo_render_pass. Used for the low- and high-res
- // progressive targets.
- auto VulkanRenderer::Impl::create_geo_target(GeoTarget& t, uint32_t w, uint32_t h) -> bool
- {
- const VkFormat fmt = VK_FORMAT_R8G8B8A8_UNORM;
- t.w = w; t.h = h;
-
- VkImageCreateInfo ici{ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
- ici.imageType = VK_IMAGE_TYPE_2D; ici.format = fmt; ici.extent = { w, h, 1 };
- ici.mipLevels = 1; ici.arrayLayers = 1; ici.samples = VK_SAMPLE_COUNT_1_BIT;
- ici.tiling = VK_IMAGE_TILING_OPTIMAL;
- ici.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
- VK_CHECK(vkCreateImage(device, &ici, nullptr, &t.image));
- VkMemoryRequirements im_req{}; vkGetImageMemoryRequirements(device, t.image, &im_req);
- VkMemoryAllocateInfo im_alloc{ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
- im_alloc.allocationSize = im_req.size;
- im_alloc.memoryTypeIndex = find_memory_type(im_req.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
- VK_CHECK(vkAllocateMemory(device, &im_alloc, nullptr, &t.mem));
- VK_CHECK(vkBindImageMemory(device, t.image, t.mem, 0));
- VkImageViewCreateInfo vci{ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO };
- vci.image = t.image; vci.viewType = VK_IMAGE_VIEW_TYPE_2D; vci.format = fmt;
- vci.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
- VK_CHECK(vkCreateImageView(device, &vci, nullptr, &t.view));
- VkFramebufferCreateInfo fbci{ VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO };
- fbci.renderPass = geo_render_pass; fbci.attachmentCount = 1; fbci.pAttachments = &t.view;
- fbci.width = w; fbci.height = h; fbci.layers = 1;
- VK_CHECK(vkCreateFramebuffer(device, &fbci, nullptr, &t.fb));
- return true;
- }
-
- auto VulkanRenderer::Impl::create_geodesic_resources() -> bool
- {
- const VkFormat fmt = VK_FORMAT_R8G8B8A8_UNORM;
- const VkMemoryPropertyFlags host_vis = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
- const float SagA_rs = 1.269e10f;
-
- VkAttachmentDescription color{};
- color.format = fmt; color.samples = VK_SAMPLE_COUNT_1_BIT;
- color.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; color.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
- color.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; color.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
- color.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; color.finalLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
- VkAttachmentReference ref{ 0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL };
- VkSubpassDescription subpass{}; subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
- subpass.colorAttachmentCount = 1; subpass.pColorAttachments = &ref;
- VkSubpassDependency deps[2]{};
- deps[0].srcSubpass = VK_SUBPASS_EXTERNAL; deps[0].dstSubpass = 0;
- deps[0].srcStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT; deps[0].srcAccessMask = VK_ACCESS_SHADER_READ_BIT;
- deps[0].dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; deps[0].dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
- deps[1].srcSubpass = 0; deps[1].dstSubpass = VK_SUBPASS_EXTERNAL;
- deps[1].srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; deps[1].srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
- deps[1].dstStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT; deps[1].dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
- VkRenderPassCreateInfo rpci{ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO };
- rpci.attachmentCount = 1; rpci.pAttachments = &color;
- rpci.subpassCount = 1; rpci.pSubpasses = &subpass;
- rpci.dependencyCount = 2; rpci.pDependencies = deps;
- VK_CHECK(vkCreateRenderPass(device, &rpci, nullptr, &geo_render_pass));
-
- if (!create_geo_target(geo_lo, GEO_LO_W, GEO_LO_H)) return false;
- if (!create_geo_target(geo_hi, GEO_HI_W, GEO_HI_H)) return false;
-
- create_buffer(128, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, host_vis, cam_buf, cam_mem);
- create_buffer(32, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, host_vis, disk_buf, disk_mem);
- create_buffer(800, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, host_vis, obj_buf, obj_mem);
- create_buffer(16, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, host_vis, sim_buf, sim_mem);
-
- camera.set_camera_mode(CameraMode::Orbital);
- camera.set_orbital_target(glm::vec3(0.0f));
- camera.set_orbital_radius(4e11); // ~31 r_s: outside the 12 r_s disk
- camera.set_orbital_limits(2.2e11, 1.5e12);
- camera.set_orbital_speed(0.01f);
- camera.set_zoom_speed(3e10);
- camera.set_azimuth(0.0f);
- camera.set_elevation(1.25f);
-
- void* p = nullptr;
- vkMapMemory(device, cam_mem, 0, 128, 0, &cam_mapped); // camera UBO refilled every frame
- vkMapMemory(device, disk_mem, 0, 32, 0, &disk_mapped); // disk UBO refilled from bh_params every frame
-
- std::vector<uint8_t> obj_data(800, 0);
- int num_objects = 1; memcpy(obj_data.data(), &num_objects, 4);
- float pos_radius[4] = { 0, 0, 0, SagA_rs }; memcpy(obj_data.data() + 16, pos_radius, 16);
- float obj_color[4] = { 0, 0, 0, 1 }; memcpy(obj_data.data() + 272, obj_color, 16);
- vkMapMemory(device, obj_mem, 0, 800, 0, &p); memcpy(p, obj_data.data(), 800); vkUnmapMemory(device, obj_mem);
-
- vkMapMemory(device, sim_mem, 0, 16, 0, &sim_mapped);
-
- if (!create_hdri_cubemap("assets/hdri/HDR_blue_nebulae-1.hdr")) return false;
-
- VkDescriptorSetLayoutBinding binds[5]{};
- for (int i = 0; i < 4; ++i) { binds[i].binding = i; binds[i].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; binds[i].descriptorCount = 1; binds[i].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT; }
- binds[4].binding = 4; binds[4].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; binds[4].descriptorCount = 1; binds[4].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
- VkDescriptorSetLayoutCreateInfo dslci{ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO };
- dslci.bindingCount = 5; dslci.pBindings = binds;
- VK_CHECK(vkCreateDescriptorSetLayout(device, &dslci, nullptr, &geo_set_layout));
- VkDescriptorPoolSize psizes[2] = { { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 4 }, { VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1 } };
- VkDescriptorPoolCreateInfo dpci{ VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO };
- dpci.maxSets = 1; dpci.poolSizeCount = 2; dpci.pPoolSizes = psizes;
- VK_CHECK(vkCreateDescriptorPool(device, &dpci, nullptr, &geo_pool));
- VkDescriptorSetAllocateInfo dsai{ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO };
- dsai.descriptorPool = geo_pool; dsai.descriptorSetCount = 1; dsai.pSetLayouts = &geo_set_layout;
- VK_CHECK(vkAllocateDescriptorSets(device, &dsai, &geo_set));
- VkDescriptorBufferInfo bi[4] = { { cam_buf, 0, VK_WHOLE_SIZE }, { disk_buf, 0, VK_WHOLE_SIZE }, { obj_buf, 0, VK_WHOLE_SIZE }, { sim_buf, 0, VK_WHOLE_SIZE } };
- VkDescriptorImageInfo cube_info{ cube_sampler, cube_view, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL };
- VkWriteDescriptorSet writes[5]{};
- for (int i = 0; i < 4; ++i) { writes[i].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; writes[i].dstSet = geo_set; writes[i].dstBinding = i; writes[i].descriptorCount = 1; writes[i].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; writes[i].pBufferInfo = &bi[i]; }
- writes[4].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; writes[4].dstSet = geo_set; writes[4].dstBinding = 4; writes[4].descriptorCount = 1; writes[4].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; writes[4].pImageInfo = &cube_info;
- vkUpdateDescriptorSets(device, 5, writes, 0, nullptr);
-
- float quad[] = {
- -1.f, 1.f, 0.f, 1.f, -1.f, -1.f, 0.f, 0.f, 1.f, -1.f, 1.f, 0.f,
- -1.f, 1.f, 0.f, 1.f, 1.f, -1.f, 1.f, 0.f, 1.f, 1.f, 1.f, 1.f,
- };
- create_buffer(sizeof(quad), VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, host_vis, quad_vb, quad_vb_mem);
- vkMapMemory(device, quad_vb_mem, 0, sizeof(quad), 0, &p); memcpy(p, quad, sizeof(quad)); vkUnmapMemory(device, quad_vb_mem);
-
- VkShaderModule vmod, fmod;
- if (!create_shader_module("assets/shaders/generated/Geodesic.vertexMain.spv", vmod)) return false;
- if (!create_shader_module("assets/shaders/generated/Geodesic.fragmentMain.spv", fmod)) return false;
- VkPipelineLayoutCreateInfo plci{ VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO };
- plci.setLayoutCount = 1; plci.pSetLayouts = &geo_set_layout;
- VK_CHECK(vkCreatePipelineLayout(device, &plci, nullptr, &geo_pipeline_layout));
- VkPipelineShaderStageCreateInfo stages[2]{};
- stages[0].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; stages[0].stage = VK_SHADER_STAGE_VERTEX_BIT; stages[0].module = vmod; stages[0].pName = "main";
- stages[1].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; stages[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT; stages[1].module = fmod; stages[1].pName = "main";
- VkVertexInputBindingDescription vib{ 0, 16, VK_VERTEX_INPUT_RATE_VERTEX };
- VkVertexInputAttributeDescription via[2] = { { 0, 0, VK_FORMAT_R32G32_SFLOAT, 0 }, { 1, 0, VK_FORMAT_R32G32_SFLOAT, 8 } };
- VkPipelineVertexInputStateCreateInfo vin{ VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO };
- vin.vertexBindingDescriptionCount = 1; vin.pVertexBindingDescriptions = &vib;
- vin.vertexAttributeDescriptionCount = 2; vin.pVertexAttributeDescriptions = via;
- VkPipelineInputAssemblyStateCreateInfo ia{ VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO }; ia.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
- // Dynamic viewport/scissor: the same pipeline renders into either the
- // low- or high-res target, sized per frame in record_command_buffer.
- VkPipelineViewportStateCreateInfo vps{ VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO }; vps.viewportCount = 1; vps.scissorCount = 1;
- VkDynamicState dyn_states[2] = { VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR };
- VkPipelineDynamicStateCreateInfo dyn{ VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO }; dyn.dynamicStateCount = 2; dyn.pDynamicStates = dyn_states;
- VkPipelineRasterizationStateCreateInfo rs{ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO }; rs.polygonMode = VK_POLYGON_MODE_FILL; rs.cullMode = VK_CULL_MODE_NONE; rs.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE; rs.lineWidth = 1.0f;
- VkPipelineMultisampleStateCreateInfo ms{ VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO }; ms.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
- VkPipelineColorBlendAttachmentState cba{}; cba.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
- VkPipelineColorBlendStateCreateInfo cb{ VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO }; cb.attachmentCount = 1; cb.pAttachments = &cba;
- VkGraphicsPipelineCreateInfo gpci{ VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO };
- gpci.stageCount = 2; gpci.pStages = stages;
- gpci.pVertexInputState = &vin; gpci.pInputAssemblyState = &ia; gpci.pViewportState = &vps;
- gpci.pRasterizationState = &rs; gpci.pMultisampleState = &ms; gpci.pColorBlendState = &cb;
- gpci.pDynamicState = &dyn;
- gpci.layout = geo_pipeline_layout; gpci.renderPass = geo_render_pass; gpci.subpass = 0;
- VkResult pr = vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &gpci, nullptr, &geo_pipeline);
- vkDestroyShaderModule(device, vmod, nullptr); vkDestroyShaderModule(device, fmod, nullptr);
- if (pr != VK_SUCCESS) { DONUT_ERROR("Vulkan: geodesic pipeline creation failed ({})", (int)pr); return false; }
-
- start_time = glfwGetTime();
- update_geodesic_uniforms();
- DONUT_INFO("Vulkan: geodesic resources ready ({}x{} moving / {}x{} settled)",
- (int)GEO_LO_W, (int)GEO_LO_H, (int)GEO_HI_W, (int)GEO_HI_H);
- return true;
- }
-
- auto VulkanRenderer::Impl::create_hdri_cubemap(const char* path) -> bool
- {
- hdri_path = path;
- const VkMemoryPropertyFlags host_vis = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
- const uint32_t FACE = 1024;
- const VkFormat cube_fmt = VK_FORMAT_R16G16B16A16_SFLOAT;
- uint32_t CUBE_MIPS = 1; for (uint32_t s = FACE; s > 1; s >>= 1) ++CUBE_MIPS; // full chain (11 for 1024)
-
- VkImageCreateInfo cci{ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
- cci.flags = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
- cci.imageType = VK_IMAGE_TYPE_2D; cci.format = cube_fmt; cci.extent = { FACE, FACE, 1 };
- cci.mipLevels = CUBE_MIPS; cci.arrayLayers = 6; cci.samples = VK_SAMPLE_COUNT_1_BIT;
- cci.tiling = VK_IMAGE_TILING_OPTIMAL;
- // COLOR_ATTACHMENT renders the 6 faces (mip 0); TRANSFER_SRC/DST build the
- // mip chain by blitting; SAMPLED for shader reads (incl. mip-LOD sampling).
- cci.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT
- | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
- VK_CHECK(vkCreateImage(device, &cci, nullptr, &cube_image));
- VkMemoryRequirements creq{}; vkGetImageMemoryRequirements(device, cube_image, &creq);
- VkMemoryAllocateInfo cai{ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
- cai.allocationSize = creq.size; cai.memoryTypeIndex = find_memory_type(creq.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
- VK_CHECK(vkAllocateMemory(device, &cai, nullptr, &cube_mem));
- VK_CHECK(vkBindImageMemory(device, cube_image, cube_mem, 0));
- VkImageViewCreateInfo cvci{ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO };
- cvci.image = cube_image; cvci.viewType = VK_IMAGE_VIEW_TYPE_CUBE; cvci.format = cube_fmt;
- cvci.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, CUBE_MIPS, 0, 6 };
- VK_CHECK(vkCreateImageView(device, &cvci, nullptr, &cube_view));
- VkSamplerCreateInfo csm{ VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO };
- csm.magFilter = VK_FILTER_LINEAR; csm.minFilter = VK_FILTER_LINEAR;
- csm.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR; csm.minLod = 0.0f; csm.maxLod = (float)CUBE_MIPS;
- csm.addressModeU = csm.addressModeV = csm.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
- VK_CHECK(vkCreateSampler(device, &csm, nullptr, &cube_sampler));
-
- int w = 0, h = 0, ch = 0;
- float* pixels = stbi_loadf(path, &w, &h, &ch, 4);
- if (!pixels)
- {
- DONUT_WARN("Vulkan: HDRI '{}' could not be loaded; using a dark background", path);
- VkCommandBufferAllocateInfo cbai{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO };
- cbai.commandPool = command_pool; cbai.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; cbai.commandBufferCount = 1;
- VkCommandBuffer cmd; VK_CHECK(vkAllocateCommandBuffers(device, &cbai, &cmd));
- VkCommandBufferBeginInfo bi{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO }; bi.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
- vkBeginCommandBuffer(cmd, &bi);
- VkImageMemoryBarrier tb{ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER };
- tb.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED; tb.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
- tb.image = cube_image; tb.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 6 };
- tb.srcAccessMask = 0; tb.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
- vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &tb);
- VkClearColorValue dark{}; dark.float32[0] = 0.02f; dark.float32[1] = 0.02f; dark.float32[2] = 0.05f; dark.float32[3] = 1.0f;
- VkImageSubresourceRange rng{ VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 6 };
- vkCmdClearColorImage(cmd, cube_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &dark, 1, &rng);
- VkImageMemoryBarrier rb = tb; rb.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; rb.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
- rb.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; rb.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
- vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, 0, nullptr, 0, nullptr, 1, &rb);
- vkEndCommandBuffer(cmd);
- VkSubmitInfo si{ VK_STRUCTURE_TYPE_SUBMIT_INFO }; si.commandBufferCount = 1; si.pCommandBuffers = &cmd;
- vkQueueSubmit(graphics_queue, 1, &si, VK_NULL_HANDLE); vkQueueWaitIdle(graphics_queue);
- vkFreeCommandBuffers(device, command_pool, 1, &cmd);
- return true;
- }
-
- // Apple GPUs can't linearly filter RGBA32F, so store the equirect as
- // RGBA16F (convert the loaded floats to half on the way into staging).
- const VkFormat eq_fmt = VK_FORMAT_R16G16B16A16_SFLOAT;
- size_t texel_count = (size_t)w * h * 4;
- VkDeviceSize eq_size = (VkDeviceSize)texel_count * sizeof(uint16_t);
- VkBuffer eq_staging; VkDeviceMemory eq_staging_mem;
- if (!create_buffer(eq_size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, host_vis, eq_staging, eq_staging_mem)) { stbi_image_free(pixels); return false; }
- void* mp = nullptr; vkMapMemory(device, eq_staging_mem, 0, eq_size, 0, &mp);
- uint16_t* dst = (uint16_t*)mp;
- for (size_t i = 0; i < texel_count; ++i) { __fp16 hf = (__fp16)pixels[i]; memcpy(&dst[i], &hf, sizeof(uint16_t)); }
- vkUnmapMemory(device, eq_staging_mem);
- stbi_image_free(pixels);
-
- VkImage eq_image; VkDeviceMemory eq_mem;
- VkImageCreateInfo eci{ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
- eci.imageType = VK_IMAGE_TYPE_2D; eci.format = eq_fmt; eci.extent = { (uint32_t)w, (uint32_t)h, 1 };
- eci.mipLevels = 1; eci.arrayLayers = 1; eci.samples = VK_SAMPLE_COUNT_1_BIT;
- eci.tiling = VK_IMAGE_TILING_OPTIMAL; eci.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
- VK_CHECK(vkCreateImage(device, &eci, nullptr, &eq_image));
- VkMemoryRequirements ereq{}; vkGetImageMemoryRequirements(device, eq_image, &ereq);
- VkMemoryAllocateInfo eai{ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
- eai.allocationSize = ereq.size; eai.memoryTypeIndex = find_memory_type(ereq.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
- VK_CHECK(vkAllocateMemory(device, &eai, nullptr, &eq_mem));
- VK_CHECK(vkBindImageMemory(device, eq_image, eq_mem, 0));
- VkImageView eq_view;
- VkImageViewCreateInfo evci{ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO };
- evci.image = eq_image; evci.viewType = VK_IMAGE_VIEW_TYPE_2D; evci.format = eq_fmt;
- evci.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
- VK_CHECK(vkCreateImageView(device, &evci, nullptr, &eq_view));
- VkSampler eq_sampler;
- VkSamplerCreateInfo esm{ VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO };
- esm.magFilter = VK_FILTER_LINEAR; esm.minFilter = VK_FILTER_LINEAR;
- esm.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT; // longitude wraps
- esm.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE; // latitude clamps
- esm.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
- VK_CHECK(vkCreateSampler(device, &esm, nullptr, &eq_sampler));
-
- VkImageView face_views[6];
- for (uint32_t i = 0; i < 6; ++i)
- {
- VkImageViewCreateInfo fvci{ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO };
- fvci.image = cube_image; fvci.viewType = VK_IMAGE_VIEW_TYPE_2D; fvci.format = cube_fmt;
- fvci.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, i, 1 };
- VK_CHECK(vkCreateImageView(device, &fvci, nullptr, &face_views[i]));
- }
-
- VkAttachmentDescription color{};
- color.format = cube_fmt; color.samples = VK_SAMPLE_COUNT_1_BIT;
- color.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; color.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
- color.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; color.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
- color.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; color.finalLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
- VkAttachmentReference ref{ 0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL };
- VkSubpassDescription subpass{}; subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS; subpass.colorAttachmentCount = 1; subpass.pColorAttachments = &ref;
- VkSubpassDependency dep{}; dep.srcSubpass = 0; dep.dstSubpass = VK_SUBPASS_EXTERNAL;
- dep.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; dep.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
- dep.dstStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT; dep.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
- VkRenderPass rp;
- VkRenderPassCreateInfo rpci{ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO };
- rpci.attachmentCount = 1; rpci.pAttachments = &color; rpci.subpassCount = 1; rpci.pSubpasses = &subpass; rpci.dependencyCount = 1; rpci.pDependencies = &dep;
- VK_CHECK(vkCreateRenderPass(device, &rpci, nullptr, &rp));
- VkFramebuffer face_fb[6];
- for (uint32_t i = 0; i < 6; ++i)
- {
- VkFramebufferCreateInfo fbci{ VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO };
- fbci.renderPass = rp; fbci.attachmentCount = 1; fbci.pAttachments = &face_views[i]; fbci.width = FACE; fbci.height = FACE; fbci.layers = 1;
- VK_CHECK(vkCreateFramebuffer(device, &fbci, nullptr, &face_fb[i]));
- }
-
- VkDescriptorSetLayoutBinding binds[2]{};
- binds[0].binding = 0; binds[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; binds[0].descriptorCount = 1; binds[0].stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
- binds[1].binding = 1; binds[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; binds[1].descriptorCount = 1; binds[1].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
- VkDescriptorSetLayout set_layout;
- VkDescriptorSetLayoutCreateInfo dslci{ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO }; dslci.bindingCount = 2; dslci.pBindings = binds;
- VK_CHECK(vkCreateDescriptorSetLayout(device, &dslci, nullptr, &set_layout));
- VkDescriptorPoolSize psizes[2] = { { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 6 }, { VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 6 } };
- VkDescriptorPool pool;
- VkDescriptorPoolCreateInfo dpci{ VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO }; dpci.maxSets = 6; dpci.poolSizeCount = 2; dpci.pPoolSizes = psizes;
- VK_CHECK(vkCreateDescriptorPool(device, &dpci, nullptr, &pool));
-
- VkShaderModule vmod, fmod;
- if (!create_shader_module("assets/shaders/generated/EquirectToCubemap.vertexMain.spv", vmod)) return false;
- if (!create_shader_module("assets/shaders/generated/EquirectToCubemap.fragmentMain.spv", fmod)) return false;
- VkPipelineLayout playout;
- VkPipelineLayoutCreateInfo plci{ VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO }; plci.setLayoutCount = 1; plci.pSetLayouts = &set_layout;
- VK_CHECK(vkCreatePipelineLayout(device, &plci, nullptr, &playout));
- VkPipelineShaderStageCreateInfo stages[2]{};
- stages[0].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; stages[0].stage = VK_SHADER_STAGE_VERTEX_BIT; stages[0].module = vmod; stages[0].pName = "main";
- stages[1].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; stages[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT; stages[1].module = fmod; stages[1].pName = "main";
- VkVertexInputBindingDescription vib{ 0, 12, VK_VERTEX_INPUT_RATE_VERTEX };
- VkVertexInputAttributeDescription via{ 0, 0, VK_FORMAT_R32G32B32_SFLOAT, 0 };
- VkPipelineVertexInputStateCreateInfo vin{ VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO };
- vin.vertexBindingDescriptionCount = 1; vin.pVertexBindingDescriptions = &vib; vin.vertexAttributeDescriptionCount = 1; vin.pVertexAttributeDescriptions = &via;
- VkPipelineInputAssemblyStateCreateInfo ia{ VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO }; ia.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
- VkViewport vp{ 0, 0, (float)FACE, (float)FACE, 0, 1 }; VkRect2D sc{ { 0, 0 }, { FACE, FACE } };
- VkPipelineViewportStateCreateInfo vps{ VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO }; vps.viewportCount = 1; vps.pViewports = &vp; vps.scissorCount = 1; vps.pScissors = &sc;
- VkPipelineRasterizationStateCreateInfo rs{ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO }; rs.polygonMode = VK_POLYGON_MODE_FILL; rs.cullMode = VK_CULL_MODE_NONE; rs.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE; rs.lineWidth = 1.0f;
- VkPipelineMultisampleStateCreateInfo ms{ VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO }; ms.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
- VkPipelineColorBlendAttachmentState cba{}; cba.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
- VkPipelineColorBlendStateCreateInfo cb{ VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO }; cb.attachmentCount = 1; cb.pAttachments = &cba;
- VkPipeline pipeline;
- VkGraphicsPipelineCreateInfo gpci{ VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO };
- gpci.stageCount = 2; gpci.pStages = stages; gpci.pVertexInputState = &vin; gpci.pInputAssemblyState = &ia; gpci.pViewportState = &vps;
- gpci.pRasterizationState = &rs; gpci.pMultisampleState = &ms; gpci.pColorBlendState = &cb; gpci.layout = playout; gpci.renderPass = rp; gpci.subpass = 0;
- VkResult pr = vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &gpci, nullptr, &pipeline);
- vkDestroyShaderModule(device, vmod, nullptr); vkDestroyShaderModule(device, fmod, nullptr);
- if (pr != VK_SUCCESS) { DONUT_ERROR("Vulkan: equirect pipeline failed ({})", (int)pr); return false; }
-
- float cube_verts[] = {
- -1,1,-1, -1,-1,-1, 1,-1,-1, 1,-1,-1, 1,1,-1, -1,1,-1,
- -1,-1,1, -1,-1,-1, -1,1,-1, -1,1,-1, -1,1,1, -1,-1,1,
- 1,-1,-1, 1,-1,1, 1,1,1, 1,1,1, 1,1,-1, 1,-1,-1,
- -1,-1,1, -1,1,1, 1,1,1, 1,1,1, 1,-1,1, -1,-1,1,
- -1,1,-1, 1,1,-1, 1,1,1, 1,1,1, -1,1,1, -1,1,-1,
- -1,-1,-1, -1,-1,1, 1,-1,-1, 1,-1,-1, -1,-1,1, 1,-1,1,
- };
- VkBuffer cube_vb; VkDeviceMemory cube_vb_mem;
- create_buffer(sizeof(cube_verts), VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, host_vis, cube_vb, cube_vb_mem);
- vkMapMemory(device, cube_vb_mem, 0, sizeof(cube_verts), 0, &mp); memcpy(mp, cube_verts, sizeof(cube_verts)); vkUnmapMemory(device, cube_vb_mem);
-
- glm::mat4 proj = glm::perspective(glm::radians(90.0f), 1.0f, 0.1f, 10.0f);
- proj[1][1] *= -1.0f; // Vulkan clip space is Y-down vs OpenGL
- glm::mat4 views[6] = {
- glm::lookAt(glm::vec3(0), glm::vec3( 1, 0, 0), glm::vec3(0, -1, 0)),
- glm::lookAt(glm::vec3(0), glm::vec3(-1, 0, 0), glm::vec3(0, -1, 0)),
- glm::lookAt(glm::vec3(0), glm::vec3( 0, 1, 0), glm::vec3(0, 0, 1)),
- glm::lookAt(glm::vec3(0), glm::vec3( 0, -1, 0), glm::vec3(0, 0, -1)),
- glm::lookAt(glm::vec3(0), glm::vec3( 0, 0, 1), glm::vec3(0, -1, 0)),
- glm::lookAt(glm::vec3(0), glm::vec3( 0, 0, -1), glm::vec3(0, -1, 0)),
- };
- VkBuffer ubo[6]; VkDeviceMemory ubo_mem[6]; VkDescriptorSet sets[6];
- for (uint32_t i = 0; i < 6; ++i)
- {
- create_buffer(128, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, host_vis, ubo[i], ubo_mem[i]);
- glm::mat4 mats[2] = { glm::transpose(proj), glm::transpose(views[i]) }; // SPIR-V expects row-major
- vkMapMemory(device, ubo_mem[i], 0, 128, 0, &mp); memcpy(mp, mats, 128); vkUnmapMemory(device, ubo_mem[i]);
- VkDescriptorSetAllocateInfo dsai{ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO }; dsai.descriptorPool = pool; dsai.descriptorSetCount = 1; dsai.pSetLayouts = &set_layout;
- VK_CHECK(vkAllocateDescriptorSets(device, &dsai, &sets[i]));
- VkDescriptorBufferInfo buf_info{ ubo[i], 0, VK_WHOLE_SIZE };
- VkDescriptorImageInfo img_info{ eq_sampler, eq_view, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL };
- VkWriteDescriptorSet ws[2]{};
- ws[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; ws[0].dstSet = sets[i]; ws[0].dstBinding = 0; ws[0].descriptorCount = 1; ws[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; ws[0].pBufferInfo = &buf_info;
- ws[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; ws[1].dstSet = sets[i]; ws[1].dstBinding = 1; ws[1].descriptorCount = 1; ws[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; ws[1].pImageInfo = &img_info;
- vkUpdateDescriptorSets(device, 2, ws, 0, nullptr);
- }
-
- VkCommandBufferAllocateInfo cbai{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO };
- cbai.commandPool = command_pool; cbai.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; cbai.commandBufferCount = 1;
- VkCommandBuffer cmd; VK_CHECK(vkAllocateCommandBuffers(device, &cbai, &cmd));
- VkCommandBufferBeginInfo bi{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO }; bi.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
- VK_CHECK(vkBeginCommandBuffer(cmd, &bi));
- VkImageMemoryBarrier to_dst{ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER };
- to_dst.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED; to_dst.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
- to_dst.image = eq_image; to_dst.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
- to_dst.srcAccessMask = 0; to_dst.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
- vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &to_dst);
- VkBufferImageCopy copy{}; copy.imageSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1 }; copy.imageExtent = { (uint32_t)w, (uint32_t)h, 1 };
- vkCmdCopyBufferToImage(cmd, eq_staging, eq_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &copy);
- VkImageMemoryBarrier to_read = to_dst; to_read.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; to_read.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
- to_read.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; to_read.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
- vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, 0, nullptr, 0, nullptr, 1, &to_read);
-
- VkClearValue clear{}; clear.color = { { 0, 0, 0, 1 } };
- for (uint32_t i = 0; i < 6; ++i)
- {
- VkRenderPassBeginInfo rpbi{ VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO };
- rpbi.renderPass = rp; rpbi.framebuffer = face_fb[i]; rpbi.renderArea = { { 0, 0 }, { FACE, FACE } }; rpbi.clearValueCount = 1; rpbi.pClearValues = &clear;
- vkCmdBeginRenderPass(cmd, &rpbi, VK_SUBPASS_CONTENTS_INLINE);
- vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
- vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, playout, 0, 1, &sets[i], 0, nullptr);
- VkDeviceSize off = 0; vkCmdBindVertexBuffers(cmd, 0, 1, &cube_vb, &off);
- vkCmdDraw(cmd, 36, 1, 0, 0);
- vkCmdEndRenderPass(cmd);
- }
-
- // Build the mip chain (all 6 faces) by successive linear down-blits, so
- // divergence-based LOD sampling can read a blurred sky for lensed rays.
- // Mip 0 (every layer) is SHADER_READ_ONLY from the render passes above.
- {
- VkImageMemoryBarrier src0{ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER };
- src0.image = cube_image; src0.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 6 };
- src0.oldLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; src0.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
- src0.srcAccessMask = VK_ACCESS_SHADER_READ_BIT; src0.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
- vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &src0);
-
- int32_t mipW = (int32_t)FACE, mipH = (int32_t)FACE;
- for (uint32_t m = 1; m < CUBE_MIPS; ++m)
- {
- int32_t nW = mipW > 1 ? mipW / 2 : 1, nH = mipH > 1 ? mipH / 2 : 1;
- VkImageMemoryBarrier bd{ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER };
- bd.image = cube_image; bd.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, m, 1, 0, 6 };
- bd.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED; bd.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
- bd.srcAccessMask = 0; bd.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
- vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &bd);
-
- VkImageBlit blit{};
- blit.srcOffsets[1] = { mipW, mipH, 1 }; blit.srcSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, m - 1, 0, 6 };
- blit.dstOffsets[1] = { nW, nH, 1 }; blit.dstSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, m, 0, 6 };
- vkCmdBlitImage(cmd, cube_image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
- cube_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &blit, VK_FILTER_LINEAR);
-
- VkImageMemoryBarrier bs{ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER };
- bs.image = cube_image; bs.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, m, 1, 0, 6 };
- bs.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; bs.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
- bs.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; bs.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
- vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &bs);
- mipW = nW; mipH = nH;
- }
- VkImageMemoryBarrier fin{ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER };
- fin.image = cube_image; fin.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, CUBE_MIPS, 0, 6 };
- fin.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL; fin.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
- fin.srcAccessMask = VK_ACCESS_TRANSFER_READ_BIT; fin.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
- vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, 0, nullptr, 0, nullptr, 1, &fin);
- }
-
- VK_CHECK(vkEndCommandBuffer(cmd));
- VkSubmitInfo si{ VK_STRUCTURE_TYPE_SUBMIT_INFO }; si.commandBufferCount = 1; si.pCommandBuffers = &cmd;
- VK_CHECK(vkQueueSubmit(graphics_queue, 1, &si, VK_NULL_HANDLE));
- VK_CHECK(vkQueueWaitIdle(graphics_queue));
-
- vkFreeCommandBuffers(device, command_pool, 1, &cmd);
- for (uint32_t i = 0; i < 6; ++i) { vkDestroyBuffer(device, ubo[i], nullptr); vkFreeMemory(device, ubo_mem[i], nullptr); vkDestroyFramebuffer(device, face_fb[i], nullptr); vkDestroyImageView(device, face_views[i], nullptr); }
- vkDestroyBuffer(device, cube_vb, nullptr); vkFreeMemory(device, cube_vb_mem, nullptr);
- vkDestroyPipeline(device, pipeline, nullptr); vkDestroyPipelineLayout(device, playout, nullptr);
- vkDestroyDescriptorPool(device, pool, nullptr); vkDestroyDescriptorSetLayout(device, set_layout, nullptr);
- vkDestroyRenderPass(device, rp, nullptr);
- vkDestroySampler(device, eq_sampler, nullptr); vkDestroyImageView(device, eq_view, nullptr);
- vkDestroyImage(device, eq_image, nullptr); vkFreeMemory(device, eq_mem, nullptr);
- vkDestroyBuffer(device, eq_staging, nullptr); vkFreeMemory(device, eq_staging_mem, nullptr);
- DONUT_INFO("Vulkan: HDRI cubemap built from {} ({}x{} equirect -> {}^2 cube)", path, w, h, (int)FACE);
- return true;
- }
-
- // Runtime HDRI switch: drain the device, tear down the old cubemap, build the
- // new one, and repoint the geodesic set's samplerCube (binding 4) at it.
- auto VulkanRenderer::Impl::rebuild_hdri_cubemap(const char* path) -> void
- {
- vkDeviceWaitIdle(device);
-
- if (cube_sampler) vkDestroySampler(device, cube_sampler, nullptr);
- if (cube_view) vkDestroyImageView(device, cube_view, nullptr);
- if (cube_image) vkDestroyImage(device, cube_image, nullptr);
- if (cube_mem) vkFreeMemory(device, cube_mem, nullptr);
- cube_sampler = VK_NULL_HANDLE; cube_view = VK_NULL_HANDLE;
- cube_image = VK_NULL_HANDLE; cube_mem = VK_NULL_HANDLE;
-
- create_hdri_cubemap(path);
-
- VkDescriptorImageInfo cube_info{ cube_sampler, cube_view, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL };
- VkWriteDescriptorSet write{ VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET };
- write.dstSet = geo_set; write.dstBinding = 4; write.descriptorCount = 1;
- write.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; write.pImageInfo = &cube_info;
- vkUpdateDescriptorSets(device, 1, &write, 0, nullptr);
-
- // The scene sphere samples the same cube (binding 1) — repoint it too.
- if (sphere_set)
- {
- VkWriteDescriptorSet sw{ VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET };
- sw.dstSet = sphere_set; sw.dstBinding = 1; sw.descriptorCount = 1;
- sw.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; sw.pImageInfo = &cube_info;
- vkUpdateDescriptorSets(device, 1, &sw, 0, nullptr);
- }
- if (skybox_set)
- {
- VkWriteDescriptorSet kw{ VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET };
- kw.dstSet = skybox_set; kw.dstBinding = 1; kw.descriptorCount = 1;
- kw.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; kw.pImageInfo = &cube_info;
- vkUpdateDescriptorSets(device, 1, &kw, 0, nullptr);
- }
- }
-
- auto VulkanRenderer::Impl::create_present_resources() -> bool
- {
- VkSamplerCreateInfo smci{ VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO };
- smci.magFilter = VK_FILTER_LINEAR; smci.minFilter = VK_FILTER_LINEAR;
- smci.addressModeU = smci.addressModeV = smci.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
- VK_CHECK(vkCreateSampler(device, &smci, nullptr, &present_sampler));
-
- VkDescriptorSetLayoutBinding bind{}; bind.binding = 0; bind.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; bind.descriptorCount = 1; bind.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
- VkDescriptorSetLayoutCreateInfo dslci{ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO };
- dslci.bindingCount = 1; dslci.pBindings = &bind;
- VK_CHECK(vkCreateDescriptorSetLayout(device, &dslci, nullptr, &present_set_layout));
- // One present set per geodesic target (low-/high-res), each sampling its
- // own image; record_command_buffer binds whichever was rendered this frame.
- VkDescriptorPoolSize psize{ VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 2 };
- VkDescriptorPoolCreateInfo dpci{ VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO };
- dpci.maxSets = 2; dpci.poolSizeCount = 1; dpci.pPoolSizes = &psize;
- VK_CHECK(vkCreateDescriptorPool(device, &dpci, nullptr, &present_pool));
- for (GeoTarget* t : { &geo_lo, &geo_hi })
- {
- VkDescriptorSetAllocateInfo dsai{ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO };
- dsai.descriptorPool = present_pool; dsai.descriptorSetCount = 1; dsai.pSetLayouts = &present_set_layout;
- VK_CHECK(vkAllocateDescriptorSets(device, &dsai, &t->present_set));
- VkDescriptorImageInfo ii{ present_sampler, t->view, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL };
- VkWriteDescriptorSet write{ VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET };
- write.dstSet = t->present_set; write.dstBinding = 0; write.descriptorCount = 1; write.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; write.pImageInfo = &ii;
- vkUpdateDescriptorSets(device, 1, &write, 0, nullptr);
- }
-
- VkShaderModule vmod, fmod;
- if (!create_shader_module("assets/shaders/generated/TexturedQuad.vertexMain.spv", vmod)) return false;
- if (!create_shader_module("assets/shaders/generated/TexturedQuad.fragmentMain.spv", fmod)) return false;
- VkPipelineLayoutCreateInfo plci{ VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO };
- plci.setLayoutCount = 1; plci.pSetLayouts = &present_set_layout;
- VK_CHECK(vkCreatePipelineLayout(device, &plci, nullptr, &present_pipeline_layout));
- VkPipelineShaderStageCreateInfo stages[2]{};
- stages[0].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; stages[0].stage = VK_SHADER_STAGE_VERTEX_BIT; stages[0].module = vmod; stages[0].pName = "main";
- stages[1].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; stages[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT; stages[1].module = fmod; stages[1].pName = "main";
- VkVertexInputBindingDescription vib{ 0, 16, VK_VERTEX_INPUT_RATE_VERTEX };
- VkVertexInputAttributeDescription via[2] = { { 0, 0, VK_FORMAT_R32G32_SFLOAT, 0 }, { 1, 0, VK_FORMAT_R32G32_SFLOAT, 8 } };
- VkPipelineVertexInputStateCreateInfo vin{ VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO };
- vin.vertexBindingDescriptionCount = 1; vin.pVertexBindingDescriptions = &vib;
- vin.vertexAttributeDescriptionCount = 2; vin.pVertexAttributeDescriptions = via;
- VkPipelineInputAssemblyStateCreateInfo ia{ VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO }; ia.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
- VkPipelineViewportStateCreateInfo vps{ VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO }; vps.viewportCount = 1; vps.scissorCount = 1;
- VkDynamicState dyn[2] = { VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR };
- VkPipelineDynamicStateCreateInfo dsci{ VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO }; dsci.dynamicStateCount = 2; dsci.pDynamicStates = dyn;
- VkPipelineRasterizationStateCreateInfo rs{ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO }; rs.polygonMode = VK_POLYGON_MODE_FILL; rs.cullMode = VK_CULL_MODE_NONE; rs.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE; rs.lineWidth = 1.0f;
- VkPipelineMultisampleStateCreateInfo ms{ VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO }; ms.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
- VkPipelineColorBlendAttachmentState cba{}; cba.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
- VkPipelineColorBlendStateCreateInfo cb{ VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO }; cb.attachmentCount = 1; cb.pAttachments = &cba;
- VkGraphicsPipelineCreateInfo gpci{ VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO };
- gpci.stageCount = 2; gpci.pStages = stages;
- gpci.pVertexInputState = &vin; gpci.pInputAssemblyState = &ia; gpci.pViewportState = &vps;
- gpci.pDynamicState = &dsci;
- gpci.pRasterizationState = &rs; gpci.pMultisampleState = &ms; gpci.pColorBlendState = &cb;
- gpci.layout = present_pipeline_layout; gpci.renderPass = render_pass; gpci.subpass = 0;
- VkResult pr = vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &gpci, nullptr, &present_pipeline);
- vkDestroyShaderModule(device, vmod, nullptr); vkDestroyShaderModule(device, fmod, nullptr);
- if (pr != VK_SUCCESS) { DONUT_ERROR("Vulkan: present pipeline creation failed ({})", (int)pr); return false; }
- DONUT_INFO("Vulkan: present pipeline ready");
- return true;
- }
-
- auto VulkanRenderer::Impl::create_scene_resources() -> bool
- {
- const VkMemoryPropertyFlags host_vis = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
-
- // Scene camera: normal-scale orbital viewer (matches the OpenGL world-builder).
- scene_camera.set_camera_mode(CameraMode::Orbital);
- scene_camera.set_orbital_target(glm::vec3(0.0f));
- scene_camera.set_orbital_radius(15.0);
- scene_camera.set_orbital_limits(2.0, 200.0);
- scene_camera.set_orbital_speed(0.01f);
- scene_camera.set_zoom_speed(2.0);
- scene_camera.set_azimuth(0.0f);
- scene_camera.set_elevation((float)std::numbers::pi / 3.0f);
- scene_camera.update_orbital();
-
- // Line grid on the XZ plane (+/-50 units, 1-unit cells). Grid.slang scales
- // the position by u_GridSize/50, so u_GridSize = 50 keeps it 1:1.
- std::vector<glm::vec3> lines;
- const int N = 50;
- for (int i = -N; i <= N; ++i)
- {
- lines.push_back({ (float)i, 0.0f, (float)-N });
- lines.push_back({ (float)i, 0.0f, (float) N });
- lines.push_back({ (float)-N, 0.0f, (float)i });
- lines.push_back({ (float) N, 0.0f, (float)i });
- }
- grid_vertex_count = (uint32_t)lines.size();
- VkDeviceSize vbsize = lines.size() * sizeof(glm::vec3);
- if (!create_buffer(vbsize, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, host_vis, grid_vb, grid_vb_mem)) return false;
- void* mp = nullptr; vkMapMemory(device, grid_vb_mem, 0, vbsize, 0, &mp); memcpy(mp, lines.data(), vbsize); vkUnmapMemory(device, grid_vb_mem);
-
- // $Globals UBO (set 0, binding 0), std140, 176 bytes; refilled each frame.
- if (!create_buffer(176, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, host_vis, grid_ubo, grid_ubo_mem)) return false;
- vkMapMemory(device, grid_ubo_mem, 0, 176, 0, &grid_ubo_mapped);
-
- VkDescriptorSetLayoutBinding b{}; b.binding = 0; b.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; b.descriptorCount = 1; b.stageFlags = VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT;
- VkDescriptorSetLayoutCreateInfo dslci{ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO }; dslci.bindingCount = 1; dslci.pBindings = &b;
- VK_CHECK(vkCreateDescriptorSetLayout(device, &dslci, nullptr, &grid_set_layout));
- VkDescriptorPoolSize psize{ VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1 };
- VkDescriptorPoolCreateInfo dpci{ VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO }; dpci.maxSets = 1; dpci.poolSizeCount = 1; dpci.pPoolSizes = &psize;
- VK_CHECK(vkCreateDescriptorPool(device, &dpci, nullptr, &grid_pool));
- VkDescriptorSetAllocateInfo dsai{ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO }; dsai.descriptorPool = grid_pool; dsai.descriptorSetCount = 1; dsai.pSetLayouts = &grid_set_layout;
- VK_CHECK(vkAllocateDescriptorSets(device, &dsai, &grid_set));
- VkDescriptorBufferInfo bi{ grid_ubo, 0, VK_WHOLE_SIZE };
- VkWriteDescriptorSet w{ VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET }; w.dstSet = grid_set; w.dstBinding = 0; w.descriptorCount = 1; w.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; w.pBufferInfo = &bi;
- vkUpdateDescriptorSets(device, 1, &w, 0, nullptr);
-
- VkShaderModule vmod, fmod;
- if (!create_shader_module("assets/shaders/generated/Grid.vertexMain.spv", vmod)) return false;
- if (!create_shader_module("assets/shaders/generated/Grid.fragmentMain.spv", fmod)) return false;
- VkPipelineLayoutCreateInfo plci{ VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO }; plci.setLayoutCount = 1; plci.pSetLayouts = &grid_set_layout;
- VK_CHECK(vkCreatePipelineLayout(device, &plci, nullptr, &grid_pipeline_layout));
- VkPipelineShaderStageCreateInfo stages[2]{};
- stages[0].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; stages[0].stage = VK_SHADER_STAGE_VERTEX_BIT; stages[0].module = vmod; stages[0].pName = "main";
- stages[1].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; stages[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT; stages[1].module = fmod; stages[1].pName = "main";
- VkVertexInputBindingDescription vib{ 0, sizeof(glm::vec3), VK_VERTEX_INPUT_RATE_VERTEX };
- VkVertexInputAttributeDescription via{ 0, 0, VK_FORMAT_R32G32B32_SFLOAT, 0 };
- VkPipelineVertexInputStateCreateInfo vin{ VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO };
- vin.vertexBindingDescriptionCount = 1; vin.pVertexBindingDescriptions = &vib;
- vin.vertexAttributeDescriptionCount = 1; vin.pVertexAttributeDescriptions = &via;
- VkPipelineInputAssemblyStateCreateInfo ia{ VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO }; ia.topology = VK_PRIMITIVE_TOPOLOGY_LINE_LIST;
- VkPipelineViewportStateCreateInfo vps{ VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO }; vps.viewportCount = 1; vps.scissorCount = 1;
- VkDynamicState dyn[2] = { VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR };
- VkPipelineDynamicStateCreateInfo dsci{ VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO }; dsci.dynamicStateCount = 2; dsci.pDynamicStates = dyn;
- VkPipelineRasterizationStateCreateInfo rs{ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO }; rs.polygonMode = VK_POLYGON_MODE_FILL; rs.cullMode = VK_CULL_MODE_NONE; rs.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE; rs.lineWidth = 1.0f;
- VkPipelineMultisampleStateCreateInfo ms{ VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO }; ms.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
- VkPipelineDepthStencilStateCreateInfo ds{ VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO };
- ds.depthTestEnable = VK_TRUE; ds.depthWriteEnable = VK_FALSE; ds.depthCompareOp = VK_COMPARE_OP_LESS_OR_EQUAL; // transparent lines: test but don't write
- VkPipelineColorBlendAttachmentState cba{};
- cba.blendEnable = VK_TRUE;
- cba.srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA; cba.dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA; cba.colorBlendOp = VK_BLEND_OP_ADD;
- cba.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE; cba.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO; cba.alphaBlendOp = VK_BLEND_OP_ADD;
- cba.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
- VkPipelineColorBlendStateCreateInfo cb{ VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO }; cb.attachmentCount = 1; cb.pAttachments = &cba;
- VkGraphicsPipelineCreateInfo gpci{ VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO };
- gpci.stageCount = 2; gpci.pStages = stages;
- gpci.pVertexInputState = &vin; gpci.pInputAssemblyState = &ia; gpci.pViewportState = &vps;
- gpci.pDynamicState = &dsci;
- gpci.pRasterizationState = &rs; gpci.pMultisampleState = &ms; gpci.pColorBlendState = &cb; gpci.pDepthStencilState = &ds;
- gpci.layout = grid_pipeline_layout; gpci.renderPass = scene_render_pass; gpci.subpass = 0;
- VkResult pr = vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &gpci, nullptr, &grid_pipeline);
- vkDestroyShaderModule(device, vmod, nullptr); vkDestroyShaderModule(device, fmod, nullptr);
- if (pr != VK_SUCCESS) { DONUT_ERROR("Vulkan: grid pipeline creation failed ({})", (int)pr); return false; }
-
- // Lit sphere: unit UV-sphere mesh (pos+normal, stride 24), placed/scaled by
- // u_Transform; samples the geodesic HDRI cubemap for ambient (binding 1).
- {
- std::vector<float> sv; std::vector<uint32_t> si;
- const int RINGS = 24, SECTORS = 48;
- for (int r = 0; r <= RINGS; ++r)
- {
- float phi = (float)std::numbers::pi * r / RINGS;
- for (int s = 0; s <= SECTORS; ++s)
- {
- float theta = 2.0f * (float)std::numbers::pi * s / SECTORS;
- float x = sinf(phi) * cosf(theta), y = cosf(phi), z = sinf(phi) * sinf(theta);
- sv.push_back(x); sv.push_back(y); sv.push_back(z); // position (unit)
- sv.push_back(x); sv.push_back(y); sv.push_back(z); // normal == position
- }
- }
- for (int r = 0; r < RINGS; ++r)
- for (int s = 0; s < SECTORS; ++s)
- {
- uint32_t a = r * (SECTORS + 1) + s, b = a + SECTORS + 1;
- si.push_back(a); si.push_back(b); si.push_back(a + 1);
- si.push_back(b); si.push_back(b + 1); si.push_back(a + 1);
- }
- sphere_index_count = (uint32_t)si.size();
- VkDeviceSize svsz = sv.size() * sizeof(float), sisz = si.size() * sizeof(uint32_t);
- if (!create_buffer(svsz, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, host_vis, sphere_vb, sphere_vb_mem)) return false;
- if (!create_buffer(sisz, VK_BUFFER_USAGE_INDEX_BUFFER_BIT, host_vis, sphere_ib, sphere_ib_mem)) return false;
- void* sp = nullptr;
- vkMapMemory(device, sphere_vb_mem, 0, svsz, 0, &sp); memcpy(sp, sv.data(), svsz); vkUnmapMemory(device, sphere_vb_mem);
- vkMapMemory(device, sphere_ib_mem, 0, sisz, 0, &sp); memcpy(sp, si.data(), sisz); vkUnmapMemory(device, sphere_ib_mem);
-
- VkPhysicalDeviceProperties pdp{}; vkGetPhysicalDeviceProperties(physical, &pdp);
- VkDeviceSize min_align = pdp.limits.minUniformBufferOffsetAlignment;
- sphere_ubo_stride = ((208 + min_align - 1) / min_align) * min_align; // per-object slot
- VkDeviceSize sphere_ubo_size = sphere_ubo_stride * MAX_SCENE_OBJECTS;
- if (!create_buffer(sphere_ubo_size, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, host_vis, sphere_ubo, sphere_ubo_mem)) return false;
- vkMapMemory(device, sphere_ubo_mem, 0, sphere_ubo_size, 0, &sphere_ubo_mapped);
-
- VkDescriptorSetLayoutBinding sb[2]{};
- sb[0].binding = 0; sb[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC; sb[0].descriptorCount = 1; sb[0].stageFlags = VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT;
- sb[1].binding = 1; sb[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; sb[1].descriptorCount = 1; sb[1].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
- VkDescriptorSetLayoutCreateInfo sdslci{ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO }; sdslci.bindingCount = 2; sdslci.pBindings = sb;
- VK_CHECK(vkCreateDescriptorSetLayout(device, &sdslci, nullptr, &sphere_set_layout));
- VkDescriptorPoolSize sps[2] = { { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 1 }, { VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1 } };
- VkDescriptorPoolCreateInfo sdpci{ VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO }; sdpci.maxSets = 1; sdpci.poolSizeCount = 2; sdpci.pPoolSizes = sps;
- VK_CHECK(vkCreateDescriptorPool(device, &sdpci, nullptr, &sphere_pool));
- VkDescriptorSetAllocateInfo sdsai{ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO }; sdsai.descriptorPool = sphere_pool; sdsai.descriptorSetCount = 1; sdsai.pSetLayouts = &sphere_set_layout;
- VK_CHECK(vkAllocateDescriptorSets(device, &sdsai, &sphere_set));
- VkDescriptorBufferInfo sbi{ sphere_ubo, 0, 208 }; // per-draw size; the dynamic offset selects the object slot
- VkDescriptorImageInfo sii{ cube_sampler, cube_view, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL };
- VkWriteDescriptorSet sw[2]{};
- sw[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; sw[0].dstSet = sphere_set; sw[0].dstBinding = 0; sw[0].descriptorCount = 1; sw[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC; sw[0].pBufferInfo = &sbi;
- sw[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; sw[1].dstSet = sphere_set; sw[1].dstBinding = 1; sw[1].descriptorCount = 1; sw[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; sw[1].pImageInfo = &sii;
- vkUpdateDescriptorSets(device, 2, sw, 0, nullptr);
-
- VkShaderModule svmod, sfmod;
- if (!create_shader_module("assets/shaders/generated/Sphere.vertexMain.spv", svmod)) return false;
- if (!create_shader_module("assets/shaders/generated/Sphere.fragmentMain.spv", sfmod)) return false;
- VkPipelineLayoutCreateInfo splci{ VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO }; splci.setLayoutCount = 1; splci.pSetLayouts = &sphere_set_layout;
- VK_CHECK(vkCreatePipelineLayout(device, &splci, nullptr, &sphere_pipeline_layout));
- VkPipelineShaderStageCreateInfo sstages[2]{};
- sstages[0].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; sstages[0].stage = VK_SHADER_STAGE_VERTEX_BIT; sstages[0].module = svmod; sstages[0].pName = "main";
- sstages[1].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; sstages[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT; sstages[1].module = sfmod; sstages[1].pName = "main";
- VkVertexInputBindingDescription svib{ 0, 6 * (uint32_t)sizeof(float), VK_VERTEX_INPUT_RATE_VERTEX };
- VkVertexInputAttributeDescription svia[2] = { { 0, 0, VK_FORMAT_R32G32B32_SFLOAT, 0 }, { 1, 0, VK_FORMAT_R32G32B32_SFLOAT, 3 * (uint32_t)sizeof(float) } };
- VkPipelineVertexInputStateCreateInfo svin{ VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO };
- svin.vertexBindingDescriptionCount = 1; svin.pVertexBindingDescriptions = &svib;
- svin.vertexAttributeDescriptionCount = 2; svin.pVertexAttributeDescriptions = svia;
- VkPipelineInputAssemblyStateCreateInfo sia{ VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO }; sia.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
- VkPipelineViewportStateCreateInfo svps{ VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO }; svps.viewportCount = 1; svps.scissorCount = 1;
- VkDynamicState sdyn[2] = { VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR };
- VkPipelineDynamicStateCreateInfo sdsci{ VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO }; sdsci.dynamicStateCount = 2; sdsci.pDynamicStates = sdyn;
- VkPipelineRasterizationStateCreateInfo srs{ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO }; srs.polygonMode = VK_POLYGON_MODE_FILL; srs.cullMode = VK_CULL_MODE_NONE; srs.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE; srs.lineWidth = 1.0f;
- VkPipelineMultisampleStateCreateInfo sms{ VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO }; sms.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
- VkPipelineDepthStencilStateCreateInfo sds{ VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO };
- sds.depthTestEnable = VK_TRUE; sds.depthWriteEnable = VK_TRUE; sds.depthCompareOp = VK_COMPARE_OP_LESS;
- VkPipelineColorBlendAttachmentState scba{}; scba.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
- VkPipelineColorBlendStateCreateInfo scb{ VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO }; scb.attachmentCount = 1; scb.pAttachments = &scba;
- VkGraphicsPipelineCreateInfo sgpci{ VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO };
- sgpci.stageCount = 2; sgpci.pStages = sstages;
- sgpci.pVertexInputState = &svin; sgpci.pInputAssemblyState = &sia; sgpci.pViewportState = &svps;
- sgpci.pDynamicState = &sdsci;
- sgpci.pRasterizationState = &srs; sgpci.pMultisampleState = &sms; sgpci.pColorBlendState = &scb; sgpci.pDepthStencilState = &sds;
- sgpci.layout = sphere_pipeline_layout; sgpci.renderPass = scene_render_pass; sgpci.subpass = 0;
- VkResult spr = vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &sgpci, nullptr, &sphere_pipeline);
- vkDestroyShaderModule(device, svmod, nullptr); vkDestroyShaderModule(device, sfmod, nullptr);
- if (spr != VK_SUCCESS) { DONUT_ERROR("Vulkan: sphere pipeline creation failed ({})", (int)spr); return false; }
- }
-
- // Skybox: a unit cube (36 verts) sampling the HDRI cubemap; the vertex
- // shader forces depth 1 (pos.xyww) so it sits behind all scene geometry.
- {
- const float cube[] = {
- -1,-1,-1, 1,-1,-1, 1, 1,-1, 1, 1,-1, -1, 1,-1, -1,-1,-1,
- -1,-1, 1, 1,-1, 1, 1, 1, 1, 1, 1, 1, -1, 1, 1, -1,-1, 1,
- -1, 1, 1, -1, 1,-1, -1,-1,-1, -1,-1,-1, -1,-1, 1, -1, 1, 1,
- 1, 1, 1, 1, 1,-1, 1,-1,-1, 1,-1,-1, 1,-1, 1, 1, 1, 1,
- -1,-1,-1, 1,-1,-1, 1,-1, 1, 1,-1, 1, -1,-1, 1, -1,-1,-1,
- -1, 1,-1, 1, 1,-1, 1, 1, 1, 1, 1, 1, -1, 1, 1, -1, 1,-1
- };
- if (!create_buffer(sizeof(cube), VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, host_vis, skybox_vb, skybox_vb_mem)) return false;
- void* kp = nullptr; vkMapMemory(device, skybox_vb_mem, 0, sizeof(cube), 0, &kp); memcpy(kp, cube, sizeof(cube)); vkUnmapMemory(device, skybox_vb_mem);
-
- // $Globals UBO (128 B: u_Projection@0, u_View@64); u_Skybox at binding 1.
- if (!create_buffer(128, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, host_vis, skybox_ubo, skybox_ubo_mem)) return false;
- vkMapMemory(device, skybox_ubo_mem, 0, 128, 0, &skybox_ubo_mapped);
-
- VkDescriptorSetLayoutBinding kb[2]{};
- kb[0].binding = 0; kb[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; kb[0].descriptorCount = 1; kb[0].stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
- kb[1].binding = 1; kb[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; kb[1].descriptorCount = 1; kb[1].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
- VkDescriptorSetLayoutCreateInfo kdslci{ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO }; kdslci.bindingCount = 2; kdslci.pBindings = kb;
- VK_CHECK(vkCreateDescriptorSetLayout(device, &kdslci, nullptr, &skybox_set_layout));
- VkDescriptorPoolSize kps[2] = { { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1 }, { VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1 } };
- VkDescriptorPoolCreateInfo kdpci{ VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO }; kdpci.maxSets = 1; kdpci.poolSizeCount = 2; kdpci.pPoolSizes = kps;
- VK_CHECK(vkCreateDescriptorPool(device, &kdpci, nullptr, &skybox_pool));
- VkDescriptorSetAllocateInfo kdsai{ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO }; kdsai.descriptorPool = skybox_pool; kdsai.descriptorSetCount = 1; kdsai.pSetLayouts = &skybox_set_layout;
- VK_CHECK(vkAllocateDescriptorSets(device, &kdsai, &skybox_set));
- VkDescriptorBufferInfo kbi{ skybox_ubo, 0, VK_WHOLE_SIZE };
- VkDescriptorImageInfo kii{ cube_sampler, cube_view, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL };
- VkWriteDescriptorSet kw[2]{};
- kw[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; kw[0].dstSet = skybox_set; kw[0].dstBinding = 0; kw[0].descriptorCount = 1; kw[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; kw[0].pBufferInfo = &kbi;
- kw[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; kw[1].dstSet = skybox_set; kw[1].dstBinding = 1; kw[1].descriptorCount = 1; kw[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; kw[1].pImageInfo = &kii;
- vkUpdateDescriptorSets(device, 2, kw, 0, nullptr);
-
- VkShaderModule kvmod, kfmod;
- if (!create_shader_module("assets/shaders/generated/Skybox.vertexMain.spv", kvmod)) return false;
- if (!create_shader_module("assets/shaders/generated/Skybox.fragmentMain.spv", kfmod)) return false;
- VkPipelineLayoutCreateInfo kplci{ VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO }; kplci.setLayoutCount = 1; kplci.pSetLayouts = &skybox_set_layout;
- VK_CHECK(vkCreatePipelineLayout(device, &kplci, nullptr, &skybox_pipeline_layout));
- VkPipelineShaderStageCreateInfo kstages[2]{};
- kstages[0].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; kstages[0].stage = VK_SHADER_STAGE_VERTEX_BIT; kstages[0].module = kvmod; kstages[0].pName = "main";
- kstages[1].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; kstages[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT; kstages[1].module = kfmod; kstages[1].pName = "main";
- VkVertexInputBindingDescription kvib{ 0, 3 * (uint32_t)sizeof(float), VK_VERTEX_INPUT_RATE_VERTEX };
- VkVertexInputAttributeDescription kvia{ 0, 0, VK_FORMAT_R32G32B32_SFLOAT, 0 };
- VkPipelineVertexInputStateCreateInfo kvin{ VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO };
- kvin.vertexBindingDescriptionCount = 1; kvin.pVertexBindingDescriptions = &kvib;
- kvin.vertexAttributeDescriptionCount = 1; kvin.pVertexAttributeDescriptions = &kvia;
- VkPipelineInputAssemblyStateCreateInfo kia{ VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO }; kia.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
- VkPipelineViewportStateCreateInfo kvps{ VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO }; kvps.viewportCount = 1; kvps.scissorCount = 1;
- VkDynamicState kdyn[2] = { VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR };
- VkPipelineDynamicStateCreateInfo kdsci{ VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO }; kdsci.dynamicStateCount = 2; kdsci.pDynamicStates = kdyn;
- VkPipelineRasterizationStateCreateInfo krs{ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO }; krs.polygonMode = VK_POLYGON_MODE_FILL; krs.cullMode = VK_CULL_MODE_NONE; krs.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE; krs.lineWidth = 1.0f;
- VkPipelineMultisampleStateCreateInfo kms{ VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO }; kms.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
- VkPipelineDepthStencilStateCreateInfo kds{ VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO };
- kds.depthTestEnable = VK_FALSE; kds.depthWriteEnable = VK_FALSE; // background: neither tests nor writes depth
- VkPipelineColorBlendAttachmentState kcba{}; kcba.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
- VkPipelineColorBlendStateCreateInfo kcb{ VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO }; kcb.attachmentCount = 1; kcb.pAttachments = &kcba;
- VkGraphicsPipelineCreateInfo kgpci{ VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO };
- kgpci.stageCount = 2; kgpci.pStages = kstages;
- kgpci.pVertexInputState = &kvin; kgpci.pInputAssemblyState = &kia; kgpci.pViewportState = &kvps;
- kgpci.pDynamicState = &kdsci;
- kgpci.pRasterizationState = &krs; kgpci.pMultisampleState = &kms; kgpci.pColorBlendState = &kcb; kgpci.pDepthStencilState = &kds;
- kgpci.layout = skybox_pipeline_layout; kgpci.renderPass = scene_render_pass; kgpci.subpass = 0;
- VkResult kpr = vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &kgpci, nullptr, &skybox_pipeline);
- vkDestroyShaderModule(device, kvmod, nullptr); vkDestroyShaderModule(device, kfmod, nullptr);
- if (kpr != VK_SUCCESS) { DONUT_ERROR("Vulkan: skybox pipeline creation failed ({})", (int)kpr); return false; }
- }
-
- DONUT_INFO("Vulkan: scene resources ready ({} grid verts, {} sphere indices, skybox)", grid_vertex_count, sphere_index_count);
- return true;
- }
-
- auto VulkanRenderer::Impl::update_scene_uniforms() -> void
- {
- struct GridUBO {
- glm::mat4 view_projection; // 0 (SPIR-V RowMajor -> upload transposed)
- glm::mat4 transform; // 64
- float grid_size; float p0[3]; // 128
- glm::vec3 grid_color; // 144
- float grid_alpha; // 156
- glm::vec3 camera_pos; // 160
- float p1; // 172
- } g{};
- static_assert(sizeof(GridUBO) == 176, "GridUBO std140 layout mismatch");
-
- uint32_t h = swapchain_extent.height ? swapchain_extent.height : 1;
- float aspect = (float)swapchain_extent.width / (float)h;
- scene_camera.set_projection(45.0f, aspect, 0.1f, 1000.0f);
- glm::mat4 vp = scene_camera.get_projection_matrix() * scene_camera.get_view_matrix();
-
- // Slang's mul(M,v) + the SPIR-V RowMajor decoration means glm's column-major
- // matrices upload directly here (no transpose) to read as the intended M.
- g.view_projection = vp;
- g.transform = glm::mat4(1.0f);
- g.grid_size = 50.0f;
- g.grid_color = glm::vec3(0.55f, 0.55f, 0.6f);
- g.grid_alpha = 0.75f;
- g.camera_pos = scene_camera.get_orbital_position();
- if (grid_ubo_mapped) memcpy(grid_ubo_mapped, &g, sizeof(g));
-
- struct SphereUBO {
- glm::mat4 view_projection; // 0
- glm::mat4 transform; // 64
- glm::vec3 color; float specular; // 128, 140
- float emission; float p0[3]; // 144
- glm::vec3 light_pos; float p1; // 160, 172
- glm::vec3 camera_pos; int is_selected; // 176, 188
- glm::vec3 outline_color; float outline_width; // 192, 204
- };
- static_assert(sizeof(SphereUBO) == 208, "SphereUBO std140 layout mismatch");
- glm::vec3 cam_pos = scene_camera.get_orbital_position();
- uint32_t obj_count = (uint32_t)std::min(scene_objects.size(), (size_t)MAX_SCENE_OBJECTS);
- for (uint32_t i = 0; i < obj_count; ++i)
- {
- const SceneObject& o = scene_objects[i];
- SphereUBO s{};
- s.view_projection = vp; // same no-transpose rule as the grid
- s.transform = glm::translate(glm::mat4(1.0f), o.position) * glm::scale(glm::mat4(1.0f), glm::vec3(o.radius));
- s.color = o.color;
- s.specular = 0.6f;
- s.emission = 0.0f;
- s.light_pos = glm::vec3(10.0f, 20.0f, 10.0f);
- s.camera_pos = cam_pos;
- s.is_selected = ((int)i == selected_object) ? 1 : 0;
- s.outline_color = glm::vec3(1.0f, 1.0f, 0.0f);
- s.outline_width = 0.15f;
- if (sphere_ubo_mapped) memcpy((char*)sphere_ubo_mapped + (VkDeviceSize)i * sphere_ubo_stride, &s, sizeof(s));
- }
-
- struct SkyboxUBO { glm::mat4 projection; glm::mat4 view; } sky{};
- static_assert(sizeof(SkyboxUBO) == 128, "SkyboxUBO std140 layout mismatch");
- sky.projection = scene_camera.get_projection_matrix(); // no transpose (mul(M,v))
- sky.view = glm::mat4(glm::mat3(scene_camera.get_view_matrix())); // strip translation so the sky stays centered
- if (skybox_ubo_mapped) memcpy(skybox_ubo_mapped, &sky, sizeof(sky));
- }
-
- auto VulkanRenderer::Impl::update_geodesic_uniforms() -> void
- {
- struct CamUBO {
- glm::vec3 pos; float p0; glm::vec3 right; float p1;
- glm::vec3 up; float p2; glm::vec3 fwd; float p3;
- float tan_half_fov; float aspect; uint32_t moving; int p4;
- } cam_data{};
- glm::vec3 pos, fwd;
- if (camera.get_camera_mode() == CameraMode::FPS)
- {
- pos = camera.get_position();
- fwd = camera.get_forward_direction();
- }
- else
- {
- pos = camera.get_orbital_position();
- fwd = glm::normalize(camera.get_orbital_target() - pos);
- }
- glm::vec3 right = glm::normalize(glm::cross(fwd, glm::vec3(0, 1, 0)));
- cam_data.pos = pos; cam_data.right = right; cam_data.up = glm::cross(right, fwd); cam_data.fwd = fwd;
- cam_data.tan_half_fov = (float)tan(glm::radians(bh_params.fov_degrees * 0.5f));
- cam_data.aspect = (float)GEO_HI_W / (float)GEO_HI_H; // 16:9, same for both targets
- cam_data.moving = user_moving ? 1u : 0u;
- if (cam_mapped) memcpy(cam_mapped, &cam_data, sizeof(cam_data));
-
- // Integration budget drives how deep the geodesics are traced: too few
- // steps and grazing rays exhaust the loop mid-lensing, so the shader
- // paints them with the HDRI (Geodesic.slang) and the hole looks sliced
- // off "up to a certain depth" -- and near face-on it vanishes entirely.
- // Measured: at ~8000 steps the disk disappears at steep poses, ~15000 is
- // needed for it to resolve, INDEPENDENT of resolution. So we DON'T drop
- // steps while moving (that would make the hole flicker out mid-drag);
- // responsiveness comes from the lower-res target instead (see record).
- // Sourced from settings.toml (max_steps_static), capped GPU-safe.
- constexpr int kStepCeil = 15000;
- struct SimUBO { int steps_moving; int steps_static; float early_exit; float time; } sim;
- sim.steps_static = std::clamp(bh_params.quality_steps, 1000, kStepCeil);
- sim.steps_moving = sim.steps_static; // same budget both frames; resolution is the lever
- sim.early_exit = SettingsManager::get_early_exit_distance();
- sim.time = (float)(glfwGetTime() - start_time);
- if (sim_mapped) memcpy(sim_mapped, &sim, sizeof(sim));
-
- // Disk UBO, refilled live from the UI-tunable parameters. Layout matches
- // the shader Disk struct: r1, r2, turbulence, slab thickness, brightness,
- // temperature. Radii are in Schwarzschild radii (x SagA_rs).
- const float SagA_rs = 1.269e10f;
- float disk_data[8] = {
- std::max(bh_params.disk_inner_rs, 3.0f) * SagA_rs,
- std::max(bh_params.disk_outer_rs, bh_params.disk_inner_rs + 0.5f) * SagA_rs,
- std::max(bh_params.turbulence, 0.0f),
- SagA_rs * 0.1f, // slab half-thickness (fixed)
- std::max(bh_params.brightness, 0.0f),
- std::max(bh_params.temperature, 1000.0f),
- 0.0f, 0.0f,
- };
- if (disk_mapped) memcpy(disk_mapped, disk_data, sizeof(disk_data));
- }
-
- static double g_ScrollAccum = 0.0;
- static GLFWscrollfun g_PrevScroll = nullptr;
- static void donut_vk_scroll_callback(GLFWwindow* w, double x, double y)
- {
- if (g_PrevScroll) g_PrevScroll(w, x, y); // keep ImGui's scroll handling intact
- g_ScrollAccum += y;
- }
-
- auto VulkanRenderer::Impl::process_input() -> void
- {
- bool over_ui = imgui_init && ImGui::GetIO().WantCaptureMouse;
-
- double now = glfwGetTime();
- float dt = last_frame_time > 0.0 ? (float)(now - last_frame_time) : 0.0f;
- last_frame_time = now;
-
- double mx = 0, my = 0;
- glfwGetCursorPos(window, &mx, &my);
- bool left_down = glfwGetMouseButton(window, GLFW_MOUSE_BUTTON_LEFT) == GLFW_PRESS;
-
- if (!scene_mode && camera.get_camera_mode() == CameraMode::FPS)
- {
- // Left-drag looks around (screen-up looks up); WASD/QE move.
- if (left_down && !left_was_down) { fps_last_x = mx; fps_last_y = my; }
- if (left_down && !over_ui)
- camera.on_mouse_move(float(mx - fps_last_x), float(fps_last_y - my));
- fps_last_x = mx; fps_last_y = my;
- left_was_down = left_down;
-
- bool over_kb = imgui_init && ImGui::GetIO().WantCaptureKeyboard;
- bool moved = false;
- if (!over_kb && dt > 0.0f)
- {
- float mdt = dt * (glfwGetKey(window, GLFW_KEY_LEFT_SHIFT) == GLFW_PRESS ? 4.0f : 1.0f);
- if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS) { camera.move_forward(mdt); moved = true; }
- if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS) { camera.move_backward(mdt); moved = true; }
- if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS) { camera.move_left(mdt); moved = true; }
- if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS) { camera.move_right(mdt); moved = true; }
- if (glfwGetKey(window, GLFW_KEY_E) == GLFW_PRESS) { camera.move_up(mdt); moved = true; }
- if (glfwGetKey(window, GLFW_KEY_Q) == GLFW_PRESS) { camera.move_down(mdt); moved = true; }
- }
- g_ScrollAccum = 0.0; // scroll unused in free-fly
- user_moving = moved || (left_down && !over_ui);
- }
- else
- {
- Camera& cam = scene_mode ? scene_camera : camera;
- if (left_down && !left_was_down && !over_ui)
- cam.process_orbital_mouse_button(GLFW_MOUSE_BUTTON_LEFT, GLFW_PRESS, 0);
- else if (!left_down && left_was_down)
- cam.process_orbital_mouse_button(GLFW_MOUSE_BUTTON_LEFT, GLFW_RELEASE, 0);
- left_was_down = left_down;
-
- cam.process_orbital_mouse_move(mx, my); // orbits only while dragging
-
- double scroll = g_ScrollAccum; g_ScrollAccum = 0.0;
- if (scroll != 0.0 && !over_ui)
- cam.process_orbital_scroll(0.0, scroll);
-
- user_moving = cam.is_dragging() || cam.is_panning();
- }
- }
-
- auto VulkanRenderer::Impl::destroy_geodesic_resources() -> void
- {
- if (grid_pipeline) vkDestroyPipeline(device, grid_pipeline, nullptr);
- if (grid_pipeline_layout) vkDestroyPipelineLayout(device, grid_pipeline_layout, nullptr);
- if (grid_pool) vkDestroyDescriptorPool(device, grid_pool, nullptr);
- if (grid_set_layout) vkDestroyDescriptorSetLayout(device, grid_set_layout, nullptr);
- if (grid_ubo_mapped) { vkUnmapMemory(device, grid_ubo_mem); grid_ubo_mapped = nullptr; }
- if (grid_ubo) vkDestroyBuffer(device, grid_ubo, nullptr);
- if (grid_ubo_mem) vkFreeMemory(device, grid_ubo_mem, nullptr);
- if (grid_vb) vkDestroyBuffer(device, grid_vb, nullptr);
- if (grid_vb_mem) vkFreeMemory(device, grid_vb_mem, nullptr);
-
- if (sphere_pipeline) vkDestroyPipeline(device, sphere_pipeline, nullptr);
- if (sphere_pipeline_layout) vkDestroyPipelineLayout(device, sphere_pipeline_layout, nullptr);
- if (sphere_pool) vkDestroyDescriptorPool(device, sphere_pool, nullptr);
- if (sphere_set_layout) vkDestroyDescriptorSetLayout(device, sphere_set_layout, nullptr);
- if (sphere_ubo_mapped) { vkUnmapMemory(device, sphere_ubo_mem); sphere_ubo_mapped = nullptr; }
- if (sphere_ubo) vkDestroyBuffer(device, sphere_ubo, nullptr);
- if (sphere_ubo_mem) vkFreeMemory(device, sphere_ubo_mem, nullptr);
- if (sphere_ib) vkDestroyBuffer(device, sphere_ib, nullptr);
- if (sphere_ib_mem) vkFreeMemory(device, sphere_ib_mem, nullptr);
- if (sphere_vb) vkDestroyBuffer(device, sphere_vb, nullptr);
- if (sphere_vb_mem) vkFreeMemory(device, sphere_vb_mem, nullptr);
-
- if (skybox_pipeline) vkDestroyPipeline(device, skybox_pipeline, nullptr);
- if (skybox_pipeline_layout) vkDestroyPipelineLayout(device, skybox_pipeline_layout, nullptr);
- if (skybox_pool) vkDestroyDescriptorPool(device, skybox_pool, nullptr);
- if (skybox_set_layout) vkDestroyDescriptorSetLayout(device, skybox_set_layout, nullptr);
- if (skybox_ubo_mapped) { vkUnmapMemory(device, skybox_ubo_mem); skybox_ubo_mapped = nullptr; }
- if (skybox_ubo) vkDestroyBuffer(device, skybox_ubo, nullptr);
- if (skybox_ubo_mem) vkFreeMemory(device, skybox_ubo_mem, nullptr);
- if (skybox_vb) vkDestroyBuffer(device, skybox_vb, nullptr);
- if (skybox_vb_mem) vkFreeMemory(device, skybox_vb_mem, nullptr);
-
- if (present_pipeline) vkDestroyPipeline(device, present_pipeline, nullptr);
- if (present_pipeline_layout) vkDestroyPipelineLayout(device, present_pipeline_layout, nullptr);
- if (present_pool) vkDestroyDescriptorPool(device, present_pool, nullptr);
- if (present_set_layout) vkDestroyDescriptorSetLayout(device, present_set_layout, nullptr);
- if (present_sampler) vkDestroySampler(device, present_sampler, nullptr);
-
- if (geo_pipeline) vkDestroyPipeline(device, geo_pipeline, nullptr);
- if (geo_pipeline_layout) vkDestroyPipelineLayout(device, geo_pipeline_layout, nullptr);
- if (geo_pool) vkDestroyDescriptorPool(device, geo_pool, nullptr);
- if (geo_set_layout) vkDestroyDescriptorSetLayout(device, geo_set_layout, nullptr);
- if (quad_vb) vkDestroyBuffer(device, quad_vb, nullptr);
- if (quad_vb_mem) vkFreeMemory(device, quad_vb_mem, nullptr);
- if (cube_sampler) vkDestroySampler(device, cube_sampler, nullptr);
- if (cube_view) vkDestroyImageView(device, cube_view, nullptr);
- if (cube_image) vkDestroyImage(device, cube_image, nullptr);
- if (cube_mem) vkFreeMemory(device, cube_mem, nullptr);
- if (cam_mapped) { vkUnmapMemory(device, cam_mem); cam_mapped = nullptr; }
- if (sim_mapped) { vkUnmapMemory(device, sim_mem); sim_mapped = nullptr; }
- if (disk_mapped) { vkUnmapMemory(device, disk_mem); disk_mapped = nullptr; }
- VkBuffer ubos[4] = { cam_buf, disk_buf, obj_buf, sim_buf };
- VkDeviceMemory umem[4] = { cam_mem, disk_mem, obj_mem, sim_mem };
- for (int i = 0; i < 4; ++i) { if (ubos[i]) vkDestroyBuffer(device, ubos[i], nullptr); if (umem[i]) vkFreeMemory(device, umem[i], nullptr); }
- for (GeoTarget* t : { &geo_lo, &geo_hi })
- {
- if (t->fb) vkDestroyFramebuffer(device, t->fb, nullptr);
- if (t->view) vkDestroyImageView(device, t->view, nullptr);
- if (t->image) vkDestroyImage(device, t->image, nullptr);
- if (t->mem) vkFreeMemory(device, t->mem, nullptr);
- }
- if (geo_render_pass) vkDestroyRenderPass(device, geo_render_pass, nullptr);
- }
-
- auto VulkanRenderer::Impl::record_command_buffer(VkCommandBuffer cmd, uint32_t image_index, const glm::vec4& clear, ImDrawData* draw_data) -> bool
- {
- VkCommandBufferBeginInfo begin{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO };
- VK_CHECK(vkBeginCommandBuffer(cmd, &begin));
-
- if (scene_mode)
- {
- // Scene view: opaque sphere (writes depth) then the transparent grid on
- // top, into a color+depth swapchain pass, then ImGui.
- VkClearValue cvs[2]{};
- cvs[0].color = { { clear.r, clear.g, clear.b, clear.a } };
- cvs[1].depthStencil = { 1.0f, 0 };
- VkRenderPassBeginInfo rpbi{ VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO };
- rpbi.renderPass = scene_render_pass; rpbi.framebuffer = scene_framebuffers[image_index];
- rpbi.renderArea = { { 0, 0 }, swapchain_extent };
- rpbi.clearValueCount = 2; rpbi.pClearValues = cvs;
- vkCmdBeginRenderPass(cmd, &rpbi, VK_SUBPASS_CONTENTS_INLINE);
-
- // Negative-height viewport flips Y so the scene reads like the GL path.
- VkViewport gvp{ 0, (float)swapchain_extent.height, (float)swapchain_extent.width, -(float)swapchain_extent.height, 0, 1 };
- VkRect2D gsc{ { 0, 0 }, swapchain_extent };
- vkCmdSetViewport(cmd, 0, 1, &gvp);
- vkCmdSetScissor(cmd, 0, 1, &gsc);
-
- // Skybox background first (forces depth 1; no depth test/write).
- vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, skybox_pipeline);
- vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, skybox_pipeline_layout, 0, 1, &skybox_set, 0, nullptr);
- VkDeviceSize skoff = 0; vkCmdBindVertexBuffers(cmd, 0, 1, &skybox_vb, &skoff);
- vkCmdDraw(cmd, 36, 1, 0, 0);
-
- vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, sphere_pipeline);
- VkDeviceSize soff = 0; vkCmdBindVertexBuffers(cmd, 0, 1, &sphere_vb, &soff);
- vkCmdBindIndexBuffer(cmd, sphere_ib, 0, VK_INDEX_TYPE_UINT32);
- uint32_t obj_count = (uint32_t)std::min(scene_objects.size(), (size_t)MAX_SCENE_OBJECTS);
- for (uint32_t i = 0; i < obj_count; ++i)
- {
- uint32_t dyn = (uint32_t)((VkDeviceSize)i * sphere_ubo_stride); // select this object's UBO slot
- vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, sphere_pipeline_layout, 0, 1, &sphere_set, 1, &dyn);
- vkCmdDrawIndexed(cmd, sphere_index_count, 1, 0, 0, 0);
- }
-
- vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, grid_pipeline);
- vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, grid_pipeline_layout, 0, 1, &grid_set, 0, nullptr);
- VkDeviceSize goff = 0; vkCmdBindVertexBuffers(cmd, 0, 1, &grid_vb, &goff);
- vkCmdDraw(cmd, grid_vertex_count, 1, 0, 0);
-
- if (draw_data)
- ImGui_ImplVulkan_RenderDrawData(draw_data, cmd);
- vkCmdEndRenderPass(cmd);
- VK_CHECK(vkEndCommandBuffer(cmd));
- return true;
- }
-
- // Geodesic offscreen pass. Progressive resolution: low-res while the
- // camera moves (4x fewer pixels -> responsive), high-res once it settles
- // (resolves the photon ring). Step count is the same for both (the disk
- // vanishes below ~15000 steps at steep poses), so resolution is the lever.
- GeoTarget& gt = user_moving ? geo_lo : geo_hi;
- VkClearValue geo_clear{}; geo_clear.color = { { 0, 0, 0, 1 } };
- VkRenderPassBeginInfo grp{ VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO };
- grp.renderPass = geo_render_pass; grp.framebuffer = gt.fb;
- grp.renderArea = { { 0, 0 }, { gt.w, gt.h } };
- grp.clearValueCount = 1; grp.pClearValues = &geo_clear;
- vkCmdBeginRenderPass(cmd, &grp, VK_SUBPASS_CONTENTS_INLINE);
- vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, geo_pipeline);
- VkViewport gvp{ 0, 0, (float)gt.w, (float)gt.h, 0, 1 }; VkRect2D gsc{ { 0, 0 }, { gt.w, gt.h } };
- vkCmdSetViewport(cmd, 0, 1, &gvp); vkCmdSetScissor(cmd, 0, 1, &gsc);
- vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, geo_pipeline_layout, 0, 1, &geo_set, 0, nullptr);
- VkDeviceSize off = 0; vkCmdBindVertexBuffers(cmd, 0, 1, &quad_vb, &off);
- vkCmdDraw(cmd, 6, 1, 0, 0);
- vkCmdEndRenderPass(cmd);
-
- // Swapchain pass: upscale the geodesic image, then the ImGui UI on top
- VkClearValue cv{}; cv.color = { { clear.r, clear.g, clear.b, clear.a } };
- VkRenderPassBeginInfo rpbi{ VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO };
- rpbi.renderPass = render_pass;
- rpbi.framebuffer = framebuffers[image_index];
- rpbi.renderArea = { { 0, 0 }, swapchain_extent };
- rpbi.clearValueCount = 1; rpbi.pClearValues = &cv;
- vkCmdBeginRenderPass(cmd, &rpbi, VK_SUBPASS_CONTENTS_INLINE);
- vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, present_pipeline);
- // Negative-height viewport flips the geodesic image vertically so the scene
- // reads the same as the OpenGL path (Vulkan's clip space is Y-down). Only
- // this draw is affected; ImGui sets its own viewport.
- VkViewport vp{ 0, (float)swapchain_extent.height, (float)swapchain_extent.width, -(float)swapchain_extent.height, 0, 1 };
- VkRect2D scissor{ { 0, 0 }, swapchain_extent };
- vkCmdSetViewport(cmd, 0, 1, &vp);
- vkCmdSetScissor(cmd, 0, 1, &scissor);
- vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, present_pipeline_layout, 0, 1, &gt.present_set, 0, nullptr);
- vkCmdBindVertexBuffers(cmd, 0, 1, &quad_vb, &off);
- vkCmdDraw(cmd, 6, 1, 0, 0);
- if (draw_data)
- ImGui_ImplVulkan_RenderDrawData(draw_data, cmd);
- vkCmdEndRenderPass(cmd);
-
- VK_CHECK(vkEndCommandBuffer(cmd));
- return true;
- }
-
- auto VulkanRenderer::Impl::cleanup_swapchain() -> void
- {
- destroy_scene_targets();
- for (auto fb : framebuffers) vkDestroyFramebuffer(device, fb, nullptr);
- framebuffers.clear();
- for (auto iv : image_views) vkDestroyImageView(device, iv, nullptr);
- image_views.clear();
- if (render_pass) { vkDestroyRenderPass(device, render_pass, nullptr); render_pass = VK_NULL_HANDLE; }
- if (swapchain) { vkDestroySwapchainKHR(device, swapchain, nullptr); swapchain = VK_NULL_HANDLE; }
- }
-
- auto VulkanRenderer::Impl::recreate_swapchain() -> bool
- {
- // Wait until the window has a non-zero size (e.g. after un-minimizing).
- int w = 0, h = 0;
- glfwGetFramebufferSize(window, &w, &h);
- while (w == 0 || h == 0)
- {
- glfwGetFramebufferSize(window, &w, &h);
- glfwWaitEvents();
- }
- width = w; height = h;
- vkDeviceWaitIdle(device);
-
- cleanup_swapchain();
- // render_finished are tied to image count; recreate below via sync if it changed.
- if (!create_swapchain()) return false;
- if (!create_image_views()) return false;
- if (!create_render_pass()) return false;
- if (!create_framebuffers())return false;
- if (!create_scene_targets())return false;
- images_in_flight.assign(images.size(), VK_NULL_HANDLE);
- return true;
- }
-
- VulkanRenderer::VulkanRenderer() { m_impl = new Impl(); }
- VulkanRenderer::~VulkanRenderer() { shutdown(); delete m_impl; m_impl = nullptr; }
-
- auto VulkanRenderer::init(void* glfwWindow, int width, int height) -> bool
- {
- Impl& v = *m_impl;
- v.window = (GLFWwindow*)glfwWindow;
- v.width = width; v.height = height;
-
- if (!v.create_instance()) return false;
- if (!v.pick_physical_and_device()) return false;
- if (!v.create_swapchain()) return false;
- if (!v.create_image_views()) return false;
- if (!v.create_render_pass()) return false;
- if (!v.create_framebuffers()) return false;
- if (!v.create_scene_targets()) return false;
- if (!v.create_command_buffers()) return false;
- if (!v.create_sync_objects()) return false;
- if (!v.create_geodesic_resources()) return false;
- if (!v.create_present_resources()) return false;
- if (!v.create_scene_resources()) return false;
-
- DONUT_INFO("Vulkan renderer ready: {} swapchain images, {}x{}",
- (int)v.images.size(), v.swapchain_extent.width, v.swapchain_extent.height);
- return true;
- }
-
- auto VulkanRenderer::init_ui() -> bool
- {
- Impl& v = *m_impl;
- if (v.device == VK_NULL_HANDLE) return false;
-
- VkDescriptorPoolSize pool_size{ VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1000 };
- VkDescriptorPoolCreateInfo dpci{ VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO };
- dpci.flags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT;
- dpci.maxSets = 1000;
- dpci.poolSizeCount = 1; dpci.pPoolSizes = &pool_size;
- VK_CHECK(vkCreateDescriptorPool(v.device, &dpci, nullptr, &v.imgui_pool));
-
- IMGUI_CHECKVERSION();
- ImGui::CreateContext();
- ImGuiIO& io = ImGui::GetIO();
- io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;
- io.ConfigFlags |= ImGuiConfigFlags_DockingEnable;
- ImGui::StyleColorsDark();
-
- ImGui_ImplGlfw_InitForVulkan(v.window, true);
- g_PrevScroll = glfwSetScrollCallback(v.window, donut_vk_scroll_callback); // chain ImGui + camera zoom
- ImGui_ImplVulkan_InitInfo info{};
- info.ApiVersion = VK_API_VERSION_1_2;
- info.Instance = v.instance;
- info.PhysicalDevice = v.physical;
- info.Device = v.device;
- info.QueueFamily = v.graphics_family;
- info.Queue = v.graphics_queue;
- info.DescriptorPool = v.imgui_pool;
- info.RenderPass = v.render_pass;
- info.MinImageCount = 2;
- info.ImageCount = (uint32_t)v.images.size();
- info.MSAASamples = VK_SAMPLE_COUNT_1_BIT;
- if (!ImGui_ImplVulkan_Init(&info))
- {
- DONUT_ERROR("Vulkan: ImGui_ImplVulkan_Init failed");
- return false;
- }
-
- v.imgui_init = true;
- DONUT_INFO("Vulkan: ImGui backend initialized");
- return true;
- }
-
- auto VulkanRenderer::resize(int width, int height) -> void
- {
- m_impl->framebuffer_resized = true;
- m_impl->width = width; m_impl->height = height;
- }
-
- auto VulkanRenderer::set_hdri(const std::string& path) -> void
- {
- Impl& v = *m_impl;
- if (v.device == VK_NULL_HANDLE || v.geo_set == VK_NULL_HANDLE) return;
- if (v.hdri_path == path) return;
- v.rebuild_hdri_cubemap(path.c_str());
- }
-
- auto VulkanRenderer::current_hdri() const -> const std::string&
- {
- return m_impl->hdri_path;
- }
-
- auto VulkanRenderer::set_free_fly(bool enabled) -> void
- {
- Impl& v = *m_impl;
- if (v.device == VK_NULL_HANDLE) return;
- const bool is_fps = v.camera.get_camera_mode() == CameraMode::FPS;
- if (enabled == is_fps) return;
-
- if (enabled)
- {
- // Seed the fly pose from the current orbital framing so the view is continuous.
- glm::vec3 pos = v.camera.get_orbital_position();
- glm::vec3 fwd = glm::normalize(v.camera.get_orbital_target() - pos);
- float pitch = glm::degrees(asin(glm::clamp(fwd.y, -1.0f, 1.0f)));
- float yaw = glm::degrees(atan2(fwd.z, fwd.x));
- v.camera.set_camera_mode(CameraMode::FPS);
- v.camera.set_movement_speed(2.0e10f); // scene spans ~1e11 units
- v.camera.set_mouse_sensitivity(0.15f);
- v.camera.set_position(pos);
- v.camera.set_rotation(glm::vec3(pitch, yaw, 0.0f));
- }
- else
- {
- v.camera.set_camera_mode(CameraMode::Orbital); // orbital state was left intact
- }
- }
-
- auto VulkanRenderer::is_free_fly() const -> bool
- {
- return m_impl->camera.get_camera_mode() == CameraMode::FPS;
- }
-
- auto VulkanRenderer::set_scene_mode(bool enabled) -> void
- {
- if (m_impl) m_impl->scene_mode = enabled;
- }
-
- auto VulkanRenderer::is_scene_mode() const -> bool
- {
- return m_impl && m_impl->scene_mode;
- }
-
- auto VulkanRenderer::scene_objects() -> std::vector<SceneObject>&
- {
- return m_impl->scene_objects;
- }
-
- auto VulkanRenderer::set_selected_object(int index) -> void
- {
- if (m_impl) m_impl->selected_object = index;
- }
-
- auto VulkanRenderer::black_hole_params() -> BlackHoleParams&
- {
- return m_impl->bh_params;
- }
-
- auto VulkanRenderer::reset_camera() -> void
- {
- if (!m_impl) return;
- Camera& cam = m_impl->camera;
- cam.set_camera_mode(CameraMode::Orbital); // also flips is_free_fly() back
- cam.set_orbital_radius(4e11);
- cam.set_azimuth(0.0f);
- cam.set_elevation(1.25f);
- }
-
- auto VulkanRenderer::device_name() const -> const std::string&
- {
- return m_impl->gpu_name;
- }
-
- auto VulkanRenderer::draw_frame(const glm::vec4& clear_color, const std::function<void()>& build_ui) -> void
- {
- Impl& v = *m_impl;
- if (v.device == VK_NULL_HANDLE) return;
-
- ImDrawData* draw_data = nullptr;
- if (v.imgui_init)
- {
- ImGui_ImplVulkan_NewFrame();
- ImGui_ImplGlfw_NewFrame();
- ImGui::NewFrame();
- if (build_ui) build_ui();
- ImGui::Render();
- draw_data = ImGui::GetDrawData();
- }
-
- vkWaitForFences(v.device, 1, &v.in_flight[v.current_frame], VK_TRUE, UINT64_MAX);
-
- uint32_t image_index = 0;
- VkResult r = vkAcquireNextImageKHR(v.device, v.swapchain, UINT64_MAX,
- v.image_available[v.current_frame], VK_NULL_HANDLE, &image_index);
- if (r == VK_ERROR_OUT_OF_DATE_KHR) { v.recreate_swapchain(); return; }
- if (r != VK_SUCCESS && r != VK_SUBOPTIMAL_KHR) { DONUT_ERROR("Vulkan: acquire failed ({})", (int)r); return; }
-
- if (v.images_in_flight[image_index] != VK_NULL_HANDLE)
- vkWaitForFences(v.device, 1, &v.images_in_flight[image_index], VK_TRUE, UINT64_MAX);
- v.images_in_flight[image_index] = v.in_flight[v.current_frame];
-
- // The geodesic offscreen image is shared across frames in flight; wait for
- // the previous frame to finish reading it before overwriting it this frame.
- if (v.geo_in_use != VK_NULL_HANDLE)
- vkWaitForFences(v.device, 1, &v.geo_in_use, VK_TRUE, UINT64_MAX);
- v.process_input();
- if (v.scene_mode) v.update_scene_uniforms(); else v.update_geodesic_uniforms();
-
- vkResetCommandBuffer(v.command_buffers[v.current_frame], 0);
- if (!v.record_command_buffer(v.command_buffers[v.current_frame], image_index, clear_color, draw_data)) return;
-
- VkPipelineStageFlags wait_stage = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
- VkSubmitInfo submit{ VK_STRUCTURE_TYPE_SUBMIT_INFO };
- submit.waitSemaphoreCount = 1;
- submit.pWaitSemaphores = &v.image_available[v.current_frame];
- submit.pWaitDstStageMask = &wait_stage;
- submit.commandBufferCount = 1;
- submit.pCommandBuffers = &v.command_buffers[v.current_frame];
- submit.signalSemaphoreCount = 1;
- submit.pSignalSemaphores = &v.render_finished[image_index];
-
- vkResetFences(v.device, 1, &v.in_flight[v.current_frame]);
- if (vkQueueSubmit(v.graphics_queue, 1, &submit, v.in_flight[v.current_frame]) != VK_SUCCESS)
- { DONUT_ERROR("Vulkan: queue submit failed"); return; }
- v.geo_in_use = v.in_flight[v.current_frame];
-
- VkPresentInfoKHR present{ VK_STRUCTURE_TYPE_PRESENT_INFO_KHR };
- present.waitSemaphoreCount = 1;
- present.pWaitSemaphores = &v.render_finished[image_index];
- present.swapchainCount = 1;
- present.pSwapchains = &v.swapchain;
- present.pImageIndices = &image_index;
- r = vkQueuePresentKHR(v.present_queue, &present);
- if (r == VK_ERROR_OUT_OF_DATE_KHR || r == VK_SUBOPTIMAL_KHR || v.framebuffer_resized)
- {
- v.framebuffer_resized = false;
- v.recreate_swapchain();
- }
-
- v.current_frame = (v.current_frame + 1) % MAX_FRAMES_IN_FLIGHT;
- }
-
- auto VulkanRenderer::shutdown() -> void
- {
- Impl& v = *m_impl;
- if (v.device == VK_NULL_HANDLE) { if (v.instance && v.surface) { vkDestroySurfaceKHR(v.instance, v.surface, nullptr); v.surface = VK_NULL_HANDLE; } if (v.instance) { vkDestroyInstance(v.instance, nullptr); v.instance = VK_NULL_HANDLE; } return; }
-
- vkDeviceWaitIdle(v.device);
- v.destroy_geodesic_resources();
- if (v.imgui_init)
- {
- ImGui_ImplVulkan_Shutdown();
- ImGui_ImplGlfw_Shutdown();
- ImGui::DestroyContext();
- v.imgui_init = false;
- }
- if (v.imgui_pool) { vkDestroyDescriptorPool(v.device, v.imgui_pool, nullptr); v.imgui_pool = VK_NULL_HANDLE; }
- for (auto s : v.render_finished) vkDestroySemaphore(v.device, s, nullptr);
- for (auto s : v.image_available) vkDestroySemaphore(v.device, s, nullptr);
- for (auto f : v.in_flight) vkDestroyFence(v.device, f, nullptr);
- v.render_finished.clear(); v.image_available.clear(); v.in_flight.clear();
- if (v.command_pool) { vkDestroyCommandPool(v.device, v.command_pool, nullptr); v.command_pool = VK_NULL_HANDLE; }
- v.cleanup_swapchain();
- vkDestroyDevice(v.device, nullptr); v.device = VK_NULL_HANDLE;
- if (v.surface) { vkDestroySurfaceKHR(v.instance, v.surface, nullptr); v.surface = VK_NULL_HANDLE; }
- if (v.instance) { vkDestroyInstance(v.instance, nullptr); v.instance = VK_NULL_HANDLE; }
- }
-}
diff --git a/src/platform/vulkan/vulkan_renderer.h b/src/platform/vulkan/vulkan_renderer.h
deleted file mode 100644
index d583f07..0000000
--- a/src/platform/vulkan/vulkan_renderer.h
+++ /dev/null
@@ -1,50 +0,0 @@
-#pragma once
-
-#include "rendering/renderer_backend.h"
-
-// Live-window Vulkan backend: owns the instance, surface, device, swapchain,
-// render pass, framebuffers and per-frame synchronization, and drives the
-// acquire -> record -> submit -> present loop. Implements the shared
-// RendererBackend interface (SceneObject / BlackHoleParams live there). Pure-C++
-// header (no vulkan.h / glfw leak); the GLFW window is passed as an opaque handle.
-namespace Donut
-{
- // Must be called BEFORE glfwInit() when the Vulkan API is selected: points
- // GLFW at the loader the app links against (GLFW's own dlopen fails on
- // macOS/Homebrew) and configures the MoltenVK ICD / layer paths.
- auto vulkan_prepare_glfw() -> void;
-
- class VulkanRenderer : public RendererBackend
- {
- public:
- VulkanRenderer();
- ~VulkanRenderer() override;
-
- // glfwWindow must be a GLFW window created with GLFW_NO_API.
- auto init(void* glfwWindow, int width, int height) -> bool override;
- auto init_ui() -> bool override;
- auto shutdown() -> void override;
- auto resize(int width, int height) -> void override;
-
- auto draw_frame(const glm::vec4& clear_color,
- const std::function<void()>& build_ui) -> void override;
-
- auto set_scene_mode(bool enabled) -> void override;
- auto is_scene_mode() const -> bool override;
- auto set_free_fly(bool enabled) -> void override; // seeds the fly pose from the orbital framing
- auto is_free_fly() const -> bool override;
- auto reset_camera() -> void override;
-
- auto set_hdri(const std::string& path) -> void override; // rebuilds the cubemap (device-idle)
- auto current_hdri() const -> const std::string& override;
- auto scene_objects() -> std::vector<SceneObject>& override;
- auto set_selected_object(int index) -> void override;
- auto black_hole_params() -> BlackHoleParams& override;
-
- auto device_name() const -> const std::string& override;
-
- private:
- struct Impl;
- Impl* m_impl = nullptr;
- };
-}