kbz_8/ScopEngine
1
0
Fork 0
Code Issues Pull Requests actions.actions Packages Projects Releases Wiki Activity

yes

Browse Source
This commit is contained in:
Kbz-8
2025-06-16 15:18:27 +02:00
parent 15510fa8a7
commit cd7e5ad26f
165 changed files with 78107 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

141
Runtime/Sources/Renderer/RenderPasses/2DPass.cpp git.filemode.normal_file
View File

@@ -0,0 +1,141 @@
#include <Renderer/RenderPasses/2DPass.h>
#include <Renderer/Pipelines/Graphics.h>
#include <Renderer/ViewerData.h>
#include <Renderer/Renderer.h>
#include <Graphics/Scene.h>
#include <Core/Engine.h>
#include <Maths/Mat4.h>
namespace Scop
{
struct SpriteData
{
Mat4f model_matrix;
Vec4f color;
};
struct ViewerData2D
{
Mat4f projection;
};
void Render2DPass::Init()
{
ShaderLayout vertex_shader_layout(
{
{ 0,
ShaderSetLayout({
{ 0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER }
})
}
}, { ShaderPushConstantLayout({ 0, sizeof(SpriteData) }) }
);
p_vertex_shader = LoadShaderFromFile(ScopEngine::Get().GetAssetsPath() / "Shaders/Build/2DVertex.spv", ShaderType::Vertex, std::move(vertex_shader_layout));
ShaderLayout fragment_shader_layout(
{
{ 1,
ShaderSetLayout({
{ 0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER }
})
}
}, {}
);
p_fragment_shader = LoadShaderFromFile(ScopEngine::Get().GetAssetsPath() / "Shaders/Build/2DFragment.spv", ShaderType::Fragment, std::move(fragment_shader_layout));
std::function<void(const EventBase&)> functor = [this](const EventBase& event)
{
if(event.What() == Event::ResizeEventCode || event.What() == Event::SceneHasChangedEventCode)
m_pipeline.Destroy();
};
EventBus::RegisterListener({ functor, "__ScopRender2DPass" });
p_viewer_data_set = RenderCore::Get().GetDescriptorPoolManager().GetAvailablePool().RequestDescriptorSet(p_vertex_shader->GetShaderLayout().set_layouts.at(0), ShaderType::Vertex);
p_texture_set = RenderCore::Get().GetDescriptorPoolManager().GetAvailablePool().RequestDescriptorSet(p_fragment_shader->GetShaderLayout().set_layouts.at(1), ShaderType::Fragment);
p_viewer_data_buffer = std::make_shared<UniformBuffer>();
p_viewer_data_buffer->Init(sizeof(ViewerData2D));
for(std::size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++)
{
p_viewer_data_set->SetUniformBuffer(i, 0, p_viewer_data_buffer->Get(i));
p_viewer_data_set->Update(i);
}
}
void Render2DPass::Pass(Scene& scene, Renderer& renderer, Texture& render_target)
{
if(m_pipeline.GetPipeline() == VK_NULL_HANDLE)
{
GraphicPipelineDescriptor pipeline_descriptor;
pipeline_descriptor.vertex_shader = p_vertex_shader;
pipeline_descriptor.fragment_shader = p_fragment_shader;
pipeline_descriptor.color_attachments = { &render_target };
pipeline_descriptor.culling = CullMode::None;
pipeline_descriptor.clear_color_attachments = false;
pipeline_descriptor.name = "2D_pass_pipeline";
m_pipeline.Init(std::move(pipeline_descriptor));
}
std::uint32_t frame_index = renderer.GetCurrentFrameIndex();
ViewerData2D viewer_data;
viewer_data.projection = Mat4f::Ortho(0.0f, render_target.GetWidth(), render_target.GetHeight(), 0.0f);
static CPUBuffer buffer(sizeof(ViewerData2D));
std::memcpy(buffer.GetData(), &viewer_data, buffer.GetSize());
p_viewer_data_buffer->SetData(buffer, frame_index);
VkCommandBuffer cmd = renderer.GetActiveCommandBuffer();
m_pipeline.BindPipeline(cmd, 0, {});
for(const auto& [_, sprite] : scene.GetSprites())
{
SpriteData sprite_data;
sprite_data.color = sprite.GetColor();
Mat4f translation_matrix = Mat4f::Identity().ApplyTranslation(Vec3f{ Vec2f(sprite.GetPosition()), 0.0f });
Mat4f scale_matrix = Mat4f::Identity().ApplyScale(Vec3f{ sprite.GetScale(), 1.0f });
sprite_data.model_matrix = Mat4f::Identity();
sprite_data.model_matrix.ConcatenateTransform(scale_matrix);
sprite_data.model_matrix.ConcatenateTransform(translation_matrix);
if(!sprite.IsSetInit())
const_cast<Sprite&>(sprite).UpdateDescriptorSet(p_texture_set);
const_cast<Sprite&>(sprite).Bind(frame_index, cmd);
std::array<VkDescriptorSet, 2> sets = { p_viewer_data_set->GetSet(frame_index), sprite.GetSet(frame_index) };
RenderCore::Get().vkCmdBindDescriptorSets(cmd, m_pipeline.GetPipelineBindPoint(), m_pipeline.GetPipelineLayout(), 0, sets.size(), sets.data(), 0, nullptr);
RenderCore::Get().vkCmdPushConstants(cmd, m_pipeline.GetPipelineLayout(), VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(SpriteData), &sprite_data);
sprite.GetMesh()->Draw(cmd, renderer.GetDrawCallsCounterRef(), renderer.GetPolygonDrawnCounterRef());
}
for(const auto& [_, text] : scene.GetTexts())
{
SpriteData sprite_data;
sprite_data.color = text.GetColor();
Mat4f translation_matrix = Mat4f::Identity().ApplyTranslation(Vec3f{ Vec2f(text.GetPosition()), 0.0f });
Mat4f scale_matrix = Mat4f::Identity().ApplyScale(Vec3f{ text.GetScale(), 1.0f });
sprite_data.model_matrix = Mat4f::Identity();
sprite_data.model_matrix.ConcatenateTransform(scale_matrix);
sprite_data.model_matrix.ConcatenateTransform(translation_matrix);
if(!text.IsSetInit())
const_cast<Text&>(text).UpdateDescriptorSet(p_texture_set);
const_cast<Text&>(text).Bind(frame_index, cmd);
std::array<VkDescriptorSet, 2> sets = { p_viewer_data_set->GetSet(frame_index), text.GetSet(frame_index) };
RenderCore::Get().vkCmdBindDescriptorSets(cmd, m_pipeline.GetPipelineBindPoint(), m_pipeline.GetPipelineLayout(), 0, sets.size(), sets.data(), 0, nullptr);
RenderCore::Get().vkCmdPushConstants(cmd, m_pipeline.GetPipelineLayout(), VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(SpriteData), &sprite_data);
text.GetMesh()->Draw(cmd, renderer.GetDrawCallsCounterRef(), renderer.GetPolygonDrawnCounterRef());
}
m_pipeline.EndPipeline(cmd);
}
void Render2DPass::Destroy()
{
RenderCore::Get().WaitDeviceIdle();
m_pipeline.Destroy();
p_vertex_shader.reset();
p_fragment_shader.reset();
p_viewer_data_set.reset();
p_viewer_data_buffer->Destroy();
p_texture_set.reset();
}
}

