xiaoqi
/
SHADE_Y3
1
0
Fork 0
Code Issues 12 Pull Requests Packages Projects Releases 9 Wiki Activity

WIP

This commit is contained in:
Brandon Mak 2022-09-12 20:08:01 +08:00
parent 47e9e3d3f2
commit 506d3a1c35
10 changed files with 104 additions and 342 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
SHADE_Engine/SHADE_Engine.vcxproj
View File

@ -276,4 +276,4 @@
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>
</Project>

11
SHADE_Engine/SHADE_Engine.vcxproj.filters
View File

@ -4,6 +4,9 @@
<Filter Include="Editor">
<UniqueIdentifier>{8C1A20B0-78BC-4A86-6177-5EDA4DB8D1D6}</UniqueIdentifier>
</Filter>
<Filter Include="Editor\Backend">
<UniqueIdentifier>{43EDC149-2FBB-B54F-184F-267604BC91B4}</UniqueIdentifier>
</Filter>
<Filter Include="Engine">
<UniqueIdentifier>{DBC7D3B0-C769-FE86-B024-12DB9C6585D7}</UniqueIdentifier>
</Filter>
@ -111,6 +114,9 @@
</Filter>
</ItemGroup>
<ItemGroup>
<ClInclude Include="src\Editor\Backend\SHImGuiVulkanBackend.h">
<Filter>Editor\Backend</Filter>
</ClInclude>
<ClInclude Include="src\Editor\SHEditor.h">
<Filter>Editor</Filter>
</ClInclude>
@ -361,9 +367,11 @@
<ClInclude Include="src\Tools\SHLogger.h">
<Filter>Tools</Filter>
</ClInclude>
<ClInclude Include="src\Editor\Backend\SHImGuiVulkanBackend.h" />
</ItemGroup>
<ItemGroup>
<ClCompile Include="src\Editor\Backend\SHImGuiVulkanBackend.cpp">
<Filter>Editor\Backend</Filter>
</ClCompile>
<ClCompile Include="src\Editor\SHEditor.cpp">
<Filter>Editor</Filter>
</ClCompile>
@ -542,6 +550,5 @@
<ClCompile Include="src\Tools\SHLogger.cpp">
<Filter>Tools</Filter>
</ClCompile>
<ClCompile Include="src\Editor\Backend\SHImGuiVulkanBackend.cpp" />
</ItemGroup>
</Project>

334
SHADE_Engine/src/Editor/Backend/SHImGuiVulkanBackend.cpp
View File

