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

fix shutdown

Browse Source
This commit is contained in:
Bram Verhulst
2026-06-20 01:20:14 +02:00
parent 1479ad468d
commit b1dad89214
8 changed files with 209 additions and 158 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
CMakeLists.txt
View File

@@ -23,3 +23,20 @@ add_dependencies(CookAssets
_internal_cook_game_assets
_internal_cook_engine_assets
)
option(ENABLE_SANITIZERS "Enable Address/Undefined sanitizers" OFF)
if (ENABLE_SANITIZERS AND CMAKE_CXX_COMPILER_ID MATCHES "Clang|GNU")
foreach(target destrum lightkeeper)
target_compile_options(${target} PRIVATE
-fsanitize=address,undefined
-fno-omit-frame-pointer
-fno-stack-protector
-g3
)
target_link_options(${target} PRIVATE
-fsanitize=address,undefined
)
endforeach()
endif()

2
destrum/include/destrum/Graphics/Renderer.h
View File

@@ -33,7 +33,7 @@ public:
void endDrawing();
void draw(VkCommandBuffer cmd, GfxDevice& gfxDevice, const Camera& camera, const SceneData& sceneData);
void cleanup(VkDevice device);
void cleanup(GfxDevice& gfxDevice);
void drawMesh(MeshID id, const glm::mat4& transform, MaterialID materialId);
void drawSkinnedMesh(MeshID id,

1
destrum/src/App.cpp
View File

@@ -126,5 +126,6 @@ void App::run() {
}
void App::cleanup() {
spdlog::info("Cleaning up");
customCleanup();
}

13
destrum/src/Graphics/GfxDevice.cpp
View File

@@ -104,18 +104,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); {
// 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);
}
imageCache.bindlessSetManager.init(device, props.limits.maxSamplerAnisotropy);
swapchain.initSync(device);

14
destrum/src/Graphics/ImageCache.cpp
View File