73
Runtime/Sources/Renderer/RenderPasses/FinalPass.cpp git.filemode.normal_file
View File

@@ -0,0 +1,73 @@
#include <Renderer/RenderPasses/FinalPass.h>
#include <Renderer/Pipelines/Graphics.h>
#include <Renderer/Renderer.h>
#include <Graphics/Scene.h>
#include <Core/EventBus.h>
#include <Core/Engine.h>
namespace Scop
{
void FinalPass::Init()
{
ShaderLayout vertex_shader_layout(
{}, {}
);
p_vertex_shader = LoadShaderFromFile(ScopEngine::Get().GetAssetsPath() / "Shaders/Build/ScreenVertex.spv", ShaderType::Vertex, std::move(vertex_shader_layout));
ShaderLayout fragment_shader_layout(
{
{ 0,
ShaderSetLayout({
{ 0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER }
})
}
}, {}
);
p_fragment_shader = LoadShaderFromFile(ScopEngine::Get().GetAssetsPath() / "Shaders/Build/ScreenFragment.spv", ShaderType::Fragment, std::move(fragment_shader_layout));
std::function<void(const EventBase&)> functor = [this](const EventBase& event)
{
if(event.What() == Event::ResizeEventCode)
m_pipeline.Destroy();
};
EventBus::RegisterListener({ functor, "__ScopFinalPass" });
p_set = RenderCore::Get().GetDescriptorPoolManager().GetAvailablePool().RequestDescriptorSet(p_fragment_shader->GetShaderLayout().set_layouts.at(0), ShaderType::Fragment);
}
void FinalPass::Pass(Scene& scene, Renderer& renderer, Texture& render_target)
{
if(m_pipeline.GetPipeline() == VK_NULL_HANDLE)
{
GraphicPipelineDescriptor pipeline_descriptor;
pipeline_descriptor.vertex_shader = p_vertex_shader;
pipeline_descriptor.fragment_shader = p_fragment_shader;
pipeline_descriptor.renderer = &renderer;
pipeline_descriptor.culling = CullMode::None;
pipeline_descriptor.no_vertex_inputs = true;
pipeline_descriptor.name = "final_pass_pipeline";
m_pipeline.Init(std::move(pipeline_descriptor));
}
VkCommandBuffer cmd = renderer.GetActiveCommandBuffer();
p_set->SetImage(renderer.GetCurrentFrameIndex(), 0, render_target);
p_set->Update(renderer.GetCurrentFrameIndex(), cmd);
m_pipeline.BindPipeline(cmd, renderer.GetSwapchain().GetImageIndex(), { 0.0f, 0.0f, 0.0f, 1.0f });
VkDescriptorSet set = p_set->GetSet(renderer.GetCurrentFrameIndex());
RenderCore::Get().vkCmdBindDescriptorSets(cmd, m_pipeline.GetPipelineBindPoint(), m_pipeline.GetPipelineLayout(), 0, 1, &set, 0, nullptr);
RenderCore::Get().vkCmdDraw(cmd, 3, 1, 0, 0);
renderer.GetDrawCallsCounterRef()++;
renderer.GetPolygonDrawnCounterRef()++;
m_pipeline.EndPipeline(cmd);
}
void FinalPass::Destroy()
{
RenderCore::Get().WaitDeviceIdle();
m_pipeline.Destroy();
p_vertex_shader.reset();
p_fragment_shader.reset();
p_set.reset();
}
}

