diff --git a/engine/3rdparty/zlog/include/zlog.h b/engine/3rdparty/zlog/include/zlog.h new file mode 100644 index 0000000..c285455 --- /dev/null +++ b/engine/3rdparty/zlog/include/zlog.h @@ -0,0 +1,12 @@ +#pragma once +#include +#include +namespace zlog +{ + static std::mutex _mutex; + static void Message(std::string info, bool logCondition); + static void Message(std::string info); + + static void Exception(std::string info, bool logCondition); + static void Exception(std::string info); +} diff --git a/engine/3rdparty/zlog/src/zlog.cpp b/engine/3rdparty/zlog/src/zlog.cpp new file mode 100644 index 0000000..7e5a776 --- /dev/null +++ b/engine/3rdparty/zlog/src/zlog.cpp @@ -0,0 +1,38 @@ +#include "zlog. + + + + +#include + +std::mutex zlog::_mutex = std::mutex(); + +void zlog::Message(std::string info, bool logCondition) +{ + if (logCondition) + { + std::unique_lock lock(_mutex); + std::cout << "Message: " + info << std::endl; + } +} + +void zlog::Message(std::string info) +{ + std::unique_lock lock(_mutex); + std::cout << "Message: " + info << std::endl; +} + +void zlog::Exception(std::string info, bool logCondition) +{ + if (logCondition) + { + std::unique_lock lock(_mutex); + std::cout << "Exception: " + info << std::endl; + } +} + +void zlog::Exception(std::string info) +{ + std::unique_lock lock(_mutex); + std::cout << "Exception: " + info << std::endl; +} diff --git a/engine/3rdparty/zlog/xmake.lua b/engine/3rdparty/zlog/xmake.lua new file mode 100644 index 0000000..06593db --- /dev/null +++ b/engine/3rdparty/zlog/xmake.lua @@ -0,0 +1,6 @@ +set_languages("cxx20") +target("zlog") + set_kind("static") + add_includedirs("include", {public = true}) + add_files("src/*.cpp") + add_headerfiles("include/*.h") \ No newline at end of file diff --git a/engine/src/engine/vulkanapi/backend.cpp b/engine/src/engine/vulkanapi/backend.cpp index cf490e0..6d1474d 100644 --- a/engine/src/engine/vulkanapi/backend.cpp +++ b/engine/src/engine/vulkanapi/backend.cpp @@ -1,6 +1,4 @@ #include "backend.h" -#include "wrapper/instance.h" -#include "wrapper/device.h" #include namespace vulkanapi { @@ -22,11 +20,9 @@ namespace vulkanapi { { if (mInstance) { delete mInstance; - mInstance = nullptr; } if (mDevice) { delete mDevice; - mDevice = nullptr; } } } diff --git a/engine/src/engine/vulkanapi/backend.h b/engine/src/engine/vulkanapi/backend.h index e5a9e77..40e93a7 100644 --- a/engine/src/engine/vulkanapi/backend.h +++ b/engine/src/engine/vulkanapi/backend.h @@ -1,19 +1,19 @@ #pragma once #include #include +#include "wrapper/instance.h" +#include "wrapper/device.h" namespace vulkanapi { - class Instance; - class Device; class Backend{ protected: Instance* mInstance; Device* mDevice; public: - Instance* GetInstance() { - return mInstance; + Instance& GetInstance() { + return *mInstance; } - Device* GetDevice() { - return mDevice; + Device& GetDevice() { + return *mDevice; } public: Backend(const char* appName, int deviceIndex = 0); diff --git a/engine/src/engine/vulkanapi/pass/forwardpass.cpp b/engine/src/engine/vulkanapi/pass/forwardpass.cpp new file mode 100644 index 0000000..144ea7c --- /dev/null +++ b/engine/src/engine/vulkanapi/pass/forwardpass.cpp @@ -0,0 +1,45 @@ +#include "forwardpass.h" +#include "../wrapper/renderpass.h" +#include "../wrapper/image.h" +namespace vulkanapi { + ForwardPass::ForwardPass(Device& device, GeometryBuffer& gBuffer) + { + VkAttachmentDescription positionAttachment{}; + positionAttachment.samples = VK_SAMPLE_COUNT_1_BIT; + positionAttachment.format = gBuffer.positions[0]->Format(); + positionAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; + positionAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE; + positionAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; + positionAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; + positionAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; + positionAttachment.finalLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + + VkAttachmentDescription normalAttachment{}; + normalAttachment.samples = VK_SAMPLE_COUNT_1_BIT; + normalAttachment.format = gBuffer.normals[0]->Format(); + normalAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; + normalAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE; + normalAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; + normalAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; + normalAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; + normalAttachment.finalLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + + VkAttachmentReference colorAttachmentRef{}; + colorAttachmentRef.attachment = 0; + colorAttachmentRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; + + VkSubpassDescription subpass{}; + subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS; + subpass.colorAttachmentCount = 1; + subpass.pColorAttachments = &colorAttachmentRef; + + std::vector attachments = {positionAttachment , normalAttachment}; + std::vector subpasses = { subpass }; + std::vector dependencies; + mPass = new RenderPass(device,"forward",attachments, subpasses, dependencies); + } + void ForwardPass::Record() + { + + } +} \ No newline at end of file diff --git a/engine/src/engine/vulkanapi/pass/forwardpass.h b/engine/src/engine/vulkanapi/pass/forwardpass.h new file mode 100644 index 0000000..ec901a1 --- /dev/null +++ b/engine/src/engine/vulkanapi/pass/forwardpass.h @@ -0,0 +1,17 @@ +#pragma once +#include "../vulkan.h" +#include "gbuffer.h" +namespace vulkanapi { + class RenderPass; + class Device; + //class MaterialCache; + class ForwardPass { + protected: + RenderPass* mPass; + //MaterialCache mMaterials; + public: + ForwardPass(Device& device, GeometryBuffer& gBuffer); + + void Record(); + }; +} \ No newline at end of file diff --git a/engine/src/engine/vulkanapi/pass/gbuffer.cpp b/engine/src/engine/vulkanapi/pass/gbuffer.cpp new file mode 100644 index 0000000..482e831 --- /dev/null +++ b/engine/src/engine/vulkanapi/pass/gbuffer.cpp @@ -0,0 +1,31 @@ +#include "gbuffer.h" +#include "../wrapper/image.h" +namespace vulkanapi { + GeometryBuffer::GeometryBuffer(Device& device,int frames, int width, int height) + :width(width), + height(height) + { + VkFormat positionFmt = VK_FORMAT_R32G32B32A32_SFLOAT; + VkFormat normalFmt = VK_FORMAT_R8G8B8A8_UNORM; + VkFormat diffuseFmt = VK_FORMAT_R8G8B8A8_UNORM; + + int usage = 1; + for (int i = 0; i < frames; i++) { + positions.push_back(new Image(device, "position", width , height, diffuseFmt, usage)); + normals.push_back(new Image(device, "normal", width, height, diffuseFmt, usage)); + diffuses.push_back(new Image(device, "diffuse", width, height, diffuseFmt, usage)); + } + } + GeometryBuffer::~GeometryBuffer() + { + int frames = positions.size(); + for (int i = 0; i < frames; i++) { + delete positions[i]; + delete normals[i]; + delete diffuses[i]; + } + positions.clear(); + normals.clear(); + diffuses.clear(); + } +} \ No newline at end of file diff --git a/engine/src/engine/vulkanapi/pass/gbuffer.h b/engine/src/engine/vulkanapi/pass/gbuffer.h new file mode 100644 index 0000000..01e44b3 --- /dev/null +++ b/engine/src/engine/vulkanapi/pass/gbuffer.h @@ -0,0 +1,18 @@ +#pragma once +#include "../vulkan.h" +#include +namespace vulkanapi { + class Image; + class Device; + struct GeometryBuffer { + public: + std::vector positions; + std::vector normals; + std::vector diffuses; + int width; + int height; + public: + GeometryBuffer(Device& device,int frames, int width, int height); + ~GeometryBuffer(); + }; +} \ No newline at end of file diff --git a/engine/src/engine/vulkanapi/vulkan.h b/engine/src/engine/vulkanapi/vulkan.h index 79a26df..d1b0550 100644 --- a/engine/src/engine/vulkanapi/vulkan.h +++ b/engine/src/engine/vulkanapi/vulkan.h @@ -10,6 +10,27 @@ namespace vulkanapi { #define LIBRARY_TYPE void* #endif +#define _USE_GRAPHIC_DEBUG + +#define assert_return(cond, info, result)\ + if (cond) {\ + zlog::Exception(info);\ + return result;\ + } +#define assert(cond,info)\ + if (cond) {\ + zlog::Exception(info);\ + } +#define assert_vulkan_return(VkResult, info, result) \ + if (VkResult != VK_SUCCESS) { \ + zlog::Exception(info);\ + return result;\ + } +#define assert_vulkan(VkResult, info) \ + if (VkResult != VK_SUCCESS) { \ + zlog::Exception(info);\ + } + using voidFn = std::function; using commandFn = std::function; diff --git a/engine/src/engine/vulkanapi/window.cpp b/engine/src/engine/vulkanapi/window.cpp index b24c3ab..c3a0604 100644 --- a/engine/src/engine/vulkanapi/window.cpp +++ b/engine/src/engine/vulkanapi/window.cpp @@ -5,12 +5,12 @@ #include "wrapper/swapchain.h" #include namespace vulkanapi { - Window::Window(Backend* backend, int frames, uint32_t width, uint32_t height, const char* title) + Window::Window(Backend& backend, int frames, uint32_t width, uint32_t height, const char* title) :renderapi::Window(width, height , title) , mSurfaceKHR(nullptr) , mSwapchain(nullptr) { - VkInstance instance = backend->GetInstance()->Ptr(); + VkInstance instance = backend.GetInstance().Ptr(); VkWin32SurfaceCreateInfoKHR surface_create_info = { VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR, // VkStructureType sType nullptr, // const void * pNext @@ -20,6 +20,6 @@ namespace vulkanapi { }; vkCreateWin32SurfaceKHR(instance, &surface_create_info, nullptr, &mSurfaceKHR); - mSwapchain = new Swapchain(backend->GetDevice(), frames, width, height, mSurfaceKHR); + mSwapchain = new Swapchain(backend.GetDevice(), frames, width, height, mSurfaceKHR); } } \ No newline at end of file diff --git a/engine/src/engine/vulkanapi/window.h b/engine/src/engine/vulkanapi/window.h index b725ec1..108fb42 100644 --- a/engine/src/engine/vulkanapi/window.h +++ b/engine/src/engine/vulkanapi/window.h @@ -8,9 +8,9 @@ namespace vulkanapi { class Swapchain; class Window : public renderapi::Window { protected: - VkSurfaceKHR mSurfaceKHR; + VkSurfaceKHR mSurfaceKHR{NULL}; Swapchain* mSwapchain; public: - Window(Backend* backend,int frames, uint32_t width, uint32_t height, const char* title); + Window(Backend& backend,int frames, uint32_t width, uint32_t height, const char* title); }; }; \ No newline at end of file diff --git a/engine/src/engine/vulkanapi/wrapper/device.h b/engine/src/engine/vulkanapi/wrapper/device.h index 562f24d..3626dd0 100644 --- a/engine/src/engine/vulkanapi/wrapper/device.h +++ b/engine/src/engine/vulkanapi/wrapper/device.h @@ -5,8 +5,8 @@ namespace vulkanapi { class Device{ protected: - VkDevice mPtr; - VkPhysicalDevice mPhysical; + VkDevice mPtr{ NULL }; + VkPhysicalDevice mPhysical{NULL}; public: VkDevice Ptr() { return mPtr; @@ -15,6 +15,7 @@ namespace vulkanapi { return mPhysical; } public: + Device(){}; Device(VkInstance ptr, VkPhysicalDevice physDevice); uint32_t GetQueueFamilyIndex(VkQueueFlags flag); diff --git a/engine/src/engine/vulkanapi/wrapper/image.cpp b/engine/src/engine/vulkanapi/wrapper/image.cpp new file mode 100644 index 0000000..142737b --- /dev/null +++ b/engine/src/engine/vulkanapi/wrapper/image.cpp @@ -0,0 +1,28 @@ +#include "image.h" +namespace vulkanapi { + Image::Image(const Device& device, const char* name, int width, int height, VkFormat format, VkImageUsageFlags usage) + :Image(device, Args{ + 1, + "", + width,height, + 1,1,1, + format,usage, + 1,1,1,1 }) + { + + } + Image::Image(const Device& device, const Args& args) + : mArgs(args) + , mDevice(device) + , mPtr(nullptr) + { + + } + Image::Image(const Device& device, VkImage ptr, const Args& args) + : mArgs(args) + , mDevice(device) + , mPtr(ptr) + { + + } +} diff --git a/engine/src/engine/vulkanapi/wrapper/image.h b/engine/src/engine/vulkanapi/wrapper/image.h new file mode 100644 index 0000000..201faa6 --- /dev/null +++ b/engine/src/engine/vulkanapi/wrapper/image.h @@ -0,0 +1,36 @@ +#pragma once +#include +#include "../vulkan.h" +namespace vulkanapi { + class Device; + class Image { + public: + struct Args { + int Type; + const char* Key; + int Width; + int Height; + int Depth; + int Layers; + int Levels; + VkFormat Format; + VkImageUsageFlags Usage; + int Tiling; + int Sharing; + int Layout; + int Memory; + }; + protected: + VkImage mPtr; + Args mArgs; + const Device& mDevice; + public: + Image(const Device& device, const char* name, int width, int height, VkFormat format, VkImageUsageFlags usage); + Image(const Device& device, const Args& args); + Image(const Device& device, VkImage ptr, const Args& args); + + VkFormat Format() { + return mArgs.Format; + }; + }; +} \ No newline at end of file diff --git a/engine/src/engine/vulkanapi/wrapper/image_help.h b/engine/src/engine/vulkanapi/wrapper/image_help.h new file mode 100644 index 0000000..e69de29 diff --git a/engine/src/engine/vulkanapi/wrapper/instance.cpp b/engine/src/engine/vulkanapi/wrapper/instance.cpp index fb96ffc..9128fb3 100644 --- a/engine/src/engine/vulkanapi/wrapper/instance.cpp +++ b/engine/src/engine/vulkanapi/wrapper/instance.cpp @@ -1,21 +1,30 @@ #include "instance.h" #include "instance_help.h" - -const char* vulkanapi::EngineName = "Vulkan"; -std::vector extensions = { - "VK_KHR_surface", - "VK_EXT_debug_utils", - "VK_KHR_get_physical_device_properties2", - "VK_KHR_win32_surface", - "VK_EXT_debug_report", - "VK_KHR_portability_enumeration", -}; -std::vector layers = { - "VK_LAYER_KHRONOS_validation", - //"VK_LAYER_LUNARG_api_dump", -}; namespace vulkanapi { - Instance::Instance(const char* appName) { + Instance::InstanceCreator::InstanceCreator() + : appName("Vulkan Application") + , appVersion(VK_MAKE_VERSION(1, 0, 0)) + , engineName("No Engine") + , engineVersion(VK_MAKE_VERSION(1, 0, 0)) + , apiVersion(VK_API_VERSION_1_0) +#ifdef _USE_GRAPHIC_DEBUG + , messageSeverity(VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) + , messageType(VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT) + , debugCallback(Instance::DebugCallback) +#endif + { + } + Instance::InstanceCreator::~InstanceCreator() + { + } + void Instance::InstanceCreator::AddExtension(std::string extensionName) + { + } + void Instance::InstanceCreator::AddLayer(std::string layerName) + { + } + + Instance::Instance(InstanceCreator& Creator) { //加载dll LIBRARY_TYPE vulkan_library; ConnectWithVulkanLoaderLibrary(vulkan_library); @@ -26,16 +35,16 @@ namespace vulkanapi { //调用vulkan接口，加载全局函数指针 LoadGlobalLevelFunctions(); VkApplicationInfo application_info = { - VK_STRUCTURE_TYPE_APPLICATION_INFO, // VkStructureType sType - nullptr, // const void * pNext - appName, // const char * pApplicationName - VK_MAKE_VERSION(1, 0, 0), // uint32_t applicationVersion - EngineName, // const char * pEngineName - VK_MAKE_VERSION(1, 0, 0), // uint32_t engineVersion - VK_MAKE_VERSION(1, 0, 0) // uint32_t apiVersion + VK_STRUCTURE_TYPE_APPLICATION_INFO, // VkStructureType sType + nullptr, // const void * pNext + Creator.appName.c_str(), // const char * pApplicationName + Creator.appVersion, // uint32_t applicationVersion + Creator.engineName.c_str(), // const char * pEngineName + Creator.engineVersion, // uint32_t engineVersion + Creator.apiVersion // uint32_t apiVersion }; - extensions = _EnabledExtensionNames(extensions); - layers = _EnabledLayerNames(layers); + auto extensions = _EnabledExtensionNames(Creator._desiredExtensions); + auto layers = _EnabledLayerNames(Creator._desiredLayers); VkDebugUtilsMessengerCreateInfoEXT createInfo = _DebugUtilsLayerNext(); VkInstanceCreateInfo instance_create_info = { VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, // VkStructureType sType @@ -47,10 +56,7 @@ namespace vulkanapi { static_cast(extensions.size()), // uint32_t enabledExtensionCount extensions.data() // const char * const * ppEnabledExtensionNames }; - VkResult result = vkCreateInstance(&instance_create_info, nullptr, &mPtr); - if ((result != VK_SUCCESS) || (mPtr == VK_NULL_HANDLE)) { - std::cout << "Could not create Instance." << std::endl; - } + zlog::Exception("Failed to create instance.", vkCreateInstance(&instance_create_info, nullptr, &mPtr)); //调用vulkan接口，加载实例函数指针 LoadInstanceLevelFunctions(mPtr, extensions); diff --git a/engine/src/engine/vulkanapi/wrapper/instance.h b/engine/src/engine/vulkanapi/wrapper/instance.h index edb4a45..e8853f4 100644 --- a/engine/src/engine/vulkanapi/wrapper/instance.h +++ b/engine/src/engine/vulkanapi/wrapper/instance.h @@ -5,10 +5,34 @@ namespace vulkanapi { class Instance{ + public: + class InstanceCreator { + friend class Instance; + public: + std::string appName; + uint32_t appVersion; + std::string engineName; + uint32_t engineVersion; + uint32_t apiVersion; +#ifdef _USE_GRAPHIC_DEBUG + VkDebugUtilsMessageSeverityFlagsEXT messageSeverity; + VkDebugUtilsMessageTypeFlagsEXT messageType; + PFN_vkDebugUtilsMessengerCallbackEXT debugCallback; +#endif + private: + std::vector _desiredExtensions; + std::vector _desiredLayers; + + public: + InstanceCreator(); + ~InstanceCreator(); + void AddExtension(std::string extensionName); + void AddLayer(std::string layerName); + }; protected: VkInstance mPtr; public: - Instance(const char* appName); + Instance(InstanceCreator& Creator); VkInstance Ptr() { return mPtr; diff --git a/engine/src/engine/vulkanapi/wrapper/instance_help.h b/engine/src/engine/vulkanapi/wrapper/instance_help.h index 0a2e0b3..1b85f88 100644 --- a/engine/src/engine/vulkanapi/wrapper/instance_help.h +++ b/engine/src/engine/vulkanapi/wrapper/instance_help.h @@ -3,6 +3,7 @@ #include #include #include +#include "zlog.h" namespace vulkanapi { bool ConnectWithVulkanLoaderLibrary(LIBRARY_TYPE& vulkan_library) { #if defined _WIN32 @@ -10,9 +11,8 @@ namespace vulkanapi { #elif defined __linux vulkan_library = dlopen("libvulkan.so.1", RTLD_NOW); #endif - if (vulkan_library == nullptr) { - std::cout << "Could not connect with a Vulkan Runtime library." << std::endl; + zlog::Exception("Could not connect with a Vulkan Runtime library."); return false; } return true; @@ -27,8 +27,7 @@ namespace vulkanapi { #define EXPORTED_VULKAN_FUNCTION( name ) \ name = (PFN_##name)LoadFunction( vulkan_library, #name ); \ if( name == nullptr ) { \ - std::cout << "Could not load exported Vulkan function named: " \ - #name << std::endl; \ + zlog::Exception( "Could not load exported Vulkan function named:"#name);\ return false; \ } #include "engine/vulkanapi/vulkan_function_list.inl" @@ -39,8 +38,7 @@ namespace vulkanapi { #define GLOBAL_LEVEL_VULKAN_FUNCTION( name ) \ name = (PFN_##name)vkGetInstanceProcAddr( nullptr, #name ); \ if( name == nullptr ) { \ - std::cout << "Could not load global level Vulkan function named: " \ - #name << std::endl; \ + zlog::Exception( "Could not load global level Vulkan function named:"#name);\ return false; \ } @@ -54,8 +52,7 @@ namespace vulkanapi { #define INSTANCE_LEVEL_VULKAN_FUNCTION( name ) \ name = (PFN_##name)vkGetInstanceProcAddr( instance, #name ); \ if( name == nullptr ) { \ - std::cout << "Could not load instance-level Vulkan function named: " \ - #name << std::endl; \ + zlog::Exception( "Could not load instance-level Vulkan function named:"#name);\ return false; \ } @@ -65,8 +62,7 @@ namespace vulkanapi { if( std::string( enabled_extension ) == std::string( extension ) ) { \ name = (PFN_##name)vkGetInstanceProcAddr( instance, #name ); \ if( name == nullptr ) { \ - std::cout << "Could not load instance-level Vulkan function named: " \ - #name << std::endl; \ + zlog::Exception( "Could not load instance-level Vulkan function named:"#name);\ return false; \ } \ } \ @@ -101,7 +97,7 @@ namespace vulkanapi { result = vkEnumerateInstanceLayerProperties(&extensions_count, nullptr); if ((result != VK_SUCCESS) || (extensions_count == 0)) { - std::cout << "Could not get the number of instance layers." << std::endl; + zlog::Exception("Could not get the number of instance layers."); return false; } @@ -109,7 +105,7 @@ namespace vulkanapi { result = vkEnumerateInstanceLayerProperties(&extensions_count, available_layers.data()); if ((result != VK_SUCCESS) || (extensions_count == 0)) { - std::cout << "Could not enumerate instance layers." << std::endl; + zlog::Exception("Could not enumerate instance layers."); return false; } @@ -122,7 +118,7 @@ namespace vulkanapi { result = vkEnumerateInstanceExtensionProperties(nullptr, &extensions_count, nullptr); if ((result != VK_SUCCESS) || (extensions_count == 0)) { - std::cout << "Could not get the number of instance extensions." << std::endl; + zlog::Exception("Could not get the number of instance extensions."); return false; } @@ -130,7 +126,7 @@ namespace vulkanapi { result = vkEnumerateInstanceExtensionProperties(nullptr, &extensions_count, available_extensions.data()); if ((result != VK_SUCCESS) || (extensions_count == 0)) { - std::cout << "Could not enumerate instance extensions." << std::endl; + zlog::Exception("Could not enumerate instance extensions."); return false; } @@ -147,6 +143,7 @@ namespace vulkanapi { _extension.push_back(extensions[i]); } else { + zlog::Exception("cann't support extension: "); std::cout << "cann't support extension: " << extensions[i] << std::endl; } } @@ -163,6 +160,7 @@ namespace vulkanapi { _layers.push_back(layers[i]); } else { + zlog::Exception("Could not load instance-level Vulkan function named:"#name); \ std::cout << "cann't support layer: " << layers[i] << std::endl; } } diff --git a/engine/src/engine/vulkanapi/wrapper/renderpass.cpp b/engine/src/engine/vulkanapi/wrapper/renderpass.cpp new file mode 100644 index 0000000..ef72122 --- /dev/null +++ b/engine/src/engine/vulkanapi/wrapper/renderpass.cpp @@ -0,0 +1,23 @@ +#include "renderpass.h" +#include "device.h" +namespace vulkanapi { + RenderPass::RenderPass(Device& device, const char* name, + std::vector& attachments, + std::vector& subpasses, + std::vector& dependencies) + { + //pAttachments + VkRenderPassCreateInfo create_info{ + VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, + nullptr, + 0, + (uint32_t)attachments.size(), + attachments.data(), + (uint32_t)subpasses.size(), + subpasses.data(), + (uint32_t)dependencies.size(), + dependencies.data() + }; + vkCreateRenderPass(device.Ptr(), &create_info, nullptr, &mPtr); + } +} diff --git a/engine/src/engine/vulkanapi/wrapper/renderpass.h b/engine/src/engine/vulkanapi/wrapper/renderpass.h new file mode 100644 index 0000000..800b52f --- /dev/null +++ b/engine/src/engine/vulkanapi/wrapper/renderpass.h @@ -0,0 +1,18 @@ +#pragma once + +#include "../vulkan.h" +#include + +namespace vulkanapi { + class Device; + class RenderPass { + protected: + VkRenderPass mPtr; + public: + RenderPass(Device& device, const char* name, + std::vector& attachments, + std::vector& subpasses, + std::vector& dependencies); + //colorAttachments, depthAttachment, subpasses, dependencies); + }; +}; \ No newline at end of file diff --git a/engine/src/engine/vulkanapi/wrapper/renderpass_help.h b/engine/src/engine/vulkanapi/wrapper/renderpass_help.h new file mode 100644 index 0000000..e69de29 diff --git a/engine/src/engine/vulkanapi/wrapper/swapchain.cpp b/engine/src/engine/vulkanapi/wrapper/swapchain.cpp index 92a7beb..5176020 100644 --- a/engine/src/engine/vulkanapi/wrapper/swapchain.cpp +++ b/engine/src/engine/vulkanapi/wrapper/swapchain.cpp @@ -1,12 +1,13 @@ #include "swapchain.h" #include "swapchain_help.h" #include "device.h" +#include "image.h" namespace vulkanapi { - Swapchain::Swapchain(Device* device, int frames, int width, int height, VkSurfaceKHR presentation_surface) + Swapchain::Swapchain(Device& device, int frames, int width, int height, VkSurfaceKHR presentation_surface) : mPtr(nullptr) { uint32_t queue_family_index; - VkPhysicalDevice physical_device = device->GetPhysical(); + VkPhysicalDevice physical_device = device.GetPhysical(); //选择交换链图像的格式与颜色空间 VkFormat image_format; @@ -23,11 +24,21 @@ namespace vulkanapi { //调用设备接口，创建交换链 VkSwapchainKHR old_swapchain = VK_NULL_HANDLE; VkImageUsageFlags imageUsage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; - CreateSwapchain(device->Ptr(), presentation_surface, frames, { image_format, image_color_space }, image_size + CreateSwapchain(device.Ptr(), presentation_surface, frames, { image_format, image_color_space }, image_size , imageUsage, VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR,VK_PRESENT_MODE_FIFO_KHR, old_swapchain, mPtr); + std::cout << "sizeof image" << sizeof(Image); std::vector swapchain_images; - GetHandlesOfSwapchainImages(device->Ptr(), mPtr, swapchain_images); - + GetHandlesOfSwapchainImages(device.Ptr(), mPtr, swapchain_images); + uint32_t image_count = swapchain_images.size(); + for (auto img : swapchain_images) { + mImages.push_back(new Image(device, img, Image::Args{ + 1, + "", + width, height, + 1, 1, 1, + image_format, imageUsage, + 1, 1, 1, 1})); + } } } diff --git a/engine/src/engine/vulkanapi/wrapper/swapchain.h b/engine/src/engine/vulkanapi/wrapper/swapchain.h index 9d59dff..41248e8 100644 --- a/engine/src/engine/vulkanapi/wrapper/swapchain.h +++ b/engine/src/engine/vulkanapi/wrapper/swapchain.h @@ -11,6 +11,6 @@ namespace vulkanapi { VkSwapchainKHR mPtr; std::vector mImages; public: - Swapchain(Device* device,int frames, int width, int height, VkSurfaceKHR presentation_surface); + Swapchain(Device& device,int frames, int width, int height, VkSurfaceKHR presentation_surface); }; }; \ No newline at end of file diff --git a/engine/src/main.cpp b/engine/src/main.cpp index 6d76c77..4da07c1 100644 --- a/engine/src/main.cpp +++ b/engine/src/main.cpp @@ -2,13 +2,17 @@ #include #include "engine/vulkanapi/backend.h" #include "engine/vulkanapi/window.h" +#include "engine/vulkanapi/pass/gbuffer.h" +#include "engine/vulkanapi/pass/forwardpass.h" using namespace std; int main(int argc, char** argv) { const char* name = "hello"; cout << name << endl; auto vulkan = vulkanapi::Backend(name); - auto wnd = vulkanapi::Window(&vulkan, 3, 640, 720, name); + auto wnd = vulkanapi::Window(vulkan, 3, 640, 720, name); + auto gbuffer = vulkanapi::GeometryBuffer(vulkan.GetDevice(), 3, 640, 720); + auto forardpass = vulkanapi::ForwardPass(vulkan.GetDevice(), gbuffer); while (true) { this_thread::sleep_for(chrono::milliseconds(1000)); } diff --git a/engine/xmake.lua b/engine/xmake.lua index 94e1242..a801cfc 100644 --- a/engine/xmake.lua +++ b/engine/xmake.lua @@ -3,8 +3,8 @@ includes("3rdparty/xmake.lua") target("zengine") set_kind("binary") - add_deps("zcoro") - add_packages("vulkansdk","tinyobjloader") + add_deps("zcoro","zlog") + add_packages("vulkansdk","tinyobjloader","glm") add_includedirs("src") add_syslinks("user32") add_files("src/*.cpp", "src/**.cpp")