feat(服务定位器): 实现服务自动注册机制并重构服务初始化流程

添加服务自动注册宏E2D_AUTO_REGISTER_SERVICE，通过模板元编程实现编译期服务注册
重构Application初始化流程，移除手动服务注册代码，改为自动注册方式
统一各服务实现类的代码风格，优化缩进和格式

Extra2D/include/extra2d/app/application.h

@@ -1,11 +1,10 @@
 #pragma once
 
-#include <extra2d/core/types.h>
+#include <extra2d/config/app_config.h>
 #include <extra2d/core/module.h>
 #include <extra2d/core/registry.h>
 #include <extra2d/core/service_locator.h>
-#include <extra2d/config/app_config.h>
+#include <extra2d/core/types.h>
-#include <string>
 
 namespace extra2d {
 
@@ -32,8 +31,7 @@ public:
    * @tparam Args 构造函数参数
    * @return 模块指针
    */
-    template<typename T, typename... Args>
+  template <typename T, typename... Args> T *use(Args &&...args) {
-    T* use(Args&&... args) {
     return Registry::instance().use<T>(std::forward<Args>(args)...);
   }
 
@@ -42,10 +40,7 @@ public:
    * @tparam T 模块类型
    * @return 模块指针
    */
-    template<typename T>
+  template <typename T> T *get() const { return Registry::instance().get<T>(); }
-    T* get() const {
-        return Registry::instance().get<T>();
-    }
 
   /**
    * @brief 初始化
@@ -123,7 +118,7 @@ private:
   void mainLoop();
   void update();
   void render();
-    void registerCoreServices();
+  void configureCameraService();
 
   bool initialized_ = false;
   bool running_ = false;

Extra2D/include/extra2d/core/service_locator.h

@@ -1,22 +1,21 @@
 #pragma once
 
+#include <algorithm>
 #include <extra2d/core/service_interface.h>
 #include <extra2d/core/types.h>
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <typeindex>
 #include <unordered_map>
 #include <vector>
-#include <mutex>
-#include <functional>
-#include <typeindex>
-#include <memory>
-#include <algorithm>
 
 namespace extra2d {
 
 /**
  * @brief 服务工厂函数类型
  */
-template<typename T>
+template <typename T> using ServiceFactory = std::function<SharedPtr<T>()>;
-using ServiceFactory = std::function<SharedPtr<T>()>;
 
 /**
  * @brief 服务定位器
@@ -45,8 +44,7 @@ public:
    * @tparam T 服务接口类型
    * @param service 服务实例
    */
-    template<typename T>
+  template <typename T> void registerService(SharedPtr<T> service) {
-    void registerService(SharedPtr<T> service) {
     static_assert(std::is_base_of_v<IService, T>,
                   "T must derive from IService");
 
@@ -62,8 +60,7 @@ public:
    * @tparam T 服务接口类型
    * @param factory 服务工厂函数
    */
-    template<typename T>
+  template <typename T> void registerFactory(ServiceFactory<T> factory) {
-    void registerFactory(ServiceFactory<T> factory) {
     static_assert(std::is_base_of_v<IService, T>,
                   "T must derive from IService");
 
@@ -72,6 +69,12 @@ public:
     factories_[typeId] = [factory]() -> SharedPtr<IService> {
       return std::static_pointer_cast<IService>(factory());
     };
+
+    // 立即创建服务实例并添加到有序列表
+    auto service = factories_[typeId]();
+    services_[typeId] = service;
+    orderedServices_.push_back(service);
+    sortServices();
   }
 
   /**
@@ -79,8 +82,7 @@ public:
    * @tparam T 服务接口类型
    * @return 服务实例，不存在返回 nullptr
    */
-    template<typename T>
+  template <typename T> SharedPtr<T> getService() const {
-    SharedPtr<T> getService() const {
     static_assert(std::is_base_of_v<IService, T>,
                   "T must derive from IService");
 
@@ -107,8 +109,7 @@ public:
    * @tparam T 服务接口类型
    * @return 服务实例，不存在返回 nullptr
    */
-    template<typename T>
+  template <typename T> SharedPtr<T> tryGetService() const {
-    SharedPtr<T> tryGetService() const {
     static_assert(std::is_base_of_v<IService, T>,
                   "T must derive from IService");
 
@@ -126,8 +127,7 @@ public:
    * @tparam T 服务接口类型
    * @return 已注册返回 true
    */
-    template<typename T>
+  template <typename T> bool hasService() const {
-    bool hasService() const {
     std::lock_guard<std::mutex> lock(mutex_);
     auto typeId = std::type_index(typeid(T));
     return services_.find(typeId) != services_.end() ||
@@ -138,8 +138,7 @@ public:
    * @brief 注销服务
    * @tparam T 服务接口类型
    */
-    template<typename T>
+  template <typename T> void unregisterService() {
-    void unregisterService() {
     std::lock_guard<std::mutex> lock(mutex_);
     auto typeId = std::type_index(typeid(T));
 
@@ -148,8 +147,8 @@ public:
       auto service = it->second;
       services_.erase(it);
 
-            auto orderIt = std::find(orderedServices_.begin(), 
+      auto orderIt =
-                                     orderedServices_.end(), service);
+          std::find(orderedServices_.begin(), orderedServices_.end(), service);
       if (orderIt != orderedServices_.end()) {
         orderedServices_.erase(orderIt);
       }
@@ -212,7 +211,8 @@ private:
   void sortServices();
 
   mutable std::unordered_map<std::type_index, SharedPtr<IService>> services_;
-    std::unordered_map<std::type_index, std::function<SharedPtr<IService>()>> factories_;
+  std::unordered_map<std::type_index, std::function<SharedPtr<IService>()>>
+      factories_;
   std::vector<SharedPtr<IService>> orderedServices_;
   mutable std::mutex mutex_;
 };
@@ -221,8 +221,7 @@ private:
  * @brief 服务注册器
  * 用于静态注册服务
  */
-template<typename Interface, typename Implementation>
+template <typename Interface, typename Implementation> class ServiceRegistrar {
-class ServiceRegistrar {
 public:
   explicit ServiceRegistrar(ServiceFactory<Interface> factory = nullptr) {
     if (factory) {
@@ -231,22 +230,73 @@ public:
       ServiceLocator::instance().registerFactory<Interface>(
           []() -> SharedPtr<Interface> {
             return makeShared<Implementation>();
-                }
+          });
-            );
     }
   }
 };
 
-} 
+/**
+ * @brief 服务注册元数据模板
+ * 使用模板元编程实现编译期服务注册
+ * 通过静态成员变量的初始化触发注册
+ */
+template <typename Interface, typename Implementation> struct ServiceAutoReg {
+  /**
+   * @brief 注册标记，访问此变量时触发服务注册
+   */
+  static const bool registered;
 
-#define E2D_REGISTER_SERVICE(Interface, Implementation) \
+  /**
-    namespace { \
+   * @brief 执行实际的服务注册
-        static ::extra2d::ServiceRegistrar<Interface, Implementation> \
+   * @return true 表示注册成功
-            E2D_CONCAT(service_registrar_, __LINE__); \
+   */
+  static bool doRegister() {
+    ::extra2d::ServiceLocator::instance().registerFactory<Interface>(
+        []() -> ::extra2d::SharedPtr<Interface> {
+          return ::extra2d::makeShared<Implementation>();
+        });
+    return true;
   }
+};
 
-#define E2D_REGISTER_SERVICE_FACTORY(Interface, Factory) \
+// 静态成员定义，在此处触发注册
-    namespace { \
+template <typename Interface, typename Implementation>
-        static ::extra2d::ServiceRegistrar<Interface, Interface> \
+const bool ServiceAutoReg<Interface, Implementation>::registered =
-            E2D_CONCAT(service_factory_registrar_, __LINE__)(Factory); \
+    ServiceAutoReg<Interface, Implementation>::doRegister();
+
+/**
+ * @brief 服务注册元数据（带自定义工厂）
+ */
+template <typename Interface> struct ServiceAutoRegFactory {
+  template <typename Factory> struct Impl {
+    static const bool registered;
+
+    static bool doRegister(Factory factory) {
+      ::extra2d::ServiceLocator::instance().registerFactory<Interface>(factory);
+      return true;
     }
+  };
+};
+
+template <typename Interface>
+template <typename Factory>
+const bool ServiceAutoRegFactory<Interface>::Impl<Factory>::registered =
+    ServiceAutoRegFactory<Interface>::Impl<Factory>::doRegister(Factory{});
+
+/**
+ * @brief 自动注册服务宏（元数据驱动）
+ * 在服务实现类中使用，通过模板元编程实现自动注册
+ * 比静态对象更可靠，不易被编译器优化
+ */
+#define E2D_AUTO_REGISTER_SERVICE(Interface, Implementation)                   \
+  static inline const bool E2D_CONCAT(_service_reg_, __LINE__) =               \
+      ServiceAutoReg<Interface, Implementation>::registered
+
+/**
+ * @brief 带自定义工厂的自动注册服务宏（元数据驱动）
+ */
+#define E2D_AUTO_REGISTER_SERVICE_FACTORY(Interface, Factory)                  \
+  static inline const bool E2D_CONCAT(_service_factory_reg_, __LINE__) =       \
+      ServiceAutoRegFactory<Interface>::Impl<Factory>::registered
+
+} // namespace extra2d

Extra2D/include/extra2d/services/camera_service.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <extra2d/core/service_interface.h>
+#include <extra2d/core/service_locator.h>
 #include <extra2d/graphics/camera/camera.h>
 #include <extra2d/graphics/camera/viewport_adapter.h>
 
@@ -106,6 +107,9 @@ public:
 private:
     Camera camera_;
     ViewportAdapter viewportAdapter_;
+
+    // 服务注册元数据
+    E2D_AUTO_REGISTER_SERVICE(ICameraService, CameraService);
 };
 
 } 

Extra2D/include/extra2d/services/event_service.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <extra2d/core/service_interface.h>
+#include <extra2d/core/service_locator.h>
 #include <extra2d/event/event_dispatcher.h>
 #include <extra2d/event/event_queue.h>
 
@@ -68,6 +69,9 @@ public:
 private:
     EventQueue queue_;
     EventDispatcher dispatcher_;
+
+    // 服务注册元数据
+    E2D_AUTO_REGISTER_SERVICE(IEventService, EventService);
 };
 
 } 

Extra2D/include/extra2d/services/logger_service.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <extra2d/core/service_interface.h>
+#include <extra2d/core/service_locator.h>
 #include <extra2d/core/types.h>
 #include <cstdarg>
 #include <string>
@@ -124,6 +125,9 @@ private:
     LogLevel level_;
     class Impl;
     UniquePtr<Impl> impl_;
+
+    // 服务注册元数据
+    E2D_AUTO_REGISTER_SERVICE(ILogger, ConsoleLogger);
 };
 
 } // namespace extra2d

Extra2D/include/extra2d/services/scene_service.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <extra2d/core/service_interface.h>
+#include <extra2d/core/service_locator.h>
 #include <extra2d/scene/scene_manager.h>
 
 namespace extra2d {
@@ -86,6 +87,9 @@ public:
 
 private:
     SceneManager manager_;
+
+    // 服务注册元数据
+    E2D_AUTO_REGISTER_SERVICE(ISceneService, SceneService);
 };
 
 } 

Extra2D/include/extra2d/services/timer_service.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <extra2d/core/service_interface.h>
+#include <extra2d/core/service_locator.h>
 #include <extra2d/utils/timer.h>
 
 namespace extra2d {
@@ -48,6 +49,9 @@ public:
 
 private:
     TimerManager manager_;
+
+    // 服务注册元数据
+    E2D_AUTO_REGISTER_SERVICE(ITimerService, TimerService);
 };
 
 } 

Extra2D/src/app/application.cpp

@@ -14,8 +14,6 @@
 #include <extra2d/services/timer_service.h>
 
 
-#include <chrono>
-
 namespace extra2d {
 
 static double getTimeSeconds() {
@@ -57,58 +55,44 @@ bool Application::init(const AppConfig &config) {
 
   appConfig_ = config;
 
-  // 首先注册日志服务（模块初始化可能需要它）
-  auto &locator = ServiceLocator::instance();
-  if (!locator.hasService<ILogger>()) {
-    auto logger = makeShared<ConsoleLogger>();
-    locator.registerService(std::static_pointer_cast<ILogger>(logger));
-  }
-
   // 初始化所有模块（拓扑排序）
+  // 服务通过 E2D_AUTO_REGISTER_SERVICE 宏自动注册
   if (!Registry::instance().init()) {
     return false;
   }
 
-  // 模块初始化完成后，注册其他核心服务
+  // 配置相机服务（需要窗口信息）
-  registerCoreServices();
+  configureCameraService();
+
+  // 初始化所有服务
+  ServiceLocator::instance().initializeAll();
 
   initialized_ = true;
   running_ = true;
   return true;
 }
 
-void Application::registerCoreServices() {
+void Application::configureCameraService() {
-  auto &locator = ServiceLocator::instance();
-
-  if (!locator.hasService<ISceneService>()) {
-    auto service = makeShared<SceneService>();
-    locator.registerService(std::static_pointer_cast<ISceneService>(service));
-  }
-
-  if (!locator.hasService<ITimerService>()) {
-    auto service = makeShared<TimerService>();
-    locator.registerService(std::static_pointer_cast<ITimerService>(service));
-  }
-
-  if (!locator.hasService<IEventService>()) {
-    auto service = makeShared<EventService>();
-    locator.registerService(std::static_pointer_cast<IEventService>(service));
-  }
-
   auto *winMod = get<WindowModule>();
-  if (winMod && winMod->win() && !locator.hasService<ICameraService>()) {
+  if (!winMod || !winMod->win()) {
-    auto cameraService = makeShared<CameraService>();
+    return;
+  }
+
+  auto cameraService = ServiceLocator::instance().getService<ICameraService>();
+  if (!cameraService) {
+    return;
+  }
+
   auto *win = winMod->win();
   cameraService->setViewport(0, static_cast<float>(win->width()),
                              static_cast<float>(win->height()), 0);
+
   ViewportConfig vpConfig;
   vpConfig.logicWidth = static_cast<float>(win->width());
   vpConfig.logicHeight = static_cast<float>(win->height());
   vpConfig.mode = ViewportMode::AspectRatio;
   cameraService->setViewportConfig(vpConfig);
   cameraService->updateViewport(win->width(), win->height());
-    locator.registerService(
-        std::static_pointer_cast<ICameraService>(cameraService));
 
   win->onResize([cameraService](int width, int height) {
     cameraService->updateViewport(width, height);
@@ -116,15 +100,13 @@ void Application::registerCoreServices() {
   });
 }
 
-  locator.initializeAll();
-}
-
 void Application::shutdown() {
   if (!initialized_)
     return;
 
   VRAMMgr::get().printStats();
 
+  ServiceLocator::instance().shutdownAll();
   ServiceLocator::instance().clear();
   Registry::instance().shutdown();
   Registry::instance().clear();

Extra2D/src/services/camera_service.cpp

@@ -15,9 +15,7 @@ CameraService::CameraService(float left, float right, float bottom, float top)
   info_.enabled = true;
 }
 
-ServiceInfo CameraService::getServiceInfo() const {
+ServiceInfo CameraService::getServiceInfo() const { return info_; }
-    return info_;
-}
 
 bool CameraService::initialize() {
   camera_.setViewportAdapter(&viewportAdapter_);
@@ -25,45 +23,30 @@ bool CameraService::initialize() {
   return true;
 }
 
-void CameraService::shutdown() {
+void CameraService::shutdown() { setState(ServiceState::Stopped); }
-    setState(ServiceState::Stopped);
-}
 
 void CameraService::setPosition(const Vec2 &position) {
   camera_.setPos(position);
 }
 
-void CameraService::setPosition(float x, float y) {
+void CameraService::setPosition(float x, float y) { camera_.setPos(x, y); }
-    camera_.setPos(x, y);
-}
 
-Vec2 CameraService::getPosition() const {
+Vec2 CameraService::getPosition() const { return camera_.getPosition(); }
-    return camera_.getPosition();
-}
 
-void CameraService::setRotation(float degrees) {
+void CameraService::setRotation(float degrees) { camera_.setRotation(degrees); }
-    camera_.setRotation(degrees);
-}
 
-float CameraService::getRotation() const {
+float CameraService::getRotation() const { return camera_.getRotation(); }
-    return camera_.getRotation();
-}
 
-void CameraService::setZoom(float zoom) {
+void CameraService::setZoom(float zoom) { camera_.setZoom(zoom); }
-    camera_.setZoom(zoom);
-}
 
-float CameraService::getZoom() const {
+float CameraService::getZoom() const { return camera_.getZoom(); }
-    return camera_.getZoom();
-}
 
-void CameraService::setViewport(float left, float right, float bottom, float top) {
+void CameraService::setViewport(float left, float right, float bottom,
+                                float top) {
   camera_.setViewport(left, right, bottom, top);
 }
 
-Rect CameraService::getViewport() const {
+Rect CameraService::getViewport() const { return camera_.getViewport(); }
-    return camera_.getViewport();
-}
 
 glm::mat4 CameraService::getViewMatrix() const {
   return camera_.getViewMatrix();
@@ -85,25 +68,15 @@ Vec2 CameraService::worldToScreen(const Vec2& worldPos) const {
   return camera_.worldToScreen(worldPos);
 }
 
-void CameraService::move(const Vec2& offset) {
+void CameraService::move(const Vec2 &offset) { camera_.move(offset); }
-    camera_.move(offset);
-}
 
-void CameraService::move(float x, float y) {
+void CameraService::move(float x, float y) { camera_.move(x, y); }
-    camera_.move(x, y);
-}
 
-void CameraService::setBounds(const Rect& bounds) {
+void CameraService::setBounds(const Rect &bounds) { camera_.setBounds(bounds); }
-    camera_.setBounds(bounds);
-}
 
-void CameraService::clearBounds() {
+void CameraService::clearBounds() { camera_.clearBounds(); }
-    camera_.clearBounds();
-}
 
-void CameraService::lookAt(const Vec2& target) {
+void CameraService::lookAt(const Vec2 &target) { camera_.lookAt(target); }
-    camera_.lookAt(target);
-}
 
 void CameraService::setViewportConfig(const ViewportConfig &config) {
   viewportAdapter_.setConfig(config);
@@ -121,8 +94,6 @@ const ViewportResult& CameraService::getViewportResult() const {
   return viewportAdapter_.getResult();
 }
 
-void CameraService::applyViewportAdapter() {
+void CameraService::applyViewportAdapter() { camera_.applyViewportAdapter(); }
-    camera_.applyViewportAdapter();
-}
 
-} 
+} // namespace extra2d

Extra2D/src/services/event_service.cpp

@@ -8,9 +8,7 @@ EventService::EventService() {
   info_.enabled = true;
 }
 
-ServiceInfo EventService::getServiceInfo() const {
+ServiceInfo EventService::getServiceInfo() const { return info_; }
-    return info_;
-}
 
 bool EventService::initialize() {
   setState(ServiceState::Running);
@@ -29,19 +27,14 @@ void EventService::update(float deltaTime) {
   }
 }
 
-void EventService::pushEvent(const Event& event) {
+void EventService::pushEvent(const Event &event) { queue_.push(event); }
-    queue_.push(event);
-}
 
-void EventService::pushEvent(Event&& event) {
+void EventService::pushEvent(Event &&event) { queue_.push(std::move(event)); }
-    queue_.push(std::move(event));
-}
 
-bool EventService::pollEvent(Event& event) {
+bool EventService::pollEvent(Event &event) { return queue_.poll(event); }
-    return queue_.poll(event);
-}
 
-ListenerId EventService::addListener(EventType type, EventDispatcher::EventCallback callback) {
+ListenerId EventService::addListener(EventType type,
+                                     EventDispatcher::EventCallback callback) {
   return dispatcher_.addListener(type, callback);
 }
 
@@ -53,17 +46,11 @@ void EventService::removeAllListeners(EventType type) {
   dispatcher_.removeAllListeners(type);
 }
 
-void EventService::removeAllListeners() {
+void EventService::removeAllListeners() { dispatcher_.removeAllListeners(); }
-    dispatcher_.removeAllListeners();
-}
 
-void EventService::dispatch(Event& event) {
+void EventService::dispatch(Event &event) { dispatcher_.dispatch(event); }
-    dispatcher_.dispatch(event);
-}
 
-void EventService::processQueue() {
+void EventService::processQueue() { dispatcher_.processQueue(queue_); }
-    dispatcher_.processQueue(queue_);
-}
 
 size_t EventService::getListenerCount(EventType type) const {
   return dispatcher_.getListenerCount(type);
@@ -73,8 +60,6 @@ size_t EventService::getTotalListenerCount() const {
   return dispatcher_.getTotalListenerCount();
 }
 
-size_t EventService::getQueueSize() const {
+size_t EventService::getQueueSize() const { return queue_.size(); }
-    return queue_.size();
-}
 
-} 
+} // namespace extra2d

Extra2D/src/services/logger_service.cpp

@@ -1,10 +1,7 @@
-#include <extra2d/services/logger_service.h>
-#include <extra2d/core/service_locator.h>
-#include <cstdio>
-#include <cstdarg>
 #include <chrono>
-#include <iomanip>
+#include <cstdarg>
-#include <sstream>
+#include <cstdio>
+#include <extra2d/services/logger_service.h>
 #include <mutex>
 
 namespace extra2d {
@@ -15,7 +12,8 @@ public:
   std::mutex mutex_;
 };
 
-ConsoleLogger::ConsoleLogger() : level_(LogLevel::Info), impl_(std::make_unique<Impl>()) {
+ConsoleLogger::ConsoleLogger()
+    : level_(LogLevel::Info), impl_(std::make_unique<Impl>()) {
   info_.name = "ConsoleLogger";
   info_.priority = ServicePriority::Core;
 }
@@ -27,24 +25,19 @@ bool ConsoleLogger::initialize() {
   return true;
 }
 
-void ConsoleLogger::shutdown() {
+void ConsoleLogger::shutdown() { setState(ServiceState::Stopped); }
-    setState(ServiceState::Stopped);
-}
 
-void ConsoleLogger::setLevel(LogLevel level) {
+void ConsoleLogger::setLevel(LogLevel level) { level_ = level; }
-    level_ = level;
-}
 
-LogLevel ConsoleLogger::getLevel() const {
+LogLevel ConsoleLogger::getLevel() const { return level_; }
-    return level_;
-}
 
 bool ConsoleLogger::isEnabled(LogLevel level) const {
   return static_cast<int>(level) >= static_cast<int>(level_);
 }
 
 void ConsoleLogger::log(LogLevel level, const char *fmt, ...) {
-    if (!isEnabled(level)) return;
+  if (!isEnabled(level))
+    return;
 
   char buffer[1024];
   va_list args;
@@ -56,12 +49,14 @@ void ConsoleLogger::log(LogLevel level, const char* fmt, ...) {
 }
 
 void ConsoleLogger::log(LogLevel level, const std::string &msg) {
-    if (!isEnabled(level)) return;
+  if (!isEnabled(level))
+    return;
   output(level, msg.c_str());
 }
 
 void ConsoleLogger::trace(const char *fmt, ...) {
-    if (!isEnabled(LogLevel::Trace)) return;
+  if (!isEnabled(LogLevel::Trace))
+    return;
   char buffer[1024];
   va_list args;
   va_start(args, fmt);
@@ -71,7 +66,8 @@ void ConsoleLogger::trace(const char* fmt, ...) {
 }
 
 void ConsoleLogger::debug(const char *fmt, ...) {
-    if (!isEnabled(LogLevel::Debug)) return;
+  if (!isEnabled(LogLevel::Debug))
+    return;
   char buffer[1024];
   va_list args;
   va_start(args, fmt);
@@ -81,7 +77,8 @@ void ConsoleLogger::debug(const char* fmt, ...) {
 }
 
 void ConsoleLogger::info(const char *fmt, ...) {
-    if (!isEnabled(LogLevel::Info)) return;
+  if (!isEnabled(LogLevel::Info))
+    return;
   char buffer[1024];
   va_list args;
   va_start(args, fmt);
@@ -91,7 +88,8 @@ void ConsoleLogger::info(const char* fmt, ...) {
 }
 
 void ConsoleLogger::warn(const char *fmt, ...) {
-    if (!isEnabled(LogLevel::Warn)) return;
+  if (!isEnabled(LogLevel::Warn))
+    return;
   char buffer[1024];
   va_list args;
   va_start(args, fmt);
@@ -101,7 +99,8 @@ void ConsoleLogger::warn(const char* fmt, ...) {
 }
 
 void ConsoleLogger::error(const char *fmt, ...) {
-    if (!isEnabled(LogLevel::Error)) return;
+  if (!isEnabled(LogLevel::Error))
+    return;
   char buffer[1024];
   va_list args;
   va_start(args, fmt);
@@ -111,7 +110,8 @@ void ConsoleLogger::error(const char* fmt, ...) {
 }
 
 void ConsoleLogger::fatal(const char *fmt, ...) {
-    if (!isEnabled(LogLevel::Fatal)) return;
+  if (!isEnabled(LogLevel::Fatal))
+    return;
   char buffer[1024];
   va_list args;
   va_start(args, fmt);
@@ -126,7 +126,8 @@ void ConsoleLogger::output(LogLevel level, const char* msg) {
   auto now = std::chrono::system_clock::now();
   auto time = std::chrono::system_clock::to_time_t(now);
   auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
-        now.time_since_epoch()) % 1000;
+                now.time_since_epoch()) %
+            1000;
 
   std::tm tm;
 #ifdef _WIN32
@@ -142,29 +143,48 @@ void ConsoleLogger::output(LogLevel level, const char* msg) {
   const char *reset = "\033[0m";
 
   switch (level) {
-        case LogLevel::Trace: color = "\033[90m"; break;
+  case LogLevel::Trace:
-        case LogLevel::Debug: color = "\033[36m"; break;
+    color = "\033[90m";
-        case LogLevel::Info:  color = "\033[32m"; break;
+    break;
-        case LogLevel::Warn:  color = "\033[33m"; break;
+  case LogLevel::Debug:
-        case LogLevel::Error: color = "\033[31m"; break;
+    color = "\033[36m";
-        case LogLevel::Fatal: color = "\033[35m"; break;
+    break;
-        default: break;
+  case LogLevel::Info:
+    color = "\033[32m";
+    break;
+  case LogLevel::Warn:
+    color = "\033[33m";
+    break;
+  case LogLevel::Error:
+    color = "\033[31m";
+    break;
+  case LogLevel::Fatal:
+    color = "\033[35m";
+    break;
+  default:
+    break;
   }
 
-    printf("%s[%02d:%02d:%02d.%03d] [%s] %s%s\n", 
+  printf("%s[%02d:%02d:%02d.%03d] [%s] %s%s\n", color, tm.tm_hour, tm.tm_min,
-           color, tm.tm_hour, tm.tm_min, tm.tm_sec, (int)ms.count(), 
+         tm.tm_sec, (int)ms.count(), levelStr, msg, reset);
-           levelStr, msg, reset);
 }
 
 const char *ConsoleLogger::getLevelString(LogLevel level) {
   switch (level) {
-        case LogLevel::Trace: return "TRACE";
+  case LogLevel::Trace:
-        case LogLevel::Debug: return "DEBUG";
+    return "TRACE";
-        case LogLevel::Info:  return "INFO";
+  case LogLevel::Debug:
-        case LogLevel::Warn:  return "WARN";
+    return "DEBUG";
-        case LogLevel::Error: return "ERROR";
+  case LogLevel::Info:
-        case LogLevel::Fatal: return "FATAL";
+    return "INFO";
-        default: return "UNKNOWN";
+  case LogLevel::Warn:
+    return "WARN";
+  case LogLevel::Error:
+    return "ERROR";
+  case LogLevel::Fatal:
+    return "FATAL";
+  default:
+    return "UNKNOWN";
   }
 }
 

Extra2D/src/services/scene_service.cpp

@@ -8,9 +8,7 @@ SceneService::SceneService() {
   info_.enabled = true;
 }
 
-ServiceInfo SceneService::getServiceInfo() const {
+ServiceInfo SceneService::getServiceInfo() const { return info_; }
-    return info_;
-}
 
 bool SceneService::initialize() {
   setState(ServiceState::Running);
@@ -36,17 +34,11 @@ void SceneService::replaceScene(Ptr<Scene> scene) {
   manager_.replaceScene(scene);
 }
 
-void SceneService::pushScene(Ptr<Scene> scene) {
+void SceneService::pushScene(Ptr<Scene> scene) { manager_.pushScene(scene); }
-    manager_.pushScene(scene);
-}
 
-void SceneService::popScene() {
+void SceneService::popScene() { manager_.popScene(); }
-    manager_.popScene();
-}
 
-void SceneService::popToRootScene() {
+void SceneService::popToRootScene() { manager_.popToRootScene(); }
-    manager_.popToRootScene();
-}
 
 void SceneService::popToScene(const std::string &name) {
   manager_.popToScene(name);
@@ -68,13 +60,9 @@ Ptr<Scene> SceneService::getSceneByName(const std::string& name) const {
   return manager_.getSceneByName(name);
 }
 
-size_t SceneService::getSceneCount() const {
+size_t SceneService::getSceneCount() const { return manager_.getSceneCount(); }
-    return manager_.getSceneCount();
-}
 
-bool SceneService::isEmpty() const {
+bool SceneService::isEmpty() const { return manager_.isEmpty(); }
-    return manager_.isEmpty();
-}
 
 bool SceneService::hasScene(const std::string &name) const {
   return manager_.hasScene(name);
@@ -92,20 +80,15 @@ bool SceneService::isTransitioning() const {
   return manager_.isTransitioning();
 }
 
-void SceneService::setTransitionCallback(SceneManager::TransitionCallback callback) {
+void SceneService::setTransitionCallback(
+    SceneManager::TransitionCallback callback) {
   manager_.setTransitionCallback(callback);
 }
 
-void SceneService::end() {
+void SceneService::end() { manager_.end(); }
-    manager_.end();
-}
 
-void SceneService::purgeCachedScenes() {
+void SceneService::purgeCachedScenes() { manager_.purgeCachedScenes(); }
-    manager_.purgeCachedScenes();
-}
 
-void SceneService::enterScene(Ptr<Scene> scene) {
+void SceneService::enterScene(Ptr<Scene> scene) { manager_.enterScene(scene); }
-    manager_.enterScene(scene);
-}
 
-} 
+} // namespace extra2d

Extra2D/src/services/timer_service.cpp

@@ -8,9 +8,7 @@ TimerService::TimerService() {
   info_.enabled = true;
 }
 
-ServiceInfo TimerService::getServiceInfo() const {
+ServiceInfo TimerService::getServiceInfo() const { return info_; }
-    return info_;
-}
 
 bool TimerService::initialize() {
   setState(ServiceState::Running);
@@ -32,7 +30,8 @@ uint32 TimerService::addTimer(float delay, Timer::Callback callback) {
   return manager_.addTimer(delay, callback);
 }
 
-uint32 TimerService::addRepeatingTimer(float interval, Timer::Callback callback) {
+uint32 TimerService::addRepeatingTimer(float interval,
+                                       Timer::Callback callback) {
   return manager_.addRepeatingTimer(interval, callback);
 }
 
@@ -40,20 +39,14 @@ void TimerService::cancelTimer(uint32 timerId) {
   manager_.cancelTimer(timerId);
 }
 
-void TimerService::pauseTimer(uint32 timerId) {
+void TimerService::pauseTimer(uint32 timerId) { manager_.pauseTimer(timerId); }
-    manager_.pauseTimer(timerId);
-}
 
 void TimerService::resumeTimer(uint32 timerId) {
   manager_.resumeTimer(timerId);
 }
 
-void TimerService::clear() {
+void TimerService::clear() { manager_.clear(); }
-    manager_.clear();
-}
 
-size_t TimerService::getTimerCount() const {
+size_t TimerService::getTimerCount() const { return manager_.getTimerCount(); }
-    return manager_.getTimerCount();
-}
 
-} 
+} // namespace extra2d