ouczbs/idk_me
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: ouczbs:3ba604a91047c45f1136ce410631bfcf85612816
Branches Tags
ouczbs:main
...
compare: ouczbs:228fafbbbbf8e10b623272d1a0d5d40cd50d508c
Branches Tags
ouczbs:main

2 Commits
3ba604a910 ... 228fafbbbb

Author SHA1 Message Date
ouczbs
228fafbbbb 修改暂时还原 2024-05-24 22:58:23 +08:00
ouczbs
e48f56135a 还原 idk 代码 2024-05-24 22:57:42 +08:00
37 changed files with 146 additions and 142 deletions
Show Stats Expand all files Collapse all files

2
src/engine/asset_compiler/asset_compiler.vcxproj
View File

@ -190,7 +190,7 @@ if %errorlevel% NEQ 0 exit /b %errorlevel%</Command>
<Link>
<SubSystem>Console</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
<AdditionalDependencies>assimp-vc142-mt.lib;coreD.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;freetype.lib;%(AdditionalDependencies)</AdditionalDependencies>
<AdditionalDependencies>assimp-vc142-mt.lib;coreD.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
<AdditionalOptions> /ignore:4099 %(AdditionalOptions)</AdditionalOptions>
</Link>
<CustomBuildStep>

BIN
src/engine/default_lut.tga Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 12 KiB

2
src/engine/editor/IDE.h
View File

@ -21,7 +21,7 @@ Accessible through Core::GetSystem<IDE>() [#include <IDE.h>]
#include <editor/commands/CommandController.h>
#include <editor/Registry.h>
#include <editor/ObjectSelection.h>
//#include "windows/IGE_IWindow.h"
#undef FindWindow
namespace idk

4
src/engine/editor/windows/IGE_InspectorWindow_DisplayComponentInnerSpecializations.cpp
View File

@ -176,11 +176,11 @@ namespace idk
ImGui::TextDisabled("Values driven by Canvas.");
return;
}
/*if (c_rt->GetGameObject()->HasComponent<AspectRatioFitter>())
if (c_rt->GetGameObject()->HasComponent<AspectRatioFitter>())
{
ImGui::TextDisabled("Values driven by AspectRatioFitter.");
return;
}*/
}
const float region_width = ImGui::GetWindowContentRegionWidth();

4
src/engine/editorstatic/DescriptorPoolManager.cpp
View File

@ -34,7 +34,7 @@ namespace vknu
,hlp::arr_count(pool_size)
,std::data(pool_size)
};
pool = device.createDescriptorPoolUnique(create_info, nullptr, vk::DispatchLoaderStatic{});
pool = device.createDescriptorPoolUnique(create_info, nullptr, vk::DispatchLoaderDefault{});
}
DescriptorPoolsManager::DescriptorPoolsManager(VkDevice device) : _device{device}
{
@ -51,7 +51,7 @@ namespace vknu
void DescriptorPoolsManager::ResetManager(Manager& manager)
{
vk::Device d = _device;
d.resetDescriptorPool(*manager.pool, vk::DescriptorPoolResetFlags{}, vk::DispatchLoaderStatic{});
d.resetDescriptorPool(*manager.pool, vk::DescriptorPoolResetFlags{}, vk::DispatchLoaderDefault{});
manager.size = 0;
}

1
src/engine/game/AddSystems.cpp
View File

@ -15,7 +15,6 @@
#include <opengl/resource/OpenGLMesh.h>
#include <opengl/resource/OpenGLTexture.h>
#include <editor/IDE.h>
#include <windows/IGE_IWindow.h>
#include <file/FileSystem.h>
#include <debug/LogSystem.h>

2
src/engine/game/game.vcxproj
View File

@ -152,7 +152,7 @@
<Link>
<SubSystem>Windows</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
<AdditionalDependencies>kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies);coreD.lib;win32D.lib;vulkanD.lib;idk_openglD.lib;editorD.lib;glslangd.lib</AdditionalDependencies>
<AdditionalDependencies>kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies);coreD.lib;win32D.lib;vulkanD.lib;idk_openglD.lib;editorD.lib</AdditionalDependencies>
<AdditionalLibraryDirectories>
</AdditionalLibraryDirectories>
<AdditionalOptions>/ignore:4006 /ignore:4075 /ignore:4099 %(AdditionalOptions)</AdditionalOptions>

8
src/engine/idk.ruleset Normal file
View File

@ -0,0 +1,8 @@
<?xml version="1.0" encoding="utf-8"?>
<RuleSet Name="idk" ToolsVersion="16.0">
<Include Path="cppcorecheckconstrules.ruleset" Action="Default" />
<Include Path="cppcorecheckstylerules.ruleset" Action="Default" />
<Rules AnalyzerId="Microsoft.Analyzers.NativeCodeAnalysis" RuleNamespace="Microsoft.Rules.Native">
<Rule Id="C26438" Action="None" />
</Rules>
</RuleSet>

2
src/engine/idk/IDK.vcxproj
View File

@ -819,7 +819,7 @@
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>_ENABLE_EXTENDED_ALIGNED_STORAGE;_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<LanguageStandard>stdcpp20</LanguageStandard>
<LanguageStandard>stdcpplatest</LanguageStandard>
<MultiProcessorCompilation>true</MultiProcessorCompilation>
<DisableSpecificWarnings>4201; 4505</DisableSpecificWarnings>
<AdditionalIncludeDirectories>$(ProjectDir);$(SolutionDir)dep\include\;%VULKAN_SDK%\Include\</AdditionalIncludeDirectories>

2
src/engine/idk/res/ResourceHandle.inl
View File