118
Runtime/Sources/Renderer/RenderPasses/ForwardPass.cpp git.filemode.normal_file
View File

@@ -0,0 +1,118 @@
#include <Renderer/RenderPasses/ForwardPass.h>
#include <Renderer/Pipelines/Graphics.h>
#include <Renderer/ViewerData.h>
#include <Renderer/Renderer.h>
#include <Graphics/Scene.h>
#include <Maths/Mat4.h>
#include <map>
namespace Scop
{
struct ModelData
{
Mat4f model_mat;
Mat4f normal_mat;
};
void ForwardPass::Pass(Scene& scene, Renderer& renderer, class Texture& render_target)
{
NonOwningPtr<GraphicPipeline> pipeline = &scene.GetPipeline();
if(scene.GetPipeline().GetPipeline() == VK_NULL_HANDLE)
{
GraphicPipelineDescriptor pipeline_descriptor;
pipeline_descriptor.vertex_shader = RenderCore::Get().GetDefaultVertexShader();
pipeline_descriptor.fragment_shader = scene.GetFragmentShader();
pipeline_descriptor.color_attachments = { &render_target };
pipeline_descriptor.depth = &scene.GetDepth();
pipeline_descriptor.clear_color_attachments = false;
pipeline_descriptor.name = "forward_pass_pipeline";
scene.GetPipeline().Init(std::move(pipeline_descriptor));
}
auto render_actor = [&render_target, &renderer, &scene, &pipeline](Actor& actor)
{
Scene::ForwardData& data = scene.GetForwardData();
VkCommandBuffer cmd = renderer.GetActiveCommandBuffer();
std::shared_ptr<GraphicPipeline> custom_pipeline = (actor.GetCustomPipeline().has_value() ? actor.GetCustomPipeline()->pipeline : nullptr);
if(custom_pipeline && !custom_pipeline->IsPipelineBound())
{
pipeline->EndPipeline(cmd);
pipeline = actor.GetCustomPipeline()->pipeline.get();
if(pipeline->GetDescription().depth != NonOwningPtr<DepthImage>{ &scene.GetDepth() })
{
GraphicPipelineDescriptor descriptor = pipeline->GetDescription();
descriptor.color_attachments = { &render_target };
descriptor.depth = &scene.GetDepth();
descriptor.renderer = nullptr;
descriptor.clear_color_attachments = false;
pipeline->Init(std::move(descriptor));
}
pipeline->BindPipeline(cmd, 0, {});
}
else if(!custom_pipeline && !scene.GetPipeline().IsPipelineBound())
{
pipeline->EndPipeline(cmd);
pipeline = &scene.GetPipeline();
pipeline->BindPipeline(cmd, 0, {});
}
ModelData model_data;
model_data.model_mat = Mat4f::Identity();
model_data.model_mat.SetTranslation(actor.GetPosition() - actor.GetModel().GetCenter());
model_data.model_mat.SetScale(actor.GetScale());
model_data.model_mat = Mat4f::Translate(-actor.GetModel().GetCenter()) * Mat4f::Rotate(actor.GetOrientation()) * model_data.model_mat;
model_data.normal_mat = model_data.model_mat;
model_data.normal_mat.Inverse().Transpose();
RenderCore::Get().vkCmdPushConstants(cmd, pipeline->GetPipelineLayout(), VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(ModelData), &model_data);
if(custom_pipeline)
{
if(!actor.GetCustomPipeline()->data_uniform_buffer)
{
actor.GetCustomPipeline()->data_uniform_buffer = std::make_shared<UniformBuffer>();
actor.GetCustomPipeline()->data_uniform_buffer->Init(actor.GetCustomPipeline()->data.GetSize(), "custom_data_buffer");
}
else
actor.GetCustomPipeline()->data_uniform_buffer->SetData(actor.GetCustomPipeline()->data, renderer.GetCurrentFrameIndex());
if(!actor.GetCustomPipeline()->set)
{
actor.GetCustomPipeline()->set = RenderCore::Get().GetDescriptorPoolManager().GetAvailablePool().RequestDescriptorSet(custom_pipeline->GetDescription().vertex_shader->GetShaderLayout().set_layouts.at(0), ShaderType::Vertex);
for(std::size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++)
{
actor.GetCustomPipeline()->set->SetUniformBuffer(i, 0, data.matrices_buffer->Get(i));
actor.GetCustomPipeline()->set->SetUniformBuffer(i, 1, actor.GetCustomPipeline()->data_uniform_buffer->Get(i));
actor.GetCustomPipeline()->set->Update(i);
}
}
actor.GetModel().Draw(cmd, actor.GetCustomPipeline()->set, *pipeline, data.albedo_set, renderer.GetDrawCallsCounterRef(), renderer.GetPolygonDrawnCounterRef(), renderer.GetCurrentFrameIndex());
}
else
actor.GetModel().Draw(cmd, data.matrices_set, *pipeline, data.albedo_set, renderer.GetDrawCallsCounterRef(), renderer.GetPolygonDrawnCounterRef(), renderer.GetCurrentFrameIndex());
};
std::multimap<float, Actor&> sorted_actors;
for(auto& [_, actor] : scene.GetActors())
{
if(!actor.IsVisible())
continue;
if(!actor.IsOpaque())
{
float distance = Vec3f::Distance(actor.GetPosition(), scene.GetCamera()->GetPosition());
sorted_actors.emplace(distance, const_cast<Actor&>(actor));
}
else
render_actor(const_cast<Actor&>(actor));
}
for(auto it = sorted_actors.rbegin(); it != sorted_actors.rend(); ++it)
{
if(!it->second.IsVisible())
continue;
render_actor(it->second);
}
if(pipeline)
pipeline->EndPipeline(renderer.GetActiveCommandBuffer());
}
}

