diff options
33 files changed, 344 insertions, 343 deletions
diff --git a/engine/xe_buffer.cpp b/engine/xe_buffer.cpp index 0c0006f..7a67f88 100644 --- a/engine/xe_buffer.cpp +++ b/engine/xe_buffer.cpp @@ -5,15 +5,15 @@ namespace xe { -VkDeviceSize XeBuffer::getAlignment(VkDeviceSize instanceSize, VkDeviceSize minOffsetAlignment) { +VkDeviceSize Buffer::getAlignment(VkDeviceSize instanceSize, VkDeviceSize minOffsetAlignment) { if (minOffsetAlignment > 0) { return (instanceSize + minOffsetAlignment - 1) & ~(minOffsetAlignment - 1); } return instanceSize; } -XeBuffer::XeBuffer( - XeDevice &device, +Buffer::Buffer( + Device &device, VkDeviceSize instanceSize, uint32_t instanceCount, VkBufferUsageFlags usageFlags, @@ -29,25 +29,25 @@ XeBuffer::XeBuffer( device.createBuffer(bufferSize, usageFlags, memoryPropertyFlags, buffer, memory); } -XeBuffer::~XeBuffer() { +Buffer::~Buffer() { unmap(); vkDestroyBuffer(xeDevice.device(), buffer, nullptr); vkFreeMemory(xeDevice.device(), memory, nullptr); } -VkResult XeBuffer::map(VkDeviceSize size, VkDeviceSize offset) { +VkResult Buffer::map(VkDeviceSize size, VkDeviceSize offset) { assert(buffer && memory && "Called map on buffer before create"); return vkMapMemory(xeDevice.device(), memory, offset, size, 0, &mapped); } -void XeBuffer::unmap() { +void Buffer::unmap() { if (mapped) { vkUnmapMemory(xeDevice.device(), memory); mapped = nullptr; } } -void XeBuffer::writeToBuffer(void *data, VkDeviceSize size, VkDeviceSize offset) { +void Buffer::writeToBuffer(void *data, VkDeviceSize size, VkDeviceSize offset) { assert(mapped && "Cannot copy to unmapped buffer"); if (size == VK_WHOLE_SIZE) { @@ -59,7 +59,7 @@ void XeBuffer::writeToBuffer(void *data, VkDeviceSize size, VkDeviceSize offset) } } -VkResult XeBuffer::flush(VkDeviceSize size, VkDeviceSize offset) { +VkResult Buffer::flush(VkDeviceSize size, VkDeviceSize offset) { VkMappedMemoryRange mappedRange = {}; mappedRange.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE; mappedRange.memory = memory; @@ -68,7 +68,7 @@ VkResult XeBuffer::flush(VkDeviceSize size, VkDeviceSize offset) { return vkFlushMappedMemoryRanges(xeDevice.device(), 1, &mappedRange); } -VkResult XeBuffer::invalidate(VkDeviceSize size, VkDeviceSize offset) { +VkResult Buffer::invalidate(VkDeviceSize size, VkDeviceSize offset) { VkMappedMemoryRange mappedRange = {}; mappedRange.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE; mappedRange.memory = memory; @@ -77,7 +77,7 @@ VkResult XeBuffer::invalidate(VkDeviceSize size, VkDeviceSize offset) { return vkInvalidateMappedMemoryRanges(xeDevice.device(), 1, &mappedRange); } -VkDescriptorBufferInfo XeBuffer::descriptorInfo(VkDeviceSize size, VkDeviceSize offset) { +VkDescriptorBufferInfo Buffer::descriptorInfo(VkDeviceSize size, VkDeviceSize offset) { return VkDescriptorBufferInfo{ buffer, offset, @@ -85,17 +85,17 @@ VkDescriptorBufferInfo XeBuffer::descriptorInfo(VkDeviceSize size, VkDeviceSize }; } -void XeBuffer::writeToIndex(void *data, int index) { +void Buffer::writeToIndex(void *data, int index) { writeToBuffer(data, instanceSize, index * alignmentSize); } -VkResult XeBuffer::flushIndex(int index) { return flush(alignmentSize, index * alignmentSize); } +VkResult Buffer::flushIndex(int index) { return flush(alignmentSize, index * alignmentSize); } -VkDescriptorBufferInfo XeBuffer::descriptorInfoForIndex(int index) { +VkDescriptorBufferInfo Buffer::descriptorInfoForIndex(int index) { return descriptorInfo(alignmentSize, index * alignmentSize); } -VkResult XeBuffer::invalidateIndex(int index) { +VkResult Buffer::invalidateIndex(int index) { return invalidate(alignmentSize, index * alignmentSize); } diff --git a/engine/xe_buffer.hpp b/engine/xe_buffer.hpp index dbbb13f..4e39836 100644 --- a/engine/xe_buffer.hpp +++ b/engine/xe_buffer.hpp @@ -4,19 +4,19 @@ namespace xe { -class XeBuffer { +class Buffer { public: - XeBuffer( - XeDevice& device, + Buffer( + Device& device, VkDeviceSize instanceSize, uint32_t instanceCount, VkBufferUsageFlags usageFlags, VkMemoryPropertyFlags memoryPropertyFlags, VkDeviceSize minOffsetAlignment = 1); - ~XeBuffer(); + ~Buffer(); - XeBuffer(const XeBuffer&) = delete; - XeBuffer& operator=(const XeBuffer&) = delete; + Buffer(const Buffer&) = delete; + Buffer& operator=(const Buffer&) = delete; VkResult map(VkDeviceSize size = VK_WHOLE_SIZE, VkDeviceSize offset = 0); void unmap(); @@ -43,7 +43,7 @@ class XeBuffer { private: static VkDeviceSize getAlignment(VkDeviceSize instanceSize, VkDeviceSize minOffsetAlignment); - XeDevice& xeDevice; + Device& xeDevice; void* mapped = nullptr; VkBuffer buffer = VK_NULL_HANDLE; VkDeviceMemory memory = VK_NULL_HANDLE; diff --git a/engine/xe_camera.cpp b/engine/xe_camera.cpp index 2174a24..42b4def 100644 --- a/engine/xe_camera.cpp +++ b/engine/xe_camera.cpp @@ -5,7 +5,7 @@ namespace xe { -void XeCamera::setOrthographicProjection( +void Camera::setOrthographicProjection( float left, float right, float top, float bottom, float near, float far) { projectionMatrix = glm::mat4{1.0f}; projectionMatrix[0][0] = 2.f / (right - left); @@ -16,7 +16,7 @@ void XeCamera::setOrthographicProjection( projectionMatrix[3][2] = -near / (far - near); } -void XeCamera::setPerspectiveProjection(float fovy, float aspect, float near, float far) { +void Camera::setPerspectiveProjection(float fovy, float aspect, float near, float far) { assert(glm::abs(aspect - std::numeric_limits<float>::epsilon()) > 0.0f); const float tanHalfFovy = tan(fovy / 2.f); projectionMatrix = glm::mat4{0.0f}; @@ -27,7 +27,7 @@ void XeCamera::setPerspectiveProjection(float fovy, float aspect, float near, fl projectionMatrix[3][2] = -(far * near) / (far - near); } -void XeCamera::setViewDirection(glm::vec3 position, glm::vec3 direction, glm::vec3 up) { +void Camera::setViewDirection(glm::vec3 position, glm::vec3 direction, glm::vec3 up) { const glm::vec3 w{glm::normalize(direction)}; const glm::vec3 u{glm::normalize(glm::cross(w, up))}; const glm::vec3 v{glm::cross(w, u)}; @@ -47,11 +47,11 @@ void XeCamera::setViewDirection(glm::vec3 position, glm::vec3 direction, glm::ve viewMatrix[3][2] = -glm::dot(w, position); } -void XeCamera::setViewTarget(glm::vec3 position, glm::vec3 target, glm::vec3 up) { +void Camera::setViewTarget(glm::vec3 position, glm::vec3 target, glm::vec3 up) { setViewDirection(position, target - position, up); } -void XeCamera::setViewYXZ(glm::vec3 position, glm::vec3 rotation) { +void Camera::setViewYXZ(glm::vec3 position, glm::vec3 rotation) { const float c3 = glm::cos(rotation.z); const float s3 = glm::sin(rotation.z); const float c2 = glm::cos(rotation.x); diff --git a/engine/xe_camera.hpp b/engine/xe_camera.hpp index 00711cd..23eef63 100644 --- a/engine/xe_camera.hpp +++ b/engine/xe_camera.hpp @@ -7,7 +7,7 @@ namespace xe { -class XeCamera { +class Camera { public: void setOrthographicProjection( diff --git a/engine/xe_descriptors.cpp b/engine/xe_descriptors.cpp index f1f4436..4840c9e 100644 --- a/engine/xe_descriptors.cpp +++ b/engine/xe_descriptors.cpp @@ -5,7 +5,7 @@ namespace xe { -XeDescriptorSetLayout::Builder &XeDescriptorSetLayout::Builder::addBinding( +DescriptorSetLayout::Builder &DescriptorSetLayout::Builder::addBinding( uint32_t binding, VkDescriptorType descriptorType, VkShaderStageFlags stageFlags, @@ -22,12 +22,12 @@ XeDescriptorSetLayout::Builder &XeDescriptorSetLayout::Builder::addBinding( return *this; } -std::unique_ptr<XeDescriptorSetLayout> XeDescriptorSetLayout::Builder::build() const { - return std::make_unique<XeDescriptorSetLayout>(xeDevice, bindings); +std::unique_ptr<DescriptorSetLayout> DescriptorSetLayout::Builder::build() const { + return std::make_unique<DescriptorSetLayout>(xeDevice, bindings); } -XeDescriptorSetLayout::XeDescriptorSetLayout( - XeDevice &xeDevice, std::unordered_map<uint32_t, VkDescriptorSetLayoutBinding> bindings) +DescriptorSetLayout::DescriptorSetLayout( + Device &xeDevice, std::unordered_map<uint32_t, VkDescriptorSetLayoutBinding> bindings) : xeDevice{xeDevice}, bindings{bindings} { std::vector<VkDescriptorSetLayoutBinding> setLayoutBindings{}; for (auto kv : bindings) { @@ -48,32 +48,32 @@ XeDescriptorSetLayout::XeDescriptorSetLayout( } } -XeDescriptorSetLayout::~XeDescriptorSetLayout() { +DescriptorSetLayout::~DescriptorSetLayout() { vkDestroyDescriptorSetLayout(xeDevice.device(), descriptorSetLayout, nullptr); } -XeDescriptorPool::Builder &XeDescriptorPool::Builder::addPoolSize( +DescriptorPool::Builder &DescriptorPool::Builder::addPoolSize( VkDescriptorType descriptorType, uint32_t count) { poolSizes.push_back({descriptorType, count}); return *this; } -XeDescriptorPool::Builder &XeDescriptorPool::Builder::setPoolFlags( +DescriptorPool::Builder &DescriptorPool::Builder::setPoolFlags( VkDescriptorPoolCreateFlags flags) { poolFlags = flags; return *this; } -XeDescriptorPool::Builder &XeDescriptorPool::Builder::setMaxSets(uint32_t count) { +DescriptorPool::Builder &DescriptorPool::Builder::setMaxSets(uint32_t count) { maxSets = count; return *this; } -std::unique_ptr<XeDescriptorPool> XeDescriptorPool::Builder::build() const { - return std::make_unique<XeDescriptorPool>(xeDevice, maxSets, poolFlags, poolSizes); +std::unique_ptr<DescriptorPool> DescriptorPool::Builder::build() const { + return std::make_unique<DescriptorPool>(xeDevice, maxSets, poolFlags, poolSizes); } -XeDescriptorPool::XeDescriptorPool( - XeDevice &xeDevice, +DescriptorPool::DescriptorPool( + Device &xeDevice, uint32_t maxSets, VkDescriptorPoolCreateFlags poolFlags, const std::vector<VkDescriptorPoolSize> &poolSizes) @@ -91,11 +91,11 @@ XeDescriptorPool::XeDescriptorPool( } } -XeDescriptorPool::~XeDescriptorPool() { +DescriptorPool::~DescriptorPool() { vkDestroyDescriptorPool(xeDevice.device(), descriptorPool, nullptr); } -bool XeDescriptorPool::allocateDescriptor( +bool DescriptorPool::allocateDescriptor( const VkDescriptorSetLayout descriptorSetLayout, VkDescriptorSet &descriptor) const { VkDescriptorSetAllocateInfo allocInfo{}; allocInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; @@ -109,7 +109,7 @@ bool XeDescriptorPool::allocateDescriptor( return true; } -void XeDescriptorPool::freeDescriptors(std::vector<VkDescriptorSet> &descriptors) const { +void DescriptorPool::freeDescriptors(std::vector<VkDescriptorSet> &descriptors) const { vkFreeDescriptorSets( xeDevice.device(), descriptorPool, @@ -117,14 +117,14 @@ void XeDescriptorPool::freeDescriptors(std::vector<VkDescriptorSet> &descriptors descriptors.data()); } -void XeDescriptorPool::resetPool() { +void DescriptorPool::resetPool() { vkResetDescriptorPool(xeDevice.device(), descriptorPool, 0); } -XeDescriptorWriter::XeDescriptorWriter(XeDescriptorSetLayout &setLayout, XeDescriptorPool &pool) +DescriptorWriter::DescriptorWriter(DescriptorSetLayout &setLayout, DescriptorPool &pool) : setLayout{setLayout}, pool{pool} {} -XeDescriptorWriter &XeDescriptorWriter::writeBuffer( +DescriptorWriter &DescriptorWriter::writeBuffer( uint32_t binding, VkDescriptorBufferInfo *bufferInfo) { assert(setLayout.bindings.count(binding) == 1 && "Layout does not contain specified binding"); @@ -145,7 +145,7 @@ XeDescriptorWriter &XeDescriptorWriter::writeBuffer( return *this; } -XeDescriptorWriter &XeDescriptorWriter::writeImage( +DescriptorWriter &DescriptorWriter::writeImage( uint32_t binding, VkDescriptorImageInfo *imageInfo) { assert(setLayout.bindings.count(binding) == 1 && "Layout does not contain specified binding"); @@ -166,7 +166,7 @@ XeDescriptorWriter &XeDescriptorWriter::writeImage( return *this; } -bool XeDescriptorWriter::build(VkDescriptorSet &set) { +bool DescriptorWriter::build(VkDescriptorSet &set) { bool success = pool.allocateDescriptor(setLayout.getDescriptorSetLayout(), set); if (!success) { return false; @@ -175,7 +175,7 @@ bool XeDescriptorWriter::build(VkDescriptorSet &set) { return true; } -void XeDescriptorWriter::overwrite(VkDescriptorSet &set) { +void DescriptorWriter::overwrite(VkDescriptorSet &set) { for (auto &write : writes) { write.dstSet = set; } diff --git a/engine/xe_descriptors.hpp b/engine/xe_descriptors.hpp index 5efe9b4..ea635c5 100644 --- a/engine/xe_descriptors.hpp +++ b/engine/xe_descriptors.hpp @@ -9,66 +9,66 @@ namespace xe { -class XeDescriptorSetLayout { +class DescriptorSetLayout { public: class Builder { public: - Builder(XeDevice &xeDevice) : xeDevice{xeDevice} {} + Builder(Device &xeDevice) : xeDevice{xeDevice} {} Builder &addBinding( uint32_t binding, VkDescriptorType descriptorType, VkShaderStageFlags stageFlags, VkSampler *sampler); - std::unique_ptr<XeDescriptorSetLayout> build() const; + std::unique_ptr<DescriptorSetLayout> build() const; private: - XeDevice &xeDevice; + Device &xeDevice; std::unordered_map<uint32_t, VkDescriptorSetLayoutBinding> bindings{}; }; - XeDescriptorSetLayout( - XeDevice &xeDevice, std::unordered_map<uint32_t, VkDescriptorSetLayoutBinding> bindings); - ~XeDescriptorSetLayout(); - XeDescriptorSetLayout(const XeDescriptorSetLayout &) = delete; - XeDescriptorSetLayout &operator=(const XeDescriptorSetLayout &) = delete; + DescriptorSetLayout( + Device &xeDevice, std::unordered_map<uint32_t, VkDescriptorSetLayoutBinding> bindings); + ~DescriptorSetLayout(); + DescriptorSetLayout(const DescriptorSetLayout &) = delete; + DescriptorSetLayout &operator=(const DescriptorSetLayout &) = delete; VkDescriptorSetLayout getDescriptorSetLayout() const { return descriptorSetLayout; } private: - XeDevice &xeDevice; + Device &xeDevice; VkDescriptorSetLayout descriptorSetLayout; std::unordered_map<uint32_t, VkDescriptorSetLayoutBinding> bindings; - friend class XeDescriptorWriter; + friend class DescriptorWriter; }; -class XeDescriptorPool { +class DescriptorPool { public: class Builder { public: - Builder(XeDevice &xeDevice) : xeDevice{xeDevice} {} + Builder(Device &xeDevice) : xeDevice{xeDevice} {} Builder &addPoolSize(VkDescriptorType descriptorType, uint32_t count); Builder &setPoolFlags(VkDescriptorPoolCreateFlags flags); Builder &setMaxSets(uint32_t count); - std::unique_ptr<XeDescriptorPool> build() const; + std::unique_ptr<DescriptorPool> build() const; private: - XeDevice &xeDevice; + Device &xeDevice; std::vector<VkDescriptorPoolSize> poolSizes{}; uint32_t maxSets = 1000; VkDescriptorPoolCreateFlags poolFlags = 0; }; - XeDescriptorPool( - XeDevice &xeDevice, + DescriptorPool( + Device &xeDevice, uint32_t maxSets, VkDescriptorPoolCreateFlags poolFlags, const std::vector<VkDescriptorPoolSize> &poolSizes); - ~XeDescriptorPool(); - XeDescriptorPool(const XeDescriptorPool &) = delete; - XeDescriptorPool &operator=(const XeDescriptorPool &) = delete; + ~DescriptorPool(); + DescriptorPool(const DescriptorPool &) = delete; + DescriptorPool &operator=(const DescriptorPool &) = delete; bool allocateDescriptor( const VkDescriptorSetLayout descriptorSetLayout, VkDescriptorSet &descriptor) const; @@ -78,25 +78,25 @@ class XeDescriptorPool { void resetPool(); private: - XeDevice &xeDevice; + Device &xeDevice; VkDescriptorPool descriptorPool; - friend class XeDescriptorWriter; + friend class DescriptorWriter; }; -class XeDescriptorWriter { +class DescriptorWriter { public: - XeDescriptorWriter(XeDescriptorSetLayout &setLayout, XeDescriptorPool &pool); + DescriptorWriter(DescriptorSetLayout &setLayout, DescriptorPool &pool); - XeDescriptorWriter &writeBuffer(uint32_t binding, VkDescriptorBufferInfo *bufferInfo); - XeDescriptorWriter &writeImage(uint32_t binding, VkDescriptorImageInfo *imageInfo); + DescriptorWriter &writeBuffer(uint32_t binding, VkDescriptorBufferInfo *bufferInfo); + DescriptorWriter &writeImage(uint32_t binding, VkDescriptorImageInfo *imageInfo); bool build(VkDescriptorSet &set); void overwrite(VkDescriptorSet &set); private: - XeDescriptorSetLayout &setLayout; - XeDescriptorPool &pool; + DescriptorSetLayout &setLayout; + DescriptorPool &pool; std::vector<VkWriteDescriptorSet> writes; }; diff --git a/engine/xe_device.cpp b/engine/xe_device.cpp index e58a77e..d6d0713 100755 --- a/engine/xe_device.cpp +++ b/engine/xe_device.cpp @@ -47,7 +47,7 @@ void DestroyDebugUtilsMessengerEXT( } // class member functions -XeDevice::XeDevice(XeWindow &window) : window{window} { +Device::Device(Window &window) : window{window} { createInstance(); setupDebugMessenger(); createSurface(); @@ -56,7 +56,7 @@ XeDevice::XeDevice(XeWindow &window) : window{window} { createCommandPool(); } -XeDevice::~XeDevice() { +Device::~Device() { vkDestroyCommandPool(device_, commandPool, nullptr); vkDestroyDevice(device_, nullptr); @@ -68,7 +68,7 @@ XeDevice::~XeDevice() { vkDestroyInstance(instance, nullptr); } -void XeDevice::createInstance() { +void Device::createInstance() { if (enableValidationLayers && !checkValidationLayerSupport()) { throw std::runtime_error("validation layers requested, but not available!"); } @@ -108,7 +108,7 @@ void XeDevice::createInstance() { hasGflwRequiredInstanceExtensions(); } -void XeDevice::pickPhysicalDevice() { +void Device::pickPhysicalDevice() { uint32_t deviceCount = 0; vkEnumeratePhysicalDevices(instance, &deviceCount, nullptr); if (deviceCount == 0) { @@ -133,7 +133,7 @@ void XeDevice::pickPhysicalDevice() { std::cout << "Physical device: " << properties.deviceName << std::endl; } -void XeDevice::createLogicalDevice() { +void Device::createLogicalDevice() { QueueFamilyIndices indices = findQueueFamilies(physicalDevice); std::vector<VkDeviceQueueCreateInfo> queueCreateInfos; @@ -179,7 +179,7 @@ void XeDevice::createLogicalDevice() { vkGetDeviceQueue(device_, indices.presentFamily, 0, &presentQueue_); } -void XeDevice::createCommandPool() { +void Device::createCommandPool() { QueueFamilyIndices queueFamilyIndices = findPhysicalQueueFamilies(); VkCommandPoolCreateInfo poolInfo = {}; @@ -193,9 +193,9 @@ void XeDevice::createCommandPool() { } } -void XeDevice::createSurface() { window.createWindowSurface(instance, &surface_); } +void Device::createSurface() { window.createWindowSurface(instance, &surface_); } -bool XeDevice::isDeviceSuitable(VkPhysicalDevice device) { +bool Device::isDeviceSuitable(VkPhysicalDevice device) { QueueFamilyIndices indices = findQueueFamilies(device); bool extensionsSupported = checkDeviceExtensionSupport(device); @@ -213,7 +213,7 @@ bool XeDevice::isDeviceSuitable(VkPhysicalDevice device) { supportedFeatures.samplerAnisotropy; } -void XeDevice::populateDebugMessengerCreateInfo( +void Device::populateDebugMessengerCreateInfo( VkDebugUtilsMessengerCreateInfoEXT &createInfo) { createInfo = {}; createInfo.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT; @@ -226,7 +226,7 @@ void XeDevice::populateDebugMessengerCreateInfo( createInfo.pUserData = nullptr; // Optional } -void XeDevice::setupDebugMessenger() { +void Device::setupDebugMessenger() { if (!enableValidationLayers) return; VkDebugUtilsMessengerCreateInfoEXT createInfo; populateDebugMessengerCreateInfo(createInfo); @@ -235,7 +235,7 @@ void XeDevice::setupDebugMessenger() { } } -bool XeDevice::checkValidationLayerSupport() { +bool Device::checkValidationLayerSupport() { uint32_t layerCount; vkEnumerateInstanceLayerProperties(&layerCount, nullptr); @@ -260,7 +260,7 @@ bool XeDevice::checkValidationLayerSupport() { return true; } -std::vector<const char *> XeDevice::getRequiredExtensions() { +std::vector<const char *> Device::getRequiredExtensions() { uint32_t glfwExtensionCount = 0; const char **glfwExtensions; glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount); @@ -274,7 +274,7 @@ std::vector<const char *> XeDevice::getRequiredExtensions() { return extensions; } -void XeDevice::hasGflwRequiredInstanceExtensions() { +void Device::hasGflwRequiredInstanceExtensions() { uint32_t extensionCount = 0; vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, nullptr); std::vector<VkExtensionProperties> extensions(extensionCount); @@ -297,7 +297,7 @@ void XeDevice::hasGflwRequiredInstanceExtensions() { } } -bool XeDevice::checkDeviceExtensionSupport(VkPhysicalDevice device) { +bool Device::checkDeviceExtensionSupport(VkPhysicalDevice device) { uint32_t extensionCount; vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionCount, nullptr); @@ -317,7 +317,7 @@ bool XeDevice::checkDeviceExtensionSupport(VkPhysicalDevice device) { return requiredExtensions.empty(); } -QueueFamilyIndices XeDevice::findQueueFamilies(VkPhysicalDevice device) { +QueueFamilyIndices Device::findQueueFamilies(VkPhysicalDevice device) { QueueFamilyIndices indices; uint32_t queueFamilyCount = 0; @@ -348,7 +348,7 @@ QueueFamilyIndices XeDevice::findQueueFamilies(VkPhysicalDevice device) { return indices; } -SwapChainSupportDetails XeDevice::querySwapChainSupport(VkPhysicalDevice device) { +SwapChainSupportDetails Device::querySwapChainSupport(VkPhysicalDevice device) { SwapChainSupportDetails details; vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device, surface_, &details.capabilities); @@ -374,7 +374,7 @@ SwapChainSupportDetails XeDevice::querySwapChainSupport(VkPhysicalDevice device) return details; } -VkFormat XeDevice::findSupportedFormat( +VkFormat Device::findSupportedFormat( const std::vector<VkFormat> &candidates, VkImageTiling tiling, VkFormatFeatureFlags features) { for (VkFormat format : candidates) { VkFormatProperties props; @@ -390,7 +390,7 @@ VkFormat XeDevice::findSupportedFormat( throw std::runtime_error("failed to find supported format!"); } -uint32_t XeDevice::findMemoryType(uint32_t typeFilter, VkMemoryPropertyFlags properties) { +uint32_t Device::findMemoryType(uint32_t typeFilter, VkMemoryPropertyFlags properties) { VkPhysicalDeviceMemoryProperties memProperties; vkGetPhysicalDeviceMemoryProperties(physicalDevice, &memProperties); for (uint32_t i = 0; i < memProperties.memoryTypeCount; i++) { @@ -403,7 +403,7 @@ uint32_t XeDevice::findMemoryType(uint32_t typeFilter, VkMemoryPropertyFlags pro throw std::runtime_error("failed to find suitable memory type!"); } -void XeDevice::createBuffer( +void Device::createBuffer( VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags properties, @@ -434,7 +434,7 @@ void XeDevice::createBuffer( vkBindBufferMemory(device_, buffer, bufferMemory, 0); } -VkCommandBuffer XeDevice::beginSingleTimeCommands() { +VkCommandBuffer Device::beginSingleTimeCommands() { VkCommandBufferAllocateInfo allocInfo{}; allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; @@ -452,7 +452,7 @@ VkCommandBuffer XeDevice::beginSingleTimeCommands() { return commandBuffer; } -void XeDevice::endSingleTimeCommands(VkCommandBuffer commandBuffer) { +void Device::endSingleTimeCommands(VkCommandBuffer commandBuffer) { vkEndCommandBuffer(commandBuffer); VkSubmitInfo submitInfo{}; @@ -466,7 +466,7 @@ void XeDevice::endSingleTimeCommands(VkCommandBuffer commandBuffer) { vkFreeCommandBuffers(device_, commandPool, 1, &commandBuffer); } -void XeDevice::copyBuffer(VkBuffer srcBuffer, VkBuffer dstBuffer, VkDeviceSize size) { +void Device::copyBuffer(VkBuffer srcBuffer, VkBuffer dstBuffer, VkDeviceSize size) { VkCommandBuffer commandBuffer = beginSingleTimeCommands(); VkBufferCopy copyRegion{}; @@ -478,7 +478,7 @@ void XeDevice::copyBuffer(VkBuffer srcBuffer, VkBuffer dstBuffer, VkDeviceSize s endSingleTimeCommands(commandBuffer); } -void XeDevice::copyBufferToImage( +void Device::copyBufferToImage( VkBuffer buffer, VkImage image, uint32_t width, uint32_t height, uint32_t layerCount) { VkCommandBuffer commandBuffer = beginSingleTimeCommands(); @@ -505,7 +505,7 @@ void XeDevice::copyBufferToImage( endSingleTimeCommands(commandBuffer); } -void XeDevice::createImageWithInfo( +void Device::createImageWithInfo( const VkImageCreateInfo &imageInfo, VkMemoryPropertyFlags properties, VkImage &image, diff --git a/engine/xe_device.hpp b/engine/xe_device.hpp index 0906123..42b0751 100755 --- a/engine/xe_device.hpp +++ b/engine/xe_device.hpp @@ -21,7 +21,7 @@ struct QueueFamilyIndices { bool isComplete() { return graphicsFamilyHasValue && presentFamilyHasValue; } }; -class XeDevice { +class Device { public: #ifdef NDEBUG const bool enableValidationLayers = false; @@ -29,13 +29,13 @@ class XeDevice { const bool enableValidationLayers = true; #endif - XeDevice(XeWindow &window); - ~XeDevice(); + Device(Window &window); + ~Device(); - XeDevice(const XeDevice &) = delete; - void operator=(const XeDevice &) = delete; - XeDevice(XeDevice &&) = delete; - XeDevice &operator=(XeDevice &&) = delete; + Device(const Device &) = delete; + void operator=(const Device &) = delete; + Device(Device &&) = delete; + Device &operator=(Device &&) = delete; VkCommandPool getCommandPool() { return commandPool; } VkDevice device() { return device_; } @@ -90,7 +90,7 @@ class XeDevice { VkInstance instance; VkDebugUtilsMessengerEXT debugMessenger; VkPhysicalDevice physicalDevice = VK_NULL_HANDLE; - XeWindow &window; + Window &window; VkCommandPool commandPool; VkDevice device_; diff --git a/engine/xe_engine.cpp b/engine/xe_engine.cpp index e137d11..7a6df71 100644 --- a/engine/xe_engine.cpp +++ b/engine/xe_engine.cpp @@ -8,46 +8,47 @@ namespace xe { -XeEngine::XeEngine(int width, int height, std::string name) : xeWindow{width, height, name}, +Engine::Engine(int width, int height, std::string name) : xeWindow{width, height, name}, xeDevice{xeWindow}, xeRenderer{xeWindow, xeDevice}, xeCamera{} { loadDescriptorPool(); alutInit(0, NULL); + std::cout << "Audio device: " << alcGetString(NULL, ALC_DEFAULT_DEVICE_SPECIFIER) << "\n"; }; -XeEngine::~XeEngine() { +Engine::~Engine() { alutExit(); }; -void XeEngine::loadDescriptorPool() { - xeDescriptorPool = XeDescriptorPool::Builder(xeDevice) - .setMaxSets(XeSwapChain::MAX_FRAMES_IN_FLIGHT) - .addPoolSize(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, XeSwapChain::MAX_FRAMES_IN_FLIGHT) - .addPoolSize(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, XeSwapChain::MAX_FRAMES_IN_FLIGHT) - .addPoolSize(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, XeSwapChain::MAX_FRAMES_IN_FLIGHT) +void Engine::loadDescriptorPool() { + xeDescriptorPool = DescriptorPool::Builder(xeDevice) + .setMaxSets(SwapChain::MAX_FRAMES_IN_FLIGHT) + .addPoolSize(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, SwapChain::MAX_FRAMES_IN_FLIGHT) + .addPoolSize(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, SwapChain::MAX_FRAMES_IN_FLIGHT) + .addPoolSize(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, SwapChain::MAX_FRAMES_IN_FLIGHT) .build(); } -std::shared_ptr<XeModel> XeEngine::loadModelFromFile(const std::string &filename) { - return XeModel::createModelFromFile(xeDevice, filename); +std::shared_ptr<Model> Engine::loadModelFromFile(const std::string &filename) { + return Model::createModelFromFile(xeDevice, filename); } -std::shared_ptr<XeModel> XeEngine::loadModelFromData(std::vector<XeModel::Vertex> vertices, std::vector<uint32_t> indices) { - XeModel::Builder builder{}; +std::shared_ptr<Model> Engine::loadModelFromData(std::vector<Model::Vertex> vertices, std::vector<uint32_t> indices) { + Model::Builder builder{}; builder.vertices = vertices; if(indices.size() > 0) { builder.indices = indices; } - return std::make_shared<XeModel>(xeDevice, builder); + return std::make_shared<Model>(xeDevice, builder); } -std::shared_ptr<XeImage> XeEngine::loadImage(const std::string &filename) { - return std::make_shared<XeImage>(xeDevice, filename); +std::shared_ptr<Image> Engine::loadImage(const std::string &filename) { + return std::make_shared<Image>(xeDevice, filename); } -bool XeEngine::poll() { +bool Engine::poll() { glfwPollEvents(); auto newTime = std::chrono::high_resolution_clock::now(); frameTime = std::chrono::duration<float, std::chrono::seconds::period>(newTime - currentTime).count(); diff --git a/engine/xe_engine.hpp b/engine/xe_engine.hpp index d86c6a9..7f78239 100644 --- a/engine/xe_engine.hpp +++ b/engine/xe_engine.hpp @@ -11,23 +11,23 @@ #include <string> namespace xe { -class XeEngine { +class Engine { public: - XeEngine(int width, int height, std::string name); + Engine(int width, int height, std::string name); - ~XeEngine(); + ~Engine(); - XeEngine(const XeEngine&) = delete; - XeEngine operator=(const XeEngine&) = delete; + Engine(const Engine&) = delete; + Engine operator=(const Engine&) = delete; - XeWindow& getWindow() {return xeWindow;} - XeCamera& getCamera() {return xeCamera;} + Window& getWindow() {return xeWindow;} + Camera& getCamera() {return xeCamera;} - std::shared_ptr<XeModel> loadModelFromFile(const std::string &filename); - std::shared_ptr<XeModel> loadModelFromData(std::vector<XeModel::Vertex> vertices, std::vector<uint32_t> indices); - std::shared_ptr<XeImage> loadImage(const std::string &filename); + std::shared_ptr<Model> loadModelFromFile(const std::string &filename); + std::shared_ptr<Model> loadModelFromData(std::vector<Model::Vertex> vertices, std::vector<uint32_t> indices); + std::shared_ptr<Image> loadImage(const std::string &filename); bool beginFrame() { return xeRenderer.beginFrame(); } void endFrame() { xeRenderer.endFrame(); } @@ -40,19 +40,19 @@ class XeEngine { void loadDescriptorPool(); - XeWindow xeWindow; - XeDevice xeDevice; - XeRenderer xeRenderer; - XeCamera xeCamera; + Window xeWindow; + Device xeDevice; + Renderer xeRenderer; + Camera xeCamera; std::chrono::_V2::system_clock::time_point currentTime; float frameTime; float FOV = 50.f; - std::unique_ptr<XeDescriptorPool> xeDescriptorPool; + std::unique_ptr<DescriptorPool> xeDescriptorPool; - friend class XeRenderSystem; + friend class RenderSystem; }; }
\ No newline at end of file diff --git a/engine/xe_game_object.hpp b/engine/xe_game_object.hpp index 7adbbed..30625f1 100644 --- a/engine/xe_game_object.hpp +++ b/engine/xe_game_object.hpp @@ -21,28 +21,28 @@ struct TransformComponent { }; -class XeGameObject { +class GameObject { public: using id_t = unsigned int; - static XeGameObject createGameObject() { + static GameObject createGameObject() { static id_t currentId = 0; - return XeGameObject(currentId++); + return GameObject(currentId++); } - XeGameObject(const XeGameObject &) = delete; - XeGameObject &operator=(const XeGameObject &) = delete; - XeGameObject(XeGameObject&&) = default; - XeGameObject &operator=(XeGameObject &&) = default; + GameObject(const GameObject &) = delete; + GameObject &operator=(const GameObject &) = delete; + GameObject(GameObject&&) = default; + GameObject &operator=(GameObject &&) = default; id_t getId() { return id; } - std::shared_ptr<XeModel> model{}; + std::shared_ptr<Model> model{}; glm::vec3 color{}; TransformComponent transform; private: - XeGameObject(id_t objId) : id{objId} {} + GameObject(id_t objId) : id{objId} {} id_t id; }; diff --git a/engine/xe_image.cpp b/engine/xe_image.cpp index 26e35f2..8b6065c 100644 --- a/engine/xe_image.cpp +++ b/engine/xe_image.cpp @@ -10,18 +10,18 @@ namespace xe { -XeImage::XeImage(XeDevice &xeDevice, const std::string &filename) : xeDevice{xeDevice} { +Image::Image(Device &xeDevice, const std::string &filename) : xeDevice{xeDevice} { createTextureImage(filename); createTextureImageView(); } -XeImage::~XeImage() { +Image::~Image() { vkDestroyImage(xeDevice.device(), textureImage, nullptr); vkFreeMemory(xeDevice.device(), textureImageMemory, nullptr); vkDestroyImageView(xeDevice.device(), textureImageView, nullptr); } -void XeImage::createTextureImage(const std::string &filename) { +void Image::createTextureImage(const std::string &filename) { int texWidth, texHeight, texChannels; stbi_uc* pixels = stbi_load(filename.c_str(), &texWidth, &texHeight, &texChannels, STBI_rgb_alpha); VkDeviceSize imageSize = texWidth * texHeight * 4; @@ -59,7 +59,7 @@ void XeImage::createTextureImage(const std::string &filename) { } -void XeImage::createImage(uint32_t width, uint32_t height, VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage, VkMemoryPropertyFlags properties, VkImage& image, VkDeviceMemory& imageMemory) { +void Image::createImage(uint32_t width, uint32_t height, VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage, VkMemoryPropertyFlags properties, VkImage& image, VkDeviceMemory& imageMemory) { VkImageCreateInfo imageInfo{}; imageInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; @@ -95,7 +95,7 @@ void XeImage::createImage(uint32_t width, uint32_t height, VkFormat format, VkIm vkBindImageMemory(xeDevice.device(), image, imageMemory, 0); } -void XeImage::transitionImageLayout(VkImage image, VkFormat format, VkImageLayout oldLayout, VkImageLayout newLayout) { +void Image::transitionImageLayout(VkImage image, VkFormat format, VkImageLayout oldLayout, VkImageLayout newLayout) { VkCommandBuffer commandBuffer = xeDevice.beginSingleTimeCommands(); VkImageMemoryBarrier barrier{}; @@ -142,7 +142,7 @@ void XeImage::transitionImageLayout(VkImage image, VkFormat format, VkImageLayou xeDevice.endSingleTimeCommands(commandBuffer); } -void XeImage::copyBufferToImage(VkBuffer buffer, VkImage image, uint32_t width, uint32_t height) { +void Image::copyBufferToImage(VkBuffer buffer, VkImage image, uint32_t width, uint32_t height) { VkCommandBuffer commandBuffer = xeDevice.beginSingleTimeCommands(); VkBufferImageCopy region{}; @@ -165,7 +165,7 @@ void XeImage::copyBufferToImage(VkBuffer buffer, VkImage image, uint32_t width, xeDevice.endSingleTimeCommands(commandBuffer); } -void XeImage::createTextureImageView() { +void Image::createTextureImageView() { VkImageViewCreateInfo viewInfo{}; viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO; viewInfo.image = textureImage; diff --git a/engine/xe_image.hpp b/engine/xe_image.hpp index 7d514d9..a8e50ba 100644 --- a/engine/xe_image.hpp +++ b/engine/xe_image.hpp @@ -6,15 +6,15 @@ namespace xe { -class XeImage { +class Image { public: - XeImage(XeDevice &xeDevice, const std::string &filename); - ~XeImage(); + Image(Device &xeDevice, const std::string &filename); + ~Image(); - XeImage(const XeImage&) = delete; - XeImage operator=(const XeImage&) = delete; + Image(const Image&) = delete; + Image operator=(const Image&) = delete; private: @@ -24,13 +24,13 @@ class XeImage { void copyBufferToImage(VkBuffer buffer, VkImage image, uint32_t width, uint32_t height); void createTextureImageView(); - XeDevice &xeDevice; + Device &xeDevice; VkImage textureImage; VkImageView textureImageView; VkDeviceMemory textureImageMemory; - friend class XeRenderSystem; + friend class RenderSystem; }; diff --git a/engine/xe_model.cpp b/engine/xe_model.cpp index e6835a6..df210d8 100644 --- a/engine/xe_model.cpp +++ b/engine/xe_model.cpp @@ -13,8 +13,8 @@ namespace std { template<> -struct hash<xe::XeModel::Vertex> { - size_t operator()(xe::XeModel::Vertex const &vertex) const { +struct hash<xe::Model::Vertex> { + size_t operator()(xe::Model::Vertex const &vertex) const { size_t seed = 0; xe::hashCombine(seed, vertex.position, vertex.normal, vertex.uv); return seed; @@ -24,26 +24,26 @@ struct hash<xe::XeModel::Vertex> { namespace xe { -XeModel::XeModel(XeDevice &device, const XeModel::Builder &builder) : xeDevice{device} { +Model::Model(Device &device, const Model::Builder &builder) : xeDevice{device} { createVertexBuffers(builder.vertices); createIndexBuffers(builder.indices); } -XeModel::~XeModel() {} +Model::~Model() {} -std::unique_ptr<XeModel> XeModel::createModelFromFile(XeDevice &device, const std::string &filepath) { +std::unique_ptr<Model> Model::createModelFromFile(Device &device, const std::string &filepath) { Builder builder{}; builder.loadModel(filepath); - return std::make_unique<XeModel>(device, builder); + return std::make_unique<Model>(device, builder); } -void XeModel::createVertexBuffers(const std::vector<Vertex> &vertices) { +void Model::createVertexBuffers(const std::vector<Vertex> &vertices) { vertexCount = static_cast<uint32_t>(vertices.size()); assert(vertexCount >= 3 && "Vertex count must be atleast 3"); VkDeviceSize bufferSize = sizeof(vertices[0]) * vertexCount; uint32_t vertexSize = sizeof(vertices[0]); - XeBuffer stagingBuffer { + Buffer stagingBuffer { xeDevice, vertexSize, vertexCount, @@ -54,7 +54,7 @@ void XeModel::createVertexBuffers(const std::vector<Vertex> &vertices) { stagingBuffer.map(); stagingBuffer.writeToBuffer((void *)vertices.data()); - vertexBuffer = std::make_unique<XeBuffer>( + vertexBuffer = std::make_unique<Buffer>( xeDevice, vertexSize, vertexCount, @@ -65,7 +65,7 @@ void XeModel::createVertexBuffers(const std::vector<Vertex> &vertices) { xeDevice.copyBuffer(stagingBuffer.getBuffer(), vertexBuffer->getBuffer(), bufferSize); } -void XeModel::createIndexBuffers(const std::vector<uint32_t> &indices) { +void Model::createIndexBuffers(const std::vector<uint32_t> &indices) { indexCount = static_cast<uint32_t>(indices.size()); hasIndexBuffer = indexCount > 0; @@ -76,7 +76,7 @@ void XeModel::createIndexBuffers(const std::vector<uint32_t> &indices) { VkDeviceSize bufferSize = sizeof(indices[0]) * indexCount; uint32_t indexSize = sizeof(indices[0]); - XeBuffer stagingBuffer { + Buffer stagingBuffer { xeDevice, indexSize, indexCount, @@ -87,7 +87,7 @@ void XeModel::createIndexBuffers(const std::vector<uint32_t> &indices) { stagingBuffer.map(); stagingBuffer.writeToBuffer((void *)indices.data()); - indexBuffer = std::make_unique<XeBuffer>( + indexBuffer = std::make_unique<Buffer>( xeDevice, indexSize, indexCount, @@ -98,7 +98,7 @@ void XeModel::createIndexBuffers(const std::vector<uint32_t> &indices) { xeDevice.copyBuffer(stagingBuffer.getBuffer(), indexBuffer->getBuffer(), bufferSize); } -void XeModel::bind(VkCommandBuffer commandBuffer) { +void Model::bind(VkCommandBuffer commandBuffer) { VkBuffer buffers[] = {vertexBuffer->getBuffer()}; VkDeviceSize offsets[] = {0}; vkCmdBindVertexBuffers(commandBuffer, 0, 1, buffers, offsets); @@ -108,7 +108,7 @@ void XeModel::bind(VkCommandBuffer commandBuffer) { } } -void XeModel::draw(VkCommandBuffer commandBuffer) { +void Model::draw(VkCommandBuffer commandBuffer) { if (hasIndexBuffer) { vkCmdDrawIndexed(commandBuffer, indexCount, 1, 0, 0, 0); } else { @@ -116,7 +116,7 @@ void XeModel::draw(VkCommandBuffer commandBuffer) { } } -std::vector<VkVertexInputBindingDescription> XeModel::Vertex::getBindingDescriptions() { +std::vector<VkVertexInputBindingDescription> Model::Vertex::getBindingDescriptions() { std::vector<VkVertexInputBindingDescription> bindingDescriptions(1); bindingDescriptions[0].binding = 0; bindingDescriptions[0].stride = sizeof(Vertex); @@ -124,7 +124,7 @@ std::vector<VkVertexInputBindingDescription> XeModel::Vertex::getBindingDescript return bindingDescriptions; } -std::vector<VkVertexInputAttributeDescription> XeModel::Vertex::getAttributeDescriptions() { +std::vector<VkVertexInputAttributeDescription> Model::Vertex::getAttributeDescriptions() { std::vector<VkVertexInputAttributeDescription> attributeDescptions{}; attributeDescptions.push_back({0, 0, VK_FORMAT_R32G32B32_SFLOAT, offsetof(Vertex, position)}); @@ -135,7 +135,7 @@ std::vector<VkVertexInputAttributeDescription> XeModel::Vertex::getAttributeDesc return attributeDescptions; } -void XeModel::Builder::loadModel(const std::string &filepath) { +void Model::Builder::loadModel(const std::string &filepath) { tinyobj::attrib_t attrib; std::vector<tinyobj::shape_t> shapes; std::vector<tinyobj::material_t> materials; diff --git a/engine/xe_model.hpp b/engine/xe_model.hpp index 2ffe298..fec572f 100644 --- a/engine/xe_model.hpp +++ b/engine/xe_model.hpp @@ -11,7 +11,7 @@ namespace xe { -class XeModel { +class Model { public: struct Vertex { @@ -35,13 +35,13 @@ class XeModel { void loadModel(const std::string &filepath); }; - XeModel(XeDevice &device, const XeModel::Builder &builder); - ~XeModel(); + Model(Device &device, const Model::Builder &builder); + ~Model(); - XeModel(const XeModel &) = delete; - XeModel operator=(const XeModel &) = delete; + Model(const Model &) = delete; + Model operator=(const Model &) = delete; - static std::unique_ptr<XeModel> createModelFromFile(XeDevice &device, const std::string &filepath); + static std::unique_ptr<Model> createModelFromFile(Device &device, const std::string &filepath); void bind(VkCommandBuffer commandBuffer); void draw(VkCommandBuffer commandBuffer); @@ -50,13 +50,13 @@ class XeModel { void createVertexBuffers(const std::vector<Vertex> &vertices); void createIndexBuffers(const std::vector<uint32_t> &indices); - XeDevice &xeDevice; + Device &xeDevice; - std::unique_ptr<XeBuffer> vertexBuffer; + std::unique_ptr<Buffer> vertexBuffer; uint32_t vertexCount; bool hasIndexBuffer = false; - std::unique_ptr<XeBuffer> indexBuffer; + std::unique_ptr<Buffer> indexBuffer; uint32_t indexCount; }; diff --git a/engine/xe_pipeline.cpp b/engine/xe_pipeline.cpp index d06d09b..3f407ec 100755 --- a/engine/xe_pipeline.cpp +++ b/engine/xe_pipeline.cpp @@ -12,8 +12,8 @@ namespace xe { - XePipeline::XePipeline( - XeDevice &device, + Pipeline::Pipeline( + Device &device, const std::string& vertFilepath, const std::string& fragFilepath, const PipelineConfigInfo& configInfo) @@ -21,13 +21,13 @@ namespace xe { createGraphicsPipeline(vertFilepath, fragFilepath, configInfo); } - XePipeline::~XePipeline() { + Pipeline::~Pipeline() { vkDestroyShaderModule(xeDevice.device(), vertShaderModule, nullptr); vkDestroyShaderModule(xeDevice.device(), fragShaderModule, nullptr); vkDestroyPipeline(xeDevice.device(), graphicsPipeline, nullptr); } - std::vector<char> XePipeline::readFile(const std::string& filepath) { + std::vector<char> Pipeline::readFile(const std::string& filepath) { std::ifstream file{filepath, std::ios::ate | std::ios::binary}; @@ -45,7 +45,7 @@ namespace xe { return buffer; }; - void XePipeline::createGraphicsPipeline( + void Pipeline::createGraphicsPipeline( const std::string& vertFilePath, const std::string& fragFilepath, const PipelineConfigInfo& configInfo) { @@ -78,8 +78,8 @@ namespace xe { shaderStages[1].pNext = nullptr; shaderStages[1].pSpecializationInfo = nullptr; - auto bindingDescriptions = XeModel::Vertex::getBindingDescriptions(); - auto attributeDescptions = XeModel::Vertex::getAttributeDescriptions(); + auto bindingDescriptions = Model::Vertex::getBindingDescriptions(); + auto attributeDescptions = Model::Vertex::getAttributeDescriptions(); VkPipelineVertexInputStateCreateInfo vertexInputInfo{}; vertexInputInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; vertexInputInfo.vertexAttributeDescriptionCount = static_cast<uint32_t>(attributeDescptions.size()); @@ -112,7 +112,7 @@ namespace xe { } } - void XePipeline::createShaderModule(const std::vector<char>& code, VkShaderModule* shaderModule) { + void Pipeline::createShaderModule(const std::vector<char>& code, VkShaderModule* shaderModule) { VkShaderModuleCreateInfo createInfo{}; createInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO; createInfo.codeSize = code.size(); @@ -124,11 +124,11 @@ namespace xe { } - void XePipeline::bind(VkCommandBuffer commandBuffer) { + void Pipeline::bind(VkCommandBuffer commandBuffer) { vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, graphicsPipeline); } - void XePipeline::defaultPipelineConfigInfo(PipelineConfigInfo& configInfo) { + void Pipeline::defaultPipelineConfigInfo(PipelineConfigInfo& configInfo) { configInfo.inputAssemblyInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; configInfo.inputAssemblyInfo.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; diff --git a/engine/xe_pipeline.hpp b/engine/xe_pipeline.hpp index 06bcf0f..cb601e0 100755 --- a/engine/xe_pipeline.hpp +++ b/engine/xe_pipeline.hpp @@ -27,17 +27,17 @@ struct PipelineConfigInfo { uint32_t subpass = 0; }; -class XePipeline { +class Pipeline { public: - XePipeline( - XeDevice &device, + Pipeline( + Device &device, const std::string& vertFilepath, const std::string& fragFilepath, const PipelineConfigInfo& configInfo); - ~XePipeline(); + ~Pipeline(); - XePipeline(const XePipeline&) = delete; - XePipeline operator=(const XePipeline&) = delete; + Pipeline(const Pipeline&) = delete; + Pipeline operator=(const Pipeline&) = delete; void bind(VkCommandBuffer commandBuffer); static void defaultPipelineConfigInfo(PipelineConfigInfo& configInfo); @@ -52,7 +52,7 @@ class XePipeline { void createShaderModule(const std::vector<char>& code, VkShaderModule* shaderModule); - XeDevice& xeDevice; + Device& xeDevice; VkPipeline graphicsPipeline; VkShaderModule vertShaderModule; VkShaderModule fragShaderModule; diff --git a/engine/xe_render_system.cpp b/engine/xe_render_system.cpp index 1e638ad..4f2aadd 100644 --- a/engine/xe_render_system.cpp +++ b/engine/xe_render_system.cpp @@ -16,12 +16,12 @@ namespace xe { -XeRenderSystem::XeRenderSystem( - XeEngine &xeEngine, +RenderSystem::RenderSystem( + Engine &xeEngine, std::string vert, std::string frag, std::map<uint32_t, uint32_t> uniformBindings, - std::map<uint32_t, XeImage*> imageBindings, + std::map<uint32_t, Image*> imageBindings, uint32_t pushCunstantDataSize, bool cullingEnabled ) : xeDevice{xeEngine.xeDevice}, @@ -39,12 +39,12 @@ XeRenderSystem::XeRenderSystem( } -XeRenderSystem::~XeRenderSystem() { +RenderSystem::~RenderSystem() { vkDestroyPipelineLayout(xeDevice.device(), pipelineLayout, nullptr); vkDestroySampler(xeDevice.device(), textureSampler, nullptr); }; -void XeRenderSystem::createTextureSampler() { +void RenderSystem::createTextureSampler() { VkSamplerCreateInfo samplerInfo{}; samplerInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO; samplerInfo.magFilter = VK_FILTER_LINEAR; @@ -67,8 +67,8 @@ void XeRenderSystem::createTextureSampler() { } } -void XeRenderSystem::createDescriptorSetLayout() { - XeDescriptorSetLayout::Builder builder{xeDevice}; +void RenderSystem::createDescriptorSetLayout() { + DescriptorSetLayout::Builder builder{xeDevice}; for ( const auto &[binding, size]: uniformBindings) { builder.addBinding(binding, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_SHADER_STAGE_VERTEX_BIT, nullptr); @@ -81,14 +81,14 @@ void XeRenderSystem::createDescriptorSetLayout() { xeDescriptorSetLayout = builder.build(); } -void XeRenderSystem::createUniformBuffers() { +void RenderSystem::createUniformBuffers() { for ( const auto &[binding, bufferSize]: uniformBindings) { - uboBuffers[binding] = std::vector<std::unique_ptr<XeBuffer>>(XeSwapChain::MAX_FRAMES_IN_FLIGHT); + uboBuffers[binding] = std::vector<std::unique_ptr<Buffer>>(SwapChain::MAX_FRAMES_IN_FLIGHT); for (int i = 0; i < uboBuffers[binding].size(); i++) { - uboBuffers[binding][i] = std::make_unique<XeBuffer>( + uboBuffers[binding][i] = std::make_unique<Buffer>( xeDevice, bufferSize, - XeSwapChain::MAX_FRAMES_IN_FLIGHT, + SwapChain::MAX_FRAMES_IN_FLIGHT, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT); uboBuffers[binding][i]->map(); @@ -96,18 +96,18 @@ void XeRenderSystem::createUniformBuffers() { } } -void XeRenderSystem::createDescriptorSets() { +void RenderSystem::createDescriptorSets() { - descriptorSets = std::vector<VkDescriptorSet>(XeSwapChain::MAX_FRAMES_IN_FLIGHT); + descriptorSets = std::vector<VkDescriptorSet>(SwapChain::MAX_FRAMES_IN_FLIGHT); for (int i = 0; i < descriptorSets.size(); i++) { updateDescriptorSet(i, true); } } -void XeRenderSystem::updateDescriptorSet(int frameIndex, bool allocate) { +void RenderSystem::updateDescriptorSet(int frameIndex, bool allocate) { - XeDescriptorWriter writer{*xeDescriptorSetLayout, *xeDescriptorPool}; + DescriptorWriter writer{*xeDescriptorSetLayout, *xeDescriptorPool}; std::vector<VkDescriptorBufferInfo> bufferInfos{}; @@ -135,7 +135,7 @@ void XeRenderSystem::updateDescriptorSet(int frameIndex, bool allocate) { } -void XeRenderSystem::createPipelineLayout() { +void RenderSystem::createPipelineLayout() { VkPushConstantRange pushConstantRange; pushConstantRange.stageFlags = VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT; @@ -164,17 +164,17 @@ void XeRenderSystem::createPipelineLayout() { } -void XeRenderSystem::createPipeline(VkRenderPass renderPass, std::string vert, std::string frag, bool cullingEnabled) { +void RenderSystem::createPipeline(VkRenderPass renderPass, std::string vert, std::string frag, bool cullingEnabled) { assert(pipelineLayout != nullptr && "Cannot create pipeline before pipeline layout"); PipelineConfigInfo pipelineConfig{}; - XePipeline::defaultPipelineConfigInfo(pipelineConfig); + Pipeline::defaultPipelineConfigInfo(pipelineConfig); if (cullingEnabled) { pipelineConfig.rasterizationInfo.cullMode = VK_CULL_MODE_BACK_BIT; } pipelineConfig.renderPass = renderPass; pipelineConfig.pipelineLayout = pipelineLayout; - xePipeline = std::make_unique<XePipeline>( + xePipeline = std::make_unique<Pipeline>( xeDevice, vert, frag, @@ -182,7 +182,7 @@ void XeRenderSystem::createPipeline(VkRenderPass renderPass, std::string vert, s ); } -void XeRenderSystem::start() { +void RenderSystem::start() { xeRenderer.beginSwapChainRenderPass(xeRenderer.getCurrentCommandBuffer()); xePipeline->bind(xeRenderer.getCurrentCommandBuffer()); if(descriptorSets.size() > 0) { @@ -200,7 +200,7 @@ void XeRenderSystem::start() { } } -void XeRenderSystem::loadPushConstant(void *pushConstantData) { +void RenderSystem::loadPushConstant(void *pushConstantData) { vkCmdPushConstants( xeRenderer.getCurrentCommandBuffer(), pipelineLayout, @@ -210,23 +210,23 @@ void XeRenderSystem::loadPushConstant(void *pushConstantData) { pushConstantData); } -void XeRenderSystem::loadUniformObject(uint32_t binding, void *uniformBufferData) { +void RenderSystem::loadUniformObject(uint32_t binding, void *uniformBufferData) { uboBuffers[binding][xeRenderer.getFrameIndex()]->writeToBuffer(uniformBufferData); } -void XeRenderSystem::loadTexture(uint32_t binding, XeImage *image) { +void RenderSystem::loadTexture(uint32_t binding, Image *image) { imageBindings[binding] = image; updateDescriptorSet(xeRenderer.getFrameIndex(), false); } -void XeRenderSystem::render(XeGameObject &gameObject) { +void RenderSystem::render(GameObject &gameObject) { gameObject.model->bind(xeRenderer.getCurrentCommandBuffer()); gameObject.model->draw(xeRenderer.getCurrentCommandBuffer()); } -void XeRenderSystem::stop() { +void RenderSystem::stop() { xeRenderer.endSwapChainRenderPass(xeRenderer.getCurrentCommandBuffer()); } diff --git a/engine/xe_render_system.hpp b/engine/xe_render_system.hpp index a8b4145..2b29642 100644 --- a/engine/xe_render_system.hpp +++ b/engine/xe_render_system.hpp @@ -14,12 +14,12 @@ namespace xe { -class XeRenderSystem { +class RenderSystem { public: class Builder { public: - Builder(XeEngine &xeEngine, std::string vert, std::string frag) : xeEngine{xeEngine}, vert{vert}, frag{frag} {} + Builder(Engine &xeEngine, std::string vert, std::string frag) : xeEngine{xeEngine}, vert{vert}, frag{frag} {} Builder& addPushConstant(uint32_t size) { pushCunstantDataSize = size; @@ -31,7 +31,7 @@ class XeRenderSystem { return *this; } - Builder& addTextureBinding(uint32_t binding, XeImage* image) { + Builder& addTextureBinding(uint32_t binding, Image* image) { imageBindings[binding] = image; return *this; } @@ -41,14 +41,14 @@ class XeRenderSystem { return *this; } - std::unique_ptr<XeRenderSystem> build() { - return std::make_unique<XeRenderSystem>(xeEngine, std::move(vert), std::move(frag), std::move(uniformBindings), std::move(imageBindings), std::move(pushCunstantDataSize), std::move(cullingEnabled)); + std::unique_ptr<RenderSystem> build() { + return std::make_unique<RenderSystem>(xeEngine, std::move(vert), std::move(frag), std::move(uniformBindings), std::move(imageBindings), std::move(pushCunstantDataSize), std::move(cullingEnabled)); } private: std::map<uint32_t, uint32_t> uniformBindings{}; - std::map<uint32_t, XeImage*> imageBindings{}; + std::map<uint32_t, Image*> imageBindings{}; uint32_t pushCunstantDataSize{0}; std::string vert; @@ -56,29 +56,29 @@ class XeRenderSystem { bool cullingEnabled{false}; - XeEngine &xeEngine; + Engine &xeEngine; }; - XeRenderSystem( - XeEngine &xeEngine, + RenderSystem( + Engine &xeEngine, std::string vert, std::string frag, std::map<uint32_t, uint32_t> uniformBindings, - std::map<uint32_t, XeImage*> imageBindings, + std::map<uint32_t, Image*> imageBindings, uint32_t pushCunstantDataSize, bool cullingEnabled ); - ~XeRenderSystem(); + ~RenderSystem(); - XeRenderSystem(const XeRenderSystem &) = delete; - XeRenderSystem operator=(const XeRenderSystem &) = delete; + RenderSystem(const RenderSystem &) = delete; + RenderSystem operator=(const RenderSystem &) = delete; void start(); void loadPushConstant(void *pushConstantData); void loadUniformObject(uint32_t binding, void *uniformBufferData); - void loadTexture(uint32_t binding, XeImage *image); - void render(XeGameObject &gameObject); + void loadTexture(uint32_t binding, Image *image); + void render(GameObject &gameObject); void stop(); private: @@ -95,12 +95,12 @@ class XeRenderSystem { bool boundDescriptor{false}; - XeDevice& xeDevice; - XeRenderer& xeRenderer; + Device& xeDevice; + Renderer& xeRenderer; - std::map<uint32_t, std::vector<std::unique_ptr<XeBuffer>>> uboBuffers{}; + std::map<uint32_t, std::vector<std::unique_ptr<Buffer>>> uboBuffers{}; std::map<uint32_t, uint32_t> uniformBindings; - std::map<uint32_t, XeImage*> imageBindings; + std::map<uint32_t, Image*> imageBindings; std::vector<VkDescriptorSet> descriptorSets; uint32_t pushCunstantDataSize; @@ -108,9 +108,9 @@ class XeRenderSystem { VkSampler textureSampler; VkPipelineLayout pipelineLayout; - std::unique_ptr<XePipeline> xePipeline; - std::unique_ptr<XeDescriptorPool> &xeDescriptorPool; - std::unique_ptr<XeDescriptorSetLayout> xeDescriptorSetLayout; + std::unique_ptr<Pipeline> xePipeline; + std::unique_ptr<DescriptorPool> &xeDescriptorPool; + std::unique_ptr<DescriptorSetLayout> xeDescriptorSetLayout; }; diff --git a/engine/xe_renderer.cpp b/engine/xe_renderer.cpp index 1714e46..2cc3303 100644 --- a/engine/xe_renderer.cpp +++ b/engine/xe_renderer.cpp @@ -14,14 +14,14 @@ namespace xe { -XeRenderer::XeRenderer(XeWindow& window, XeDevice& device) : xeWindow{window}, xeDevice{device} { +Renderer::Renderer(Window& window, Device& device) : xeWindow{window}, xeDevice{device} { recreateSwapChain(); createCommandBuffers(); } -XeRenderer::~XeRenderer() { freeCommandBuffers(); } +Renderer::~Renderer() { freeCommandBuffers(); } -void XeRenderer::recreateSwapChain() { +void Renderer::recreateSwapChain() { auto extent = xeWindow.getExtent(); while (extent.width == 0 || extent.height == 0) { extent = xeWindow.getExtent(); @@ -31,10 +31,10 @@ void XeRenderer::recreateSwapChain() { vkDeviceWaitIdle(xeDevice.device()); if(xeSwapChain == nullptr) { - xeSwapChain = std::make_unique<XeSwapChain>(xeDevice, extent); + xeSwapChain = std::make_unique<SwapChain>(xeDevice, extent); } else { - std::shared_ptr<XeSwapChain> oldSwapChain = std::move(xeSwapChain); - xeSwapChain = std::make_unique<XeSwapChain>(xeDevice, extent, oldSwapChain); + std::shared_ptr<SwapChain> oldSwapChain = std::move(xeSwapChain); + xeSwapChain = std::make_unique<SwapChain>(xeDevice, extent, oldSwapChain); if(!oldSwapChain->compareSwapFormats(*xeSwapChain.get())) { throw std::runtime_error("Swap chain image (or depth) format has changed"); @@ -45,9 +45,9 @@ void XeRenderer::recreateSwapChain() { // we'll come back to this in just a moment } -void XeRenderer::createCommandBuffers() { +void Renderer::createCommandBuffers() { - commandBuffers.resize(XeSwapChain::MAX_FRAMES_IN_FLIGHT); + commandBuffers.resize(SwapChain::MAX_FRAMES_IN_FLIGHT); VkCommandBufferAllocateInfo allocInfo{}; allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; @@ -61,7 +61,7 @@ void XeRenderer::createCommandBuffers() { } -void XeRenderer::freeCommandBuffers() { +void Renderer::freeCommandBuffers() { vkFreeCommandBuffers( xeDevice.device(), xeDevice.getCommandPool(), @@ -70,7 +70,7 @@ void XeRenderer::freeCommandBuffers() { commandBuffers.clear(); } -VkCommandBuffer XeRenderer::beginFrame() { +VkCommandBuffer Renderer::beginFrame() { assert(!isFrameStarted && "Can't acll beingFrame while already in progress"); auto result = xeSwapChain->acquireNextImage(¤tImageIndex); @@ -97,7 +97,7 @@ VkCommandBuffer XeRenderer::beginFrame() { return commandBuffer; } -void XeRenderer::endFrame() { +void Renderer::endFrame() { assert(isFrameStarted && "Can't call endFrame while frame is not in progress"); auto commandBuffer = getCurrentCommandBuffer(); if(vkEndCommandBuffer(commandBuffer) != VK_SUCCESS) { @@ -111,10 +111,10 @@ void XeRenderer::endFrame() { } isFrameStarted = false; - currentFrameIndex = (currentFrameIndex + 1) % XeSwapChain::MAX_FRAMES_IN_FLIGHT; + currentFrameIndex = (currentFrameIndex + 1) % SwapChain::MAX_FRAMES_IN_FLIGHT; } -void XeRenderer::beginSwapChainRenderPass(VkCommandBuffer commandBuffer){ +void Renderer::beginSwapChainRenderPass(VkCommandBuffer commandBuffer){ assert(isFrameStarted && "Can't call beginSwapChainRenderPass while frame is not in progress"); assert(commandBuffer == getCurrentCommandBuffer() && "Can't begin render pass on command buffer from a different frame"); @@ -146,7 +146,7 @@ void XeRenderer::beginSwapChainRenderPass(VkCommandBuffer commandBuffer){ vkCmdSetScissor(commandBuffer, 0, 1, &scissor); } -void XeRenderer::endSwapChainRenderPass(VkCommandBuffer commandBuffer){ +void Renderer::endSwapChainRenderPass(VkCommandBuffer commandBuffer){ assert(isFrameStarted && "Can't call endSwapChainRenderPass while frame is not in progress"); assert(commandBuffer == getCurrentCommandBuffer() && "Can't end render pass on command buffer from a different frame"); diff --git a/engine/xe_renderer.hpp b/engine/xe_renderer.hpp index 321a4e3..58b782d 100644 --- a/engine/xe_renderer.hpp +++ b/engine/xe_renderer.hpp @@ -10,14 +10,14 @@ #include <cassert> namespace xe { -class XeRenderer { +class Renderer { public: - XeRenderer(XeWindow &window, XeDevice &device); - ~XeRenderer(); + Renderer(Window &window, Device &device); + ~Renderer(); - XeRenderer(const XeRenderer &) = delete; - XeRenderer operator=(const XeRenderer &) = delete; + Renderer(const Renderer &) = delete; + Renderer operator=(const Renderer &) = delete; VkRenderPass getSwapChainRenderPass() const { return xeSwapChain->getRenderPass(); } float getAspectRatio() const { return xeSwapChain->extentAspectRatio(); } @@ -43,9 +43,9 @@ class XeRenderer { void freeCommandBuffers(); void recreateSwapChain(); - XeWindow& xeWindow; - XeDevice& xeDevice; - std::unique_ptr<XeSwapChain> xeSwapChain; + Window& xeWindow; + Device& xeDevice; + std::unique_ptr<SwapChain> xeSwapChain; std::vector<VkCommandBuffer> commandBuffers; uint32_t currentImageIndex; diff --git a/engine/xe_sound.cpp b/engine/xe_sound.cpp index 07d8e7b..e458356 100644 --- a/engine/xe_sound.cpp +++ b/engine/xe_sound.cpp @@ -6,7 +6,7 @@ namespace xe { -XeSound::XeSound(const std::string& filename) { +Sound::Sound(const std::string& filename) { buffer = alutCreateBufferFromFile(filename.c_str()); @@ -21,43 +21,43 @@ XeSound::XeSound(const std::string& filename) { } -XeSound::~XeSound() { +Sound::~Sound() { alDeleteSources(1, &source); alDeleteBuffers(1, &buffer); } -void XeSound::play() { +void Sound::play() { stop(); alSourcePlay(source); }; -void XeSound::stop() { +void Sound::stop() { alSourceStop(source); }; -void XeSound::pause() { +void Sound::pause() { alSourcePause(source); }; -void XeSound::resume() { +void Sound::resume() { alSourcePlay(source); }; -bool XeSound::isPlaying() { +bool Sound::isPlaying() { ALint playing; alGetSourcei(source, AL_SOURCE_STATE, &playing); return playing == AL_PLAYING; }; -void XeSound::setPosition(glm::vec3 position) { +void Sound::setPosition(glm::vec3 position) { alSource3f(source, AL_POSITION, position.x, position.y, position.z); }; -void XeSound::setLooping(bool looping) { +void Sound::setLooping(bool looping) { alSourcei(source, AL_LOOPING, looping ? 1 : 0); }; -void XeSound::setVolume(float volume) { +void Sound::setVolume(float volume) { alSourcef(source, AL_GAIN, volume); } diff --git a/engine/xe_sound.hpp b/engine/xe_sound.hpp index b2a7a14..4b14589 100644 --- a/engine/xe_sound.hpp +++ b/engine/xe_sound.hpp @@ -11,12 +11,12 @@ namespace xe { -class XeSound { +class Sound { public: - XeSound(const std::string& filename); - ~XeSound(); + Sound(const std::string& filename); + ~Sound(); void play(); void stop(); diff --git a/engine/xe_swap_chain.cpp b/engine/xe_swap_chain.cpp index c7a0345..6f15fda 100755 --- a/engine/xe_swap_chain.cpp +++ b/engine/xe_swap_chain.cpp @@ -11,21 +11,21 @@ namespace xe { -bool XeSwapChain::initialSwapChainCreated = false; +bool SwapChain::initialSwapChainCreated = false; -XeSwapChain::XeSwapChain(XeDevice &deviceRef, VkExtent2D extent) +SwapChain::SwapChain(Device &deviceRef, VkExtent2D extent) : device{deviceRef}, windowExtent{extent} { init(); } -XeSwapChain::XeSwapChain(XeDevice &deviceRef, VkExtent2D extent, std::shared_ptr<XeSwapChain> previous) +SwapChain::SwapChain(Device &deviceRef, VkExtent2D extent, std::shared_ptr<SwapChain> previous) : device{deviceRef}, windowExtent{extent}, oldSwapChain{previous} { init(); oldSwapChain = nullptr; } -void XeSwapChain::init() { +void SwapChain::init() { createSwapChain(); createImageViews(); createRenderPass(); @@ -35,7 +35,7 @@ void XeSwapChain::init() { initialSwapChainCreated = true; } -XeSwapChain::~XeSwapChain() { +SwapChain::~SwapChain() { for (auto imageView : swapChainImageViews) { vkDestroyImageView(device.device(), imageView, nullptr); } @@ -65,7 +65,7 @@ XeSwapChain::~XeSwapChain() { } } -VkResult XeSwapChain::acquireNextImage(uint32_t *imageIndex) { +VkResult SwapChain::acquireNextImage(uint32_t *imageIndex) { vkWaitForFences( device.device(), 1, @@ -84,7 +84,7 @@ VkResult XeSwapChain::acquireNextImage(uint32_t *imageIndex) { return result; } -VkResult XeSwapChain::submitCommandBuffers( +VkResult SwapChain::submitCommandBuffers( const VkCommandBuffer *buffers, uint32_t *imageIndex) { if (imagesInFlight[*imageIndex] != VK_NULL_HANDLE) { vkWaitForFences(device.device(), 1, &imagesInFlight[*imageIndex], VK_TRUE, UINT64_MAX); @@ -132,7 +132,7 @@ VkResult XeSwapChain::submitCommandBuffers( return result; } -void XeSwapChain::createSwapChain() { +void SwapChain::createSwapChain() { SwapChainSupportDetails swapChainSupport = device.getSwapChainSupport(); VkSurfaceFormatKHR surfaceFormat = chooseSwapSurfaceFormat(swapChainSupport.formats); @@ -189,7 +189,7 @@ void XeSwapChain::createSwapChain() { swapChainExtent = extent; } -void XeSwapChain::createImageViews() { +void SwapChain::createImageViews() { swapChainImageViews.resize(swapChainImages.size()); for (size_t i = 0; i < swapChainImages.size(); i++) { VkImageViewCreateInfo viewInfo{}; @@ -210,7 +210,7 @@ void XeSwapChain::createImageViews() { } } -void XeSwapChain::createRenderPass() { +void SwapChain::createRenderPass() { VkAttachmentDescription depthAttachment{}; depthAttachment.format = findDepthFormat(); depthAttachment.samples = VK_SAMPLE_COUNT_1_BIT; @@ -271,7 +271,7 @@ void XeSwapChain::createRenderPass() { } } -void XeSwapChain::createFramebuffers() { +void SwapChain::createFramebuffers() { swapChainFramebuffers.resize(imageCount()); for (size_t i = 0; i < imageCount(); i++) { std::array<VkImageView, 2> attachments = {swapChainImageViews[i], depthImageViews[i]}; @@ -296,7 +296,7 @@ void XeSwapChain::createFramebuffers() { } } -void XeSwapChain::createDepthResources() { +void SwapChain::createDepthResources() { VkFormat depthFormat = findDepthFormat(); swapChainDepthFormat = depthFormat; VkExtent2D swapChainExtent = getSwapChainExtent(); @@ -345,7 +345,7 @@ void XeSwapChain::createDepthResources() { } } -void XeSwapChain::createSyncObjects() { +void SwapChain::createSyncObjects() { imageAvailableSemaphores.resize(MAX_FRAMES_IN_FLIGHT); renderFinishedSemaphores.resize(MAX_FRAMES_IN_FLIGHT); inFlightFences.resize(MAX_FRAMES_IN_FLIGHT); @@ -369,7 +369,7 @@ void XeSwapChain::createSyncObjects() { } } -VkSurfaceFormatKHR XeSwapChain::chooseSwapSurfaceFormat( +VkSurfaceFormatKHR SwapChain::chooseSwapSurfaceFormat( const std::vector<VkSurfaceFormatKHR> &availableFormats) { for (const auto &availableFormat : availableFormats) { if (availableFormat.format == VK_FORMAT_B8G8R8A8_UNORM && @@ -381,7 +381,7 @@ VkSurfaceFormatKHR XeSwapChain::chooseSwapSurfaceFormat( return availableFormats[0]; } -VkPresentModeKHR XeSwapChain::chooseSwapPresentMode( +VkPresentModeKHR SwapChain::chooseSwapPresentMode( const std::vector<VkPresentModeKHR> &availablePresentModes) { for (const auto &availablePresentMode : availablePresentModes) { if (availablePresentMode == VK_PRESENT_MODE_MAILBOX_KHR) { @@ -404,7 +404,7 @@ VkPresentModeKHR XeSwapChain::chooseSwapPresentMode( return VK_PRESENT_MODE_FIFO_KHR; } -VkExtent2D XeSwapChain::chooseSwapExtent(const VkSurfaceCapabilitiesKHR &capabilities) { +VkExtent2D SwapChain::chooseSwapExtent(const VkSurfaceCapabilitiesKHR &capabilities) { if (capabilities.currentExtent.width != std::numeric_limits<uint32_t>::max()) { return capabilities.currentExtent; } else { @@ -420,7 +420,7 @@ VkExtent2D XeSwapChain::chooseSwapExtent(const VkSurfaceCapabilitiesKHR &capabil } } -VkFormat XeSwapChain::findDepthFormat() { +VkFormat SwapChain::findDepthFormat() { return device.findSupportedFormat( {VK_FORMAT_D32_SFLOAT, VK_FORMAT_D32_SFLOAT_S8_UINT, VK_FORMAT_D24_UNORM_S8_UINT}, VK_IMAGE_TILING_OPTIMAL, diff --git a/engine/xe_swap_chain.hpp b/engine/xe_swap_chain.hpp index a15a5a0..2d4e81b 100755 --- a/engine/xe_swap_chain.hpp +++ b/engine/xe_swap_chain.hpp @@ -11,16 +11,16 @@ namespace xe { -class XeSwapChain { +class SwapChain { public: static constexpr int MAX_FRAMES_IN_FLIGHT = 2; - XeSwapChain(XeDevice &deviceRef, VkExtent2D windowExtent); - XeSwapChain(XeDevice &deviceRef, VkExtent2D windowExtent, std::shared_ptr<XeSwapChain> previous); - ~XeSwapChain(); + SwapChain(Device &deviceRef, VkExtent2D windowExtent); + SwapChain(Device &deviceRef, VkExtent2D windowExtent, std::shared_ptr<SwapChain> previous); + ~SwapChain(); - XeSwapChain(const XeSwapChain &) = delete; - XeSwapChain operator=(const XeSwapChain &) = delete; + SwapChain(const SwapChain &) = delete; + SwapChain operator=(const SwapChain &) = delete; VkFramebuffer getFrameBuffer(int index) { return swapChainFramebuffers[index]; } VkRenderPass getRenderPass() { return renderPass; } @@ -39,7 +39,7 @@ class XeSwapChain { VkResult acquireNextImage(uint32_t *imageIndex); VkResult submitCommandBuffers(const VkCommandBuffer *buffers, uint32_t *imageIndex); - bool compareSwapFormats(const XeSwapChain& swapChain) const { + bool compareSwapFormats(const SwapChain& swapChain) const { return swapChain.swapChainDepthFormat == swapChainDepthFormat && swapChain.swapChainImageFormat == swapChainImageFormat; } @@ -72,11 +72,11 @@ class XeSwapChain { std::vector<VkImage> swapChainImages; std::vector<VkImageView> swapChainImageViews; - XeDevice &device; + Device &device; VkExtent2D windowExtent; VkSwapchainKHR swapChain; - std::shared_ptr<XeSwapChain> oldSwapChain; + std::shared_ptr<SwapChain> oldSwapChain; std::vector<VkSemaphore> imageAvailableSemaphores; std::vector<VkSemaphore> renderFinishedSemaphores; diff --git a/engine/xe_window.cpp b/engine/xe_window.cpp index 2721279..8aaed9d 100755 --- a/engine/xe_window.cpp +++ b/engine/xe_window.cpp @@ -6,16 +6,16 @@ namespace xe { - XeWindow::XeWindow(int w, int h, std::string name) : width{w}, height{h}, windowName{name} { + Window::Window(int w, int h, std::string name) : width{w}, height{h}, windowName{name} { initWindow(); } - XeWindow::~XeWindow() { + Window::~Window() { glfwDestroyWindow(window); glfwTerminate(); } - void XeWindow::initWindow() { + void Window::initWindow() { glfwInit(); glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API); glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE); @@ -25,14 +25,14 @@ namespace xe { glfwSetFramebufferSizeCallback(window, framebufferResizeCallback); } - void XeWindow::createWindowSurface(VkInstance instance, VkSurfaceKHR *surface){ + void Window::createWindowSurface(VkInstance instance, VkSurfaceKHR *surface){ if (glfwCreateWindowSurface(instance, window, nullptr, surface) != VK_SUCCESS) { throw std::runtime_error("failed to create window surface"); } } - void XeWindow::framebufferResizeCallback(GLFWwindow *window, int width, int height){ - auto xeWindow = reinterpret_cast<XeWindow *>(glfwGetWindowUserPointer(window)); + void Window::framebufferResizeCallback(GLFWwindow *window, int width, int height){ + auto xeWindow = reinterpret_cast<Window *>(glfwGetWindowUserPointer(window)); xeWindow->frameBufferResized = true; xeWindow->width = width; xeWindow->height = height; diff --git a/engine/xe_window.hpp b/engine/xe_window.hpp index bf80bd7..e449e34 100755 --- a/engine/xe_window.hpp +++ b/engine/xe_window.hpp @@ -7,13 +7,13 @@ #include <string> namespace xe { -class XeWindow { +class Window { public: - XeWindow(int w, int h, std::string name); - ~XeWindow(); + Window(int w, int h, std::string name); + ~Window(); - XeWindow(const XeWindow &) = delete; - XeWindow &operator=(const XeWindow &); + Window(const Window &) = delete; + Window &operator=(const Window &); bool shouldClose() { return glfwWindowShouldClose(window); } VkExtent2D getExtent() { return { static_cast<uint32_t>(width), static_cast<uint32_t>(height)}; } diff --git a/src/first_app.cpp b/src/first_app.cpp index 423012a..5b2d23d 100755 --- a/src/first_app.cpp +++ b/src/first_app.cpp @@ -27,16 +27,16 @@ FirstApp::~FirstApp() {} void FirstApp::run() { - std::shared_ptr<xe::XeImage> image = xeEngine.loadImage("res/image/texture.png"); - std::shared_ptr<xe::XeImage> image2 = xeEngine.loadImage("res/image/scaly.png"); + std::shared_ptr<xe::Image> image = xeEngine.loadImage("res/image/texture.png"); + std::shared_ptr<xe::Image> image2 = xeEngine.loadImage("res/image/ltt."); SimpleRenderer renderer{xeEngine, image.get()}; - xe::XeSound sound{"res/sound/when_the_world_ends.wav"}; + xe::Sound sound{"res/sound/when_the_world_ends.wav"}; sound.setLooping(true); sound.play(); - auto viewerObject = xe::XeGameObject::createGameObject(); + auto viewerObject = xe::GameObject::createGameObject(); viewerObject.transform.translation = {-7.f, 3.f, -7.f}; viewerObject.transform.rotation.y = glm::radians(45.f); KeyboardMovementController cameraController{}; @@ -60,15 +60,15 @@ void FirstApp::run() { } void FirstApp::loadGameObjects() { - std::shared_ptr<xe::XeModel> xeModel = xeEngine.loadModelFromFile("res/models/stanford-dragon.obj"); + std::shared_ptr<xe::Model> xeModel = xeEngine.loadModelFromFile("res/models/stanford-dragon.obj"); - auto dragon = xe::XeGameObject::createGameObject(); + auto dragon = xe::GameObject::createGameObject(); dragon.model = xeModel; dragon.transform.translation = {.0f, .0f, 2.5f}; dragon.transform.scale = {.5f, .5f, .5f}; gameObjects.push_back(std::move(dragon)); - auto dragon2 = xe::XeGameObject::createGameObject(); + auto dragon2 = xe::GameObject::createGameObject(); dragon2.model = xeModel; dragon2.transform.translation = {5.0f, .0f, -1.5f}; dragon2.transform.rotation.y = glm::radians(90.f); diff --git a/src/first_app.hpp b/src/first_app.hpp index d8942ab..d7beb78 100755 --- a/src/first_app.hpp +++ b/src/first_app.hpp @@ -26,8 +26,8 @@ class FirstApp { void loadGameObjects(); - xe::XeEngine xeEngine; + xe::Engine xeEngine; - std::vector<xe::XeGameObject> gameObjects; + std::vector<xe::GameObject> gameObjects; }; }
\ No newline at end of file diff --git a/src/keyboard_movement_controller.cpp b/src/keyboard_movement_controller.cpp index 325693e..d1613ee 100644 --- a/src/keyboard_movement_controller.cpp +++ b/src/keyboard_movement_controller.cpp @@ -6,7 +6,7 @@ namespace app { -void KeyboardMovementController::moveInPlaneXZ(GLFWwindow* window, float dt, xe::XeGameObject& gameObject) { +void KeyboardMovementController::moveInPlaneXZ(GLFWwindow* window, float dt, xe::GameObject& gameObject) { glm::vec3 rotate{0}; if(glfwGetKey(window, keys.lookRight) == GLFW_PRESS) rotate.y += 1.f; if(glfwGetKey(window, keys.lookLeft) == GLFW_PRESS) rotate.y -= 1.f; diff --git a/src/keyboard_movement_controller.hpp b/src/keyboard_movement_controller.hpp index b3e3a15..0df841e 100644 --- a/src/keyboard_movement_controller.hpp +++ b/src/keyboard_movement_controller.hpp @@ -21,7 +21,7 @@ namespace app { int lookDown = GLFW_KEY_DOWN; }; - void moveInPlaneXZ(GLFWwindow* window, float dt, xe::XeGameObject& gameObject); + void moveInPlaneXZ(GLFWwindow* window, float dt, xe::GameObject& gameObject); KeyMappings keys{}; float moveSpeed{3.f}; diff --git a/src/simple_renderer.cpp b/src/simple_renderer.cpp index 921019a..43c933d 100644 --- a/src/simple_renderer.cpp +++ b/src/simple_renderer.cpp @@ -5,8 +5,8 @@ namespace app { -SimpleRenderer::SimpleRenderer(xe::XeEngine &xeEngine, xe::XeImage *xeImage) { - xeRenderSystem = xe::XeRenderSystem::Builder(xeEngine, "res/shaders/simple_shader.vert.spv", "res/shaders/simple_shader.frag.spv") +SimpleRenderer::SimpleRenderer(xe::Engine &xeEngine, xe::Image *xeImage) { + xeRenderSystem = xe::RenderSystem::Builder(xeEngine, "res/shaders/simple_shader.vert.spv", "res/shaders/simple_shader.frag.spv") .addPushConstant(sizeof(PushConstant)) .addUniformBinding(0, sizeof(UniformBuffer)) .addTextureBinding(1, xeImage) @@ -14,7 +14,7 @@ SimpleRenderer::SimpleRenderer(xe::XeEngine &xeEngine, xe::XeImage *xeImage) { .build(); } -void SimpleRenderer::render(std::vector<xe::XeGameObject> &gameObjects, xe::XeCamera &xeCamera, xe::XeImage *xeImage) { +void SimpleRenderer::render(std::vector<xe::GameObject> &gameObjects, xe::Camera &xeCamera, xe::Image *xeImage) { xeRenderSystem->loadTexture(1, xeImage); diff --git a/src/simple_renderer.hpp b/src/simple_renderer.hpp index d9be7b2..59c1e60 100644 --- a/src/simple_renderer.hpp +++ b/src/simple_renderer.hpp @@ -19,17 +19,17 @@ class SimpleRenderer { public: - SimpleRenderer(xe::XeEngine &xeEngine, xe::XeImage *xeImage); + SimpleRenderer(xe::Engine &xeEngine, xe::Image *xeImage); ~SimpleRenderer() {}; SimpleRenderer(const SimpleRenderer&) = delete; SimpleRenderer operator=(const SimpleRenderer&) = delete; - void render(std::vector<xe::XeGameObject> &gameObjects, xe::XeCamera &xeCamera, xe::XeImage *xeImage); + void render(std::vector<xe::GameObject> &gameObjects, xe::Camera &xeCamera, xe::Image *xeImage); private: - std::unique_ptr<xe::XeRenderSystem> xeRenderSystem; + std::unique_ptr<xe::RenderSystem> xeRenderSystem; }; |