lenheart/DNF_DEV
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

修改游戏底层矩阵相关

Browse Source
This commit is contained in:
Lenheart
2025-10-26 14:38:53 +08:00
parent dc0213dc16
commit 88f039348a
50 changed files with 1983 additions and 362 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
source/Asset/AnimationStruct.cpp
View File

@@ -277,7 +277,7 @@ namespace AniScriptParser
case 7:
{
Key = "IMAGE_RATE";
VecFPos pos{
Vec2 pos{
blob.getFloat(),
blob.getFloat()};
FrameObject.Flag.emplace(Key, pos);

2
source/Asset/AnimationStruct.h
View File

@@ -15,7 +15,7 @@ namespace AniScriptParser
int,
float,
VecPos,
VecFPos,
Vec2,
std::string,
std::vector<int>,
std::vector<float>>;

56
source/EngineFrame/Base/BaseNode.cpp
View File

@@ -1,4 +1,14 @@
#include "BaseNode.h"
#include "EngineCore/Game.h"
BaseNode::BaseNode()
{
Game::GetInstance().m_nodeCount++;
}
BaseNode::~BaseNode()
{
Game::GetInstance().m_nodeCount--;
}
void BaseNode::Init()
{
@@ -67,7 +77,7 @@ void BaseNode::SetCallbackOnUpdate(const UpdateCallback &cb)
void BaseNode::SetChildIterationTransform()
{
TransformT n_transform;
Transform n_transform;
n_transform.position = transform.position + transformIter.position;
n_transform.scale = transform.scale * transformIter.scale;
n_transform.rotation = transform.rotation + transformIter.rotation;
@@ -147,7 +157,7 @@ void BaseNode::AddChild(RefPtr<BaseNode> child)
// 如果组件有transform标签，则设置其位置
if (child->hasTag(Tag::TRANSFORM))
{
TransformT n_transform;
Transform n_transform;
n_transform.position = transform.position + transformIter.position;
n_transform.scale = transform.scale * transformIter.scale;
n_transform.rotation = transform.rotation + transformIter.rotation;
@@ -172,7 +182,7 @@ void BaseNode::OnAdded(BaseNode *node)
m_Parent = node;
}
void BaseNode::SetIterationTransform(TransformT n_transform)
void BaseNode::SetIterationTransform(Transform n_transform)
{
if (n_transform == transformIter)
return;
@@ -181,12 +191,12 @@ void BaseNode::SetIterationTransform(TransformT n_transform)
SetChildIterationTransform();
}
TransformT BaseNode::GetIterationTransform()
Transform BaseNode::GetIterationTransform()
{
return transformIter;
}
void BaseNode::SetTransform(TransformT n_transform)
void BaseNode::SetTransform(Transform n_transform)
{
if (n_transform == transform)
return;
@@ -195,12 +205,12 @@ void BaseNode::SetTransform(TransformT n_transform)
SetChildIterationTransform();
}
TransformT BaseNode::GetTransform()
Transform BaseNode::GetTransform()
{
return transform;
}
void BaseNode::SetPos(VecFPos pos)
void BaseNode::SetPos(Vec2 pos)
{
if (pos == this->transform.position)
return;
@@ -209,17 +219,17 @@ void BaseNode::SetPos(VecFPos pos)
SetChildIterationTransform();
}
VecFPos BaseNode::GetPos()
Vec2 BaseNode::GetPos()
{
return this->transform.position;
}
VecFPos BaseNode::GetWorldPos()
Vec2 BaseNode::GetWorldPos()
{
return this->transform.position + this->transformIter.position;
}
void BaseNode::SetScale(VecFPos scale)
void BaseNode::SetScale(Vec2 scale)
{
if (scale == this->transform.scale)
return;
@@ -228,7 +238,7 @@ void BaseNode::SetScale(VecFPos scale)
SetChildIterationTransform();
}
VecFPos BaseNode::GetScale()
Vec2 BaseNode::GetScale()
{
return this->transform.scale;
}
@@ -247,7 +257,7 @@ float BaseNode::GetRotation()
return this->transform.rotation;
}
void BaseNode::SetAnchor(VecFPos anchor)
void BaseNode::SetAnchor(Vec2 anchor)
{
if (anchor == this->Anchor)
return;
@@ -255,9 +265,9 @@ void BaseNode::SetAnchor(VecFPos anchor)
Anchor.y = anchor.y;
}
VecFPos BaseNode::GetAnchor()
Vec2 BaseNode::GetAnchor()
{
VecFPos P;
Vec2 P;
P.x = Anchor.x;
P.y = Anchor.y;
return P;
@@ -298,7 +308,7 @@ float BaseNode::GetAlpha()
return this->Alpha;
}
void BaseNode::SetIterationPos(VecFPos pos)
void BaseNode::SetIterationPos(Vec2 pos)
{
if (pos == this->transformIter.position)
return;
@@ -307,12 +317,12 @@ void BaseNode::SetIterationPos(VecFPos pos)
SetChildIterationTransform();
}
VecFPos BaseNode::GetIterationPos()
Vec2 BaseNode::GetIterationPos()
{
return this->transformIter.position;
}
void BaseNode::SetIterationScale(VecFPos scale)
void BaseNode::SetIterationScale(Vec2 scale)
{
if (scale == this->transformIter.scale)
return;
@@ -321,7 +331,7 @@ void BaseNode::SetIterationScale(VecFPos scale)
SetChildIterationTransform();
}
VecFPos BaseNode::GetIterationScale()
Vec2 BaseNode::GetIterationScale()
{
return this->transformIter.scale;
}
@@ -339,3 +349,13 @@ float BaseNode::GetIterationRotation()
{
return this->transformIter.rotation;
}
void BaseNode::SetBlendMode(LE_BlEND_MODE mode)
{
this->_BlendMode = mode;
}
LE_BlEND_MODE BaseNode::GetBlendMode()
{
return this->_BlendMode;
}

50
source/EngineFrame/Base/BaseNode.h
View File

@@ -6,7 +6,9 @@
#include "Tool/RefPtr.h"
#include "Tool/IntrusiveList.hpp"
#include "Tool/TagGed.h"
#include "Tool/TransformT.h"
#include "math/Transform.hpp"
#include "math/Math.h"
using namespace ember;
class BaseNode : public RefObject, public TagGed, protected IntrusiveListValue<RefPtr<BaseNode>>
{
@@ -28,23 +30,25 @@ public:
// 渲染层级
int m_RenderZOrder = 0;
// 二维仿射变换
TransformT transform;
Transform transform;
// 迭代的二维仿射变换
TransformT transformIter;
Transform transformIter;
// 锚点
VecFPos Anchor = {0.f, 0.f};
Vec2 Anchor = {0.f, 0.f};
// 大小
VecSize Size = {0, 0};
// 透明度
float Alpha = 1.f;
// 混合模式
LE_BlEND_MODE _BlendMode = NONE;
// 是否显示
bool Visible = true;
// 计算渲染信息Flag (为了保证每帧只计算一次)
bool CalcRenderInfoFlag = true;
public:
BaseNode(/* args */) = default;
~BaseNode() = default;
BaseNode(/* args */);
~BaseNode();
public:
virtual void Init();
@@ -81,45 +85,45 @@ public:
// 被添加时
virtual void OnAdded(BaseNode *node);
// 设置迭代的二维仿射变换
void SetIterationTransform(TransformT transform);
void SetIterationTransform(Transform transform);
// 获取迭代的二维仿射变换
TransformT GetIterationTransform();
Transform GetIterationTransform();
// 设置二维仿射变换
void SetTransform(TransformT transform);
void SetTransform(Transform transform);
// 获取二维仿射变换
TransformT GetTransform();
Transform GetTransform();
// 设置迭代的坐标
virtual void SetIterationPos(VecFPos pos);
virtual void SetIterationPos(Vec2 pos);
// 获取迭代的坐标
VecFPos GetIterationPos();
Vec2 GetIterationPos();
// 设置迭代的缩放
virtual void SetIterationScale(VecFPos scale);
virtual void SetIterationScale(Vec2 scale);
// 获取迭代的缩放
VecFPos GetIterationScale();
Vec2 GetIterationScale();
// 设置迭代的旋转角度
virtual void SetIterationRotation(float angle);
// 获取迭代的旋转角度
float GetIterationRotation();
// 设置坐标
virtual void SetPos(VecFPos pos);
virtual void SetPos(Vec2 pos);
// 获取坐标
VecFPos GetPos();
Vec2 GetPos();
// 获取世界坐标
VecFPos GetWorldPos();
Vec2 GetWorldPos();
// 设置缩放
virtual void SetScale(VecFPos scale);
virtual void SetScale(Vec2 scale);
// 获取缩放
VecFPos GetScale();
Vec2 GetScale();
// 设置旋转角度
virtual void SetRotation(float angle);
// 获取旋转角度
float GetRotation();
// 设置中心点
virtual void SetAnchor(VecFPos anchor);
virtual void SetAnchor(Vec2 anchor);
// 获取中心点
VecFPos GetAnchor();
Vec2 GetAnchor();
// 设置大小
virtual void SetSize(VecSize size);
// 获取大小
@@ -132,6 +136,10 @@ public:
virtual void SetAlpha(float alpha);
// 获取透明度
float GetAlpha();
// 设置混合模式
void SetBlendMode(LE_BlEND_MODE mode);
// 获取混合模式
LE_BlEND_MODE GetBlendMode();
//获取父对象
BaseNode *GetParent();

24
source/EngineFrame/Component/Animation.cpp
View File

@@ -45,8 +45,8 @@ void Animation::Init(std::string AniPath)
FrameObj.Img_Path = AdditionalOptions(FrameObj.Img_Path, this->AdditionalOptionsData);
}
SpriteObj = new Sprite(FrameObj.Img_Path, FrameObj.Img_Index);
SpriteObj->SetAnchor(VecFPos(0.5f, 0.5f));
SpriteObj->SetPos(VecFPos(FrameObj.Img_Pos.x, FrameObj.Img_Pos.y));
SpriteObj->SetAnchor(Vec2(0.5f, 0.5f));
SpriteObj->SetPos(Vec2(FrameObj.Img_Pos.x, FrameObj.Img_Pos.y));
SpriteObj->SetVisible(false);
}
else
@@ -191,8 +191,8 @@ void Animation::FlushFrame(int Index)
// 缩放
if (FlagBuf.count("IMAGE_RATE"))
{
VecFPos Rate = std::get<VecFPos>(FlagBuf["IMAGE_RATE"]);
CurrentFrame->SetScale(VecFPos{Rate.x, Rate.y});
Vec2 Rate = std::get<Vec2>(FlagBuf["IMAGE_RATE"]);
CurrentFrame->SetScale(Vec2{Rate.x, Rate.y});
}
// 线性减淡
if (FlagBuf.count("GRAPHIC_EFFECT_LINEARDODGE"))
@@ -202,7 +202,7 @@ void Animation::FlushFrame(int Index)
// 旋转
if (FlagBuf.count("IMAGE_ROTATE"))
{
CurrentFrame->SetAnchor(VecFPos{0.5f, 0.5f});
CurrentFrame->SetAnchor(Vec2{0.5f, 0.5f});
CurrentFrame->SetRotation(std::get<float>(FlagBuf["IMAGE_ROTATE"]));
}
// 染色
@@ -277,27 +277,27 @@ void Animation::InterpolationLogic()
}
// 坐标
{
VecFPos PosData = {
Vec2 PosData = {
(OldData.Img_Pos.x + (NewData.Img_Pos.x - OldData.Img_Pos.x) * InterRate),
(OldData.Img_Pos.y + (NewData.Img_Pos.y - OldData.Img_Pos.y) * InterRate)};
CurrentFrame->SetPos(PosData);
}
// 缩放
{
VecFPos OldRateData = {1.0f, 1.0f};
VecFPos NewRateData = {1.0f, 1.0f};
Vec2 OldRateData = {1.0f, 1.0f};
Vec2 NewRateData = {1.0f, 1.0f};
if (OldData.Flag.count("IMAGE_RATE"))
{
OldRateData = std::get<VecFPos>(OldData.Flag["IMAGE_RATE"]);
OldRateData = std::get<Vec2>(OldData.Flag["IMAGE_RATE"]);
}
if (NewData.Flag.count("IMAGE_RATE"))
{
NewRateData = std::get<VecFPos>(NewData.Flag["IMAGE_RATE"]);
NewRateData = std::get<Vec2>(NewData.Flag["IMAGE_RATE"]);
}
VecFPos RateData = {
Vec2 RateData = {
OldRateData.x + (NewRateData.x - OldRateData.x) * InterRate,
OldRateData.y + (NewRateData.y - OldRateData.y) * InterRate};
CurrentFrame->SetAnchor(VecFPos{0.5f, 0.5f});
CurrentFrame->SetAnchor(Vec2{0.5f, 0.5f});
CurrentFrame->SetScale(RateData);
}
// 旋转

104
source/EngineFrame/Component/NumberText.cpp Normal file
View File

@@ -0,0 +1,104 @@
#include "NumberText.h"
void NumberText::PreloadDigits()
{
// 需要支持的字符：0-9和负号
const std::string digits = "0123456789-";
for (char c : digits)
{
std::string charStr(1, c);
// 渲染单个字符为纹理
SDL_Surface *surface = TTF_RenderUTF8_Blended(m_font, charStr.c_str(), m_color);
if (!surface)
{
SDL_LogError(0, "数字字符渲染数字字符失败：%s", TTF_GetError());
continue;
}
// 转换为RGBA格式
SDL_Surface *rgbaSurface = SDL_ConvertSurfaceFormat(surface, SDL_PIXELFORMAT_ABGR8888, 0);
SDL_FreeSurface(surface);
// 创建纹理并缓存
Texture *tex = new Texture();
tex->Init(rgbaSurface);
SDL_FreeSurface(rgbaSurface);
m_digitTextures[c] = tex;
}
}
void NumberText::UpdateDigitSprites(const std::string &numStr)
{
// // 先释放旧的精灵
// for (auto *sprite : m_digitSprites)
// {
// if (sprite)
// {
// delete sprite;
// }
// }
// m_digitSprites.clear();
// // 计算总宽度（用于居中或左对齐）
// int totalWidth = 0;
// std::vector<int> charWidths; // 记录每个字符的宽度
// for (char c : numStr)
// {
// auto it = m_digitTextures.find(c);
// if (it == m_digitTextures.end())
// continue; // 跳过不支持的字符
// int w = it->second->getSize().width;
// totalWidth += w;
// charWidths.push_back(w);
// }
// // 绘制每个字符（从左到右排列）
// float currentX = GetWorldPos().x; // 基于当前位置排列
// float currentY = GetWorldPos().y;
// int index = 0;
// for (char c : numStr)
// {
// auto it = m_digitTextures.find(c);
// if (it == m_digitTextures.end())
// continue;
// // 创建字符精灵
// Sprite *sprite = new Sprite();
// sprite->SetTexture(it->second);
// sprite->SetPosition(Vec2(currentX, currentY));
// sprite->SetSize(it->second->getSize());
// m_digitSprites.push_back(sprite);
// // 移动到下一个字符的位置（预留1px间距）
// currentX += charWidths[index] + 1;
// index++;
// }
}
NumberText::NumberText(TTF_Font *font, SDL_Color color) : m_font(font), m_color(color)
{
PreloadDigits();
}
NumberText::~NumberText()
{
}
void NumberText::SetNumber(int number)
{
if (number == m_currentNumber)
return; // 数字未变化则跳过
m_currentNumber = number;
// 转换数字为字符串（处理负数）
std::string numStr = std::to_string(number);
UpdateDigitSprites(numStr); // 更新数字精灵布局
}
void NumberText::Render()
{
// for (auto *sprite : m_digitSprites)
// {
// if (sprite)
// sprite->Render();
// }
}

44
source/EngineFrame/Component/NumberText.h Normal file
View File

@@ -0,0 +1,44 @@
#pragma once
#include "EngineFrame/Component/Text.h"
#include "EngineCore/Game.h"
#include "EngineFrame/Render/RenderManager.h"
#include <string>
#include <unordered_map>
#include <vector>
// 数字文本类，高效处理数字更新
class NumberText : public Text
{
private:
// 字体
TTF_Font *m_font;
// 文本颜色
SDL_Color m_color;
// 当前数字
int m_currentNumber = 0;
// 数字字符纹理缓存（'0'-'9'和'-'）
std::unordered_map<char, RefPtr<Texture>> m_digitTextures;
// 当前数字的字符精灵列表
std::vector<Sprite *> m_digitSprites;
// 预加载0-9和负号的纹理
void PreloadDigits();
// 更新数字精灵（根据新数字字符串重新排列字符）
void UpdateDigitSprites(const std::string &numStr);
public:
// 构造函数：指定字体、颜色和字符尺寸
NumberText(TTF_Font *font, SDL_Color color);
~NumberText();
// 设置数字（核心方法：仅更新变化的数字部分）
void SetNumber(int number);
int GetNumber() const { return m_currentNumber; }
// 重写Render，绘制所有数字字符
void Render() override;
};

10
source/EngineFrame/Component/RenderBase.cpp
View File

@@ -40,13 +40,13 @@ void RenderBase::Render()
Component::Render();
}
void RenderBase::SetIterationPos(VecFPos pos)
void RenderBase::SetIterationPos(Vec2 pos)
{
Component::SetIterationPos(pos);
CalcRenderInfo(); // 更新渲染信息
}
void RenderBase::SetIterationScale(VecFPos scale)
void RenderBase::SetIterationScale(Vec2 scale)
{
Component::SetIterationScale(scale);
CalcRenderInfo(); // 更新渲染信息
@@ -60,14 +60,14 @@ void RenderBase::SetIterationRotation(float angle)
CalcRenderInfo(); // 更新渲染信息
}
void RenderBase::SetPos(VecFPos pos)
void RenderBase::SetPos(Vec2 pos)
{
Component::SetPos(pos);
CalcRenderInfo(); // 更新渲染信息
}
void RenderBase::SetScale(VecFPos scale)
void RenderBase::SetScale(Vec2 scale)
{
Component::SetScale(scale);
CalcRenderInfo(); // 更新渲染信息
@@ -79,7 +79,7 @@ void RenderBase::SetRotation(float angle)
CalcRenderInfo(); // 更新渲染信息
}
void RenderBase::SetAnchor(VecFPos anchor)
void RenderBase::SetAnchor(Vec2 anchor)
{
Component::SetAnchor(anchor);
CalcRenderInfo(); // 更新渲染信息

15
source/EngineFrame/Component/RenderBase.h
View File

@@ -1,7 +1,6 @@
#pragma once
#include "EngineFrame/Component/Component.h"
#include "Tool/TransformT.h"
class RenderBase : public Component
{
@@ -15,11 +14,13 @@ public:
// 翻转Flag
SDL_RendererFlip flip = SDL_FLIP_NONE;
// 锚点坐标
VecFPos AnchorPos;
Vec2 AnchorPos;
// 是否显示
bool Visible = true;
// 是否在屏幕内
bool IsInScreen = false;
//渲染矩阵
GlMatrix RenderMatrix;
};
public:
@@ -35,20 +36,20 @@ public:
public:
public:
// 设置迭代的坐标
void SetIterationPos(VecFPos pos) override;
void SetIterationPos(Vec2 pos) override;
// 设置迭代的缩放
void SetIterationScale(VecFPos scale) override;
void SetIterationScale(Vec2 scale) override;
// 设置迭代的旋转角度
void SetIterationRotation(float angle) override;
// 设置坐标
void SetPos(VecFPos pos) override;
void SetPos(Vec2 pos) override;
// 设置缩放
void SetScale(VecFPos scale) override;
void SetScale(Vec2 scale) override;
// 设置旋转角度
void SetRotation(float angle) override;
// 设置中心点
void SetAnchor(VecFPos anchor) override;
void SetAnchor(Vec2 anchor) override;
// 计算渲染信息
void CalcRenderInfo() override;

45
source/EngineFrame/Component/Sprite.cpp
View File

@@ -43,6 +43,35 @@ RefPtr<Texture> Sprite::GetTexture()
return m_texture;
}
GlMatrix Sprite::matrix3x2ToGLMatrix(const Matrix3x2 &mat)
{
return {
// 列0：x轴线性变换
mat._11, // [0][0]
mat._12, // [1][0]
0.0f, // [2][0]
0.0f, // [3][0]
// 列1：y轴线性变换
mat._21, // [0][1]
mat._22, // [1][1]
0.0f, // [2][1]
0.0f, // [3][1]
// 列2：z轴（固定）
0.0f, // [0][2]
0.0f, // [1][2]
1.0f, // [2][2]
0.0f, // [3][2]
// 列3：平移
mat._31, // [0][3]（x平移）
mat._32, // [1][3]（y平移）
0.0f, // [2][3]
1.0f // [3][3]
};
}
void Sprite::CalcRenderInfoLogic()
{
// 获取至在最终的父对象检查是否显示
@@ -151,7 +180,9 @@ void Sprite::Render()
if (_RenderGuidanceInfo.IsInScreen && _RenderGuidanceInfo.Visible)
{
SDL_FPoint AnchorPos = _RenderGuidanceInfo.AnchorPos;
SDL_FPoint AnchorPos;
AnchorPos.x = _RenderGuidanceInfo.AnchorPos.x;
AnchorPos.y = _RenderGuidanceInfo.AnchorPos.y;
// 混合
if (this->_BlendMode != NONE)
@@ -163,8 +194,6 @@ void Sprite::Render()
// 还原混合
if (this->_BlendMode != NONE)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
Game::GetInstance().m_RenderCount++;
}
}
@@ -172,10 +201,7 @@ void Sprite::Clear()
{
}
void Sprite::SetBlendMode(LE_BlEND_MODE mode)
{
this->_BlendMode = mode;
}
void Sprite::Blend()
{
@@ -186,8 +212,3 @@ void Sprite::Blend()
break;
}
}
LE_BlEND_MODE Sprite::GetBlendMode()
{
return this->_BlendMode;
}

10
source/EngineFrame/Component/Sprite.h
View File

@@ -29,19 +29,17 @@ public:
public:
// 渲染信息
RenderGuidanceInfo _RenderGuidanceInfo;
// 混合模式
LE_BlEND_MODE _BlendMode = NONE;
std::string imgPath;
int Index;
Matrix3x2 transform_matrix_;
GlMatrix matrix3x2ToGLMatrix(const Matrix3x2 &mat);
public:
// 计算渲染信息
void CalcRenderInfoLogic();
// 设置混合模式
void SetBlendMode(LE_BlEND_MODE mode);
// 混合
void Blend();
// 获取混合模式
LE_BlEND_MODE GetBlendMode();
};

