Fix mesh loading for new API

12 files changed, 311 insertions, 23 deletions

diff --git a/include/gltf.hpp b/include/gltf.hpp
index 6e89509..1ccaf56 100644
--- a/include/gltf.hpp
+++ b/include/gltf.hpp
@@ -49,7 +49,12 @@ private:
     json gltf_json;

     std::vector<Mesh> meshes;

     std::vector<material> materials;

+#ifdef API_TEST

+    std::vector<handle<device_texture>> textures;

+    // handle<device_sampler> samplers;

+#else

     std::vector<Texture*> textures;

+#endif // API_TEST

     std::vector<std::vector<uint8_t>> buffers;

 };

 

diff --git a/include/material.hpp b/include/material.hpp
index 71dd4ca..35710d2 100644
--- a/include/material.hpp
+++ b/include/material.hpp
@@ -4,12 +4,21 @@
 
 #include "vec3.hpp"
 
+#ifdef API_TEST
+#include "vk-device-types.hpp"
+#else
 class Texture;
+#endif
 
 struct material {
     color base_color;
+#ifdef API_TEST
+    handle<device_texture> base_color_texture;
+    handle<device_texture> metallic_roughness_texture;
+#else
     Texture* base_color_texture;
     Texture* metallic_roughness_texture;
+#endif // API_TEST
     float metalness = 1.f;
     float roughness = 1.f;
 };
diff --git a/include/mesh.hpp b/include/mesh.hpp
index 9a30be6..b88896d 100644
--- a/include/mesh.hpp
+++ b/include/mesh.hpp
@@ -4,7 +4,11 @@
 #include <vector>
 #include <array>
 
+#ifdef API_TEST
+#include "vk-device-types.hpp"
+#else
 #include "vk-renderer.hpp"
+#endif // API_TEST
 
 enum ATTRIBUTE_TYPE {
     POSITION,
@@ -89,9 +93,15 @@ private:
     std::vector<submesh_info> submeshes;
 
     struct gpu_mesh {
+#ifdef API_TEST
+        std::array<handle<device_buffer>, ATTRIBUTE_TYPE::MAX_ATTRIBUTE> attributes;
+        const device_buffer& indices;
+        const device_buffer& submeshes;
+#else
         std::array<Buffer*, ATTRIBUTE_TYPE::MAX_ATTRIBUTE> attributes;
         Buffer* indices;
         Buffer* submeshes;
+#endif // API_TEST
     };
 
     // allocate gpu mesh upon instanciation
diff --git a/include/scene.hpp b/include/scene.hpp
index 78b90b7..ad298da 100644
--- a/include/scene.hpp
+++ b/include/scene.hpp
@@ -3,6 +3,10 @@
 

 #include <cstdint>

 

+#ifdef API_TEST

+#include "vk-device-types.hpp"

+#include "vk-device.hpp"

+#endif // API_TEST

 #include "camera.hpp"

 

 class Buffer;

@@ -33,6 +37,23 @@ public:
 

     metadata meta;

 

+#ifdef API_TEST

+    handle<device_buffer>    scene_buffer_handle;

+    handle<device_buffer>    indices_buffer_handle;

+    handle<device_buffer>    positions_buffer_handle;

+    handle<device_buffer>    normals_buffer_handle;

+    handle<device_buffer>    uvs_buffer_handle;

+    handle<device_buffer>    bvh_buffer_handle;

+    handle<device_buffer>    materials_buffer_handle;

+

+    uint64_t scene_buffer_address() { return vkdevice::get_render_device().get_buffer(scene_buffer_handle).device_address; };

+    uint64_t indices_buffer_address() { return vkdevice::get_render_device().get_buffer(indices_buffer_handle).device_address; };

+    uint64_t positions_buffer_address() { return vkdevice::get_render_device().get_buffer(positions_buffer_handle).device_address; };

+    uint64_t normals_buffer_address() { return vkdevice::get_render_device().get_buffer(normals_buffer_handle).device_address; };

+    uint64_t uvs_buffer_address() { return vkdevice::get_render_device().get_buffer(uvs_buffer_handle).device_address; };

+    uint64_t bvh_buffer_address() { return vkdevice::get_render_device().get_buffer(bvh_buffer_handle).device_address; };

+    uint64_t materials_buffer_address() { return vkdevice::get_render_device().get_buffer(materials_buffer_handle).device_address; };

+#else

     Buffer*                 scene_buffer;

     Buffer*                 indices_buffer;

     Buffer*                 positions_buffer;

@@ -40,6 +61,7 @@ public:
     Buffer*                 uvs_buffer;

     Buffer*                 bvh_buffer;

     Buffer*                 materials_buffer;

+#endif // API_TEST

 };

 

 #endif // !__SCENE_HPP_