62
Runtime/Sources/Renderer/RenderPasses/Passes.cpp git.filemode.normal_file
View File

@@ -0,0 +1,62 @@
#include <Renderer/RenderPasses/Passes.h>
#include <Renderer/Renderer.h>
#include <Graphics/Scene.h>
namespace Scop
{
void RenderPasses::Init()
{
m_skybox.Init();
m_2Dpass.Init();
m_post_process.Init();
m_final.Init();
std::function<void(const EventBase&)> functor = [this](const EventBase& event)
{
if(event.What() == Event::ResizeEventCode)
m_main_render_texture.Destroy();
};
EventBus::RegisterListener({ functor, "__ScopRenderPasses" });
}
void RenderPasses::Pass(Scene& scene, Renderer& renderer)
{
if(!m_main_render_texture.IsInit())
{
auto extent = kvfGetSwapchainImagesSize(renderer.GetSwapchain().Get());
m_main_render_texture.Init({}, extent.width, extent.height, VK_FORMAT_R8G8B8A8_UNORM, false, "scop_main_render_texture", false);
}
scene.GetDepth().Clear(renderer.GetActiveCommandBuffer(), {});
m_main_render_texture.Clear(renderer.GetActiveCommandBuffer(), Vec4f{ 0.0f, 0.0f, 0.0f, 1.0f });
m_main_render_texture.TransitionLayout(VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, renderer.GetActiveCommandBuffer());
if(scene.GetDescription().render_3D_enabled)
m_forward.Pass(scene, renderer, m_main_render_texture);
if(scene.GetDescription().render_skybox_enabled)
m_skybox.Pass(scene, renderer, m_main_render_texture);
if(scene.GetDescription().render_post_process_enabled && scene.GetDescription().post_process_shader)
{
m_post_process.Pass(scene, renderer, m_main_render_texture);
if(scene.GetDescription().render_2D_enabled)
m_2Dpass.Pass(scene, renderer, m_post_process.GetProcessTexture());
m_final.Pass(scene, renderer, m_post_process.GetProcessTexture());
}
else
{
if(scene.GetDescription().render_2D_enabled)
m_2Dpass.Pass(scene, renderer, m_main_render_texture);
m_final.Pass(scene, renderer, m_main_render_texture);
}
}
void RenderPasses::Destroy()
{
RenderCore::Get().WaitDeviceIdle();
m_skybox.Destroy();
m_2Dpass.Destroy();
m_post_process.Destroy();
m_final.Destroy();
m_main_render_texture.Destroy();
}
}