@ -2,10 +2,10 @@
#include <type_traits>
#include <res/Resource.h>
#include <res/ResourceUtils.inl>
#include <res/ResourceManager.inl>
#include <math/comparable.inl>
#include <res/Guid.inl>
namespace idk
{
template<typename Res>

2
src/engine/launcher/launcher.vcxproj
View File

@ -205,7 +205,7 @@ if %errorlevel% NEQ 0 exit /b %errorlevel%</Command>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<AdditionalDependencies>kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;SPIRV-Toolsd.lib;OGLCompilerd.lib;SPIRVd.lib;OSDependentd.lib;glslangd.lib;shaderc_utild.lib;shadercd.lib;vulkan-1.lib;win32D.lib;dspirv-cross-reflect.lib;dspirv-cross-glsl.lib;dspirv-cross-cpp.lib;dspirv-cross-core.lib;%(AdditionalDependencies)</AdditionalDependencies>
<AdditionalDependencies>kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
<AdditionalOptions> /ignore:4099 %(AdditionalOptions)</AdditionalOptions>
</Link>
</ItemDefinitionGroup>

4
src/engine/launcher/launcher.vcxproj.user Normal file
View File

@ -0,0 +1,4 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="Current" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup />
</Project>

2
src/engine/opengl/idk_opengl.vcxproj
View File

@ -220,7 +220,7 @@
<PreprocessorDefinitions>_ENABLE_EXTENDED_ALIGNED_STORAGE;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
<AdditionalIncludeDirectories>$(SolutionDir)projects\idk\;$(SolutionDir)projects\;$(SolutionDir)dep\include\;$(SolutionDir)projects\win32\;$(SolutionDir)projects\editorstatic\</AdditionalIncludeDirectories>
<AdditionalIncludeDirectories>$(SolutionDir)projects\idk\;$(SolutionDir)projects\;$(SolutionDir)dep\include\;$(SolutionDir)projects\win32\</AdditionalIncludeDirectories>
<LanguageStandard>stdcpplatest</LanguageStandard>
<EnablePREfast>false</EnablePREfast>
<AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>

4
src/engine/opengl/idk_opengl.vcxproj.user Normal file
View File

@ -0,0 +1,4 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="Current" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup />
</Project>

20
src/engine/vkn/BufferHelpers.h
View File

@ -23,23 +23,23 @@ namespace idk::vkn::hlp
std::optional<vk::Semaphore> signal = {}
);
template<typename Dispatcher = vk::DispatchLoaderStatic>
template<typename Dispatcher = vk::DispatchLoaderDefault>
vk::UniqueBuffer CreateBuffer(vk::Device device, vk::DeviceSize size, vk::BufferUsageFlags usage, Dispatcher const& dispatcher = {});
template<typename T, typename Dispatcher = vk::DispatchLoaderStatic>
template<typename T, typename Dispatcher = vk::DispatchLoaderDefault>
vk::UniqueBuffer CreateVertexBuffer(vk::Device device, T* const begin, T* const end, const Dispatcher& dispatcher = {});
template<typename T, typename Dispatcher = vk::DispatchLoaderStatic>
template<typename T, typename Dispatcher = vk::DispatchLoaderDefault>
vk::UniqueBuffer CreateVertexBuffer(vk::Device device, std::vector<T> const& vertices, const Dispatcher& dispatcher = {});
template<typename Dispatcher = vk::DispatchLoaderStatic>
template<typename Dispatcher = vk::DispatchLoaderDefault>
vk::UniqueDeviceMemory AllocateBuffer(
vk::PhysicalDevice pdevice, vk::Device device, vk::Buffer const& buffer, vk::MemoryPropertyFlags memory_flags, Dispatcher const& dispatcher = {});
template<typename Dispatcher = vk::DispatchLoaderStatic>
template<typename Dispatcher = vk::DispatchLoaderDefault>
void BindBufferMemory(vk::Device device, vk::Buffer buffer, vk::DeviceMemory memory, uint32_t offset, Dispatcher const& dispatcher = {});
template<typename Dispatcher = vk::DispatchLoaderStatic>
template<typename Dispatcher = vk::DispatchLoaderDefault>
std::pair<vk::UniqueBuffer, UniqueAlloc> CreateAllocBindBuffer(
vk::PhysicalDevice pdevice, vk::Device device,
vk::DeviceSize buffer_size,
@ -49,7 +49,7 @@ namespace idk::vkn::hlp
const Dispatcher& dispatcher = {}
);
template<typename Dispatcher = vk::DispatchLoaderStatic>
template<typename Dispatcher = vk::DispatchLoaderDefault>
std::pair<vk::UniqueBuffer, vk::UniqueDeviceMemory> CreateAllocBindBuffer(
vk::PhysicalDevice pdevice, vk::Device device,
vk::DeviceSize buffer_size,
@ -58,17 +58,17 @@ namespace idk::vkn::hlp
const Dispatcher& dispatcher = {}
);
template<typename T, typename Dispatcher = vk::DispatchLoaderStatic>
template<typename T, typename Dispatcher = vk::DispatchLoaderDefault>
std::pair<vk::UniqueBuffer, vk::UniqueDeviceMemory> CreateAllocBindVertexBuffer(
vk::PhysicalDevice pdevice, vk::Device device, T const* vertices, T const* vertices_end, const Dispatcher& dispatcher = {}
);
template<typename T, typename Dispatcher = vk::DispatchLoaderStatic>
template<typename T, typename Dispatcher = vk::DispatchLoaderDefault>
std::pair<vk::UniqueBuffer, vk::UniqueDeviceMemory> CreateAllocBindVertexBuffer(
vk::PhysicalDevice pdevice, vk::Device device, std::vector<T> const& vertices, const Dispatcher& dispatcher = {}
);
template<typename T, typename Dispatcher = vk::DispatchLoaderStatic>
template<typename T, typename Dispatcher = vk::DispatchLoaderDefault>
void MapMemory(vk::Device device, vk::DeviceMemory memory, vk::DeviceSize dest_offset, T* src_start, vk::DeviceSize trf_size, Dispatcher const& dispatcher = {});
void CopyBuffer(vk::CommandBuffer cmd_buffer, vk::Queue queue, vk::Buffer srcBuffer, vk::Buffer dstBuffer, vk::DeviceSize size, std::optional<vk::Fence> fence = {}, bool wait_for_idle=true);

8
src/engine/vkn/ColorPickRenderer.cpp
View File

@ -469,17 +469,17 @@ namespace idk::vkn
{
auto opt = pipeline.GetBinding(location);
if (opt)
cmd_buffer.bindVertexBuffers(*opt, attrib.buffer, vk::DeviceSize{ attrib.offset }, vk::DispatchLoaderStatic{});
cmd_buffer.bindVertexBuffers(*opt, attrib.buffer, vk::DeviceSize{ attrib.offset }, vk::DispatchLoaderDefault{});
}
auto& oidx = p_ro.index_buffer;
if (oidx)
{
cmd_buffer.bindIndexBuffer(oidx->buffer, oidx->offset, oidx->index_type, vk::DispatchLoaderStatic{});
cmd_buffer.drawIndexed(s_cast<uint32_t>(p_ro.num_vertices), s_cast<uint32_t>(p_ro.num_instances), 0, 0, s_cast<uint32_t>(p_ro.inst_offset), vk::DispatchLoaderStatic{});
cmd_buffer.bindIndexBuffer(oidx->buffer, oidx->offset, oidx->index_type, vk::DispatchLoaderDefault{});
cmd_buffer.drawIndexed(s_cast<uint32_t>(p_ro.num_vertices), s_cast<uint32_t>(p_ro.num_instances), 0, 0, s_cast<uint32_t>(p_ro.inst_offset), vk::DispatchLoaderDefault{});
}
else
{
cmd_buffer.draw(s_cast<uint32_t>(p_ro.num_vertices), s_cast<uint32_t>(p_ro.num_instances), 0, s_cast<uint32_t>(p_ro.inst_offset), vk::DispatchLoaderStatic{});
cmd_buffer.draw(s_cast<uint32_t>(p_ro.num_vertices), s_cast<uint32_t>(p_ro.num_instances), 0, s_cast<uint32_t>(p_ro.inst_offset), vk::DispatchLoaderDefault{});
}
}

12
src/engine/vkn/CubemapRenderer.cpp
View File

@ -328,14 +328,14 @@ namespace idk::vkn
auto& attrib_buffer = mesh.Get(attrib);
auto binding = Pipeline().GetBinding(location);
if (binding)
cmd_buffer.bindVertexBuffers(*binding, *attrib_buffer.buffer(), vk::DeviceSize{ attrib_buffer.offset }, vk::DispatchLoaderStatic{});
cmd_buffer.bindVertexBuffers(*binding, *attrib_buffer.buffer(), vk::DeviceSize{ attrib_buffer.offset }, vk::DispatchLoaderDefault{});
}
auto& oidx = mesh.GetIndexBuffer();
if (oidx)
{
cmd_buffer.bindIndexBuffer(*(*oidx).buffer(), 0, mesh.IndexType(), vk::DispatchLoaderStatic{});
cmd_buffer.drawIndexed(mesh.IndexCount(), 1, 0, 0, 0, vk::DispatchLoaderStatic{});
cmd_buffer.bindIndexBuffer(*(*oidx).buffer(), 0, mesh.IndexType(), vk::DispatchLoaderDefault{});
cmd_buffer.drawIndexed(mesh.IndexCount(), 1, 0, 0, 0, vk::DispatchLoaderDefault{});
}
@ -392,14 +392,14 @@ namespace idk::vkn
auto& attrib_buffer = mesh.Get(attrib);
auto binding = Pipeline().GetBinding(location);
if (binding)
cmd_buffer.bindVertexBuffers(*binding, *attrib_buffer.buffer(), vk::DeviceSize{ attrib_buffer.offset }, vk::DispatchLoaderStatic{});
cmd_buffer.bindVertexBuffers(*binding, *attrib_buffer.buffer(), vk::DeviceSize{ attrib_buffer.offset }, vk::DispatchLoaderDefault{});
}
auto& oidx = mesh.GetIndexBuffer();
if (oidx)
{
cmd_buffer.bindIndexBuffer(*(*oidx).buffer(), 0, mesh.IndexType(), vk::DispatchLoaderStatic{});
cmd_buffer.drawIndexed(mesh.IndexCount(), 1, 0, 0, 0, vk::DispatchLoaderStatic{});
cmd_buffer.bindIndexBuffer(*(*oidx).buffer(), 0, mesh.IndexType(), vk::DispatchLoaderDefault{});
cmd_buffer.drawIndexed(mesh.IndexCount(), 1, 0, 0, 0, vk::DispatchLoaderDefault{});
}

10
src/engine/vkn/DeferredPass.cpp
View File