2
source/Tool/Allocator.cpp
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2016-2018 Kiwano - Nomango
// Copyright (c) 2016-2018 Ember - Nomango
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal

130
source/Tool/Common.h
View File

@@ -17,6 +17,8 @@
#include <cmath>
#endif
#include "math/Math.h"
/// \~chinese
/// @brief 不可拷贝对象
class Noncopyable
@@ -30,134 +32,6 @@ private:
Noncopyable &operator=(const Noncopyable &) = delete;
};
// 整数坐标向量
typedef struct VecPos
{
int x;
int y;
// 构造函数，方便初始化
VecPos(int x_ = 0, int y_ = 0) : x(x_), y(y_) {}
// 定义到 SDL_Point 的转换运算符
operator SDL_Point() const
{
return {x, y}; // 直接返回包含 x、y 的 SDL_Point
}
// 转换为SDL_Point指针的运算符（用于指针场景）
operator const SDL_Point *() const
{
// 注意：这里返回的是指向当前对象的指针，需确保对象生命周期有效
return reinterpret_cast<const SDL_Point *>(this);
}
// 加法运算符重载：两个 VecPos 相加
VecPos operator+(const VecPos &other) const
{
return VecPos(x + other.x, y + other.y);
}
// 减法运算符重载：两个 VecPos 相减
VecPos operator-(const VecPos &other) const
{
return VecPos(x - other.x, y - other.y);
}
// 等于运算符重载：判断两个 VecPos 是否相等
bool operator==(const VecPos &other) const
{
return x == other.x && y == other.y;
}
// 复合赋值加法：当前对象加上另一个 VecPos
VecPos &operator+=(const VecPos &other)
{
x += other.x;
y += other.y;
return *this;
}
// 复合赋值减法：当前对象减去另一个 VecPos
VecPos &operator-=(const VecPos &other)
{
x -= other.x;
y -= other.y;
return *this;
}
// 乘法
VecPos operator*(float value) const
{
return VecPos(x * value, y * value);
}
} VecPos;
// 浮点数坐标向量
typedef struct VecFPos
{
float x;
float y;
// 构造函数，方便初始化
VecFPos(float x_ = 0.0f, float y_ = 0.0f) : x(x_), y(y_) {}
VecFPos(int x_, int y_ = 0) : x(static_cast<float>(x_)), y(static_cast<float>(y_)) {}
// 定义到 SDL_FPoint 的转换运算符
operator SDL_FPoint() const
{
return {x, y}; // 直接返回包含 x、y 的 SDL_Point
}
// 加法运算符重载：两个 VecFPos 相加
VecFPos operator+(const VecFPos &other) const
{
return VecFPos(x + other.x, y + other.y);
}
// 减法运算符重载：两个 VecFPos 相减
VecFPos operator-(const VecFPos &other) const
{
return VecFPos(x - other.x, y - other.y);
}
// 乘法运算符重载：两个 VecFPos 相乘
VecFPos operator*(const VecFPos &other) const
{
return VecFPos(x * other.x, y * other.y);
}
// 除法运算符重载：除以一个 float 值
VecFPos operator/(float value) const
{
return VecFPos(x / value, y / value);
}
// 等于运算符重载：判断两个 VecFPos 是否相等
// 注意：浮点数比较需要考虑精度问题
bool operator==(const VecFPos &other) const
{
// 使用一个小的epsilon值来比较浮点数
const float epsilon = 0.0001f;
return (fabs(x - other.x) < epsilon) && (fabs(y - other.y) < epsilon);
}
// 复合赋值加法：当前对象加上另一个 VecFPos
VecFPos &operator+=(const VecFPos &other)
{
x += other.x;
y += other.y;
return *this;
}
// 复合赋值减法：当前对象减去另一个 VecFPos
VecFPos &operator-=(const VecFPos &other)
{
x -= other.x;
y -= other.y;
return *this;
}
} VecFPos;
// 尺寸向量
typedef struct VecSize
{

4
source/Tool/RefBasePtr.hpp
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2016-2018 Kiwano - Nomango
// Copyright (c) 2016-2018 Ember - Nomango
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
@@ -249,7 +249,7 @@ inline bool operator<(const RefBasePtr<_Ty, _RefPolicy> &lhs, const RefBasePtr<_
}
// template class cannot specialize std::swap,
// so implement a swap function in kiwano namespace
// so implement a swap function in ember namespace
template <class _Ty, class _RefPolicy>
inline void swap(RefBasePtr<_Ty, _RefPolicy> &lhs, RefBasePtr<_Ty, _RefPolicy> &rhs) noexcept
{

2
source/Tool/RefPtr.h
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2016-2018 Kiwano - Nomango
// Copyright (c) 2016-2018 Ember - Nomango
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal

52
source/Tool/TransformT.cpp
View File

@@ -1,52 +0,0 @@
#include "TransformT.h"
TransformT::TransformT()
: rotation(0.f), position(), scale(1.f, 1.f)
{
}
bool TransformT::IsFast() const
{
return scale.x == 1.f && scale.y == 1.f && rotation == 0.f;
}
bool TransformT::operator==(const TransformT &rhs) const
{
return position == rhs.position && rotation == rhs.rotation && scale == rhs.scale;
}
// -------------------------- 加法运算符实现 --------------------------
TransformT TransformT::operator+(const TransformT &rhs) const
{
TransformT result;
result.rotation = this->rotation + rhs.rotation;
result.position = this->position + rhs.position;
result.scale = this->scale + rhs.scale;
return result;
}
TransformT TransformT::operator-(const TransformT &rhs) const
{
TransformT result;
result.rotation = this->rotation - rhs.rotation;
result.position = this->position - rhs.position;
result.scale = this->scale - rhs.scale;
return result;
}
// -------------------------- 复合赋值运算符实现 --------------------------
TransformT &TransformT::operator+=(const TransformT &rhs)
{
this->rotation += rhs.rotation;
this->position += rhs.position;
this->scale += rhs.scale;
return *this;
}
TransformT &TransformT::operator-=(const TransformT &rhs)
{
this->rotation -= rhs.rotation;
this->position -= rhs.position;
this->scale -= rhs.scale;
return *this;
}

25
source/Tool/TransformT.h
View File

@@ -1,25 +0,0 @@
#pragma once
#include "Tool/Common.h"
/**
* \~chinese
* @brief 二维放射变换
*/
class TransformT
{
public:
float rotation; ///< 旋转
VecFPos position; ///< 坐标
VecFPos scale; ///< 缩放
public:
TransformT();
bool IsFast() const;
bool operator==(const TransformT &rhs) const;
TransformT operator+(const TransformT &rhs) const;
TransformT operator-(const TransformT &rhs) const;
TransformT &operator+=(const TransformT &rhs);
TransformT &operator-=(const TransformT &rhs);
};

40
source/math/Constants.h Normal file
View File

@@ -0,0 +1,40 @@
// Copyright (c) 2016-2018 Ember - Nomango
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#pragma once
namespace ember
{
namespace math
{
constexpr auto PI_F = 3.141592653589793f;
constexpr auto PI_F_2 = 1.570796326794896f;
constexpr auto PI_F_X_2 = 6.283185307179586f;
constexpr auto PI_D = 3.14159265358979323846;
constexpr auto PI_D_2 = 1.57079632679489661923;
constexpr auto PI_D_X_2 = 6.28318530717958647692;
constexpr auto FLOAT_MAX = 3.402823466e+38F;
constexpr auto FLOAT_MIN = 1.175494351e-38F;
} // namespace math
} // namespace ember

278
source/math/EaseFunctions.h Normal file
View File

@@ -0,0 +1,278 @@
// Copyright (c) 2016-2018 Ember - Nomango
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#pragma once
#include <math/Scalar.h>
namespace ember
{
namespace math
{
inline float Linear(float step)
{
return step;
}
// Ease
inline float EaseIn(float step, float rate)
{
return math::Pow(step, rate);
}
inline float EaseOut(float step, float rate)
{
return math::Pow(step, 1.f / rate);
}
inline float EaseInOut(float step, float rate)
{
if (step < .5f)
return .5f * math::Pow(2 * step, rate);
return 1.f - .5f * math::Pow(2.f - 2 * step, rate);
}
// Exponential Ease
inline float EaseExponentialIn(float step)
{
return math::Pow(2.f, 10 * (step - 1));
}
inline float EaseExponentialOut(float step)
{
return 1.f - math::Pow(2.f, -10 * step);
}
inline float EaseExponentialInOut(float step)
{
if (step < .5f)
return .5f * math::Pow(2.f, 10 * (2 * step - 1));
return 0.5f * (2 - math::Pow(2, -10 * (step * 2 - 1)));
}
// Bounce Ease
inline float EaseBounceOut(float step)
{
if (step < 1 / 2.75f)
{
return 7.5625f * step * step;
}
else if (step < 2 / 2.75f)
{
step -= 1.5f / 2.75f;
return 7.5625f * step * step + 0.75f;
}
else if (step < 2.5f / 2.75f)
{
step -= 2.25f / 2.75f;
return 7.5625f * step * step + 0.9375f;
}
step -= 2.625f / 2.75f;
return 7.5625f * step * step + 0.984375f;
}
inline float EaseBounceIn(float step)
{
return 1 - EaseBounceOut(1 - step);
}
inline float EaseBounceInOut(float step)
{
if (step < 0.5f)
{
return EaseBounceIn(step * 2) * 0.5f;
}
else
{
return EaseBounceOut(step * 2 - 1) * 0.5f + 0.5f;
}
}
// Elastic Ease
inline float EaseElasticIn(float step, float period)
{
if (step == 0 || step == 1)
return step;
step = step - 1;
return -math::Pow(2, 10 * step) * math::Sin((step - period / 4) * 360.f / period);
}
inline float EaseElasticOut(float step, float period)
{
if (step == 0 || step == 1)
return step;
return math::Pow(2, -10 * step) * math::Sin((step - period / 4) * 360.f / period) + 1;
}
inline float EaseElasticInOut(float step, float period)
{
if (step == 0 || step == 1)
return step;
step = step * 2 - 1;
if (step < 0)
{
return -0.5f * math::Pow(2, 10 * step) * math::Sin((step - period / 4) * 360.f / period);
}
return math::Pow(2, -10 * step) * math::Sin((step - period / 4) * 360.f / period) * 0.5f + 1;
}
// Back Ease
inline float EaseBackIn(float step)
{
const float overshoot = 1.70158f;
return step * step * ((overshoot + 1) * step - overshoot);
}
inline float EaseBackOut(float step)
{
const float overshoot = 1.70158f;
step = step - 1;
return step * step * ((overshoot + 1) * step + overshoot) + 1;
}
inline float EaseBackInOut(float step)
{
const float overshoot = 1.70158f * 1.525f;
step = step * 2;
if (step < 1)
{
return (step * step * ((overshoot + 1) * step - overshoot)) / 2;
}
step = step - 2;
return (step * step * ((overshoot + 1) * step + overshoot)) / 2 + 1;
}
// Sine Ease
inline float EaseSineIn(float step)
{
return 1.f - math::Cos(step * 90);
}
inline float EaseSineOut(float step)
{
return math::Sin(step * 90);
}
inline float EaseSineInOut(float step)
{
return -0.5f * (math::Cos(step * 180) - 1);
}
// Quad Ease
inline float EaseQuadIn(float step)
{
return step * step;
}
inline float EaseQuadOut(float step)
{
return -1 * step * (step - 2);
}
inline float EaseQuadInOut(float step)
{
step = step * 2;
if (step < 1)
return 0.5f * step * step;
--step;
return -0.5f * (step * (step - 2) - 1);
}
// Cubic Ease
inline float EaseCubicIn(float step)
{
return step * step * step;
}
inline float EaseCubicOut(float step)
{
step -= 1;
return (step * step * step + 1);
}
inline float EaseCubicInOut(float step)
{
step = step * 2;
if (step < 1)
return 0.5f * step * step * step;
step -= 2;
return 0.5f * (step * step * step + 2);
}
// Quart Ease
inline float EaseQuartIn(float step)
{
return step * step * step * step;
}
inline float EaseQuartOut(float step)
{
step -= 1;
return -(step * step * step * step - 1);
}
inline float EaseQuartInOut(float step)
{
step = step * 2;
if (step < 1)
return 0.5f * step * step * step * step;
step -= 2;
return -0.5f * (step * step * step * step - 2);
}
// Quint Ease
inline float EaseQuintIn(float step)
{
return step * step * step * step * step;
}
inline float EaseQuintOut(float step)
{
step -= 1;
return (step * step * step * step * step + 1);
}
inline float EaseQuintInOut(float step)
{
step = step * 2;
if (step < 1)
return 0.5f * step * step * step * step * step;
step -= 2;
return 0.5f * (step * step * step * step * step + 2);
}
} // namespace math
} // namespace ember

153
source/math/Interpolator.h Normal file
View File

@@ -0,0 +1,153 @@
// Copyright (c) 2016-2018 Ember - Nomango
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#pragma once
#include <core/Function.h>
#include <math/Vec2.hpp>
#include <math/Rect.hpp>
#include <math/Transform.hpp>
namespace ember
{
namespace math
{
template <typename _Method = void>
struct InterpolateMethod;
template <>
struct InterpolateMethod<void>
{
inline float operator()(float frac) const noexcept
{
return frac;
}
};
template <>
struct InterpolateMethod<float (*)(float)>
{
float (*method)(float);
InterpolateMethod(float (*method)(float)) noexcept
: method(method)
{
}
inline float operator()(float frac) const noexcept
{
if (method)
return method(frac);
return frac;
}
};
template <>
struct InterpolateMethod<Function<float(float)>>
{
Function<float(float)> method;
InterpolateMethod(const Function<float(float)> &method) noexcept
: method(method)
{
}
inline float operator()(float frac) const noexcept
{
if (method)
return method(frac);
return frac;
}
};
template <typename _Ty>
class Interpolator;
template <typename _Ty>
class Interpolator
{
public:
template <typename _Method = void>
inline _Ty Interpolate(_Ty start, _Ty end, float frac, const InterpolateMethod<_Method> &method = {})
{
if (frac >= 1)
return end;
return start + static_cast<_Ty>(static_cast<float>(end - start) * method(frac));
}
};
template <typename _Ty>
class Interpolator<Vec2T<_Ty>>
{
public:
template <typename _Method = void>
inline Vec2T<_Ty> Interpolate(const Vec2T<_Ty> &start, const Vec2T<_Ty> &end, float frac,
const InterpolateMethod<_Method> &method = {})
{
if (frac >= 1)
return end;
Interpolator<_Ty> fi;
return Vec2T<_Ty>{fi.Interpolate(start.x, end.x, frac, method), fi.Interpolate(start.y, end.y, frac, method)};
}
};
template <typename _Ty>
class Interpolator<RectT<_Ty>>
{
public:
template <typename _Method = void>
inline RectT<_Ty> Interpolate(const RectT<_Ty> &start, const RectT<_Ty> &end, float frac,
const InterpolateMethod<_Method> &method = {})
{
if (frac >= 1)
return end;
Interpolator<Vec2T<_Ty>> vi;
return RectT<_Ty>{vi.Interpolate(start.left_top, end.left_top, frac, method),
vi.Interpolate(start.right_bottom, end.right_bottom, frac, method)};
}
};
template <typename _Ty>
class Interpolator<TransformT<_Ty>>
{
public:
template <typename _Method = void>
inline TransformT<_Ty> Interpolate(const TransformT<_Ty> &start, const TransformT<_Ty> &end, float frac,
const InterpolateMethod<_Method> &method = {})
{
if (frac >= 1)
return end;
Interpolator<_Ty> fi;
Interpolator<Vec2T<_Ty>> vi;
TransformT<_Ty> transform;
transform.rotation = fi.Interpolate(start.rotation, end.rotation, frac, method);
transform.position = vi.Interpolate(start.position, end.position, frac, method);
transform.scale = vi.Interpolate(start.scale, end.scale, frac, method);
transform.skew = vi.Interpolate(start.skew, end.skew, frac, method);
return transform;
}
};
} // namespace math
} // namespace ember

39
source/math/Math.h Normal file
View File

@@ -0,0 +1,39 @@
// Copyright (c) 2016-2018 Ember - Nomango
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#pragma once
#include <math/Vec2.hpp>
#include <math/Rect.hpp>
#include <math/Matrix.hpp>
#include <math/Transform.hpp>
#include <math/Constants.h>
#include <math/EaseFunctions.h>
#include <math/Scalar.h>
using Vec2 = ember::math::Vec2T<float>;
using VecPos = ember::math::Vec2T<int>;
using Rect = ember::math::RectT<float>;
using Matrix3x2 = ember::math::Matrix3x2T<float>;
using Transform = ember::math::TransformT<float>;
using GlMatrix = std::array<float, 16>;
using Point = Vec2;
using Size = Vec2;

268
source/math/Matrix.hpp Normal file
View File

@@ -0,0 +1,268 @@
// Copyright (c) 2016-2018 Ember - Nomango
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#pragma once
#include <algorithm>
#include <math/Rect.hpp>
#include <math/Vec2.hpp>
namespace ember
{
namespace math
{
template <typename _Ty, typename _Lty, typename _Rty>
struct MatrixMultiply;
template <typename _Ty>
struct Matrix3x2T
{
using ValueType = _Ty;
using Vec2Type = Vec2T<ValueType>;
using RectType = RectT<ValueType>;
union
{
struct
{
_Ty m[6]; // m[3][2]
};
struct
{
_Ty _11, _12, _21, _22, _31, _32;
};
};
Matrix3x2T()
: _11(1.f), _12(0.f), _21(0.f), _22(1.f), _31(0.f), _32(0.f)
{
}
Matrix3x2T(ValueType _11, ValueType _12, ValueType _21, ValueType _22, ValueType _31, ValueType _32)
: _11(_11), _12(_12), _21(_21), _22(_22), _31(_31), _32(_32)
{
}
explicit Matrix3x2T(const ValueType *p)
{
for (int i = 0; i < 6; i++)
m[i] = p[i];
}
Matrix3x2T(const Matrix3x2T &other)
: _11(other._11), _12(other._12), _21(other._21), _22(other._22), _31(other._31), _32(other._32)
{
}
template <typename _MTy>
Matrix3x2T(const _MTy &other)
{
for (int i = 0; i < 6; i++)
m[i] = other[i];
}
inline ValueType operator[](uint32_t index) const
{
return m[index];
}
inline ValueType &operator[](uint32_t index)
{
return m[index];
}
inline Matrix3x2T &operator=(const Matrix3x2T &other)
{
for (int i = 0; i < 6; i++)
m[i] = other[i];
return (*this);
}
template <typename _Lty, typename _Rty>
inline Matrix3x2T &operator=(const MatrixMultiply<ValueType, _Lty, _Rty> &other)
{
Matrix3x2T result(other);
(*this) = result;
return (*this);
}
inline Matrix3x2T &operator*=(const Matrix3x2T &other)
{
return operator=((*this) * other);
}
inline void Identity()
{
_11 = 1.f;
_12 = 0.f;
_21 = 0.f;
_22 = 1.f;
_31 = 0.f;
_32 = 0.f;
}
inline bool IsIdentity() const
{
return _11 == 1.f && _12 == 0.f && _21 == 0.f && _22 == 1.f && _31 == 0.f && _32 == 0.f;
}
inline Matrix3x2T Invert() const
{
ValueType det = 1.f / Determinant();
return Matrix3x2T(det * _22, -det * _12, -det * _21, det * _11, det * (_21 * _32 - _22 * _31),
det * (_12 * _31 - _11 * _32));
}
inline bool IsInvertible() const
{
return 0 != Determinant();
}
inline ValueType Determinant() const
{
return (_11 * _22) - (_12 * _21);
}
inline Vec2Type Transform(const Vec2Type &v) const
{
return Vec2Type(v.x * _11 + v.y * _21 + _31, v.x * _12 + v.y * _22 + _32);
}
RectType Transform(const RectType &rect) const
{
Vec2Type top_left = Transform(rect.GetLeftTop());
Vec2Type top_right = Transform(rect.GetRightTop());
Vec2Type bottom_left = Transform(rect.GetLeftBottom());
Vec2Type bottom_right = Transform(rect.GetRightBottom());
ValueType left = (std::min)((std::min)(top_left.x, top_right.x), (std::min)(bottom_left.x, bottom_right.x));
ValueType right = (std::max)((std::max)(top_left.x, top_right.x), (std::max)(bottom_left.x, bottom_right.x));
ValueType top = (std::min)((std::min)(top_left.y, top_right.y), (std::min)(bottom_left.y, bottom_right.y));
ValueType bottom = (std::max)((std::max)(top_left.y, top_right.y), (std::max)(bottom_left.y, bottom_right.y));
return RectType{left, top, right, bottom};
}
inline void Translate(const Vec2Type &v)
{
_31 += _11 * v.x + _21 * v.y;
_32 += _12 * v.x + _22 * v.y;
}
static inline Matrix3x2T Translation(const Vec2Type &v)
{
return Matrix3x2T(1.f, 0.f, 0.f, 1.f, v.x, v.y);
}
static inline Matrix3x2T Scaling(const Vec2Type &v)
{
return Matrix3x2T(v.x, 0.f, 0.f, v.y, 0.f, 0.f);
}
static inline Matrix3x2T Scaling(const Vec2Type &v, const Vec2Type &center)
{
return Matrix3x2T(v.x, 0.f, 0.f, v.y, center.x - v.x * center.x, center.y - v.y * center.y);
}
static inline Matrix3x2T Rotation(ValueType angle)
{
ValueType s = math::Sin(angle);
ValueType c = math::Cos(angle);
return Matrix3x2T(c, s, -s, c, 0.f, 0.f);
}
static inline Matrix3x2T Rotation(ValueType angle, const Vec2Type &center)
{
ValueType s = math::Sin(angle);
ValueType c = math::Cos(angle);
return Matrix3x2T(c, s, -s, c, center.x * (1 - c) + center.y * s, center.y * (1 - c) - center.x * s);
}
static inline Matrix3x2T SRT(const Vec2Type &trans, const Vec2Type &scale, ValueType angle)
{
ValueType s = math::Sin(angle);
ValueType c = math::Cos(angle);
return Matrix3x2T(c * scale.x, s * scale.x, -s * scale.y, c * scale.y, trans.x, trans.y);
}
static inline Matrix3x2T Skewing(const Vec2Type &angle)
{
ValueType tx = math::Tan(angle.x);
ValueType ty = math::Tan(angle.y);
return Matrix3x2T(1.f, -ty, -tx, 1.f, 0.f, 0.f);
}
static inline Matrix3x2T Skewing(const Vec2Type &angle, const Vec2Type &center)
{
ValueType tx = math::Tan(angle.x);
ValueType ty = math::Tan(angle.y);
return Matrix3x2T(1.f, -ty, -tx, 1.f, center.y * tx, center.x * ty);
}
};
// Use template expression to optimize matrix multiply
template <typename _Ty, typename _Lty, typename _Rty>
struct MatrixMultiply
{
const _Lty &lhs;
const _Rty &rhs;
MatrixMultiply(const _Lty &lhs, const _Rty &rhs)
: lhs(lhs), rhs(rhs)
{
}
inline _Ty operator[](uint32_t index) const
{
switch (index)
{
case 0:
return lhs[0] * rhs[0] + lhs[1] * rhs[2];
case 1:
return lhs[0] * rhs[1] + lhs[1] * rhs[3];
case 2:
return lhs[2] * rhs[0] + lhs[3] * rhs[2];
case 3:
return lhs[2] * rhs[1] + lhs[3] * rhs[3];
case 4:
return lhs[4] * rhs[0] + lhs[5] * rhs[2] + rhs[4];
case 5:
return lhs[4] * rhs[1] + lhs[5] * rhs[3] + rhs[5];
default:
return 0.f;
}
}
};
template <typename _Ty>
inline MatrixMultiply<_Ty, Matrix3x2T<_Ty>, Matrix3x2T<_Ty>> operator*(const Matrix3x2T<_Ty> &lhs,
const Matrix3x2T<_Ty> &rhs)
{
return MatrixMultiply<_Ty, Matrix3x2T<_Ty>, Matrix3x2T<_Ty>>(lhs, rhs);
}
template <typename _Ty, typename _Lty, typename _Rty>
inline MatrixMultiply<_Ty, MatrixMultiply<_Ty, _Lty, _Rty>, Matrix3x2T<_Ty>>
operator*(const MatrixMultiply<_Ty, _Lty, _Rty> &lhs, const Matrix3x2T<_Ty> &rhs)
{
return MatrixMultiply<_Ty, MatrixMultiply<_Ty, _Lty, _Rty>, Matrix3x2T<_Ty>>(lhs, rhs);
}
} // namespace math
} // namespace ember

114
source/math/Random.h Normal file
View File

@@ -0,0 +1,114 @@
// Copyright (c) 2016-2018 Ember - Nomango
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#pragma once
#include <random>
namespace ember
{
namespace math
{
//
// 随机数
//
// 获取指定范围内的一个随机数, 如:
// int n = math::Random(1, 5); // 获取 1~5 内的随机整数, 包含 1 和 5
// 产生的随机数类型取决于参数的类型, 如获取随机浮点数:
// float d = math::Random(1.2f, 1.5f);
//
int Random(int min, int max);
unsigned int Random(unsigned int min, unsigned int max);
long Random(long min, long max);
unsigned long Random(unsigned long min, unsigned long max);
char Random(char min, char max);
float Random(float min, float max);
double Random(double min, double max);
//
// Details of math::Rand
//
namespace __rand_detail
{
inline std::default_random_engine &GetRandomEngine()
{
static std::random_device device;
static std::default_random_engine engine(device());
return engine;
}
template <typename T>
inline T RandomInt(T min, T max)
{
std::uniform_int_distribution<T> dist(min, max);
return dist(GetRandomEngine());
}
template <typename T>
inline T RandomReal(T min, T max)
{
std::uniform_real_distribution<T> dist(min, max);
return dist(GetRandomEngine());
}
} // namespace __rand_detail
inline int Random(int min, int max)
{
return __rand_detail::RandomInt(min, max);
}
inline unsigned int Random(unsigned int min, unsigned int max)
{
return __rand_detail::RandomInt(min, max);
}
inline long Random(long min, long max)
{
return __rand_detail::RandomInt(min, max);
}
inline unsigned long Random(unsigned long min, unsigned long max)
{
return __rand_detail::RandomInt(min, max);
}
inline char Random(char min, char max)
{
return static_cast<char>(__rand_detail::RandomInt(static_cast<int>(min), static_cast<int>(max)));
}
inline float Random(float min, float max)
{
return __rand_detail::RandomReal(min, max);
}
inline double Random(double min, double max)
{
return __rand_detail::RandomReal(min, max);
}
} // namespace math
} // namespace ember

154
source/math/Rect.hpp Normal file
View File

@@ -0,0 +1,154 @@
// Copyright (c) 2016-2018 Ember - Nomango
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#pragma once
#include <math/Vec2.hpp>
namespace ember
{
namespace math
{
template <typename _Ty>
struct RectT
{
public:
using ValueType = _Ty;
Vec2T<ValueType> left_top;
Vec2T<ValueType> right_bottom;
public:
RectT() {}
RectT(ValueType left, ValueType top, ValueType right, ValueType bottom)
: left_top(left, top), right_bottom(right, bottom)
{
}
RectT(const Vec2T<ValueType> &left_top, const Vec2T<ValueType> &right_bottom)
: left_top(left_top), right_bottom(right_bottom)
{
}
RectT(const RectT &other)
: left_top(other.left_top), right_bottom(other.right_bottom)
{
}
RectT &operator=(const RectT &other)
{
left_top = other.left_top;
right_bottom = other.right_bottom;
return *this;
}
inline bool operator==(const RectT &rect) const
{
return (left_top == rect.left_top) && (right_bottom == rect.right_bottom);
}
inline void Set(ValueType left, ValueType top, ValueType right, ValueType bottom)
{
left_top = Vec2T<ValueType>{left, top};
right_bottom = Vec2T<ValueType>{right, bottom};
}
inline Vec2T<ValueType> GetCenter() const
{
return Vec2T<ValueType>{(left_top.x + right_bottom.x) / 2, (left_top.y + right_bottom.y) / 2};
}
inline Vec2T<ValueType> GetLeftTop() const
{
return left_top;
}
inline Vec2T<ValueType> GetRightBottom() const
{
return right_bottom;
}
inline Vec2T<ValueType> GetRightTop() const
{
return Vec2T<ValueType>{right_bottom.x, left_top.y};
}
inline Vec2T<ValueType> GetLeftBottom() const
{
return Vec2T<ValueType>{left_top.x, right_bottom.y};
}
inline ValueType GetLeft() const
{
return left_top.x;
}
inline ValueType GetTop() const
{
return left_top.y;
}
inline ValueType GetRight() const
{
return right_bottom.x;
}
inline ValueType GetBottom() const
{
return right_bottom.y;
}
inline ValueType GetWidth() const
{
return right_bottom.x - left_top.x;
}
inline ValueType GetHeight() const
{
return right_bottom.y - left_top.y;
}
inline Vec2T<ValueType> GetSize() const
{
return Vec2T<ValueType>{GetWidth(), GetHeight()};
}
inline bool IsEmpty() const
{
return left_top.IsOrigin() && right_bottom.IsOrigin();
}
inline bool ContainsPoint(const Vec2T<ValueType> &point) const
{
return point.x >= left_top.x && point.x <= right_bottom.x && point.y >= left_top.y && point.y <= right_bottom.y;
}
inline bool Intersects(const RectT &rect) const
{
return !(right_bottom.x < rect.left_top.x || rect.right_bottom.x < left_top.x || right_bottom.y < rect.left_top.y || rect.right_bottom.y < left_top.y);
}
static inline RectT Infinite()
{
return RectT{-math::FLOAT_MAX, -math::FLOAT_MAX, math::FLOAT_MAX, math::FLOAT_MAX};
}
};
} // namespace math
} // namespace ember

165
source/math/Scalar.h Normal file
View File

@@ -0,0 +1,165 @@
// Copyright (c) 2016-2018 Ember - Nomango
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#pragma once
#include <cmath>
#include <math/Constants.h>
namespace ember
{
namespace math
{
inline int Abs(int val)
{
return ::abs(val);
}
inline float Abs(float val)
{
return ::fabsf(val);
}
inline double Abs(double val)
{
return ::fabs(val);
}
inline float Sqrt(float val)
{
return ::sqrtf(val);
}
inline double Sqrt(double val)
{
return ::sqrt(val);
}
inline float Pow(float core, float exponent)
{
return ::powf(core, exponent);
}
inline double Pow(double core, double exponent)
{
return ::pow(core, exponent);
}
inline int Sign(int val)
{
return val < 0 ? -1 : 1;
}
inline float Sign(float val)
{
return val < 0 ? -1.f : 1.f;
}
inline double Sign(double val)
{
return val < 0 ? -1.0 : 1.0;
}
inline float Degree2Radian(float angle)
{
return angle * math::PI_F / 180.f;
}
inline double Degree2Radian(double angle)
{
return angle * math::PI_D / 180.0;
}
inline float Radian2Degree(float radian)
{
return radian * 180.f / math::PI_F;
}
inline double Radian2Degree(double radian)
{
return radian * 180.0 / math::PI_D;
}
inline float Sin(float val)
{
return ::sinf(Degree2Radian(val));
}
inline double Sin(double val)
{
return ::sin(Degree2Radian(val));
}
inline float Cos(float val)
{
return ::cosf(Degree2Radian(val));
}
inline double Cos(double val)
{
return ::cos(Degree2Radian(val));
}
inline float Tan(float val)
{
return ::tanf(Degree2Radian(val));
}
inline double Tan(double val)
{
return ::tan(Degree2Radian(val));
}
inline float Asin(float val)
{
return Radian2Degree(::asinf(val));
}
inline double Asin(double val)
{
return Radian2Degree(::asin(val));
}
inline float Acos(float val)
{
return Radian2Degree(::acosf(val));
}
inline double Acos(double val)
{
return Radian2Degree(::acos(val));
}
inline float Atan(float val)
{
return Radian2Degree(::atanf(val));
}
inline double Atan(double val)
{
return Radian2Degree(::atan(val));
}
inline float Ceil(float val)
{
return ::ceil(val);
}
inline double Ceil(double val)
{
return ::ceil(val);
}
inline float Floor(float val)
{
return ::floor(val);
}
inline double Floor(double val)
{
return ::floor(val);
}
} // namespace math
} // namespace ember

86
source/math/Transform.hpp Normal file
View File

@@ -0,0 +1,86 @@
// Copyright (c) 2016-2018 Ember - Nomango
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#pragma once
#include <math/Vec2.hpp>
#include <math/Matrix.hpp>
namespace ember
{
namespace math
{
/**
* \~chinese
* @brief ¶þά·ÅÉä±ä»»
*/
template <typename _Ty>
class TransformT
{
public:
using ValueType = _Ty;
float rotation; ///< Ðýת
Vec2T<ValueType> position; ///< ×ø±ê
Vec2T<ValueType> scale; ///< Ëõ·Å
Vec2T<ValueType> skew; ///< ´íÇнǶÈ
public:
TransformT();
/// \~chinese
/// @brief ½«¶þά·ÅÉä±ä»»×ª»»Îª¾ØÕó
Matrix3x2T<ValueType> ToMatrix() const;
bool IsFast() const;
bool operator==(const TransformT &rhs) const;
};
template <typename _Ty>
inline TransformT<_Ty>::TransformT()
: position(), rotation(0.f), scale(1.f, 1.f), skew(0.f, 0.f)
{
}
template <typename _Ty>
Matrix3x2T<_Ty> TransformT<_Ty>::ToMatrix() const
{
if (!skew.IsOrigin())
{
return Matrix3x2T<_Ty>::Skewing(skew) * Matrix3x2T<_Ty>::SRT(position, scale, rotation);
}
return Matrix3x2T<_Ty>::SRT(position, scale, rotation);
}
template <typename _Ty>
inline bool TransformT<_Ty>::IsFast() const
{
return skew.x == 0.f && skew.y == 0.f && scale.x == 1.f && scale.y == 1.f && rotation == 0.f;
}
template <typename _Ty>
bool TransformT<_Ty>::operator==(const TransformT &rhs) const
{
return position == rhs.position && rotation == rhs.rotation && scale == rhs.scale && skew == rhs.skew;
}
} // namespace math
} // namespace ember

136
source/math/Vec2.hpp Normal file
View File

@@ -0,0 +1,136 @@
// Copyright (c) 2016-2018 Ember - Nomango
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#pragma once
#include <math/Scalar.h>
namespace ember
{
namespace math
{
template <typename _Ty>
struct Vec2T
{
using ValueType = _Ty;
ValueType x;
ValueType y;
Vec2T()
: x(ValueType(0)), y(ValueType(0))
{
}
Vec2T(ValueType x, ValueType y)
: x(x), y(y)
{
}
Vec2T(const Vec2T &other)
: x(other.x), y(other.y)
{
}
inline ValueType Length() const
{
return static_cast<ValueType>(math::Sqrt(static_cast<float>(x * x + y * y)));
}
inline bool IsOrigin() const
{
return (x == 0) && (y == 0);
}
inline void Set(ValueType x, ValueType y)
{
this->x = x;
this->y = y;
}
inline const Vec2T operator+(const Vec2T &other) const
{
return Vec2T(x + other.x, y + other.y);
}
inline const Vec2T operator-(const Vec2T &other) const
{
return Vec2T(x - other.x, y - other.y);
}
inline const Vec2T operator*(ValueType val) const
{
return Vec2T(x * val, y * val);
}
inline const Vec2T operator*(const Vec2T &other) const
{
return Vec2T(x * other.x, y * other.y);
}
inline const Vec2T operator/(ValueType val) const
{
return Vec2T(x / val, y / val);
}
inline const Vec2T operator-() const
{
return Vec2T(-x, -y);
}
inline Vec2T &operator+=(const Vec2T &other)
{
x += other.x;
y += other.y;
return (*this);
}
inline Vec2T &operator-=(const Vec2T &other)
{
x -= other.x;
y -= other.y;
return (*this);
}
inline Vec2T &operator*=(ValueType val)
{
x *= val;
y *= val;
return (*this);
}
inline Vec2T &operator/=(ValueType val)
{
x /= val;
y /= val;
return (*this);
}
inline bool operator==(const Vec2T &other) const
{
return (x == other.x) && (y == other.y);
}
inline bool operator!=(const Vec2T &other) const
{
return (x != other.x) || (y != other.y);
}
};
} // namespace math
} // namespace ember

1
source/squirrel/SquirrelEx.cpp
View File

@@ -102,6 +102,7 @@ void SquirrelEx::Init()
dbg = sqdbg_attach_debugger(v);
sqdbg_listen_socket(dbg, 2222);
fclose(file1);
}
#endif

3
source/squirrel/SquirrelEx.h
View File

@@ -76,6 +76,7 @@ private:
//工作目录
std::string WorkPath;
//热重载
bool HotReload = true;
bool HotReload = false;
std::map<std::string, int> _scriptmap;
};

7
source/squirrel/sqdbg/server.cpp
View File

@@ -4318,6 +4318,11 @@ void SQDebugServer::OnRequest_SetBreakpoints(const json_table_t &arguments, int
return;
}
//必须切割否则无法取消断点
#ifdef SQDBG_SOURCENAME_HAS_PATH
StripFileName(&srcname.ptr, &srcname.len);
#endif
RemoveBreakpoints(srcname);
DAP_START_RESPONSE(seq, "setBreakpoints");
@@ -18191,7 +18196,6 @@ void SQDebugServer::RemoveBreakpoints(const string_t &source)
for (unsigned int i = 0; i < m_nFunctionBreakpointsIdx;)
{
breakpoint_t &bp = m_Breakpoints[i];
if (bp.src.IsEqualTo(src))
{
FreeBreakpoint(bp);
@@ -19968,6 +19972,7 @@ void SQDebugServer::DebugHook(HSQUIRRELVM vm, int type,
sqstring_t src;
src.Assign(sourcename, srclen);
breakpoint_t *bp = GetBreakpoint(line, src);
if (bp)