74
Runtime/Sources/Renderer/RenderPasses/PostProcessPass.cpp git.filemode.normal_file
View File

@@ -0,0 +1,74 @@
#include <Renderer/RenderPasses/PostProcessPass.h>
#include <Renderer/Pipelines/Graphics.h>
#include <Renderer/Renderer.h>
#include <Graphics/Scene.h>
#include <Core/EventBus.h>
#include <Core/Engine.h>
namespace Scop
{
void PostProcessPass::Init()
{
ShaderLayout vertex_shader_layout(
{}, {}
);
p_vertex_shader = LoadShaderFromFile(ScopEngine::Get().GetAssetsPath() / "Shaders/Build/ScreenVertex.spv", ShaderType::Vertex, std::move(vertex_shader_layout));
std::function<void(const EventBase&)> functor = [this](const EventBase& event)
{
if(event.What() == Event::ResizeEventCode)
{
m_render_texture.Destroy();
m_pipeline.Destroy();
}
};
EventBus::RegisterListener({ functor, "__ScopPostProcessPass" });
}
void PostProcessPass::Pass(Scene& scene, Renderer& renderer, Texture& render_target)
{
Scene::PostProcessData& data = scene.GetPostProcessData();
if(!m_render_texture.IsInit())
{
auto extent = kvfGetSwapchainImagesSize(renderer.GetSwapchain().Get());
m_render_texture.Init({}, extent.width, extent.height, VK_FORMAT_R8G8B8A8_UNORM, false, "scop_post_process_render_texture", false);
}
if(m_pipeline.GetPipeline() == VK_NULL_HANDLE)
{
GraphicPipelineDescriptor pipeline_descriptor;
pipeline_descriptor.vertex_shader = p_vertex_shader;
pipeline_descriptor.fragment_shader = scene.GetDescription().post_process_shader;
pipeline_descriptor.color_attachments = { &m_render_texture };
pipeline_descriptor.culling = CullMode::None;
pipeline_descriptor.clear_color_attachments = false;
pipeline_descriptor.no_vertex_inputs = true;
pipeline_descriptor.name = "post_process_pass_pipeline";
m_pipeline.Init(std::move(pipeline_descriptor));
}
VkCommandBuffer cmd = renderer.GetActiveCommandBuffer();
data.set->SetImage(renderer.GetCurrentFrameIndex(), 0, render_target);
data.set->SetImage(renderer.GetCurrentFrameIndex(), 1, scene.GetDepth());
data.set->SetUniformBuffer(renderer.GetCurrentFrameIndex(), 2, data.data_buffer->Get(renderer.GetCurrentFrameIndex()));
data.set->Update(renderer.GetCurrentFrameIndex(), cmd);
m_pipeline.BindPipeline(cmd, 0, {});
VkDescriptorSet set = data.set->GetSet(renderer.GetCurrentFrameIndex());
RenderCore::Get().vkCmdBindDescriptorSets(cmd, m_pipeline.GetPipelineBindPoint(), m_pipeline.GetPipelineLayout(), 0, 1, &set, 0, nullptr);
RenderCore::Get().vkCmdDraw(cmd, 3, 1, 0, 0);
renderer.GetDrawCallsCounterRef()++;
renderer.GetPolygonDrawnCounterRef()++;
m_pipeline.EndPipeline(cmd);
}
void PostProcessPass::Destroy()
{
RenderCore::Get().WaitDeviceIdle();
m_render_texture.Destroy();
m_pipeline.Destroy();
p_vertex_shader.reset();
}
}