@ -129,7 +129,7 @@ namespace idk::vkn
0,1,
}
};
cmd_buffer.pipelineBarrier(vk::PipelineStageFlagBits::eColorAttachmentOutput, vk::PipelineStageFlagBits::eTransfer, vk::DependencyFlagBits::eByRegion, nullptr, nullptr, barriers, vk::DispatchLoaderStatic{});
cmd_buffer.pipelineBarrier(vk::PipelineStageFlagBits::eColorAttachmentOutput, vk::PipelineStageFlagBits::eTransfer, vk::DependencyFlagBits::eByRegion, nullptr, nullptr, barriers, vk::DispatchLoaderDefault{});
}
@ -683,19 +683,19 @@ namespace idk::vkn
for (auto&& [attrib, location] : renderer_req.mesh_requirements)
{
auto& attrib_buffer = mesh.Get(attrib);
cmd_buffer.bindVertexBuffers(*pipeline.GetBinding(location), *attrib_buffer.buffer(), vk::DeviceSize{ attrib_buffer.offset }, vk::DispatchLoaderStatic{});
cmd_buffer.bindVertexBuffers(*pipeline.GetBinding(location), *attrib_buffer.buffer(), vk::DeviceSize{ attrib_buffer.offset }, vk::DispatchLoaderDefault{});
}
if (state&&is_mesh_renderer)
{
uint32_t obj_trf_loc = 4;
cmd_buffer.bindVertexBuffers(*pipeline.GetBinding(obj_trf_loc), state->shared_gfx_state->inst_mesh_render_buffer.buffer(), { 0 }, vk::DispatchLoaderStatic{});
cmd_buffer.bindVertexBuffers(*pipeline.GetBinding(obj_trf_loc), state->shared_gfx_state->inst_mesh_render_buffer.buffer(), { 0 }, vk::DispatchLoaderDefault{});
}
auto& oidx = mesh.GetIndexBuffer();
if (oidx)
{
cmd_buffer.bindIndexBuffer(*(*oidx).buffer(), 0, mesh.IndexType(), vk::DispatchLoaderStatic{});
cmd_buffer.drawIndexed(mesh.IndexCount(), static_cast<uint32_t>(p_ro.num_instances), 0, 0, static_cast<uint32_t>(p_ro.inst_offset), vk::DispatchLoaderStatic{});
cmd_buffer.bindIndexBuffer(*(*oidx).buffer(), 0, mesh.IndexType(), vk::DispatchLoaderDefault{});
cmd_buffer.drawIndexed(mesh.IndexCount(), static_cast<uint32_t>(p_ro.num_instances), 0, 0, static_cast<uint32_t>(p_ro.inst_offset), vk::DispatchLoaderDefault{});
}
}
return rendered;

8
src/engine/vkn/DescriptorPoolsManager.cpp
View File

@ -20,7 +20,7 @@ namespace idk::vkn
,hlp::arr_count(pool_size)
,std::data(pool_size)
};
pool = device.createDescriptorPoolUnique(create_info, nullptr, vk::DispatchLoaderStatic{});
pool = device.createDescriptorPoolUnique(create_info, nullptr, vk::DispatchLoaderDefault{});
}
vk::DescriptorPool DescriptorPoolsManager::Add(uint32_t num_ds,vk::DescriptorType type)
{
@ -47,13 +47,13 @@ namespace idk::vkn
void DescriptorPoolsManager::ResetManager(Manager& manager)
{
vk::Device d = *view.Device();
d.resetDescriptorPool(*manager.pool, vk::DescriptorPoolResetFlags{}, vk::DispatchLoaderStatic{});
d.resetDescriptorPool(*manager.pool, vk::DescriptorPoolResetFlags{}, vk::DispatchLoaderDefault{});
manager.size = 0;
}
void DescriptorPoolsManager::ResetManager(Manager2& manager)
{
vk::Device d = *view.Device();
d.resetDescriptorPool(*manager.pool, vk::DescriptorPoolResetFlags{}, vk::DispatchLoaderStatic{});
d.resetDescriptorPool(*manager.pool, vk::DescriptorPoolResetFlags{}, vk::DispatchLoaderDefault{});
for (auto& cap : manager.cap)
{
cap.size = 0;
@ -113,7 +113,7 @@ namespace idk::vkn
,total_types//hlp::arr_count(pool_size)
,std::data(pool_size)
};
pool = device.createDescriptorPoolUnique(create_info, nullptr, vk::DispatchLoaderStatic{});
pool = device.createDescriptorPoolUnique(create_info, nullptr, vk::DispatchLoaderDefault{});
}
}

2
src/engine/vkn/DescriptorUpdateData.cpp
View File

@ -29,7 +29,7 @@ void DescriptorUpdateData::SendUpdates()
{
auto& device = *View().Device();
ConvertBufferIdxToPointer();
device.updateDescriptorSets(descriptorWrite, nullptr, vk::DispatchLoaderStatic{});
device.updateDescriptorSets(descriptorWrite, nullptr, vk::DispatchLoaderDefault{});
}
void DescriptorUpdateData::Reset()

44
src/engine/vkn/FrameRenderer.cpp
View File

