137 lines
3.8 KiB
C++
137 lines
3.8 KiB
C++
// =============================================
|
|
// Aster: helpers.cpp
|
|
// Copyright (c) 2020-2025 Anish Bhobe
|
|
// =============================================
|
|
|
|
#include "helpers.h"
|
|
|
|
#include "aster/core/device.h"
|
|
#include "aster/core/physical_device.h"
|
|
|
|
#include <EASTL/array.h>
|
|
|
|
constexpr QueueSupportFlags REQUIRED_QUEUE_SUPPORT = QueueSupportFlags{} | QueueSupportFlagBits::eGraphics |
|
|
QueueSupportFlagBits::eCompute | QueueSupportFlagBits::ePresent |
|
|
QueueSupportFlagBits::eTransfer;
|
|
|
|
bool
|
|
IsSuitableDevice(const PhysicalDevice *physicalDevice)
|
|
{
|
|
const bool hasAllRequiredQueues =
|
|
std::ranges::any_of(physicalDevice->m_QueueFamilies, [](const auto &queueFamilyProp) {
|
|
return (queueFamilyProp.m_Support & REQUIRED_QUEUE_SUPPORT) == REQUIRED_QUEUE_SUPPORT;
|
|
});
|
|
|
|
const bool isNotCpu = physicalDevice->m_DeviceProperties.deviceType != vk::PhysicalDeviceType::eCpu;
|
|
|
|
const bool hasPresentMode = !physicalDevice->m_PresentModes.empty();
|
|
|
|
const bool hasSurfaceFormat = !physicalDevice->m_SurfaceFormats.empty();
|
|
|
|
return hasSurfaceFormat && hasPresentMode && isNotCpu && hasAllRequiredQueues;
|
|
}
|
|
|
|
PhysicalDevice
|
|
FindSuitableDevice(const PhysicalDevices &physicalDevices)
|
|
{
|
|
for (auto &physicalDevice : physicalDevices)
|
|
{
|
|
if (IsSuitableDevice(&physicalDevice))
|
|
{
|
|
return physicalDevice;
|
|
}
|
|
}
|
|
|
|
ERROR("No suitable GPU available on the system.")
|
|
THEN_ABORT(vk::Result::eErrorUnknown);
|
|
}
|
|
|
|
QueueAllocation
|
|
FindAppropriateQueueAllocation(const PhysicalDevice *physicalDevice)
|
|
{
|
|
for (auto &queueFamilyInfo : physicalDevice->m_QueueFamilies)
|
|
{
|
|
if ((queueFamilyInfo.m_Support & REQUIRED_QUEUE_SUPPORT) == REQUIRED_QUEUE_SUPPORT)
|
|
{
|
|
return {
|
|
.m_Family = queueFamilyInfo.m_Index,
|
|
.m_Count = queueFamilyInfo.m_Count,
|
|
};
|
|
}
|
|
}
|
|
ERROR("No suitable queue family on the GPU.")
|
|
THEN_ABORT(vk::Result::eErrorUnknown);
|
|
}
|
|
|
|
eastl::vector<u32>
|
|
ReadFile(cstr fileName)
|
|
{
|
|
FILE *filePtr = fopen(fileName, "rb");
|
|
|
|
if (!filePtr)
|
|
{
|
|
ERROR("Invalid read of {}", fileName) THEN_ABORT(-1);
|
|
}
|
|
|
|
eastl::vector<u32> outputVec;
|
|
eastl::array<u32, 1024> buffer{};
|
|
usize totalRead = 0;
|
|
usize readCount;
|
|
do
|
|
{
|
|
readCount = fread(buffer.data(), sizeof(u32), buffer.size(), filePtr);
|
|
const auto nextSize = totalRead + readCount;
|
|
outputVec.resize(nextSize);
|
|
memcpy(outputVec.data() + totalRead, buffer.data(), readCount * sizeof *buffer.data());
|
|
totalRead = nextSize;
|
|
} while (readCount == buffer.size());
|
|
|
|
return outputVec;
|
|
}
|
|
|
|
eastl::vector<u8>
|
|
ReadFileBytes(cstr fileName, bool errorOnFail)
|
|
{
|
|
FILE *filePtr = fopen(fileName, "rb");
|
|
|
|
if (!filePtr)
|
|
{
|
|
ERROR_IF(errorOnFail, "Invalid open (r) of {}. Cause: {}", fileName, errno);
|
|
return {};
|
|
}
|
|
|
|
eastl::vector<u8> outputVec;
|
|
eastl::array<u8, 4096> buffer{};
|
|
usize totalRead = 0;
|
|
usize readCount;
|
|
do
|
|
{
|
|
readCount = fread(buffer.data(), sizeof(u8), buffer.size(), filePtr);
|
|
const auto nextSize = totalRead + readCount;
|
|
outputVec.resize(nextSize);
|
|
memcpy(outputVec.data() + totalRead, buffer.data(), readCount * sizeof *buffer.data());
|
|
totalRead = nextSize;
|
|
} while (readCount == buffer.size());
|
|
|
|
(void)fclose(filePtr);
|
|
|
|
return outputVec;
|
|
}
|
|
|
|
bool
|
|
WriteFileBytes(cstr fileName, eastl::span<u8> data)
|
|
{
|
|
FILE *filePtr = fopen(fileName, "wb");
|
|
|
|
if (!filePtr)
|
|
{
|
|
ERROR("Invalid open (w) of {}. Cause: {}", fileName, errno);
|
|
return false;
|
|
}
|
|
|
|
const usize written = fwrite(data.data(), sizeof(u8), data.size(), filePtr);
|
|
|
|
(void)fclose(filePtr);
|
|
|
|
return written == data.size();
|
|
} |