修改暂时还原

src/engine/asset_compiler/asset_compiler.vcxproj

@@ -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>

src/engine/editor/IDE.h

@@ -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

src/engine/editor/windows/IGE_InspectorWindow_DisplayComponentInnerSpecializations.cpp

@@ -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();
 

src/engine/editorstatic/DescriptorPoolManager.cpp

@@ -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;
 	}
 

src/engine/game/AddSystems.cpp

@@ -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>
 

src/engine/game/game.vcxproj

@@ -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>

src/engine/idk.ruleset

@@ -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>

src/engine/idk/IDK.vcxproj

@@ -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>

src/engine/idk/res/ResourceHandle.inl

@@ -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>

src/engine/launcher/launcher.vcxproj

@@ -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>

src/engine/launcher/launcher.vcxproj.user

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

src/engine/opengl/idk_opengl.vcxproj

@@ -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>

src/engine/opengl/idk_opengl.vcxproj.user

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

src/engine/vkn/BufferHelpers.h

@@ -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);

src/engine/vkn/ColorPickRenderer.cpp

@@ -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.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::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::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{});
 				}
 			}
 

src/engine/vkn/CubemapRenderer.cpp

@@ -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.bindIndexBuffer(*(*oidx).buffer(), 0, mesh.IndexType(), vk::DispatchLoaderDefault{});
-				cmd_buffer.drawIndexed(mesh.IndexCount(), 1, 0, 0, 0, vk::DispatchLoaderStatic{});
+				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.bindIndexBuffer(*(*oidx).buffer(), 0, mesh.IndexType(), vk::DispatchLoaderDefault{});
-				cmd_buffer.drawIndexed(mesh.IndexCount(), 1, 0, 0, 0, vk::DispatchLoaderStatic{});
+				cmd_buffer.drawIndexed(mesh.IndexCount(), 1, 0, 0, 0, vk::DispatchLoaderDefault{});
 			}
 
 

src/engine/vkn/DeferredPass.cpp

@@ -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.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::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::DispatchLoaderDefault{});
 			}
 		}
 		return rendered;

src/engine/vkn/DescriptorPoolsManager.cpp

@@ -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{});
 	}
 
 }

src/engine/vkn/DescriptorUpdateData.cpp

@@ -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()

src/engine/vkn/FrameRenderer.cpp

@@ -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.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::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::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->begin(begin_info, vk::DispatchLoaderDefault{});
-			transition_buffer->pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, vk::PipelineStageFlagBits::eTransfer, vk::DependencyFlags{}, nullptr, nullptr, presentToClearBarrier, vk::DispatchLoaderStatic{});
+			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;

src/engine/vkn/MemoryAllocator.cpp

@@ -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();

src/engine/vkn/PipelineThingy.cpp

@@ -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{});
 	}
 
 	*/

src/engine/vkn/RenderTask.cpp

@@ -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;
 									}

src/engine/vkn/ShaderModule.cpp

@@ -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)
 		//{

src/engine/vkn/VknCubeMapLoader.cpp

@@ -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
 				{

src/engine/vkn/VknFontAtlasLoader.cpp

@@ -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);
 			;

src/engine/vkn/VknMeshModder.cpp

@@ -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)

src/engine/vkn/VknRenderTargetFactory.cpp

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

src/engine/vkn/VknTextureLoader.cpp

@@ -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);

src/engine/vkn/VulkanResourceManager.h

@@ -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) } {}

src/engine/vkn/VulkanState.cpp

@@ -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;

src/engine/vkn/VulkanState.h

@@ -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;
 

src/engine/vkn/VulkanView.cpp

@@ -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; }

src/engine/vkn/VulkanView.h

@@ -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;

src/engine/vkn/VulkanWin32GraphicsSystem.cpp

@@ -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.bindIndexBuffer(*(*oidx).buffer(), 0, mesh.IndexType(), vk::DispatchLoaderDefault{});
-			cmd_buffer.drawIndexed(mesh.IndexCount(), 1, 0, 0, 0, vk::DispatchLoaderStatic{});
+			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.bindIndexBuffer(*(*oidx).buffer, 0, vk::IndexType::eUint16, vk::DispatchLoaderDefault{});
-				cmd_buffer.drawIndexed(mesh.IndexCount(), 1, 0, 0, 0, vk::DispatchLoaderStatic{});
+				cmd_buffer.drawIndexed(mesh.IndexCount(), 1, 0, 0, 0, vk::DispatchLoaderDefault{});
 			}
 		}
 		cmd_buffer.endRenderPass();

src/engine/vkn/vector_buffer.cpp

@@ -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);