@ -445,9 +445,9 @@ namespace idk::vkn
_cmd_pool = cmd_pool;
auto device = *View().Device();
auto pri_buffers = device.allocateCommandBuffersUnique(vk::CommandBufferAllocateInfo{ cmd_pool,vk::CommandBufferLevel::ePrimary, num_fo }, vk::DispatchLoaderStatic{});
auto pri_buffers = device.allocateCommandBuffersUnique(vk::CommandBufferAllocateInfo{ cmd_pool,vk::CommandBufferLevel::ePrimary, num_fo }, vk::DispatchLoaderDefault{});
_pri_buffer = std::move(pri_buffers[0]);
auto t_buffers = device.allocateCommandBuffersUnique(vk::CommandBufferAllocateInfo{ cmd_pool,vk::CommandBufferLevel::eSecondary, num_fo }, vk::DispatchLoaderStatic{});
auto t_buffers = device.allocateCommandBuffersUnique(vk::CommandBufferAllocateInfo{ cmd_pool,vk::CommandBufferLevel::eSecondary, num_fo }, vk::DispatchLoaderDefault{});
{
_transition_buffer = std::move(t_buffers[0]);
}
@ -559,7 +559,7 @@ namespace idk::vkn
};
auto queue = View().GraphicsQueue();
queue.submit(submit_info, vk::Fence{}, vk::DispatchLoaderStatic{});
queue.submit(submit_info, vk::Fence{}, vk::DispatchLoaderDefault{});
}
{
@ -584,7 +584,7 @@ namespace idk::vkn
auto& rs = _pre_states[curr_state];
{
auto dispatcher = vk::DispatchLoaderStatic{};
auto dispatcher = vk::DispatchLoaderDefault{};
vk::CommandBuffer cmd_buffer = rs.CommandBuffer();
vk::CommandBufferBeginInfo begin_info{ vk::CommandBufferUsageFlagBits::eOneTimeSubmit,nullptr };
cmd_buffer.begin(begin_info, dispatcher);
@ -659,7 +659,7 @@ namespace idk::vkn
};
auto queue = View().GraphicsQueue();
queue.submit(submit_info, vk::Fence{}, vk::DispatchLoaderStatic{});
queue.submit(submit_info, vk::Fence{}, vk::DispatchLoaderDefault{});
dbg::EndLabel(queue);
}
VulkanView& View();
@ -758,17 +758,17 @@ namespace idk::vkn
for (auto&& [location, attrib] : p_ro.attrib_buffers)
{
cmd_buffer.bindVertexBuffers(*pipeline.GetBinding(location), attrib.buffer, vk::DeviceSize{ attrib.offset }, vk::DispatchLoaderStatic{});
cmd_buffer.bindVertexBuffers(*pipeline.GetBinding(location), attrib.buffer, vk::DeviceSize{ attrib.offset }, vk::DispatchLoaderDefault{});
}
auto& oidx = p_ro.index_buffer;
if (oidx)
{
cmd_buffer.bindIndexBuffer(oidx->buffer, 0, oidx->index_type, vk::DispatchLoaderStatic{});
cmd_buffer.drawIndexed(s_cast<uint32_t>(p_ro.num_vertices), static_cast<uint32_t>(p_ro.num_instances), 0, 0, static_cast<uint32_t>(p_ro.inst_offset), vk::DispatchLoaderStatic{});
cmd_buffer.bindIndexBuffer(oidx->buffer, 0, oidx->index_type, vk::DispatchLoaderDefault{});
cmd_buffer.drawIndexed(s_cast<uint32_t>(p_ro.num_vertices), static_cast<uint32_t>(p_ro.num_instances), 0, 0, static_cast<uint32_t>(p_ro.inst_offset), vk::DispatchLoaderDefault{});
}
else
{
cmd_buffer.draw(s_cast<uint32_t>(p_ro.num_vertices), s_cast<uint32_t>(p_ro.num_instances), 0, s_cast<uint32_t>(p_ro.inst_offset), vk::DispatchLoaderStatic{});
cmd_buffer.draw(s_cast<uint32_t>(p_ro.num_vertices), s_cast<uint32_t>(p_ro.num_instances), 0, s_cast<uint32_t>(p_ro.inst_offset), vk::DispatchLoaderDefault{});
}
}
}
@ -783,7 +783,7 @@ namespace idk::vkn
{
auto& rt = rr.as<VknRenderTarget>();
//auto& swapchain = view.Swapchain();
auto dispatcher = vk::DispatchLoaderStatic{};
auto dispatcher = vk::DispatchLoaderDefault{};
vk::CommandBuffer cmd_buffer = rs.CommandBuffer();
vk::CommandBufferBeginInfo begin_info{ vk::CommandBufferUsageFlagBits::eOneTimeSubmit,nullptr };
GraphicsStateInterface gsi = { state };
@ -920,7 +920,7 @@ namespace idk::vkn
GetGfxTimeLog().end();//Misc
GetGfxTimeLog().end();//Render Graph
}
pri_buffer->reset({}, vk::DispatchLoaderStatic{});
pri_buffer->reset({}, vk::DispatchLoaderDefault{});
vector<vk::CommandBuffer> buffers{};
for (auto& state : curr_frame._states)
{
@ -928,9 +928,9 @@ namespace idk::vkn
buffers.emplace_back(state.CommandBuffer());
}
vk::CommandBufferBeginInfo begin_info{ vk::CommandBufferUsageFlagBits::eOneTimeSubmit };
pri_buffer->begin(begin_info, vk::DispatchLoaderStatic{});
pri_buffer->begin(begin_info, vk::DispatchLoaderDefault{});
//if(buffers.size())
// pri_buffer->executeCommands(buffers, vk::DispatchLoaderStatic{});
// pri_buffer->executeCommands(buffers, vk::DispatchLoaderDefault{});
vk::CommandBufferInheritanceInfo iinfo
{
};
@ -954,11 +954,11 @@ namespace idk::vkn
presentToClearBarrier.image = swapchain.m_graphics.Images()[swapchain.curr_index];
presentToClearBarrier.subresourceRange = subResourceRange;
begin_info.pInheritanceInfo = &iinfo;
transition_buffer->begin(begin_info, vk::DispatchLoaderStatic{});
transition_buffer->pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, vk::PipelineStageFlagBits::eTransfer, vk::DependencyFlags{}, nullptr, nullptr, presentToClearBarrier, vk::DispatchLoaderStatic{});
transition_buffer->begin(begin_info, vk::DispatchLoaderDefault{});
transition_buffer->pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, vk::PipelineStageFlagBits::eTransfer, vk::DependencyFlags{}, nullptr, nullptr, presentToClearBarrier, vk::DispatchLoaderDefault{});
transition_buffer->end();
//hlp::TransitionImageLayout(*transition_buffer, queue, swapchain.images[swapchain.curr_index], vk::Format::eUndefined, vk::ImageLayout::eUndefined, vk::ImageLayout::ePresentSrcKHR,&iinfo);
pri_buffer->executeCommands(*transition_buffer, vk::DispatchLoaderStatic{});
pri_buffer->executeCommands(*transition_buffer, vk::DispatchLoaderDefault{});
}
pri_buffer->end();
@ -993,9 +993,9 @@ namespace idk::vkn
};
View().Device()->resetFences(1, &inflight_fence, vk::DispatchLoaderStatic{});
View().Device()->resetFences(1, &inflight_fence, vk::DispatchLoaderDefault{});
dbg::BeginLabel(queue, "Render GraphicsStates", color{ 0.3f,0.0f,0.3f });
queue.submit(submit_info, inflight_fence, vk::DispatchLoaderStatic{});
queue.submit(submit_info, inflight_fence, vk::DispatchLoaderDefault{});
dbg::EndLabel(queue);
auto copy = View().Swapchain().m_graphics.Images();
copy[View().vulkan().rv ]= RscHandle<VknRenderTarget>()->GetColorBuffer().as<VknTexture>().Image();
@ -1077,7 +1077,7 @@ namespace idk::vkn
};
auto queue = View().GraphicsQueue();
queue.submit(submit_info, vk::Fence{}, vk::DispatchLoaderStatic{});
queue.submit(submit_info, vk::Fence{}, vk::DispatchLoaderDefault{});
}
@ -1127,7 +1127,7 @@ namespace idk::vkn
};
auto queue = View().GraphicsQueue();
queue.submit(submit_info, vk::Fence{}, vk::DispatchLoaderStatic{});
queue.submit(submit_info, vk::Fence{}, vk::DispatchLoaderDefault{});
}
PresentationSignals& FrameRenderer::GetMainSignal()
{
@ -1142,7 +1142,7 @@ namespace idk::vkn
for (auto i = diff; i-- > 0;)
{
auto cmd_pool = View().vulkan().CreateGfxCommandPool();
auto&& buffers = device.allocateCommandBuffersUnique(vk::CommandBufferAllocateInfo{ *cmd_pool,vk::CommandBufferLevel::ePrimary, 1}, vk::DispatchLoaderStatic{});
auto&& buffers = device.allocateCommandBuffersUnique(vk::CommandBufferAllocateInfo{ *cmd_pool,vk::CommandBufferLevel::ePrimary, 1}, vk::DispatchLoaderDefault{});
auto& buffer = buffers[0];
states.emplace_back(RenderStateV2{std::move(cmd_pool), std::move(buffer),UboManager{View()},PresentationSignals{},DescriptorsManager{View()} }).signal.Init(View());
//_state_cmd_buffers.emplace_back(std::move(buffer));
@ -1154,7 +1154,7 @@ namespace idk::vkn
void FrameRenderer::RenderDebugStuff(const GraphicsState& , RenderStateV2& , rect )
{
#if 0
auto dispatcher = vk::DispatchLoaderStatic{};
auto dispatcher = vk::DispatchLoaderDefault{};
vk::CommandBuffer cmd_buffer = rs.CommandBuffer();
//TODO: figure out inheritance pipeline inheritance and inherit from dbg_pipeline for various viewport sizes
//auto& pipelines = state.dbg_pipeline;

4
src/engine/vkn/MemoryAllocator.cpp
View File

@ -111,7 +111,7 @@ namespace idk::vkn::hlp
}
MemoryAllocator::UniqueAlloc MemoryAllocator::Allocate(vk::PhysicalDevice pd, vk::Device d, vk::Buffer& buffer, vk::MemoryPropertyFlags prop)
{
auto mem_req = d.getBufferMemoryRequirements(buffer, vk::DispatchLoaderStatic{});
auto mem_req = d.getBufferMemoryRequirements(buffer, vk::DispatchLoaderDefault{});
auto mem_type = hlp::findMemoryType(pd, mem_req.memoryTypeBits, prop);
return Allocate(d, mem_type, mem_req);
}
@ -188,7 +188,7 @@ namespace idk::vkn::hlp
memories.emplace_back(device.allocateMemoryUnique(
vk::MemoryAllocateInfo{
Track(sz),type
}, nullptr, vk::DispatchLoaderStatic{}
}, nullptr, vk::DispatchLoaderDefault{}
), sz);
return memories.back();

2
src/engine/vkn/PipelineThingy.cpp
View File

@ -59,7 +59,7 @@ namespace idk::vkn
std::visit(updater, binding.ubuffer);
}
CondenseDSW(descriptorWrite);
device.updateDescriptorSets(descriptorWrite, nullptr, vk::DispatchLoaderStatic{});
device.updateDescriptorSets(descriptorWrite, nullptr, vk::DispatchLoaderDefault{});
}
*/

2
src/engine/vkn/RenderTask.cpp
View File

@ -488,7 +488,7 @@ namespace idk::vkn
auto& [prev_buffer, prev_offset] = vb_n_offset[vb.binding];
if (prev_buffer != vb.buffer || prev_offset != vb.offset)
{
cmd_buffer.bindVertexBuffers(vb.binding, vb.buffer, vk::DeviceSize{ vb.offset }, vk::DispatchLoaderStatic{});
cmd_buffer.bindVertexBuffers(vb.binding, vb.buffer, vk::DeviceSize{ vb.offset }, vk::DispatchLoaderDefault{});
prev_buffer = vb.buffer;
prev_offset = vb.offset;
}

