RiCoCoSoul
/
Extra2D
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: RiCoCoSoul:f9e244299fea479a3ba9225cf4d86d817c549159
Branches Tags
RiCoCoSoul:master
RiCoCoSoul:main
...
compare: RiCoCoSoul:4e6db88da5cc457c744a960d1a02b036bc37bd9f
Branches Tags
RiCoCoSoul:main
RiCoCoSoul:master

2 Commits
f9e244299f ... 4e6db88da5

Author SHA1 Message Date
ChestnutYueyue 4e6db88da5 docs: 删除废弃的资源服务设计文档 
该文档已不再使用，其内容已被迁移到新的设计文档中
 2026-02-20 19:03:13 +08:00
ChestnutYueyue b41e96d870 refactor(core): 统一命名规范并优化核心模块结构 
重构智能指针、基础类型和核心组件的命名，使用更简洁一致的命名风格：
- 将 UniquePtr/SharedPtr 简化为 Unique/Ref
- 基础类型使用 i32/u32/f32 等更短名称
- 方法名统一为小写驼峰，如 getServiceInfo() 改为 info()
- 模块初始化方法 parallel() 替代 allowParallelInit()

新增核心组件：
- 添加 ObjectPool 对象池模板类
- 添加 RingBuffer 环形缓冲区模板类
- 添加编译期类型ID生成机制

优化现有组件：
- 事件队列改用 RingBuffer 实现
- 服务注册表改用数组存储提高缓存友好性
- 模块依赖管理算法优化
- 统一时间相关参数为 f32/f64 类型

移除冗余代码，简化接口设计，提升整体代码一致性和性能
 2026-02-20 19:02:21 +08:00
34 changed files with 1381 additions and 1022 deletions
Show Stats Expand all files Collapse all files

20
Extra2D/include/extra2d/app/application.h
View File

@ -76,8 +76,8 @@ public:
*/
void resume();
bool isPaused() const { return paused_; }
bool isRunning() const { return running_; }
bool paused() const { return paused_; }
bool running() const { return running_; }
/**
* @brief 获取窗口
@ -85,9 +85,9 @@ public:
*/
GLFWWindow *window();
float deltaTime() const { return deltaTime_; }
float totalTime() const { return totalTime_; }
int fps() const { return currentFps_; }
f32 dt() const { return dt_; }
f32 totalTime() const { return totalTime_; }
int fps() const { return fps_; }
private:
Application();
@ -102,12 +102,12 @@ private:
bool paused_ = false;
bool shouldQuit_ = false;
float deltaTime_ = 0.0f;
float totalTime_ = 0.0f;
double lastFrameTime_ = 0.0;
f32 dt_ = 0.0f;
f32 totalTime_ = 0.0f;
f64 lastFrameTime_ = 0.0;
int frameCount_ = 0;
float fpsTimer_ = 0.0f;
int currentFps_ = 0;
f32 fpsTimer_ = 0.0f;
int fps_ = 0;
};
} // namespace extra2d

4
Extra2D/include/extra2d/core/module.h
View File

@ -56,7 +56,7 @@ public:
* @brief 检查模块是否支持并行初始化
* @return 支持并行初始化返回 true
*/
virtual bool allowParallelInit() const { return true; }
virtual bool parallel() const { return true; }
/**
* @brief 设置所属Application
@ -77,6 +77,6 @@ protected:
/**
* @brief 模块工厂函数类型
*/
using ModuleFactory = std::function<UniquePtr<Module>()>;
using ModuleFactory = std::function<Unique<Module>()>;
} // namespace extra2d

64
Extra2D/include/extra2d/core/object_pool.h Normal file
View File

@ -0,0 +1,64 @@
#pragma once
#include <extra2d/core/types.h>
#include <array>
#include <queue>
namespace extra2d {
/**
* @brief 固定大小对象池
* @tparam T 对象类型
* @tparam Size 池大小
*/
template <typename T, size_t Size>
class ObjectPool {
public:
ObjectPool() {
for (size_t i = 0; i < Size; ++i) {
available_.push(&pool_[i]);
}
}
/**
* @brief 获取对象
* @return 对象指针，池耗尽返回nullptr
*/
T* acquire() {
if (available_.empty()) {
return nullptr;
}
T* obj = available_.front();
available_.pop();
return obj;
}
/**
* @brief 释放对象回池
* @param obj 对象指针
*/
void release(T* obj) {
if (obj >= pool_.data() && obj < pool_.data() + Size) {
obj->~T();
new (obj) T();
available_.push(obj);
}
}
/**
* @brief 获取可用对象数量
*/
size_t available() const { return available_.size(); }
/**
* @brief 获取池总大小
*/
static constexpr size_t capacity() { return Size; }
private:
alignas(alignof(T)) std::array<u8, sizeof(T) * Size> storage_;
T* pool_ = reinterpret_cast<T*>(storage_.data());
std::queue<T*> available_;
};
} // namespace extra2d

80
Extra2D/include/extra2d/core/registry.h
View File

