brammie15/Destrum
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: move all caches to RenderResources object

Browse Source
This commit is contained in:
brammie15
2026-06-29 04:08:57 +02:00
parent 3bc8ba02e1
commit aa5c497f29
27 changed files with 1187 additions and 692 deletions
Download Patch File Download Diff File Expand all files Collapse all files
destrum/src/Components/MeshRendererComponent.cpp
+2 -2
View File
@@ -14,7 +14,7 @@ void MeshRendererComponent::Start() {
Component::Start();
if (auto* animator = GetGameObject()->GetComponent<Animator>()) {
const auto& gfxDevice = GameState::GetInstance().Gfx();
const auto& mesh = GameState::GetInstance().Renderer().GetMeshCache().getMesh(meshID);
const auto& mesh = GameState::GetInstance().Renderer().getResources()->meshes().getMesh(meshID);
m_skinnedMesh = std::make_unique<SkinnedMesh>();
m_skinnedMesh->skinnedVertexBuffer = gfxDevice.createBuffer(
@@ -33,7 +33,7 @@ void MeshRendererComponent::Render(const RenderContext& ctx) {
if (meshID == NULL_MESH_ID || materialID == NULL_MATERIAL_ID) return;
if (auto* animator = GetGameObject()->GetComponent<Animator>(); animator && m_skinnedMesh) {
const auto& mesh = ctx.renderer.GetMeshCache().getCPUMesh(meshID);
const auto& mesh = ctx.renderer.getResources()->meshes().getCPUMesh(meshID);
const auto skeleton = GetGameObject()->GetComponent<Animator>()->getSkeleton();
std::uint32_t frameIdx = GameState::GetInstance().Gfx().getCurrentFrameIndex();
destrum/src/Graphics/ImageCache.cpp → destrum/src/Graphics/Caches/ImageCache.cpp
+26 -6
View File
@@ -1,23 +1,43 @@
#include <destrum/Graphics/ImageCache.h>
#include <../../include/destrum/Graphics/Caches/ImageCache.h>
#include <destrum/Graphics/GfxDevice.h>
#include "spdlog/spdlog.h"
ImageCache::ImageCache(GfxDevice& gfxDevice) : gfxDevice(gfxDevice) {
}
ImageID ImageCache::loadImageFromFile(const std::filesystem::path& path, VkImageUsageFlags usage, bool mipMap, TextureIntent intent) {
for (const auto& [id, info]: loadedImagesInfo) {
if (info.path == path && info.intent == intent && info.usage == usage && info.mipMap == mipMap) {
ImageID ImageCache::loadImageFromFile(
const std::filesystem::path& path,
VkImageUsageFlags usage,
bool mipMap,
TextureIntent intent)
{
for (const auto& [id, info] : loadedImagesInfo) {
if (info.path == path &&
info.intent == intent &&
info.usage == usage &&
info.mipMap == mipMap)
{
return id;
}
}
auto image = gfxDevice.loadImageFromFileRaw(path, usage, mipMap, intent);
if (image.isInitialized() && image.getBindlessId() == errorImageId) {
auto imageOpt = gfxDevice.loadImageFromFileRaw(path, usage, mipMap, intent);
if (!imageOpt.has_value()) {
spdlog::warn(
"Using error texture for failed image load: '{}'",
path.string()
);
return errorImageId;
}
auto image = std::move(imageOpt.value());
const auto id = getFreeImageId();
addImage(id, std::move(image));
loadedImagesInfo.emplace(
destrum/src/Graphics/Caches/MaterialCache.cpp
+139
View File
@@ -0,0 +1,139 @@
#include <../../include/destrum/Graphics/Caches/MaterialCache.h>
#include <destrum/Graphics/GfxDevice.h>
#include <destrum/Graphics/Util.h>
#include "spdlog/spdlog.h"
void MaterialCache::init(
GfxDevice& gfxDevice,
MaterialDefaultTextures defaults)
{
defaultTextures = defaults;
materialDataBuffer = gfxDevice.createBuffer(
MAX_MATERIALS * sizeof(MaterialData),
VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT);
vkutil::addDebugLabel(
gfxDevice.getDevice(),
materialDataBuffer.buffer,
"material data");
Material placeholderMaterial{};
placeholderMaterial.name = "PLACEHOLDER_MATERIAL";
placeholderMaterial.diffuseTexture = defaultTextures.white;
placeholderMaterialId = addMaterial(placeholderMaterial);
}
void MaterialCache::cleanup(GfxDevice& gfxDevice)
{
gfxDevice.destroyBuffer(materialDataBuffer);
}
MaterialID MaterialCache::addMaterial(Material material)
{
const auto getTextureOrElse = [](ImageID imageId, ImageID placeholder)
{
return imageId != NULL_IMAGE_ID ? imageId : placeholder;
};
MaterialData* data = static_cast<MaterialData*>(materialDataBuffer.info.pMappedData);
const auto id = getFreeMaterialId();
assert(id < MAX_MATERIALS);
data[id] = MaterialData{
.baseColor = glm::vec4(material.baseColor, 1.0f),
.metalRoughnessEmissive = glm::vec4{
material.metallicFactor,
material.roughnessFactor,
material.emissiveFactor,
0.f
},
.textureFilteringMode = static_cast<std::uint32_t>(material.textureFilteringMode),
.diffuseTex = getTextureOrElse(
material.diffuseTexture,
defaultTextures.white),
.normalTex = defaultTextures.normal,
.metallicRoughnessTex = defaultTextures.metallicRoughness,
.emissiveTex = defaultTextures.emissive,
};
materials.push_back(std::move(material));
return id;
}
MaterialID MaterialCache::addSimpleTextureMaterial(ImageID textureID)
{
Material material{};
material.name = "simple texture material";
material.diffuseTexture = textureID;
material.metallicFactor = 0.0f;
material.roughnessFactor = 1.0f;
return addMaterial(material);
}
const Material& MaterialCache::getMaterial(MaterialID id) const
{
return materials.at(id);
}
MaterialID MaterialCache::getFreeMaterialId() const
{
return materials.size();
}
MaterialID MaterialCache::getPlaceholderMaterialId() const
{
assert(placeholderMaterialId != NULL_MATERIAL_ID && "MaterialCache::init not called");
return placeholderMaterialId;
}
Material& MaterialCache::getMaterialMutable(MaterialID id)
{
assert(id < materials.size());
return materials.at(id);
}
void MaterialCache::updateMaterialGPU(MaterialID id)
{
assert(id < materials.size());
assert(materialDataBuffer.info.pMappedData && "materialDataBuffer must be mapped");
const auto getTextureOrElse = [](ImageID imageId, ImageID placeholder)
{
return imageId != NULL_IMAGE_ID ? imageId : placeholder;
};
Material& material = materials[id];
MaterialData* data =
reinterpret_cast<MaterialData*>(materialDataBuffer.info.pMappedData);
data[id] = MaterialData{
.baseColor = glm::vec4(material.baseColor, 1.0f),
.metalRoughnessEmissive = glm::vec4{
material.metallicFactor,
material.roughnessFactor,
material.emissiveFactor,
0.f
},
.textureFilteringMode = static_cast<std::uint32_t>(material.textureFilteringMode),
.diffuseTex = getTextureOrElse(material.diffuseTexture, defaultTextures.white),
.normalTex = defaultTextures.normal,
.metallicRoughnessTex = defaultTextures.metallicRoughness,
.emissiveTex = defaultTextures.emissive,
};
}
destrum/src/Graphics/GfxDevice.cpp
+45 -119
View File
@@ -24,7 +24,7 @@
#include "tracy/Tracy.hpp"
#include "tracy/TracyVulkan.hpp"
GfxDevice::GfxDevice(): imageCache(*this) {
GfxDevice::GfxDevice() {
}
void GfxDevice::init(SDL_Window* window, const std::string& appName, bool vSync) {
@@ -120,7 +120,7 @@ void GfxDevice::init(SDL_Window* window, const std::string& appName, bool vSync)
VkPhysicalDeviceProperties props{};
vkGetPhysicalDeviceProperties(physicalDevice, &props);
imageCache.bindlessSetManager.init(device, props.limits.maxSamplerAnisotropy);
// imageCache.bindlessSetManager.init(device, props.limits.maxSamplerAnisotropy);
swapchain.initSync(device);
@@ -163,34 +163,34 @@ void GfxDevice::init(SDL_Window* window, const std::string& appName, bool vSync)
}
#endif
{ // create white texture
std::uint32_t pixel = 0xFFFFFFFF;
whiteImageId = createImage(
{
.format = VK_FORMAT_R8G8B8A8_UNORM,
.usage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT,
.extent = VkExtent3D{1, 1, 1},
},
"white texture",
&pixel);
}
{ // create error texture (black/magenta checker)
constexpr auto black = 0xFF000000;
constexpr auto magenta = 0xFFFF00FF;
std::array<std::uint32_t, 4> pixels{black, magenta, magenta, black};
errorImageId = createImage(
{
.format = VK_FORMAT_R8G8B8A8_UNORM,
.usage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT |
VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
.extent = VkExtent3D{2, 2, 1},
},
"error texture",
pixels.data());
imageCache.setErrorImageId(errorImageId);
}
// { // create white texture
// std::uint32_t pixel = 0xFFFFFFFF;
// whiteImageId = createImage(
// {
// .format = VK_FORMAT_R8G8B8A8_UNORM,
// .usage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT,
// .extent = VkExtent3D{1, 1, 1},
// },
// "white texture",
// &pixel);
// }
//
// { // create error texture (black/magenta checker)
// constexpr auto black = 0xFF000000;
// constexpr auto magenta = 0xFFFF00FF;
//
// std::array<std::uint32_t, 4> pixels{black, magenta, magenta, black};
// errorImageId = createImage(
// {
// .format = VK_FORMAT_R8G8B8A8_UNORM,
// .usage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT |
// VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
// .extent = VkExtent3D{2, 2, 1},
// },
// "error texture",
// pixels.data());
// imageCache.setErrorImageId(errorImageId);
// }
GameState::GetInstance().SetGfxDevice(this);
}
@@ -359,29 +359,7 @@ void GfxDevice::waitIdle() {
VK_CHECK(vkDeviceWaitIdle(device));
}
BindlessSetManager& GfxDevice::getBindlessSetManager() {
return imageCache.bindlessSetManager;
}
VkDescriptorSetLayout GfxDevice::getBindlessDescSetLayout() const {
return imageCache.bindlessSetManager.getDescSetLayout();
}
const VkDescriptorSet& GfxDevice::getBindlessDescSet() const {
return imageCache.bindlessSetManager.getDescSet();
}
void GfxDevice::bindBindlessDescSet(VkCommandBuffer cmd, VkPipelineLayout layout) const {
vkCmdBindDescriptorSets(
cmd,
VK_PIPELINE_BIND_POINT_GRAPHICS,
layout,
0,
1,
&imageCache.bindlessSetManager.getDescSet(),
0,
nullptr);
}
void GfxDevice::immediateSubmit(ImmediateExecuteFunction&& f) const {
executor.immediateSubmit(std::move(f));
@@ -463,69 +441,6 @@ void GfxDevice::destroyBuffer(const GPUBuffer& buffer) const {
// return image;
// }
ImageID GfxDevice::createImage(
const vkutil::CreateImageInfo& createInfo,
const std::string& debugName,
void* pixelData,
ImageID imageId) {
auto image = createImageRaw(createInfo);
if (!debugName.empty()) {
vkutil::addDebugLabel(device, image.image, debugName.c_str());
image.debugName = debugName;
}
if (pixelData) {
const std::size_t bytes =
std::size_t(image.extent.width) *
std::size_t(image.extent.height) *
std::size_t(image.extent.depth) *
BytesPerTexel(image.format);
uploadImageDataSized(image, pixelData, bytes, 0);
}
if (imageId != NULL_IMAGE_ID) {
return imageCache.addImage(imageId, std::move(image));
} else {
return addImageToCache(std::move(image));
}
}
ImageID GfxDevice::createDrawImage(
VkFormat format,
glm::ivec2 size,
const std::string& debugName,
ImageID imageId) {
assert(size.x > 0 && size.y > 0);
const auto extent = VkExtent3D{
.width = (std::uint32_t)size.x,
.height = (std::uint32_t)size.y,
.depth = 1,
};
VkImageUsageFlags usages{};
usages |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
usages |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
usages |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
usages |= VK_IMAGE_USAGE_SAMPLED_BIT;
const auto createImageInfo = vkutil::CreateImageInfo{
.format = format,
.usage = usages,
.extent = extent,
};
return createImage(createImageInfo, debugName, nullptr, imageId);
}
ImageID GfxDevice::loadImageFromFile(const std::filesystem::path& path, VkImageUsageFlags usage, bool mipMap, TextureIntent intent) {
return imageCache.loadImageFromFile(path, usage, mipMap, intent);
}
const GPUImage& GfxDevice::getImage(ImageID id) const {
return imageCache.getImage(id);
}
ImageID GfxDevice::addImageToCache(GPUImage img) {
return imageCache.addImage(std::move(img));
}
GPUImage GfxDevice::createImageRaw(
const vkutil::CreateImageInfo& createInfo,
@@ -611,12 +526,20 @@ GPUImage GfxDevice::createImageRaw(
return image;
}
GPUImage GfxDevice::loadImageFromFileRaw(const std::filesystem::path& path, VkImageUsageFlags usage, bool mipMap, TextureIntent intent) const {
std::optional<GPUImage> GfxDevice::loadImageFromFileRaw(
const std::filesystem::path& path,
VkImageUsageFlags usage,
bool mipMap,
TextureIntent intent) const
{
const auto data = util::loadImage(path, intent);
if (data.vkFormat == VK_FORMAT_UNDEFINED || data.byteSize == 0 || (data.hdr ? (data.hdrPixels == nullptr) : (data.pixels == nullptr))) {
if (data.vkFormat == VK_FORMAT_UNDEFINED ||
data.byteSize == 0 ||
(data.hdr ? data.hdrPixels == nullptr : data.pixels == nullptr))
{
spdlog::error("Failed to load image '{}'", path.string());
return getImage(errorImageId);
return std::nullopt;
}
auto image = createImageRaw({
@@ -632,7 +555,10 @@ GPUImage GfxDevice::loadImageFromFileRaw(const std::filesystem::path& path, VkIm
.mipMap = mipMap,
});
const void* src = data.hdr ? static_cast<const void*>(data.hdrPixels) : static_cast<const void*>(data.pixels);
const void* src =
data.hdr
? static_cast<const void*>(data.hdrPixels)
: static_cast<const void*>(data.pixels);
uploadImageDataSized(image, src, data.byteSize, 0);
destrum/src/Graphics/MaterialCache.cpp
-117
View File
@@ -1,117 +0,0 @@
#include <destrum/Graphics/MaterialCache.h>
#include <destrum/Graphics/GfxDevice.h>
#include <destrum/Graphics/Util.h>
#include "spdlog/spdlog.h"
void MaterialCache::init(GfxDevice& gfxDevice)
{
materialDataBuffer = gfxDevice.createBuffer(
MAX_MATERIALS * sizeof(MaterialData),
VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT);
vkutil::addDebugLabel(gfxDevice.getDevice(), materialDataBuffer.buffer, "material data");
{ // create default normal map texture
std::uint32_t normal = 0xFFFF8080; // (0.5, 0.5, 1.0, 1.0)
defaultNormalMapTextureID = gfxDevice.createImage(
{
.format = VK_FORMAT_R8G8B8A8_UNORM,
.usage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT,
.extent = VkExtent3D{1, 1, 1},
},
"normal map placeholder texture",
&normal);
}
Material placeholderMaterial{.diffuseTexture = defaultNormalMapTextureID, .name = "PLACEHOLDER_MATERIAL"};
placeholderMaterialId = addMaterial(gfxDevice, placeholderMaterial);
}
void MaterialCache::cleanup(GfxDevice& gfxDevice)
{
gfxDevice.destroyBuffer(materialDataBuffer);
}
MaterialID MaterialCache::addMaterial(GfxDevice& gfxDevice, Material material)
{
const auto getTextureOrElse = [](ImageID imageId, ImageID placeholder) {
spdlog::warn("Using placeholder texture for material given texture ID: {}", imageId);
return imageId != NULL_IMAGE_ID ? imageId : placeholder;
};
// store on GPU
MaterialData* data = static_cast<MaterialData*>(materialDataBuffer.info.pMappedData);
const auto whiteTextureID = gfxDevice.getWhiteTextureID();
const auto id = getFreeMaterialId();
assert(id < MAX_MATERIALS);
data[id] = MaterialData{
.baseColor = glm::vec4(material.baseColor, 1.0f),
.metalRoughnessEmissive = glm::vec4{material.metallicFactor, material.roughnessFactor, material.emissiveFactor, 0.f},
.textureFilteringMode = static_cast<std::uint32_t>(material.textureFilteringMode),
.diffuseTex = getTextureOrElse(material.diffuseTexture, whiteTextureID),
.normalTex = whiteTextureID,
.metallicRoughnessTex = whiteTextureID,
.emissiveTex = whiteTextureID,
};
// store on CPU
materials.push_back(std::move(material));
return id;
}
MaterialID MaterialCache::addSimpleTextureMaterial(GfxDevice& gfxDevice, ImageID textureID) {
Material material{};
material.name = "idk";
material.diffuseTexture = textureID;
material.metallicFactor = 0.0f;
material.roughnessFactor = 1.0f;
return addMaterial(gfxDevice, material);
}
const Material& MaterialCache::getMaterial(MaterialID id) const
{
return materials.at(id);
}
MaterialID MaterialCache::getFreeMaterialId() const
{
return materials.size();
}
MaterialID MaterialCache::getPlaceholderMaterialId() const
{
assert(placeholderMaterialId != NULL_MATERIAL_ID && "MaterialCache::init not called");
return placeholderMaterialId;
}
Material& MaterialCache::getMaterialMutable(MaterialID id) {
assert(id < materials.size());
return materials.at(id);
}
void MaterialCache::updateMaterialGPU(GfxDevice& gfxDevice, MaterialID id)
{
assert(id < materials.size());
assert(materialDataBuffer.info.pMappedData && "materialDataBuffer must be mapped");
const auto getTextureOrElse = [](ImageID imageId, ImageID placeholder) {
return imageId != NULL_IMAGE_ID ? imageId : placeholder;
};
Material& material = materials[id];
MaterialData* data = reinterpret_cast<MaterialData*>(materialDataBuffer.info.pMappedData);
const ImageID whiteTextureID = gfxDevice.getWhiteTextureID();
data[id] = MaterialData{
.baseColor = glm::vec4(material.baseColor, 1.0f),
.metalRoughnessEmissive = glm::vec4(material.metallicFactor, material.roughnessFactor, material.emissiveFactor, 0.f),
.diffuseTex = getTextureOrElse(material.diffuseTexture, whiteTextureID),
.normalTex = whiteTextureID,
.metallicRoughnessTex = whiteTextureID,
.emissiveTex = whiteTextureID,
};
}
destrum/src/Graphics/MeshCache.cpp
+2 -2
View File
@@ -1,4 +1,4 @@
#include <destrum/Graphics/MeshCache.h>
#include <../../include/destrum/Graphics/Caches/MeshCache.h>
#include <destrum/Graphics/Resources/Mesh.h>
#include <destrum/Graphics/GfxDevice.h>
@@ -114,7 +114,7 @@ const CPUMesh& MeshCache::getCPUMesh(MeshID id) const
return cpuMeshes.at(id);
}
void MeshCache::cleanup(const GfxDevice& gfxDevice)
void MeshCache::cleanup(GfxDevice& gfxDevice)
{
for (const auto& mesh : meshes) {
gfxDevice.destroyBuffer(mesh.indexBuffer);
destrum/src/Graphics/Pipelines/MeshPipeline.cpp
+107 -48
View File
@@ -1,21 +1,32 @@
#include <destrum/Graphics/Pipelines/MeshPipeline.h>
#include <destrum/FS/AssetFS.h>
#include "destrum/Graphics/Frustum.h"
#include <array>
#include <cassert>
#include <stdexcept>
#include <destrum/FS/AssetFS.h>
#include <destrum/Graphics/GfxDevice.h>
#include <destrum/Graphics/RenderResources.h>
#include <destrum/Graphics/Caches/MeshCache.h>
#include <destrum/Graphics/Frustum.h>
#include "spdlog/spdlog.h"
MeshPipeline::MeshPipeline(): m_pipelineLayout{nullptr} {
}
MeshPipeline::MeshPipeline() = default;
MeshPipeline::~MeshPipeline() {
}
MeshPipeline::~MeshPipeline() = default;
void MeshPipeline::init(GfxDevice& gfxDevice, VkFormat drawImageFormat, VkFormat depthImageFormat) {
const auto& device = gfxDevice.getDevice();
const auto vertexShader = AssetFS::GetInstance().GetCookedPathForFile("engine://shaders/mesh.vert");
const auto fragShader = AssetFS::GetInstance().GetCookedPathForFile("engine://shaders/mesh.frag");
void MeshPipeline::init(
GfxDevice& gfxDevice,
RenderResources& resources,
VkFormat drawImageFormat,
VkFormat depthImageFormat)
{
const auto vertexShader =
AssetFS::GetInstance().GetCookedPathForFile("engine://shaders/mesh.vert");
const auto fragShader =
AssetFS::GetInstance().GetCookedPathForFile("engine://shaders/mesh.frag");
const auto bufferRange = VkPushConstantRange{
.stageFlags = VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT,
@@ -24,24 +35,31 @@ void MeshPipeline::init(GfxDevice& gfxDevice, VkFormat drawImageFormat, VkFormat
};
const auto pushConstantRanges = std::array{bufferRange};
const auto layouts = std::array{gfxDevice.getBindlessDescSetLayout()};
// m_pipelineLayout = vkutil::createPipelineLayout(device, layouts, pushConstantRanges);
// vkutil::addDebugLabel(device, pipelineLayout, "mesh pipeline layout");
const auto layouts = std::array{
resources.getBindlessDescSetLayout()
};
VkPipelineLayoutCreateInfo pipelineLayoutInfo{};
pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
pipelineLayoutInfo.setLayoutCount = static_cast<uint32_t>(layouts.size());
pipelineLayoutInfo.setLayoutCount = static_cast<std::uint32_t>(layouts.size());
pipelineLayoutInfo.pSetLayouts = layouts.data();
pipelineLayoutInfo.pushConstantRangeCount = 1;
pipelineLayoutInfo.pushConstantRangeCount =
static_cast<std::uint32_t>(pushConstantRanges.size());
pipelineLayoutInfo.pPushConstantRanges = pushConstantRanges.data();
if (vkCreatePipelineLayout(gfxDevice.getDevice().device, &pipelineLayoutInfo, nullptr, &m_pipelineLayout) != VK_SUCCESS) {
throw std::runtime_error("Could not make pipleine layout");
if (vkCreatePipelineLayout(
gfxDevice.getDevice().device,
&pipelineLayoutInfo,
nullptr,
&m_pipelineLayout) != VK_SUCCESS)
{
throw std::runtime_error("Could not create mesh pipeline layout");
}
PipelineConfigInfo pipelineConfig{};
Pipeline::DefaultPipelineConfigInfo(pipelineConfig);
pipelineConfig.name = "Mesh Pipeline";
pipelineConfig.pipelineLayout = m_pipelineLayout;
@@ -59,78 +77,119 @@ void MeshPipeline::init(GfxDevice& gfxDevice, VkFormat drawImageFormat, VkFormat
);
}
void MeshPipeline::draw(VkCommandBuffer cmd,
VkExtent2D renderExtent,
const GfxDevice& gfxDevice,
const MeshCache& meshCache,
const MaterialCache& materialCache,
const Camera& camera,
const GPUBuffer& sceneDataBuffer,
const std::vector<MeshDrawCommand>& drawCommands,
const std::vector<std::size_t>& sortedDrawCommands) {
m_pipeline->bind(cmd);
gfxDevice.bindBindlessDescSet(cmd, m_pipelineLayout);
void MeshPipeline::draw(
VkCommandBuffer cmd,
VkExtent2D renderExtent,
const RenderResources& resources,
const Camera& camera,
const GPUBuffer& sceneDataBuffer,
const std::vector<MeshDrawCommand>& drawCommands,
const std::vector<std::size_t>& sortedDrawCommands)
{
if (!m_pipeline) {
return;
}
int ActualDrawCalls = 0;
const MeshCache& meshCache = resources.meshes();
m_pipeline->bind(cmd);
resources.bindBindlessDescSet(cmd, m_pipelineLayout);
const auto viewport = VkViewport{
.x = 0,
.y = 0,
.width = (float)renderExtent.width,
.height = (float)renderExtent.height,
.x = 0.f,
.y = 0.f,
.width = static_cast<float>(renderExtent.width),
.height = static_cast<float>(renderExtent.height),
.minDepth = 0.f,
.maxDepth = 1.f,
};
vkCmdSetViewport(cmd, 0, 1, &viewport);
const auto scissor = VkRect2D{
.offset = {},
.extent = renderExtent,
};
vkCmdSetScissor(cmd, 0, 1, &scissor);
vkCmdSetPolygonModeEXT(cmd, m_renderWireframe ? VK_POLYGON_MODE_LINE : VK_POLYGON_MODE_FILL);
vkCmdSetPolygonModeEXT(
cmd,
m_renderWireframe ? VK_POLYGON_MODE_LINE : VK_POLYGON_MODE_FILL
);
auto prevMeshId = NULL_MESH_ID;
MeshID prevMeshId = NULL_MESH_ID;
int actualDrawCalls = 0;
const auto frustum = edge::createFrustumFromCamera(camera);
for (const auto& dcIdx : drawCommands) {
const auto& dc = dcIdx;
const auto drawOne = [&](const MeshDrawCommand& dc) {
if (!edge::isInFrustum(frustum, dc.worldBoundingSphere)) {
continue;
return;
}
ActualDrawCalls++;
++actualDrawCalls;
const auto& mesh = meshCache.getMesh(dc.meshId);
if (dc.meshId != prevMeshId) {
prevMeshId = dc.meshId;
vkCmdBindIndexBuffer(cmd, mesh.indexBuffer.buffer, 0, VK_INDEX_TYPE_UINT32);
vkCmdBindIndexBuffer(
cmd,
mesh.indexBuffer.buffer,
0,
VK_INDEX_TYPE_UINT32
);
}
assert(dc.materialId != NULL_MATERIAL_ID);
const auto pushConstants = PushConstants{
.transform = dc.transformMatrix,
.sceneDataBuffer = sceneDataBuffer.address,
.vertexBuffer = dc.skinnedMesh != nullptr ? dc.skinnedMesh->skinnedVertexBuffer.address : mesh.vertexBuffer.address,
.vertexBuffer =
dc.skinnedMesh != nullptr
? dc.skinnedMesh->skinnedVertexBuffer.address
: mesh.vertexBuffer.address,
.materialId = dc.materialId,
.padding = 0,
};
vkCmdPushConstants(
cmd,
m_pipelineLayout,
VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT,
0,
sizeof(PushConstants),
&pushConstants);
&pushConstants
);
vkCmdDrawIndexed(cmd, mesh.numIndices, 1, 0, 0, 0);
};
if (!sortedDrawCommands.empty()) {
for (std::size_t drawIndex : sortedDrawCommands) {
assert(drawIndex < drawCommands.size());
drawOne(drawCommands[drawIndex]);
}
} else {
for (const MeshDrawCommand& dc : drawCommands) {
drawOne(dc);
}
}
// Optional:
// spdlog::debug("Actual mesh draw calls: {}", actualDrawCalls);
}
void MeshPipeline::cleanup(VkDevice device) {
vkDestroyPipelineLayout(device, m_pipelineLayout, nullptr);
void MeshPipeline::cleanup(VkDevice device)
{
m_pipeline.reset();
}
if (m_pipelineLayout != VK_NULL_HANDLE) {
vkDestroyPipelineLayout(device, m_pipelineLayout, nullptr);
m_pipelineLayout = VK_NULL_HANDLE;
}
}
destrum/src/Graphics/Pipelines/SkinningPipeline.cpp
+1 -1
View File
@@ -1,7 +1,7 @@
#include <destrum/Graphics/Pipelines/SkinningPipeline.h>
#include "destrum/FS/AssetFS.h"
#include "destrum/Graphics/MeshCache.h"
#include "../../../include/destrum/Graphics/Caches/MeshCache.h"
#include "destrum/Graphics/MeshDrawCommand.h"
#include <array>
destrum/src/Graphics/Pipelines/SkyboxPipeline.cpp
+63 -25
View File
@@ -13,49 +13,63 @@ SkyboxPipeline::SkyboxPipeline(): pipelineLayout{nullptr} {
SkyboxPipeline::~SkyboxPipeline() {
}
void SkyboxPipeline::init(GfxDevice& gfxDevice, VkFormat drawImageFormat, VkFormat depthImageFormat) {
void SkyboxPipeline::init(
GfxDevice& gfxDevice,
RenderResources& resources,
VkFormat drawImageFormat,
VkFormat depthImageFormat)
{
const auto vertexShader =
AssetFS::GetInstance().GetCookedPathForFile("engine://shaders/fullscreen_triangle.vert");
const auto vertexShader = AssetFS::GetInstance().GetCookedPathForFile("engine://shaders/fullscreen_triangle.vert");
const auto fragShader = AssetFS::GetInstance().GetCookedPathForFile("engine://shaders/skybox.frag");
const auto fragShader =
AssetFS::GetInstance().GetCookedPathForFile("engine://shaders/skybox.frag");
constexpr auto bufferRange = VkPushConstantRange{
.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT,
.offset = 0,
.size = sizeof(SkyboxPushConstants),
};
constexpr auto pushConstantRanges = std::array{bufferRange};
const auto layouts = std::array{gfxDevice.getBindlessDescSetLayout()};
const auto layouts = std::array{
resources.getBindlessDescSetLayout()
};
VkPipelineLayoutCreateInfo pipelineLayoutInfo{};
pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
pipelineLayoutInfo.setLayoutCount = static_cast<uint32_t>(layouts.size());
pipelineLayoutInfo.pSetLayouts = layouts.data();
pipelineLayoutInfo.pushConstantRangeCount = static_cast<uint32_t>(pushConstantRanges.size());
pipelineLayoutInfo.pPushConstantRanges = pushConstantRanges.data();
if (vkCreatePipelineLayout(gfxDevice.getDevice().device, &pipelineLayoutInfo, nullptr, &pipelineLayout) != VK_SUCCESS) {
throw std::runtime_error("Could not make pipleine layout");
if (vkCreatePipelineLayout(
gfxDevice.getDevice().device,
&pipelineLayoutInfo,
nullptr,
&pipelineLayout) != VK_SUCCESS)
{
throw std::runtime_error("Could not make skybox pipeline layout");
}
PipelineConfigInfo pipelineConfig{};
Pipeline::DefaultPipelineConfigInfo(pipelineConfig);
pipelineConfig.name = "skybox pipeline";
pipelineConfig.pipelineLayout = pipelineLayout;
pipelineConfig.vertexAttributeDescriptions = {};
pipelineConfig.vertexBindingDescriptions = {};
pipelineConfig.vertexBindingDescriptions = {};
pipelineConfig.colorAttachments = { drawImageFormat };
pipelineConfig.depthAttachment = depthImageFormat;
pipelineConfig.depthAttachment = depthImageFormat;
pipelineConfig.rasterizationInfo.cullMode = VK_CULL_MODE_NONE;
pipelineConfig.depthStencilInfo.depthTestEnable = VK_TRUE;
pipelineConfig.depthStencilInfo.depthTestEnable = VK_TRUE;
pipelineConfig.depthStencilInfo.depthWriteEnable = VK_FALSE;
pipelineConfig.depthStencilInfo.depthCompareOp = VK_COMPARE_OP_LESS_OR_EQUAL;
pipelineConfig.rasterizationInfo.cullMode = VK_CULL_MODE_NONE;
pipelineConfig.depthStencilInfo.depthCompareOp = VK_COMPARE_OP_LESS_OR_EQUAL;
pipeline = std::make_unique<Pipeline>(
gfxDevice,
@@ -65,34 +79,58 @@ void SkyboxPipeline::init(GfxDevice& gfxDevice, VkFormat drawImageFormat, VkForm
);
}
void SkyboxPipeline::cleanup(VkDevice device) {
void SkyboxPipeline::cleanup(VkDevice device)
{
pipeline.reset();
vkDestroyPipelineLayout(device, pipelineLayout, nullptr);
if (pipelineLayout != VK_NULL_HANDLE) {
vkDestroyPipelineLayout(device, pipelineLayout, nullptr);
pipelineLayout = VK_NULL_HANDLE;
}
}
void SkyboxPipeline::draw(VkCommandBuffer cmd, GfxDevice& gfxDevice, const Camera& camera) {
void SkyboxPipeline::draw(
VkCommandBuffer cmd,
RenderResources& resources,
const Camera& camera)
{
if (skyboxTextureId == NULL_IMAGE_ID) {
return;
}
//rotate skybox slowly for visual interest
const float rotationSpeed = 0.01f; // radians per second
//Rotate over the Y axis
skyboxRotation = glm::rotate(skyboxRotation, rotationSpeed * static_cast<float>(Time::GetInstance().DeltaTime()), glm::vec3(0.f, 1.f, 0.f));
const float rotationSpeed = 0.01f;
skyboxRotation = glm::rotate(
skyboxRotation,
rotationSpeed * static_cast<float>(Time::GetInstance().DeltaTime()),
glm::vec3(0.f, 1.f, 0.f));
pipeline->bind(cmd);
vkCmdSetPolygonModeEXT(cmd, VK_POLYGON_MODE_FILL);
gfxDevice.bindBindlessDescSet(cmd, pipelineLayout);
resources.bindBindlessDescSet(cmd, pipelineLayout);
const glm::mat3 r = glm::mat3(skyboxRotation);
const auto pcs = SkyboxPushConstants{
.invViewProj = glm::inverse(camera.GetViewProjectionMatrix()),
.skyboxRot = { glm::vec4(r[0], 0.f), glm::vec4(r[1], 0.f), glm::vec4(r[2], 0.f) },
.cameraPos = camera.GetPosition(),
.invViewProj = glm::inverse(camera.GetViewProjectionMatrix()),
.skyboxRot = {
glm::vec4(r[0], 0.f),
glm::vec4(r[1], 0.f),
glm::vec4(r[2], 0.f)
},
.cameraPos = camera.GetPosition(),
.skyboxTextureId = static_cast<std::uint32_t>(skyboxTextureId),
};
vkCmdPushConstants(cmd, pipelineLayout, VK_SHADER_STAGE_FRAGMENT_BIT, 0, sizeof(SkyboxPushConstants), &pcs);
vkCmdPushConstants(
cmd,
pipelineLayout,
VK_SHADER_STAGE_FRAGMENT_BIT,
0,
sizeof(SkyboxPushConstants),
&pcs);
vkCmdDraw(cmd, 3, 1, 0, 0);
}
destrum/src/Graphics/RenderResources.cpp
+211
View File
@@ -0,0 +1,211 @@
#include <destrum/Graphics/RenderResources.h>
#include <destrum/Graphics/GfxDevice.h>
#include <destrum/Graphics/Util.h>
#include "spdlog/spdlog.h"
RenderResources::RenderResources() = default;
void RenderResources::init(GfxDevice& gfxDevice)
{
imageCache = std::make_unique<ImageCache>(gfxDevice);
meshCache = std::make_unique<MeshCache>();
materialCache = std::make_unique<MaterialCache>();
VkPhysicalDeviceProperties props{};
vkGetPhysicalDeviceProperties(gfxDevice.getVkPhysicalDevice(), &props);
imageCache->bindlessSetManager.init(
gfxDevice.getVkDevice(),
props.limits.maxSamplerAnisotropy);
{
std::uint32_t white = 0xFFFFFFFF;
whiteImageId = createImage(
gfxDevice,
{
.format = VK_FORMAT_R8G8B8A8_UNORM,
.usage = VK_IMAGE_USAGE_SAMPLED_BIT |
VK_IMAGE_USAGE_TRANSFER_DST_BIT,
.extent = VkExtent3D{1, 1, 1},
},
"white texture",
&white);
}
{
std::uint32_t normal = 0xFFFF8080; // tangent-space normal: 0.5, 0.5, 1.0, 1.0
defaultNormalImageId = createImage(
gfxDevice,
{
.format = VK_FORMAT_R8G8B8A8_UNORM,
.usage = VK_IMAGE_USAGE_SAMPLED_BIT |
VK_IMAGE_USAGE_TRANSFER_DST_BIT,
.extent = VkExtent3D{1, 1, 1},
},
"default normal texture",
&normal);
}
{
constexpr auto black = 0xFF000000;
constexpr auto magenta = 0xFFFF00FF;
std::array<std::uint32_t, 4> pixels{
black, magenta,
magenta, black
};
errorImageId = createImage(
gfxDevice,
{
.format = VK_FORMAT_R8G8B8A8_UNORM,
.usage = VK_IMAGE_USAGE_SAMPLED_BIT |
VK_IMAGE_USAGE_TRANSFER_DST_BIT |
VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
.extent = VkExtent3D{2, 2, 1},
},
"error texture",
pixels.data());
imageCache->setErrorImageId(errorImageId);
}
materialCache->init(
gfxDevice,
MaterialDefaultTextures{
.white = whiteImageId,
.normal = defaultNormalImageId,
.metallicRoughness = whiteImageId,
.emissive = whiteImageId,
});
}
ImageID RenderResources::createImage(
GfxDevice& gfxDevice,
const vkutil::CreateImageInfo& createInfo,
const std::string& debugName,
void* pixelData,
ImageID imageId)
{
auto image = gfxDevice.createImageRaw(createInfo);
if (!debugName.empty()) {
vkutil::addDebugLabel(gfxDevice.getVkDevice(), image.image, debugName.c_str());
image.debugName = debugName;
}
if (pixelData) {
const std::size_t bytes =
std::size_t(image.extent.width) *
std::size_t(image.extent.height) *
std::size_t(image.extent.depth) *
BytesPerTexel(image.format);
gfxDevice.uploadImageDataSized(image, pixelData, bytes, 0);
}
if (imageId != NULL_IMAGE_ID) {
return imageCache->addImage(imageId, std::move(image));
}
return addImageToCache(std::move(image));
}
ImageID RenderResources::createDrawImage(
GfxDevice& gfxDevice,
VkFormat format,
glm::ivec2 size,
const std::string& debugName,
ImageID imageId)
{
assert(size.x > 0 && size.y > 0);
const auto extent = VkExtent3D{
.width = static_cast<std::uint32_t>(size.x),
.height = static_cast<std::uint32_t>(size.y),
.depth = 1,
};
VkImageUsageFlags usages{};
usages |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
usages |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
usages |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
usages |= VK_IMAGE_USAGE_SAMPLED_BIT;
const auto createImageInfo = vkutil::CreateImageInfo{
.format = format,
.usage = usages,
.extent = extent,
};
return createImage(gfxDevice, createImageInfo, debugName, nullptr, imageId);
}
ImageID RenderResources::loadImageFromFile(
GfxDevice& gfxDevice,
const std::filesystem::path& path,
VkImageUsageFlags usage,
bool mipMap,
TextureIntent intent)
{
return imageCache->loadImageFromFile(path, usage, mipMap, intent);
}
const GPUImage& RenderResources::getImage(ImageID id) const {
return imageCache->getImage(id);
}
ImageID RenderResources::addImageToCache(GPUImage image) {
return imageCache->addImage(std::move(image));
}
BindlessSetManager& RenderResources::getBindlessSetManager() {
return imageCache->bindlessSetManager;
}
VkDescriptorSetLayout RenderResources::getBindlessDescSetLayout() const {
return imageCache->bindlessSetManager.getDescSetLayout();
}
const VkDescriptorSet& RenderResources::getBindlessDescSet() const {
return imageCache->bindlessSetManager.getDescSet();
}
void RenderResources::bindBindlessDescSet(VkCommandBuffer cmd, VkPipelineLayout layout) const {
vkCmdBindDescriptorSets(
cmd,
VK_PIPELINE_BIND_POINT_GRAPHICS,
layout,
0,
1,
&imageCache->bindlessSetManager.getDescSet(),
0,
nullptr
);
}
std::uint32_t RenderResources::BytesPerTexel(VkFormat fmt)
{
switch (fmt) {
case VK_FORMAT_R8_UNORM:
return 1;
case VK_FORMAT_R8G8B8A8_UNORM:
case VK_FORMAT_R8G8B8A8_SRGB:
case VK_FORMAT_B8G8R8A8_SRGB:
return 4;
case VK_FORMAT_R16G16B16A16_SFLOAT:
return 8;
case VK_FORMAT_R32G32B32A32_SFLOAT:
return 16;
default:
throw std::runtime_error("RenderResources::BytesPerTexel: unsupported format");
}
}
destrum/src/Graphics/Renderer.cpp
+74 -57
View File
@@ -7,10 +7,13 @@
#include "tracy/TracyVulkan.hpp"
GameRenderer::GameRenderer(MeshCache& meshCache, MaterialCache& matCache): meshCache{meshCache}, materialCache{matCache} {
GameRenderer::GameRenderer()
{
}
void GameRenderer::init(GfxDevice& gfxDevice, const glm::ivec2& drawImageSize) {
void GameRenderer::init(GfxDevice& gfxDevice, RenderResources& _resources, glm::ivec2 drawImageSize)
{
resources = &_resources;
sceneDataBuffer.init(
gfxDevice,
VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
@@ -20,10 +23,10 @@ void GameRenderer::init(GfxDevice& gfxDevice, const glm::ivec2& drawImageSize) {
createDrawImage(gfxDevice, drawImageSize, true);
meshPipeline = std::make_unique<MeshPipeline>();
meshPipeline->init(gfxDevice, drawImageFormat, depthImageFormat);
meshPipeline->init(gfxDevice, _resources, drawImageFormat, depthImageFormat);
skyboxPipeline = std::make_unique<SkyboxPipeline>();
skyboxPipeline->init(gfxDevice, drawImageFormat, depthImageFormat);
skyboxPipeline->init(gfxDevice, _resources, drawImageFormat, depthImageFormat);
skinningPipeline = std::make_unique<SkinningPipeline>();
skinningPipeline->init(gfxDevice);
@@ -32,28 +35,33 @@ void GameRenderer::init(GfxDevice& gfxDevice, const glm::ivec2& drawImageSize) {
GameState::GetInstance().SetRenderer(this);
}
void GameRenderer::beginDrawing(GfxDevice& gfxDevice) {
void GameRenderer::beginDrawing(GfxDevice& gfxDevice)
{
flushMaterialUpdates(gfxDevice);
meshDrawCommands.clear();
skinningPipeline->beginDrawing(gfxDevice.getCurrentFrameIndex());
}
void GameRenderer::endDrawing() {
void GameRenderer::endDrawing()
{
//Sort the drawlist
}
void GameRenderer::draw(VkCommandBuffer cmd, GfxDevice& gfxDevice, const Camera& camera, const SceneData& sceneData) {
void GameRenderer::draw(VkCommandBuffer cmd, GfxDevice& gfxDevice, const Camera& camera, const SceneData& sceneData)
{
ZoneScopedN("GameRenderer::draw");
TracyVkZone(gfxDevice.getTracyVkCtx(), cmd, "GameRenderer::draw");
{
TracyVkZone(gfxDevice.getTracyVkCtx(), cmd, "Skinning");
for (const auto& dc : meshDrawCommands) {
if (!dc.skinnedMesh) {
for (const auto& dc : meshDrawCommands)
{
if (!dc.skinnedMesh)
{
continue;
}
skinningPipeline->doSkinning(cmd, gfxDevice.getCurrentFrameIndex(), meshCache, dc);
skinningPipeline->doSkinning(cmd, gfxDevice.getCurrentFrameIndex(), resources->meshes(), dc);
}
}
@@ -66,7 +74,7 @@ void GameRenderer::draw(VkCommandBuffer cmd, GfxDevice& gfxDevice, const Camera&
.ambientIntensity = sceneData.ambientIntensity,
.fogColor = {sceneData.fogColor},
.fogDensity = sceneData.fogDensity,
.materialsBuffer = materialCache.getMaterialDataBufferAddress(),
.materialsBuffer = resources->materials().getMaterialDataBufferAddress(),
};
{
@@ -74,7 +82,7 @@ void GameRenderer::draw(VkCommandBuffer cmd, GfxDevice& gfxDevice, const Camera&
vkutil::bufferHostWriteToShaderReadBarrier(
cmd,
materialCache.getMaterialDataBuffer().buffer,
resources->materials().getMaterialDataBuffer().buffer,
0,
VK_WHOLE_SIZE
);
@@ -91,10 +99,9 @@ void GameRenderer::draw(VkCommandBuffer cmd, GfxDevice& gfxDevice, const Camera&
);
}
const auto& drawImage = gfxDevice.getImage(drawImageId);
const auto& depthImage = gfxDevice.getImage(depthImageId);
const auto& drawImage = resources->getImage(drawImageId);
const auto& depthImage = resources->getImage(depthImageId);
// vkutil::cmdBeginLabel(cmd, "Geometry");
{
TracyVkZone(gfxDevice.getTracyVkCtx(), cmd, "Transition Draw Image");
@@ -135,9 +142,7 @@ void GameRenderer::draw(VkCommandBuffer cmd, GfxDevice& gfxDevice, const Camera&
meshPipeline->draw(
cmd,
drawImage.getExtent2D(),
gfxDevice,
meshCache,
materialCache,
*resources,
camera,
sceneDataBuffer.getBuffer(),
meshDrawCommands,
@@ -147,7 +152,7 @@ void GameRenderer::draw(VkCommandBuffer cmd, GfxDevice& gfxDevice, const Camera&
{
TracyVkZone(gfxDevice.getTracyVkCtx(), cmd, "SkyboxPipeline::draw");
skyboxPipeline->draw(cmd, gfxDevice, camera);
skyboxPipeline->draw(cmd, *resources, camera);
}
{
@@ -158,7 +163,8 @@ void GameRenderer::draw(VkCommandBuffer cmd, GfxDevice& gfxDevice, const Camera&
// vkutil::cmdEndLabel(cmd);
}
void GameRenderer::cleanup(GfxDevice& gfxDevice) {
void GameRenderer::cleanup(GfxDevice& gfxDevice)
{
VkDevice device = gfxDevice.getDevice().device;
vkDeviceWaitIdle(device);
@@ -175,17 +181,18 @@ void GameRenderer::cleanup(GfxDevice& gfxDevice) {
sceneDataBuffer.cleanup(gfxDevice);
// if (drawImageId != NULL_IMAGE_ID)
// gfxDevice.destroyImage();
// gfxDevice.destroyImage();
// if (depthImageId != NULL_IMAGE_ID)
// gfxDevice.destroyImage(depthImageId);
// gfxDevice.destroyImage(depthImageId);
drawImageId = NULL_IMAGE_ID;
depthImageId = NULL_IMAGE_ID;
}
void GameRenderer::drawMesh(MeshID id, const glm::mat4& transform, MaterialID materialId) {
const auto& mesh = meshCache.getMesh(id);
void GameRenderer::drawMesh(MeshID id, const glm::mat4& transform, MaterialID materialId)
{
const auto& mesh = resources->meshes().getMesh(id);
const auto worldBoundingSphere = edge::calculateBoundingSphereWorld(transform, mesh.boundingSphere, false);
assert(materialId != NULL_MATERIAL_ID);
@@ -197,46 +204,54 @@ void GameRenderer::drawMesh(MeshID id, const glm::mat4& transform, MaterialID ma
}
void GameRenderer::drawSkinnedMesh(MeshID id,
const glm::mat4& transform,
MaterialID materialId,
SkinnedMesh* skinnedMesh,
std::size_t jointMatricesStartIndex) {
const auto& mesh = meshCache.getMesh(id);
const auto worldBoundingSphere = edge::calculateBoundingSphereWorld(transform, mesh.boundingSphere, false);
const glm::mat4& transform,
MaterialID materialId,
SkinnedMesh* skinnedMesh,
std::size_t jointMatricesStartIndex)
{
const auto& mesh = resources->meshes().getMesh(id);
const auto worldBoundingSphere = edge::calculateBoundingSphereWorld(transform, mesh.boundingSphere, false);
assert(materialId != NULL_MATERIAL_ID);
assert(skinnedMesh != nullptr);
meshDrawCommands.push_back(MeshDrawCommand{
.meshId = id,
.transformMatrix = transform,
.materialId = materialId,
.skinnedMesh = skinnedMesh,
.meshId = id,
.transformMatrix = transform,
.materialId = materialId,
.skinnedMesh = skinnedMesh,
.jointMatricesStartIndex = static_cast<std::uint32_t>(jointMatricesStartIndex),
});
}
const GPUImage& GameRenderer::getDrawImage(const GfxDevice& gfx_device) const {
return gfx_device.getImage(drawImageId);
const GPUImage& GameRenderer::getDrawImage() const
{
assert(resources);
return resources->getImage(drawImageId);
}
Material& GameRenderer::getMaterialMutable(MaterialID id) {
Material& GameRenderer::getMaterialMutable(MaterialID id)
{
assert(id != NULL_MATERIAL_ID);
return materialCache.getMaterialMutable(id);
return resources->materials().getMaterialMutable(id);
}
void GameRenderer::updateMaterialGPU(MaterialID id) {
void GameRenderer::updateMaterialGPU(MaterialID id)
{
assert(id != NULL_MATERIAL_ID);
pendingMaterialUploads.push_back(id);
}
void GameRenderer::setSkyboxTexture(ImageID skyboxImageId) {
void GameRenderer::setSkyboxTexture(ImageID skyboxImageId)
{
spdlog::debug("Set skybox texture to image id {}", skyboxImageId);
skyboxPipeline->setSkyboxImage(skyboxImageId);
}
void GameRenderer::flushMaterialUpdates(GfxDevice& gfxDevice) {
for (MaterialID id : pendingMaterialUploads) {
materialCache.updateMaterialGPU(gfxDevice, id);
void GameRenderer::flushMaterialUpdates(GfxDevice& gfxDevice)
{
for (MaterialID id : pendingMaterialUploads)
{
resources->materials().updateMaterialGPU(id);
// if non-coherent: flush mapped range for that id here
}
pendingMaterialUploads.clear();
@@ -247,14 +262,15 @@ void GameRenderer::createDrawImage(GfxDevice& gfxDevice,
bool firstCreate)
{
const VkExtent3D drawImageExtent{
.width = (std::uint32_t)drawImageSize.x,
.width = (std::uint32_t)drawImageSize.x,
.height = (std::uint32_t)drawImageSize.y,
.depth = 1,
.depth = 1,
};
constexpr VkSampleCountFlagBits noMsaa = VK_SAMPLE_COUNT_1_BIT;
{ // setup draw image (single-sampled)
{
// setup draw image (single-sampled)
VkImageUsageFlags usages{};
usages |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
usages |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
@@ -262,32 +278,33 @@ void GameRenderer::createDrawImage(GfxDevice& gfxDevice,
usages |= VK_IMAGE_USAGE_SAMPLED_BIT;
auto createImageInfo = vkutil::CreateImageInfo{
.format = drawImageFormat,
.usage = usages,
.extent = drawImageExtent,
.format = drawImageFormat,
.usage = usages,
.extent = drawImageExtent,
.samples = noMsaa,
};
// reuse the same id if creating again
drawImageId = gfxDevice.createImage(createImageInfo, "draw image", nullptr, drawImageId);
drawImageId = resources->createImage(gfxDevice, createImageInfo, "draw image", nullptr, drawImageId);
if (firstCreate) {
if (firstCreate)
{
// Optional: a separate post-fx target (ping-pong)
// postFXDrawImageId = gfxDevice.createImage(createImageInfo, "post FX draw image");
}
}
{ // setup depth image (single-sampled)
{
// setup depth image (single-sampled)
auto createInfo = vkutil::CreateImageInfo{
.format = depthImageFormat,
.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT,
.extent = drawImageExtent,
.format = depthImageFormat,
.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT,
.extent = drawImageExtent,
.samples = noMsaa,
};
depthImageId = gfxDevice.createImage(createInfo, "depth image", nullptr, depthImageId);
depthImageId = resources->createImage(gfxDevice, createInfo, "depth image", nullptr, depthImageId);
spdlog::info("Created depth image with id {}", depthImageId);
}
}
destrum/src/Graphics/Resources/Cubemap.cpp
+138 -115
View File
@@ -1,54 +1,76 @@
#include <destrum/Graphics/Resources/Cubemap.h>
#include "destrum/FS/AssetFS.h"
#include "destrum/Graphics/GfxDevice.h"
#include "destrum/Graphics/Pipeline.h"
#include "destrum/Util/GameState.h"
#include <destrum/Graphics/GfxDevice.h>
#include <destrum/Graphics/RenderResources.h>
#include <destrum/Graphics/Pipeline.h>
#include <destrum/Graphics/Util.h>
#include "glm/ext/matrix_clip_space.hpp"
#include <glm/ext/matrix_clip_space.hpp>
#include <cmath>
#include <stdexcept>
#include <utility>
#include "spdlog/spdlog.h"
CubeMap::CubeMap() {
m_projection = glm::perspective(glm::radians(90.0f), 1.0f, 0.1f, 10.0f);;
CubeMap::CubeMap()
{
m_projection = glm::perspective(
glm::radians(90.0f),
1.0f,
0.1f,
10.0f
);
}
CubeMap::~CubeMap() {
auto& gfx = GameState::GetInstance().Gfx();
VkDevice device = gfx.getDevice();
CubeMap::~CubeMap() = default;
if (m_skyboxView) {
vkDestroyImageView(device, m_skyboxView, nullptr);
m_skyboxView = VK_NULL_HANDLE;
}
void CubeMap::cleanup(GfxDevice& gfxDevice)
{
VkDevice device = gfxDevice.getDevice();
if (m_cubemapPipelineLayout) {
m_cubemapPipeline.reset();
if (m_cubemapPipelineLayout != VK_NULL_HANDLE) {
vkDestroyPipelineLayout(device, m_cubemapPipelineLayout, nullptr);
m_cubemapPipelineLayout = VK_NULL_HANDLE;
}
m_cubemapImageID = NULL_IMAGE_ID;
m_hdrImage = NULL_IMAGE_ID;
}
void CubeMap::LoadCubeMap(const std::filesystem::path& directoryPath) {
// m_hdrImage = GameState::GetInstance().Gfx().loadImageFromFile(directoryPath, VK_FORMAT_R8G8B8A8_SRGB, VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, false);
m_hdrImage = GameState::GetInstance().Gfx().loadImageFromFile(directoryPath, VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, false);
void CubeMap::LoadCubeMap(
GfxDevice& gfxDevice,
RenderResources& resources,
const std::filesystem::path& directoryPath)
{
m_hdrImage = resources.loadImageFromFile(
gfxDevice,
directoryPath,
VK_IMAGE_USAGE_SAMPLED_BIT |
VK_IMAGE_USAGE_TRANSFER_DST_BIT |
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
false
);
}
void CubeMap::RenderToCubemap(ImageID inputImage,
VkImage outputImage,
std::array<VkImageView, 6> faceViews,
uint32_t size)
void CubeMap::RenderToCubemap(
GfxDevice& gfxDevice,
RenderResources& resources,
ImageID inputImage,
VkImage outputImage,
std::array<VkImageView, 6> faceViews,
std::uint32_t size)
{
// Ensure pipeline exists
if (!m_cubemapPipeline || m_cubemapPipelineLayout == VK_NULL_HANDLE) {
throw std::runtime_error("Cubemap pipeline not initialized. Call InitCubemapPipeline first.");
throw std::runtime_error(
"Cubemap pipeline not initialized. Call InitCubemapPipeline first."
);
}
auto& gfx = GameState::GetInstance().Gfx();
gfx.GetImmediateExecuter().immediateSubmit([&](VkCommandBuffer cmd) {
VkImageMemoryBarrier barrier{ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER };
gfxDevice.GetImmediateExecuter().immediateSubmit([&](VkCommandBuffer cmd) {
VkImageMemoryBarrier barrier{VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER};
barrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED;
barrier.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
@@ -75,7 +97,7 @@ void CubeMap::RenderToCubemap(ImageID inputImage,
VkViewport viewport{};
viewport.x = 0.0f;
viewport.y = 0.0f;
viewport.width = static_cast<float>(size);
viewport.width = static_cast<float>(size);
viewport.height = static_cast<float>(size);
viewport.minDepth = 0.0f;
viewport.maxDepth = 1.0f;
@@ -84,20 +106,24 @@ void CubeMap::RenderToCubemap(ImageID inputImage,
scissor.offset = {0, 0};
scissor.extent = {size, size};
for (uint32_t face = 0; face < 6; ++face) {
for (std::uint32_t face = 0; face < 6; ++face) {
PC pc{};
pc.viewMtx = viewMatrices[face];
pc.projMtx = m_projection;
pc.inputImageId = m_hdrImage;
pc.inputImageId = static_cast<std::uint32_t>(inputImage);
VkRenderingAttachmentInfoKHR colorAttachment{ VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR };
VkRenderingAttachmentInfoKHR colorAttachment{
VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR
};
colorAttachment.imageView = faceViews[face];
colorAttachment.imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
colorAttachment.clearValue.color = {0.f, 0.f, 0.f, 1.f};
VkRenderingInfoKHR renderingInfo{ VK_STRUCTURE_TYPE_RENDERING_INFO_KHR };
VkRenderingInfoKHR renderingInfo{
VK_STRUCTURE_TYPE_RENDERING_INFO_KHR
};
renderingInfo.renderArea.offset = {0, 0};
renderingInfo.renderArea.extent = {size, size};
renderingInfo.layerCount = 1;
@@ -111,7 +137,8 @@ void CubeMap::RenderToCubemap(ImageID inputImage,
m_cubemapPipeline->bind(cmd);
vkCmdSetPolygonModeEXT(cmd, VK_POLYGON_MODE_FILL);
gfx.bindBindlessDescSet(cmd, m_cubemapPipelineLayout);
resources.bindBindlessDescSet(cmd, m_cubemapPipelineLayout);
vkCmdPushConstants(
cmd,
@@ -127,7 +154,6 @@ void CubeMap::RenderToCubemap(ImageID inputImage,
vkCmdEndRendering(cmd);
}
// Transition to shader read
barrier.oldLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
barrier.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
barrier.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
@@ -145,54 +171,40 @@ void CubeMap::RenderToCubemap(ImageID inputImage,
});
}
void CubeMap::CreateCubeMap() {
const uint32_t mipLevels = static_cast<uint32_t>(std::floor(std::log2(m_cubeMapSize))) + 1;
void CubeMap::CreateCubeMap(
GfxDevice& gfxDevice,
RenderResources& resources)
{
if (m_hdrImage == NULL_IMAGE_ID) {
throw std::runtime_error(
"Cannot create cubemap before loading HDR image. Call LoadCubeMap first."
);
}
VkImageCreateInfo imageInfo{};
imageInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
imageInfo.imageType = VK_IMAGE_TYPE_2D;
imageInfo.extent.height = m_cubeMapSize;
imageInfo.extent.width = m_cubeMapSize;
imageInfo.extent.depth = 1;
imageInfo.mipLevels = mipLevels;
imageInfo.arrayLayers = 6; // 6 faces for cubemap
imageInfo.format = VK_FORMAT_R32G32B32A32_SFLOAT;
imageInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
imageInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
imageInfo.usage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
imageInfo.samples = VK_SAMPLE_COUNT_1_BIT;
imageInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
imageInfo.flags = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT; // Create a cubemap
VmaAllocationCreateInfo allocInfo{};
allocInfo.usage = VMA_MEMORY_USAGE_GPU_ONLY;
auto& device = GameState::GetInstance().Gfx();
GPUImage cubeMapID = device.createImageRaw({
GPUImage cubeMapImage = gfxDevice.createImageRaw({
.format = VK_FORMAT_R32G32B32A32_SFLOAT,
.usage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
.usage =
VK_IMAGE_USAGE_SAMPLED_BIT |
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
VK_IMAGE_USAGE_TRANSFER_DST_BIT |
VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
.flags = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT,
.extent =
VkExtent3D{
.width = m_cubeMapSize,
.height = m_cubeMapSize,
.depth = 1,
},
.extent = VkExtent3D{
.width = m_cubeMapSize,
.height = m_cubeMapSize,
.depth = 1,
},
.numLayers = 6,
.mipMap = true,
.mipMap = false,
.isCubemap = true
});
// if (vmaCreateImage(device.getAllocator(), &imageInfo, &allocInfo, &cubeMapID.image, &cubeMapID.allocation, nullptr) != VK_SUCCESS) {
// throw std::runtime_error("Failed to create image with VMA!");
// }
std::array<VkImageView, 6> faceViews{};
for (uint32_t face = 0; face < 6; ++face) {
for (std::uint32_t face = 0; face < 6; ++face) {
VkImageViewCreateInfo viewInfo{};
viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
viewInfo.image = cubeMapID.image;
viewInfo.image = cubeMapImage.image;
viewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
viewInfo.format = VK_FORMAT_R32G32B32A32_SFLOAT;
viewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
@@ -201,70 +213,81 @@ void CubeMap::CreateCubeMap() {
viewInfo.subresourceRange.baseArrayLayer = face;
viewInfo.subresourceRange.layerCount = 1;
if (vkCreateImageView(device.getDevice(), &viewInfo, nullptr, &faceViews[face]) != VK_SUCCESS) {
throw std::runtime_error("Failed to create image view!");
if (vkCreateImageView(
gfxDevice.getDevice(),
&viewInfo,
nullptr,
&faceViews[face]) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create cubemap face image view.");
}
}
VkImageViewCreateInfo viewInfo{};
viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
viewInfo.image = cubeMapID.image;
viewInfo.viewType = VK_IMAGE_VIEW_TYPE_CUBE;
viewInfo.format = VK_FORMAT_R32G32B32A32_SFLOAT;
viewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
viewInfo.subresourceRange.baseMipLevel = 0;
viewInfo.subresourceRange.levelCount = 1;
viewInfo.subresourceRange.baseArrayLayer = 0;
viewInfo.subresourceRange.layerCount = 6;
spdlog::info("HDRI image id = {}", m_hdrImage);
RenderToCubemap(
gfxDevice,
resources,
m_hdrImage,
cubeMapImage.image,
faceViews,
m_cubeMapSize
);
if (vkCreateImageView(device.getDevice(), &viewInfo, nullptr, &m_skyboxView) != VK_SUCCESS) {
throw std::runtime_error("Failed to create image view!");
}
const auto vertPath = AssetFS::GetInstance().GetCookedPathForFile("engine://shaders/cubemap.vert");
const auto fragPath = AssetFS::GetInstance().GetCookedPathForFile("engine://shaders/cubemap.frag");
spdlog::info("hdriImage id = {}", m_hdrImage);
RenderToCubemap(m_hdrImage, cubeMapID.image, faceViews, m_cubeMapSize);
m_cubemapImageID = resources.addImageToCache(std::move(cubeMapImage));
m_cubemapImageID = GameState::GetInstance().Gfx().addImageToCache(cubeMapID);
for (auto v : faceViews) {
vkDestroyImageView(device.getDevice(), v, nullptr);
for (VkImageView view : faceViews) {
if (view != VK_NULL_HANDLE) {
vkDestroyImageView(gfxDevice.getDevice(), view, nullptr);
}
}
}
ImageID CubeMap::GetCubeMapImageID() {
ImageID CubeMap::GetCubeMapImageID() const
{
return m_cubemapImageID;
}
void CubeMap::InitCubemapPipeline(const std::string& vertPath, const std::string& fragPath)
void CubeMap::InitCubemapPipeline(
GfxDevice& gfxDevice,
RenderResources& resources,
const std::string& vertPath,
const std::string& fragPath)
{
auto& gfx = GameState::GetInstance().Gfx();
VkDevice device = gfx.getDevice();
if (m_cubemapPipeline) {
return;
}
if (m_cubemapPipeline) return; // already created
VkDevice device = gfxDevice.getDevice();
// Save paths if you want
m_cubemapVert = vertPath;
m_cubemapFrag = fragPath;
VkPushConstantRange pushConstantRange{};
pushConstantRange.stageFlags = VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT;
pushConstantRange.stageFlags =
VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT;
pushConstantRange.offset = 0;
pushConstantRange.size = sizeof(PC);
const auto layouts = std::array{ gfx.getBindlessDescSetLayout() };
const auto layouts = std::array{
resources.getBindlessDescSetLayout()
};
VkPipelineLayoutCreateInfo pipelineLayoutInfo{ VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO };
pipelineLayoutInfo.setLayoutCount = static_cast<uint32_t>(layouts.size());
VkPipelineLayoutCreateInfo pipelineLayoutInfo{
VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO
};
pipelineLayoutInfo.setLayoutCount = static_cast<std::uint32_t>(layouts.size());
pipelineLayoutInfo.pSetLayouts = layouts.data();
pipelineLayoutInfo.pushConstantRangeCount = 1;
pipelineLayoutInfo.pPushConstantRanges = &pushConstantRange;
if (vkCreatePipelineLayout(device, &pipelineLayoutInfo, nullptr, &m_cubemapPipelineLayout) != VK_SUCCESS) {
throw std::runtime_error("Failed to create cubemap pipeline layout!");
if (vkCreatePipelineLayout(
device,
&pipelineLayoutInfo,
nullptr,
&m_cubemapPipelineLayout) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create cubemap pipeline layout.");
}
PipelineConfigInfo pipelineConfig{};
@@ -273,16 +296,16 @@ void CubeMap::InitCubemapPipeline(const std::string& vertPath, const std::string
pipelineConfig.vertexAttributeDescriptions = {};
pipelineConfig.vertexBindingDescriptions = {};
pipelineConfig.pipelineLayout = m_cubemapPipelineLayout;
pipelineConfig.colorAttachments = { VK_FORMAT_R32G32B32A32_SFLOAT }; // must match cubemap image view format
pipelineConfig.colorAttachments = {VK_FORMAT_R32G32B32A32_SFLOAT};
pipelineConfig.depthAttachment = VK_FORMAT_UNDEFINED;
pipelineConfig.depthStencilInfo.depthTestEnable = VK_FALSE;
pipelineConfig.depthStencilInfo.depthWriteEnable = VK_FALSE;
pipelineConfig.rasterizationInfo.cullMode = VK_CULL_MODE_NONE;
m_cubemapPipeline = std::make_unique<Pipeline>(
gfx,
gfxDevice,
vertPath,
fragPath,
pipelineConfig
);
}
}