todo

CMakeLists.txt

@@ -1,5 +1,6 @@
 cmake_minimum_required(VERSION 3.15)
 cmake_policy(SET CMP0167 NEW)
+
 project(aorii LANGUAGES C CXX)
 set(CMAKE_CXX_STANDARD 26)
 if (APPLE)
@@ -38,7 +39,6 @@ else ()
     add_definitions(-DDEBUG=0)
 endif ()
 
-add_subdirectory(third_party/LLGL)
 add_subdirectory(third_party/msdfgen)
 add_subdirectory(src/core)
 add_subdirectory(src/widget)

cmake/detect_os.cmake

@@ -2,72 +2,72 @@
 
 function(add_os_definitions target)
     # 初始化所有平台宏为 0
-    set(PLATFORMS WINDOWS MACOS LINUX FREEBSD IOS ANDROID)
+    set(PLATFORMS AORII_WINDOWS AORII_MACOS AORII_LINUX AORII_FREEBSD AORII_IOS AORII_ANDROID)
 
     # 检测操作系统并设置相应的宏为 1
     if(WIN32)
-        target_compile_definitions(${target} PRIVATE WINDOWS=1)
+        target_compile_definitions(${target} PUBLIC AORII_WINDOWS=1)
         message(STATUS "Detected Windows operating system")
-        list(REMOVE_ITEM PLATFORMS WINDOWS)
+        list(REMOVE_ITEM PLATFORMS AORII_WINDOWS)
     elseif(APPLE AND UNIX)
-        target_compile_definitions(${target} PRIVATE MACOS=1)
+        target_compile_definitions(${target} PUBLIC AORII_MACOS=1)
         message(STATUS "Detected macOS operating system")