@@ -38,12 +38,20 @@ ImageID ImageCache::addImage(GPUImage image) {
ImageID ImageCache::addImage(ImageID id, GPUImage image) {
image.setBindlessId(static_cast<std::uint32_t>(id));
if (id != images.size()) {
images[id] = std::move(image); // replacing existing image
if (id < images.size()) {
gfxDevice.destroyImage(images[id]);
images[id] = std::move(image);
} else {
assert(id == images.size());
images.push_back(std::move(image));
}
bindlessSetManager.addImage(gfxDevice.getDevice(), id, image.imageView);
bindlessSetManager.addImage(
gfxDevice.getDevice(),
id,
images[id].imageView
);
return id;
}

24
destrum/src/Graphics/Renderer.cpp
View File

@@ -112,8 +112,30 @@ void GameRenderer::draw(VkCommandBuffer cmd, GfxDevice& gfxDevice, const Camera&
}
void GameRenderer::cleanup(VkDevice device) {
void GameRenderer::cleanup(GfxDevice& gfxDevice) {
VkDevice device = gfxDevice.getDevice().device;
vkDeviceWaitIdle(device);
if (skinningPipeline)
skinningPipeline->cleanup(gfxDevice);
if (skyboxPipeline)
skyboxPipeline->cleanup(device);
if (meshPipeline)
meshPipeline->cleanup(device);
sceneDataBuffer.cleanup(gfxDevice);
// if (drawImageId != NULL_IMAGE_ID)
// gfxDevice.destroyImage();
// if (depthImageId != NULL_IMAGE_ID)
// gfxDevice.destroyImage(depthImageId);
drawImageId = NULL_IMAGE_ID;
depthImageId = NULL_IMAGE_ID;
}
void GameRenderer::drawMesh(MeshID id, const glm::mat4& transform, MaterialID materialId) {

258
lightkeeper/src/Lightkeeper.cpp
View File

@@ -25,138 +25,138 @@ void LightKeeper::customInit() {
const float aspectRatio = static_cast<float>(m_params.renderSize.x) / static_cast<float>(m_params.renderSize.y);
camera.setAspectRatio(aspectRatio);
testMesh.name = "Test Mesh";
auto list_of_models = ModelLoader::LoadGLTF_CPUMeshes_MergedPerMesh(AssetFS::GetInstance().GetFullPath("game://kitty.glb").generic_string());
testMesh = list_of_models[0];
testMeshID = meshCache.addMesh(gfxDevice, testMesh);
spdlog::info("TestMesh uploaded with id: {}", testMeshID);
auto testimgID = gfxDevice.loadImageFromFile(AssetFS::GetInstance().GetFullPath("game://kitty.png"));
spdlog::info("Test image loaded with id: {}", testimgID);
testMaterialID = materialCache.addMaterial(gfxDevice, {
.baseColor = glm::vec3(1.f),
.diffuseTexture = testimgID,
});
spdlog::info("Test material created with id: {}", testMaterialID);
camera.SetRotation(glm::radians(glm::vec2(90.f, 0.f)));
//
// testMesh.name = "Test Mesh";
// auto list_of_models = ModelLoader::LoadGLTF_CPUMeshes_MergedPerMesh(AssetFS::GetInstance().GetFullPath("game://kitty.glb").generic_string());
// testMesh = list_of_models[0];
// testMeshID = meshCache.addMesh(gfxDevice, testMesh);
// spdlog::info("TestMesh uploaded with id: {}", testMeshID);
//
// auto testimgID = gfxDevice.loadImageFromFile(AssetFS::GetInstance().GetFullPath("game://kitty.png"));
// spdlog::info("Test image loaded with id: {}", testimgID);
// testMaterialID = materialCache.addMaterial(gfxDevice, {
// .baseColor = glm::vec3(1.f),
// .diffuseTexture = testimgID,
// });
// spdlog::info("Test material created with id: {}", testMaterialID);
//
// camera.SetRotation(glm::radians(glm::vec2(90.f, 0.f)));
//
auto& scene = SceneManager::GetInstance().CreateScene("Main");
// auto testCube = std::make_shared<GameObject>("TestCube");
// auto meshComp = testCube->AddComponent<MeshRendererComponent>();
// meshComp->SetMeshID(testMeshID);
// meshComp->SetMaterialID(testMaterialID);
const int count = 100;
const float radius = 5.0f;
const float orbitRadius = 5.0f;
for (int i = 0; i < count; ++i) {
// auto childCube = std::make_shared<GameObject>(fmt::format("ChildCube{}", i));
//
// auto childMeshComp = childCube->AddComponent<MeshRendererComponent>();
// childMeshComp->SetMeshID(testMeshID);
// childMeshComp->SetMaterialID(testMaterialID);
// // auto testCube = std::make_shared<GameObject>("TestCube");
// // auto meshComp = testCube->AddComponent<MeshRendererComponent>();
// // meshComp->SetMeshID(testMeshID);
// // meshComp->SetMaterialID(testMaterialID);
// const int count = 100;
// const float radius = 5.0f;
//
// childCube->GetTransform().SetWorldScale(glm::vec3(0.1f));
// const float orbitRadius = 5.0f;
//
// // Add orbit + self spin
// auto orbit = childCube->AddComponent<OrbitAndSpin>(orbitRadius, glm::vec3(0.0f));
// orbit->Randomize(1337u + (uint32_t)i); // stable random per index
// for (int i = 0; i < count; ++i) {
// // auto childCube = std::make_shared<GameObject>(fmt::format("ChildCube{}", i));
// //
// // auto childMeshComp = childCube->AddComponent<MeshRendererComponent>();
// // childMeshComp->SetMeshID(testMeshID);
// // childMeshComp->SetMaterialID(testMaterialID);
// //
// // childCube->GetTransform().SetWorldScale(glm::vec3(0.1f));
// //
// // // Add orbit + self spin
// // auto orbit = childCube->AddComponent<OrbitAndSpin>(orbitRadius, glm::vec3(0.0f));
// // orbit->Randomize(1337u + (uint32_t)i); // stable random per index
// //
// // scene.Add(childCube);
// }
// // testCube->AddComponent<Spinner>(glm::vec3(0, 1, 0), glm::radians(10.0f)); // spin around Y, rad/sec
// //rotate 180 around X axis
// // testCube->GetTransform().SetLocalRotation(glm::quat(glm::vec3(glm::radians(180.0f), 0.0f, 0.0f)));
// //
// auto globeRoot = std::make_shared<GameObject>("GlobeRoot");
// globeRoot->GetTransform().SetWorldPosition(glm::vec3(0.0f));
// globeRoot->AddComponent<Spinner>(glm::vec3(0, 1, 0), 1.0f); // spin around Y, rad/sec
// scene.Add(globeRoot);
//
// scene.Add(childCube);
}
// testCube->AddComponent<Spinner>(glm::vec3(0, 1, 0), glm::radians(10.0f)); // spin around Y, rad/sec
//rotate 180 around X axis
// testCube->GetTransform().SetLocalRotation(glm::quat(glm::vec3(glm::radians(180.0f), 0.0f, 0.0f)));
//
auto globeRoot = std::make_shared<GameObject>("GlobeRoot");
globeRoot->GetTransform().SetWorldPosition(glm::vec3(0.0f));
globeRoot->AddComponent<Spinner>(glm::vec3(0, 1, 0), 1.0f); // spin around Y, rad/sec
scene.Add(globeRoot);
// scene.Add(testCube);
// const auto skyboxID = AssetFS::GetInstance().GetFullPath("engine://textures/skybox.jpg");
// const auto skyboxID = AssetFS::GetInstance().GetFullPath("engine://textures/mars.jpg");
const auto skyboxID = AssetFS::GetInstance().GetCookedPathForFile("game://starmap_2020_4k.exr");
//
// const auto skyboxID = AssetFS::GetInstance().GetFullPath("engine://textures/test-skybox.png");
// // scene.Add(testCube);
//
const auto vertShaderPath = AssetFS::GetInstance().GetCookedPathForFile("engine://shaders/cubemap.vert");
const auto fragShaderPath = AssetFS::GetInstance().GetCookedPathForFile("engine://shaders/cubemap.frag");
// // const auto skyboxID = AssetFS::GetInstance().GetFullPath("engine://textures/skybox.jpg");
// // const auto skyboxID = AssetFS::GetInstance().GetFullPath("engine://textures/mars.jpg");
// const auto skyboxID = AssetFS::GetInstance().GetCookedPathForFile("game://starmap_2020_4k.exr");
// //
// // const auto skyboxID = AssetFS::GetInstance().GetFullPath("engine://textures/test-skybox.png");
// //
// const auto vertShaderPath = AssetFS::GetInstance().GetCookedPathForFile("engine://shaders/cubemap.vert");
// const auto fragShaderPath = AssetFS::GetInstance().GetCookedPathForFile("engine://shaders/cubemap.frag");
// //
// skyboxCubemap = std::make_unique<CubeMap>();
// skyboxCubemap->LoadCubeMap(skyboxID.generic_string());
// skyboxCubemap->InitCubemapPipeline(vertShaderPath.generic_string(), fragShaderPath.generic_string());
// skyboxCubemap->CreateCubeMap();
//
skyboxCubemap = std::make_unique<CubeMap>();
skyboxCubemap->LoadCubeMap(skyboxID.generic_string());
skyboxCubemap->InitCubemapPipeline(vertShaderPath.generic_string(), fragShaderPath.generic_string());
skyboxCubemap->CreateCubeMap();
renderer.setSkyboxTexture(skyboxCubemap->GetCubeMapImageID());
// renderer.setSkyboxTexture(skyboxCubemap->GetCubeMapImageID());
//
const auto planeObj = std::make_shared<GameObject>("GroundPlane");
const auto planeMeshComp = planeObj->AddComponent<MeshRendererComponent>();
const auto planeModel = ModelLoader::LoadGLTF_CPUMeshes_MergedPerMesh(AssetFS::GetInstance().GetFullPath("game://plane.glb").generic_string());
const auto planeMeshID = meshCache.addMesh(gfxDevice, planeModel[0]);
const auto planeTextureID = gfxDevice.loadImageFromFile(AssetFS::GetInstance().GetFullPath("game://grass.png"));
const auto planeMaterialID = materialCache.addMaterial(gfxDevice, {
.baseColor = glm::vec3(1.f),
.textureFilteringMode = TextureFilteringMode::Nearest,
.diffuseTexture = planeTextureID,
.name = "GroundPlaneMaterial",
});
planeMeshComp->SetMeshID(planeMeshID);
planeMeshComp->SetMaterialID(planeMaterialID);
planeObj->GetTransform().SetWorldPosition(glm::vec3(0.f, -1.0f, 0.f));
planeObj->GetTransform().SetWorldScale(glm::vec3(10.f, 1.f, 10.f));
scene.Add(planeObj);
// At the bottom of customInit(), replace the incomplete CharObj block:
const auto CharObj = std::make_shared<GameObject>("Character");
auto charModel = ModelLoader::LoadSkinnedModel(
AssetFS::GetInstance().GetFullPath("engine://char2.fbx").generic_string()
);
const auto charMeshID = meshCache.addMesh(gfxDevice, charModel.meshes[0]);
const auto charTextureID = gfxDevice.loadImageFromFile(AssetFS::GetInstance().GetFullPath("engine://char.jpg"));
const auto charMaterialID = materialCache.addMaterial(gfxDevice, {
.baseColor = glm::vec3(1.f),
.diffuseTexture = charTextureID,
.name = "CharacterMaterial",
});
const auto charMeshComp = CharObj->AddComponent<MeshRendererComponent>();
charMeshComp->SetMeshID(charMeshID);
charMeshComp->SetMaterialID(charMaterialID);
const auto animator = CharObj->AddComponent<Animator>();
animator->setSkeleton(std::move(charModel.skeleton));
for (auto& clip : charModel.animations) {
animator->addClip(std::make_shared<SkeletalAnimation>(std::move(clip)));
}
for (const auto& clip : charModel.animations)
spdlog::info("Loaded animation: '{}' ({:.2f}s)", clip.name, clip.duration);
if (!charModel.animations.empty())
// animator->play("Armature|Armature|mixamo.com");
// // animator->play(charModel.animations[0].name);
animator->play("Armature|Armature|Armature|main");
// or: animator->play("Run", 0.2f); // 0.2s cross-fade
CharObj->GetTransform().SetWorldPosition(glm::vec3(0.f, 0.f, 0.f));
// CharObj->GetTransform().SetWorldScale(0.01f, 0.01f, 0.01f);
scene.Add(CharObj);
// //
// const auto planeObj = std::make_shared<GameObject>("GroundPlane");
// const auto planeMeshComp = planeObj->AddComponent<MeshRendererComponent>();
// const auto planeModel = ModelLoader::LoadGLTF_CPUMeshes_MergedPerMesh(AssetFS::GetInstance().GetFullPath("game://plane.glb").generic_string());
// const auto planeMeshID = meshCache.addMesh(gfxDevice, planeModel[0]);
//
// const auto planeTextureID = gfxDevice.loadImageFromFile(AssetFS::GetInstance().GetFullPath("game://grass.png"));
// const auto planeMaterialID = materialCache.addMaterial(gfxDevice, {
// .baseColor = glm::vec3(1.f),
// .textureFilteringMode = TextureFilteringMode::Nearest,
// .diffuseTexture = planeTextureID,
// .name = "GroundPlaneMaterial",
// });
// planeMeshComp->SetMeshID(planeMeshID);
// planeMeshComp->SetMaterialID(planeMaterialID);
// planeObj->GetTransform().SetWorldPosition(glm::vec3(0.f, -1.0f, 0.f));
// planeObj->GetTransform().SetWorldScale(glm::vec3(10.f, 1.f, 10.f));
// scene.Add(planeObj);
//
//
// // At the bottom of customInit(), replace the incomplete CharObj block:
//
// const auto CharObj = std::make_shared<GameObject>("Character");
//
// auto charModel = ModelLoader::LoadSkinnedModel(
// AssetFS::GetInstance().GetFullPath("engine://char2.fbx").generic_string()
// );
//
// const auto charMeshID = meshCache.addMesh(gfxDevice, charModel.meshes[0]);
//
// const auto charTextureID = gfxDevice.loadImageFromFile(AssetFS::GetInstance().GetFullPath("engine://char.jpg"));
// const auto charMaterialID = materialCache.addMaterial(gfxDevice, {
// .baseColor = glm::vec3(1.f),
// .diffuseTexture = charTextureID,
// .name = "CharacterMaterial",
// });
//
// const auto charMeshComp = CharObj->AddComponent<MeshRendererComponent>();
// charMeshComp->SetMeshID(charMeshID);
// charMeshComp->SetMaterialID(charMaterialID);
//
//
// const auto animator = CharObj->AddComponent<Animator>();
// animator->setSkeleton(std::move(charModel.skeleton));
// for (auto& clip : charModel.animations) {
// animator->addClip(std::make_shared<SkeletalAnimation>(std::move(clip)));
// }
//
// for (const auto& clip : charModel.animations)
// spdlog::info("Loaded animation: '{}' ({:.2f}s)", clip.name, clip.duration);
//
// if (!charModel.animations.empty())
// // animator->play("Armature|Armature|mixamo.com");
// // // animator->play(charModel.animations[0].name);
// animator->play("Armature|Armature|Armature|main");
// // or: animator->play("Run", 0.2f); // 0.2s cross-fade
//
// CharObj->GetTransform().SetWorldPosition(glm::vec3(0.f, 0.f, 0.f));
// // CharObj->GetTransform().SetWorldScale(0.01f, 0.01f, 0.01f);
// scene.Add(CharObj);
}
void LightKeeper::customUpdate(float dt) {
@@ -198,8 +198,20 @@ void LightKeeper::customDraw() {
}
void LightKeeper::customCleanup() {
auto device = gfxDevice.getDevice().device;
vkDeviceWaitIdle(device);
SceneManager::GetInstance().Destroy();
renderer.cleanup(gfxDevice.getDevice().device);
if (skyboxCubemap) {
skyboxCubemap.reset();
}
renderer.cleanup(gfxDevice);
materialCache.cleanup(gfxDevice);
meshCache.cleanup(gfxDevice);
}
void LightKeeper::onWindowResize(int newWidth, int newHeight) {

4
lightkeeper/src/main.cpp
View File

@@ -9,7 +9,7 @@ int main(int argc, char* argv[]) {
SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "Error", SDL_GetError(), nullptr);
return 1;
}
{
std::filesystem::path exeDir = SDL_GetBasePath();
spdlog::set_level(spdlog::level::debug);
@@ -24,7 +24,9 @@ int main(int argc, char* argv[]) {
});
app.run();
app.cleanup();
}
SDL_Quit();
return 0;
}