86
Runtime/Sources/Renderer/RenderPasses/SkyboxPass.cpp git.filemode.normal_file
View File

@@ -0,0 +1,86 @@
#include <Renderer/RenderPasses/SkyboxPass.h>
#include <Renderer/Pipelines/Graphics.h>
#include <Graphics/MeshFactory.h>
#include <Renderer/ViewerData.h>
#include <Renderer/Renderer.h>
#include <Graphics/Scene.h>
#include <Core/EventBus.h>
#include <Core/Engine.h>
namespace Scop
{
void SkyboxPass::Init()
{
ShaderLayout vertex_shader_layout(
{
{ 0,
ShaderSetLayout({
{ 0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER }
})
}
}, {}
);
p_vertex_shader = LoadShaderFromFile(ScopEngine::Get().GetAssetsPath() / "Shaders/Build/SkyboxVertex.spv", ShaderType::Vertex, std::move(vertex_shader_layout));
ShaderLayout fragment_shader_layout(
{
{ 1,
ShaderSetLayout({
{ 0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER }
})
}
}, {}
);
p_fragment_shader = LoadShaderFromFile(ScopEngine::Get().GetAssetsPath() / "Shaders/Build/SkyboxFragment.spv", ShaderType::Fragment, std::move(fragment_shader_layout));
std::function<void(const EventBase&)> functor = [this](const EventBase& event)
{
if(event.What() == Event::ResizeEventCode || event.What() == Event::SceneHasChangedEventCode)
m_pipeline.Destroy();
};
EventBus::RegisterListener({ functor, "__ScopSkyboxPass" });
m_cube = CreateCube();
p_set = RenderCore::Get().GetDescriptorPoolManager().GetAvailablePool().RequestDescriptorSet(p_fragment_shader->GetShaderLayout().set_layouts.at(1), ShaderType::Fragment);
}
void SkyboxPass::Pass(Scene& scene, Renderer& renderer, class Texture& render_target)
{
if(!scene.GetSkybox())
return;
if(m_pipeline.GetPipeline() == VK_NULL_HANDLE)
{
GraphicPipelineDescriptor pipeline_descriptor;
pipeline_descriptor.vertex_shader = p_vertex_shader;
pipeline_descriptor.fragment_shader = p_fragment_shader;
pipeline_descriptor.color_attachments = { &render_target };
pipeline_descriptor.depth = &scene.GetDepth();
pipeline_descriptor.culling = CullMode::None;
pipeline_descriptor.depth_test_equal = true;
pipeline_descriptor.clear_color_attachments = false;
pipeline_descriptor.name = "skybox_pass_pipeline";
m_pipeline.Init(std::move(pipeline_descriptor));
}
VkCommandBuffer cmd = renderer.GetActiveCommandBuffer();
p_set->SetImage(renderer.GetCurrentFrameIndex(), 0, *scene.GetSkybox());
p_set->Update(renderer.GetCurrentFrameIndex(), cmd);
m_pipeline.BindPipeline(cmd, 0, {});
std::array<VkDescriptorSet, 2> sets = { scene.GetForwardData().matrices_set->GetSet(renderer.GetCurrentFrameIndex()), p_set->GetSet(renderer.GetCurrentFrameIndex()) };
RenderCore::Get().vkCmdBindDescriptorSets(cmd, m_pipeline.GetPipelineBindPoint(), m_pipeline.GetPipelineLayout(), 0, sets.size(), sets.data(), 0, nullptr);
m_cube->Draw(cmd, renderer.GetDrawCallsCounterRef(), renderer.GetPolygonDrawnCounterRef());
m_pipeline.EndPipeline(cmd);
}
void SkyboxPass::Destroy()
{
RenderCore::Get().WaitDeviceIdle();
m_pipeline.Destroy();
p_vertex_shader.reset();
p_fragment_shader.reset();
m_cube.reset();
p_set.reset();
}
}