-        list(REMOVE_ITEM PLATFORMS MACOS)
+        list(REMOVE_ITEM PLATFORMS AORII_MACOS)
     elseif(UNIX)
         if(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
-            target_compile_definitions(${target} PRIVATE LINUX=1)
+            target_compile_definitions(${target} PUBLIC AORII_LINUX=1)
             message(STATUS "Detected Linux operating system")
-            list(REMOVE_ITEM PLATFORMS LINUX)
+            list(REMOVE_ITEM PLATFORMS AORII_LINUX)
         elseif(${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD")
-            target_compile_definitions(${target} PRIVATE FREEBSD=1)
+            target_compile_definitions(${target} PUBLIC AORII_FREEBSD=1)
             message(STATUS "Detected FreeBSD operating system")
-            list(REMOVE_ITEM PLATFORMS FREEBSD)
+            list(REMOVE_ITEM PLATFORMS AORII_FREEBSD)
         else()
             message(WARNING "Detected unknown Unix-like operating system")
         endif()
     elseif(ANDROID)
-        target_compile_definitions(${target} PRIVATE ANDROID=1)
+        target_compile_definitions(${target} PUBLIC AORII_ANDROID=1)
         message(STATUS "Detected Android operating system")
-        list(REMOVE_ITEM PLATFORMS ANDROID)
+        list(REMOVE_ITEM PLATFORMS AORII_ANDROID)
     elseif(IOS)
-        target_compile_definitions(${target} PRIVATE IOS=1)
+        target_compile_definitions(${target} PUBLIC AORII_IOS=1)
         message(STATUS "Detected iOS operating system")
-        list(REMOVE_ITEM PLATFORMS IOS)
+        list(REMOVE_ITEM PLATFORMS AORII_IOS)
     else()
         message(WARNING "Unknown operating system")
     endif()
 
     foreach(PLATFORM ${PLATFORMS})
-        target_compile_definitions(${target} PRIVATE ${PLATFORM}=0)
+        target_compile_definitions(${target} PUBLIC ${PLATFORM}=0)
     endforeach()
 
     # 检测并设置架构宏
     if(CMAKE_SIZEOF_VOID_P EQUAL 8)
-        target_compile_definitions(${target} PRIVATE ARCH_64BIT=1 ARCH_32BIT=0)
+        target_compile_definitions(${target} PUBLIC AORII_ARCH_64BIT=1 AORII_ARCH_32BIT=0)
         message(STATUS "Detected 64-bit architecture")
     else()
-        target_compile_definitions(${target} PRIVATE ARCH_64BIT=0 ARCH_32BIT=1)
+        target_compile_definitions(${target} PUBLIC AORII_ARCH_64BIT=0 AORII_ARCH_32BIT=1)
         message(STATUS "Detected 32-bit architecture")
     endif()
 
     # 设置通用的 UNIX 宏
     if(UNIX)
-        target_compile_definitions(${target} PRIVATE UNIX=1)
+        target_compile_definitions(${target} PUBLIC AORII_UNIX=1)
     else()
-        target_compile_definitions(${target} PRIVATE UNIX=0)
+        target_compile_definitions(${target} PUBLIC AORII_UNIX=0)
     endif()
 
     # 设置通用的 POSIX 宏
     if(UNIX OR APPLE)
-        target_compile_definitions(${target} PRIVATE POSIX=1)
+        target_compile_definitions(${target} PUBLIC AORII_POSIX=1)
     else()
-        target_compile_definitions(${target} PRIVATE POSIX=0)
+        target_compile_definitions(${target} PUBLIC AORII_POSIX=0)
     endif()
 
     # 设置IS_MOBILE宏
     if(ANDROID OR IOS)
-        target_compile_definitions(${target} PRIVATE IS_MOBILE=1)
+        target_compile_definitions(${target} PUBLIC AORII_IS_MOBILE=1)
     else()
-        target_compile_definitions(${target} PRIVATE IS_MOBILE=0)
+        target_compile_definitions(${target} PUBLIC AORII_IS_MOBILE=0)
     endif()
 endfunction()

example/src/main.cpp

@@ -8,7 +8,7 @@
 #include "window/renderer_window.h"
 
 int main(int argc, char* argv[]) {
-    aorii::init(renderer_api::metal);
+    aorii::init(renderer_api::vulkan);
 
     renderer_window::desc_type desc{};
     desc.resolution = { 1280, 1280 };

src/core/CMakeLists.txt

@@ -5,6 +5,7 @@ find_package(Eigen3 REQUIRED)
 find_package(spdlog REQUIRED)
 find_package(Boost REQUIRED)
 find_package(Freetype REQUIRED)
+find_package(Vulkan REQUIRED)
 
 if (APPLE)
     find_library(COCOA_LIBRARY Cocoa)
@@ -14,7 +15,7 @@ set(RENDERER_SOURCES "")
 retrieve_files(${CMAKE_CURRENT_SOURCE_DIR} RENDERER_SOURCES)
 
 add_library(${PROJECT_NAME} STATIC ${RENDERER_SOURCES})
-target_link_libraries(${PROJECT_NAME} PUBLIC Freetype::Freetype harfbuzz::harfbuzz Eigen3::Eigen spdlog::spdlog msdfgen-full Boost::boost LLGL)
+target_link_libraries(${PROJECT_NAME} PUBLIC Freetype::Freetype harfbuzz::harfbuzz Eigen3::Eigen spdlog::spdlog msdfgen-full Boost::boost Vulkan::Vulkan)
 target_include_directories(${PROJECT_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
 target_compile_definitions(${PROJECT_NAME} PRIVATE NOMINMAX)
 add_os_definitions(${PROJECT_NAME})

src/core/renderer/renderer.cpp

@@ -18,10 +18,7 @@ using time_type = decltype(std::chrono::high_resolution_clock::now());
 std::chrono::duration<double> delta_time = {};
 time_type begin_time = {};
 time_type last_time = {};
-LLGL::RenderSystemPtr s_renderer{};
+aorii_renderer* s_renderer{};
-LLGL::CommandBuffer* command_buffer{};
-LLGL::CommandBuffer* static_command_buffer{};
-LLGL::CommandBuffer* postprocess_command_buffer{};
 
 // renderer_texture* renderer::load_image(const std::string& file_path, texture_format in_format) {
 //     int width, height, channels;
@@ -76,9 +73,10 @@ LLGL::CommandBuffer* postprocess_command_buffer{};
 //     return texture;
 // }
 
-bool aorii::init(renderer_api in_api) {
+bool aorii::init() {
-    create_renderer(in_api);
+    create_renderer();
     create_window_manager();
+    return true;
 }
 
 void aorii::destroy() {
@@ -86,47 +84,17 @@ void aorii::destroy() {
     destroy_renderer();
 }
 
-LLGL::RenderSystem* aorii::get_renderer() {
+aorii_renderer* aorii::get_renderer() {
-    return s_renderer.get();
+    return s_renderer;
 }
 
-LLGL::CommandBuffer* aorii::get_command_buffer() {
+bool aorii::create_renderer() {
-    return command_buffer;
-}
-
-LLGL::CommandQueue* aorii::get_command_queue() {
-    return s_renderer->GetCommandQueue();
-}
-
-bool aorii::create_renderer(renderer_api api) {
     if (!aorii_text::init_freetype())
         return false;
     begin_time = std::chrono::high_resolution_clock::now();
     if (s_renderer) return true;
 
-    LLGL::RenderSystemDescriptor desc;
+    s_renderer = new aorii_renderer();
-    switch (api) {
-        case renderer_api::DX11:
-            desc.moduleName = "Direct3D11";
-            break;
-        case renderer_api::DX12:
-            desc.moduleName = "Direct3D12";
-            break;
-        case renderer_api::vulkan:
-            desc.moduleName = "Vulkan";
-            break;
-        case renderer_api::opengl:
-            desc.moduleName = "OpenGL";
-            break;
-        case renderer_api::metal:
-            desc.moduleName = "Metal";
-            break;
-        default: spdlog::critical("Failed to create renderer!");
-            assert(false);
-    }
-
-    s_renderer = LLGL::RenderSystem::Load(desc);
-    command_buffer = s_renderer->CreateCommandBuffer();
     last_time = std::chrono::high_resolution_clock::now();
     return s_renderer != nullptr;
 }
@@ -134,7 +102,7 @@ bool aorii::create_renderer(renderer_api api) {
 void aorii::destroy_renderer() {
     if (!s_renderer) return;
 
-    LLGL::RenderSystem::Unload(std::move(s_renderer));
+    delete s_renderer;
     aorii_text::destroy_freetype();
 }
 
@@ -145,14 +113,8 @@ void aorii::update() {
     delta_time = current_time - last_time;
     last_time = current_time;
 
-    LLGL::Surface::ProcessEvents();
     s_window_manager->update();
 
-    command_buffer->Begin();
-    command_buffer->;
-    command_buffer->End();
-    get_command_queue()->Submit(*command_buffer);
-
     std::this_thread::yield();
 }
 

src/core/renderer/renderer.h

@@ -1,36 +1,22 @@
 #pragma once
 #include <chrono>
 #include <filesystem>
+#include <vulkan/vulkan.hpp>
 
-#include "LLGL/RenderSystem.h"
+class aorii_renderer {
+public:
 
-enum class renderer_api {
+private:
-    opengl,
-    opengl_es,
-    webgl,
-    vulkan,
-    DX11,
-    DX12,
-    metal
-};
 
-struct postprocess_render_pass {
-    LLGL::RenderTarget* input_render_target;
-    LLGL::RenderTarget* output_render_target;
-    LLGL::Texture* result_texture;
-    LLGL::PipelineState* pipeline_state;
-    LLGL::ResourceHeap* resource;
 };
 
 namespace aorii {
-    bool init(renderer_api in_api);
+    bool init();
     void destroy();
 
-    LLGL::RenderSystem* get_renderer();
+    aorii_renderer* get_renderer();
-    LLGL::CommandBuffer* get_command_buffer();
-    LLGL::CommandQueue* get_command_queue();
 
-    bool create_renderer(renderer_api api);
+    bool create_renderer();
     void destroy_renderer();
     void update();
 

src/core/window/renderer_window.h

@@ -1,29 +1,12 @@
 #pragma once
 #include "renderer/renderer.h"
-#include "LLGL/SwapChain.h"
-#include "LLGL/Window.h"
 
-#if MACOS
+#include "vulkan/vulkan.hpp"
-#elif WINDOWS
-#include "LLGL/Platform/Win32/Win32NativeHandle.h"
-#elif LINUX
-#include "LLGL/Platform/Linux/LinuxNativeHandle.h"
-#endif
 
 class renderer_window {
     friend class window_manager;
 public:
-    using desc_type      = LLGL::SwapChainDescriptor;
+    explicit renderer_window();
-
-#if IS_MOBILE
-    using surface_type   = LLGL::Canvas;
-    using event_listener = LLGL::Canvas::EventListener;
-#else
-    using surface_type   = LLGL::Window;
-    using event_listener = LLGL::Window::EventListener;
-#endif
-
-    explicit renderer_window(const desc_type& in_desc);
 
     virtual ~renderer_window();
 
@@ -35,8 +18,8 @@ public:
 
     [[nodiscard]] void* get_native_handle() const;
 private:
-    surface_type* surface       = nullptr;
+    vk::SwapchainKHR swap_chain;
-    LLGL::SwapChain* swap_chain = nullptr;
+    vk::SurfaceKHR surface;
 };
 
 inline renderer_window::renderer_window(const desc_type& in_desc) {
@@ -51,18 +34,20 @@ inline void renderer_window::set_title(const std::wstring& in_title) const {
 }
 
 inline void renderer_window::close() const {
-#if !IS_MOBILE
+#if !AORII_IS_MOBILE
     if (const auto window = get_surface()) { window->Show(false); }
 #endif
 }
 
-#if !MACOS
+#if !AORII_MACOS
 inline void* renderer_window::get_native_handle() const {
-#if !IS_MOBILE
+#if !AORII_IS_MOBILE
     if (auto surface = get_surface()) {
-#if WINDOWS
+        LLGL::NativeHandle native_handle;
+        surface->GetNativeHandle(&native_handle, sizeof(LLGL::NativeHandle));
+#if AORII_WINDOWS
         return native_handle.window;
-#elif LINUX
+#elif AORII_LINUX
         return native_handle.window;
 #endif
     }