5
src/engine/vkn/ShaderModule.cpp
View File

@ -185,11 +185,6 @@ namespace idk::vkn
ubo_info[ub.name] = std::move(info);
}
//这里反序列化的数据是错误的，不能执行析构函数
using SVBuiltResource = decltype(resources.builtin_inputs);
char data[sizeof(SVBuiltResource)];
std::construct_at((SVBuiltResource*)&data, std::move(resources.builtin_outputs));
std::construct_at((SVBuiltResource*)&data, std::move(resources.builtin_inputs));
//for (auto& ub : cs)
//{

26
src/engine/vkn/VknCubeMapLoader.cpp
View File

@ -137,7 +137,7 @@ namespace idk::vkn {
{
src_flags,dst_flags,original_layout,target,VK_QUEUE_FAMILY_IGNORED,VK_QUEUE_FAMILY_IGNORED,image,*range
};
cmd_buffer.pipelineBarrier(src_stage, dst_stage, {}, nullptr, nullptr, barrier, vk::DispatchLoaderStatic{});
cmd_buffer.pipelineBarrier(src_stage, dst_stage, {}, nullptr, nullptr, barrier, vk::DispatchLoaderDefault{});
}
std::pair<vk::UniqueImage, hlp::UniqueAlloc> CreateBlitImage(hlp::MemoryAllocator& allocator, uint32_t mipmap_level, uint32_t width, uint32_t height, vk::Format format)
@ -162,9 +162,9 @@ namespace idk::vkn {
imageInfo.samples = vk::SampleCountFlagBits::e1; //Multisampling
imageInfo.flags = vk::ImageCreateFlagBits::eCubeCompatible;
vk::UniqueImage image = device.createImageUnique(imageInfo, nullptr, vk::DispatchLoaderStatic{});
vk::UniqueImage image = device.createImageUnique(imageInfo, nullptr, vk::DispatchLoaderDefault{});
auto alloc = allocator.Allocate(*image, vk::MemoryPropertyFlagBits::eDeviceLocal); //Allocate on device only
device.bindImageMemory(*image, alloc->Memory(), alloc->Offset(), vk::DispatchLoaderStatic{});
device.bindImageMemory(*image, alloc->Memory(), alloc->Offset(), vk::DispatchLoaderDefault{});
return std::make_pair(std::move(image), std::move(alloc));
}
}
@ -401,9 +401,9 @@ namespace idk::vkn {
imageInfo.sharingMode = vk::SharingMode::eExclusive; //Only graphics queue needs this.
imageInfo.samples = vk::SampleCountFlagBits::e1; //Multisampling
vk::UniqueImage image = device.createImageUnique(imageInfo, nullptr, vk::DispatchLoaderStatic{});
vk::UniqueImage image = device.createImageUnique(imageInfo, nullptr, vk::DispatchLoaderDefault{});
auto alloc = allocator.Allocate(*image, vk::MemoryPropertyFlagBits::eDeviceLocal); //Allocate on device only
device.bindImageMemory(*image, alloc->Memory(), alloc->Offset(), vk::DispatchLoaderStatic{});
device.bindImageMemory(*image, alloc->Memory(), alloc->Offset(), vk::DispatchLoaderDefault{});
const vk::ImageAspectFlagBits img_aspect = load_info.aspect;
result.aspect = img_aspect;
@ -444,7 +444,7 @@ namespace idk::vkn {
copy_dest = *blit_src_img;
layout = vk::ImageLayout::eTransferSrcOptimal;
}
auto&& [stagingBuffer, stagingMemory] = hlp::CreateAllocBindBuffer(pd, device, in_info->mem_size, vk::BufferUsageFlagBits::eTransferSrc, vk::MemoryPropertyFlagBits::eHostCoherent | vk::MemoryPropertyFlagBits::eHostVisible, vk::DispatchLoaderStatic{});
auto&& [stagingBuffer, stagingMemory] = hlp::CreateAllocBindBuffer(pd, device, in_info->mem_size, vk::BufferUsageFlagBits::eTransferSrc, vk::MemoryPropertyFlagBits::eHostCoherent | vk::MemoryPropertyFlagBits::eHostVisible, vk::DispatchLoaderDefault{});
if (in_info)
{
@ -455,7 +455,7 @@ namespace idk::vkn {
,num_bytes
};
uint8_t* data = nullptr;
device.mapMemory(*stagingMemory, mmr.offset, in_info->mem_size, vk::MemoryMapFlags{}, (void**)&data, vk::DispatchLoaderStatic());
device.mapMemory(*stagingMemory, mmr.offset, in_info->mem_size, vk::MemoryMapFlags{}, (void**)&data, vk::DispatchLoaderDefault());
memcpy_s(data, mmr.size, in_info->data, mmr.size);
std::vector<decltype(mmr)> memory_ranges
{
@ -505,7 +505,7 @@ namespace idk::vkn {
}
}
cmd_buffer.copyBufferToImage(*stagingBuffer, copy_dest, vk::ImageLayout::eTransferDstOptimal, copy_regions, vk::DispatchLoaderStatic{});
cmd_buffer.copyBufferToImage(*stagingBuffer, copy_dest, vk::ImageLayout::eTransferDstOptimal, copy_regions, vk::DispatchLoaderDefault{});
staging_buffer = std::move(stagingBuffer);
staging_memory = std::move(stagingMemory);
@ -573,17 +573,17 @@ namespace idk::vkn {
imageInfo.samples = vk::SampleCountFlagBits::e1; //Multisampling
imageInfo.flags = vk::ImageCreateFlagBits::eCubeCompatible;
vk::UniqueImage image = device.createImageUnique(imageInfo, nullptr, vk::DispatchLoaderStatic{});
vk::UniqueImage image = device.createImageUnique(imageInfo, nullptr, vk::DispatchLoaderDefault{});
auto alloc = allocator.Allocate(*image, vk::MemoryPropertyFlagBits::eDeviceLocal);
device.bindImageMemory(*image, alloc->Memory(), alloc->Offset(), vk::DispatchLoaderStatic{});
device.bindImageMemory(*image, alloc->Memory(), alloc->Offset(), vk::DispatchLoaderDefault{});
auto&& [stagingBuffer, stagingMemory] = hlp::CreateAllocBindBuffer(pd, device, num_bytes, vk::BufferUsageFlagBits::eTransferSrc, vk::MemoryPropertyFlagBits::eHostCoherent | vk::MemoryPropertyFlagBits::eHostVisible, vk::DispatchLoaderStatic{});
auto&& [stagingBuffer, stagingMemory] = hlp::CreateAllocBindBuffer(pd, device, num_bytes, vk::BufferUsageFlagBits::eTransferSrc, vk::MemoryPropertyFlagBits::eHostCoherent | vk::MemoryPropertyFlagBits::eHostVisible, vk::DispatchLoaderDefault{});
if (image)
dbg::TextureTracker::Inst(dbg::TextureAllocTypes::eCubemap).reg_allocate(image->operator VkImage(), num_bytes);
if (data)
hlp::MapMemory(device, *stagingMemory, 0, data, num_bytes, vk::DispatchLoaderStatic{});
hlp::MapMemory(device, *stagingMemory, 0, data, num_bytes, vk::DispatchLoaderDefault{});
vk::AccessFlags src_flags = vk::AccessFlagBits::eMemoryRead | vk::AccessFlagBits::eShaderRead;
vk::AccessFlags dst_flags = vk::AccessFlagBits::eTransferWrite;
vk::PipelineStageFlags shader_flags = vk::PipelineStageFlagBits::eVertexShader | vk::PipelineStageFlagBits::eFragmentShader;// | vk::PipelineStageFlagBits::eTessellationControlShader | vk::PipelineStageFlagBits::eTessellationEvaluationShader;
@ -642,7 +642,7 @@ namespace idk::vkn {
bCopyRegions.emplace_back(region);
//offset += i;
}
cmd_buffer.copyBufferToImage(*stagingBuffer, *image, vk::ImageLayout::eTransferDstOptimal, bCopyRegions, vk::DispatchLoaderStatic{});
cmd_buffer.copyBufferToImage(*stagingBuffer, *image, vk::ImageLayout::eTransferDstOptimal, bCopyRegions, vk::DispatchLoaderDefault{});
vcm::TransitionImageLayout(cmd_buffer, src_flags, shader_flags, dst_flags, dst_stages, vk::ImageLayout::eTransferDstOptimal, layout, *image, img_aspect,vk::ImageSubresourceRange
{

26
src/engine/vkn/VknFontAtlasLoader.cpp
View File

@ -147,7 +147,7 @@ namespace idk::vkn
{
src_flags,dst_flags,original_layout,target,VK_QUEUE_FAMILY_IGNORED,VK_QUEUE_FAMILY_IGNORED,image,*range
};
cmd_buffer.pipelineBarrier(src_stage, dst_stage, {}, nullptr, nullptr, barrier, vk::DispatchLoaderStatic{});
cmd_buffer.pipelineBarrier(src_stage, dst_stage, {}, nullptr, nullptr, barrier, vk::DispatchLoaderDefault{});
}
vk::UniqueImageView CreateImageView2D(vk::Device device, vk::Image image, vk::Format format, vk::ImageAspectFlags aspect)
@ -215,9 +215,9 @@ namespace idk::vkn
imageInfo.sharingMode = vk::SharingMode::eExclusive; //Only graphics queue needs this.
imageInfo.samples = vk::SampleCountFlagBits::e1; //Multisampling
vk::UniqueImage image = device.createImageUnique(imageInfo, nullptr, vk::DispatchLoaderStatic{});
vk::UniqueImage image = device.createImageUnique(imageInfo, nullptr, vk::DispatchLoaderDefault{});
auto alloc = allocator.Allocate(*image, vk::MemoryPropertyFlagBits::eDeviceLocal); //Allocate on device only
device.bindImageMemory(*image, alloc->Memory(), alloc->Offset(), vk::DispatchLoaderStatic{});
device.bindImageMemory(*image, alloc->Memory(), alloc->Offset(), vk::DispatchLoaderDefault{});
return std::make_pair(std::move(image), std::move(alloc));
}
@ -390,9 +390,9 @@ namespace idk::vkn
imageInfo.sharingMode = vk::SharingMode::eExclusive; //Only graphics queue needs this.
imageInfo.samples = vk::SampleCountFlagBits::e1; //Multisampling
vk::UniqueImage image = device.createImageUnique(imageInfo, nullptr, vk::DispatchLoaderStatic{});
vk::UniqueImage image = device.createImageUnique(imageInfo, nullptr, vk::DispatchLoaderDefault{});
auto alloc = allocator.Allocate(*image, vk::MemoryPropertyFlagBits::eDeviceLocal); //Allocate on device only
device.bindImageMemory(*image, alloc->Memory(), alloc->Offset(), vk::DispatchLoaderStatic{});
device.bindImageMemory(*image, alloc->Memory(), alloc->Offset(), vk::DispatchLoaderDefault{});
if (image)
dbg::TextureTracker::Inst(dbg::TextureAllocTypes::eCubemap).reg_allocate(image->operator VkImage(), num_bytes);
@ -431,10 +431,10 @@ namespace idk::vkn
copy_dest = *blit_src_img;
layout = vk::ImageLayout::eTransferSrcOptimal;
}
auto&& [stagingBuffer, stagingMemory] = hlp::CreateAllocBindBuffer(pd, device, num_bytes, vk::BufferUsageFlagBits::eTransferSrc, vk::MemoryPropertyFlagBits::eHostCoherent | vk::MemoryPropertyFlagBits::eHostVisible, vk::DispatchLoaderStatic{});
auto&& [stagingBuffer, stagingMemory] = hlp::CreateAllocBindBuffer(pd, device, num_bytes, vk::BufferUsageFlagBits::eTransferSrc, vk::MemoryPropertyFlagBits::eHostCoherent | vk::MemoryPropertyFlagBits::eHostVisible, vk::DispatchLoaderDefault{});
if (in_info)
hlp::MapMemory(device, *stagingMemory, 0, in_info->data, num_bytes, vk::DispatchLoaderStatic{});
hlp::MapMemory(device, *stagingMemory, 0, in_info->data, num_bytes, vk::DispatchLoaderDefault{});
//if (is_render_target)
//{
// src_flags |= vk::AccessFlagBits::eColorAttachmentRead;
@ -493,7 +493,7 @@ namespace idk::vkn
}
//vector<vk::BufferImageCopy>
cmd_buffer.copyBufferToImage(*stagingBuffer, copy_dest, vk::ImageLayout::eTransferDstOptimal, copy_regions, vk::DispatchLoaderStatic{});
cmd_buffer.copyBufferToImage(*stagingBuffer, copy_dest, vk::ImageLayout::eTransferDstOptimal, copy_regions, vk::DispatchLoaderDefault{});
staging_buffer = std::move(stagingBuffer);
staging_memory = std::move(stagingMemory);
@ -561,16 +561,16 @@ namespace idk::vkn
imageInfo.sharingMode = vk::SharingMode::eExclusive; //Only graphics queue needs this.
imageInfo.samples = vk::SampleCountFlagBits::e1; //Multisampling
vk::UniqueImage image = device.createImageUnique(imageInfo, nullptr, vk::DispatchLoaderStatic{});
vk::UniqueImage image = device.createImageUnique(imageInfo, nullptr, vk::DispatchLoaderDefault{});
auto alloc = allocator.Allocate(*image, vk::MemoryPropertyFlagBits::eDeviceLocal);
device.bindImageMemory(*image, alloc->Memory(), alloc->Offset(), vk::DispatchLoaderStatic{});
device.bindImageMemory(*image, alloc->Memory(), alloc->Offset(), vk::DispatchLoaderDefault{});
auto&& [stagingBuffer, stagingMemory] = hlp::CreateAllocBindBuffer(pd, device, num_bytes, vk::BufferUsageFlagBits::eTransferSrc, vk::MemoryPropertyFlagBits::eHostCoherent | vk::MemoryPropertyFlagBits::eHostVisible, vk::DispatchLoaderStatic{});
auto&& [stagingBuffer, stagingMemory] = hlp::CreateAllocBindBuffer(pd, device, num_bytes, vk::BufferUsageFlagBits::eTransferSrc, vk::MemoryPropertyFlagBits::eHostCoherent | vk::MemoryPropertyFlagBits::eHostVisible, vk::DispatchLoaderDefault{});
if (image)
dbg::TextureTracker::Inst(dbg::TextureAllocTypes::eFontAtlas).reg_allocate(image->operator VkImage(), num_bytes);
if (data)
hlp::MapMemory(device, *stagingMemory, 0, data, num_bytes, vk::DispatchLoaderStatic{});
hlp::MapMemory(device, *stagingMemory, 0, data, num_bytes, vk::DispatchLoaderDefault{});
vk::AccessFlags src_flags = vk::AccessFlagBits::eMemoryRead | vk::AccessFlagBits::eShaderRead;
vk::AccessFlags dst_flags = vk::AccessFlagBits::eTransferWrite;
vk::PipelineStageFlags shader_flags = vk::PipelineStageFlagBits::eVertexShader | vk::PipelineStageFlagBits::eFragmentShader;// | vk::PipelineStageFlagBits::eTessellationControlShader | vk::PipelineStageFlagBits::eTessellationEvaluationShader;
@ -611,7 +611,7 @@ namespace idk::vkn
height,
1
};
cmd_buffer.copyBufferToImage(*stagingBuffer, *image, vk::ImageLayout::eTransferDstOptimal, region, vk::DispatchLoaderStatic{});
cmd_buffer.copyBufferToImage(*stagingBuffer, *image, vk::ImageLayout::eTransferDstOptimal, region, vk::DispatchLoaderDefault{});
vfa::TransitionImageLayout(cmd_buffer, src_flags, shader_flags, dst_flags, dst_stages, vk::ImageLayout::eTransferDstOptimal, layout, *image);
;

