From 2b2d374eb642edf345f93fa559e8cd7d76a0c9d1 Mon Sep 17 00:00:00 2001 From: ladevieq Date: Sun, 26 Jan 2025 22:14:47 +0100 Subject: Fix mesh loading for new API --- include/gltf.hpp | 5 +++ include/material.hpp | 9 ++++ include/mesh.hpp | 10 +++++ include/scene.hpp | 22 ++++++++++ include/vec3.hpp | 9 +++- shaders/CMakeLists.txt | 2 +- shaders/compute.comp | 17 +++++--- shaders/test.comp | 10 ++++- src/CMakeLists.txt | 16 +++++-- src/gltf.cpp | 116 +++++++++++++++++++++++++++++++++++++++++++++++-- src/scene.cpp | 114 +++++++++++++++++++++++++++++++++++++++++++++++- src/vec3.cpp | 4 +- 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 meshes; std::vector materials; +#ifdef API_TEST + std::vector> textures; + // handle samplers; +#else std::vector textures; +#endif // API_TEST std::vector> 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 base_color_texture; + handle 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 #include +#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 submeshes; struct gpu_mesh { +#ifdef API_TEST + std::array, ATTRIBUTE_TYPE::MAX_ATTRIBUTE> attributes; + const device_buffer& indices; + const device_buffer& submeshes; +#else std::array 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 +#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 scene_buffer_handle; + handle indices_buffer_handle; + handle positions_buffer_handle; + handle normals_buffer_handle; + handle uvs_buffer_handle; + handle bvh_buffer_handle; + handle 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 #include +#ifndef API_TEST #define STB_IMAGE_IMPLEMENTATION +#endif #include #include "utils.hpp" +#ifdef API_TEST +#include "vk-device-types.hpp" +#include "vk-device.hpp" +#include +#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 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 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()).string(); @@ -130,14 +182,69 @@ void gltf::load_textures(const std::filesystem::path& path) { // auto samplers_count = gltf_samplers.size(); // std::vector 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> 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()]; + // if (gltf_texture.contains("sampler")) { + // auto sampler_index = gltf_texture["sampler"].get(); + // sampler = samplers[sampler_index]; + // } + + auto texture = device.create_texture({ + .width = static_cast(image.width), + .height = static_cast(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(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 #include +#ifdef API_TEST +#include +#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 indices; std::vector 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::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::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(scene_buffer.mapped_ptr); + memcpy(static_cast(ptr), &meta, sizeof(meta)); + memcpy(static_cast(ptr + sizeof(meta)), &meta, sizeof(meta)); + memcpy(static_cast(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) }; } -- cgit v1.3