diff --git a/include/vec3.hpp b/include/vec3.hpp
index 75b67d2..968f3ed 100644
--- a/include/vec3.hpp
+++ b/include/vec3.hpp
@@ -6,8 +6,10 @@
 
 struct vec3u {
     union {
-        uint32_t vec[3];
-        uint32_t x, y, z;
+        uint32_t arr[3];
+        struct {
+            uint32_t x, y, z;
+        } vec;
     };
 };
 
@@ -36,6 +38,9 @@ class vec3 {
 
     vec3 operator>(const vec3& vec) const;
 
+    [[nodiscard]]vec3 (min)(const vec3& vec) const;
+    [[nodiscard]]vec3 (max)(const vec3& vec) const;
+
     float operator[](int axis);
 
     [[nodiscard]] float length() const;
diff --git a/shaders/CMakeLists.txt b/shaders/CMakeLists.txt
index f572ced..8f6985f 100644
--- a/shaders/CMakeLists.txt
+++ b/shaders/CMakeLists.txt
@@ -13,7 +13,7 @@ foreach(GLSL ${GLSL_SOURCE_FILES})
   set(SPIRV "${PROJECT_BINARY_DIR}/shaders/${FILE_NAME}.spv")
   add_custom_command(
     OUTPUT ${SPIRV}
-    COMMAND glslc --target-env=vulkan1.2 -std=460 ${GLSL} -o ${SPIRV} -I "../../shaders/include" # relative to build directory
+    COMMAND glslc --target-env=vulkan1.2 -g -O -std=460 ${GLSL} -o ${SPIRV} -I "../../shaders/include" # relative to build directory
     DEPENDS ${GLSL})
   list(APPEND SPIRV_BINARY_FILES ${SPIRV})
 endforeach(GLSL)
diff --git a/shaders/compute.comp b/shaders/compute.comp
index 92fa9db..14f1238 100644
--- a/shaders/compute.comp
+++ b/shaders/compute.comp
@@ -142,13 +142,15 @@ vec3 ray_color(ray r, uint seed) {
         vec3 diffuse_color = srgb_to_linear(texture(
             sampler2D(
                 textures[nonuniformEXT(tri.mat.base_color_texture.texture_id)],
-                samplers[nonuniformEXT(tri.mat.base_color_texture.sampler_id)]
+                // samplers[nonuniformEXT(tri.mat.base_color_texture.sampler_id)]
+                samplers[1]
             ), uv
         ).xyz) * tri.mat.base_color.xyz;
         vec2 metalness_roughness = texture(
             sampler2D(
                 textures[nonuniformEXT(tri.mat.metallic_roughness_texture.texture_id)],
-                samplers[nonuniformEXT(tri.mat.metallic_roughness_texture.sampler_id)]
+                // samplers[nonuniformEXT(tri.mat.metallic_roughness_texture.sampler_id)]
+                samplers[1]
             ), uv
         ).xy * vec2(tri.mat.metalness, tri.mat.roughness);
 
@@ -281,9 +283,10 @@ void main() {
     vec3 acc_color = srgb_to_linear(imageLoad(images[nonuniformEXT(bufs.accumulation_image_index)], coords).xyz);
     out_color = linear_to_srgb(mix(acc_color, out_color, spp_scale));
 
-    for (uint i = 0; i < bufs.scene.downscale_factor; i++) {
-        for (uint j = 0; j < bufs.scene.downscale_factor; j++) {
-            imageStore(images[nonuniformEXT(bufs.output_image_index)], coords + ivec2(i, j), vec4(out_color, 1.0));
-        }
-    }
+    // for (uint i = 0; i < bufs.scene.downscale_factor; i++) {
+    //     for (uint j = 0; j < bufs.scene.downscale_factor; j++) {
+    //         imageStore(images[nonuniformEXT(bufs.output_image_index)], coords + ivec2(i, j), vec4(out_color, 1.0));
+    //     }
+    // }
+    imageStore(images[nonuniformEXT(bufs.output_image_index)], coords, vec4(out_color, 1.0));
 }
diff --git a/shaders/test.comp b/shaders/test.comp
index b3d2089..a17de69 100644
--- a/shaders/test.comp
+++ b/shaders/test.comp
@@ -6,10 +6,18 @@ layout(local_size_x = 8, local_size_y = 8, local_size_z = 1) in;
 layout(set = 0, binding = 0) uniform sampler samplers[];
 layout(set = 0, binding = 1) uniform texture2D textures[];
 layout(set = 0, binding = 2, rgba32f) uniform image2D images[];
-layout(set = 2, binding = 0) uniform parameters {
+// layout(set = 2, binding = 0) uniform parameters {
+//     uint input_id1;
+//     uint input_id2;
+//     uint output_id;
+// } params;
+layout(push_constant) uniform parameters {
     uint input_id1;
+    uint padding1;
     uint input_id2;
+    uint padding2;
     uint output_id;
+    uint padding3;
 } params;
 
 void main() {
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 1f514f0..d482ddf 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,6 +1,6 @@
 set(LIBRARIES imgui::imgui)
 
-set(DEFINES -DNOMINMAX -D_USE_MATH_DEFINES -DVK_NO_PROTOTYPES)
+set(DEFINES -DNOMINMAX -D_USE_MATH_DEFINES -DVK_NO_PROTOTYPES TRACY_ENABLE)
 
 if(UNIX AND NOT APPLE)
     set(DEFINES ${DEFINES} -DLINUX -DVK_USE_PLATFORM_XCB_KHR)
@@ -30,6 +30,8 @@ add_executable(
     bvh.cpp
     mesh.cpp
     resource-manager.cpp
+
+    ${CMAKE_SOURCE_DIR}/tracy/public/TracyClient.cpp
 )
 
 if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
@@ -57,11 +59,17 @@ target_link_directories(path-tracer PRIVATE "C:\\Program Files\\LLVM\\lib\\clang
 
 target_compile_definitions(path-tracer PUBLIC ${DEFINES})
 
-target_include_directories(path-tracer SYSTEM PUBLIC ${CMAKE_SOURCE_DIR}/thirdparty)
+target_include_directories(path-tracer
+    SYSTEM PUBLIC
+
+    ${CMAKE_SOURCE_DIR}/thirdparty
+    ${CMAKE_SOURCE_DIR}/tracy/public
+    ${Vulkan_INCLUDE_DIRS}
 
-target_include_directories(path-tracer SYSTEM PUBLIC ${Vulkan_INCLUDE_DIRS})
+    PUBLIC
 
-target_include_directories(path-tracer PUBLIC ${CMAKE_SOURCE_DIR}/include)
+    ${CMAKE_SOURCE_DIR}/include
+)
 
 if(UNIX AND NOT APPLE)
     target_include_directories(path-tracer PUBLIC ${X11_xcb_INCLUDE_PATH})
diff --git a/src/gltf.cpp b/src/gltf.cpp
index 0e611da..1d3d935 100644
--- a/src/gltf.cpp
+++ b/src/gltf.cpp
@@ -5,16 +5,32 @@
 #include <filesystem>
 #include <fstream>
 
+#ifndef API_TEST
 #define STB_IMAGE_IMPLEMENTATION
+#endif
 #include <stb_image.h>
 
 #include "utils.hpp"
+#ifdef API_TEST
+#include "vk-device-types.hpp"
+#include "vk-device.hpp"
+#include <vk_mem_alloc.h>
+#else
 #include "vk-renderer.hpp"
+#endif
+
+#ifdef TRACY_ENABLE
+#include "tracy/Tracy.hpp"
+#endif
 
 gltf::gltf(const std::filesystem::path& filepath) {
     auto parent_path = filepath.parent_path();
     std::fstream f{ filepath };
 
+    if (!f.is_open()) {
+        OutputDebugStringA("failed to open!");
+    }
+
     f >> gltf_json;
 
     auto& scene = gltf_json["scenes"][0];
@@ -119,6 +135,42 @@ void gltf::load_textures(const std::filesystem::path& path) {
     std::vector<size_t> v(images_count);
     std::iota(v.begin(), v.end(), 0);
 
+    const auto& gltf_textures = gltf_json["textures"];
+    auto textures_count = gltf_textures.size();
+    textures.resize(textures_count);
+
+#ifdef API_TEST
+    auto& device = vkdevice::get_render_device();
+
+    constexpr auto buffers_count = 2U;
+    auto total_size = images_count * 4096U * 4096 * sizeof(uint32_t);
+    auto buffer_size = total_size / 32U;
+
+    handle<device_buffer> staging_buffers_handle[buffers_count] = {
+        device.create_buffer({
+            .size = buffer_size,
+            .usages = VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
+            .memory_properties = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
+            .memory_usage = VMA_MEMORY_USAGE_CPU_TO_GPU,
+        }),
+        device.create_buffer({
+            .size = buffer_size,
+            .usages = VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
+            .memory_properties = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
+            .memory_usage = VMA_MEMORY_USAGE_CPU_TO_GPU,
+        }),
+    };
+
+    graphics_command_buffer command_buffers[buffers_count];
+    device.allocate_command_buffers(command_buffers, buffers_count, QueueType::GRAPHICS);
+    auto buffer_index = 0U;
+    auto command_buffer = command_buffers[buffer_index];
+    auto buffer_handle = staging_buffers_handle[buffer_index];
+    auto buffer = device.get_buffer(buffer_handle);
+
+    command_buffer.start();
+#endif // API_TEST
+
     std::for_each(std::execution::par, v.begin(), v.end(), [&](const size_t image_index) {
         const auto& gltf_image = gltf_images[image_index];
         auto filepath = (path / gltf_image["uri"].get<std::string>()).string();
@@ -130,14 +182,69 @@ void gltf::load_textures(const std::filesystem::path& path) {
     // auto samplers_count = gltf_samplers.size();
     // std::vector<Sampler *> samplers{samplers_count};
 
-    Sampler* sampler = vkrenderer::create_sampler(VK_FILTER_LINEAR, VK_SAMPLER_ADDRESS_MODE_REPEAT);
+#ifdef API_TEST
+    const auto &gltf_samplers = gltf_json["samplers"];
+    auto samplers_count = gltf_samplers.size();
+    std::vector<handle<device_sampler>> samplers{samplers_count};
+
+    // auto sampler = device.create_sampler(VK_FILTER_LINEAR, VK_SAMPLER_ADDRESS_MODE_REPEAT);
     // for (size_t sampler_index = 0; sampler_index < samplers_count; sampler_index++) {
     //     samplers[sampler_index] = vkrenderer::create_sampler(VK_FILTER_LINEAR, VK_SAMPLER_ADDRESS_MODE_REPEAT);
     // }
 
-    const auto& gltf_textures = gltf_json["textures"];
-    auto textures_count = gltf_textures.size();
-    textures.resize(textures_count);
+    for (size_t texture_index = 0; texture_index < textures_count; texture_index++) {
+        auto gltf_texture = gltf_textures[texture_index];
+        auto& image = images[gltf_texture["source"].get<uint32_t>()];
+        // if (gltf_texture.contains("sampler")) {
+        //     auto sampler_index = gltf_texture["sampler"].get<uint32_t>();
+        //     sampler = samplers[sampler_index];
+        // }
+
+        auto texture = device.create_texture({
+            .width  = static_cast<uint32_t>(image.width),
+            .height = static_cast<uint32_t>(image.height),
+            .usages = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
+            .format = VK_FORMAT_R8G8B8A8_UNORM,
+            .type   = VK_IMAGE_TYPE_2D,
+        });
+
+        uint64_t size = image.width * image.height * sizeof(uint32_t);
+        auto offset = buffer.offset;
+        if (offset + size > buffer_size) {
+            command_buffer.stop();
+
+            device.submit(&command_buffer, 1 );
+
+            buffer_index = (++buffer_index) % buffers_count;
+            command_buffer = command_buffers[buffer_index];
+            buffer_handle = staging_buffers_handle[buffer_index];
+            buffer = device.get_buffer(buffer_handle);
+            buffer.reset();
+            device.wait();
+            command_buffer.start();
+            offset = 0U;
+        }
+
+        void* ptr = buffer.allocate(size);
+        memcpy(ptr, image.data, size);
+
+        command_buffer.barrier(texture, VK_PIPELINE_STAGE_2_TRANSFER_BIT, VK_ACCESS_2_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
+        command_buffer.copy(buffer_handle, texture, static_cast<VkDeviceSize>(offset));
+        command_buffer.barrier(texture, VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT, VK_ACCESS_2_SHADER_WRITE_BIT, VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL);
+
+        textures[texture_index] = texture;
+    }
+
+    command_buffer.stop();
+    device.submit(&command_buffer, 1);
+    device.wait();
+    device.destroy_buffer(staging_buffers_handle[0]);
+    device.destroy_buffer(staging_buffers_handle[1]);
+#else
+    Sampler* sampler = vkrenderer::create_sampler(VK_FILTER_LINEAR, VK_SAMPLER_ADDRESS_MODE_REPEAT);
+    // for (size_t sampler_index = 0; sampler_index < samplers_count; sampler_index++) {
+    //     samplers[sampler_index] = vkrenderer::create_sampler(VK_FILTER_LINEAR, VK_SAMPLER_ADDRESS_MODE_REPEAT);
+    // }
 
     for (size_t texture_index = 0; texture_index < textures_count; texture_index++) {
         auto gltf_texture = gltf_textures[texture_index];
@@ -154,6 +261,7 @@ void gltf::load_textures(const std::filesystem::path& path) {
 
         textures[texture_index] = texture;
     }
+#endif
 }
 
 void gltf::load_materials() {
diff --git a/src/scene.cpp b/src/scene.cpp
index 9980e75..b70026a 100644
--- a/src/scene.cpp
+++ b/src/scene.cpp
@@ -3,7 +3,12 @@
 #include <filesystem>

 #include <queue>

 

+#ifdef API_TEST

+#include <vk_mem_alloc.h>

+#else

 #include "vk-renderer.hpp"

+#endif // API_TEST

+

 #include "gltf.hpp"

 #include "bvh.hpp"

 #include "material.hpp"

@@ -64,6 +69,10 @@ scene::metadata::metadata(const camera &cam, uint32_t width, uint32_t height)
 scene::scene(const camera& cam, uint32_t width, uint32_t height)

     :meta(cam, width, height){

 

+#ifdef API_TEST

+    auto& device = vkdevice::get_render_device();

+#endif

+

     // Geometry & BVH

     std::vector<uint32_t>       indices;

     std::vector<float>          positions;

@@ -145,7 +154,7 @@ scene::scene(const camera& cam, uint32_t width, uint32_t height)
 //                 const auto& albedo_image = vkrenderer::api.get_image(material.base_color_texture->device_image);

 //                 const auto& albedo_sampler = vkrenderer::api.get_sampler(material.base_color_texture->sampler->device_sampler);

 

-                materials.emplace_back(gpu_material {

+                auto& mat = materials.emplace_back(gpu_material {

                     .base_color = material.base_color,

 //                     .albedo_texture_id = albedo_image.bindless_sampled_index,

 //                     .albedo_texture_sampler_id = albedo_sampler.bindless_index,

@@ -153,14 +162,26 @@ scene::scene(const camera& cam, uint32_t width, uint32_t height)
                     .roughness = material.roughness

                 });

 

+#ifdef API_TEST

+                if (material.base_color_texture.id != handle<device_texture>::invalid_id) {

+                    mat.albedo_texture_id = device.get_texture(material.base_color_texture).get_sampled_index();

+                    // mat.albedo_texture_sampler_id = device.get_sampler(0);

+                }

+

+                if (material.metallic_roughness_texture.id != handle<device_texture>::invalid_id) {

+                    mat.metallic_roughness_texture_id = device.get_texture(material.metallic_roughness_texture).get_sampled_index();

+                    // mat.metallic_roughness_texture_sampler_id = device.get_sampler(0);

+                }

+#else

                 if (material.metallic_roughness_texture != nullptr) {

-                    auto& gpu_material = materials.back();

+                    // auto& gpu_material = materials.back();

 //                     const auto& metallic_roughness_image = vkrenderer::api.get_image(material.metallic_roughness_texture->device_image);

 //                     const auto& metallic_roughness_sampler = vkrenderer::api.get_sampler(material.metallic_roughness_texture->sampler->device_sampler);

 

 //                    gpu_material.metallic_roughness_texture_id = metallic_roughness_image.bindless_sampled_index;

 //                    gpu_material.metallic_roughness_texture_sampler_id = metallic_roughness_sampler.bindless_index;

                 }

+#endif

 

             }

 

@@ -180,6 +201,94 @@ scene::scene(const camera& cam, uint32_t width, uint32_t height)
     bvh builder(triangles, packed_nodes);

     // bvh builder(spheres, packed_nodes);

 

+#ifdef API_TEST

+    {

+        scene_buffer_handle = device.create_buffer({

+            .size = sizeof(meta) * 3U,

+            .usages = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,

+            .memory_properties = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,

+            .memory_usage = VMA_MEMORY_USAGE_CPU_TO_GPU,

+        });

+

+        const auto& scene_buffer = device.get_buffer(scene_buffer_handle);

+        uint8_t* ptr = static_cast<uint8_t*>(scene_buffer.mapped_ptr);

+        memcpy(static_cast<void*>(ptr), &meta, sizeof(meta));

+        memcpy(static_cast<void*>(ptr + sizeof(meta)), &meta, sizeof(meta));

+        memcpy(static_cast<void*>(ptr + sizeof(meta) * 2U), &meta, sizeof(meta));

+    }

+

+    {

+        indices_buffer_handle = device.create_buffer({

+            .size = indices.size() * sizeof(indices[0]),

+            .usages = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,

+            .memory_properties = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,

+            .memory_usage = VMA_MEMORY_USAGE_CPU_TO_GPU,

+        });

+        const auto& indices_buffer = device.get_buffer(indices_buffer_handle);

+        void* ptr = indices_buffer.mapped_ptr;

+        memcpy(ptr, indices.data(), indices.size() * sizeof(indices[0]));

+    }

+

+    {

+        positions_buffer_handle = device.create_buffer({

+            .size = positions.size() * sizeof(positions[0]),

+            .usages = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,

+            .memory_properties = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,

+            .memory_usage = VMA_MEMORY_USAGE_CPU_TO_GPU,

+        });

+        const auto& positions_buffer = device.get_buffer(positions_buffer_handle);

+        void* ptr = positions_buffer.mapped_ptr;

+        memcpy(ptr, positions.data(), positions.size() * sizeof(positions[0]));

+    }

+

+    {

+        normals_buffer_handle = device.create_buffer({

+            .size = normals.size() * sizeof(normals[0]),

+            .usages = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,

+            .memory_properties = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,

+            .memory_usage = VMA_MEMORY_USAGE_CPU_TO_GPU,

+        });

+        const auto& normals_buffer = device.get_buffer(normals_buffer_handle);

+        void* ptr = normals_buffer.mapped_ptr;

+        memcpy(ptr, normals.data(), normals.size() * sizeof(normals[0]));

+    }

+

+    {

+        uvs_buffer_handle = device.create_buffer({

+            .size = uvs.size() * sizeof(uvs[0]),

+            .usages = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,

+            .memory_properties = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,

+            .memory_usage = VMA_MEMORY_USAGE_CPU_TO_GPU,

+        });

+        const auto& uvs_buffer = device.get_buffer(uvs_buffer_handle);

+        void* ptr = uvs_buffer.mapped_ptr;

+        memcpy(ptr, uvs.data(), uvs.size() * sizeof(uvs[0]));

+    }

+

+    {

+        bvh_buffer_handle = device.create_buffer({

+            .size = packed_nodes.size() * sizeof(packed_nodes[0]),

+            .usages = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,

+            .memory_properties = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,

+            .memory_usage = VMA_MEMORY_USAGE_CPU_TO_GPU,

+        });

+        const auto& bvh_buffer = device.get_buffer(bvh_buffer_handle);

+        void* ptr = bvh_buffer.mapped_ptr;

+        memcpy(ptr, packed_nodes.data(), packed_nodes.size() * sizeof(packed_nodes[0]));

+    }

+

+    {

+        materials_buffer_handle = device.create_buffer({

+            .size = materials.size() * sizeof(materials[0]),

+            .usages = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,

+            .memory_properties = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,

+            .memory_usage = VMA_MEMORY_USAGE_CPU_TO_GPU,

+        });

+        const auto& materials_buffer = device.get_buffer(materials_buffer_handle);

+        void* ptr = materials_buffer.mapped_ptr;

+        memcpy(ptr, materials.data(), materials.size() * sizeof(materials[0]));

+    }

+#else

     scene_buffer = vkrenderer::create_buffer(sizeof(meta) * vkrenderer::virtual_frames_count);

     scene_buffer->write(&meta, 0, sizeof(meta));

     scene_buffer->write(&meta, sizeof(meta), sizeof(meta));

@@ -202,4 +311,5 @@ scene::scene(const camera& cam, uint32_t width, uint32_t height)
 

     materials_buffer = vkrenderer::create_buffer(materials.size() * sizeof(materials[0]));

     materials_buffer->write(materials.data(), 0, materials.size() * sizeof(materials[0]));

+#endif // API_TEST

 }

diff --git a/src/vec3.cpp b/src/vec3.cpp
index 0e08f16..73dec98 100644
--- a/src/vec3.cpp
+++ b/src/vec3.cpp
@@ -73,11 +73,11 @@ vec3 vec3::cross(const vec3& vec) const {
     return _mm_sub_ps(tmp3, tmp4);
 }
 
-vec3 vec3::min(const vec3& vec) const {
+vec3 (vec3::min)(const vec3& vec) const {
     return { _mm_min_ps(v, vec.v) };
 }
 
-vec3 vec3::max(const vec3& vec) const {
+vec3 (vec3::max)(const vec3& vec) const {
     return { _mm_max_ps(v, vec.v) };
 }