4
src/engine/vkn/VknMeshModder.cpp
View File

@ -33,10 +33,6 @@ namespace idk::vkn
vk::UniqueCommandBuffer cmd_buffer;
vk::UniqueBuffer buffer;
vk::UniqueDeviceMemory memory;
~StagingStuff() {
}
};
//Expensive (probably).
StagingStuff TransferData(vk::CommandPool cmd_pool, vk::Queue queue, vk::PhysicalDevice pdevice, vk::Device device, size_t dst_offset, size_t num_bytes, const void* data, vk::Buffer dst_buffer, vk::Fence fence)

6
src/engine/vkn/VknRenderTargetFactory.cpp
View File

@ -36,14 +36,12 @@ namespace idk::vkn
auto result = RenderTargetFactory::GenerateDefaultResource();
auto pm = RscHandle<VknRenderTarget>{};
if (pm) {
auto& m = *pm;
auto& m = *RscHandle<VknRenderTarget>{};
m.size = uvec2{ Core::GetSystem<Application>().GetScreenSize() };
if (m.ColorGradingLut == RscHandle<Texture>{})
m.ColorGradingLut = RscHandle<Texture>{GetDefaultColorGradeGuid()};
m.Name("Default RenderTarget");
}
return result;
}

16
src/engine/vkn/VknTextureLoader.cpp
View File