@ -235,6 +235,7 @@ namespace SHADE
ImVec2 SHImGuiVulkanBackend::GetChildWindowPos(ImGuiViewport* viewport) noexcept
{
return {};
}
void SHImGuiVulkanBackend::SetChildWindowPos(ImGuiViewport* viewport, ImVec2 size) noexcept
@ -254,14 +255,14 @@ namespace SHADE
{
for (auto& primBuffer : primitiveBuffers)
{
primBuffer.vertexBuffer = logicalDeviceHdl->CreateBuffer(sizeof(ImDrawVert) * 3000,
primBuffer.vertexBuffer = device->CreateBuffer(sizeof(ImDrawVert) * 3000,
nullptr,
sizeof(ImDrawVert) * 3000,
vk::BufferUsageFlagBits::eVertexBuffer,
VMA_MEMORY_USAGE_AUTO,
VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT | VMA_ALLOCATION_CREATE_MAPPED_BIT); // alloc flags
primBuffer.indicesBuffer = logicalDeviceHdl->CreateBuffer(sizeof(ImDrawIdx) * 3000,
primBuffer.indicesBuffer = device->CreateBuffer(sizeof(ImDrawIdx) * 3000,
nullptr,
sizeof(ImDrawIdx) * 3000,
vk::BufferUsageFlagBits::eIndexBuffer,
@ -283,331 +284,28 @@ namespace SHADE
// If your ImTextureId represent a higher-level concept than just a GL texture id, consider calling GetTexDataAsAlpha8() instead to save on GPU memory.
io.Fonts->GetTexDataAsRGBA32(&pixels, &width, &height);
SHImageCreateParams createParams{};
createParams.imageType = vk::ImageType::e2D;
createParams.width = width;
createParams.height = height;
createParams.depth = 1;
createParams.levels = 1;
createParams.arrayLayers = 1;
createParams.imageFormat = vk::Format::eR8G8B8A8Unorm;
createParams.usageFlags = vk::ImageUsageFlagBits::eSampled | vk::ImageUsageFlagBits::eTransferDst;
createParams.createFlags = {};
fontsMipOffset.push_back(0);
// Create the texture in xgpu
{
std::array<xgpu::texture::setup::mip, 1> Mip{ height * width * sizeof(std::uint32_t) };
xgpu::texture::setup Setup;
Setup.m_Height = height;
Setup.m_Width = width;
Setup.m_MipChain = Mip;
Setup.m_Data = { reinterpret_cast<const std::byte*>(pixels), Mip[0].m_Size };
if (auto Err = m_Device.Create(Texture, Setup); Err)
return Err;
}
fontsTexture = device->CreateImage(createParams, pixels, width * height * sizeof(uint32_t), fontsMipOffset, VmaMemoryUsage::VMA_MEMORY_USAGE_AUTO, {});
// We could put here the texture id if we wanted
io.Fonts->TexID = nullptr;
return nullptr;
}
}
#include <SHpch.h>
#include <stdio.h>
#include <imgui.h>
#include "SHImGuiVulkanBackend.h"
#include <Engine/ECS_Base/System/SHSystemManager.h>
#include "Tools/SHLogger.h"
namespace SHADE
{
#define GETINSTANCE \
ImGuiIO& io = ImGui::GetIO(); \
SHBreachInstance& instance = *reinterpret_cast<SHBreachInstance*>(io.UserData);
/*
#==============================================================#
|| Embedded Shaders ||
#==============================================================#
*/
// glsl_shader.vert, compiled with:
// # glslangValidator -V -x -o glsl_shader.vert.u32 glsl_shader.vert
/*
#version 450 core
layout(location = 0) in vec2 aPos;
layout(location = 1) in vec2 aUV;
layout(location = 2) in vec4 aColor;
layout(push_constant) uniform uPushConstant { vec2 uScale; vec2 uTranslate; } pc;
out gl_PerVertex { vec4 gl_Position; };
layout(location = 0) out struct { vec4 Color; vec2 UV; } Out;
void main()
{
Out.Color = aColor;
Out.UV = aUV;
gl_Position = vec4(aPos * pc.uScale + pc.uTranslate, 0, 1);
}
*/
static uint32_t __glsl_shader_vert_spv[] =
{
0x07230203,0x00010000,0x00080001,0x0000002e,0x00000000,0x00020011,0x00000001,0x0006000b,
0x00000001,0x4c534c47,0x6474732e,0x3035342e,0x00000000,0x0003000e,0x00000000,0x00000001,
0x000a000f,0x00000000,0x00000004,0x6e69616d,0x00000000,0x0000000b,0x0000000f,0x00000015,
0x0000001b,0x0000001c,0x00030003,0x00000002,0x000001c2,0x00040005,0x00000004,0x6e69616d,
0x00000000,0x00030005,0x00000009,0x00000000,0x00050006,0x00000009,0x00000000,0x6f6c6f43,
0x00000072,0x00040006,0x00000009,0x00000001,0x00005655,0x00030005,0x0000000b,0x0074754f,
0x00040005,0x0000000f,0x6c6f4361,0x0000726f,0x00030005,0x00000015,0x00565561,0x00060005,
0x00000019,0x505f6c67,0x65567265,0x78657472,0x00000000,0x00060006,0x00000019,0x00000000,
0x505f6c67,0x7469736f,0x006e6f69,0x00030005,0x0000001b,0x00000000,0x00040005,0x0000001c,
0x736f5061,0x00000000,0x00060005,0x0000001e,0x73755075,0x6e6f4368,0x6e617473,0x00000074,
0x00050006,0x0000001e,0x00000000,0x61635375,0x0000656c,0x00060006,0x0000001e,0x00000001,
0x61725475,0x616c736e,0x00006574,0x00030005,0x00000020,0x00006370,0x00040047,0x0000000b,
0x0000001e,0x00000000,0x00040047,0x0000000f,0x0000001e,0x00000002,0x00040047,0x00000015,
0x0000001e,0x00000001,0x00050048,0x00000019,0x00000000,0x0000000b,0x00000000,0x00030047,
0x00000019,0x00000002,0x00040047,0x0000001c,0x0000001e,0x00000000,0x00050048,0x0000001e,
0x00000000,0x00000023,0x00000000,0x00050048,0x0000001e,0x00000001,0x00000023,0x00000008,
0x00030047,0x0000001e,0x00000002,0x00020013,0x00000002,0x00030021,0x00000003,0x00000002,
0x00030016,0x00000006,0x00000020,0x00040017,0x00000007,0x00000006,0x00000004,0x00040017,
0x00000008,0x00000006,0x00000002,0x0004001e,0x00000009,0x00000007,0x00000008,0x00040020,
0x0000000a,0x00000003,0x00000009,0x0004003b,0x0000000a,0x0000000b,0x00000003,0x00040015,
0x0000000c,0x00000020,0x00000001,0x0004002b,0x0000000c,0x0000000d,0x00000000,0x00040020,
0x0000000e,0x00000001,0x00000007,0x0004003b,0x0000000e,0x0000000f,0x00000001,0x00040020,
0x00000011,0x00000003,0x00000007,0x0004002b,0x0000000c,0x00000013,0x00000001,0x00040020,
0x00000014,0x00000001,0x00000008,0x0004003b,0x00000014,0x00000015,0x00000001,0x00040020,
0x00000017,0x00000003,0x00000008,0x0003001e,0x00000019,0x00000007,0x00040020,0x0000001a,
0x00000003,0x00000019,0x0004003b,0x0000001a,0x0000001b,0x00000003,0x0004003b,0x00000014,
0x0000001c,0x00000001,0x0004001e,0x0000001e,0x00000008,0x00000008,0x00040020,0x0000001f,
0x00000009,0x0000001e,0x0004003b,0x0000001f,0x00000020,0x00000009,0x00040020,0x00000021,
0x00000009,0x00000008,0x0004002b,0x00000006,0x00000028,0x00000000,0x0004002b,0x00000006,
0x00000029,0x3f800000,0x00050036,0x00000002,0x00000004,0x00000000,0x00000003,0x000200f8,
0x00000005,0x0004003d,0x00000007,0x00000010,0x0000000f,0x00050041,0x00000011,0x00000012,
0x0000000b,0x0000000d,0x0003003e,0x00000012,0x00000010,0x0004003d,0x00000008,0x00000016,
0x00000015,0x00050041,0x00000017,0x00000018,0x0000000b,0x00000013,0x0003003e,0x00000018,
0x00000016,0x0004003d,0x00000008,0x0000001d,0x0000001c,0x00050041,0x00000021,0x00000022,
0x00000020,0x0000000d,0x0004003d,0x00000008,0x00000023,0x00000022,0x00050085,0x00000008,
0x00000024,0x0000001d,0x00000023,0x00050041,0x00000021,0x00000025,0x00000020,0x00000013,
0x0004003d,0x00000008,0x00000026,0x00000025,0x00050081,0x00000008,0x00000027,0x00000024,
0x00000026,0x00050051,0x00000006,0x0000002a,0x00000027,0x00000000,0x00050051,0x00000006,
0x0000002b,0x00000027,0x00000001,0x00070050,0x00000007,0x0000002c,0x0000002a,0x0000002b,
0x00000028,0x00000029,0x00050041,0x00000011,0x0000002d,0x0000001b,0x0000000d,0x0003003e,
0x0000002d,0x0000002c,0x000100fd,0x00010038
};
// glsl_shader.frag, compiled with:
// # glslangValidator -V -x -o glsl_shader.frag.u32 glsl_shader.frag
/*
#version 450 core
layout(location = 0) out vec4 fColor;
layout(set=0, binding=0) uniform sampler2D sTexture;
layout(location = 0) in struct { vec4 Color; vec2 UV; } In;
void main()
{
fColor = In.Color * texture(sTexture, In.UV.st);
}
*/
static uint32_t __glsl_shader_frag_spv[] =
{
0x07230203,0x00010000,0x00080001,0x0000001e,0x00000000,0x00020011,0x00000001,0x0006000b,
0x00000001,0x4c534c47,0x6474732e,0x3035342e,0x00000000,0x0003000e,0x00000000,0x00000001,
0x0007000f,0x00000004,0x00000004,0x6e69616d,0x00000000,0x00000009,0x0000000d,0x00030010,
0x00000004,0x00000007,0x00030003,0x00000002,0x000001c2,0x00040005,0x00000004,0x6e69616d,
0x00000000,0x00040005,0x00000009,0x6c6f4366,0x0000726f,0x00030005,0x0000000b,0x00000000,
0x00050006,0x0000000b,0x00000000,0x6f6c6f43,0x00000072,0x00040006,0x0000000b,0x00000001,
0x00005655,0x00030005,0x0000000d,0x00006e49,0x00050005,0x00000016,0x78655473,0x65727574,
0x00000000,0x00040047,0x00000009,0x0000001e,0x00000000,0x00040047,0x0000000d,0x0000001e,
0x00000000,0x00040047,0x00000016,0x00000022,0x00000000,0x00040047,0x00000016,0x00000021,
0x00000000,0x00020013,0x00000002,0x00030021,0x00000003,0x00000002,0x00030016,0x00000006,
0x00000020,0x00040017,0x00000007,0x00000006,0x00000004,0x00040020,0x00000008,0x00000003,
0x00000007,0x0004003b,0x00000008,0x00000009,0x00000003,0x00040017,0x0000000a,0x00000006,
0x00000002,0x0004001e,0x0000000b,0x00000007,0x0000000a,0x00040020,0x0000000c,0x00000001,
0x0000000b,0x0004003b,0x0000000c,0x0000000d,0x00000001,0x00040015,0x0000000e,0x00000020,
0x00000001,0x0004002b,0x0000000e,0x0000000f,0x00000000,0x00040020,0x00000010,0x00000001,
0x00000007,0x00090019,0x00000013,0x00000006,0x00000001,0x00000000,0x00000000,0x00000000,
0x00000001,0x00000000,0x0003001b,0x00000014,0x00000013,0x00040020,0x00000015,0x00000000,
0x00000014,0x0004003b,0x00000015,0x00000016,0x00000000,0x0004002b,0x0000000e,0x00000018,
0x00000001,0x00040020,0x00000019,0x00000001,0x0000000a,0x00050036,0x00000002,0x00000004,
0x00000000,0x00000003,0x000200f8,0x00000005,0x00050041,0x00000010,0x00000011,0x0000000d,
0x0000000f,0x0004003d,0x00000007,0x00000012,0x00000011,0x0004003d,0x00000014,0x00000017,
0x00000016,0x00050041,0x00000019,0x0000001a,0x0000000d,0x00000018,0x0004003d,0x0000000a,
0x0000001b,0x0000001a,0x00050057,0x00000007,0x0000001c,0x00000017,0x0000001b,0x00050085,
0x00000007,0x0000001d,0x00000012,0x0000001c,0x0003003e,0x00000009,0x0000001d,0x000100fd,
0x00010038
};
/*
#==============================================================#
|| ImGui Push Constants ||
#==============================================================#
*/
struct ImGui_Push_Constants
{
std::array<float, 2> scale;
std::array<float, 2> translate;
};
void SHImGuiVulkanBackend::CreateInstance(Handle<SHVkLogicalDevice> const& logicalDevice) noexcept
{
if (ImGui::GetCurrentContext() == nullptr)
{
IMGUI_CHECKVERSION();
ImGui::CreateContext();
}
else { SHLOG_WARNING("ImGui context already exists") };
ImGuiIO& io = ImGui::GetIO();
io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; // Enable Keyboard Controls
io.ConfigFlags |= ImGuiConfigFlags_DockingEnable; // Enable Docking
io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable; // Enable Multi-Viewport / Platform Windows
io.BackendFlags |= ImGuiBackendFlags_RendererHasVtxOffset; // We can honor the ImDrawCmd::VtxOffset field, allowing for large meshes.
//io.BackendFlags |= ImGuiBackendFlags_RendererHasViewports; // We can create multi-viewports on the Renderer side (optional)
//io.BackendFlags |= ImGuiBackendFlags_PlatformHasViewports; // We can create multi-viewports on the Platform side (optional)
io.BackendRendererName = "SHImGuiVulkanBackend";
if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
{
ImGuiPlatformIO& platformIO = ImGui::GetPlatformIO();
platformIO.Renderer_CreateWindow = CreateChildWindow;
platformIO.Renderer_DestroyWindow = DestroyChildWindow;
platformIO.Renderer_SetWindowSize = SetChildWindowSize;
platformIO.Renderer_RenderWindow = RenderChildWindow;
platformIO.Renderer_SwapBuffers = ChildSwapBuffers;
platformIO.Platform_CreateWindow = CreateChildWindow;
platformIO.Platform_DestroyWindow = DestroyChildWindow;
platformIO.Platform_ShowWindow = [](ImGuiViewport* pViewport) {};
platformIO.Platform_SetWindowPos = SetChildWindowPos;
platformIO.Platform_GetWindowPos = GetChildWindowPos;
platformIO.Platform_SetWindowSize = SetChildWindowSize;
platformIO.Platform_GetWindowSize = GetChildWindowSize;
//platform_io.Platform_SetWindowFocus = ImGui_ImplGlfw_SetWindowFocus;
//platform_io.Platform_GetWindowFocus = ImGui_ImplGlfw_GetWindowFocus;
//platform_io.Platform_GetWindowMinimized = ImGui_ImplGlfw_GetWindowMinimized;
platformIO.Platform_SetWindowTitle = [](ImGuiViewport* pViewport, const char*) {};
platformIO.Platform_RenderWindow = RenderChildWindow;
platformIO.Platform_SwapBuffers = ChildSwapBuffers;
platformIO.Monitors.resize(0);
ImGuiPlatformMonitor monitor;
monitor.MainPos = monitor.WorkPos = {};
monitor.MainSize = monitor.WorkSize = {};
platformIO.Monitors.push_back(monitor);
}//if(io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
//associate io keymap with engine input keymap
//Initialize instance
auto instance = std::make_unique<SHBreachInstance>();
instance->InitializePipeline(io);
instance->lastFrameTime = std::chrono::high_resolution_clock::now();
io.UserData = instance.release();
ImGuiViewport* viewport = ImGui::GetMainViewport();
viewport->RendererUserData = io.UserData;
viewport->PlatformHandle = io.UserData;
}
void SHImGuiVulkanBackend::Render(void) noexcept
{
ImGui::Render();
ImDrawData* drawData = ImGui::GetDrawData();
//TODO: instance draw data
}
void SHImGuiVulkanBackend::CreateChildWindow(ImGuiViewport* viewport) noexcept
{
GETINSTANCE
auto& info = *new SHImGuiWindow{ instance.device };
viewport->RendererUserData = &info;
}
void SHImGuiVulkanBackend::DestroyChildWindow(ImGuiViewport* viewport) noexcept
{
GETINSTANCE
auto info = reinterpret_cast<SHImGuiWindow*>(viewport->RendererUserData);
delete info;
viewport->RendererUserData = nullptr;
}
ImVec2 SHImGuiVulkanBackend::GetChildWindowSize(ImGuiViewport* viewport) noexcept
{
auto info = reinterpret_cast<SHImGuiWindow*>(viewport->RendererUserData);
return{};
}
void SHImGuiVulkanBackend::SetChildWindowSize(ImGuiViewport* viewport, ImVec2 size) noexcept
void SHImGuiVulkanBackend::SHBreachInstance::InitializePipeline(ImGuiIO& io) noexcept
{
}
ImVec2 SHImGuiVulkanBackend::GetChildWindowPos(ImGuiViewport* viewport) noexcept
{
}
void SHImGuiVulkanBackend::SetChildWindowPos(ImGuiViewport* viewport, ImVec2 size) noexcept
{
}
void SHImGuiVulkanBackend::RenderChildWindow(ImGuiViewport* viewport, void*) noexcept
{
}
void SHImGuiVulkanBackend::ChildSwapBuffers(ImGuiViewport* viewport, void*) noexcept
{
}
void SHImGuiVulkanBackend::SHImGuiWindow::InitializeBuffers(void) noexcept
{
for (auto& primBuffer : primitiveBuffers)
{
primBuffer.vertexBuffer = logicalDeviceHdl->CreateBuffer(sizeof(ImDrawVert) * 3000,
nullptr,
sizeof(ImDrawVert) * 3000,
vk::BufferUsageFlagBits::eVertexBuffer,
VMA_MEMORY_USAGE_AUTO,
VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT | VMA_ALLOCATION_CREATE_MAPPED_BIT); // alloc flags
primBuffer.indicesBuffer = logicalDeviceHdl->CreateBuffer(sizeof(ImDrawIdx) * 3000,
nullptr,
sizeof(ImDrawIdx) * 3000,
vk::BufferUsageFlagBits::eIndexBuffer,
VMA_MEMORY_USAGE_AUTO,
VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT | VMA_ALLOCATION_CREATE_MAPPED_BIT); // alloc flags
}
}
void SHImGuiVulkanBackend::SHBreachInstance::CreateFontsTexture(Handle<SHVkImage> image, ImGuiIO& io) noexcept
{
// Build texture atlas
unsigned char* pixels;
int width, height;
// Load as RGBA 32-bits (75% of the memory is wasted, but default font is so small) because it is more likely to be compatible with user's existing shaders.
// If your ImTextureId represent a higher-level concept than just a GL texture id, consider calling GetTexDataAsAlpha8() instead to save on GPU memory.
io.Fonts->GetTexDataAsRGBA32(&pixels, &width, &height);
// Create the texture in xgpu
{
std::array<xgpu::texture::setup::mip, 1> Mip{ height * width * sizeof(std::uint32_t) };
xgpu::texture::setup Setup;
Setup.m_Height = height;
Setup.m_Width = width;
Setup.m_MipChain = Mip;
Setup.m_Data = { reinterpret_cast<const std::byte*>(pixels), Mip[0].m_Size };
if (auto Err = m_Device.Create(Texture, Setup); Err)
return Err;
}
// We could put here the texture id if we wanted
io.Fonts->TexID = nullptr;
return nullptr;
}
}

3
SHADE_Engine/src/Editor/Backend/SHImGuiVulkanBackend.h
View File

@ -1,5 +1,6 @@
#pragma once
#include <chrono>
#include <Graphics/Instance/SHVkInstance.h>
#include "Graphics/Buffers/SHVkBuffer.h"
#include "Graphics/Images/SHVkImage.h"
@ -35,6 +36,8 @@ namespace SHADE
{
Handle<SHVkPipeline> pipeline;
std::chrono::time_point<std::chrono::steady_clock> lastFrameTime;
Handle<SHVkImage> fontsTexture;
std::vector<uint32_t> fontsMipOffset;
public:
void CreateFontsTexture (Handle<SHVkImage> image, ImGuiIO& io) noexcept;
void InitializePipeline(ImGuiIO& io) noexcept;

19
SHADE_Engine/src/Graphics/Commands/SHVkCommandBuffer.cpp
View File

@ -407,6 +407,25 @@ namespace SHADE
}
void SHVkCommandBuffer::PipelineBarrier (
vk::PipelineStageFlags srcStage,
vk::PipelineStageFlags dstStage,
vk::DependencyFlags deps,
std::vector<vk::MemoryBarrier> const& memoryBarriers,
std::vector<vk::BufferMemoryBarrier> const& bufferMemoryBarriers,
std::vector<vk::ImageMemoryBarrier> const& imageMemoryBarriers
) const noexcept
{
vkCommandBuffer.pipelineBarrier (
srcStage,
dstStage,
deps,
memoryBarriers,
bufferMemoryBarriers,
imageMemoryBarriers
);
}
//void SHVkCommandBuffer::PipelineBarrier(vk::PipelineStageFlags ) const noexcept
//{
// //vkCommandBuffer.pipelineBarrier()

9
SHADE_Engine/src/Graphics/Commands/SHVkCommandBuffer.h
View File

@ -115,7 +115,14 @@ namespace SHADE
void DrawIndexed (uint32_t indexCount, uint32_t firstIndex, uint32_t vertexOffset) const noexcept;
// memory barriers
//void PipelineBarrier (void) const noexcept;
void PipelineBarrier (
vk::PipelineStageFlags srcStage,
vk::PipelineStageFlags dstStage,
vk::DependencyFlags deps,
std::vector<vk::MemoryBarrier> const& memoryBarriers,
std::vector<vk::BufferMemoryBarrier> const& bufferMemoryBarriers,
std::vector<vk::ImageMemoryBarrier> const& imageMemoryBarriers
) const noexcept;
// Push Constant variable setting
template <typename T>

7
SHADE_Engine/src/Graphics/Devices/SHVkLogicalDevice.cpp
View File

@ -418,7 +418,12 @@ namespace SHADE
/***************************************************************************/
Handle<SHVkImage> SHVkLogicalDevice::CreateImage(uint32_t w, uint32_t h, uint8_t levels, vk::Format format, vk::ImageUsageFlags usage, vk::ImageCreateFlags create) const noexcept
{
return SHVkInstance::GetResourceManager().Create<SHVkImage>(std::cref(vmaAllocator), w, h, levels, format, usage, create);
return SHVkInstance::GetResourceManager().Create<SHVkImage>(&vmaAllocator, w, h, levels, format, usage, create);
}
Handle<SHVkImage> SHVkLogicalDevice::CreateImage(SHImageCreateParams const& imageDetails, unsigned char* data, uint32_t dataSize, std::span<uint32_t> inMipOffsets, VmaMemoryUsage memUsage, VmaAllocationCreateFlags allocFlags) noexcept
{
return SHVkInstance::GetResourceManager().Create<SHVkImage>(&vmaAllocator, imageDetails, data, dataSize, inMipOffsets, memUsage, allocFlags);
}
/***************************************************************************/

25
SHADE_Engine/src/Graphics/Devices/SHVkLogicalDevice.h
View File

@ -19,6 +19,7 @@
#include "vk_mem_alloc.h"
#include "Graphics/Descriptors/SHVkDescriptorPool.h"
#include "Graphics/Descriptors/SHVkDescriptorSetLayout.h"
#include "Graphics/Images/SHVkImage.h"
namespace SHADE
{
@ -29,7 +30,6 @@ namespace SHADE
class SHVkSurface;
class SHVkSwapchain;
class SHVkBuffer;
class SHVkImage;
class SHVkFence;
class SHVkSemaphore;
class SHVkShaderModule;
@ -138,14 +138,23 @@ namespace SHADE
) const noexcept;
Handle<SHVkImage> CreateImage (
uint32_t w,
uint32_t h,
uint8_t levels,
vk::Format format,
vk::ImageUsageFlags usage,
vk::ImageCreateFlags create
uint32_t w,
uint32_t h,
uint8_t levels,
vk::Format format,
vk::ImageUsageFlags usage,
vk::ImageCreateFlags create
) const noexcept;
Handle<SHVkImage> CreateImage (
SHImageCreateParams const& imageDetails,
unsigned char* data,
uint32_t dataSize,
std::span<uint32_t> inMipOffsets,
VmaMemoryUsage memUsage,
VmaAllocationCreateFlags allocFlags
) noexcept;
Handle<SHVkShaderModule> CreateShaderModule (
std::vector<uint32_t> const& binaryData,
std::string entryPoint,

30
SHADE_Engine/src/Graphics/Images/SHVkImage.cpp
View File

@ -103,11 +103,8 @@ namespace SHADE
, randomAccessOptimized {false}
, mappedPtr{nullptr}
{
for (auto& bit : imageDetails.usageBits)
usageFlags |= bit;
for (auto& bit : imageDetails.createBits)
createFlags |= bit;
usageFlags = imageDetails.usageFlags;
createFlags = imageDetails.createFlags;
// If marked as 2D array compatible, image type MUST be 3D
if (createFlags & vk::ImageCreateFlagBits::e2DArrayCompatible)
@ -257,9 +254,27 @@ namespace SHADE
}
void SHVkImage::TransitionImage(vk::ImageLayout oldLayout, vk::ImageLayout newLayout) noexcept
/***************************************************************************/
/*!
\brief
Does not perform any image transitions but prepares a barrier for image
transitioning. Pipeline barrier will be issued outside this call after
this preparation function, or at least, it should be.
\param oldLayout
Old layout of the image.
\param newLayout
new layout of the image to transition to.
\param barrier
Barrier to modify to prepare the image for transitioning.
*/
/***************************************************************************/
void SHVkImage::PrepareImageTransition(vk::ImageLayout oldLayout, vk::ImageLayout newLayout, vk::ImageMemoryBarrier& barrier) noexcept
{
vk::ImageMemoryBarrier barrier{};
barrier.oldLayout = oldLayout;
barrier.newLayout = newLayout;
barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
@ -297,7 +312,6 @@ namespace SHADE
SHLOG_ERROR("Image layouts are invalid. ");
}
//cmdBufferHdl
}
void SHVkImage::LinkWithExteriorImage(vk::Image inVkImage, vk::ImageType type, uint32_t inWidth, uint32_t inHeight, uint32_t inDepth, uint32_t layers, uint8_t levels, vk::Format format, vk::ImageUsageFlags flags) noexcept

6
SHADE_Engine/src/Graphics/Images/SHVkImage.h
View File

@ -36,10 +36,10 @@ namespace SHADE
vk::Format imageFormat;
//! Image usage bits
std::span<vk::ImageUsageFlagBits> usageBits;
vk::ImageUsageFlags usageFlags;
//! Image create flags
std::span<vk::ImageCreateFlagBits> createBits;
vk::ImageCreateFlags createFlags;
};
class SHVkImage
@ -136,7 +136,7 @@ namespace SHADE
/*-----------------------------------------------------------------------*/
Handle<SHVkImageView> CreateImageView (Handle<SHVkLogicalDevice> const& inLogicalDeviceHdl, Handle<SHVkImage> const& parent, SHImageViewDetails const& createParams) const noexcept;
void TransferToDeviceResource (Handle<SHVkCommandBuffer> const& cmdBufferHdl) noexcept;
void TransitionImage (vk::ImageLayout oldLayout, vk::ImageLayout newLayout) noexcept;
void PrepareImageTransition (vk::ImageLayout oldLayout, vk::ImageLayout newLayout, vk::ImageMemoryBarrier& barrier) noexcept;
/*-----------------------------------------------------------------------*/
/* GETTERS AND SETTERS */