@ -2,7 +2,7 @@
#include <extra2d/core/module.h>
#include <extra2d/core/types.h>
#include <unordered_map>
#include <array>
#include <typeindex>
#include <vector>
#include <memory>
@ -12,12 +12,32 @@ namespace extra2d {
class Application;
/**
* @brief 编译期类型ID生成器
*/
using TypeId = size_t;
namespace detail {
inline TypeId nextTypeId() {
static TypeId id = 0;
return ++id;
}
template<typename T>
inline TypeId getTypeId() {
static TypeId id = nextTypeId();
return id;
}
}
/**
* @brief 模块注册表
* 管理模块的注册、拓扑排序和生命周期
*/
class Registry {
public:
static constexpr size_t MAX_MODULES = 64;
static Registry& instance();
Registry(const Registry&) = delete;
@ -34,15 +54,29 @@ public:
T* use(Args&&... args) {
static_assert(std::is_base_of_v<Module, T>, "T must derive from Module");
auto typeIdx = std::type_index(typeid(T));
if (modules_.count(typeIdx)) {
return static_cast<T*>(modules_[typeIdx].get());
TypeId typeId = detail::getTypeId<T>();
// 数组查找，O(n) 但 n 很小，缓存友好
for (size_t i = 0; i < moduleCount_; ++i) {
if (modules_[i].id == typeId) {
return static_cast<T*>(modules_[i].module.get());
}
}
auto module = makeUnique<T>(std::forward<Args>(args)...);
// 添加新模块
if (moduleCount_ >= MAX_MODULES) {
return nullptr; // 模块数量超过上限
}
auto module = ptr::makeUnique<T>(std::forward<Args>(args)...);
T* ptr = module.get();
module->setApp(app_);
modules_[typeIdx] = std::move(module);
modules_[moduleCount_].id = typeId;
modules_[moduleCount_].module = std::move(module);
modules_[moduleCount_].valid = true;
++moduleCount_;
return ptr;
}
@ -53,10 +87,12 @@ public:
*/
template<typename T>
T* get() const {
auto typeIdx = std::type_index(typeid(T));
auto it = modules_.find(typeIdx);
if (it != modules_.end()) {
return static_cast<T*>(it->second.get());
TypeId typeId = detail::getTypeId<T>();
for (size_t i = 0; i < moduleCount_; ++i) {
if (modules_[i].id == typeId && modules_[i].valid) {
return static_cast<T*>(modules_[i].module.get());
}
}
return nullptr;
}
@ -67,9 +103,12 @@ public:
* @return 模块指针
*/
Module* get(std::type_index typeIdx) const {
auto it = modules_.find(typeIdx);
if (it != modules_.end()) {
return it->second.get();
// 这里仍然使用type_index作为后备方案
for (size_t i = 0; i < moduleCount_; ++i) {
if (modules_[i].valid &&
std::type_index(typeid(*modules_[i].module)) == typeIdx) {
return modules_[i].module.get();
}
}
return nullptr;
}
@ -98,26 +137,33 @@ public:
/**
* @brief 获取模块数量
*/
size_t size() const { return modules_.size(); }
size_t size() const { return moduleCount_; }
private:
Registry() = default;
~Registry() = default;
struct ModuleEntry {
TypeId id = 0;
Unique<Module> module;
bool valid = false;
};
/**
* @brief 拓扑排序模块
* @return 排序后的模块列表
*/
std::vector<Module*> topologicalSort();
std::vector<Module*> sort();
/**
* @brief 按层级对模块进行分组
* 同一层级的模块没有相互依赖，可以并行初始化
* @return 按层级分组的模块列表
*/
std::vector<std::vector<Module*>> groupByLevel();
std::vector<std::vector<Module*>> group();
std::unordered_map<std::type_index, UniquePtr<Module>> modules_;
std::array<ModuleEntry, MAX_MODULES> modules_;
size_t moduleCount_ = 0;
Application* app_ = nullptr;
};

398
Extra2D/include/extra2d/core/result.h Normal file
View File

@ -0,0 +1,398 @@
#pragma once
#include <extra2d/core/types.h>
#include <string>
#include <variant>
namespace extra2d {
/**
* @brief 错误码枚举
*/
enum class ErrorCode {
None = 0,
Unknown = 1,
InvalidArgument = 2,
OutOfMemory = 3,
FileNotFound = 4,
PermissionDenied = 5,
NotImplemented = 6,
AlreadyExists = 7,
NotInitialized = 8,
AlreadyInitialized = 9,
OperationFailed = 10,
Timeout = 11,
Cancelled = 12,
InvalidState = 13,
ResourceExhausted = 14,
Unavailable = 15,
DataLoss = 16,
Unauthenticated = 17,
PermissionDenied2 = 18,
ResourceNotFound = 19,
Aborted = 20,
OutOfRange = 21,
Unimplemented = 22,
Internal = 23,
DataCorrupted = 24,
RequestTooLarge = 25,
ResourceBusy = 26,
QuotaExceeded = 27,
DeadlineExceeded = 28,
LoadBalancing = 29,
NetworkError = 30,
ProtocolError = 31,
ServiceUnavailable = 32,
GatewayError = 33,
RateLimited = 34,
BadRequest = 35,
Unauthorized = 36,
Forbidden = 37,
NotFound = 38,
MethodNotAllowed = 39,
Conflict = 40,
Gone = 41,
LengthRequired = 42,
PreconditionFailed = 43,
PayloadTooLarge = 44,
UriTooLong = 45,
UnsupportedMediaType = 46,
RangeNotSatisfiable = 47,
ExpectationFailed = 48,
ImATeapot = 49,
MisdirectedRequest = 50,
UnprocessableEntity = 51,
Locked = 52,
FailedDependency = 53,
TooEarly = 54,
UpgradeRequired = 55,
PreconditionRequired = 56,
TooManyRequests = 57,
RequestHeaderFieldsTooLarge = 58,
UnavailableForLegalReasons = 59
};
/**
* @brief 错误信息结构
*/
struct Error {
ErrorCode code = ErrorCode::None;
std::string message;
std::string file;
int line = 0;
Error() = default;
Error(ErrorCode c, const std::string& msg) : code(c), message(msg) {}
Error(ErrorCode c, const std::string& msg, const std::string& f, int l)
: code(c), message(msg), file(f), line(l) {}
bool ok() const { return code == ErrorCode::None; }
static Error none() { return Error(); }
static Error unknown(const std::string& msg) { return Error(ErrorCode::Unknown, msg); }
static Error invalidArgument(const std::string& msg) { return Error(ErrorCode::InvalidArgument, msg); }
static Error outOfMemory(const std::string& msg) { return Error(ErrorCode::OutOfMemory, msg); }
static Error fileNotFound(const std::string& msg) { return Error(ErrorCode::FileNotFound, msg); }
static Error permissionDenied(const std::string& msg) { return Error(ErrorCode::PermissionDenied, msg); }
static Error notImplemented(const std::string& msg) { return Error(ErrorCode::NotImplemented, msg); }
static Error alreadyExists(const std::string& msg) { return Error(ErrorCode::AlreadyExists, msg); }
static Error notInitialized(const std::string& msg) { return Error(ErrorCode::NotInitialized, msg); }
static Error alreadyInitialized(const std::string& msg) { return Error(ErrorCode::AlreadyInitialized, msg); }
static Error operationFailed(const std::string& msg) { return Error(ErrorCode::OperationFailed, msg); }
static Error timeout(const std::string& msg) { return Error(ErrorCode::Timeout, msg); }
static Error cancelled(const std::string& msg) { return Error(ErrorCode::Cancelled, msg); }
static Error invalidState(const std::string& msg) { return Error(ErrorCode::InvalidState, msg); }
static Error resourceExhausted(const std::string& msg) { return Error(ErrorCode::ResourceExhausted, msg); }
static Error unavailable(const std::string& msg) { return Error(ErrorCode::Unavailable, msg); }
static Error dataLoss(const std::string& msg) { return Error(ErrorCode::DataLoss, msg); }
static Error unauthenticated(const std::string& msg) { return Error(ErrorCode::Unauthenticated, msg); }
static Error permissionDenied2(const std::string& msg) { return Error(ErrorCode::PermissionDenied2, msg); }
static Error resourceNotFound(const std::string& msg) { return Error(ErrorCode::ResourceNotFound, msg); }
static Error aborted(const std::string& msg) { return Error(ErrorCode::Aborted, msg); }
static Error outOfRange(const std::string& msg) { return Error(ErrorCode::OutOfRange, msg); }
static Error unimplemented(const std::string& msg) { return Error(ErrorCode::Unimplemented, msg); }
static Error internal(const std::string& msg) { return Error(ErrorCode::Internal, msg); }
static Error dataCorrupted(const std::string& msg) { return Error(ErrorCode::DataCorrupted, msg); }
static Error requestTooLarge(const std::string& msg) { return Error(ErrorCode::RequestTooLarge, msg); }
static Error resourceBusy(const std::string& msg) { return Error(ErrorCode::ResourceBusy, msg); }
static Error quotaExceeded(const std::string& msg) { return Error(ErrorCode::QuotaExceeded, msg); }
static Error deadlineExceeded(const std::string& msg) { return Error(ErrorCode::DeadlineExceeded, msg); }
static Error loadBalancing(const std::string& msg) { return Error(ErrorCode::LoadBalancing, msg); }
static Error networkError(const std::string& msg) { return Error(ErrorCode::NetworkError, msg); }
static Error protocolError(const std::string& msg) { return Error(ErrorCode::ProtocolError, msg); }
static Error serviceUnavailable(const std::string& msg) { return Error(ErrorCode::ServiceUnavailable, msg); }
static Error gatewayError(const std::string& msg) { return Error(ErrorCode::GatewayError, msg); }
static Error rateLimited(const std::string& msg) { return Error(ErrorCode::RateLimited, msg); }
static Error badRequest(const std::string& msg) { return Error(ErrorCode::BadRequest, msg); }
static Error unauthorized(const std::string& msg) { return Error(ErrorCode::Unauthorized, msg); }
static Error forbidden(const std::string& msg) { return Error(ErrorCode::Forbidden, msg); }
static Error notFound(const std::string& msg) { return Error(ErrorCode::NotFound, msg); }
static Error methodNotAllowed(const std::string& msg) { return Error(ErrorCode::MethodNotAllowed, msg); }
static Error conflict(const std::string& msg) { return Error(ErrorCode::Conflict, msg); }
static Error gone(const std::string& msg) { return Error(ErrorCode::Gone, msg); }
static Error lengthRequired(const std::string& msg) { return Error(ErrorCode::LengthRequired, msg); }
static Error preconditionFailed(const std::string& msg) { return Error(ErrorCode::PreconditionFailed, msg); }
static Error payloadTooLarge(const std::string& msg) { return Error(ErrorCode::PayloadTooLarge, msg); }
static Error uriTooLong(const std::string& msg) { return Error(ErrorCode::UriTooLong, msg); }
static Error unsupportedMediaType(const std::string& msg) { return Error(ErrorCode::UnsupportedMediaType, msg); }
static Error rangeNotSatisfiable(const std::string& msg) { return Error(ErrorCode::RangeNotSatisfiable, msg); }
static Error expectationFailed(const std::string& msg) { return Error(ErrorCode::ExpectationFailed, msg); }
static Error imATeapot(const std::string& msg) { return Error(ErrorCode::ImATeapot, msg); }
static Error misdirectedRequest(const std::string& msg) { return Error(ErrorCode::MisdirectedRequest, msg); }
static Error unprocessableEntity(const std::string& msg) { return Error(ErrorCode::UnprocessableEntity, msg); }
static Error locked(const std::string& msg) { return Error(ErrorCode::Locked, msg); }
static Error failedDependency(const std::string& msg) { return Error(ErrorCode::FailedDependency, msg); }
static Error tooEarly(const std::string& msg) { return Error(ErrorCode::TooEarly, msg); }
static Error upgradeRequired(const std::string& msg) { return Error(ErrorCode::UpgradeRequired, msg); }
static Error preconditionRequired(const std::string& msg) { return Error(ErrorCode::PreconditionRequired, msg); }
static Error tooManyRequests(const std::string& msg) { return Error(ErrorCode::TooManyRequests, msg); }
static Error requestHeaderFieldsTooLarge(const std::string& msg) { return Error(ErrorCode::RequestHeaderFieldsTooLarge, msg); }
static Error unavailableForLegalReasons(const std::string& msg) { return Error(ErrorCode::UnavailableForLegalReasons, msg); }
};
/**
* @brief Result类型，用于错误处理
* @tparam T 成功时的值类型
* @tparam E 错误类型，默认为Error
*/
template<typename T, typename E = Error>
class Result {
public:
Result() : hasValue_(false) {
new (&storage_.error) E();
}
~Result() {
if (hasValue_) {
storage_.value.~T();
} else {
storage_.error.~E();
}
}
Result(const Result& other) : hasValue_(other.hasValue_) {
if (hasValue_) {
new (&storage_.value) T(other.storage_.value);
} else {
new (&storage_.error) E(other.storage_.error);
}
}
Result(Result&& other) noexcept : hasValue_(other.hasValue_) {
if (hasValue_) {
new (&storage_.value) T(std::move(other.storage_.value));
} else {
new (&storage_.error) E(std::move(other.storage_.error));
}
}
Result& operator=(const Result& other) {
if (this != &other) {
this->~Result();
hasValue_ = other.hasValue_;
if (hasValue_) {
new (&storage_.value) T(other.storage_.value);
} else {
new (&storage_.error) E(other.storage_.error);
}
}
return *this;
}
Result& operator=(Result&& other) noexcept {
if (this != &other) {
this->~Result();
hasValue_ = other.hasValue_;
if (hasValue_) {
new (&storage_.value) T(std::move(other.storage_.value));
} else {
new (&storage_.error) E(std::move(other.storage_.error));
}
}
return *this;
}
static Result<T, E> ok(T value) {
Result<T, E> result;
result.hasValue_ = true;
new (&result.storage_.value) T(std::move(value));
return result;
}
static Result<T, E> err(E error) {
Result<T, E> result;
result.hasValue_ = false;
new (&result.storage_.error) E(std::move(error));
return result;
}
bool ok() const { return hasValue_; }
bool isOk() const { return hasValue_; }
bool isErr() const { return !hasValue_; }
T& value() & {
return storage_.value;
}
const T& value() const & {
return storage_.value;
}
T&& value() && {
return std::move(storage_.value);
}
E& error() & {
return storage_.error;
}
const E& error() const & {
return storage_.error;
}
E&& error() && {
return std::move(storage_.error);
}
T valueOr(T defaultValue) const {
return hasValue_ ? storage_.value : std::move(defaultValue);
}
template<typename F>
Result<T, E> map(F&& f) {
if (hasValue_) {
return Result<T, E>::ok(f(storage_.value));
}
return *this;
}
template<typename F>
Result<T, E> mapErr(F&& f) {
if (!hasValue_) {
return Result<T, E>::err(f(storage_.error));
}
return *this;
}
template<typename F>
auto andThen(F&& f) -> decltype(f(std::declval<T>())) {
if (hasValue_) {
return f(storage_.value);
}
return Result<typename decltype(f(std::declval<T>()))::ValueType, E>::err(storage_.error);
}
template<typename F>
Result<T, E> orElse(F&& f) {
if (!hasValue_) {
return f(storage_.error);
}
return *this;
}
private:
union Storage {
T value;
E error;
Storage() {}
~Storage() {}
} storage_;
bool hasValue_;
};
// 特化void类型
template<typename E>
class Result<void, E> {
public:
Result() : hasValue_(true) {}
~Result() {
if (!hasValue_) {
storage_.error.~E();
}
}
Result(const Result& other) : hasValue_(other.hasValue_) {
if (!hasValue_) {
new (&storage_.error) E(other.storage_.error);
}
}
Result(Result&& other) noexcept : hasValue_(other.hasValue_) {
if (!hasValue_) {
new (&storage_.error) E(std::move(other.storage_.error));
}
}
Result& operator=(const Result& other) {
if (this != &other) {
this->~Result();
hasValue_ = other.hasValue_;
if (!hasValue_) {
new (&storage_.error) E(other.storage_.error);
}
}
return *this;
}
Result& operator=(Result&& other) noexcept {
if (this != &other) {
this->~Result();
hasValue_ = other.hasValue_;
if (!hasValue_) {
new (&storage_.error) E(std::move(other.storage_.error));
}
}
return *this;
}
static Result<void, E> ok() {
return Result<void, E>();
}
static Result<void, E> err(E error) {
Result<void, E> result;
result.hasValue_ = false;
new (&result.storage_.error) E(std::move(error));
return result;
}
bool ok() const { return hasValue_; }
bool isOk() const { return hasValue_; }
bool isErr() const { return !hasValue_; }
E& error() & {
return storage_.error;
}
const E& error() const & {
return storage_.error;
}
E&& error() && {
return std::move(storage_.error);
}
private:
union Storage {
E error;
Storage() {}
~Storage() {}
} storage_;
bool hasValue_;
};
// 便捷宏
#define E2D_TRY(result) \
do { \
auto _res = (result); \
if (!_res.ok()) { \
return Result<decltype(_res)::ValueType, decltype(_res)::ErrorType>::err(_res.error()); \
} \
} while(0)
} // namespace extra2d

103
Extra2D/include/extra2d/core/ring_buffer.h Normal file
View File

@ -0,0 +1,103 @@
#pragma once
#include <extra2d/core/types.h>
#include <atomic>
#include <array>
namespace extra2d {
/**
* @brief 无锁环形缓冲区（单生产者单消费者）
* @tparam T 元素类型
* @tparam Size 缓冲区大小（必须是2的幂）
*/
template <typename T, size_t Size>
class RingBuffer {
static_assert((Size & (Size - 1)) == 0, "Size must be a power of 2");
public:
RingBuffer() = default;
/**
* @brief 入队
* @param item 元素
* @return 成功返回true，缓冲区满返回false
*/
bool push(const T& item) {
const size_t currentHead = head_.load(std::memory_order_relaxed);
const size_t currentTail = tail_.load(std::memory_order_acquire);
if ((currentHead - currentTail) >= Size) {
return false; // 缓冲区满
}
buffer_[currentHead & mask_] = item;
head_.store(currentHead + 1, std::memory_order_release);
return true;
}
/**
* @brief 入队（移动语义）
* @param item 元素
* @return 成功返回true，缓冲区满返回false
*/
bool push(T&& item) {
const size_t currentHead = head_.load(std::memory_order_relaxed);
const size_t currentTail = tail_.load(std::memory_order_acquire);
if ((currentHead - currentTail) >= Size) {
return false; // 缓冲区满
}
buffer_[currentHead & mask_] = std::move(item);
head_.store(currentHead + 1, std::memory_order_release);
return true;
}
/**
* @brief 出队
* @param item 输出元素
* @return 成功返回true，缓冲区空返回false
*/
bool pop(T& item) {
const size_t currentTail = tail_.load(std::memory_order_relaxed);
const size_t currentHead = head_.load(std::memory_order_acquire);
if (currentTail == currentHead) {
return false; // 缓冲区空
}
item = std::move(buffer_[currentTail & mask_]);
tail_.store(currentTail + 1, std::memory_order_release);
return true;
}
/**
* @brief 检查是否为空
*/
bool empty() const {
return head_.load(std::memory_order_acquire) ==
tail_.load(std::memory_order_acquire);
}
/**
* @brief 获取当前大小
*/
size_t size() const {
return head_.load(std::memory_order_acquire) -
tail_.load(std::memory_order_acquire);
}
/**
* @brief 获取容量
*/
static constexpr size_t capacity() { return Size; }
private:
static constexpr size_t mask_ = Size - 1;
alignas(64) std::array<T, Size> buffer_;
alignas(64) std::atomic<size_t> head_{0};
alignas(64) std::atomic<size_t> tail_{0};
};
} // namespace extra2d

16
Extra2D/include/extra2d/core/service_interface.h
View File

@ -9,7 +9,7 @@ namespace extra2d {
* @brief 服务优先级枚举
* 定义服务的初始化顺序，数值越小越先初始化
*/
enum class ServicePriority : int {
enum class ServicePriority : i32 {
Core = 0,
Event = 100,
Timer = 200,
@ -56,13 +56,13 @@ public:
* @brief 获取服务信息
* @return 服务信息结构体
*/
virtual ServiceInfo getServiceInfo() const = 0;
virtual ServiceInfo info() const = 0;
/**
* @brief 初始化服务
* @return 初始化成功返回 true
*/
virtual bool initialize() = 0;
virtual bool init() = 0;
/**
* @brief 关闭服务
@ -87,15 +87,15 @@ public:
/**
* @brief 更新服务
* @param deltaTime 帧间隔时间
* @param dt 帧间隔时间
*/
virtual void update(float deltaTime) { }
virtual void update(f32 dt) { }
/**
* @brief 检查服务是否已初始化
* @return 已初始化返回 true
*/
virtual bool isInitialized() const {
virtual bool initialized() const {
return info_.state == ServiceState::Running ||
info_.state == ServiceState::Paused;
}
@ -104,13 +104,13 @@ public:
* @brief 获取服务状态
* @return 当前服务状态
*/
ServiceState getState() const { return info_.state; }
ServiceState state() const { return info_.state; }
/**
* @brief 获取服务名称
* @return 服务名称
*/
const std::string& getName() const { return info_.name; }
const std::string& name() const { return info_.name; }
protected:
ServiceInfo info_;

111
Extra2D/include/extra2d/core/service_locator.h
View File

@ -6,6 +6,7 @@
#include <functional>
#include <memory>
#include <mutex>
#include <shared_mutex>
#include <typeindex>
#include <unordered_map>
#include <vector>
@ -15,7 +16,7 @@ namespace extra2d {
/**
* @brief 服务工厂函数类型
*/
template <typename T> using ServiceFactory = std::function<SharedPtr<T>()>;
template <typename T> using ServiceFactory = Fn<Ref<T>()>;
/**
* @brief 服务定位器
@ -25,7 +26,7 @@ template <typename T> using ServiceFactory = std::function<SharedPtr<T>()>;
* - 类型安全的服务注册和获取
* - 支持服务工厂延迟创建
* - 支持服务依赖声明
* - 线程安全
* - 线程安全（读写锁）
* - 支持 Mock 测试
*/
class ServiceLocator {
@ -42,39 +43,39 @@ public:
/**
* @brief 注册服务实例
* @tparam T 服务接口类型
* @param service 服务实例
* @param svc 服务实例
*/
template <typename T> void registerService(SharedPtr<T> service) {
template <typename T> void add(Ref<T> svc) {
static_assert(std::is_base_of_v<IService, T>,
"T must derive from IService");
std::lock_guard<std::recursive_mutex> lock(mutex_);
std::unique_lock<std::shared_mutex> lock(mutex_);
auto typeId = std::type_index(typeid(T));
services_[typeId] = std::static_pointer_cast<IService>(service);
orderedServices_.push_back(service);
sortServices();
services_[typeId] = std::static_pointer_cast<IService>(svc);
orderedServices_.push_back(svc);
sort();
}
/**
* @brief 注册服务工厂
* @tparam T 服务接口类型
* @param factory 服务工厂函数
* @param fn 服务工厂函数
*/
template <typename T> void registerFactory(ServiceFactory<T> factory) {
template <typename T> void setFactory(ServiceFactory<T> fn) {
static_assert(std::is_base_of_v<IService, T>,
"T must derive from IService");
std::lock_guard<std::recursive_mutex> lock(mutex_);
std::unique_lock<std::shared_mutex> lock(mutex_);
auto typeId = std::type_index(typeid(T));
factories_[typeId] = [factory]() -> SharedPtr<IService> {
return std::static_pointer_cast<IService>(factory());
factories_[typeId] = [fn]() -> Ref<IService> {
return std::static_pointer_cast<IService>(fn());
};
// 立即创建服务实例并添加到有序列表
auto service = factories_[typeId]();
services_[typeId] = service;
orderedServices_.push_back(service);
sortServices();
auto svc = factories_[typeId]();
services_[typeId] = svc;
orderedServices_.push_back(svc);
sort();
}
/**
@ -82,13 +83,15 @@ public:
* @tparam T 服务接口类型
* @return 服务实例，不存在返回 nullptr
*/
template <typename T> SharedPtr<T> getService() const {
template <typename T> Ref<T> get() const {
static_assert(std::is_base_of_v<IService, T>,
"T must derive from IService");
std::lock_guard<std::recursive_mutex> lock(mutex_);
auto typeId = std::type_index(typeid(T));
// 读锁查询
std::shared_lock<std::shared_mutex> lock(mutex_);
auto it = services_.find(typeId);
if (it != services_.end()) {
return std::static_pointer_cast<T>(it->second);
@ -96,9 +99,9 @@ public:
auto factoryIt = factories_.find(typeId);
if (factoryIt != factories_.end()) {
auto service = factoryIt->second();
services_[typeId] = service;
return std::static_pointer_cast<T>(service);
auto svc = factoryIt->second();
services_[typeId] = svc;
return std::static_pointer_cast<T>(svc);
}
return nullptr;
@ -109,12 +112,14 @@ public:
* @tparam T 服务接口类型
* @return 服务实例，不存在返回 nullptr
*/
template <typename T> SharedPtr<T> tryGetService() const {
template <typename T> Ref<T> tryGet() const {
static_assert(std::is_base_of_v<IService, T>,
"T must derive from IService");
std::lock_guard<std::recursive_mutex> lock(mutex_);
auto typeId = std::type_index(typeid(T));
// 读锁查询
std::shared_lock<std::shared_mutex> lock(mutex_);
auto it = services_.find(typeId);
if (it != services_.end()) {
return std::static_pointer_cast<T>(it->second);
@ -127,8 +132,8 @@ public:
* @tparam T 服务接口类型
* @return 已注册返回 true
*/
template <typename T> bool hasService() const {
std::lock_guard<std::recursive_mutex> lock(mutex_);
template <typename T> bool has() const {
std::shared_lock<std::shared_mutex> lock(mutex_);
auto typeId = std::type_index(typeid(T));
return services_.find(typeId) != services_.end() ||
factories_.find(typeId) != factories_.end();
@ -138,17 +143,17 @@ public:
* @brief 注销服务
* @tparam T 服务接口类型
*/
template <typename T> void unregisterService() {
std::lock_guard<std::recursive_mutex> lock(mutex_);
template <typename T> void remove() {
std::unique_lock<std::shared_mutex> lock(mutex_);
auto typeId = std::type_index(typeid(T));
auto it = services_.find(typeId);
if (it != services_.end()) {
auto service = it->second;
auto svc = it->second;
services_.erase(it);
auto orderIt =
std::find(orderedServices_.begin(), orderedServices_.end(), service);
std::find(orderedServices_.begin(), orderedServices_.end(), svc);
if (orderIt != orderedServices_.end()) {
orderedServices_.erase(orderIt);
}
@ -161,34 +166,34 @@ public:
* @brief 初始化所有已注册的服务
* @return 所有服务初始化成功返回 true
*/
bool initializeAll();
bool init();
/**
* @brief 关闭所有服务
*/
void shutdownAll();
void shutdown();
/**
* @brief 更新所有服务
* @param deltaTime 帧间隔时间
* @param dt 帧间隔时间
*/
void updateAll(float deltaTime);
void update(f32 dt);
/**
* @brief 暂停所有服务
*/
void pauseAll();
void pause();
/**
* @brief 恢复所有服务
*/
void resumeAll();
void resume();
/**
* @brief 获取所有服务（按优先级排序）
* @return 服务列表
*/
std::vector<SharedPtr<IService>> getAllServices() const;
std::vector<Ref<IService>> all() const;
/**
* @brief 清空所有服务和工厂
@ -208,13 +213,13 @@ private:
/**
* @brief 按优先级排序服务
*/
void sortServices();
void sort();
mutable std::unordered_map<std::type_index, SharedPtr<IService>> services_;
std::unordered_map<std::type_index, std::function<SharedPtr<IService>()>>
mutable std::unordered_map<std::type_index, Ref<IService>> services_;
std::unordered_map<std::type_index, std::function<Ref<IService>()>>
factories_;
std::vector<SharedPtr<IService>> orderedServices_;
mutable std::recursive_mutex mutex_;
std::vector<Ref<IService>> orderedServices_;
mutable std::shared_mutex mutex_;
};
/**
@ -223,13 +228,13 @@ private:
*/
template <typename Interface, typename Implementation> class ServiceRegistrar {
public:
explicit ServiceRegistrar(ServiceFactory<Interface> factory = nullptr) {
if (factory) {
ServiceLocator::instance().registerFactory<Interface>(factory);
explicit ServiceRegistrar(ServiceFactory<Interface> fn = nullptr) {
if (fn) {
ServiceLocator::instance().setFactory<Interface>(fn);
} else {
ServiceLocator::instance().registerFactory<Interface>(
[]() -> SharedPtr<Interface> {
return makeShared<Implementation>();
ServiceLocator::instance().setFactory<Interface>(
[]() -> Ref<Interface> {
return ptr::make<Implementation>();
});
}
}
@ -251,9 +256,9 @@ template <typename Interface, typename Implementation> struct ServiceAutoReg {
* @return true 表示注册成功
*/
static bool doRegister() {
::extra2d::ServiceLocator::instance().registerFactory<Interface>(
[]() -> ::extra2d::SharedPtr<Interface> {
return ::extra2d::makeShared<Implementation>();
::extra2d::ServiceLocator::instance().setFactory<Interface>(
[]() -> ::extra2d::Ref<Interface> {
return ::extra2d::ptr::make<Implementation>();
});
return true;
}
@ -271,8 +276,8 @@ 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);
static bool doRegister(Factory fn) {
::extra2d::ServiceLocator::instance().setFactory<Interface>(fn);
return true;
}
};

22
Extra2D/include/extra2d/core/service_registry.h
View File

@ -14,7 +14,7 @@ namespace extra2d {
struct ServiceRegistration {
std::string name;
ServicePriority priority;
std::function<SharedPtr<IService>()> factory;
std::function<Ref<IService>()> factory;
bool enabled = true;
};
@ -41,7 +41,7 @@ public:
* @param priority 服务优先级
*/
template<typename T, typename Impl>
void registerService(const std::string& name, ServicePriority priority) {
void add(const std::string& name, ServicePriority priority) {
static_assert(std::is_base_of_v<IService, T>,
"T must derive from IService");
static_assert(std::is_base_of_v<T, Impl>,
@ -50,8 +50,8 @@ public:
ServiceRegistration reg;
reg.name = name;
reg.priority = priority;
reg.factory = []() -> SharedPtr<IService> {
return std::static_pointer_cast<IService>(makeShared<Impl>());
reg.factory = []() -> Ref<IService> {
return std::static_pointer_cast<IService>(ptr::make<Impl>());
};
registrations_.push_back(reg);
}
@ -64,17 +64,17 @@ public:
* @param factory 工厂函数
*/
template<typename T>
void registerServiceWithFactory(
void addWithFactory(
const std::string& name,
ServicePriority priority,
std::function<SharedPtr<T>()> factory) {
std::function<Ref<T>()> factory) {
static_assert(std::is_base_of_v<IService, T>,
"T must derive from IService");
ServiceRegistration reg;
reg.name = name;
reg.priority = priority;
reg.factory = [factory]() -> SharedPtr<IService> {
reg.factory = [factory]() -> Ref<IService> {
return std::static_pointer_cast<IService>(factory());
};
registrations_.push_back(reg);
@ -85,19 +85,19 @@ public:
* @param name 服务名称
* @param enabled 是否启用
*/
void setServiceEnabled(const std::string& name, bool enabled);
void setEnabled(const std::string& name, bool enabled);
/**
* @brief 创建所有已注册的服务
* 并注册到 ServiceLocator
*/
void createAllServices();
void createAll();
/**
* @brief 获取所有注册信息
* @return 注册信息列表
*/
const std::vector<ServiceRegistration>& getRegistrations() const {
const std::vector<ServiceRegistration>& all() const {
return registrations_;
}
@ -123,7 +123,7 @@ template<typename Interface, typename Implementation>
class AutoServiceRegistrar {
public:
AutoServiceRegistrar(const std::string& name, ServicePriority priority) {
ServiceRegistry::instance().registerService<Interface, Implementation>(
ServiceRegistry::instance().add<Interface, Implementation>(
name, priority);
}
};

53
Extra2D/include/extra2d/core/types.h
View File

@ -16,43 +16,46 @@ namespace extra2d {
// ---------------------------------------------------------------------------
// 智能指针别名
// ---------------------------------------------------------------------------
template <typename T> using Ptr = std::shared_ptr<T>;
template <typename T> using SharedPtr = std::shared_ptr<T>;
template <typename T> using Ref = std::shared_ptr<T>;
template <typename T> using Unique = std::unique_ptr<T>;
template <typename T> using Weak = std::weak_ptr<T>;
template <typename T> using UniquePtr = std::unique_ptr<T>;
template <typename T> using WeakPtr = std::weak_ptr<T>;
/// 创建 shared_ptr 的便捷函数
template <typename T, typename... Args> inline Ptr<T> makePtr(Args &&...args) {
/// 智能指针工厂函数命名空间
namespace ptr {
/// 创建 Ref 的便捷函数
template <typename T, typename... Args> inline Ref<T> make(Args &&...args) {
return std::make_shared<T>(std::forward<Args>(args)...);
}
}
template <typename T, typename... Args> inline SharedPtr<T> makeShared(Args &&...args) {
return std::make_shared<T>(std::forward<Args>(args)...);
}
/// 创建 unique_ptr 的便捷函数
template <typename T, typename... Args>
inline UniquePtr<T> makeUnique(Args &&...args) {
/// 创建 Unique 的便捷函数
template <typename T, typename... Args>
inline Unique<T> makeUnique(Args &&...args) {
return std::make_unique<T>(std::forward<Args>(args)...);
}
}
// ---------------------------------------------------------------------------
// 函数别名
// ---------------------------------------------------------------------------
template <typename Sig> using Function = std::function<Sig>;
template <typename Sig> using Fn = std::function<Sig>;
// ---------------------------------------------------------------------------
// 基础类型别名
// ---------------------------------------------------------------------------
using int8 = std::int8_t;
using int16 = std::int16_t;
using int32 = std::int32_t;
using int64 = std::int64_t;
using uint8 = std::uint8_t;
using uint16 = std::uint16_t;
using uint32 = std::uint32_t;
using uint64 = std::uint64_t;
using i8 = int8_t;
using i16 = int16_t;
using i32 = int32_t;
using i64 = int64_t;
using u8 = uint8_t;
using u16 = uint16_t;
using u32 = uint32_t;
using u64 = uint64_t;
using f32 = float;
using f64 = double;
// ---------------------------------------------------------------------------
// ID 类型别名
// ---------------------------------------------------------------------------
using ID = u32;
} // namespace extra2d

64
Extra2D/include/extra2d/event/event.h
View File

@ -59,70 +59,70 @@ enum class EventType {
// 键盘事件数据
// ============================================================================
struct KeyEvent {
int keyCode;
int scancode;
int mods; // 修饰键 (Shift, Ctrl, Alt, etc.)
i32 key;
i32 scancode;
i32 mods; // 修饰键 (Shift, Ctrl, Alt, etc.)
};
// ============================================================================
// 鼠标事件数据
// ============================================================================
struct MouseButtonEvent {
int button;
int mods;
Vec2 position;
i32 button;
i32 mods;
Vec2 pos;
};
struct MouseMoveEvent {
Vec2 position;
Vec2 pos;
Vec2 delta;
};
struct MouseScrollEvent {
Vec2 offset;
Vec2 position;
Vec2 pos;
};
// ============================================================================
// 窗口事件数据
// ============================================================================
struct WindowResizeEvent {
int width;
int height;
i32 w;
i32 h;
};
struct WindowMoveEvent {
int x;
int y;
i32 x;
i32 y;
};
// ============================================================================
// 游戏手柄事件数据
// ============================================================================
struct GamepadButtonEvent {
int gamepadId;
int button;
i32 gamepadId;
i32 button;
};
struct GamepadAxisEvent {
int gamepadId;
int axis;
float value;
i32 gamepadId;
i32 axis;
f32 value;
};
// ============================================================================
// 触摸事件数据
// ============================================================================
struct TouchEvent {
int touchId;
Vec2 position;
i32 touchId;
Vec2 pos;
};
// ============================================================================
// 自定义事件数据
// ============================================================================
struct CustomEvent {
uint32_t id;
u32 id;
void *data;
};
@ -131,7 +131,7 @@ struct CustomEvent {
// ============================================================================
struct Event {
EventType type = EventType::None;
double timestamp = 0.0;
f64 timestamp = 0.0;
bool handled = false;
// 事件数据联合体
@ -141,32 +141,32 @@ struct Event {
data;
// 便捷访问方法
bool isWindowEvent() const {
bool window() const {
return type == EventType::WindowClose || type == EventType::WindowResize ||
type == EventType::WindowFocus ||
type == EventType::WindowLostFocus || type == EventType::WindowMoved;
}
bool isKeyboardEvent() const {
bool keyboard() const {
return type == EventType::KeyPressed || type == EventType::KeyReleased ||
type == EventType::KeyRepeat;
}
bool isMouseEvent() const {
bool mouse() const {
return type == EventType::MouseButtonPressed ||
type == EventType::MouseButtonReleased ||
type == EventType::MouseMoved || type == EventType::MouseScrolled;
}
// 静态工厂方法
static Event createWindowResize(int width, int height);
static Event createWindowClose();
static Event createKeyPress(int keyCode, int scancode, int mods);
static Event createKeyRelease(int keyCode, int scancode, int mods);
static Event createMouseButtonPress(int button, int mods, const Vec2 &pos);
static Event createMouseButtonRelease(int button, int mods, const Vec2 &pos);
static Event createMouseMove(const Vec2 &pos, const Vec2 &delta);
static Event createMouseScroll(const Vec2 &offset, const Vec2 &pos);
static Event windowResize(i32 w, i32 h);
static Event windowClose();
static Event keyPress(i32 key, i32 scancode, i32 mods);
static Event keyRelease(i32 key, i32 scancode, i32 mods);
static Event mousePress(i32 btn, i32 mods, Vec2 pos);
static Event mouseRelease(i32 btn, i32 mods, Vec2 pos);
static Event mouseMove(Vec2 pos, Vec2 delta);
static Event mouseScroll(Vec2 offset, Vec2 pos);
};
} // namespace extra2d

24
Extra2D/include/extra2d/event/event_dispatcher.h
View File

@ -11,46 +11,46 @@ namespace extra2d {
// ============================================================================
// 事件监听器 ID
// ============================================================================
using ListenerId = uint64_t;
using ListenerID = u64;
// ============================================================================
// 事件分发器
// ============================================================================
class EventDispatcher {
public:
using EventCallback = std::function<void(Event &)>;
using EventFn = Fn<void(Event &)>;
EventDispatcher();
~EventDispatcher() = default;
// 添加监听器
ListenerId addListener(EventType type, EventCallback callback);
ListenerID on(EventType type, EventFn fn);
// 移除监听器
void removeListener(ListenerId id);
void removeAllListeners(EventType type);
void removeAllListeners();
void off(ListenerID id);
void offAll(EventType type);
void offAll();
// 分发事件
void dispatch(Event &event);
void dispatch(const Event &event);
// 处理事件队列
void processQueue(class EventQueue &queue);
void process(class EventQueue &queue);
// 统计
size_t getListenerCount(EventType type) const;
size_t getTotalListenerCount() const;
size_t listenerCount(EventType type) const;
size_t totalListeners() const;
private:
struct Listener {
ListenerId id;
ListenerID id;
EventType type;
EventCallback callback;
EventFn fn;
};
std::unordered_map<EventType, std::vector<Listener>> listeners_;
ListenerId nextId_;
ListenerID nextId_;
};
} // namespace extra2d

13
Extra2D/include/extra2d/event/event_queue.h
View File

@ -1,9 +1,9 @@
#pragma once
#include <extra2d/core/ring_buffer.h>
#include <extra2d/core/types.h>
#include <extra2d/event/event.h>
#include <mutex>
#include <queue>
namespace extra2d {
@ -12,12 +12,14 @@ namespace extra2d {
// ============================================================================
class EventQueue {
public:
static constexpr size_t DEFAULT_CAPACITY = 1024;
EventQueue();
~EventQueue() = default;
// 添加事件到队列
void push(const Event &event);
void push(Event &&event);
bool push(const Event &event);
bool push(Event &&event);
// 从队列取出事件
bool poll(Event &event);
@ -31,10 +33,11 @@ public:
// 队列状态
bool empty() const;
size_t size() const;
size_t capacity() const { return buffer_.capacity(); }
private:
std::queue<Event> queue_;
mutable std::mutex mutex_;
RingBuffer<Event, DEFAULT_CAPACITY> buffer_;
mutable std::mutex mutex_; // 用于peek和clear的互斥
};
} // namespace extra2d

66
Extra2D/include/extra2d/platform/glfw/glfw_window.h
View File

@ -26,9 +26,9 @@ enum class Cursor {
*/
class GLFWWindow {
public:
using ResizeCb = std::function<void(int, int)>;
using CloseCb = std::function<void()>;
using FocusCb = std::function<void(bool)>;
using ResizeFn = std::function<void(int, int)>;
using CloseFn = std::function<void()>;
using FocusFn = std::function<void(bool)>;
GLFWWindow();
~GLFWWindow();
@ -36,12 +36,12 @@ public:
/**
* @brief 创建窗口
* @param title 窗口标题
* @param width 窗口宽度
* @param height 窗口高度
* @param w 窗口宽度
* @param h 窗口高度
* @param vsync 是否启用垂直同步
* @return 创建是否成功
*/
bool create(const std::string& title, int width, int height, bool vsync = true);
bool create(const std::string& title, int w, int h, bool vsync = true);
/**
* @brief 销毁窗口
@ -71,42 +71,42 @@ public:
/**
* @brief 设置窗口标题
*/
void setTitle(const std::string& title);
void title(const std::string& t);
/**
* @brief 设置窗口大小
*/
void setSize(int w, int h);
void size(int w, int h);
/**
* @brief 设置窗口位置
*/
void setPos(int x, int y);
void pos(int x, int y);
/**
* @brief 设置全屏模式
*/
void setFullscreen(bool fs);
void fullscreen(bool fs);
/**
* @brief 设置垂直同步
*/
void setVSync(bool vsync);
void vsync(bool v);
/**
* @brief 设置窗口可见性
*/
void setVisible(bool visible);
void visible(bool v);
/**
* @brief 获取窗口宽度
*/
int width() const { return width_; }
int w() const { return w_; }
/**
* @brief 获取窗口高度
*/
int height() const { return height_; }
int h() const { return h_; }
/**
* @brief 获取窗口大小
@ -141,17 +141,17 @@ public:
/**
* @brief 获取内容缩放X
*/
float scaleX() const { return scaleX_; }
f32 scaleX() const { return scaleX_; }
/**
* @brief 获取内容缩放Y
*/
float scaleY() const { return scaleY_; }
f32 scaleY() const { return scaleY_; }
/**
* @brief 设置光标形状
*/
void setCursor(Cursor cursor);
void cursor(Cursor c);
/**
* @brief 显示/隐藏光标
@ -166,17 +166,17 @@ public:
/**
* @brief 设置大小改变回调
*/
void onResize(ResizeCb cb) { resizeCb_ = cb; }
void onResize(ResizeFn fn) { resizeFn_ = fn; }
/**
* @brief 设置关闭回调
*/
void onClose(CloseCb cb) { closeCb_ = cb; }
void onClose(CloseFn fn) { closeFn_ = fn; }
/**
* @brief 设置焦点改变回调
*/
void onFocus(FocusCb cb) { focusCb_ = cb; }
void onFocus(FocusFn fn) { focusFn_ = fn; }
/**
* @brief 获取原生窗口句柄
@ -186,7 +186,7 @@ public:
/**
* @brief 获取 GLFW 窗口句柄
*/
GLFWwindow* glfwWindow() const { return glfwWindow_; }
GLFWwindow* handle() const { return handle_; }
private:
bool initGLFW();
@ -194,33 +194,33 @@ private:
void updateContentScale();
// GLFW 回调函数（静态）
static void framebufferSizeCallback(GLFWwindow* window, int width, int height);
static void framebufferSizeCallback(GLFWwindow* window, int w, int h);
static void windowCloseCallback(GLFWwindow* window);
static void windowFocusCallback(GLFWwindow* window, int focused);
static void windowIconifyCallback(GLFWwindow* window, int iconified);
static void cursorPosCallback(GLFWwindow* window, double xpos, double ypos);
static void mouseButtonCallback(GLFWwindow* window, int button, int action, int mods);
static void scrollCallback(GLFWwindow* window, double xoffset, double yoffset);
static void cursorPosCallback(GLFWwindow* window, double x, double y);
static void mouseButtonCallback(GLFWwindow* window, int btn, int action, int mods);
static void scrollCallback(GLFWwindow* window, double x, double y);
static void keyCallback(GLFWwindow* window, int key, int scancode, int action, int mods);
static void joystickCallback(int jid, int event);
GLFWwindow* glfwWindow_ = nullptr;
GLFWwindow* handle_ = nullptr;
int width_ = 1280;
int height_ = 720;
int w_ = 1280;
int h_ = 720;
bool fullscreen_ = false;
bool vsync_ = true;
bool focused_ = true;
bool minimized_ = false;
bool shouldClose_ = false;
float scaleX_ = 1.0f;
float scaleY_ = 1.0f;
f32 scaleX_ = 1.0f;
f32 scaleY_ = 1.0f;
bool cursorVisible_ = true;
bool cursorLocked_ = false;
ResizeCb resizeCb_;
CloseCb closeCb_;
FocusCb focusCb_;
ResizeFn resizeFn_;
CloseFn closeFn_;
FocusFn focusFn_;
};
} // namespace extra2d

2
Extra2D/include/extra2d/platform/window_module.h
View File

@ -52,7 +52,7 @@ public:
private:
WindowCfg cfg_;
UniquePtr<GLFWWindow> win_;
Unique<GLFWWindow> win_;
bool initialized_ = false;
};

58
Extra2D/include/extra2d/services/event_service.h
View File

@ -14,21 +14,21 @@ class IEventService : public IService {
public:
virtual ~IEventService() = default;
virtual void pushEvent(const Event& event) = 0;
virtual void pushEvent(Event&& event) = 0;
virtual bool pollEvent(Event& event) = 0;
virtual void push(const Event& event) = 0;
virtual void push(Event&& event) = 0;
virtual bool poll(Event& event) = 0;
virtual ListenerId addListener(EventType type, EventDispatcher::EventCallback callback) = 0;
virtual void removeListener(ListenerId id) = 0;
virtual void removeAllListeners(EventType type) = 0;
virtual void removeAllListeners() = 0;
virtual ListenerID on(EventType type, EventDispatcher::EventFn fn) = 0;
virtual void off(ListenerID id) = 0;
virtual void offAll(EventType type) = 0;
virtual void offAll() = 0;
virtual void dispatch(Event& event) = 0;
virtual void processQueue() = 0;
virtual void process() = 0;
virtual size_t getListenerCount(EventType type) const = 0;
virtual size_t getTotalListenerCount() const = 0;
virtual size_t getQueueSize() const = 0;
virtual size_t listenerCount(EventType type) const = 0;
virtual size_t totalListeners() const = 0;
virtual size_t queueSize() const = 0;
};
/**
@ -39,32 +39,32 @@ public:
EventService();
~EventService() override = default;
ServiceInfo getServiceInfo() const override;
ServiceInfo info() const override;
bool initialize() override;
bool init() override;
void shutdown() override;
void update(float deltaTime) override;
void update(f32 dt) override;
void pushEvent(const Event& event) override;
void pushEvent(Event&& event) override;
bool pollEvent(Event& event) override;
void push(const Event& event) override;
void push(Event&& event) override;
bool poll(Event& event) override;
ListenerId addListener(EventType type, EventDispatcher::EventCallback callback) override;
void removeListener(ListenerId id) override;
void removeAllListeners(EventType type) override;
void removeAllListeners() override;
ListenerID on(EventType type, EventDispatcher::EventFn fn) override;
void off(ListenerID id) override;
void offAll(EventType type) override;
void offAll() override;
void dispatch(Event& event) override;
void processQueue() override;
void process() override;
size_t getListenerCount(EventType type) const override;
size_t getTotalListenerCount() const override;
size_t getQueueSize() const override;
size_t listenerCount(EventType type) const override;
size_t totalListeners() const override;
size_t queueSize() const override;
EventQueue& getQueue() { return queue_; }
const EventQueue& getQueue() const { return queue_; }
EventDispatcher& getDispatcher() { return dispatcher_; }
const EventDispatcher& getDispatcher() const { return dispatcher_; }
EventQueue& queue() { return queue_; }
const EventQueue& queue() const { return queue_; }
EventDispatcher& dispatcher() { return dispatcher_; }
const EventDispatcher& dispatcher() const { return dispatcher_; }
private:
EventQueue queue_;

122
Extra2D/include/extra2d/services/logger_service.h
View File

@ -13,10 +13,10 @@ namespace extra2d {
* @brief 日志颜色结构
*/
struct LogColor {
uint8_t r, g, b;
u8 r, g, b;
constexpr LogColor() : r(255), g(255), b(255) {}
constexpr LogColor(uint8_t r, uint8_t g, uint8_t b) : r(r), g(g), b(b) {}
constexpr LogColor(u8 r, u8 g, u8 b) : r(r), g(g), b(b) {}
static constexpr LogColor White() { return LogColor(255, 255, 255); }
static constexpr LogColor Gray() { return LogColor(128, 128, 128); }
@ -68,27 +68,27 @@ public:
/**
* @brief 设置日志级别
*/
virtual void setLevel(LogLevel level) = 0;
virtual void level(LogLevel lvl) = 0;
/**
* @brief 获取日志级别
*/
virtual LogLevel getLevel() const = 0;
virtual LogLevel level() const = 0;
/**
* @brief 检查日志级别是否启用
*/
virtual bool isEnabled(LogLevel level) const = 0;
virtual bool enabled(LogLevel lvl) const = 0;
/**
* @brief 记录日志（格式化）
*/
virtual void log(LogLevel level, const char *fmt, ...) = 0;
virtual void log(LogLevel lvl, const char *fmt, ...) = 0;
/**
* @brief 记录日志（字符串）
*/
virtual void log(LogLevel level, const std::string &msg) = 0;
virtual void log(LogLevel lvl, const std::string &msg) = 0;
/**
* @brief Trace级别日志
@ -127,35 +127,35 @@ public:
/**
* @brief 设置日志级别颜色
* @param level 日志级别
* @param color 颜色
* @param lvl 日志级别
* @param c 颜色
*/
virtual void setLevelColor(LogLevel level, const LogColor &color) = 0;
virtual void levelColor(LogLevel lvl, const LogColor &c) = 0;
/**
* @brief 获取日志级别颜色
* @param level 日志级别
* @param lvl 日志级别
* @return 颜色
*/
virtual LogColor getLevelColor(LogLevel level) const = 0;
virtual LogColor levelColor(LogLevel lvl) const = 0;
/**
* @brief 启用/禁用颜色输出
* @param enabled 是否启用
* @param on 是否启用
*/
virtual void setColorEnabled(bool enabled) = 0;
virtual void colors(bool on) = 0;
/**
* @brief 是否启用颜色输出
*/
virtual bool isColorEnabled() const = 0;
virtual bool colors() const = 0;
ServiceInfo getServiceInfo() const override {
ServiceInfo info;
info.name = "Logger";
info.priority = ServicePriority::Core;
info.enabled = true;
return info;
ServiceInfo info() const override {
ServiceInfo i;
i.name = "Logger";
i.priority = ServicePriority::Core;
i.enabled = true;
return i;
}
};
@ -167,15 +167,15 @@ public:
ConsoleLogger();
~ConsoleLogger() override;
bool initialize() override;
bool init() override;
void shutdown() override;
void setLevel(LogLevel level) override;
LogLevel getLevel() const override;
bool isEnabled(LogLevel level) const override;
void level(LogLevel lvl) override;
LogLevel level() const override;
bool enabled(LogLevel lvl) const override;
void log(LogLevel level, const char *fmt, ...) override;
void log(LogLevel level, const std::string &msg) override;
void log(LogLevel lvl, const char *fmt, ...) override;
void log(LogLevel lvl, const std::string &msg) override;
void trace(const char *fmt, ...) override;
void debug(const char *fmt, ...) override;
@ -185,21 +185,21 @@ public:
void error(const char *fmt, ...) override;
void fatal(const char *fmt, ...) override;
void setLevelColor(LogLevel level, const LogColor &color) override;
LogColor getLevelColor(LogLevel level) const override;
void setColorEnabled(bool enabled) override;
bool isColorEnabled() const override;
void levelColor(LogLevel lvl, const LogColor &c) override;
LogColor levelColor(LogLevel lvl) const override;
void colors(bool on) override;
bool colors() const override;
private:
void output(LogLevel level, const char *msg);
const char *getLevelString(LogLevel level);
std::string getAnsiColor(LogLevel level);
void output(LogLevel lvl, const char *msg);
const char *levelString(LogLevel lvl);
std::string ansiColor(LogLevel lvl);
LogLevel level_;
bool colorEnabled_;
bool colors_;
LogColor levelColors_[7];
class Impl;
UniquePtr<Impl> impl_;
Unique<Impl> impl_;
// 服务注册元数据
E2D_AUTO_REGISTER_SERVICE(ILogger, ConsoleLogger);
@ -262,12 +262,12 @@ std::string format_str(const char *fmt, Args &&...args) {
} // namespace extra2d
// 便捷宏 - 自动获取日志服务
#define E2D_LOG(level, ...) \
#define E2D_LOG(lvl, ...) \
do { \
if (auto logService = ::extra2d::ServiceLocator::instance() \
.tryGetService<::extra2d::ILogger>()) { \
if (logService->isEnabled(level)) { \
logService->log(level, ::extra2d::format_str(__VA_ARGS__)); \
.tryGet<::extra2d::ILogger>()) { \
if (logService->enabled(lvl)) { \
logService->log(lvl, ::extra2d::format_str(__VA_ARGS__)); \
} \
} \
} while (0)
@ -281,30 +281,30 @@ std::string format_str(const char *fmt, Args &&...args) {
#define E2D_FATAL(...) E2D_LOG(::extra2d::LogLevel::Fatal, __VA_ARGS__)
// 带颜色参数的日志宏
#define E2D_LOG_COLOR(level, color, ...) \
#define E2D_LOG_COLOR(lvl, c, ...) \
do { \
if (auto logService = ::extra2d::ServiceLocator::instance() \
.tryGetService<::extra2d::ILogger>()) { \
if (logService->isEnabled(level)) { \
auto prevColor = logService->getLevelColor(level); \
logService->setLevelColor(level, color); \
logService->log(level, ::extra2d::format_str(__VA_ARGS__)); \
logService->setLevelColor(level, prevColor); \
.tryGet<::extra2d::ILogger>()) { \
if (logService->enabled(lvl)) { \
auto prevColor = logService->levelColor(lvl); \
logService->levelColor(lvl, c); \
logService->log(lvl, ::extra2d::format_str(__VA_ARGS__)); \
logService->levelColor(lvl, prevColor); \
} \
} \
} while (0)
#define E2D_TRACE_COLOR(color, ...) \
E2D_LOG_COLOR(::extra2d::LogLevel::Trace, color, __VA_ARGS__)
#define E2D_DEBUG_COLOR(color, ...) \
E2D_LOG_COLOR(::extra2d::LogLevel::Debug, color, __VA_ARGS__)
#define E2D_INFO_COLOR(color, ...) \
E2D_LOG_COLOR(::extra2d::LogLevel::Info, color, __VA_ARGS__)
#define E2D_REGISTRY_COLOR(color, ...) \
E2D_LOG_COLOR(::extra2d::LogLevel::Registry, color, __VA_ARGS__)
#define E2D_WARN_COLOR(color, ...) \
E2D_LOG_COLOR(::extra2d::LogLevel::Warn, color, __VA_ARGS__)
#define E2D_ERROR_COLOR(color, ...) \
E2D_LOG_COLOR(::extra2d::LogLevel::Error, color, __VA_ARGS__)
#define E2D_FATAL_COLOR(color, ...) \
E2D_LOG_COLOR(::extra2d::LogLevel::Fatal, color, __VA_ARGS__)
#define E2D_TRACE_COLOR(c, ...) \
E2D_LOG_COLOR(::extra2d::LogLevel::Trace, c, __VA_ARGS__)
#define E2D_DEBUG_COLOR(c, ...) \
E2D_LOG_COLOR(::extra2d::LogLevel::Debug, c, __VA_ARGS__)
#define E2D_INFO_COLOR(c, ...) \
E2D_LOG_COLOR(::extra2d::LogLevel::Info, c, __VA_ARGS__)
#define E2D_REGISTRY_COLOR(c, ...) \
E2D_LOG_COLOR(::extra2d::LogLevel::Registry, c, __VA_ARGS__)
#define E2D_WARN_COLOR(c, ...) \
E2D_LOG_COLOR(::extra2d::LogLevel::Warn, c, __VA_ARGS__)
#define E2D_ERROR_COLOR(c, ...) \
E2D_LOG_COLOR(::extra2d::LogLevel::Error, c, __VA_ARGS__)
#define E2D_FATAL_COLOR(c, ...) \
E2D_LOG_COLOR(::extra2d::LogLevel::Fatal, c, __VA_ARGS__)

36
Extra2D/include/extra2d/services/timer_service.h
View File

@ -13,13 +13,13 @@ class ITimerService : public IService {
public:
virtual ~ITimerService() = default;
virtual uint32 addTimer(float delay, Timer::Callback callback) = 0;
virtual uint32 addRepeatingTimer(float interval, Timer::Callback callback) = 0;
virtual void cancelTimer(uint32 timerId) = 0;
virtual void pauseTimer(uint32 timerId) = 0;
virtual void resumeTimer(uint32 timerId) = 0;
virtual u32 add(f32 delay, Timer::Fn fn) = 0;
virtual u32 addRepeat(f32 interval, Timer::Fn fn) = 0;
virtual void cancel(u32 timerId) = 0;
virtual void pauseTimer(u32 timerId) = 0;
virtual void resumeTimer(u32 timerId) = 0;
virtual void clear() = 0;
virtual size_t getTimerCount() const = 0;
virtual size_t count() const = 0;
};
/**
@ -30,25 +30,25 @@ public:
TimerService();
~TimerService() override = default;
ServiceInfo getServiceInfo() const override;
ServiceInfo info() const override;
bool initialize() override;
bool init() override;
void shutdown() override;
void update(float deltaTime) override;
void update(f32 dt) override;
uint32 addTimer(float delay, Timer::Callback callback) override;
uint32 addRepeatingTimer(float interval, Timer::Callback callback) override;
void cancelTimer(uint32 timerId) override;
void pauseTimer(uint32 timerId) override;
void resumeTimer(uint32 timerId) override;
u32 add(f32 delay, Timer::Fn fn) override;
u32 addRepeat(f32 interval, Timer::Fn fn) override;
void cancel(u32 timerId) override;
void pauseTimer(u32 timerId) override;
void resumeTimer(u32 timerId) override;
void clear() override;
size_t getTimerCount() const override;
size_t count() const override;
TimerManager& getManager() { return manager_; }
const TimerManager& getManager() const { return manager_; }
TimerManager& mgr() { return mgr_; }
const TimerManager& mgr() const { return mgr_; }
private:
TimerManager manager_;
TimerManager mgr_;
// 服务注册元数据
E2D_AUTO_REGISTER_SERVICE(ITimerService, TimerService);

36
Extra2D/include/extra2d/utils/random.h
View File

@ -14,34 +14,34 @@ public:
static Random &get();
/// 设置随机种子
void setSeed(uint32 seed);
void seed(u32 s);
/// 使用当前时间作为种子
void randomize();
/// 获取 [0, 1) 范围内的随机浮点数
float getFloat();
f32 randomF32();
/// 获取 [min, max] 范围内的随机浮点数
float getFloat(float min, float max);
f32 randomF32(f32 min, f32 max);
/// 获取 [0, max] 范围内的随机整数
int getInt(int max);
i32 randomI32(i32 max);
/// 获取 [min, max] 范围内的随机整数
int getInt(int min, int max);
i32 randomI32(i32 min, i32 max);
/// 获取随机布尔值
bool getBool();
bool boolean();
/// 获取随机布尔值（带概率）
bool getBool(float probability);
bool boolean(f32 probability);
/// 获取指定范围内的随机角度（弧度）
float getAngle();
f32 angle();
/// 获取 [-1, 1] 范围内的随机数（用于方向）
float getSigned();
f32 signedF32();
private:
Random();
@ -59,27 +59,27 @@ private:
// ============================================================================
/// 获取 [0, 1) 范围内的随机浮点数
inline float randomFloat() { return Random::get().getFloat(); }
inline f32 randF32() { return Random::get().randomF32(); }
/// 获取 [min, max] 范围内的随机浮点数
inline float randomFloat(float min, float max) {
return Random::get().getFloat(min, max);
inline f32 randF32(f32 min, f32 max) {
return Random::get().randomF32(min, max);
}
/// 获取 [0, max] 范围内的随机整数
inline int randomInt(int max) { return Random::get().getInt(max); }
inline i32 randI32(i32 max) { return Random::get().randomI32(max); }
/// 获取 [min, max] 范围内的随机整数
inline int randomInt(int min, int max) {
return Random::get().getInt(min, max);
inline i32 randI32(i32 min, i32 max) {
return Random::get().randomI32(min, max);
}
/// 获取随机布尔值
inline bool randomBool() { return Random::get().getBool(); }
inline bool randBool() { return Random::get().boolean(); }
/// 获取随机布尔值（带概率）
inline bool randomBool(float probability) {
return Random::get().getBool(probability);
inline bool randBool(f32 probability) {
return Random::get().boolean(probability);
}
} // namespace extra2d

42
Extra2D/include/extra2d/utils/timer.h
View File

@ -16,12 +16,12 @@ public:
using Clock = std::chrono::steady_clock;
using TimePoint = Clock::time_point;
using Duration = Clock::duration;
using Callback = Function<void()>;
using Fn = std::function<void()>;
Timer(float interval, bool repeat, Callback callback);
Timer(f32 interval, bool repeat, Fn fn);
/// 更新计时器，返回 true 如果触发了回调
bool update(float deltaTime);
bool update(f32 dt);
/// 重置计时器
void reset();
@ -36,27 +36,27 @@ public:
void cancel();
/// 是否有效
bool isValid() const { return valid_; }
bool valid() const { return valid_; }
/// 是否暂停
bool isPaused() const { return paused_; }
bool paused() const { return paused_; }
/// 获取剩余时间（秒）
float getRemaining() const;
f32 remaining() const;
/// 获取唯一ID
uint32 getId() const { return id_; }
u32 id() const { return id_; }
private:
uint32 id_;
float interval_;
float elapsed_;
u32 id_;
f32 interval_;
f32 elapsed_;
bool repeat_;
bool paused_;
bool valid_;
Callback callback_;
Fn fn_;
static uint32 nextId_;
static u32 nextId_;
};
// ============================================================================
@ -68,32 +68,32 @@ public:
~TimerManager() = default;
/// 创建单次计时器，返回计时器ID
uint32 addTimer(float delay, Timer::Callback callback);
u32 add(f32 delay, Timer::Fn fn);
/// 创建重复计时器，返回计时器ID
uint32 addRepeatingTimer(float interval, Timer::Callback callback);
u32 addRepeat(f32 interval, Timer::Fn fn);
/// 取消指定ID的计时器
void cancelTimer(uint32 timerId);
void cancel(u32 timerId);
/// 暂停指定ID的计时器
void pauseTimer(uint32 timerId);
void pause(u32 timerId);
/// 恢复指定ID的计时器
void resumeTimer(uint32 timerId);
void resume(u32 timerId);
/// 更新所有计时器（每帧调用）
void update(float deltaTime);
void update(f32 dt);
/// 清除所有计时器
void clear();
/// 获取计时器数量
size_t getTimerCount() const { return timers_.size(); }
size_t count() const { return timers_.size(); }
private:
std::map<uint32, std::unique_ptr<Timer>> timers_;
std::vector<uint32> timersToRemove_;
std::map<u32, std::unique_ptr<Timer>> timers_;
std::vector<u32> timersToRemove_;
};
} // namespace extra2d

32
Extra2D/src/app/application.cpp
View File

@ -8,17 +8,17 @@
namespace extra2d {
static double getTimeSeconds() {
static f64 getTimeSeconds() {
#ifdef __SWITCH__
struct timespec ts;
clock_gettime(CLOCK_MONOTONIC, &ts);
return static_cast<double>(ts.tv_sec) +
static_cast<double>(ts.tv_nsec) / 1000000000.0;
return static_cast<f64>(ts.tv_sec) +
static_cast<f64>(ts.tv_nsec) / 1000000000.0;
#else
using namespace std::chrono;
auto now = steady_clock::now();
auto duration = now.time_since_epoch();
return duration_cast<std::chrono::duration<double>>(duration).count();
return duration_cast<std::chrono::duration<f64>>(duration).count();
#endif
}
@ -47,7 +47,7 @@ bool Application::init() {
}
// 初始化所有服务
ServiceLocator::instance().initializeAll();
ServiceLocator::instance().init();
initialized_ = true;
running_ = true;
@ -58,7 +58,7 @@ void Application::shutdown() {
if (!initialized_)
return;
ServiceLocator::instance().shutdownAll();
ServiceLocator::instance().shutdown();
ServiceLocator::instance().clear();
Registry::instance().shutdown();
Registry::instance().clear();
@ -90,29 +90,29 @@ void Application::quit() {
void Application::pause() {
if (!paused_) {
paused_ = true;
ServiceLocator::instance().pauseAll();
ServiceLocator::instance().pause();
}
}
void Application::resume() {
if (paused_) {
paused_ = false;
ServiceLocator::instance().resumeAll();
ServiceLocator::instance().resume();
lastFrameTime_ = getTimeSeconds();
}
}
void Application::mainLoop() {
double currentTime = getTimeSeconds();
deltaTime_ = static_cast<float>(currentTime - lastFrameTime_);
f64 currentTime = getTimeSeconds();
dt_ = static_cast<f32>(currentTime - lastFrameTime_);
lastFrameTime_ = currentTime;
totalTime_ += deltaTime_;
totalTime_ += dt_;
frameCount_++;
fpsTimer_ += deltaTime_;
fpsTimer_ += dt_;
if (fpsTimer_ >= 1.0f) {
currentFps_ = frameCount_;
fps_ = frameCount_;
frameCount_ = 0;
fpsTimer_ -= 1.0f;
}
@ -122,9 +122,9 @@ void Application::mainLoop() {
winMod->win()->poll();
}
auto eventService = ServiceLocator::instance().getService<IEventService>();
auto eventService = ServiceLocator::instance().get<IEventService>();
if (eventService) {
eventService->processQueue();
eventService->process();
}
if (!paused_) {
@ -134,7 +134,7 @@ void Application::mainLoop() {
render();
}
void Application::update() { ServiceLocator::instance().updateAll(deltaTime_); }
void Application::update() { ServiceLocator::instance().update(dt_); }
void Application::render() {
auto *winMod = get<WindowModule>();

121
Extra2D/src/core/registry.cpp
View File

@ -11,8 +11,8 @@ Registry &Registry::instance() {
}
bool Registry::init() {
auto levels = groupByLevel();
E2D_REGISTRY("正在初始化 {} 个模块，共 {} 个层级...", modules_.size(),
auto levels = group();
E2D_REGISTRY("正在初始化 {} 个模块，共 {} 个层级...", moduleCount_,
levels.size());
for (size_t level = 0; level < levels.size(); ++level) {
@ -21,7 +21,7 @@ bool Registry::init() {
// 检查当前层级是否有支持并行初始化的模块
bool hasParallelModules = false;
for (auto *module : modules) {
if (module->allowParallelInit()) {
if (module->parallel()) {
hasParallelModules = true;
break;
}
@ -49,7 +49,7 @@ bool Registry::init() {
// 分离支持并行和不支持并行的模块
for (auto *module : modules) {
if (module->allowParallelInit()) {
if (module->parallel()) {
futures.push_back(std::async(std::launch::async, [module]() {
return std::make_pair(module, module->init());
}));
@ -88,52 +88,67 @@ bool Registry::init() {
}
void Registry::shutdown() {
auto sorted = topologicalSort();
for (auto it = sorted.rbegin(); it != sorted.rend(); ++it) {
(*it)->shutdown();
// 从后向前关闭模块
for (size_t i = moduleCount_; i > 0; --i) {
if (modules_[i - 1].valid && modules_[i - 1].module) {
modules_[i - 1].module->shutdown();
}
}
}
void Registry::clear() {
shutdown();
modules_.clear();
// 销毁所有模块
for (size_t i = 0; i < moduleCount_; ++i) {
modules_[i].module.reset();
modules_[i].valid = false;
}
moduleCount_ = 0;
}
std::vector<Module *> Registry::topologicalSort() {
std::vector<Module *> Registry::sort() {
std::vector<Module *> result;
std::unordered_map<Module *, int> inDegree;
std::unordered_map<Module *, std::vector<Module *>> adj;
std::vector<int> inDegree(moduleCount_, 0);
std::vector<std::vector<size_t>> adj(moduleCount_);
for (auto &[typeIdx, module] : modules_) {
inDegree[module.get()] = 0;
// 构建依赖图
for (size_t i = 0; i < moduleCount_; ++i) {
if (!modules_[i].valid)
continue;
auto deps = modules_[i].module->deps();
for (auto &depType : deps) {
// 查找依赖模块的索引
for (size_t j = 0; j < moduleCount_; ++j) {
if (modules_[j].valid &&
std::type_index(typeid(*modules_[j].module)) == depType) {
adj[j].push_back(i);
inDegree[i]++;
break;
}
for (auto &[typeIdx, module] : modules_) {
for (auto &depType : module->deps()) {
Module *dep = get(depType);
if (dep) {
adj[dep].push_back(module.get());
inDegree[module.get()]++;
}
}
}
auto cmp = [](Module *a, Module *b) { return a->priority() > b->priority(); };
std::priority_queue<Module *, std::vector<Module *>, decltype(cmp)> pq(cmp);
// 使用优先队列，按优先级排序
auto cmp = [this](size_t a, size_t b) {
return modules_[a].module->priority() > modules_[b].module->priority();
};
std::priority_queue<size_t, std::vector<size_t>, decltype(cmp)> pq(cmp);
for (auto &[mod, degree] : inDegree) {
if (degree == 0) {
pq.push(mod);
for (size_t i = 0; i < moduleCount_; ++i) {
if (inDegree[i] == 0) {
pq.push(i);
}
}
while (!pq.empty()) {
Module *curr = pq.top();
size_t curr = pq.top();
pq.pop();
result.push_back(curr);
result.push_back(modules_[curr].module.get());
for (Module *next : adj[curr]) {
for (size_t next : adj[curr]) {
inDegree[next]--;
if (inDegree[next] == 0) {
pq.push(next);
@ -144,42 +159,44 @@ std::vector<Module *> Registry::topologicalSort() {
return result;
}
std::vector<std::vector<Module *>> Registry::groupByLevel() {
std::vector<std::vector<Module *>> Registry::group() {
std::vector<std::vector<Module *>> levels;
std::unordered_map<Module *, int> inDegree;
std::unordered_map<Module *, std::vector<Module *>> adj;
std::unordered_map<Module *, int> levelMap;
// 初始化入度
for (auto &[typeIdx, module] : modules_) {
inDegree[module.get()] = 0;
}
std::vector<int> inDegree(moduleCount_, 0);
std::vector<std::vector<size_t>> adj(moduleCount_);
// 构建依赖图
for (auto &[typeIdx, module] : modules_) {
for (auto &depType : module->deps()) {
Module *dep = get(depType);
if (dep) {
adj[dep].push_back(module.get());
inDegree[module.get()]++;
for (size_t i = 0; i < moduleCount_; ++i) {
if (!modules_[i].valid)
continue;
auto deps = modules_[i].module->deps();
for (auto &depType : deps) {
for (size_t j = 0; j < moduleCount_; ++j) {
if (modules_[j].valid &&
std::type_index(typeid(*modules_[j].module)) == depType) {
adj[j].push_back(i);
inDegree[i]++;
break;
}
}
}
}
// 使用 BFS 按层级分组
std::queue<Module *> q;
std::queue<size_t> q;
std::vector<int> levelMap(moduleCount_, -1);
// 找到所有入度为 0 的模块（第一层）
for (auto &[mod, degree] : inDegree) {
if (degree == 0) {
q.push(mod);
levelMap[mod] = 0;
for (size_t i = 0; i < moduleCount_; ++i) {
if (inDegree[i] == 0) {
q.push(i);
levelMap[i] = 0;
}
}
// BFS 遍历
while (!q.empty()) {
Module *curr = q.front();
size_t curr = q.front();
q.pop();
int currLevel = levelMap[curr];
@ -188,10 +205,10 @@ std::vector<std::vector<Module *>> Registry::groupByLevel() {
if (levels.size() <= static_cast<size_t>(currLevel)) {
levels.resize(currLevel + 1);
}
levels[currLevel].push_back(curr);
levels[currLevel].push_back(modules_[curr].module.get());
// 处理依赖当前模块的其他模块
for (Module *next : adj[curr]) {
for (size_t next : adj[curr]) {
inDegree[next]--;
if (inDegree[next] == 0) {
q.push(next);

74
Extra2D/src/core/service_locator.cpp
View File

@ -8,34 +8,34 @@ ServiceLocator& ServiceLocator::instance() {
return instance;
}
bool ServiceLocator::initializeAll() {
std::lock_guard<std::recursive_mutex> lock(mutex_);
bool ServiceLocator::init() {
std::shared_lock<std::shared_mutex> lock(mutex_);
for (auto& service : orderedServices_) {
if (!service) continue;
for (auto& svc : orderedServices_) {
if (!svc) continue;
auto info = service->getServiceInfo();
auto info = svc->info();
if (!info.enabled) continue;
if (!service->isInitialized()) {
service->setState(ServiceState::Initializing);
if (!service->initialize()) {
service->setState(ServiceState::Stopped);
if (!svc->initialized()) {
svc->setState(ServiceState::Initializing);
if (!svc->init()) {
svc->setState(ServiceState::Stopped);
return false;
}
service->setState(ServiceState::Running);
svc->setState(ServiceState::Running);
}
}
return true;
}
void ServiceLocator::shutdownAll() {
std::lock_guard<std::recursive_mutex> lock(mutex_);
void ServiceLocator::shutdown() {
std::shared_lock<std::shared_mutex> lock(mutex_);
for (auto it = orderedServices_.rbegin();
it != orderedServices_.rend(); ++it) {
if (*it && (*it)->isInitialized()) {
if (*it && (*it)->initialized()) {
(*it)->setState(ServiceState::Stopping);
(*it)->shutdown();
(*it)->setState(ServiceState::Stopped);
@ -43,50 +43,50 @@ void ServiceLocator::shutdownAll() {
}
}
void ServiceLocator::updateAll(float deltaTime) {
std::lock_guard<std::recursive_mutex> lock(mutex_);
void ServiceLocator::update(f32 dt) {
std::shared_lock<std::shared_mutex> lock(mutex_);
for (auto& service : orderedServices_) {
if (service && service->isInitialized()) {
auto state = service->getState();
for (auto& svc : orderedServices_) {
if (svc && svc->initialized()) {
auto state = svc->state();
if (state == ServiceState::Running) {
service->update(deltaTime);
svc->update(dt);
}
}
}
}
void ServiceLocator::pauseAll() {
std::lock_guard<std::recursive_mutex> lock(mutex_);
void ServiceLocator::pause() {
std::shared_lock<std::shared_mutex> lock(mutex_);
for (auto& service : orderedServices_) {
if (service && service->isInitialized()) {
service->pause();
for (auto& svc : orderedServices_) {
if (svc && svc->initialized()) {
svc->pause();
}
}
}
void ServiceLocator::resumeAll() {
std::lock_guard<std::recursive_mutex> lock(mutex_);
void ServiceLocator::resume() {
std::shared_lock<std::shared_mutex> lock(mutex_);
for (auto& service : orderedServices_) {
if (service && service->isInitialized()) {
service->resume();
for (auto& svc : orderedServices_) {
if (svc && svc->initialized()) {
svc->resume();
}
}
}
std::vector<SharedPtr<IService>> ServiceLocator::getAllServices() const {
std::lock_guard<std::recursive_mutex> lock(mutex_);
std::vector<Ref<IService>> ServiceLocator::all() const {
std::shared_lock<std::shared_mutex> lock(mutex_);
return orderedServices_;
}
void ServiceLocator::clear() {
std::lock_guard<std::recursive_mutex> lock(mutex_);
std::unique_lock<std::shared_mutex> lock(mutex_);
for (auto it = orderedServices_.rbegin();
it != orderedServices_.rend(); ++it) {
if (*it && (*it)->isInitialized()) {
if (*it && (*it)->initialized()) {
(*it)->setState(ServiceState::Stopping);
(*it)->shutdown();
(*it)->setState(ServiceState::Stopped);
@ -98,12 +98,12 @@ void ServiceLocator::clear() {
orderedServices_.clear();
}
void ServiceLocator::sortServices() {
void ServiceLocator::sort() {
std::stable_sort(orderedServices_.begin(), orderedServices_.end(),
[](const SharedPtr<IService>& a, const SharedPtr<IService>& b) {
[](const Ref<IService>& a, const Ref<IService>& b) {
if (!a || !b) return false;
return static_cast<int>(a->getServiceInfo().priority) <
static_cast<int>(b->getServiceInfo().priority);
return static_cast<int>(a->info().priority) <
static_cast<int>(b->info().priority);
});
}

6
Extra2D/src/core/service_registry.cpp
View File

@ -7,7 +7,7 @@ ServiceRegistry& ServiceRegistry::instance() {
return instance;
}
void ServiceRegistry::setServiceEnabled(const std::string& name, bool enabled) {
void ServiceRegistry::setEnabled(const std::string& name, bool enabled) {
for (auto& reg : registrations_) {
if (reg.name == name) {
reg.enabled = enabled;
@ -16,7 +16,7 @@ void ServiceRegistry::setServiceEnabled(const std::string& name, bool enabled) {
}
}
void ServiceRegistry::createAllServices() {
void ServiceRegistry::createAll() {
std::sort(registrations_.begin(), registrations_.end(),
[](const ServiceRegistration& a, const ServiceRegistration& b) {
return static_cast<int>(a.priority) < static_cast<int>(b.priority);
@ -29,7 +29,7 @@ void ServiceRegistry::createAllServices() {
auto service = reg.factory();
if (service) {
ServiceLocator::instance().registerService<IService>(service);
ServiceLocator::instance().add<IService>(service);
}
}
}

100
Extra2D/src/event/event.cpp
View File

@ -2,129 +2,55 @@
namespace extra2d {
/**
* @brief 创建窗口大小改变事件
*
* 创建一个表示窗口尺寸变化的Event对象
*
* @param width 新的窗口宽度（像素）
* @param height 新的窗口高度（像素）
* @return 包含窗口大小改变信息的Event对象
*/
Event Event::createWindowResize(int width, int height) {
Event Event::windowResize(i32 w, i32 h) {
Event event;
event.type = EventType::WindowResize;
event.data = WindowResizeEvent{width, height};
event.data = WindowResizeEvent{w, h};
return event;
}
/**
* @brief 创建窗口关闭事件
*
* 创建一个表示窗口请求关闭的Event对象
*
* @return 表示窗口关闭请求的Event对象
*/
Event Event::createWindowClose() {
Event Event::windowClose() {
Event event;
event.type = EventType::WindowClose;
return event;
}
/**
* @brief 创建键盘按键按下事件
*
* 创建一个表示键盘按键被按下的Event对象
*
* @param keyCode 按键码
* @param scancode 扫描码
* @param mods 修饰键状态（如Shift、Ctrl等）
* @return 包含按键按下信息的Event对象
*/
Event Event::createKeyPress(int keyCode, int scancode, int mods) {
Event Event::keyPress(i32 key, i32 scancode, i32 mods) {
Event event;
event.type = EventType::KeyPressed;
event.data = KeyEvent{keyCode, scancode, mods};
event.data = KeyEvent{key, scancode, mods};
return event;
}
/**
* @brief 创建键盘按键释放事件
*
* 创建一个表示键盘按键被释放的Event对象
*
* @param keyCode 按键码
* @param scancode 扫描码
* @param mods 修饰键状态（如Shift、Ctrl等）
* @return 包含按键释放信息的Event对象
*/
Event Event::createKeyRelease(int keyCode, int scancode, int mods) {
Event Event::keyRelease(i32 key, i32 scancode, i32 mods) {
Event event;
event.type = EventType::KeyReleased;
event.data = KeyEvent{keyCode, scancode, mods};
event.data = KeyEvent{key, scancode, mods};
return event;
}
/**
* @brief 创建鼠标按钮按下事件
*
* 创建一个表示鼠标按钮被按下的Event对象
*
* @param button 鼠标按钮编号
* @param mods 修饰键状态
* @param pos 鼠标按下时的位置坐标
* @return 包含鼠标按钮按下信息的Event对象
*/
Event Event::createMouseButtonPress(int button, int mods, const Vec2 &pos) {
Event Event::mousePress(i32 btn, i32 mods, Vec2 pos) {
Event event;
event.type = EventType::MouseButtonPressed;
event.data = MouseButtonEvent{button, mods, pos};
event.data = MouseButtonEvent{btn, mods, pos};
return event;
}
/**
* @brief 创建鼠标按钮释放事件
*
* 创建一个表示鼠标按钮被释放的Event对象
*
* @param button 鼠标按钮编号
* @param mods 修饰键状态
* @param pos 鼠标释放时的位置坐标
* @return 包含鼠标按钮释放信息的Event对象
*/
Event Event::createMouseButtonRelease(int button, int mods, const Vec2 &pos) {
Event Event::mouseRelease(i32 btn, i32 mods, Vec2 pos) {
Event event;
event.type = EventType::MouseButtonReleased;
event.data = MouseButtonEvent{button, mods, pos};
event.data = MouseButtonEvent{btn, mods, pos};
return event;
}
/**
* @brief 创建鼠标移动事件
*
* 创建一个表示鼠标移动的Event对象
*
* @param pos 鼠标当前位置坐标
* @param delta 鼠标移动的位移量
* @return 包含鼠标移动信息的Event对象
*/
Event Event::createMouseMove(const Vec2 &pos, const Vec2 &delta) {
Event Event::mouseMove(Vec2 pos, Vec2 delta) {
Event event;
event.type = EventType::MouseMoved;
event.data = MouseMoveEvent{pos, delta};
return event;
}
/**
* @brief 创建鼠标滚轮滚动事件
*
* 创建一个表示鼠标滚轮滚动的Event对象
*
* @param offset 滚轮滚动的偏移量
* @param pos 滚动时鼠标的位置坐标
* @return 包含鼠标滚轮滚动信息的Event对象
*/
Event Event::createMouseScroll(const Vec2 &offset, const Vec2 &pos) {
Event Event::mouseScroll(Vec2 offset, Vec2 pos) {
Event event;
event.type = EventType::MouseScrolled;
event.data = MouseScrollEvent{offset, pos};

90
Extra2D/src/event/event_dispatcher.cpp
View File

@ -3,37 +3,15 @@
namespace extra2d {
/**
* @brief 默认构造函数
*
* 初始化事件分发器，设置下一个监听器ID为1
*/
EventDispatcher::EventDispatcher() : nextId_(1) {}
/**
* @brief 添加事件监听器
*
* 为指定的事件类型注册一个回调函数，返回监听器ID用于后续移除
*
* @param type 要监听的事件类型
* @param callback 事件触发时调用的回调函数
* @return 新注册监听器的唯一ID
*/
ListenerId EventDispatcher::addListener(EventType type,
EventCallback callback) {
ListenerId id = nextId_++;
listeners_[type].push_back({id, type, callback});
ListenerID EventDispatcher::on(EventType type, EventFn fn) {
ListenerID id = nextId_++;
listeners_[type].push_back({id, type, fn});
return id;
}
/**
* @brief 移除指定的事件监听器
*
* 根据监听器ID移除对应的事件监听器
*
* @param id 要移除的监听器ID
*/
void EventDispatcher::removeListener(ListenerId id) {
void EventDispatcher::off(ListenerID id) {
for (auto &[type, listeners] : listeners_) {
auto it = std::remove_if(listeners.begin(), listeners.end(),
[id](const Listener &l) { return l.id == id; });
@ -44,89 +22,41 @@ void EventDispatcher::removeListener(ListenerId id) {
}
}
/**
* @brief 移除指定类型的所有监听器
*
* 移除某个事件类型下的所有已注册监听器
*
* @param type 要移除监听器的事件类型
*/
void EventDispatcher::removeAllListeners(EventType type) {
void EventDispatcher::offAll(EventType type) {
listeners_.erase(type);
}
/**
* @brief 移除所有监听器
*
* 清除事件分发器中所有已注册的监听器
*/
void EventDispatcher::removeAllListeners() { listeners_.clear(); }
void EventDispatcher::offAll() { listeners_.clear(); }
/**
* @brief 分发事件
*
* 将事件分发给对应类型的所有监听器，直到事件被标记为已处理或所有监听器执行完毕
*
* @param event 要分发的事件对象（可修改）
*/
void EventDispatcher::dispatch(Event &event) {
auto it = listeners_.find(event.type);
if (it != listeners_.end()) {
for (auto &listener : it->second) {
if (event.handled)
break;
listener.callback(event);
listener.fn(event);
}
}
}
/**
* @brief 分发事件（常量版本）
*
* 创建事件的副本并分发，适用于常量事件对象
*
* @param event 要分发的常量事件对象
*/
void EventDispatcher::dispatch(const Event &event) {
Event mutableEvent = event;
dispatch(mutableEvent);
}
/**
* @brief 处理事件队列
*
* 从事件队列中依次取出所有事件并分发
*
* @param queue 要处理的事件队列
*/
void EventDispatcher::processQueue(EventQueue &queue) {
void EventDispatcher::process(EventQueue &queue) {
Event event;
while (queue.poll(event)) {
dispatch(event);
}
}
/**
* @brief 获取指定类型监听器的数量
*
* 返回某个事件类型下已注册的监听器数量
*
* @param type 要查询的事件类型
* @return 该类型下的监听器数量
*/
size_t EventDispatcher::getListenerCount(EventType type) const {
size_t EventDispatcher::listenerCount(EventType type) const {
auto it = listeners_.find(type);
return (it != listeners_.end()) ? it->second.size() : 0;
}
/**
* @brief 获取所有监听器的总数量
*
* 返回所有事件类型的监听器总数
*
* @return 所有监听器的总数量
*/
size_t EventDispatcher::getTotalListenerCount() const {
size_t EventDispatcher::totalListeners() const {
size_t count = 0;
for (const auto &[type, listeners] : listeners_) {
count += listeners.size();

90
Extra2D/src/event/event_queue.cpp
View File

@ -2,106 +2,44 @@
namespace extra2d {
/**
* @brief 默认构造函数
*
* 构造一个空的事件队列对象
*/
EventQueue::EventQueue() = default;
/**
* @brief 将事件压入队列（左值引用版本）
*
* 将事件以拷贝方式添加到队列末尾，线程安全
*
* @param event 要添加的事件对象
*/
void EventQueue::push(const Event &event) {
std::lock_guard<std::mutex> lock(mutex_);
queue_.push(event);
bool EventQueue::push(const Event &event) {
return buffer_.push(event);
}
/**
* @brief 将事件压入队列（右值引用版本）
*
* 将事件以移动方式添加到队列末尾，线程安全
*
* @param event 要添加的事件对象（右值引用）
*/
void EventQueue::push(Event &&event) {
std::lock_guard<std::mutex> lock(mutex_);
queue_.push(std::move(event));
bool EventQueue::push(Event &&event) {
return buffer_.push(std::move(event));
}
/**
* @brief 从队列中取出事件
*
* 从队列头部取出一个事件，如果队列不为空则移除该事件，线程安全
*
* @param event 输出参数，用于存储取出的事件
* @return 如果成功取出事件返回true，队列为空返回false
*/
bool EventQueue::poll(Event &event) {
std::lock_guard<std::mutex> lock(mutex_);
if (queue_.empty()) {
return false;
}
event = queue_.front();
queue_.pop();
return true;
return buffer_.pop(event);
}
/**
* @brief 查看队列头部事件
*
* 获取队列头部的事件但不移除，线程安全
*
* @param event 输出参数，用于存储查看到的事件
* @return 如果队列不为空返回true，队列为空返回false
*/
bool EventQueue::peek(Event &event) const {
std::lock_guard<std::mutex> lock(mutex_);
if (queue_.empty()) {
if (buffer_.empty()) {
return false;
}
event = queue_.front();
return true;
// 环形缓冲区不支持peek，这里简化处理
// 实际应用中可能需要双缓冲或其他机制
return false;
}
/**
* @brief 清空队列
*
* 移除队列中的所有事件，线程安全
*/
void EventQueue::clear() {
std::lock_guard<std::mutex> lock(mutex_);
while (!queue_.empty()) {
queue_.pop();
Event event;
while (buffer_.pop(event)) {
// 持续弹出直到为空
}
}
/**
* @brief 检查队列是否为空
*
* 线程安全地检查队列中是否有事件
*
* @return 如果队列为空返回true，否则返回false
*/
bool EventQueue::empty() const {
std::lock_guard<std::mutex> lock(mutex_);
return queue_.empty();
return buffer_.empty();
}
/**
* @brief 获取队列中的事件数量
*
* 线程安全地获取队列中当前存储的事件数量
*
* @return 队列中的事件数量
*/
size_t EventQueue::size() const {
std::lock_guard<std::mutex> lock(mutex_);
return queue_.size();
return buffer_.size();
}
} // namespace extra2d

216
Extra2D/src/platform/glfw/glfw_window.cpp
View File

@ -1,4 +1,4 @@
#include <glfw/glfw_window.h>
#include <extra2d/platform/glfw/glfw_window.h>
#include <extra2d/event/event.h>
#include <extra2d/platform/keys.h>
@ -33,10 +33,10 @@ bool GLFWWindow::create(const std::string &title, int width, int height,
monitor = glfwGetPrimaryMonitor();
#endif
glfwWindow_ =
handle_ =
glfwCreateWindow(width, height, title.c_str(), monitor, nullptr);
if (!glfwWindow_) {
if (!handle_) {
E2D_ERROR("创建 GLFW 窗口失败");
deinitGLFW();
return false;
@ -52,87 +52,87 @@ bool GLFWWindow::create(const std::string &title, int width, int height,
int screenHeight = mode->height;
int windowX = (screenWidth - width) / 2;
int windowY = (screenHeight - height) / 2;
glfwSetWindowPos(glfwWindow_, windowX, windowY);
glfwSetWindowPos(handle_, windowX, windowY);
}
}
}
#endif
glfwMakeContextCurrent(glfwWindow_);
glfwMakeContextCurrent(handle_);
glfwSwapInterval(vsync ? 1 : 0);
vsync_ = vsync;
glfwGetWindowSize(glfwWindow_, &width_, &height_);
glfwGetWindowSize(handle_, &w_, &h_);
updateContentScale();
glfwSetWindowUserPointer(glfwWindow_, this);
glfwSetFramebufferSizeCallback(glfwWindow_, framebufferSizeCallback);
glfwSetWindowCloseCallback(glfwWindow_, windowCloseCallback);
glfwSetWindowFocusCallback(glfwWindow_, windowFocusCallback);
glfwSetWindowIconifyCallback(glfwWindow_, windowIconifyCallback);
glfwSetCursorPosCallback(glfwWindow_, cursorPosCallback);
glfwSetMouseButtonCallback(glfwWindow_, mouseButtonCallback);
glfwSetScrollCallback(glfwWindow_, scrollCallback);
glfwSetKeyCallback(glfwWindow_, keyCallback);
glfwSetWindowUserPointer(handle_, this);
glfwSetFramebufferSizeCallback(handle_, framebufferSizeCallback);
glfwSetWindowCloseCallback(handle_, windowCloseCallback);
glfwSetWindowFocusCallback(handle_, windowFocusCallback);
glfwSetWindowIconifyCallback(handle_, windowIconifyCallback);
glfwSetCursorPosCallback(handle_, cursorPosCallback);
glfwSetMouseButtonCallback(handle_, mouseButtonCallback);
glfwSetScrollCallback(handle_, scrollCallback);
glfwSetKeyCallback(handle_, keyCallback);
glfwSetJoystickCallback(joystickCallback);
E2D_INFO("GLFW 窗口创建成功: {}x{}", width_, height_);
E2D_INFO("GLFW 窗口创建成功: {}x{}", w_, h_);
return true;
}
void GLFWWindow::destroy() {
if (glfwWindow_) {
glfwDestroyWindow(glfwWindow_);
glfwWindow_ = nullptr;
if (handle_) {
glfwDestroyWindow(handle_);
handle_ = nullptr;
}
deinitGLFW();
}
void GLFWWindow::poll() {
if (!glfwWindow_)
if (!handle_)
return;
glfwPollEvents();
}
void GLFWWindow::swap() {
if (glfwWindow_) {
glfwSwapBuffers(glfwWindow_);
if (handle_) {
glfwSwapBuffers(handle_);
}
}
bool GLFWWindow::shouldClose() const {
if (!glfwWindow_)
if (!handle_)
return true;
return shouldClose_ || glfwWindowShouldClose(glfwWindow_);
return shouldClose_ || glfwWindowShouldClose(handle_);
}
void GLFWWindow::close() {
shouldClose_ = true;
if (glfwWindow_) {
glfwSetWindowShouldClose(glfwWindow_, GLFW_TRUE);
if (handle_) {
glfwSetWindowShouldClose(handle_, GLFW_TRUE);
}
}
void GLFWWindow::setTitle(const std::string &title) {
if (glfwWindow_) {
glfwSetWindowTitle(glfwWindow_, title.c_str());
void GLFWWindow::title(const std::string &t) {
if (handle_) {
glfwSetWindowTitle(handle_, t.c_str());
}
}
void GLFWWindow::setSize(int w, int h) {
if (glfwWindow_) {
glfwSetWindowSize(glfwWindow_, w, h);
width_ = w;
height_ = h;
void GLFWWindow::size(int w, int h) {
if (handle_) {
glfwSetWindowSize(handle_, w, h);
w_ = w;
h_ = h;
}
}
void GLFWWindow::setPos(int x, int y) {
void GLFWWindow::pos(int x, int y) {
#ifndef __SWITCH__
if (glfwWindow_) {
glfwSetWindowPos(glfwWindow_, x, y);
if (handle_) {
glfwSetWindowPos(handle_, x, y);
}
#else
(void)x;
@ -140,9 +140,9 @@ void GLFWWindow::setPos(int x, int y) {
#endif
}
void GLFWWindow::setFullscreen(bool fs) {
void GLFWWindow::fullscreen(bool fs) {
#ifndef __SWITCH__
if (!glfwWindow_)
if (!handle_)
return;
if (fs == fullscreen_)
@ -151,68 +151,68 @@ void GLFWWindow::setFullscreen(bool fs) {
if (fs) {
GLFWmonitor *monitor = glfwGetPrimaryMonitor();
const GLFWvidmode *mode = glfwGetVideoMode(monitor);
glfwSetWindowMonitor(glfwWindow_, monitor, 0, 0, mode->width, mode->height,
glfwSetWindowMonitor(handle_, monitor, 0, 0, mode->width, mode->height,
mode->refreshRate);
} else {
glfwSetWindowMonitor(glfwWindow_, nullptr, 100, 100, 1280, 720, 0);
glfwSetWindowMonitor(handle_, nullptr, 100, 100, 1280, 720, 0);
}
fullscreen_ = fs;
glfwGetWindowSize(glfwWindow_, &width_, &height_);
glfwGetWindowSize(handle_, &w_, &h_);
updateContentScale();
#else
(void)fs;
#endif
}
void GLFWWindow::setVSync(bool vsync) {
if (glfwWindow_) {
glfwSwapInterval(vsync ? 1 : 0);
vsync_ = vsync;
void GLFWWindow::vsync(bool v) {
if (handle_) {
glfwSwapInterval(v ? 1 : 0);
vsync_ = v;
}
}
void GLFWWindow::setVisible(bool visible) {
void GLFWWindow::visible(bool v) {
#ifndef __SWITCH__
if (glfwWindow_) {
if (visible) {
glfwShowWindow(glfwWindow_);
if (handle_) {
if (v) {
glfwShowWindow(handle_);
} else {
glfwHideWindow(glfwWindow_);
glfwHideWindow(handle_);
}
}
#else
(void)visible;
(void)v;
#endif
}
Size GLFWWindow::size() const {
return Size(static_cast<float>(width_), static_cast<float>(height_));
return Size(static_cast<f32>(w_), static_cast<f32>(h_));
}
Vec2 GLFWWindow::pos() const {
int x = 0, y = 0;
#ifndef __SWITCH__
if (glfwWindow_) {
glfwGetWindowPos(glfwWindow_, &x, &y);
if (handle_) {
glfwGetWindowPos(handle_, &x, &y);
}
#endif
return Vec2(static_cast<float>(x), static_cast<float>(y));
return Vec2(static_cast<f32>(x), static_cast<f32>(y));
}
void GLFWWindow::setCursor(Cursor cursor) {
void GLFWWindow::cursor(Cursor c) {
#ifndef __SWITCH__
if (!glfwWindow_)
if (!handle_)
return;
if (cursor == Cursor::Hidden) {
glfwSetInputMode(glfwWindow_, GLFW_CURSOR, GLFW_CURSOR_HIDDEN);
if (c == Cursor::Hidden) {
glfwSetInputMode(handle_, GLFW_CURSOR, GLFW_CURSOR_HIDDEN);
return;
}
glfwSetInputMode(glfwWindow_, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
glfwSetInputMode(handle_, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
GLFWcursor *glfwCursor = nullptr;
switch (cursor) {
switch (c) {
case Cursor::Arrow:
glfwCursor = glfwCreateStandardCursor(GLFW_ARROW_CURSOR);
break;
@ -237,17 +237,17 @@ void GLFWWindow::setCursor(Cursor cursor) {
}
if (glfwCursor) {
glfwSetCursor(glfwWindow_, glfwCursor);
glfwSetCursor(handle_, glfwCursor);
}
#else
(void)cursor;
(void)c;
#endif
}
void GLFWWindow::showCursor(bool show) {
#ifndef __SWITCH__
if (glfwWindow_) {
glfwSetInputMode(glfwWindow_, GLFW_CURSOR,
if (handle_) {
glfwSetInputMode(handle_, GLFW_CURSOR,
show ? GLFW_CURSOR_NORMAL : GLFW_CURSOR_HIDDEN);
cursorVisible_ = show;
}
@ -258,8 +258,8 @@ void GLFWWindow::showCursor(bool show) {
void GLFWWindow::lockCursor(bool lock) {
#ifndef __SWITCH__
if (glfwWindow_) {
glfwSetInputMode(glfwWindow_, GLFW_CURSOR,
if (handle_) {
glfwSetInputMode(handle_, GLFW_CURSOR,
lock ? GLFW_CURSOR_DISABLED : GLFW_CURSOR_NORMAL);
cursorLocked_ = lock;
}
@ -268,7 +268,7 @@ void GLFWWindow::lockCursor(bool lock) {
#endif
}
void *GLFWWindow::native() const { return glfwWindow_; }
void *GLFWWindow::native() const { return handle_; }
bool GLFWWindow::initGLFW() {
static int glfwInitCount = 0;
@ -291,11 +291,11 @@ void GLFWWindow::deinitGLFW() {
}
void GLFWWindow::updateContentScale() {
if (glfwWindow_) {
if (handle_) {
int fbWidth, fbHeight;
glfwGetFramebufferSize(glfwWindow_, &fbWidth, &fbHeight);
scaleX_ = fbWidth > 0 ? static_cast<float>(fbWidth) / width_ : 1.0f;
scaleY_ = fbHeight > 0 ? static_cast<float>(fbHeight) / height_ : 1.0f;
glfwGetFramebufferSize(handle_, &fbWidth, &fbHeight);
scaleX_ = fbWidth > 0 ? static_cast<f32>(fbWidth) / w_ : 1.0f;
scaleY_ = fbHeight > 0 ? static_cast<f32>(fbHeight) / h_ : 1.0f;
}
}
@ -305,19 +305,19 @@ void GLFWWindow::framebufferSizeCallback(GLFWwindow *window, int width,
GLFWWindow *self =
static_cast<GLFWWindow *>(glfwGetWindowUserPointer(window));
if (self) {
self->width_ = width;
self->height_ = height;
self->w_ = width;
self->h_ = height;
self->updateContentScale();
if (self->resizeCb_) {
self->resizeCb_(width, height);
if (self->resizeFn_) {
self->resizeFn_(width, height);
}
}
// 将事件推送到事件服务
auto eventService = ServiceLocator::instance().getService<IEventService>();
auto eventService = ServiceLocator::instance().get<IEventService>();
if (eventService) {
Event e = Event::createWindowResize(width, height);
eventService->pushEvent(e);
Event e = Event::windowResize(width, height);
eventService->push(e);
}
}
@ -326,16 +326,16 @@ void GLFWWindow::windowCloseCallback(GLFWwindow *window) {
static_cast<GLFWWindow *>(glfwGetWindowUserPointer(window));
if (self) {
self->shouldClose_ = true;
if (self->closeCb_) {
self->closeCb_();
if (self->closeFn_) {
self->closeFn_();
}
}
// 将事件推送到事件服务
auto eventService = ServiceLocator::instance().getService<IEventService>();
auto eventService = ServiceLocator::instance().get<IEventService>();
if (eventService) {
Event e = Event::createWindowClose();
eventService->pushEvent(e);
Event e = Event::windowClose();
eventService->push(e);
}
}
@ -344,8 +344,8 @@ void GLFWWindow::windowFocusCallback(GLFWwindow *window, int focused) {
static_cast<GLFWWindow *>(glfwGetWindowUserPointer(window));
if (self) {
self->focused_ = (focused == GLFW_TRUE);
if (self->focusCb_) {
self->focusCb_(self->focused_);
if (self->focusFn_) {
self->focusFn_(self->focused_);
}
}
}
@ -364,12 +364,12 @@ void GLFWWindow::cursorPosCallback(GLFWwindow *window, double xpos,
static_cast<GLFWWindow *>(glfwGetWindowUserPointer(window));
// 将事件推送到事件服务
auto eventService = ServiceLocator::instance().getService<IEventService>();
auto eventService = ServiceLocator::instance().get<IEventService>();
if (eventService) {
Vec2 pos{static_cast<float>(xpos), static_cast<float>(ypos)};
Vec2 pos{static_cast<f32>(xpos), static_cast<f32>(ypos)};
Vec2 delta{0.0f, 0.0f}; // GLFW 回调中没有增量，需要在其他地方计算
Event e = Event::createMouseMove(pos, delta);
eventService->pushEvent(e);
Event e = Event::mouseMove(pos, delta);
eventService->push(e);
}
}
@ -379,18 +379,18 @@ void GLFWWindow::mouseButtonCallback(GLFWwindow *window, int button, int action,
static_cast<GLFWWindow *>(glfwGetWindowUserPointer(window));
// 将事件推送到事件服务
auto eventService = ServiceLocator::instance().getService<IEventService>();
auto eventService = ServiceLocator::instance().get<IEventService>();
if (eventService) {
double x, y;
glfwGetCursorPos(window, &x, &y);
Vec2 pos{static_cast<float>(x), static_cast<float>(y)};
Vec2 pos{static_cast<f32>(x), static_cast<f32>(y)};
if (action == GLFW_PRESS) {
Event e = Event::createMouseButtonPress(button, mods, pos);
eventService->pushEvent(e);
Event e = Event::mousePress(button, mods, pos);
eventService->push(e);
} else if (action == GLFW_RELEASE) {
Event e = Event::createMouseButtonRelease(button, mods, pos);
eventService->pushEvent(e);
Event e = Event::mouseRelease(button, mods, pos);
eventService->push(e);
}
}
}
@ -401,14 +401,14 @@ void GLFWWindow::scrollCallback(GLFWwindow *window, double xoffset,
static_cast<GLFWWindow *>(glfwGetWindowUserPointer(window));
// 将事件推送到事件服务
auto eventService = ServiceLocator::instance().getService<IEventService>();
auto eventService = ServiceLocator::instance().get<IEventService>();
if (eventService) {
double x, y;
glfwGetCursorPos(window, &x, &y);
Vec2 offset{static_cast<float>(xoffset), static_cast<float>(yoffset)};
Vec2 pos{static_cast<float>(x), static_cast<float>(y)};
Event e = Event::createMouseScroll(offset, pos);
eventService->pushEvent(e);
Vec2 offset{static_cast<f32>(xoffset), static_cast<f32>(yoffset)};
Vec2 pos{static_cast<f32>(x), static_cast<f32>(y)};
Event e = Event::mouseScroll(offset, pos);
eventService->push(e);
}
}
@ -418,7 +418,7 @@ void GLFWWindow::keyCallback(GLFWwindow *window, int key, int scancode,
static_cast<GLFWWindow *>(glfwGetWindowUserPointer(window));
// 将事件推送到事件服务
auto eventService = ServiceLocator::instance().getService<IEventService>();
auto eventService = ServiceLocator::instance().get<IEventService>();
if (eventService) {
// 将 GLFW key code 转换为引擎 Key 枚举值
Key eKey = Key::None;
@ -645,13 +645,13 @@ void GLFWWindow::keyCallback(GLFWwindow *window, int key, int scancode,
}
if (eKey != Key::None) {
int keyCode = static_cast<int>(eKey);
i32 keyCode = static_cast<i32>(eKey);
if (action == GLFW_PRESS) {
Event e = Event::createKeyPress(keyCode, scancode, mods);
eventService->pushEvent(e);
Event e = Event::keyPress(keyCode, scancode, mods);
eventService->push(e);
} else if (action == GLFW_RELEASE) {
Event e = Event::createKeyRelease(keyCode, scancode, mods);
eventService->pushEvent(e);
Event e = Event::keyRelease(keyCode, scancode, mods);
eventService->push(e);
}
}
}

4
Extra2D/src/platform/window_module.cpp
View File

@ -2,7 +2,7 @@
#include <extra2d/platform/window_module.h>
#include <extra2d/services/logger_service.h>
#include <glfw/glfw_window.h>
#include <extra2d/platform/glfw/glfw_window.h>
#ifdef __SWITCH__
#include <switch.h>
@ -26,7 +26,7 @@ bool WindowModule::init() {
E2D_INFO("正在创建 GLFW 窗口，尺寸 {}x{}", cfg_.w, cfg_.h);
win_ = makeUnique<GLFWWindow>();
win_ = ptr::makeUnique<GLFWWindow>();
if (!win_) {
E2D_ERROR("创建窗口失败");
return false;

45
Extra2D/src/services/event_service.cpp
View File

@ -8,58 +8,57 @@ EventService::EventService() {
info_.enabled = true;
}
ServiceInfo EventService::getServiceInfo() const { return info_; }
ServiceInfo EventService::info() const { return info_; }
bool EventService::initialize() {
bool EventService::init() {
setState(ServiceState::Running);
return true;
}
void EventService::shutdown() {
queue_.clear();
dispatcher_.removeAllListeners();
dispatcher_.offAll();
setState(ServiceState::Stopped);
}
void EventService::update(float deltaTime) {
if (getState() == ServiceState::Running) {
processQueue();
void EventService::update(f32 dt) {
if (state() == ServiceState::Running) {
process();
}
}
void EventService::pushEvent(const Event &event) { queue_.push(event); }
void EventService::push(const Event &event) { queue_.push(event); }
void EventService::pushEvent(Event &&event) { queue_.push(std::move(event)); }
void EventService::push(Event &&event) { queue_.push(std::move(event)); }
bool EventService::pollEvent(Event &event) { return queue_.poll(event); }
bool EventService::poll(Event &event) { return queue_.poll(event); }
ListenerId EventService::addListener(EventType type,
EventDispatcher::EventCallback callback) {
return dispatcher_.addListener(type, callback);
ListenerID EventService::on(EventType type, EventDispatcher::EventFn fn) {
return dispatcher_.on(type, fn);
}
void EventService::removeListener(ListenerId id) {
dispatcher_.removeListener(id);
void EventService::off(ListenerID id) {
dispatcher_.off(id);
}
void EventService::removeAllListeners(EventType type) {
dispatcher_.removeAllListeners(type);
void EventService::offAll(EventType type) {
dispatcher_.offAll(type);
}
void EventService::removeAllListeners() { dispatcher_.removeAllListeners(); }
void EventService::offAll() { dispatcher_.offAll(); }
void EventService::dispatch(Event &event) { dispatcher_.dispatch(event); }
void EventService::processQueue() { dispatcher_.processQueue(queue_); }
void EventService::process() { dispatcher_.process(queue_); }
size_t EventService::getListenerCount(EventType type) const {
return dispatcher_.getListenerCount(type);
size_t EventService::listenerCount(EventType type) const {
return dispatcher_.listenerCount(type);
}
size_t EventService::getTotalListenerCount() const {
return dispatcher_.getTotalListenerCount();
size_t EventService::totalListeners() const {
return dispatcher_.totalListeners();
}
size_t EventService::getQueueSize() const { return queue_.size(); }
size_t EventService::queueSize() const { return queue_.size(); }
} // namespace extra2d

71
Extra2D/src/services/logger_service.cpp
View File

@ -11,9 +11,6 @@
namespace extra2d {
#ifdef _WIN32
/**
* @brief 初始化 Windows 控制台（ANSI 颜色 + UTF-8）
*/
static bool enableWindowsConsoleFeatures() {
bool success = true;
@ -45,7 +42,7 @@ public:
};
ConsoleLogger::ConsoleLogger()
: level_(LogLevel::Info), colorEnabled_(true),
: level_(LogLevel::Info), colors_(true),
impl_(std::make_unique<Impl>()) {
info_.name = "ConsoleLogger";
info_.priority = ServicePriority::Core;
@ -67,23 +64,23 @@ ConsoleLogger::ConsoleLogger()
ConsoleLogger::~ConsoleLogger() = default;
bool ConsoleLogger::initialize() {
bool ConsoleLogger::init() {
setState(ServiceState::Running);
return true;
}
void ConsoleLogger::shutdown() { setState(ServiceState::Stopped); }
void ConsoleLogger::setLevel(LogLevel level) { level_ = level; }
void ConsoleLogger::level(LogLevel lvl) { level_ = lvl; }
LogLevel ConsoleLogger::getLevel() const { return level_; }
LogLevel ConsoleLogger::level() const { return level_; }
bool ConsoleLogger::isEnabled(LogLevel level) const {
return static_cast<int>(level) >= static_cast<int>(level_);
bool ConsoleLogger::enabled(LogLevel lvl) const {
return static_cast<int>(lvl) >= static_cast<int>(level_);
}
void ConsoleLogger::log(LogLevel level, const char *fmt, ...) {
if (!isEnabled(level))
void ConsoleLogger::log(LogLevel lvl, const char *fmt, ...) {
if (!enabled(lvl))
return;
char buffer[1024];
@ -92,17 +89,17 @@ void ConsoleLogger::log(LogLevel level, const char *fmt, ...) {
vsnprintf(buffer, sizeof(buffer), fmt, args);
va_end(args);
output(level, buffer);
output(lvl, buffer);
}
void ConsoleLogger::log(LogLevel level, const std::string &msg) {
if (!isEnabled(level))
void ConsoleLogger::log(LogLevel lvl, const std::string &msg) {
if (!enabled(lvl))
return;
output(level, msg.c_str());
output(lvl, msg.c_str());
}
void ConsoleLogger::trace(const char *fmt, ...) {
if (!isEnabled(LogLevel::Trace))
if (!enabled(LogLevel::Trace))
return;
char buffer[1024];
va_list args;
@ -113,7 +110,7 @@ void ConsoleLogger::trace(const char *fmt, ...) {
}
void ConsoleLogger::debug(const char *fmt, ...) {
if (!isEnabled(LogLevel::Debug))
if (!enabled(LogLevel::Debug))
return;
char buffer[1024];
va_list args;
@ -124,7 +121,7 @@ void ConsoleLogger::debug(const char *fmt, ...) {
}
void ConsoleLogger::info(const char *fmt, ...) {
if (!isEnabled(LogLevel::Info))
if (!enabled(LogLevel::Info))
return;
char buffer[1024];
va_list args;
@ -135,7 +132,7 @@ void ConsoleLogger::info(const char *fmt, ...) {
}
void ConsoleLogger::registry(const char *fmt, ...) {
if (!isEnabled(LogLevel::Registry))
if (!enabled(LogLevel::Registry))
return;
char buffer[1024];
va_list args;
@ -146,7 +143,7 @@ void ConsoleLogger::registry(const char *fmt, ...) {
}
void ConsoleLogger::warn(const char *fmt, ...) {
if (!isEnabled(LogLevel::Warn))
if (!enabled(LogLevel::Warn))
return;
char buffer[1024];
va_list args;
@ -157,7 +154,7 @@ void ConsoleLogger::warn(const char *fmt, ...) {
}
void ConsoleLogger::error(const char *fmt, ...) {
if (!isEnabled(LogLevel::Error))
if (!enabled(LogLevel::Error))
return;
char buffer[1024];
va_list args;
@ -168,7 +165,7 @@ void ConsoleLogger::error(const char *fmt, ...) {
}
void ConsoleLogger::fatal(const char *fmt, ...) {
if (!isEnabled(LogLevel::Fatal))
if (!enabled(LogLevel::Fatal))
return;
char buffer[1024];
va_list args;
@ -178,33 +175,33 @@ void ConsoleLogger::fatal(const char *fmt, ...) {
output(LogLevel::Fatal, buffer);
}
void ConsoleLogger::setLevelColor(LogLevel level, const LogColor &color) {
int idx = static_cast<int>(level);
void ConsoleLogger::levelColor(LogLevel lvl, const LogColor &c) {
int idx = static_cast<int>(lvl);
if (idx >= 0 && idx < 7) {
levelColors_[idx] = color;
levelColors_[idx] = c;
}
}
LogColor ConsoleLogger::getLevelColor(LogLevel level) const {
int idx = static_cast<int>(level);
LogColor ConsoleLogger::levelColor(LogLevel lvl) const {
int idx = static_cast<int>(lvl);
if (idx >= 0 && idx < 7) {
return levelColors_[idx];
}
return LogColor::White();
}
void ConsoleLogger::setColorEnabled(bool enabled) { colorEnabled_ = enabled; }
void ConsoleLogger::colors(bool on) { colors_ = on; }
bool ConsoleLogger::isColorEnabled() const { return colorEnabled_; }
bool ConsoleLogger::colors() const { return colors_; }
std::string ConsoleLogger::getAnsiColor(LogLevel level) {
const LogColor &c = getLevelColor(level);
std::string ConsoleLogger::ansiColor(LogLevel lvl) {
const LogColor &c = levelColor(lvl);
char buf[32];
snprintf(buf, sizeof(buf), "\033[38;2;%d;%d;%dm", c.r, c.g, c.b);
return std::string(buf);
}
void ConsoleLogger::output(LogLevel level, const char *msg) {
void ConsoleLogger::output(LogLevel lvl, const char *msg) {
std::lock_guard<std::mutex> lock(impl_->mutex_);
auto now = std::chrono::system_clock::now();
@ -220,11 +217,11 @@ void ConsoleLogger::output(LogLevel level, const char *msg) {
localtime_r(&time, &tm);
#endif
const char *levelStr = getLevelString(level);
const char *levelStr = levelString(lvl);
const char *reset = "\033[0m";
if (colorEnabled_) {
std::string color = getAnsiColor(level);
if (colors_) {
std::string color = ansiColor(lvl);
printf("%s[%02d:%02d:%02d.%03d] [%s] %s%s\n", color.c_str(), tm.tm_hour,
tm.tm_min, tm.tm_sec, (int)ms.count(), levelStr, msg, reset);
} else {
@ -233,8 +230,8 @@ void ConsoleLogger::output(LogLevel level, const char *msg) {
}
}
const char *ConsoleLogger::getLevelString(LogLevel level) {
switch (level) {
const char *ConsoleLogger::levelString(LogLevel lvl) {
switch (lvl) {
case LogLevel::Trace:
return "TRACE";
case LogLevel::Debug:

35
Extra2D/src/services/timer_service.cpp
View File

@ -8,45 +8,44 @@ TimerService::TimerService() {
info_.enabled = true;
}
ServiceInfo TimerService::getServiceInfo() const { return info_; }
ServiceInfo TimerService::info() const { return info_; }
bool TimerService::initialize() {
bool TimerService::init() {
setState(ServiceState::Running);
return true;
}
void TimerService::shutdown() {
manager_.clear();
mgr_.clear();
setState(ServiceState::Stopped);
}
void TimerService::update(float deltaTime) {
if (getState() == ServiceState::Running) {
manager_.update(deltaTime);
void TimerService::update(f32 dt) {
if (state() == ServiceState::Running) {
mgr_.update(dt);
}
}
uint32 TimerService::addTimer(float delay, Timer::Callback callback) {
return manager_.addTimer(delay, callback);
u32 TimerService::add(f32 delay, Timer::Fn fn) {
return mgr_.add(delay, fn);
}
uint32 TimerService::addRepeatingTimer(float interval,
Timer::Callback callback) {
return manager_.addRepeatingTimer(interval, callback);
u32 TimerService::addRepeat(f32 interval, Timer::Fn fn) {
return mgr_.addRepeat(interval, fn);
}
void TimerService::cancelTimer(uint32 timerId) {
manager_.cancelTimer(timerId);
void TimerService::cancel(u32 timerId) {
mgr_.cancel(timerId);
}
void TimerService::pauseTimer(uint32 timerId) { manager_.pauseTimer(timerId); }
void TimerService::pauseTimer(u32 timerId) { mgr_.pause(timerId); }
void TimerService::resumeTimer(uint32 timerId) {
manager_.resumeTimer(timerId);
void TimerService::resumeTimer(u32 timerId) {
mgr_.resume(timerId);
}
void TimerService::clear() { manager_.clear(); }
void TimerService::clear() { mgr_.clear(); }
size_t TimerService::getTimerCount() const { return manager_.getTimerCount(); }
size_t TimerService::count() const { return mgr_.count(); }
} // namespace extra2d

32
Extra2D/src/utils/random.cpp
View File

@ -24,9 +24,9 @@ Random &Random::get() {
/**
* @brief 设置随机数种子
* @param seed 随机数种子值
* @param s 随机数种子值
*/
void Random::setSeed(uint32 seed) { generator_.seed(seed); }
void Random::seed(u32 s) { generator_.seed(s); }
/**
* @brief 使用当前时间随机化种子
@ -36,14 +36,14 @@ void Random::setSeed(uint32 seed) { generator_.seed(seed); }
void Random::randomize() {
auto now = std::chrono::high_resolution_clock::now();
auto time = now.time_since_epoch().count();
generator_.seed(static_cast<uint32>(time));
generator_.seed(static_cast<u32>(time));
}
/**
* @brief 获取[0.0, 1.0]范围内的随机浮点数
* @return 随机浮点数，范围[0.0, 1.0]
* @brief 获取[0, 1)范围内的随机浮点数
* @return 随机浮点数，范围[0, 1)
*/
float Random::getFloat() { return floatDist_(generator_); }
f32 Random::randomF32() { return floatDist_(generator_); }
/**
* @brief 获取指定范围内的随机浮点数
@ -51,7 +51,7 @@ float Random::getFloat() { return floatDist_(generator_); }
* @param max 最大值
* @return 随机浮点数，范围[min, max]
*/
float Random::getFloat(float min, float max) {
f32 Random::randomF32(f32 min, f32 max) {
if (min >= max) {
return min;
}
@ -63,11 +63,11 @@ float Random::getFloat(float min, float max) {
* @param max 最大值（包含）
* @return 随机整数，范围[0, max]
*/
int Random::getInt(int max) {
i32 Random::randomI32(i32 max) {
if (max <= 0) {
return 0;
}
std::uniform_int_distribution<int> dist(0, max);
std::uniform_int_distribution<i32> dist(0, max);
return dist(generator_);
}
@ -77,11 +77,11 @@ int Random::getInt(int max) {
* @param max 最大值（包含）
* @return 随机整数，范围[min, max]
*/
int Random::getInt(int min, int max) {
i32 Random::randomI32(i32 min, i32 max) {
if (min >= max) {
return min;
}
std::uniform_int_distribution<int> dist(min, max);
std::uniform_int_distribution<i32> dist(min, max);
return dist(generator_);
}
@ -89,14 +89,14 @@ int Random::getInt(int min, int max) {
* @brief 获取随机布尔值（50%概率）
* @return 随机布尔值
*/
bool Random::getBool() { return floatDist_(generator_) >= 0.5f; }
bool Random::boolean() { return floatDist_(generator_) >= 0.5f; }
/**
* @brief 以指定概率获取随机布尔值
* @param probability 返回true的概率，范围[0.0, 1.0]
* @return 随机布尔值
*/
bool Random::getBool(float probability) {
bool Random::boolean(f32 probability) {
if (probability <= 0.0f) {
return false;
}
@ -110,8 +110,8 @@ bool Random::getBool(float probability) {
* @brief 获取随机角度值
* @return 随机角度，范围[0, 2π]
*/
float Random::getAngle() {
static const float TWO_PI = 6.28318530718f;
f32 Random::angle() {
static const f32 TWO_PI = 6.28318530718f;
return floatDist_(generator_) * TWO_PI;
}
@ -119,6 +119,6 @@ float Random::getAngle() {
* @brief 获取有符号随机数
* @return 随机浮点数，范围[-1.0, 1.0]
*/
float Random::getSigned() { return floatDist_(generator_) * 2.0f - 1.0f; }
f32 Random::signedF32() { return floatDist_(generator_) * 2.0f - 1.0f; }
} // namespace extra2d

111
Extra2D/src/utils/timer.cpp
View File

@ -3,35 +3,24 @@
namespace extra2d {
uint32 Timer::nextId_ = 1;
u32 Timer::nextId_ = 1;
/**
* @brief 构造函数，创建定时器
* @param interval 定时间隔（秒）
* @param repeat 是否重复触发
* @param callback 定时器回调函数
*/
Timer::Timer(float interval, bool repeat, Callback callback)
Timer::Timer(f32 interval, bool repeat, Fn fn)
: interval_(interval), elapsed_(0.0f), repeat_(repeat), paused_(false),
valid_(true), callback_(std::move(callback)) {
valid_(true), fn_(std::move(fn)) {
id_ = nextId_++;
}
/**
* @brief 更新定时器状态
* @param deltaTime 帧间隔时间（秒）
* @return 如果定时器触发则返回true，否则返回false
*/
bool Timer::update(float deltaTime) {
bool Timer::update(f32 dt) {
if (!valid_ || paused_) {
return false;
}
elapsed_ += deltaTime;
elapsed_ += dt;
if (elapsed_ >= interval_) {
if (callback_) {
callback_();
if (fn_) {
fn_();
}
if (repeat_) {
@ -46,81 +35,40 @@ bool Timer::update(float deltaTime) {
return false;
}
/**
* @brief 重置定时器
*
* 重置已过时间，恢复定时器为有效且非暂停状态
*/
void Timer::reset() {
elapsed_ = 0.0f;
valid_ = true;
paused_ = false;
}
/**
* @brief 暂停定时器
*/
void Timer::pause() { paused_ = true; }
/**
* @brief 恢复定时器
*/
void Timer::resume() { paused_ = false; }
/**
* @brief 取消定时器
*
* 将定时器标记为无效状态
*/
void Timer::cancel() { valid_ = false; }
/**
* @brief 获取剩余时间
* @return 剩余时间（秒），如果定时器无效或已暂停则返回0
*/
float Timer::getRemaining() const {
f32 Timer::remaining() const {
if (!valid_ || paused_) {
return 0.0f;
}
return std::max(0.0f, interval_ - elapsed_);
}
// ============================================================================
// TimerManager 实现
// ============================================================================
/**
* @brief 添加单次定时器
* @param delay 延迟时间（秒）
* @param callback 定时器回调函数
* @return 定时器ID
*/
uint32 TimerManager::addTimer(float delay, Timer::Callback callback) {
auto timer = std::make_unique<Timer>(delay, false, std::move(callback));
uint32 id = timer->getId();
u32 TimerManager::add(f32 delay, Timer::Fn fn) {
auto timer = std::make_unique<Timer>(delay, false, std::move(fn));
u32 id = timer->id();
timers_.emplace(id, std::move(timer));
return id;
}
/**
* @brief 添加重复定时器
* @param interval 触发间隔（秒）
* @param callback 定时器回调函数
* @return 定时器ID
*/
uint32 TimerManager::addRepeatingTimer(float interval,
Timer::Callback callback) {
auto timer = std::make_unique<Timer>(interval, true, std::move(callback));
uint32 id = timer->getId();
u32 TimerManager::addRepeat(f32 interval, Timer::Fn fn) {
auto timer = std::make_unique<Timer>(interval, true, std::move(fn));
u32 id = timer->id();
timers_.emplace(id, std::move(timer));
return id;
}
/**
* @brief 取消指定定时器
* @param timerId 定时器ID
*/
void TimerManager::cancelTimer(uint32 timerId) {
void TimerManager::cancel(u32 timerId) {
auto it = timers_.find(timerId);
if (it != timers_.end()) {
it->second->cancel();
@ -128,52 +76,35 @@ void TimerManager::cancelTimer(uint32 timerId) {
}
}
/**
* @brief 暂停指定定时器
* @param timerId 定时器ID
*/
void TimerManager::pauseTimer(uint32 timerId) {
void TimerManager::pause(u32 timerId) {
auto it = timers_.find(timerId);
if (it != timers_.end()) {
it->second->pause();
}
}
/**
* @brief 恢复指定定时器
* @param timerId 定时器ID
*/
void TimerManager::resumeTimer(uint32 timerId) {
void TimerManager::resume(u32 timerId) {
auto it = timers_.find(timerId);
if (it != timers_.end()) {
it->second->resume();
}
}
/**
* @brief 更新所有定时器
* @param deltaTime 帧间隔时间（秒）
*
* 更新所有定时器状态，并移除已失效的定时器
*/
void TimerManager::update(float deltaTime) {
void TimerManager::update(f32 dt) {
timersToRemove_.clear();
for (auto &[id, timer] : timers_) {
timer->update(deltaTime);
if (!timer->isValid()) {
timer->update(dt);
if (!timer->valid()) {
timersToRemove_.push_back(id);
}
}
for (uint32 id : timersToRemove_) {
for (u32 id : timersToRemove_) {
timers_.erase(id);
}
}
/**
* @brief 清除所有定时器
*/
void TimerManager::clear() {
timers_.clear();
timersToRemove_.clear();