@ -329,7 +329,7 @@ namespace idk::vkn
{
src_flags,dst_flags,original_layout,target,VK_QUEUE_FAMILY_IGNORED,VK_QUEUE_FAMILY_IGNORED,image,*range
};
cmd_buffer.pipelineBarrier(src_stage, dst_stage, {}, nullptr, nullptr, barrier, vk::DispatchLoaderStatic{});
cmd_buffer.pipelineBarrier(src_stage, dst_stage, {}, nullptr, nullptr, barrier, vk::DispatchLoaderDefault{});
}
@ -488,9 +488,9 @@ namespace idk::vkn
imageInfo.sharingMode = vk::SharingMode::eExclusive; //Only graphics queue needs this.
imageInfo.samples = vk::SampleCountFlagBits::e1; //Multisampling
vk::UniqueImage image = device.createImageUnique(imageInfo, nullptr, vk::DispatchLoaderStatic{});
vk::UniqueImage image = device.createImageUnique(imageInfo, nullptr, vk::DispatchLoaderDefault{});
auto alloc = allocator.Allocate(*image, vk::MemoryPropertyFlagBits::eDeviceLocal); //Allocate on device only
device.bindImageMemory(*image, alloc->Memory(), alloc->Offset(), vk::DispatchLoaderStatic{});
device.bindImageMemory(*image, alloc->Memory(), alloc->Offset(), vk::DispatchLoaderDefault{});
return std::make_pair(std::move(image), std::move(alloc));
}
@ -590,10 +590,10 @@ namespace idk::vkn
//}
vk::UniqueImage image = device.createImageUnique(imageInfo, nullptr, vk::DispatchLoaderStatic{});
vk::UniqueImage image = device.createImageUnique(imageInfo, nullptr, vk::DispatchLoaderDefault{});
auto alloc = allocator.Allocate(*image, mem_property); //Allocate on device only
result.size_on_device = alloc->Size();
device.bindImageMemory(*image, alloc->Memory(), alloc->Offset(), vk::DispatchLoaderStatic{});
device.bindImageMemory(*image, alloc->Memory(), alloc->Offset(), vk::DispatchLoaderDefault{});
const vk::ImageAspectFlagBits img_aspect = load_info.aspect;
result.aspect = img_aspect;
@ -635,10 +635,10 @@ namespace idk::vkn
copy_dest = *blit_src_img;
layout = vk::ImageLayout::eTransferSrcOptimal;
}
auto&& [stagingBuffer, stagingMemory] = hlp::CreateAllocBindBuffer(pd, device, num_bytes, vk::BufferUsageFlagBits::eTransferSrc, vk::MemoryPropertyFlagBits::eHostCoherent | vk::MemoryPropertyFlagBits::eHostVisible, vk::DispatchLoaderStatic{});
auto&& [stagingBuffer, stagingMemory] = hlp::CreateAllocBindBuffer(pd, device, num_bytes, vk::BufferUsageFlagBits::eTransferSrc, vk::MemoryPropertyFlagBits::eHostCoherent | vk::MemoryPropertyFlagBits::eHostVisible, vk::DispatchLoaderDefault{});
if (in_info)
hlp::MapMemory(device, *stagingMemory, 0, in_info->data, num_bytes, vk::DispatchLoaderStatic{});
hlp::MapMemory(device, *stagingMemory, 0, in_info->data, num_bytes, vk::DispatchLoaderDefault{});
//if (is_render_target)
//{
// src_flags |= vk::AccessFlagBits::eColorAttachmentRead;
@ -719,7 +719,7 @@ namespace idk::vkn
// name += " Staging Dest";
// dbg::NameObject(copy_dest, name);
//}
cmd_buffer.copyBufferToImage(*stagingBuffer, copy_dest, vk::ImageLayout::eTransferDstOptimal, copy_regions, vk::DispatchLoaderStatic{});
cmd_buffer.copyBufferToImage(*stagingBuffer, copy_dest, vk::ImageLayout::eTransferDstOptimal, copy_regions, vk::DispatchLoaderDefault{});
staging_buffer = std::move(stagingBuffer);
staging_memory = std::move(stagingMemory);

8
src/engine/vkn/VulkanResourceManager.h
View File

@ -18,9 +18,9 @@ namespace idk::vkn
virtual ~VulkanRscBase()=default;
};
template<typename T>
struct VulkanRscDel : VulkanRscBase,vk::UniqueHandle<T, vk::DispatchLoaderStatic>
struct VulkanRscDel : VulkanRscBase,vk::UniqueHandle<T, vk::DispatchLoaderDefault>
{
using Base = vk::UniqueHandle<T, vk::DispatchLoaderStatic>;
using Base = vk::UniqueHandle<T, vk::DispatchLoaderDefault>;
using Base::Base;
VulkanRscDel(Base&& base)noexcept :Base{ std::move(base) } {}
VulkanRscDel& operator=(VulkanRscDel&& rhs)
@ -103,9 +103,9 @@ namespace idk::vkn
};
template<typename T>
struct VulkanRsc : vk::UniqueHandle<T, vk::DispatchLoaderStatic>
struct VulkanRsc : vk::UniqueHandle<T, vk::DispatchLoaderDefault>
{
using Base = vk::UniqueHandle<T, vk::DispatchLoaderStatic>;
using Base = vk::UniqueHandle<T, vk::DispatchLoaderDefault>;
using Base::Base;
VulkanRsc() = default;
VulkanRsc(Base&& base)noexcept :Base{ std::move(base) } {}

12
src/engine/vkn/VulkanState.cpp
View File

@ -310,7 +310,7 @@ namespace idk::vkn
{
result.present_family = static_cast<uint32_t>(i);
}
if (family.queueFlags & vk::QueueFlagBits::eGraphics)
if (family.queueFlags & vk::QueueFlagBits::eGraphics && family.queueCount>2)
{
result.graphics_family = static_cast<uint32_t>(i);
}
@ -406,7 +406,7 @@ namespace idk::vkn
{
QueueFamilyIndices indices = findQueueFamilies(pdevice);
m_queue_family = indices;
constexpr uint32_t num_queues = 1;//this be hack
constexpr uint32_t num_queues = 2;//this be hack
float queuePriority[num_queues] = {};
int num = 1;
for (auto& queuePri : queuePriority)
@ -455,7 +455,7 @@ namespace idk::vkn
//m_device.~UniqueHandle();
m_device = vk::UniqueDevice{ pdevice.createDevice(createInfo, nullptr, dispatcher) };
m_graphics_queue = m_device->getQueue(*m_queue_family.graphics_family, 0, dispatcher);
m_graphics_tex_queue = m_graphics_queue;
m_graphics_tex_queue = m_device->getQueue(*m_queue_family.graphics_family, 1, dispatcher);
m_present_queue = m_device->getQueue(*m_queue_family.present_family, 0, dispatcher);
//m_transfer_queue = m_device->getQueue(*m_queue_family.transfer_family, 0, dispatcher);
}
@ -805,12 +805,12 @@ namespace idk::vkn
alloc = allocator.Allocate(image, vk::MemoryPropertyFlagBits::eDeviceLocal);
vk::DeviceSize num_bytes = (4 * sizeof(uint32_t));
device->bindImageMemory(image, alloc->Memory(), alloc->Offset(), vk::DispatchLoaderStatic{});
device->bindImageMemory(image, alloc->Memory(), alloc->Offset(), vk::DispatchLoaderDefault{});
auto&& [stagingBuffer, stagingMemory] = hlp::CreateAllocBindBuffer(pdevice, *device, num_bytes, vk::BufferUsageFlagBits::eTransferSrc, vk::MemoryPropertyFlagBits::eHostCoherent | vk::MemoryPropertyFlagBits::eHostVisible, vk::DispatchLoaderStatic{});
auto&& [stagingBuffer, stagingMemory] = hlp::CreateAllocBindBuffer(pdevice, *device, num_bytes, vk::BufferUsageFlagBits::eTransferSrc, vk::MemoryPropertyFlagBits::eHostCoherent | vk::MemoryPropertyFlagBits::eHostVisible, vk::DispatchLoaderDefault{});
const void* data = nullptr;
if (data)
hlp::MapMemory(*device, *stagingMemory, 0, data, num_bytes, vk::DispatchLoaderStatic{});
hlp::MapMemory(*device, *stagingMemory, 0, data, num_bytes, vk::DispatchLoaderDefault{});
vk::AccessFlags src_flags = vk::AccessFlagBits::eMemoryRead | vk::AccessFlagBits::eShaderRead;
vk::AccessFlags dst_flags = vk::AccessFlagBits::eTransferWrite;
vk::PipelineStageFlags shader_flags = vk::PipelineStageFlagBits::eVertexShader | vk::PipelineStageFlagBits::eFragmentShader;// | vk::PipelineStageFlagBits::eTessellationControlShader | vk::PipelineStageFlagBits::eTessellationEvaluationShader;

2
src/engine/vkn/VulkanState.h
View File

@ -162,7 +162,7 @@ namespace idk::vkn
std::mutex m_graphics_tex_mutex;
vk::UniqueDescriptorPool m_descriptorpool;
vk::DispatchLoaderStatic dispatcher = {};
vk::DispatchLoaderDefault dispatcher = {};
vk::DispatchLoaderDynamic dyn_dispatcher = {};
DynamicHandle<vk::DebugUtilsMessengerEXT> m_debug_messenger;

2
src/engine/vkn/VulkanView.cpp
View File

@ -23,7 +23,7 @@ namespace idk::vkn
{
return this->vulkan_->ResourceManager();
}
vk::DispatchLoaderStatic& VulkanView::Dispatcher() const { return vulkan().dispatcher; }
vk::DispatchLoaderDefault& VulkanView::Dispatcher() const { return vulkan().dispatcher; }
vk::DispatchLoaderDynamic& VulkanView::DynDispatcher()const { return vulkan().dyn_dispatcher; }
vk::UniqueInstance& VulkanView::Instance()const { return vulkan().instance; }

2
src/engine/vkn/VulkanView.h
View File

@ -19,7 +19,7 @@ namespace idk::vkn
{
public:
VulkanResourceManager& ResourceManager()const;
vk::DispatchLoaderStatic& Dispatcher()const;
vk::DispatchLoaderDefault& Dispatcher()const;
vk::DispatchLoaderDynamic& DynDispatcher()const;
vk::UniqueInstance& Instance()const;
vk::UniqueSurfaceKHR& Surface()const;

14
src/engine/vkn/VulkanWin32GraphicsSystem.cpp
View File

@ -220,14 +220,14 @@ namespace idk::vkn
for (auto&& [attrib, location] : req.mesh_requirements)
{
auto& attrib_buffer = mesh.Get(attrib);
cmd_buffer.bindVertexBuffers(*brdf_pipeline.GetBinding(location), *attrib_buffer.buffer(), vk::DeviceSize{ attrib_buffer.offset }, vk::DispatchLoaderStatic{});
cmd_buffer.bindVertexBuffers(*brdf_pipeline.GetBinding(location), *attrib_buffer.buffer(), vk::DeviceSize{ attrib_buffer.offset }, vk::DispatchLoaderDefault{});
}
auto& oidx = mesh.GetIndexBuffer();
if (oidx)
{
cmd_buffer.bindIndexBuffer(*(*oidx).buffer(), 0, mesh.IndexType(), vk::DispatchLoaderStatic{});
cmd_buffer.drawIndexed(mesh.IndexCount(), 1, 0, 0, 0, vk::DispatchLoaderStatic{});
cmd_buffer.bindIndexBuffer(*(*oidx).buffer(), 0, mesh.IndexType(), vk::DispatchLoaderDefault{});
cmd_buffer.drawIndexed(mesh.IndexCount(), 1, 0, 0, 0, vk::DispatchLoaderDefault{});
}
cmd_buffer.endRenderPass();
cmd_buffer.end();
@ -728,7 +728,7 @@ namespace idk::vkn
void VulkanWin32GraphicsSystem::RenderGraphicsState(const GraphicsState& state, RenderStateV2& rs)
{
auto& swapchain = instance_->View().Swapchain();
auto dispatcher = vk::DispatchLoaderStatic{};
auto dispatcher = vk::DispatchLoaderDefault{};
vk::CommandBuffer& cmd_buffer = rs.cmd_buffer;
vk::CommandBufferInheritanceInfo aaa{};
vk::CommandBufferBeginInfo begin_info{vk::CommandBufferUsageFlagBits::eOneTimeSubmit,&aaa};
@ -761,13 +761,13 @@ namespace idk::vkn
for (auto&& [bindingz,attrib] : bindings)
{
auto& attrib_buffer = mesh.Get(attrib);
cmd_buffer.bindVertexBuffers(bindingz, *attrib_buffer.buffer, vk::DeviceSize{ 0 }, vk::DispatchLoaderStatic{});
cmd_buffer.bindVertexBuffers(bindingz, *attrib_buffer.buffer, vk::DeviceSize{ 0 }, vk::DispatchLoaderDefault{});
}
auto& oidx = mesh.GetIndexBuffer();
if (oidx)
{
cmd_buffer.bindIndexBuffer(*(*oidx).buffer, 0, vk::IndexType::eUint16, vk::DispatchLoaderStatic{});
cmd_buffer.drawIndexed(mesh.IndexCount(), 1, 0, 0, 0, vk::DispatchLoaderStatic{});
cmd_buffer.bindIndexBuffer(*(*oidx).buffer, 0, vk::IndexType::eUint16, vk::DispatchLoaderDefault{});
cmd_buffer.drawIndexed(mesh.IndexCount(), 1, 0, 0, 0, vk::DispatchLoaderDefault{});
}
}
cmd_buffer.endRenderPass();

6
src/engine/vkn/vector_buffer.cpp
View File

@ -38,7 +38,7 @@ namespace idk::vkn
pdevice, device, _capacity,
vk::BufferUsageFlagBits::eIndexBuffer | vk::BufferUsageFlagBits::eVertexBuffer | vk::BufferUsageFlagBits::eTransferDst | vk::BufferUsageFlagBits::eTransferSrc,
vk::MemoryPropertyFlagBits::eHostCoherent | vk::MemoryPropertyFlagBits::eHostVisible,
vk::DispatchLoaderStatic{}
vk::DispatchLoaderDefault{}
);
_memory = std::move(mem);
@ -64,7 +64,7 @@ namespace idk::vkn
size_t limit_offset = 0;
do {
auto limit_len = std::min(len-limit_offset, limit);
cmd_buffer.updateBuffer(*_buffer, limit_offset+offset, hlp::make_array_proxy(static_cast<uint32_t>(limit_len), data+limit_offset), vk::DispatchLoaderStatic{});
cmd_buffer.updateBuffer(*_buffer, limit_offset+offset, hlp::make_array_proxy(static_cast<uint32_t>(limit_len), data+limit_offset), vk::DispatchLoaderDefault{});
limit_offset += limit_len;
} while (limit_offset<len);
}
@ -111,7 +111,7 @@ namespace idk::vkn
}
bbucket_list::bucket::bucket(vk::Device device, vk::PhysicalDevice pd, MemoryAllocator& allocator, vk::BufferUsageFlags buffer_flags, vk::MemoryPropertyFlags mem_flags, size_t cap) :capacity{ cap }, data(cap, '0')
{
auto&& [buf, alloc] = hlp::CreateAllocBindBuffer(pd, device, cap, buffer_flags, mem_flags, allocator, vk::DispatchLoaderStatic{});
auto&& [buf, alloc] = hlp::CreateAllocBindBuffer(pd, device, cap, buffer_flags, mem_flags, allocator, vk::DispatchLoaderDefault{});
buffer = std::move(buf);
memory = std::move(alloc);
data.resize(0);