柚子其实是蜜柑

远征IM@S Live

Mon, 14 Jul 2025 00:00:00 GMT

国内 P 如何远征偶像大师 Live

确定企划 Live 时间, 地点, 出演人员

偶像大师公式门户站 https://idolmaster-official.jp/
找到其中的ライブ/イベント, 可以看到相关的所有信息。

注册账号

Asobi Store https://asobistore.jp/
注册时居住国家需选择日本, 出生日期必须匹配, 出票会进行比对。

注册成功后 Event 界面可以进行购票。

信息录入

填写个人信息时, 不要输入汉字, 输入拼音。

地址在地图上随便找一个公寓地址, 不要填写一户建或商家, 避免被投诉。

电话随便填写一个。

票种

出售票种：

抽选全席位指定(最普通的坐票)和更好的位置。
先着剩余的全席指定和好票, 立见指定票和位置较差的票。
公式リセール 官方换票。
当日票 售票时间较晚的票, 全席指定没卖完。

一般抽选的票体验最好, 但官方公布较晚, 甚至当天才会公布, 需要多关注推特或者公演官网。

席位

席位种类：

全席指定 坐票, 好坏皆有
立见指定 站票, 告别好席, 主舞台可能被遮挡
着席指定 全程就坐, 不能爽打 Call
見切り席/完全見切り席 被遮挡席位, 无法完整看到甚至无法看到表演
SS 席/S 席 好位置票, 通常带特典
SPラウンジ席 VIP 休息间席位
バルコニー席 露台席, 离舞台较远

大会员

大会员抽票一般先行且更可能抽到好票。

在 ASOBI STORE 的プレミアム会とは可以进入大会员商店。

注意大会员要开就开年票, 月票是无法参与大会员抽选的。

开大会员需要办理一张 JCB 的卡, Visa 卡基本不可以开通。

国民经济核算

Thu, 10 Jul 2025 00:00:00 GMT

国民经济核算

Introduce

宏观经济学主要围绕 经济增长 , 就业和物价展开研究。（产出, 事业和通胀）

宏观经济学核心研究的社会组织是家庭 , 企业和部门。

宏观经济学认为有 产品市场 , 货币市场 和 劳动力市场 三个市场。

GDP

Gross domestic product - Wikipedia, 国内生产总值。

如果所有环节的价值增值等于参与到这个环节的所有人的收入总和, 而一件商品的产出是所有这些环节价值增值的总和。那么一件商品的产出, 就应该等于生产这件商品的全部环节中, 所有各种要素提供者的收入总和, 也就是总收入。
需要理解, 产出=支出=收入。

也就是说 GDP=总产出=总收入。

GDP 是什么：一段时间内, 一个地区新生产的所有最终产品和劳动的全部市场价值。

一段时间：指的是一个时间段
一个地区：指的是一个地域范围
新生产的：指的是在这段时间新创造的, 以前的不算
最终产品和劳务：指的是最后的使用者使用且消费掉的产品或者劳务
市场价值：指的是必须进入市场流通, 自产自销的不算
价值：指的是用钱来衡量的价值

GDP 核算方法

收入法
支出法
生产法

支出法：
家庭支出 $C$ -各种消费品和服务。
企业支出 $I$ -固定资产投资(新的, 不包括原材料, 支出法的投资算法包含了重置投资)；存货投资(库存, 注意已经核算的不会在第二年重复核算)。
政府支出 $G$ -政府购买(购买公共服务或公共产品)
外贸-净出口(出口总额 $X$ -进口总额 $M$) $$ GDP=C+I+G+(X-M) $$ 也可以说 GDP=消费+投资+政府购买+净出口
存货投资：支出法认为, 在本段时间内新生产但没有卖出去的库存属于企业自己花钱买自己的东西, 然后放在仓库明年直接拿出来卖, 所以算作投资。

Q：为什么从公司债中得到的利息收入算作 GDP, 而政府公债得到的利息不算 GDP
A：宏观经济学假定了公司会拿债务去进行投资, 债权人是资产要素提供者, 本金和利息是对提供者的补偿, 这是公司的投资支出, 也是债权人的收入, 故可以算入 GDP。政府举债并不会投入再生产, 政府的利息支出并不是生产所得, 而是用其他纳税人的前作为利息给债权人, 故是一种转移支付。

Q：买卖股票赚的钱为什么不计入 GDP
A：买卖股票在经济学上是一种投机而不是投资, 钱只是从 A 转移到 B, 而没有投入生产, 故不算入 GDP

Q：生产10亿, 卖了8亿, 剩下2亿算作存货投资。那么明年卖出2亿库存, 明年消费支出会增加2亿。是不是就重复计算了？
A：明年的存货投资会减少, 实际上是当年的存货投资转换为了明年的消费支出, 故没有重复计算

转移支付是不计入 GDP 的。
折旧：不能一次性用完的生产资料在生产过程中产生的磨损。

收入法：
把所有要素提供者的收入加起来核算 GDP 的方法, 收入法本质是核算成本, 这些成本包括

生产要素者提供的补偿：工资, 利息, 租金(包括专利, 版权等)
非公司企业主收入
公司税前利润
企业转移支付和间接税
折旧(一种会计处理, 为了和支出法一致)
GDP=工资+利息+利润+租金+间接税+企业转移支付+折旧+统计误差

产出法：
把一段时间内各个生产环节的价值增值全部相加

其他宏观经济指标

GNP：国民生产总值, GDP 是属地原则, GNP 是属人原则
NDP(Net Domestic Produc)：国内生产净值, NDP=GDP-折旧
NI(National Income)：国民收入, NI=NDP-间接税-企业转移支付+政府给企业的补贴, 反映了劳动和土地要素提供者的总收入
PI：个人收入, PI=NI-企业未分配利润-公司所得税-社会保险+政府转移支付
DPI(Disposable Personal Income)：个人可支配收入, DPI=PI-个人所得税

国民经济恒等式

下面是凯恩斯流派的观点：

考虑两部门经济(家庭+企业)：
支出法：GDP=消费+投资
收入法：GDP=消费+储蓄

投资=储蓄

考虑三部分经济(家庭+企业+政府购买)：
支出法：GDP=消费+投资+政府购买
收入法：GDP=消费+储蓄+税收

投资=储蓄+税收-政府购买=个人储蓄+政府储蓄=储蓄

考虑四部门经济(家庭+企业+政府+外国)：
支出法：GDP=消费+投资+政府购买+净出口
收入法：GDP=消费+储蓄+税收+对外转移支付

投资=个人储蓄+政府储蓄+外国人的储蓄(净进口-对外转移支付)

上述三个公式成为投资储蓄恒等式, 或国民经济恒等式

这是一种会计角度的恒等, 算完账后的事后恒等

名义 GDP 和实际 GDP

名义 GDP：单纯用当年物价水平确定的全部最终产品和劳务
实际 GDP：以某一年的物价作为基期价格计算出来的全部最终产品和劳务
名义 GDP/实际 GDP=GDP 折算指数或 GDP 平减指数

失业的衡量和失业率的计算

失业：有劳动能力且想工作的人找不到工作叫失业

失业率=失业人数/劳动力人数

物价水平的衡量

CPI(Consumer Price Index)：消费者价格指数（服务和消费品）。表示消费品的价格变化, 计算的最终数值 x100
PPI(Producer Price Index)：生产者价格指数（生产资料或工业品）。表示工业品的价格变化, 计算的最终数值 x100

物价水平：所有商品和劳务价格总额的加权平均值。代表所有商品和劳务的平均价格。

价格水平变化=一段时间结束时的物价水平/一段时间开始的物价水平
>1 物价水平上涨
<1 物价水平下降

计算价格水平, 会采用加权平均, 会使用商品的数量作为加权值。注意计算时, 加权值不能改变。

和上一期对比, 称为环比, 和去年同期相比, 称为同比。

CPI 算法的缺陷：

商品加权和基期一样, 不能改变
无法反映新商品淘汰旧商品, 导致 CPI 被高估, 产生了 CPI 替代偏向
反映不出商品质量更好或更便宜, 消费数量被高估, 导致 CPI 被高估
普遍 CPI 偏高。

CPI 和 PPI 都只衡量了部分商品, GDP 平减指数, 在衡量通货膨胀方面更加全面一些

注意 CPI 和 GDP 平减指数的算法是不同的
CPI=计算期/基期(加权基准), 称为拉氏指数
GDP 平减指数=计算期(加权基准)/基期, 称为帕氏指数

国民收入决定理论

收入-支出模型

凯恩斯定律：需求决定供给和和均衡产出, 一个经济社会的总产出是由需求决定的。
古典经济学萨伊定律：供给会创造自己的需求。

贝塞尔曲线

Wed, 09 Jul 2025 00:00:00 GMT

What is Bezier Curve

贝塞尔曲线是控制点按一定规则和比例插值得到的曲线。
他的几何意义下计算规则如下： $$ Given \left( \begin{aligned} p_{1} &= point_{1} \ p_{2} &= point_{2} \ distance &= (p_{2}-p_{1}) \ ratio &= \frac{percentage}{100} \end{aligned} \right), new \space point = p_{1}+distance\cdot ratio $$

Mathematics of Bezier Curve

贝塞尔曲线是一种"参数化"函数("parametric" function)。贝塞尔曲线是关于参数 $t$ 的多项式, 其中 $t \in [0,1]$。
我们定义一个杨辉三角(Pascal's triangle) 的打表： $$ \begin{aligned} \text{linear} &= 1+1 \ \text{squre} &= 1+2+1 \ \text{cubic} &= 1+3+3+1 \ \text{quartic} &= 1+4+6+4+1 \end{aligned} $$ 我们容易得到贝塞尔曲线在一阶, 二阶, 三阶的情况: $$ \begin{aligned} \text{linear} &= (1-t)+t \ \text{squre} &= (1-t)^2+2t(1-t)+t^2 \ \text{cubic} &= (1-t)^3+3t(1-t)^2+3t^2(1-t)+t^3 \ \end{aligned}

$$ 进一步, 可以得到 Bezier 的通用公式： $$ Bezier(n,t)= \sum^{n} \text{Pascal}(n,i)\cdot(1-t)^{n-i}\cdot t^i $$

Control Bezier Curvatures

在上面的公式上, 再添加 $\text{Weight}$ 就是带有控制点的贝塞尔曲线公式： $$ Bezier(n,t)= \sum^{n} \text{Pascal}(n,i)\cdot(1-t)^{n-i}\cdot t^i\cdot W_{i} $$ $\text{Weight}$ 是控制点的坐标值, $W_{0}$ 是起始坐标, $W_{n}$ 是终点坐标, 中间的 $W_{i}$ 就是贝塞尔曲线的控制点。

Bezier Curvatures as Matrix Operations

贝塞尔曲线能表示为矩阵形式, 特别地, 针对三次贝塞尔曲线, 可以表示为：

$$ B(t)=\begin{bmatrix} 1&t&t^2&t^3 \end{bmatrix} \cdot \begin{bmatrix} 1 & 0 & 0 & 0 \ -3 & 3 & 0 & 0 \ 3 & -6 & 3 & 0 \ -1 & 3 & -3 & 1 \end{bmatrix} \cdot \begin{bmatrix} p_{1} \
p_{2} \ p_{3} \ p_{4} \end{bmatrix} $$

de Casteljau's Algorithm

德卡斯特里奥算法 是计算伯恩斯坦形式的多项式或贝塞尔曲线的递归方法。
算法计算步骤如下：

取曲线定义点间的所有线段, 对于 $n$ 阶的曲线, 就是 $n$ 条线段。
沿每条线段 $t$ 位置放置标记。
连接这些标记点, 形成 $t-1$ 条线段。
在上述线段的 $t$ 位置再次放置标记。
连接这些标记点, 形成 $t-2$ 条线段。
递归上述流程。
最终只剩下一条线段, 得到比率 $t$ 下的曲线位置。

Split Curve

德卡斯特里奥算法可以实现贝塞尔曲线的分割。

Splite Curve using Matrices

对于任意三次贝塞尔曲线 $$

B(t)=\begin{bmatrix} 1&t&t^2&t^3 \end{bmatrix} \cdot \begin{bmatrix} 1 & 0 & 0 & 0 \ -3 & 3 & 0 & 0 \ 3 & -6 & 3 & 0 \ -1 & 3 & -3 & 1 \end{bmatrix} \cdot \begin{bmatrix} p_{1} \
p_{2} \ p_{3} \ p_{4} \end{bmatrix}

$$ 可以在 $t=z$ 处分割为两条贝塞尔曲线。

那么引入 $z$ 的左曲线矩阵为: $$ \begin{align*} B(t) &= \begin{bmatrix} 1 & (z \cdot t) & (z \cdot t)^2 & (z \cdot t)^3 \end{bmatrix} \cdot \begin{bmatrix} 1 & 0 & 0 & 0 \ -3 & 3 & 0 & 0 \ 3 & -6 & 3 & 0 \ -1 & 3 & -3 & 1 \end{bmatrix} \cdot \begin{bmatrix} P_1 \ P_2 \ P_3 \ P_4 \end{bmatrix} \ &= \begin{bmatrix} 1 & t & t^2 & t^3 \end{bmatrix} \cdot \begin{bmatrix} 1 & 0 & 0 & 0 \ 0 & z & 0 & 0 \ 0 & 0 & z^2 & 0 \ 0 & 0 & 0 & z^3 \end{bmatrix} \cdot \begin{bmatrix} 1 & 0 & 0 & 0 \ -3 & 3 & 0 & 0 \ 3 & -6 & 3 & 0 \ -1 & 3 & -3 & 1 \end{bmatrix} \cdot \begin{bmatrix} P_1 \ P_2 \ P_3 \ P_4 \end{bmatrix} \end{align*} $$ 如果这个矩阵表达式侧能被表达为 $[\text{t Values}]\cdot[\text{Bezier matrix}]\cdot[\text{column matrix}]$ 的形式, 那么就可以得到 $t=0$ 到 $t=z$ 的贝塞尔曲线矩阵。

简单起见, 推算过程以二次贝塞尔曲线矩阵为例：
首先, 我们定义三次贝塞尔矩阵为 $M$： $$ M= \begin{bmatrix} 1 & 0 & 0 & 0 \ -3 & 3 & 0 & 0 \ 3 & -6 & 3 & 0 \ -1 & 3 & -3 & 1 \end{bmatrix} $$

定义 $Z$ 矩阵 $$ \begin{bmatrix} 1 & 0 & 0 & 0 \ 0 & z & 0 & 0 \ 0 & 0 & z^2 & 0 \ 0 & 0 & 0 & z^3 \end{bmatrix} $$ 那么 $$ \begin{align*} B(t)&= \begin{bmatrix} 1 & t & t^2 & t^3 \end{bmatrix} \cdot \begin{bmatrix} 1 & 0 & 0 & 0 \ 0 & z & 0 & 0 \ 0 & 0 & z^2 & 0 \ 0 & 0 & 0 & z^3 \end{bmatrix} \cdot \begin{bmatrix} 1 & 0 & 0 & 0 \ -3 & 3 & 0 & 0 \ 3 & -6 & 3 & 0 \ -1 & 3 & -3 & 1 \end{bmatrix} \cdot \begin{bmatrix} P_1 \ P_2 \ P_3 \ P_4 \end{bmatrix} \ &= \begin{bmatrix} 1 & t & t^2 & t^3 \end{bmatrix} \cdot Z \cdot M \cdot \begin{bmatrix} 1 & 0 & 0 & 0 \ -3 & 3 & 0 & 0 \ 3 & -6 & 3 & 0 \ -1 & 3 & -3 & 1 \end{bmatrix} \ &= \begin{bmatrix} 1 & t & t^2 & t^3 \end{bmatrix} \cdot M\cdot M^{-1}\cdot Z \cdot M \begin{bmatrix} P_1 \ P_2 \ P_3 \ P_4 \end{bmatrix} \end{align*} $$

也就是说, 最后得到的点的仅需要乘以矩阵 $$ Q=M^{-1}\cdot Z \cdot M $$ 就得到了分割后矩阵的新的控制点。

另外, 这个算法是解析出来的, 针对我们常规的贝塞尔曲线解是唯一的(有理贝塞尔曲线会添加控制点影响度的参数, 解控制点的位置就不唯一)。

最后得到左曲线： $$

\begin{align*}

&\begin{bmatrix} 1 & 0 & 0 & 0 \ -(z-1) & z & 0 & 0 \ (z-1)^2 & -2 \cdot (z-1) \cdot z & z^2 & 0 \ -(z-1)^3 & 3 \cdot (z-1)^2 \cdot z & -3 \cdot (z-1) \cdot z^2 & z^3 \end{bmatrix} \begin{bmatrix} P_1 \ P_2 \ P_3 \ P_4 \end{bmatrix} \= &\begin{bmatrix} P_1 \ z \cdot P_2 - (z-1) \cdot P_1 \ z^2 \cdot P_3 - 2 \cdot z \cdot (z-1) \cdot P_2 + (z-1)^2 \cdot P_1 \ z^3 \cdot P_4 - 3 \cdot z^2 \cdot (z-1) \cdot P_3 + 3 \cdot z \cdot (z-1)^2 \cdot P_2 - (z-1)^3 \cdot P_1 \end{bmatrix} \end{align*}

$$ 得到右曲线： $$ \begin{align*}

&\begin{bmatrix} -(z-1)^3 & 3 \cdot (z-1)^2 \cdot z & -3 \cdot (z-1) \cdot z^2 & z^3 \ 0 & (z-1)^2 & -2 \cdot (z-1) \cdot z & z^2 \ 0 & 0 & -(z-1) & z \ 0 & 0 & 0 & 1 \end{bmatrix} \cdot \begin{bmatrix} P_1 \ P_2 \ P_3 \ P_4 \end{bmatrix} \= &\begin{bmatrix} z^3 \cdot P_4 - 3 \cdot z^2 \cdot (z-1) \cdot P_3 + 3 \cdot z \cdot (z-1)^2 \cdot P_2 - (z-1)^3 \cdot P_1 \ z^2 \cdot P_4 - 2 \cdot z \cdot (z-1) \cdot P_3 + (z-1)^2 \cdot P_2 \ z \cdot P_4 - (z-1) \cdot P_3 \ P_4 \end{bmatrix} \end{align*}

Possibility of Curve Segmentation

我们已经得到了贝塞尔曲线的分割的解析解, 现在需要考察的是, 在 $1/3$ 和 $2/3$ 处是否一定能找到对应的解析解。
也就是说, 矩阵方程 $$

\begin{align*} &\begin{bmatrix} x_1 \ z \cdot x_2 - (z-1) \cdot x_1 \ z^2 \cdot x_3 - 2 \cdot z \cdot (z-1) \cdot x_2 + (z-1)^2 \cdot x_1 \ x'{4}=z^3 \cdot x_4 - 3 \cdot z^2 \cdot (z-1) \cdot x_3 + 3 \cdot z \cdot (z-1)^2 \cdot x_2 - (z-1)^3 \cdot x_1 \end{bmatrix} \= &\begin{bmatrix} x_1 \ \frac{2}{3}x{1}+\frac{1}{3}x'{4} \ \frac{1}{3}x{1}+\frac{2}{3}x'{4} \ x'{4} \end{bmatrix} \end{align*}

$$ 尝试展开式子, 显然, 这个式子很容易看出是无解的。
所以得出结论, 用曲线分割的方式去得到 $1/3$ 和 $2/3$ 的固定三次贝塞尔贝塞尔表达任意三次贝塞尔曲线是没有解析解的。

Reference

A Primer on Bézier Curves
知乎 - 贝塞尔曲线
 贝塞尔曲线 - 维基百科，自由的百科全书
 De Casteljau's algorithm - Wikipedia

原附件：preview-9781483296999_A23889377.pdf（原仓库未包含此文件）。

导数

Mon, 16 Jun 2025 00:00:00 GMT

导数的几何含义

函数上某一点切线的斜率。

求导公式

幂函数求导公式 $$ \frac{d(x^n)}{dx}=nx^{n-1} $$ 三角函数 $$ \begin{align} \frac{d(\sin \theta)}{d\theta}=\cos \theta \ \frac{d(\cos \theta)}{d\theta}=-\sin \theta \end{align}

指数函数的导数和函数本身成正比 $$ d\left( \frac{e^{ct}}{dt} \right) = ce^{ct} $$ 同时, 考虑到 $$ e^{\ln x}=x $$ 这样, 可以得到 $$ \frac{d(x^t)}{dt}=\frac{d}{dt} e^{\ln(x)t}=\ln(x)e^{\ln (x)t} $$ 同样, 考虑函数 $$ \begin{align} y=\ln(x) \ e^y=x \ e^ydy=dx \ \frac{dy}{dx}=\frac{1}{e^y}=x \end{align} $$

链式求导法则和乘积法则

加法法则

和函数的导数是导数的和。

乘法法则

左乘右导, 右乘左导。 $$ \frac{d(f(x)g(x))}{dx}=f(x)\cdot \frac{dg(x)}{dx} + g(x) \cdot \frac{df(x)}{dx} $$

复合求导法则(链式法则)

$$ \frac{d}{dx}g(h(x))=\frac{dg}{dh}(h(x))\cdot \frac{dh}{dx}(x)=\frac{dg}{dh} \frac{dh}{dx} $$

隐函数求导

对于 $$ f(x)+g(y) = 0 $$ 可以看做 $$ h(x,y) = 0 $$ 这样, 左侧函数的微小变化需要等于右侧函数的微小变化 $$ f'(x)dx+g'(y)dy=0 $$ 就能自然得出 $\frac{dy}{dx}$ 或 $\frac{dx}{dy}$ 的值。

反函数求导

前向运动学和逆向运动学

Thu, 05 Jun 2025 00:00:00 GMT

Kinematics of a Chain

根据坐标转换公式线性代数基础 , 可以得到每个关节点在全局坐标下的表示。

同样对于任意的点, 也可以得到其在全局坐标系或任意局部坐标系下的坐标。

Types of Joints

IK

Tow Joint IK

Parameterization of Rotation

Wed, 04 Jun 2025 00:00:00 GMT

Parameterization of Rotation

Matrix

在线性代数基础中已经介绍过, 旋转矩阵是一个特殊的正交矩阵, 满足 $$ \begin{align} R^TR=I \ \det R = 1 \end{align} $$ 实际上, 旋转矩阵有6个变量都是由其他变量决定的。

旋转矩阵的实际自由度为3(degrees of freedom, DoF)。

旋转矩阵的优缺点

优点：
易于应用

缺点：
难以构造
难以插值

Euler Angle

定理：任何旋转都能表示为三个基本旋转的乘积。

欧拉角旋转可以延世界坐标系或者局部坐标系旋转, 均能够表达所有的旋转。

欧拉角的特性：

Rotation Vectors and Axis Angle

应用轴角：

轴角的优缺点：

Quaternions

基本性质：

四元数的乘法：

四元数的向量定义形式：

Unity Quaternion

对于单位四元数：

可以看做是四维空间上的一个单位球壳。

Rotation Representation of Quaternion

Combination of Quaternion

Interpolation of Quaternion

Nlerp

四元数仅做线性插值得到的结果不是一个能作为旋转表示的四元数(单位四元数)。需要在插值之后再进行单位化。

Slerp

优缺点

线性代数基础

Wed, 28 May 2025 00:00:00 GMT

Vector

Vector Representation

$$ \vec{a} = (a_{1}, a_{2},\dots,a_{3})^T=\begin{bmatrix} a_{1}\ a_{2} \ \vdots \ a_{n} \end{bmatrix} $$

$$ ||\vec{a}||=\sqrt{ a_{x}^2+a_{y}^2+a_{z}^2 } $$

Dot product

$$ \vec{a}\cdot\vec{b}=a_{1}b_{1}+a_{2}b_{2}+\cdots +a_{n}b_{n} $$

In Eucidean Space，
$$\vec{a}\cdot\vec{b}=||\vec{a}||\space||\vec{b}||\cos \theta$$

Cross product

$$ \vec{a} \times \vec{b} = ||\vec{a}|| ||\vec{b}|| \sin (\theta) \vec{n} $$ 注意, 叉积满足反交换律： $$ \vec{a} \times \vec{b} = -\vec{b} \times \vec{a} $$ 叉乘不满足结合律。

How to find the rotation between vector

Dodrigues's Rotation Formula

Dodrigues’ Rotation Fomula: $$ \vec{b}=\vec{a}+(\sin \theta)\vec{u} \times \vec{a}+(1-\cos \theta)\vec{u}\times (\vec{u}\times \vec{a}) $$ 注意, 旋转方向的正负由左右手轴决定。针对左右手轴, 公式都是一致的。

同时这个公式也可以写成矩阵的形式(见 Matrix Form of Cross Product)。

Orthogonal Coordinate

对于满足下面要求的轴满足右手系： $$ \begin{split} ||e_{x}||=||e_{y}||=||e_{z}||=1 \ e_{x}\cdot e_{y}=e_{y}\cdot e_{z}=e_{z}\cdot e_{x}=0 \ e_{x}\times e_{y}=e_{z} \ e_{y}\times e_{z}=e_{x} \ e_{z}\times e_{x}=e_{y} \end{split}

$$ 这样可以得出以下的结论： $$ \begin{align} \vec{a}\cdot \vec{b}= a_{x}b_{x}+a_{y}b_{y}+a_{z}b_{z} \ \vec{a} \times \vec{b} = (a_{y}b_{z}-a_{z}b_{y}, a_{z}b_{x}-a_{x}b_{z},a_{x}b_{y}-a_{y}b_{z}) \end{align} $$

Matrix

Matrix Operation

Matrix Form of Dot Produnct

Matrix Form of Cross Product

叉乘可以表达为一个反对称阵的形式：

叉乘也可以用行列式进行表示：

叉乘满足下面的一些性质：

Orthogonal Matrix

如果矩阵的列向量互相正交，且长度为1，那么该矩阵称之为标准正交矩阵，不要求矩阵满秩。
如果满秩，即 $Q$ 是方阵，称之为正交矩阵(Orthogonal Matrix)。标准正交矩阵有很多好的性质：

$Q^TQ=I$
$Qx$ 不改变 $x$ 的长度。$|Qx|^2=(Qx)^TQx=x^TQ^TQx=x^Tx=|x|^2$
$Q$ 不改变向量点积。$Qx\cdot Qy=(Qx)^TQy=x^TQ^TQy=x^Ty$
如果 $Q$ 是方阵, $Q^TQ=QQ^T=I\implies Q^T=Q^{-1}$

Determinant of a Matrix

行列式的性质： $$ \begin{align} \det I = 1 \ \det AB = \det A*\det B \ \det A^{T}= \det A \ if \ A \ is \ invertible, \det A^{-1} = (\det A)^{-1} \ if \ U \ is \ orthogonal, \det U = \pm 1 \end{align} $$

Eigenvalues and Eigenvetors

对于矩阵 $A$, 存在一个非零向量 $x$ 满足： $$ Ax=\lambda x $$ 则称 $\lambda$ 为 $A$ 的特征值, $x$ 为 $A$ 的特征向量。

特别地, 对于 $3\times {3}$ 的正交矩阵 $U$, 它至少有一个特征值 $\lambda=\det U=\pm {1}$

Rigid Transformation

Scaling

Rotation

向量 $a$ 经过旋转得到 $a'$, 对于 $a'=Ra$, 则称 $R$ 是 $a\implies a'$ 的旋转矩阵。

旋转矩阵是一个正交矩阵, 满足一些性质： $$ \begin{align} R^{-1}=R^{T} \ R^{T}R = RR^{T} = I \ \det R = +1 \ ||Rx||=||x|| \end{align}

Combination of Rotations

Rotation around Coordinate Axes

Rotation Axis and Angle

旋转矩阵始终有一个特征值 $+1$。

也就是存在一个特征向量 $Ru=u$。

这样, 旋转矩阵 $R$ 可以看做是 $a$ 绕轴 $u$ 旋转 $\theta$ 角度。

这样反对称矩阵可以和叉乘建立关系(见线性代数基础)

这样 $u'$ 和 $u$ 是平行的, 对 $u'$ 进行标准化后就能得到旋转轴 $u$。

同时根据线性代数基础可以计算得出旋转角 $\theta$

View of Rotation

对于原点相同的正交基, 可以看做 $object$ 的正交基是由 $global$ 的正交基旋转 $R$ 得到的。
也就是说旋转矩阵给出了从局部坐标系到全局坐标系的转换公式。

加上位移后就是上图所示的坐标变换公式。

蒙皮和BS的Compute Shader参考

Tue, 27 May 2025 00:00:00 GMT

Unity 的蒙皮和 Bs 的 ComputeShader 的一种实现的参考。

Unity-Built-in-Shaders/DefaultResources/Internal-BlendShape.compute at master · TwoTailsGames/Unity-Built-in-Shaders · GitHub

// Unity built-in shader source. Copyright (c) 2016 Unity Technologies. MIT license (see license.txt)

#pragma kernel main
#pragma kernel main SKIN_NORM
#pragma kernel main SKIN_NORM SKIN_TANG

#include "HLSLSupport.cginc"
#include "Internal-Skinning-Util.cginc"

struct BlendShapeVertex
{
    int index;
    float3 pos;
    float3 norm;
    float3 tang;
};

uint g_FirstVert; // First vertex from blend shape buffer to use
uint g_VertCount; // Sparse vertex count, not the full amount of vertices in mesh
float g_Weight;

[numthreads(64, 1, 1)]
void main(uint3 threadID : SV_DispatchThreadID, SAMPLER_UNIFORM RWStructuredBuffer<MeshVertex> inOutMeshVertices, SAMPLER_UNIFORM StructuredBuffer<BlendShapeVertex> inBlendShapeVertices)
{
    const uint t = threadID.x;

    if (t >= g_VertCount)
    {
        return;
    }

    BlendShapeVertex blendShapeVert = inBlendShapeVertices[t + g_FirstVert];

    const uint vertIndex = blendShapeVert.index;

    inOutMeshVertices[vertIndex].pos += blendShapeVert.pos * g_Weight;
#if SKIN_NORM
    inOutMeshVertices[vertIndex].norm += blendShapeVert.norm * g_Weight;
#endif
#if SKIN_TANG
    inOutMeshVertices[vertIndex].tang.xyz += blendShapeVert.tang * g_Weight;
#endif
}

Unity-Built-in-Shaders/DefaultResources/Internal-Skinning.compute at master · TwoTailsGames/Unity-Built-in-Shaders · GitHub

// Unity built-in shader source. Copyright (c) 2016 Unity Technologies. MIT license (see license.txt)

// Generic compute skinning ... with pos, norm, and tangent skinning

#pragma kernel main SKIN_BONESFORVERT=0
#pragma kernel main SKIN_BONESFORVERT=0 SKIN_NORM
#pragma kernel main SKIN_BONESFORVERT=0 SKIN_TANG
#pragma kernel main SKIN_BONESFORVERT=0 SKIN_NORM SKIN_TANG
#pragma kernel main SKIN_BONESFORVERT=1
#pragma kernel main SKIN_BONESFORVERT=1 SKIN_NORM
#pragma kernel main SKIN_BONESFORVERT=1 SKIN_TANG
#pragma kernel main SKIN_BONESFORVERT=1 SKIN_NORM SKIN_TANG
#pragma kernel main SKIN_BONESFORVERT=2
#pragma kernel main SKIN_BONESFORVERT=2 SKIN_NORM
#pragma kernel main SKIN_BONESFORVERT=2 SKIN_TANG
#pragma kernel main SKIN_BONESFORVERT=2 SKIN_NORM SKIN_TANG
#pragma kernel main SKIN_BONESFORVERT=4
#pragma kernel main SKIN_BONESFORVERT=4 SKIN_NORM
#pragma kernel main SKIN_BONESFORVERT=4 SKIN_TANG
#pragma kernel main SKIN_BONESFORVERT=4 SKIN_NORM SKIN_TANG

#include "HLSLSupport.cginc"

uint g_VertCount;

#if defined(SHADER_API_D3D11) || defined(SHADER_API_XBOXONE) || defined(SHADER_API_PS4) || defined(SHADER_API_GLCORE) || defined(SHADER_API_GLES3) || defined(SHADER_API_VULKAN) || defined(SHADER_API_METAL) || defined(SHADER_API_PSSL) || defined(SHADER_API_SWITCH)
#define STRUCTURED_BUFFER_SUPPORT 1
#else
#define STRUCTURED_BUFFER_SUPPORT 0
#endif

struct MeshVertex
{
    float3 pos;
#if SKIN_NORM
    float3 norm;
#endif
#if SKIN_TANG
    float4 tang;
#endif
};

struct SkinInfluence
{
#if SKIN_BONESFORVERT <= 1
    int index0;
#elif SKIN_BONESFORVERT == 2
    float weight0, weight1;
    int index0, index1;
#elif SKIN_BONESFORVERT == 4
    float weight0, weight1, weight2, weight3;
    int index0, index1, index2, index3;
#endif
};

#if SKIN_NORM && SKIN_TANG
#define VERTEX_STRIDE 10
#elif SKIN_NORM
#define VERTEX_STRIDE 6
#else
#define VERTEX_STRIDE 3
#endif


#if !STRUCTURED_BUFFER_SUPPORT
MeshVertex FetchVert(SAMPLER_UNIFORM Buffer<float> vertices, const uint index, const uint stride)
{
    MeshVertex vert;

    uint offset = index * stride;
    vert.pos.x = vertices[offset++];
    vert.pos.y = vertices[offset++];
    vert.pos.z = vertices[offset++];

#if SKIN_NORM
    vert.norm.x = vertices[offset++];
    vert.norm.y = vertices[offset++];
    vert.norm.z = vertices[offset++];
#endif

#if SKIN_TANG
    vert.tang.x = vertices[offset++];
    vert.tang.y = vertices[offset++];
    vert.tang.z = vertices[offset++];
    vert.tang.w = vertices[offset++];
#endif

    return vert;
}

void StoreVert(SAMPLER_UNIFORM RWBuffer<float> vertices, float3 pos, float3 normal, float4 tang, const uint index, const uint stride)
{
    uint offset = index * stride;
    vertices[offset++] = pos.x;
    vertices[offset++] = pos.y;
    vertices[offset++] = pos.z;

#if SKIN_NORM
    vertices[offset++] = normal.x;
    vertices[offset++] = normal.y;
    vertices[offset++] = normal.z;
#endif

#if SKIN_TANG
    vertices[offset++] = tang.x;
    vertices[offset++] = tang.y;
    vertices[offset++] = tang.z;
    vertices[offset++] = tang.w;
#endif
}

#endif


[numthreads(64, 1, 1)]
#if !STRUCTURED_BUFFER_SUPPORT
void main(uint3 threadID : SV_DispatchThreadID, SAMPLER_UNIFORM Buffer<float> inVertices, SAMPLER_UNIFORM StructuredBuffer<SkinInfluence> inSkin, SAMPLER_UNIFORM RWBuffer<float> outVertices, SAMPLER_UNIFORM StructuredBuffer<float4x4> inMatrices)
#else
void main(uint3 threadID : SV_DispatchThreadID, SAMPLER_UNIFORM StructuredBuffer<MeshVertex> inVertices, SAMPLER_UNIFORM StructuredBuffer<SkinInfluence> inSkin, SAMPLER_UNIFORM RWStructuredBuffer<MeshVertex> outVertices, SAMPLER_UNIFORM StructuredBuffer<float4x4> inMatrices)
#endif
{
    const uint t = threadID.x;

    if (t >= g_VertCount)
    {
        return;
    }

#if !STRUCTURED_BUFFER_SUPPORT
    const MeshVertex vert = FetchVert(inVertices, t, VERTEX_STRIDE);
#else
    const MeshVertex vert = inVertices[t];
#endif
    SkinInfluence si = inSkin[t];

    float3 vPos = vert.pos.xyz;
#if SKIN_NORM
    float3 vNorm = vert.norm.xyz;
#endif
#if SKIN_TANG
    float3 vTang = vert.tang.xyz;
#endif

    float3 oPos = float3(0, 0, 0);
    float3 oNorm = float3(0, 0, 0);
    float4 oTang = float4(0, 0, 0, 0);

#if SKIN_BONESFORVERT == 0
    uint startIndex = si.index0;
    uint endIndex = inSkin[t + 1].index0;
    float4x4 blendedMatrix = 0;
    for (uint i = startIndex; i < endIndex; i++)
    {
        uint weightAndIndex = inSkin[i].index0;
        float weight = float(weightAndIndex >> 16) * (1.0f / 65535.0f);
        uint index = weightAndIndex & 0xFFFF;
        blendedMatrix += inMatrices[index] * weight;
    }
#elif SKIN_BONESFORVERT == 1
    const float4x4 blendedMatrix = inMatrices[si.index0];
#elif SKIN_BONESFORVERT == 2
    const float4x4 blendedMatrix = inMatrices[si.index0] * si.weight0 +
                                   inMatrices[si.index1] * si.weight1;
#elif SKIN_BONESFORVERT == 4
    const float4x4 blendedMatrix = inMatrices[si.index0] * si.weight0 +
                                   inMatrices[si.index1] * si.weight1 +
                                   inMatrices[si.index2] * si.weight2 +
                                   inMatrices[si.index3] * si.weight3;
#endif

    oPos = mul(blendedMatrix, float4(vPos, 1)).xyz;

#if SKIN_NORM
    oNorm = mul(blendedMatrix, float4(vNorm, 0)).xyz;
#endif

#if SKIN_TANG
    oTang.xyz = mul(blendedMatrix, float4(vTang, 0)).xyz;
    oTang.w = vert.tang.w;
#endif

#if STRUCTURED_BUFFER_SUPPORT
    outVertices[t].pos = oPos;
#if SKIN_NORM
    outVertices[t].norm = oNorm;
#endif
#if SKIN_TANG
    outVertices[t].tang = oTang;
#endif
#else
    StoreVert(outVertices, oPos, oNorm, oTang, t, VERTEX_STRIDE);
#endif
}

UE 5.5.4 SkeletalRenderCPUSkin 源码深度解析

Tue, 27 May 2025 00:00:00 GMT

UE 5.5.4 SkeletalRenderCPUSkin 源码深度解析

UE 5.5.4 SkeletalRenderCPUSkin 源码深度解析

基于您提供的真实源码，我来详细分析 UE 5.5.4中 CPU 蒙皮系统的实际实现原理。

核心架构分析

1. 主要类结构

// 主要的CPU蒙皮对象
class FSkeletalMeshObjectCPUSkin : public FSkeletalMeshObject
{
    // LOD数据数组
    TArray<FSkeletalMeshObjectLOD> LODs;
    
    // 动态数据指针
    FDynamicSkelMeshObjectDataCPUSkin* DynamicData;
    
    // 缓存的顶点数据
    mutable TArray<FFinalSkinVertex> CachedFinalVertices;
    mutable int32 CachedVertexLOD;
    
    // 调试渲染相关
    bool bRenderOverlayMaterial;
    TArray<int32> BonesOfInterest;
    TArray<UMorphTarget*> MorphTargetOfInterest;
};

// LOD级别的数据管理
struct FSkeletalMeshObjectLOD
{
    // 顶点缓冲区
    FPositionVertexBuffer PositionVertexBuffer;
    FStaticMeshVertexBuffer StaticMeshVertexBuffer;
    
    // 顶点工厂
    FLocalVertexFactory VertexFactory;
    
    // 权重和颜色缓冲区指针
    FSkinWeightVertexBuffer* MeshObjectWeightBuffer;
    FColorVertexBuffer* MeshObjectColorBuffer;
    
    // 射线追踪支持
    #if RHI_RAYTRACING
    FRayTracingGeometry RayTracingGeometry;
    #endif
};

2. 动态数据结构

class FDynamicSkelMeshObjectDataCPUSkin
{
public:
    int32 LODIndex;                                    // 当前LOD级别
    FMorphTargetWeightMap ActiveMorphTargets;          // 活跃的Morph Target
    TArray<float> MorphTargetWeights;                  // Morph Target权重
    TArray<FMatrix44f> ReferenceToLocal;               // 骨骼变换矩阵
    
    // 布料模拟相关
    TMap<int32, FClothSimulData> ClothSimulUpdateData; // 布料模拟数据
    float ClothBlendWeight;                            // 布料混合权重
    FMatrix WorldToLocal;                              // 世界到局部空间变换
    
    #if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
    TArray<FTransform> MeshComponentSpaceTransforms;   // 组件空间变换（调试用）
    #endif
};

主要更新流程

1. Update 函数 - 主线程调用

void FSkeletalMeshObjectCPUSkin::Update(
    int32 LODIndex,
    USkinnedMeshComponent* InMeshComponent,
    const FMorphTargetWeightMap& InActiveMorphTargets,
    const TArray<float>& InMorphTargetWeights,
    EPreviousBoneTransformUpdateMode PreviousBoneTransformUpdateMode,
    const FExternalMorphWeightData& InExternalMorphWeightData)
{
    if (InMeshComponent)
    {
        // 创建新的动态数据
        FDynamicSkelMeshObjectDataCPUSkin* NewDynamicData = 
            new FDynamicSkelMeshObjectDataCPUSkin(
                InMeshComponent, SkeletalMeshRenderData, LODIndex, 
                InActiveMorphTargets, InMorphTargetWeights);

        uint64 FrameNumberToPrepare = GFrameCounter;
        uint32 RevisionNumber = 0;

        if (InMeshComponent->SceneProxy)
        {
            RevisionNumber = InMeshComponent->GetBoneTransformRevisionNumber();
        }

        // 提交渲染命令到特定的渲染管道
        FSkeletalMeshObjectCPUSkin* MeshObject = this;
        ENQUEUE_RENDER_COMMAND(SkelMeshObjectUpdateDataCommand)(
            UE::RenderCommandPipe::SkeletalMesh,
            [MeshObject, FrameNumberToPrepare, RevisionNumber, NewDynamicData]
            (FRHICommandList& RHICmdList)
            {
                FScopeCycleCounter Context(MeshObject->GetStatId());
                MeshObject->UpdateDynamicData_RenderThread(
                    RHICmdList, NewDynamicData, FrameNumberToPrepare, RevisionNumber);
            }
        );
    }
}

2. UpdateDynamicData_RenderThread - 渲染线程执行

void FSkeletalMeshObjectCPUSkin::UpdateDynamicData_RenderThread(
    FRHICommandList& RHICmdList, 
    FDynamicSkelMeshObjectDataCPUSkin* InDynamicData, 
    uint64 FrameNumberToPrepare, 
    uint32 RevisionNumber)
{
    // 删除旧数据，更新新数据
    delete DynamicData;
    DynamicData = InDynamicData; 
    check(DynamicData);

    // 执行顶点缓存更新
    CacheVertices(DynamicData->LODIndex, true, RHICmdList);
}

核心蒙皮算法实现

1. CacheVertices - 顶点缓存核心函数

void FSkeletalMeshObjectCPUSkin::CacheVertices(int32 LODIndex, bool bForce, FRHICommandList& RHICmdList) const
{
    SCOPE_CYCLE_COUNTER(STAT_CPUSkinUpdateRTTime);
    check(IsInParallelRenderingThread());

    FSkeletalMeshLODRenderData& LOD = SkeletalMeshRenderData->LODRenderData[LODIndex];
    const FSkeletalMeshObjectLOD& MeshLOD = LODs[LODIndex];

    // 只在LOD变化或强制更新时重新计算
    if ((LODIndex != CachedVertexLOD || bForce) &&
        DynamicData && 
        MeshLOD.StaticMeshVertexBuffer.IsValid())
    {
        // 获取骨骼变换矩阵
        FMatrix44f* ReferenceToLocal = DynamicData->ReferenceToLocal.GetData();

        int32 CachedFinalVerticesNum = LOD.GetNumVertices();
        CachedFinalVertices.Empty(CachedFinalVerticesNum);
        CachedFinalVertices.AddUninitialized(CachedFinalVerticesNum);

        FFinalSkinVertex* DestVertex = CachedFinalVertices.GetData();

        if (DestVertex)
        {
            check(GIsEditor || LOD.StaticVertexBuffers.StaticMeshVertexBuffer.GetAllowCPUAccess());
            SCOPE_CYCLE_COUNTER(STAT_SkinningTime);

            // 根据UV精度选择不同的蒙皮路径
            if (LOD.StaticVertexBuffers.StaticMeshVertexBuffer.GetUseFullPrecisionUVs())
            {
                SKIN_LOD_VERTICES(TGPUSkinVertexFloat32Uvs, 
                    LOD.StaticVertexBuffers.StaticMeshVertexBuffer.GetNumTexCoords());
            }
            else
            {
                SKIN_LOD_VERTICES(TGPUSkinVertexFloat16Uvs, 
                    LOD.StaticVertexBuffers.StaticMeshVertexBuffer.GetNumTexCoords());
            }

            // 处理调试渲染（骨骼权重或Morph Target可视化）
            if (bRenderOverlayMaterial)
            {
                if (MorphTargetOfInterest.Num() > 0)
                {
                    CalculateMorphTargetWeights(DestVertex, LOD, LODIndex, MorphTargetOfInterest);
                }
                else
                {
                    CalculateBoneWeights(DestVertex, LOD, *MeshLOD.MeshObjectWeightBuffer, BonesOfInterest);
                }
            }
        }

        CachedVertexLOD = LODIndex;
        
        // 将计算结果写入GPU缓冲区
        UpdateGPUBuffers(LOD, MeshLOD, RHICmdList);
    }
}

2. SKIN_LOD_VERTICES 宏展开

#define SKIN_LOD_VERTICES(VertexType, NumUVs) \
{\
    switch(NumUVs)\
    {\
        case 1:\
            SkinVertices<VertexType<1>, 1>(DestVertex, ReferenceToLocal, /*...*/);\
            break;\
        case 2:\
            SkinVertices<VertexType<2>, 2>(DestVertex, ReferenceToLocal, /*...*/);\
            break;\
        case 3:\
            SkinVertices<VertexType<3>, 3>(DestVertex, ReferenceToLocal, /*...*/);\
            break;\
        case 4:\
            SkinVertices<VertexType<4>, 4>(DestVertex, ReferenceToLocal, /*...*/);\
            break;\
        default:\
            checkf(false, TEXT("Invalid number of UV sets. Must be between 1 and 4"));\
            break;\
    }\
}

高度优化的蒙皮核心算法

1. SkinVertices 模板函数

template<typename VertexType, int32 NumberOfUVs>
static void SkinVertices(
    FFinalSkinVertex* DestVertex, 
    FMatrix44f* ReferenceToLocal, 
    int32 LODIndex, 
    FSkeletalMeshLODRenderData& LOD,
    FSkinWeightVertexBuffer& WeightBuffer,
    const FMorphTargetWeightMap& InActiveMorphTargets, 
    const TArray<float>& MorphTargetWeights, 
    const TMap<int32, FClothSimulData>& ClothSimulUpdateData, 
    float ClothBlendWeight, 
    const FMatrix& WorldToLocal,
    const FVector& WorldScale)
{
    // 设置SIMD寄存器控制
    uint32 StatusRegister = VectorGetControlRegister();
    VectorSetControlRegister(StatusRegister | VECTOR_ROUND_TOWARD_ZERO);

    // 初始化Morph Target评估信息
    TArray<FMorphTargetInfo> MorphEvalInfos;
    uint32 NumValidMorphs = InitEvalInfos(InActiveMorphTargets, MorphTargetWeights, 
                                         LODIndex, MorphEvalInfos);

    // 预取骨骼矩阵到缓存
    const uint32 MaxGPUSkinBones = FGPUBaseSkinVertexFactory::GetMaxGPUSkinBones();
    for (uint32 MatrixIndex = 0; MatrixIndex < MaxGPUSkinBones; MatrixIndex += 2)
    {
        FPlatformMisc::Prefetch(ReferenceToLocal + MatrixIndex);
    }

    int32 CurBaseVertIdx = 0;
    int32 VertexBufferBaseIndex = 0;
    const FVector WorldScaleAbs = WorldScale.GetAbs();

    // 按Section处理顶点
    for(int32 SectionIndex = 0; SectionIndex < LOD.RenderSections.Num(); SectionIndex++)
    {
        FSkelMeshRenderSection& Section = LOD.RenderSections[SectionIndex];
        const FClothSimulData* ClothSimData = ClothSimulUpdateData.Find(Section.CorrespondClothAssetIndex);

        SkinVertexSection<VertexType, NumberOfUVs>(
            DestVertex, MorphEvalInfos, MorphTargetWeights, Section, LOD, WeightBuffer, 
            VertexBufferBaseIndex, NumValidMorphs, CurBaseVertIdx, LODIndex, 
            ReferenceToLocal, ClothSimData, ClothBlendWeight, WorldToLocal, WorldScaleAbs);
    }

    // 恢复SIMD寄存器状态
    VectorSetControlRegister(StatusRegister);
}

2. SkinVertexSection - SIMD 优化的蒙皮计算

template<typename VertexType, int32 NumberOfUVs>
static void SkinVertexSection(/* 参数列表 */)
{
    static constexpr VectorRegister VECTOR_INV_65535 = 
        MakeVectorRegisterDoubleConstant(1.0/65535, 1.0/65535, 1.0/65535, 1.0/65535);
    
    VertexType VertexCopy; // Morph Target处理用的临时顶点

    // 预取骨骼映射数据
    const FBoneIndexType* BoneMap = Section.BoneMap.GetData();
    FPlatformMisc::Prefetch(BoneMap);
    FPlatformMisc::Prefetch(BoneMap, PLATFORM_CACHE_LINE_SIZE);

    const int32 MaxSectionBoneInfluences = WeightBuffer.GetMaxBoneInfluences();
    const bool bLODUsesCloth = LOD.HasClothData() && ClothSimData != nullptr && ClothBlendWeight > 0.0f;
    const int32 NumSoftVertices = Section.GetNumVertices();
    
    if (NumSoftVertices > 0)
    {
        INC_DWORD_STAT_BY(STAT_CPUSkinVertices, NumSoftVertices);
        
        // 逐顶点处理
        for(int32 VertexIndex = VertexBufferBaseIndex; VertexIndex < NumSoftVertices; 
            VertexIndex++, DestVertex++)
        {
            const int32 VertexBufferIndex = Section.GetVertexBufferIndex() + VertexIndex;

            // 加载源顶点数据
            VertexType SrcSoftVertex;
            const FVector& VertexPosition = (FVector)LOD.StaticVertexBuffers.PositionVertexBuffer.VertexPosition(VertexBufferIndex);
            FPlatformMisc::Prefetch(&VertexPosition, PLATFORM_CACHE_LINE_SIZE);
            
            SrcSoftVertex.Position = (FVector3f)VertexPosition;
            SrcSoftVertex.TangentX = LOD.StaticVertexBuffers.StaticMeshVertexBuffer.VertexTangentX(VertexBufferIndex);
            SrcSoftVertex.TangentZ = LOD.StaticVertexBuffers.StaticMeshVertexBuffer.VertexTangentZ(VertexBufferIndex);
            
            // 加载UV坐标
            for (uint32 j = 0; j < VertexType::NumTexCoords; j++)
            {
                SrcSoftVertex.UVs[j] = LOD.StaticVertexBuffers.StaticMeshVertexBuffer.GetVertexUV_Typed<VertexType::StaticMeshVertexUVType>(VertexBufferIndex, j);
            }

            // 处理Morph Target
            VertexType* MorphedVertex = &SrcSoftVertex;
            if(NumValidMorphs) 
            {
                MorphedVertex = &VertexCopy;
                UpdateMorphedVertex<VertexType>(*MorphedVertex, SrcSoftVertex, CurBaseVertIdx, LODIndex, MorphEvalInfos, MorphTargetWeights);
            }

            // 获取蒙皮权重
            FSkinWeightInfo SrcWeights = WeightBuffer.GetVertexSkinWeights(VertexBufferIndex);
            
            // 执行SIMD优化的蒙皮计算
            PerformSIMDSkinning(MorphedVertex, SrcWeights, BoneMap, ReferenceToLocal, 
                               MaxSectionBoneInfluences, DestVertex);

            // 处理布料模拟
            ProcessClothSimulation(VertexIndex, ClothVertData, ClothSimData, 
                                 ClothBlendWeight, WorldToLocal, WorldScaleAbs, DestVertex);

            // 复制UV坐标
            CopyUVCoordinates(VertexIndex, Section, LOD, NumberOfUVs, DestVertex);

            CurBaseVertIdx++;
        }
    }
}

3. SIMD 优化的蒙皮矩阵计算

// 核心的SIMD蒙皮计算（简化版）
void PerformSIMDSkinning(/* 参数 */)
{
    const FBoneIndexType* RESTRICT BoneIndices = SrcWeights.InfluenceBones;
    const uint16* RESTRICT BoneWeights = SrcWeights.InfluenceWeights;

    // 将顶点数据加载到SIMD寄存器
    static VectorRegister SrcNormals[3];
    VectorRegister DstNormals[3];
    SrcNormals[0] = VectorLoadFloat3_W1(&MorphedVertex->Position);
    SrcNormals[1] = Unpack3(&MorphedVertex->TangentX.Vector.Packed);
    SrcNormals[2] = Unpack4(&MorphedVertex->TangentZ.Vector.Packed);
    
    // 权重归一化（从uint16转换为float）
    VectorRegister Weights = VectorMultiply(VectorLoadURGBA16N(BoneWeights), VECTOR_INV_65535);
    VectorRegister ExtraWeights = MakeVectorRegister(0.f, 0.f, 0.f, 0.f);
    VectorRegister ExtraWeights2 = MakeVectorRegister(0.f, 0.f, 0.f, 0.f);
    
    // 处理超过4个骨骼影响的情况
    if (MaxSectionBoneInfluences > 4)
    {
        ExtraWeights = VectorMultiply(VectorLoadURGBA16N(&BoneWeights[MAX_INFLUENCES_PER_STREAM]), VECTOR_INV_65535);
    }
    if (MaxSectionBoneInfluences > 8)
    {
        ExtraWeights2 = VectorMultiply(VectorLoadURGBA16N(&BoneWeights[EXTRA_BONE_INFLUENCES]), VECTOR_INV_65535);
    }
    
    VectorResetFloatRegisters();

    // 累积骨骼变换（支持最多12个骨骼影响）
    const FMatrix44f BoneMatrix0 = ReferenceToLocal[BoneMap[BoneIndices[INFLUENCE_0]]];
    VectorRegister Weight0 = VectorReplicate(Weights, INFLUENCE_0);
    VectorRegister M00 = VectorMultiply(VectorLoadAligned(&BoneMatrix0.M[0][0]), Weight0);
    VectorRegister M10 = VectorMultiply(VectorLoadAligned(&BoneMatrix0.M[1][0]), Weight0);
    VectorRegister M20 = VectorMultiply(VectorLoadAligned(&BoneMatrix0.M[2][0]), Weight0);
    VectorRegister M30 = VectorMultiply(VectorLoadAligned(&BoneMatrix0.M[3][0]), Weight0);

    // 展开循环处理其他骨骼影响（源码中有完整的if-else嵌套结构）
    if (MaxSectionBoneInfluences > 1)
    {
        const FMatrix44f BoneMatrix1 = ReferenceToLocal[BoneMap[BoneIndices[INFLUENCE_1]]];
        VectorRegister Weight1 = VectorReplicate(Weights, INFLUENCE_1);
        M00 = VectorMultiplyAdd(VectorLoadAligned(&BoneMatrix1.M[0][0]), Weight1, M00);
        M10 = VectorMultiplyAdd(VectorLoadAligned(&BoneMatrix1.M[1][0]), Weight1, M10);
        M20 = VectorMultiplyAdd(VectorLoadAligned(&BoneMatrix1.M[2][0]), Weight1, M20);
        M30 = VectorMultiplyAdd(VectorLoadAligned(&BoneMatrix1.M[3][0]), Weight1, M30);
        
        // ... 继续处理其他骨骼 (源码支持最多12个骨骼)
    }

    // 应用变换到顶点属性
    VectorRegister N_xxxx = VectorReplicate(SrcNormals[0], 0);
    VectorRegister N_yyyy = VectorReplicate(SrcNormals[0], 1);
    VectorRegister N_zzzz = VectorReplicate(SrcNormals[0], 2);
    DstNormals[0] = VectorMultiplyAdd(N_xxxx, M00, 
                    VectorMultiplyAdd(N_yyyy, M10, 
                    VectorMultiplyAdd(N_zzzz, M20, M30)));

    // 处理切线和法线
    N_xxxx = VectorReplicate(SrcNormals[1], 0);
    N_yyyy = VectorReplicate(SrcNormals[1], 1);
    N_zzzz = VectorReplicate(SrcNormals[1], 2);
    DstNormals[1] = VectorNormalize(VectorMultiplyAdd(N_xxxx, M00, 
                    VectorMultiplyAdd(N_yyyy, M10, VectorMultiply(N_zzzz, M20))));

    N_xxxx = VectorReplicate(SrcNormals[2], 0);
    N_yyyy = VectorReplicate(SrcNormals[2], 1);
    N_zzzz = VectorReplicate(SrcNormals[2], 2);
    DstNormals[2] = VectorNormalize(VectorMultiplyAdd(N_xxxx, M00, 
                    VectorMultiplyAdd(N_yyyy, M10, VectorMultiply(N_zzzz, M20))));

    // 保持W分量（基向量的行列式符号）
    DstNormals[2] = VectorMultiplyAdd(VECTOR_0001, SrcNormals[2], DstNormals[2]);

    // 写入内存
    VectorStoreFloat3(DstNormals[0], &DestVertex->Position);
    Pack3(DstNormals[1], &DestVertex->TangentX.Vector.Packed);
    Pack4(DstNormals[2], &DestVertex->TangentZ.Vector.Packed);
    VectorResetFloatRegisters();
}

Morph Target 处理系统

1. Morph Target 信息结构

struct FMorphTargetInfo
{
    int32 WeightIndex = INDEX_NONE;     // 权重列表中的索引
    int32 NextDeltaIndex = INDEX_NONE;  // 下一个要应用的Delta索引
    const FMorphTargetDelta* Deltas = nullptr;  // Delta数组
    int32 NumDeltas = 0;                // Delta数量
};

// 初始化Morph Target评估信息
static uint32 InitEvalInfos(const FMorphTargetWeightMap& InActiveMorphTargets, 
                           const TArray<float>& MorphTargetWeights, 
                           int32 LODIndex, 
                           TArray<FMorphTargetInfo>& OutEvalInfos)
{
    uint32 NumValidMorphTargets = 0;
    const float MorphTargetMaxBlendWeight = UE::SkeletalRender::Settings::GetMorphTargetMaxBlendWeight();

    for(const TTuple<const UMorphTarget*, int32>& MorphItem : InActiveMorphTargets)
    {
        FMorphTargetInfo NewInfo;
        const UMorphTarget* MorphTarget = MorphItem.Key;
        const int32 WeightIndex = MorphItem.Value;

        const float ActiveMorphAbsVertexWeight = FMath::Abs(MorphTargetWeights[WeightIndex]);

        // 检查Morph Target是否有效且权重在有效范围内
        if(MorphTarget != nullptr &&
           ActiveMorphAbsVertexWeight >= MinMorphTargetBlendWeight &&
           ActiveMorphAbsVertexWeight <= MorphTargetMaxBlendWeight &&
           MorphTarget->HasDataForLOD(LODIndex))
        {
            NewInfo.WeightIndex = WeightIndex;
            NewInfo.NextDeltaIndex = 0;
            NewInfo.Deltas = MorphTarget->GetMorphTargetDelta(LODIndex, NewInfo.NumDeltas);
            NumValidMorphTargets++;
        }

        OutEvalInfos.Add(NewInfo);
    }
    return NumValidMorphTargets;
}

2. Morph Target 混合算法

template<typename VertexType>
FORCEINLINE void UpdateMorphedVertex(
    VertexType& MorphedVertex, 
    const VertexType& SrcVertex, 
    int32 CurBaseVertIdx, 
    int32 LODIndex, 
    TArray<FMorphTargetInfo>& EvalInfos, 
    const TArray<float>& MorphWeights)
{
    MorphedVertex = SrcVertex;

    // 遍历所有活跃的Morph Target
    for(int32 MorphIdx = 0; MorphIdx < EvalInfos.Num(); MorphIdx++)
    {
        FMorphTargetInfo& Info = EvalInfos[MorphIdx];

        // 检查下一个Delta是否匹配当前顶点
        if(Info.NextDeltaIndex != INDEX_NONE &&
           Info.NextDeltaIndex < Info.NumDeltas &&
           Info.Deltas[Info.NextDeltaIndex].SourceIdx == CurBaseVertIdx)
        {
            // 应用Morph Target混合
            ApplyMorphBlend(MorphedVertex, Info.Deltas[Info.NextDeltaIndex], 
                           MorphWeights[Info.WeightIndex]);

            // 更新下一个Delta索引
            Info.NextDeltaIndex += 1;
        }
    }

    // 重建正交标准化的切线基
    RebuildTangentBasis(MorphedVertex);
}

template<typename VertexType>
FORCEINLINE void ApplyMorphBlend(VertexType& DestVertex, 
                                const FMorphTargetDelta& SrcMorph, 
                                float Weight)
{
    // 添加位置偏移
    DestVertex.Position += SrcMorph.PositionDelta * Weight;

    // 保存W分量（TangentZ的W存储基向量行列式符号）
    int8 W = DestVertex.TangentZ.Vector.W;

    FVector TanZ = DestVertex.TangentZ.ToFVector();
    
    // 添加法线偏移（法线Delta权重最大限制为1.0）
    DestVertex.TangentZ = (TanZ + FVector(SrcMorph.TangentZDelta * FMath::Min(Weight, 1.0f))).GetUnsafeNormal();
    
    // 恢复W分量
    DestVertex.TangentZ.Vector.W = W;
}

template<typename VertexType>
FORCEINLINE void RebuildTangentBasis(VertexType& DestVertex)
{
    // 通过将新法线与基切线向量正交标准化来重建切线
    FVector Tangent = DestVertex.TangentX.ToFVector();
    FVector Normal = DestVertex.TangentZ.ToFVector();
    Tangent = Tangent - ((Tangent | Normal) * Normal);
    Tangent.Normalize();
    DestVertex.TangentX = Tangent;
}

布料模拟集成

1. 布料模拟数据结构

// 布料模拟的CPU实现
struct ClothCPU
{
    // 获取布料模拟位置
    FORCEINLINE static FVector GetClothSimulPosition(const FClothSimulData& InClothSimData, int32 InIndex)
    {
        if (InClothSimData.Positions.IsValidIndex(InIndex))
        {
            return FVector(InClothSimData.Transform.TransformPosition(
                (FVector)InClothSimData.Positions[InIndex]));
        }
        return FVector::ZeroVector;
    }

    // 获取布料模拟法线
    FORCEINLINE static FVector GetClothSimulNormal(const FClothSimulData& InClothSimData, int32 InIndex)
    {
        if (InClothSimData.Normals.IsValidIndex(InIndex))
        {
            return FVector(InClothSimData.Transform.TransformVector(
                (FVector)InClothSimData.Normals[InIndex]));
        }
        return FVector(0, 0, 1);
    }

    // 计算布料位置（使用重心坐标插值）
    FORCEINLINE static FVector ClothingPosition(const FMeshToMeshVertData& InClothVertData, 
                                               const FClothSimulData& InClothSimData, 
                                               const FVector& InWorldScaleAbs)
    {
        return InClothVertData.PositionBaryCoordsAndDist.X * 
               (GetClothSimulPosition(InClothSimData, InClothVertData.SourceMeshVertIndices[0]) + 
                GetClothSimulNormal(InClothSimData, InClothVertData.SourceMeshVertIndices[0]) * 
                InClothVertData.PositionBaryCoordsAndDist.W * InWorldScaleAbs.X)
             + /* 类似地处理Y和Z分量 */;
    }
};

2. 布料与骨骼蒙皮的混合

// 在SkinVertexSection中应用布料模拟
if (ClothVertData != nullptr && ClothVertData->SourceMeshVertIndices[3] < FIXED_VERTEX_INDEX)
{
    // 构建模拟位置（世界空间）
    FVector SimulatedPositionWorld = ClothCPU::ClothingPosition(*ClothVertData, *ClothSimData, WorldScaleAbs);

    // 转换回局部空间
    FVector3f SimulatedPosition = (FVector4f)WorldToLocal.TransformPosition(SimulatedPositionWorld);

    // 计算顶点混合权重
    const float VertexBlend = ClothBlendWeight * (1.0f - (ClothVertData->SourceMeshVertIndices[3] / 65535.0f));
    
    // 在蒙皮位置和模拟位置之间插值
    DestVertex->Position = FMath::Lerp(DestVertex->Position, SimulatedPosition, VertexBlend);

    // 重新计算切线和法线
    FVector TangentX, TangentZ;
    ClothCPU::ClothingTangents(*ClothVertData, *ClothSimData, SimulatedPositionWorld, 
                              WorldToLocal, WorldScaleAbs, TangentX, TangentZ);

    // 在蒙皮切线和模拟切线之间插值
    FVector SkinnedTangentX = DestVertex->TangentX.ToFVector();
    FVector4 SkinnedTangentZ = DestVertex->TangentZ.ToFVector4();
    DestVertex->TangentX = (TangentX * VertexBlend) + (SkinnedTangentX * (1.0f - VertexBlend));
    DestVertex->TangentZ = FVector4((TangentZ * VertexBlend) + (SkinnedTangentZ * (1.0f - VertexBlend)), 
                                   SkinnedTangentZ.W);
}

GPU 缓冲区更新机制

1. 缓存顶点到 GPU 缓冲区更新

// 在CacheVertices函数的最后部分
void UpdateGPUBuffers(const FSkeletalMeshLODRenderData& LOD, 
                     const FSkeletalMeshObjectLOD& MeshLOD, 
                     FRHICommandList& RHICmdList)
{
    check(LOD.GetNumVertices() == CachedFinalVertices.Num());

    // 更新位置和切线数据
    for (int i = 0; i < CachedFinalVertices.Num(); i++)
    {
        // 位置缓冲区
        MeshLOD.PositionVertexBuffer.VertexPosition(i) = CachedFinalVertices[i].Position;
        
        // 切线缓冲区
        MeshLOD.StaticMeshVertexBuffer.SetVertexTangents(i, 
            (FVector3f)CachedFinalVertices[i].TangentX.ToFVector(), 
            CachedFinalVertices[i].GetTangentY(), 
            (FVector3f)CachedFinalVertices[i].TangentZ.ToFVector());

        // UV坐标
        for (uint32 UVIndex = 0; UVIndex < LOD.StaticVertexBuffers.StaticMeshVertexBuffer.GetNumTexCoords(); ++UVIndex)
        {
            MeshLOD.StaticMeshVertexBuffer.SetVertexUV(i, UVIndex, 
                FVector2f(CachedFinalVertices[i].TextureCoordinates[UVIndex].X, 
                         CachedFinalVertices[i].TextureCoordinates[UVIndex].Y));
        }
    }

    // 更新RHI缓冲区
    MeshLOD.PositionVertexBuffer.UpdateRHI(RHICmdList);
    MeshLOD.StaticMeshVertexBuffer.UpdateRHI(RHICmdList);

    // 重新绑定顶点工厂
    FLocalVertexFactory::FDataType Data;
    MeshLOD.PositionVertexBuffer.BindPositionVertexBuffer(&MeshLOD.VertexFactory, Data);
    MeshLOD.StaticMeshVertexBuffer.BindTangentVertexBuffer(&MeshLOD.VertexFactory, Data);
    MeshLOD.StaticMeshVertexBuffer.BindPackedTexCoordVertexBuffer(&MeshLOD.VertexFactory, Data, MAX_TEXCOORDS);
    MeshLOD.StaticMeshVertexBuffer.BindLightMapVertexBuffer(&MeshLOD.VertexFactory, Data, 0);
    MeshLOD.MeshObjectColorBuffer->BindColorVertexBuffer(&MeshLOD.VertexFactory, Data);

    MeshLOD.VertexFactory.SetData(RHICmdList, Data);
    MeshLOD.VertexFactory.InitResource(RHICmdList);
}

调试和可视化功能

1. 骨骼权重可视化

static void CalculateBoneWeights(FFinalSkinVertex* DestVertex, 
                                FSkeletalMeshLODRenderData& LOD, 
                                FSkinWeightVertexBuffer& WeightBuffer, 
                                TArray<int32> InBonesOfInterest)
{
    int32 VertexBufferBaseIndex = 0;

    for(int32 SectionIndex = 0; SectionIndex < LOD.RenderSections.Num(); SectionIndex++)
    {
        FSkelMeshRenderSection& Section = LOD.RenderSections[SectionIndex];
        CalculateSectionBoneWeights(DestVertex, WeightBuffer, Section, InBonesOfInterest);
    }
}

static FORCEINLINE void CalculateSectionBoneWeights(FFinalSkinVertex*& DestVertex, 
                                                   FSkinWeightVertexBuffer& SkinWeightVertexBuffer, 
                                                   FSkelMeshRenderSection& Section, 
                                                   const TArray<int32>& BonesOfInterest)
{
    FBoneIndexType* BoneMap = Section.BoneMap.GetData();

    for(int32 VertexIndex = 0; VertexIndex < Section.GetNumVertices(); VertexIndex++, DestVertex++)
    {
        const int32 VertexBufferIndex = Section.GetVertexBufferIndex() + VertexIndex;
        FSkinWeightInfo SrcWeight = SkinWeightVertexBuffer.GetVertexSkinWeights(VertexBufferIndex);

        // 清零 UV 坐标
        DestVertex->TextureCoordinates[0].X = 0.0f;
        DestVertex->TextureCoordinates[0].Y = 0.0f;

        const FBoneIndexType* RESTRICT BoneIndices = SrcWeight.InfluenceBones;
        const uint16* RESTRICT BoneWeights = SrcWeight.InfluenceWeights;

        // 累积感兴趣骨骼的权重
        for (uint32 i = 0; i < SkinWeightVertexBuffer.GetMaxBoneInfluences(); i++)
        {
            if (BonesOfInterest.Contains(BoneMap[BoneIndices[i]]))
            {
                DestVertex->TextureCoordinates[0].X += BoneWeights[i] / 65535.0; 
                DestVertex->TextureCoordinates[0].Y += BoneWeights[i] / 65535.0;
            }
        }
    }
}

2. Morph Target 可视化

static void CalculateMorphTargetWeights(FFinalSkinVertex* DestVertex, 
                                       FSkeletalMeshLODRenderData& LOD, 
                                       int LODIndex, 
                                       TArray<UMorphTarget*> InMorphTargetOfInterest)
{
    const FFinalSkinVertex* EndVert = DestVertex + LOD.GetNumVertices();

    // 清零所有顶点的 UV 坐标
    for (FFinalSkinVertex* ClearVert = DestVertex; ClearVert != EndVert; ++ClearVert)
    {
        ClearVert->TextureCoordinates[0].X = 0.0f;
        ClearVert->TextureCoordinates[0].Y = 0.0f;
    }

    // 为每个感兴趣的 Morph Target 标记受影响的顶点
    for (const UMorphTarget* Morphtarget : InMorphTargetOfInterest)
    {
        int32 NumDeltas;
        const FMorphTargetDelta* MTLODVertices = Morphtarget->GetMorphTargetDelta(LODIndex, NumDeltas);
        
        for (int32 MorphVertexIndex = 0; MorphVertexIndex < NumDeltas; ++MorphVertexIndex)
        {
            FFinalSkinVertex* SetVert = DestVertex + MTLODVertices[MorphVertexIndex].SourceIdx;
            SetVert->TextureCoordinates[0].X += 1.0f;
            SetVert->TextureCoordinates[0].Y += 1.0f;
        }
    }
}

性能优化要点

1. SIMD 指令使用

使用VectorRegister类型进行4路并行计算
VectorLoadAligned、VectorMultiplyAdd等优化指令
Unpack3、Pack4等紧凑数据格式处理

2. 内存访问优化

FPlatformMisc::Prefetch预取数据到缓存
RESTRICT关键字告诉编译器指针不重叠
顺序访问模式最大化缓存效率

3. 分支预测优化

展开骨骼影响处理循环而非使用动态循环
模板特化避免运行时分支
常量条件编译时优化

4. 内存布局优化

顶点数据紧凑排列
Section-wise 处理提高局部性
预分配缓冲区避免动态分配

总结

UE 5.5.4的 CPU 蒙皮系统是一个高度优化的多功能渲染管线：

核心特征

SIMD 向量化：充分利用现代 CPU 的并行计算能力
多骨骼支持：最多支持12个骨骼影响 per 顶点
Morph Target 集成：高效的增量混合算法
布料模拟：与物理模拟的无缝集成
调试可视化：完整的权重和变形可视化工具

适用场景

高精度需求：需要 CPU 端访问变形后顶点数据
兼容性考虑：不支持 GPU 蒙皮的平台
调试开发：实时权重调试和可视化
特殊效果：复杂的程序化变形

这个系统为 UE 提供了强大的 CPU 端骨骼动画处理能力，确保在各种场景下都能提供高质量的骨骼动画渲染效果。

GPGPU in Unity

Mon, 26 May 2025 00:00:00 GMT

GPGPU in Unity

首先从 Unity 应用的角度来看 GPGPU。Unity 想要使用 GPGPU, 需要用到 Compute Shader。
定义一个简单的 ComputeShader：

#pragma kernel CSMain

RWStructuredBuffer<float4> Result;

[numthreads(8,8,1)]
void CSMain (uint3 id : SV_DispatchThreadID)
{
    Result[id.xy] = float4(id.x & id.y, (id.x & 15)/15.0, (id.y & 15)/15.0, 0.0);
}

kernel

kernel 指定核函数, Compute Shader 最终会在 C# 层调用 Dispatch 函数来运行指定的核函数。

public extern void Dispatch(  
  int kernelIndex,  
  int threadGroupsX,  
  int threadGroupsY,  
  int threadGroupsZ);

Thread and Group

Dispatch 定义了计算的 线程组 的数量。
numthread 定义了一个 线程组 (Thread Group) 中被执行线程 的总数量。

Compute Shader 中需要理解与线程相关的 SV 的含义：
定义 由 Dispatch 函数决定 的线程组 ID 定义为 $[gx, gy, gz]$ , 范围是 $[gX-1, gY-1, gZ-1]$。
定义 由 threadnumber 决定的 线程组内线程 ID 定义为 $[tx,ty,tz]$, 范围是 $[tX-1, tY-1, tZ-1]$
定义线程的 全局唯一标识 ID 的范围是 $[gXtX-1,gYtY-1,gZ*tZ-1]$

SV	Type	Desc	Formula
SV_GroupID	int3	由 Dispatch 函数决定的线程组 ID
SV_GroupThreadID	int3	由 threadnumber 决定的线程组内线程 ID
SV_DispatchThreadID	int3	全局唯一标识 ID	$[gxtX+tx,gytY+ty,gz*tZ+tz]$
SV_GroupIndex	int	线程所在线程组内的下标	$x+ytX+ztX*tY$
注意 group 和 thread 计数的时候, 都是将 x 作为最后的计数维度, z 作为最先技术的维度。

numthreads - Win32 apps | Microsoft Learn

Static Value

#pragma kernel CSMain

float3 boxSize1 = float3(1.0f, 1.0f, 1.0f); // 方法1
const float3 boxSize2 = float3(2.0f, 2.0f, 2.0f); // 方法2
static float3 boxSize3 = float3(3.0f, 3.0f, 3.0f); // 方法3

[numthreads(8,8,1)]
void CSMain (uint3 id : SV_DispatchThreadID)
{
    // 做判断
}

Computer Shader 遵循 HLSL 的语法规定。方法一和方法二初始化是无效的, 在 CSMain 中会读取到 $(0,0,0)$。只有方法三才能读取到初始化的值。

Code in CPU

在 CPU 层, 核心只需要做两件事情：

Data Transfer
Dispatch

Data Transfer

核心是定义基础数据结构或者 StructBuffer, 然后通过 ComputeShader 的 Set 方法将 CPU 的数据传递给 GPU。

Dispatch

调用 ComputeShader 的 Dispatch 函数, 触发核函数的计算。一般是回写到 RWStructBuffer 或者其他 RW 的 GPU 结构。

回写之后, 可以在显存中直接取用已经计算好的数据。

Hardware GPGPU

Mon, 26 May 2025 00:00:00 GMT

Thead and Group

在 GPU 编程的过程中，根据程序具体的执行需求，可将线程划分为由 线程组（thread group） 构成的网格（grid）。

numthread 和 Dispatch 的三维 Grid 的设置方式只是方便逻辑上的划分，硬件执行的时候还会把所有线程当成一维的。因此 numthread(8, 8, 1) 和 numthread(64, 1, 1) 只是对我们来说索引线程的方式不一样而已，除外没区别。

具体划分见 Compute Shader in Unity

Thread and Group in Hardware

GPU 会有上千个“核心”，用 NVIDIA 的说法就是 CUDA Core。

SP：最基本的处理单元，streaming processor，也称为 CUDA core。最后具体的指令和任务都是在 SP 上处理的。GPU 进行并行计算，也就是很多个 SP 同时做处理。常说的几百核心的 GPU 值指的都是 SP 的数量。
SM：多个 SP 加上其他的一些资源组成一个 streaming multiprocessor。也叫 GPU 大核，其他资源如：warp scheduler，register，shared memory 等。SM 可以看做 GPU 的心脏，register 和 shared memory 是 SM 的稀缺资源。CUDA 将这些资源分配给所有驻留在 SM 中的 threads。因此，这些有限的资源就使每个 SM 中 active warps 有非常严格的限制，也就限制了并行能力。

这些核心被组织在流式多处理器（streaming multiprocessor, SM）中，一个线程组运行于一个多处理器（SM）之上。每一个 SP 同一时间可以运行一个线程。

Warp and Wavefront

SM 会将它从 Gigathread 引擎（NVIDIA 技术，专门管理整个流水线）那收到的大线程块，拆分成许多更小的堆，每个堆包含 32 个线程，这样的堆也被称为：warp (AMD 则称为 wavefront)。多处理器会以 SIMD32 的方式（即 32 个线程同时执行相同的指令序列）来处理 warp，每个 CUDA 核心都可处理一个线程。

每一个线程组都会被划分到一个 Compute Unit 来计算，线程组中的线程由 Compute Unit 中的 SIMD 部分来执行。
如果我们定义 numthreads(8, 2, 4) ，那么每个线程组就有 $8×2×4=64$ 个线程，这一整个线程组会被分成两个 warp，调度到单个 SIMD 单元计算。

单个 SM 处理逐个 warp，当一个 warp 暂时需要等待数据的时候，就可以先换其他 warp 继续执行。

Set Size of Thread Group

应当总是将线程组的大小设置为 warp 尺寸的整数倍。让 SM 同时容纳多个 warp，能够以防一些情况。

例如有时候为了等待某些数据就绪，不得不停下来。比如说，我们需要通过法线纹理贴图来计算法线光照，即使该法线纹理已经在 Cache 中了，访问该资源仍然会有所耗时，而如果它不在 Cache 中，那就更加耗时了。用专业术语讲就是 Memory Stall（内存延迟）。与其什么事情也不做，不如将当前的 Warp 换成其它已经准备就绪的 Warp 继续执行。

NVIDIA 公司生产的图形硬件所用的 warp 单位共有 32 个线程。而 ATI 公司采用的 “wavefront” 单位则具有 64 个线程，且建议为其分配的线程组大小应总为 wavefront 尺寸的整数倍。另外，值得一提的是，不管是 warp 还是 wavefront，它们的大小在未来几代中都有可能发生改变。

总之，每个 SM 的操作度是 warp，但是每个 SM 可以同时处理多个 warp。然后因为有内存等待（memory stall）的问题，同一个 thread block 有可能需要等待内存才做，因此可以使用多个线程组交叉运行。warp 对我们是不可见和不可编程的，我们可编程的只有线程组。

Communication between Thread

Communication between Multi Thread Groups

thread 不能访问其他 group 的共享内存。

group 之间的通信需要 L2 Cache 支持。L2 Cache 性能有所折扣, 因此要见着 group 间的通信。

Communication in Single Thread Group

单个 group 之间的 thread 的通信, 通过 Local Data Share (LSD)来完成。LDS 的速度是快于 L1 Cache 的。

LDS 会被某些着色阶段使用, 如 fragment shader (pixel shader) 需要用 LDS 来进行插值。但 Compute Shader 和传统着色器不同, 不需要 LDS, 故可以随意只用 LDS。

groupshared float data[8][8];  
  
[numthreads(8,8,1)]  
void main(ivec3 index : SV_GroupThreadID)  
{  
  data[index.x][index.y] = 0.0;  
  GroupMemoryBarrierWithGroupSync();  
  data[index.y][index.x] += index.x;  
  …  
}

需要组内共享的变量加上 groupshared , 同时为了保证其他线程正确读取到数据, 需要通过 Barrier 来保证读的时候 LDS 有需要的数据。

Vector Register and Scalar Register

如果有些变量是线程独立的，称之为 “non-uniform” 变量。（如果一个线程组内有 64 个线程，就要存 64 份数据）

如果有些变量是线程间共享的，称之为 “uniform” 变量，例如线程组 id 是组内每个线程都一样的。（每个线程组内只存 1 份数据）

“non-uniform” 变量会被储存到 Vector Register（VGPR, vector general purpose register）中。

“uniform” 变量会被储存到 Scalar Register（SGPR, scalar general purpose register）中。

如果用了过多 “non-uniform” 变量导致 Vector Register 装不下，就会导致分配给 SIMD 的线程组数量降低。

Differences with Traditional Shader Execution Pipeline

Vert-Frag Shader：

Command Processor 收集并处理所有命令，发送到 GPU。
Draw() 命令发送后，Command Processor 告知 Graphics Processor 要做的事情。
顶点着色器和其他需要计算的阶段被送到 Compute Unit 去计算，处理完会到 Rasterizer (光栅器)，并返回处理好的像素到 Compute Unit 执行像素着色（Pixel shader）。
输出到 RenderTarget。

Compute Shader：

Command Processor 仍会收集并处理所有命令，发送到 GPU。
不需要传数据到 Graphics Processor, 而是直接传到 Compute Unit。
Compute Unit 开始处理 Compute Shader，输入可以有 constants 和 resources（对应 DirectX 的 Resource 可以绑定到渲染管线的资源，例如顶点数组等），输出可以有 writable resources（UAV, Unordered Access View 能被着色器写入的资源视图）。

因此，如果我们用了 Compute Shader，可以不通过渲染管线，跳过 Render Output，使用更少硬件资源，利用 GPU 来完成一些渲染不相关的工作。此外，Compute Shader 的流水线需要的信息也更少。

Disadvantages

难以 Debug。
至少需要 DX11 和 OpenGL ES3。
不同平台针对错误的处理不一致。

数组越界：dx 返回0, 其他平台出错。
变量和关键字或内置函数重名：dx 无影响, 其他平台出错。
SBuffer 和内存布局不一致：dx 会自动转换, 其他平台会出错。
Buffer 未初始化：dx 全是0, 但其他平台可能是任意值或 NaN。

Application

Unity线上技术大会-游戏专场｜从手机走向主机 -《原神》主机版渲染技术分享
 《天涯明月刀》手游引擎技术负责人：如何应用GPU Driven优化渲染效果？| TGDC 2020
三七研发，这款被称作 “目前最原汁原味的”《斗罗大陆》3D 手游都用到了哪些 Unity 技术？
DD2018: Sebastian Aaltonen - GPU based clay simulation and ray tracing tech in Claybook

Blend Shape

Wed, 14 May 2025 00:00:00 GMT

BlendShape 技术的记录。

Why to Use Blend Shape

在制作面部动画的时候，由于人们对面部肌肉运动的敏感性，质量不佳的面部动画很容易出现恐怖谷效应。

同时面部的肌肉数量众多，使用纯骨骼蒙皮动画的方案不仅会有性能上的问题同时对艺术家们的技术提出了极高的要求。

基于BlendShape的方案允许将最终的面部姿势作为多个面部表情的线性组合。

面部动作编码系统（FACS）为目标形状的构建提供了指导。这个系统详细阐述了表情与情绪之间的相对应关系。该系统中的许多目标近似于单个面部肌肉的线性化效果。通过改变线性组合的权重，可以用很少的计算来表达一系列面部表情。可以根据角色表情的需要扩展我们的BlendShape数据集，以细化角色可以产生的表情范围。

与其他表示法相比，BS具有以下优点：

可以通过使用ZBrush等软件雕刻混合形状目标来直接制定所需的面部形状。可以对形状产生直接的控制。其他方法提供的是对形状的间接控制。
BlendShape采用一种语义参数化的控制方式。每一个权重对于动画师来说具有直观的意义，即各种面部表情的weight。
混合动画迫使动画师的修改在各个BlendShape基所张成的空间中，即保持“在模型上”，即动画师不可能进行任意变形。当然，另一方面这代表着你不能通过使用BlendShape去制作形状数据集中没有的表情。

一种使用多数地形的攀爬和翻越思路

Wed, 14 May 2025 00:00:00 GMT

一种多地形适配的攀爬和翻越思路。

基本思路

从膝盖发出射线检测墙体
从上向下打射线检测出攀爬点
向前从上到下再打一个射线

攀爬和翻越的区别

攀爬的高度要求更高

存在的问题

无法检测窗框

陡峭楼梯会被识别为厚墙触发攀爬动作

有个洞，但太厚无法翻越
即可翻越又可攀爬
下方是破碎的
悬空物体

检测思路

判断墙的厚度

碰撞检测能获得碰撞点的法向量，沿法向量反方向检测墙的厚度。

墙厚->只能站上去，执行攀爬。
墙薄->玩家在移动，执行翻越。
墙薄->玩家未移动，执行攀爬。

Playable API构建动画系统

Wed, 14 May 2025 00:00:00 GMT

Playable 尝试构建动画系统的记录。

Why

可控制动画加载策略，按需加载，异步加载。
灵活控制PlayableGraph数据流，可插入自定义AnimationJob。
加载自定义配置数据，和其他游戏系统配合。
更高自由度的Override。

动作系统机制

动态过度时间：
比较角色当前pose和目标pose，差异越大，过渡时间越长。

按角色当前pose自动匹配目标动作：
如制作了多个跑步停止缓冲动作，不同脚部周期自动匹配到不同的动作

动作后处理：
叠加受击动作（参数化表现受击方向、力度）
IK

运动系统

基础运动：
走跑，跳跃，蹲伏，滑铲
特殊运动：
翻越，攀爬，贴墙，

触发方式：
离线标注-可控且精度高，但工作量大
物理检测-运行时更加灵活，但有性能开销

运行时环境检测

坡度检测，用于上下坡动作融合；

自动跨越前方小障碍；

贴墙；

跳跃目标点连通性检测

优化方向

Reference

[Unity 活动]-Unity X 永劫无间「Unity大咖作客」线上分享会 — 动作动画专场【回放】_哔哩哔哩_bilibili

工具开发经验

Wed, 14 May 2025 00:00:00 GMT

工具开发的一些经验。

编辑和运行时数据分离

编辑状态数据：高可读，版本管理，协同编辑友好，可添加备注

运行时数据：低冗余，高性能

编辑运行时重载

方便进行调试和编辑

推进工具比开发工具更加重要

注重文档建设和规范性检查

Blend Shape in Unity

Mon, 12 May 2025 00:00:00 GMT

Storage

Storage of Imported Assets

BlendShape数据最初存储在导入的3D模型文件中(如FBX)

Storage in Runtime

In Mesh

在Mesh中，BlendShape的具体数据包括：

顶点偏移量
法线偏移量
切线偏移量

// Mesh类包含BlendShape数据
public sealed class Mesh : Object
{
    // 获取BlendShape数量
    public int blendShapeCount { get; }
    
    // 获取指定索引的BlendShape名称
    public string GetBlendShapeName(int shapeIndex);
    
    // 获取BlendShape的帧数
    public int GetBlendShapeFrameCount(int shapeIndex);
    
    // 重要：这个方法能获取原始BlendShape顶点位移数据
    public void GetBlendShapeFrameVertices(
        int shapeIndex, 
        int frameIndex, 
        Vector3[] deltaVertices, 
        Vector3[] deltaNormals, 
        Vector3[] deltaTangents
    );
}

在C++层中

// 简化的C++伪代码示意内部结构
struct BlendShapeChannel
{
    std::string name;
    std::vector<BlendShapeFrame> frames;
};

struct BlendShapeFrame
{
    float weight;
    std::vector<Vector3> deltaVertices;  // 顶点位置增量
    std::vector<Vector3> deltaNormals;   // 法线增量
    std::vector<Vector3> deltaTangents;  // 切线增量
};

class Mesh
{
    // 其他网格数据...
    std::vector<BlendShapeChannel> blendShapes;
};

Storate In GPU

当BlendShape被应用时，数据会通过Mesh被上传到GPU顶点缓冲区：

Compute

Compute In CPU

传统上，BlendShape的混合是在CPU端完成的：

// CPU端BlendShape处理过程的伪代码
void ProcessBlendShapesOnCPU()
{
    // 获取基础网格数据
    Vector3[] baseVertices = mesh.vertices;
    Vector3[] result = new Vector3[baseVertices.Length];
    
    // 复制基础顶点数据
    System.Array.Copy(baseVertices, result, baseVertices.Length);
    
    // 对每个BlendShape进行处理
    for (int shapeIndex = 0; shapeIndex < mesh.blendShapeCount; shapeIndex++)
    {
        // 获取权重
        float weight = skinnedMeshRenderer.GetBlendShapeWeight(shapeIndex) / 100f;
        
        if (weight > 0)
        {
            // 获取此BlendShape的顶点偏移
            Vector3[] deltaVertices = new Vector3[baseVertices.Length];
            Vector3[] deltaNormals = new Vector3[baseVertices.Length];
            Vector3[] deltaTangents = new Vector3[baseVertices.Length];
            
            mesh.GetBlendShapeFrameVertices(shapeIndex, 0, deltaVertices, deltaNormals, deltaTangents);
            
            // 应用权重偏移
            for (int i = 0; i < baseVertices.Length; i++)
            {
                result[i] += deltaVertices[i] * weight;
            }
        }
    }
    
    // 最终更新网格并上传到GPU
    mesh.vertices = result;
    mesh.RecalculateBounds();
}

当在CPU上计算时，Unity使用SkinnedMeshRenderer组件进行处理，并将计算后的最终网格数据上传到GPU进行渲染。实际上这些计算都是在C++层实现的，主要考虑：

性能考量：处理大量顶点数据需要高效计算，C++比C# 更适合此类低级操作。C++实现允许使用SIMD、多线程等更低层次的优化
内存管理：避免在托管代码中产生大量的垃圾回收压力。

Compute In GPU

从Unity 2019版本开始，引入了"GPU Skinning"（GPU蒙皮）技术，允许BlendShape在GPU上直接计算。 GPU蒙皮将BlendShape计算移至顶点着色器阶段，大致实现方式为：

// 顶点着色器中的伪代码（简化版）
void vert(inout appdata_full v) {
    // 基础顶点位置
    float3 basePosition = v.vertex.xyz;
    float3 finalPosition = basePosition;
    
    // 应用每个BlendShape的偏移
    // 这些值和权重由Unity自动传递到GPU
    finalPosition += _BlendShape0 * _Weight0;
    finalPosition += _BlendShape1 * _Weight1;
    // ... 更多BlendShape
    
    v.vertex.xyz = finalPosition;
}

BlendShape

Mon, 12 May 2025 00:00:00 GMT

Blend Shape

blendshape的核心原理是存储多个预定义的网格变形（称为morph target或blend key），这些变形通常基于一个中性姿态（neutral pose）创建。

每个morph target代表一种特定的表情或姿势，例如“微笑”、“闭眼”或“扬眉”。

在动画过程中，顶点的属性（如位置、法线、纹理坐标）会在顶点着色器中通过线性插值（linear interpolation）进行混合，生成最终的动画效果。

数学上，blendshape可以表示为每个顶点的差值：，然后通过权重组合计算最终位置。例如，对于面部动画，可以创建多个morph target（如“微笑”权重为0.5，“闭眼”权重为0.3），中性姿态的权重为1减去所有target权重的和，确保总和在0到1之间。

顶点动画则更广义，涵盖任何直接操作顶点属性的动画技术。blendshape是顶点动画的一种具体实现，特别适合需要高精度控制的场景，如面部表情、布料或皮肤的变形。相比之下，骨骼动画通过骨骼层次结构驱动顶点变形，适合更通用的角色动画。

Tech

现代blendshape技术在GPU计算方面的优化已经非常成熟。DirectX 10引入了Stream-Out和Buffer-Template等特性，显著提升了blendshape的性能。例如，Stream-Out方法通过迭代处理将blendshape数据流式输出到缓冲区，适合处理多个blendshape的场景（如7次迭代处理54个blendshape中的50%以上）。Buffer-Template方法则允许在顶点着色器中直接访问blendshape数据，通过shader resource view实现单次绘制调用（draw call），性能更高。例如，在处理50个blendshape时，Buffer-Template方法比Stream-Out方法快2.4倍（见NVIDIA Developer的Figure 3-6）。
Shader Model 5以上才能支持GPU加速。

另一个前沿技术是Vertex Animation Texture（VAT），它将动画数据烘焙（bake）到纹理中，在顶点着色器中通过采样纹理来驱动动画。这种方法特别适合处理大量简单动画对象，如游戏中的观众（例如Tennis Clash中的观众动画）。VAT将SkinnedMeshRenderer替换为MeshRenderer，保持网格在CPU上静态，减少CPU负载。在Samsung S6上测试，超过2000个实例（每个800顶点）无帧率下降。但VAT在动画混合方面存在局限性，可能会导致过渡时的“弹跳”效果（popping），通常通过确保初始和最终帧一致来缓解，如Tennis Clash的观众动画（闲置和鼓掌动画通过个体起始时间偏移实现有机效果）。VAT使用RGBAHalf（64位/像素）格式，但为支持更多设备，推荐使用RGB24（24位/像素），受限于OpenGLES 2.0的2048x2048纹理限制，适合顶点数≤2048的网格。

VS Skeletal Skinning Animation

blendshape和骨骼蒙皮动画各有优势和劣势，具体选择取决于动画需求。

	BlendShape	骨骼蒙皮动画
适用场景	面部表情、布料、皮肤等有机变形	通用角色动画
控制精度	高，允许直接定义每个顶点	低，依赖骨骼变换进行间接控制
动画混合	线性插值，可能出现“弹跳”，混合效果有限	支持复杂的状态过渡
内存使用	高，每个BS需要存储完整的顶点数据	低，仅存储骨骼变换
美术开发难度	高，美术工作量大	低，骨骼动画开发快
性能	GPU进行优化后高效	复杂骨骼可能增加CPU负载
技术局限	线性插值不适合旋转运动，可能需多target模拟	对精细变形（如面部细节）控制不足

关于Unity中GetBlendShapeFrame参数的解释

Mon, 12 May 2025 00:00:00 GMT

Blend Shape Funcs in Unity

BlendShape在Unity中有以下的函数：

GetBlendShapeFrameWeight
GetBlendShapeFrameCount
GetBlendShapeFrameVertices
GetBlendShapeIndex
GetBlendShapeName

这几个函数涉及到两个参数 shapeIndex 和 frameIndex。

shapeIndex
BlendShape按照导入时的顺序进行索引，可以通过 GetBlendShapeName(index) 获取指定索引对应的BlendShape名称
frameIndex
指定BlendShape中的关键帧索引，大多数情况下每个BlendShape只有一个关键帧

策略模式

Mon, 12 May 2025 00:00:00 GMT

Strategy Pattern

策略模式是一种行为设计模式，它能让你定义一系列算法，并将每种算法分别放入独立的类中，以使算法的对象能够相互替换。

Structure

策略模式建议找出负责用许多不同方式完成特定任务的类，然后将其中的算法抽取到一组被称为策略的独立类中。

名为 上下文(Context) 的原始类必须包含一个成员变量来存储对于每种策略的引用。上下文并不执行任务，而是将工作委派给已连接的策略对象。

上下文不负责选择符合任务需要的算法——客户端会将所需策略传递给上下文。实际上，上下文并不十分了解策略，它会通过同样的通用接口与所有策略进行交互，而该接口只需暴露一个方法来触发所选策略中封装的算法即可。

因此，上下文可独立于具体策略。这样就可在不修改上下文代码或其他策略的情况下添加新算法或修改已有算法了。

Pros and Cons

Relationship with Other Patterns

Code Example

Reference

策略设计模式

C++中调用蓝图函数

Fri, 09 May 2025 00:00:00 GMT

BlueprintImplementableEvent and BlueprintNativeEvent

这是在类定义时预先建立C++和蓝图间接口的方法，也是最常用的方式

// 在头文件中声明函数
UCLASS()
class MYGAME_API AMyActor : public AActor
{
    GENERATED_BODY()
public:
    // 纯蓝图实现事件 - 没有C++定义
    UFUNCTION(BlueprintImplementableEvent, Category="MyGame")
    void OnBlueprintEvent(int32 Value, const FString& Message);
    
    // 带默认C++实现的蓝图事件
    UFUNCTION(BlueprintNativeEvent, Category="MyGame")
    float CalculateValue(float BaseValue);
    
    // 调用函数示例
    void CallBlueprintFunctions();
};

Interface

使用接口是一种更灵活的方法，特别适用于不同类型对象间的通信。

// 定义接口
UINTERFACE(BlueprintType)
class MYGAME_API UMyInterface : public UInterface
{
    GENERATED_BODY()
};

class MYGAME_API IMyInterface
{
    GENERATED_BODY()
public:
    UFUNCTION(BlueprintCallable, BlueprintImplementableEvent)
    void OnInteract(AActor* Instigator);
    
    UFUNCTION(BlueprintCallable, BlueprintNativeEvent)
    bool CanInteract() const;
};

// 实现接口的默认C++方法
bool IMyInterface::CanInteract_Implementation() const
{
    return true;
}

// 在C++中调用接口方法
void AMyActor::InteractWithObject(AActor* TargetActor)
{
    if (TargetActor->GetClass()->ImplementsInterface(UMyInterface::StaticClass()))
    {
        // 检查是否可以交互
        if (IMyInterface::Execute_CanInteract(TargetActor))
        {
            // 调用蓝图实现的方法
            IMyInterface::Execute_OnInteract(TargetActor, this);
        }
    }
}

Delegate

使用动态委托将蓝图函数绑定到C++定义的事件。

UCLASS()
class MYGAME_API AMyActor : public AActor
{
    GENERATED_BODY()
public:
    // 声明动态多播委托
    UPROPERTY(BlueprintAssignable, Category="Events")
    FOnCustomEventSignature OnCustomEvent;
    
    // 声明动态委托
    UPROPERTY(BlueprintAssignable, Category="Events")
    FOnCalculateValueSignature OnCalculateValue;
    
    // 触发事件
    void TriggerEvents();
};

// 在CPP中实现
void AMyActor::TriggerEvents()
{
    // 广播多播委托
    OnCustomEvent.Broadcast(42, TEXT("Event triggered"));
    
    // 执行委托并获取结果
    if (OnCalculateValue.IsBound())
    {
        float Result = OnCalculateValue.Execute(100.0f);
    }
}

Reflection

核心是 FindFunction 拿到函数指针，然后通过 ProcessEvent 接口调用相关函数。

// 获取蓝图类实例
AActor* BlueprintActor = /* 获取BP实例的引用 */;

// 方法1: 使用ProcessEvent直接调用
FName FunctionName = "BlueprintFunction";
BlueprintActor->ProcessEvent(BlueprintActor->FindFunction(FunctionName), &Params);

// 方法2: 使用ExecuteUbergraph (仅限事件图表入口点)
BlueprintActor->ExecuteUbergraph(/* 图表入口点索引 */);

// 方法3: 推荐方式 - 使用InvokeFunction模板函数
FOutputParams Result;
UFunction* Function = BlueprintActor->FindFunction(TEXT("MyBlueprintFunction"));
if (Function)
{
    struct
    {
        float InParam1;
        FString InParam2;
        int32 ReturnValue;
    } Params;
    
    Params.InParam1 = 10.0f;
    Params.InParam2 = TEXT("Hello");
    
    BlueprintActor->ProcessEvent(Function, &Params);
    int32 ReturnValue = Params.ReturnValue;
}

图形学基础

Thu, 08 May 2025 00:00:00 GMT

渲染管线

各种缓冲和测试的含义

执行顺序 alpha test -> stencil test -> depth test

Alpha测试：根据物体的透明度来决定是否渲染
像素值一般是由RGBA四个分量来表示的，其中的A是alpha，表示的是物体的不透明度。1代表完全不透明，0代表完全透明。可选的 alpha 测试可在深度测试执行前在传入片段上运行。片段的 alpha 值与参考值作某些特定的测试（如等于，大于等），如果片段未能通过测试，它将不再进行进一步的处理。 alpha 测试经常用于不影响深度缓存的全透明片段的处理。

深度测试：根据物体的深度决定是否渲染
图形管线会先对每一个位置的像素存储一个深度值，称为深度缓冲，代表了该像素点在3D世界中离相机最近物体的深度值。于是在计算每一个物体的像素值的时候，都会将它的深度值和缓冲器当中的深度值进行比较，如果这个深度值小于缓冲器中的深度值，就更新深度缓冲和颜色缓冲的值，否则就丢弃。

模板测试：根据物体的位置范围决定是否渲染。
模板测试就是用片段指定的参考值与模板缓冲中的模板值进行比较，如果达到预设的比较结果，模板测试就通过了，然后用这个参考值更新模板缓冲中的模板值；如果没有达到预设的比较结果，就是没有通过测试，就不更新模板缓冲。

深度测试在哪个阶段，Early-Z呢，又会存在什么问题？

深度测试位于像素处理阶段的测试合并阶段，Early-Z是一种提前深度测试的技术，它位于光栅化阶段之后，像素处理阶段之前，目的是减少进入像素着色阶段的片段，优化性能。

Early-Z会带来透明测试的冲突，例如某个片元A虽然遮挡了另一个片元B，但A却是透明的，GPU应当渲染的是片元B，这就产生了矛盾，这就是透明度测试会导致性能下降的原因(因为无法用Early-Z)

局部光照模型

由于环境光是常数

经验化的简单光照模型。光栅化算法一次只考虑一个像素的光照强度，因此局部光照模型不能计算某像素受其他像素影响的光照强度部分。也就是说，局部光照模型只对物体进行直接光照的计算，而不考虑其他的间接影响。

Lambert漫反射模型，phong光照明模型，BlinnPhong光照模型
Lambert光照模型主要是用来模拟粗糙物体表面的光照现象 ：反射强度与光线的入射角度有关系，DiffuseLight=I*cosθ，其中cosθ=dot(N,L)(L为入射光线的反向量，N为当前表面的法向量方向)

Phone模型，镜面反射，反射光强度和反射光线与视线夹角有关。

其中 $R$ 向量可以计算公式为: $$ R=2*(L \cdot N)*N - L $$

则整体公式为

$$ Spec = (LightColor*SpecularColor)(V \cdot R)^{Glossiness} $$

BlinPhone基本和Phone一致，只是将反射向量 $R$ 换成半程向量 $H$ 其中 $$ H = (V+L)/||V+H|| $$

全局光照，像素会受到其他像素影响，光线追踪。

着色

Gouraud Shading 计算顶点光照，然后通过插值计算像素的着色 Phone Shading 每一个图元逐像素的法线进行光照计算，计算量较大，但是效果最好

AO

粗略的全局光照算法。用于计算没一点是如何接受环境光的。

SSAO：对于屏幕空间(Screen-filled Quad)上的每一个片段，我们都会根据周边深度值计算一个遮蔽因子(Occlusion Factor)。这个遮蔽因子之后会被用来减少或者抵消片段的环境光照分量。遮蔽因子是通过采集片段周围球体/半球体核心(Kernel)的多个深度样本，并和当前片段深度值对比而得到的。高于片段深度值样本的个数就是我们想要的遮蔽因子。

抗锯齿

光栅化的时候，是以像素中心点是否被三角形覆盖来决定是否生成片段，因此有些片段覆盖了采样点就生成，有些没有覆盖就不生成，最终导致了锯齿现象。

MVP

模型矩阵M(Model)：将局部坐标变换到世界坐标；

观察矩阵V(View)：将世界坐标转换为观察坐标，或者说，将物体的世界坐标，转换为在相机视角下的坐标；

投影矩阵P(Projection)：将顶点坐标从观察空间变换到裁剪空间(clip space) ，后续的透视除法操作会将裁剪空间的坐标转换为标准化设备坐标系中（NDC）。一旦顶点位于相机空间中，最终可以通过应用投影变换将其变换到裁剪空间。投影矩阵通过定义相机视图的范围来编码场景中有多少被捕获在渲染中。两种最常见的投影类型是透视投影和正交投影。

欧拉角、矩阵和四元数表示旋转的区别和优缺点

（1）欧拉角：定义了绕着三个坐标轴的旋转角，来确定刚体的旋转位置的方式，包括俯仰角pitch，偏航角yaw和滚动角roll；它的优点是比较直观，而且单个维度上的角度也比较容易插值；缺点是它不能进行任意方向的插值，而且会导致万向节死锁的问题，旋转的次序对结果也有影响。
万向锁的原因是内轴无法带动外轴旋转。
无伤理解欧拉角中的“万向死锁”现象_哔哩哔哩_bilibili

（2）矩阵：优点是不受万向节死锁的影响，可以独一无二的表达任意旋转，并且可以通过矩阵乘法来对点或矢量进行旋转变换；现在多数CPU以及所有GPU都有内置的硬件加速点积和矩阵乘法；缺点是不太直观，而且需要比较大的存储空间，也不太容易进行插值计算。

（3）四元数：四元数的好处是能够串接旋转；能把旋转直接作用于点或者矢量；而且能够进行旋转插值；另外它所占用的存储空间也比矩阵小；四元数可以解决万向节死锁的问题。

判断点在凸多边体内

射线法，延点和任意多边体顶点方向做射线，偶数则在多边体外，奇数则在多边体内
平面向量，对于没一个平面，沿法线向量和点与平面任一点的向量做内积，若均大于0则在多面体内部

法线贴图和切线空间

切线空间：顶点原点是顶点位置，Z轴是切线，一般指定纹理方向作为XY(且与Z轴垂直) 法线贴图的rgb为什么呈现出蓝色 (0.5, 0.5, 1) ，因为法线某一个轴的范围在（-1, 1）之间，需要和rgb的（0，1）做映射。那么默认的法线是（0，0，1），映射公式为 $(tangent+1)/2$，这时候结果就是(0.5，0.5，1)。

主要是光照计算一般放在切线空间中

与模型无关，可以重用和变形(发生形变时，法线可以自适应变换)
切线空间法线Z分量始终为正，这样，就可以从XY重建，节省通道
切线空间允许容易地混合多个法线贴图：基础法线贴图(如皮肤的主要特征) 细节法线贴图(如毛孔、皱纹等微观细节) 程序化生成的法线(如动态伤痕、积水效果)

Lerp

Lerp是圆上弦的等分，而Slerp是弧的等分

Linear interpolation : 线性插值

Normalized Linear interpolation : 归一化线性插值（唯一做的事情就是线性插值之后进行归一化）由于是按照弦长的比例来插值的，即在弦上是匀速的，故在角速度或弧上并不匀速。

Spherical Linear interpolation : 球面线性插值，对四元数做这个操作能保证角速度均匀 $$ SLerp(v_{0},v_{1},t)=\frac{\sin(1-t)\theta}{\sin \theta}v_{0}+\frac{\sin t\theta}{\sin \theta}v_{1} $$

Alpha混合

Blend Src Dst Blend SrcAlpha OneMinusSrcAlpha 其中Src为片元颜色，Dst为缓存颜色

Blend DstColor Zero Multiply 正片叠底 Blend DstColor SrcColor 两倍相乘

BlendOp Min Blend One One 变暗

BlendOp Max Blend One One 变亮

透明物体渲染需要关闭深度写入，否则会导致后面的物体无法正常渲染

延迟渲染

先进行深度测试，再进行着色渲染。且将光照计算从三维空间放到二维空间。 GBuffer-存储像素位置，法线，漫反射信息，方便直接在像空间进行逐像素光照处理。

1、几何处理阶段(Geometry Pass)。这个阶段中，我们获取对象的各种几何信息，并将第二步所需的各种数据储存（也就是渲染）到多个G-buffer中；

2、光照处理阶段(Lighting Pass)。在这个pass中，我们只需渲染出一个屏幕大小的二维矩形，使用第一步在G-buffer中存储的数据对此矩阵的每一个片段计算场景的光照；光照计算的过程还是和正向渲染以前一样，只是现在我们需要从对应的G-buffer而不是顶点着色器(和一些uniform变量)那里获取输入变量了。

优点：复杂度仅O(m+n)，而前向渲染为O(m*n) 缺点：透明渲染存在问题

顺序无关渲染

深度剥离算法N个Pass

AABB交叉检测

Thu, 08 May 2025 00:00:00 GMT

定义需要检测的矩阵 $A$ 和 $B$。

每个矩阵分别用左上角坐标和右下角坐标进行描述，这样，两个矩阵分别可以表示为 $(ax_{1},ay_{1}),(ax_{2},ay_{2})$ 和 $(bx_{1},by_{1}),(bx_{2},by_{2})$。

检测是否有重叠的代码如下

bool isOverlap = ax1 <= bx2 && ax2 >= bx1 && ay1 <= by2 && ay2 >= by1;

这行代码有四个条件：

$A$ 的上边界在 $B$ 的下边界上面。
$A$ 的下边界在 $B$ 的上边界下面。
$A$ 的左边界在 $B$ 的右边界左边。
$A$ 的右边界在 $B$ 的左边界右边。

判断目标点是否在凸多边形区域

Thu, 08 May 2025 00:00:00 GMT

目标点 $p$ 对凸多边形每个顶点之间建立一个向量 $vec$（如：$\vec{v}{p\to v{1}}$），该向量与其对应的顶点的边 $edge$（如：$v_{2}-v_{1}$）进行叉乘，得到一个叉积值。

若每个叉积值的符号都一样（都是正数/都是负数），则证明点在凸多边形内。

否则，则证明点不再凸多边形内。


bool Chunk::inChunk(Vector2 p)
{   int size = vertexs.size(); 
    for(int i = 0; i < size; ++i)
    { 
        //假设凸多边形的边edge都是逆时针方向 
        Vector2 edge = vertex[(i+1)%size]-vertex[i]; 
        Vector2 vec = vertex[i] - p; 
        int result = cross(edge,vec); 
        //若点在凸多边形内，得到的叉积值应都是正数 
        if(sign(result) == 0)
            return false; 
    } 
    return true;

四叉树

Thu, 08 May 2025 00:00:00 GMT

四叉树 ：

四叉树索引的基本思想是将地理空间递归划分为不同层次的树结构。

它将已知范围的空间等分成四个相等的子空间，如此递归下去，直至树的层次达到一定深度或者满足某种要求后停止分割。

Splite

为了灵活性，设计一个 ssf 分裂终止函数。当满足这个函数时，分裂终止；同时，这个是触发合并的对偶条件，只有当满足这个条件时，才会尝试合并。
对于一个 ssf 函数，可以这样设计：叶子结点<=4 || 节点面积<=最小的元素面积，也就是说只有叶子节点>4且节点面积>4才能触发分裂。

分裂需要满足下面的条件：

该节点是叶子节点。
!ssf

执行分裂时：

element 可以以中心坐标为准，放入四分的新的叶子节点。
对所有新的叶子节点再次尝试分裂。

Merge

合并需要满足下面的条件：

不是根节点。
自身是叶子节点，且其兄弟节点均为叶子节点。
ssf 且父节点满足 ssf

执行分裂时：

自身及其兄弟节点的所有 element 上挪到父节点。
对父节点再次尝试合并。

When to Splite or Merge

并非只有添加对象才会引起分裂，同样并非只有移除对象才会引起合并。

分裂和合并的触发，取决于终止分裂条件 ssf() 的设计。

举一个例子，我们希望叶子节点在下面的任一情况成立时终止分裂：

节点内没有任何管理的对象。
节点内每一个方格都是对象。

这种条件十分适合地图中的固定障碍物的管理（地形、建筑等），四叉树可以把完全空旷的、和完全都是障碍物的地方不重叠地放到不同的叶子中去。

这样可能发生：

当添加一个对象时，有可能一个大的矩形正好放满了，引起合并。
当移除一个对象时，有可能一个满的大矩形变的不满了，引起分裂。

这种情况下， 不论是添加还是移除对象，分裂和合并都有可能发生。

但是，用户的条件是稳定的，也就是说保证 分裂和合并的条件不会同时成立，一定是时刻相反的。

所以在实现中，每次添加或移除对象时，都回去尝试分裂或合并，但 二者只发生一个。

// 添加对象时, 先尝试分裂，否则尝试合并
trySplitDown(node) || tryMergeUp(node);
// 移除对象时，先尝试合并，否则尝试分裂
tryMergeUp(node) || trySplitDown(node);

Query Optimize

对于一个宽 $w$，高 $h$ 的带划分平面。可以将其进行 $d$ 次二分，这样对于点 $(x,y)$，一定在第 $(2^dx/w,2^dy/h)$ 个小区间内。

也就是说，对于 $d$ 的节点而言，其覆盖区域内的任意一个位置 $(x,y)$ 都有：

位置 $(x,y)$ 一定位于 $x$ 轴上第 $2^dx/w$ 个、$y$ 轴上第 $2^dy/h$ 个小矩形内。

其中 $d$ 从 $0$ 开始计算的，计数也是从 $0$ 开始的。

构造哈希函数：

可以构造一个参数为 $(d,x,y)$ 的哈希函数，这个函数输出为对于特定深度 $d$ 的某一区域内的 $(x,y)$，具有相同的ID。

这样，每个特定深度 $d$ 的区域可以对应四叉树的某一可能的叶子节点，都具有了唯一的ID。

接下来只需要建立从 $(d,x,y)$ 到该叶子结点指针的映射即可。

uint64_t pack(
    uint64_t d, uint64_t x, uint64_t y, uint64_t w, uint64_t h) {
  // 0xfc00000000000000 : 高6位全是 1, 其余是0
  // 0x3ffffffe0000000  : 高6位全是 0, 接下来29位全是1，其余全是0
  // 0x1fffffff         : 低29位全是 1，其余全是0
  return ((d << 58) & 0xfc00000000000000ULL) |
         ((((1 << d) * x / h) << 29) & 0x3ffffffe0000000ULL) |
         (((1 << d) * y / w) & 0x1fffffffULL);
}

查找位置为 $(x,y)$ 的叶子节点，关键就在于 确定深度 $d$。因为深度十分有限，遍历的开销十分低。但也可以通过二分进一步优化。

提前维护整棵树的高度 $maxd$，这样初始可行域为 $[0,maxd]$，设定 $l=0,r=maxd$。
二分猜 $m=(l+r)>>1$，用 pack 函数查找计算出的ID，如果查找不到任何节点，说明太大了，需要收缩上界 $r=m-1$。
如果哈希表中存在，那就看是不是叶子节点。如果是叶子节点，则已经命中。如果不是，说明是一个中间的非叶子节点，需要收缩下界 $l=m+1$。

$maxd$ 的维护：
由于支持动态合并，维护 $maxd$ 时，需要同时维护 $maxd$ 的数量，只有当最后一个 $maxd$ 被销毁时，才减少 $maxd$。

Region Query

思路很简单，从根节点开始，不断 判断重叠：

如果是叶子节点，则直接收集位于查询区域范围内的对象就可以了。
若果是非叶子节点，则继续判断子节点，递归下去。

Region Query Optimize

区域查询时，有了 Query Optimize 机制，就可以不从根节点开始查询。

这时候其实是要找到包含所有区域的最小公共节点。也就是 同时包含查询区域左上角和右下角两个点的最小的节点 。

假设查询区域左上角是 $a$ 点，右上角是 $b$ 点，同时包含这两个点的最小节点是 $Q$，那么：

对于 $Q$，及其祖先节点，一定同时包含 $a$ 和 $b$。
对于 $Q$ 的所有子孙节点，必然不会同时包含 $a$ 和 $b$。

Node* find_smallest_node_covering_range(int x1, int y1, int x2, int y2)
{
    int l = 0, r = maxd;
    Node* node = root;
    while (l < r)
    {
        int d = (l + r + 1) >> 1;
        auto id1 = pack(d, x1, y1, w, h);
        auto id2 = pack(d, x2, y2, w, h);
        if (id1 == id2)
        {
            node = id2NodeDict.find(id1);
            id1 = pack(d + 1, x1, y1, w, h);
            id2 = pack(d + 1，x2, y2, w, h);
            if (id1 == id2)
            {
                l = d;
                continue;
            }
        }
        // 猜得太细分了，缩小上界
        r = d - 1;
    }
    return node;
}

Loose Quadtree Optimize

松散节点优化本质是用查询效率换取移动效率。

在 element 覆盖多个像素的这种情况下。可以采取另一种思路，那就是如果横跨多个区域，可以将其同时放在多个区域中。同时要注意在 ssf 设计时，要考虑到，当区域大小细分后小于了最大 element 大小，则应当阻止继续细分。

在实际情况中，很少会出现一个足够小的元素来回波动，更加常见的是一个元素始终在边界徘徊。这种情况下，认为为了查询效率，牺牲一定的移动效率是值得的。

Reference

四叉树的思路、优化和 C++ 实现 | 春水煎茶

Actor生命周期

Wed, 07 May 2025 00:00:00 GMT

/// Caption
Actor生命周期
///

Create

创建Actor方式有以下几种：

Load From Disc

从磁盘加载 适用于关卡中已存在的 Actor：

调用 UEngine::LoadMap 时。
关卡流式传输调用 UWorld::AddToWorld 时。

Play In Editor

Play in Editor 的Actor由编辑器中复制而来。

SpawnActor

BeginPlay

关卡开始后被调用。

EndPlay

GC

Reference

Unreal Engine Actor Lifecycle | Unreal Engine 5.5 Documentation

优先级队列

Mon, 05 May 2025 00:00:00 GMT

优先级队列是一种基于二叉堆的数据结构。

优先级队列会使用到二叉堆的二叉堆和二叉堆操作。

入队

template<class T>
void Enqueue(T item, int priority)
{
    heap.Add(new PriorityItem(item, priority));
    ShiftUp(heap, heap.length, heap.length - 1);
}

出队

template<class T>
T Dequeue()
{
    if (heap.Count == 0)
        throw new InvalidOperationException("Queue is empty");

    T result = heap[0].Item;
    // 将最后一个元素移到堆顶
    heap[0] = heap[heap.Count - 1];
    heap.RemoveAt(heap.Count - 1);
    if (heap.Count > 0)
        HeapifyDown(heap, heap.length, 0);
    return result;
}

复合节点

Mon, 05 May 2025 00:00:00 GMT

复合（Composite） 节点定义分支的根，以及执行该分支的基本规则。可以对其应用装饰器节点，从而修改进入它们分支的条目，或取消执行中的条目。

还可以连接服务节点，这些服务节点只有在复合节点的子节点正在被执行时才会激活。

Selector

选择器（Selector） 节点按从左到右的顺序执行其子节点。当其中一个子节点执行成功时，选择器节点将停止执行。如果选择器的一个子节点成功运行，则选择器运行成功。如果选择器的所有子节点运行失败，则选择器运行失败。

Sequence

序列（Sequence） 节点按从左到右的顺序执行其子节点。当其中一个子节点失败时，序列节点也将停止执行。如果有子节点失败，那么序列就会失败。如果该序列的所有子节点运行都成功执行，则序列节点成功。

Simple Parallel

简单平行（Simple Parallel） 节点允许一个主任务节点沿整个的行为树执行。主任务完成后，结束模式（Finish Mode） 中的设置会指示该节点是应该立即结束，同时中止次要树，还是应该推迟结束，直到次要树完成。


结束模式（Finish Mode）	- 立即（Immediate）：主任务完成后，后台树的执行将立即中止。<br>- 推迟（Delayed）：主任务完成后，允许后台树继续执行直至完成。

服务节点

Mon, 05 May 2025 00:00:00 GMT

服务（Service） 节点通常连接至复合节点或任务，只要其分支被执行，它们就会以定义的频率执行。这些节点常用于检查和更新黑板。它们取代了其他行为树系统中的传统平行（Parallel）节点。

装饰器节点

Mon, 05 May 2025 00:00:00 GMT

装饰器节点（在其他行为树系统中也称为条件语句）连接到复合节点或任务节点，并定义树中的分支，甚至单个节点是否可以执行

TopK

Sun, 04 May 2025 00:00:00 GMT

线性找第 k 大的数

在下面的代码示例中，第 $k$ 大的数被定义为序列排成升序时，第 $k$ 个位置上的数（编号从 0 开始）。

找第 $k$ 大的数（K-th order statistic），最简单的方法是先排序，然后直接找到第 $k$ 大的位置的元素。这样做的时间复杂度是 $O(n\log n)$，对于这个问题来说很不划算。

我们可以借助快速排序的思想解决这个问题。考虑快速排序的划分过程，在快速排序的「划分」结束后，数列 $A_{p}\dots A_{r}$ 被分成了 $A_{p}\dots A_{q}$ 和 $A_{p+1}\dots A_{r}$，此时可以按照左边元素的个数（$q-p+1$）和 $k$ 的大小关系来判断是只在左边还是只在右边递归地求解。

和快速排序一样，该方法的时间复杂度依赖于每次划分时选择的分界值。如果采用随机选取分界值的方式，可以证明在期望意义下，程序的时间复杂度为 $O(n)$。

实现

```cpp
// 模板的 T 参数表示元素的类型，此类型需要定义小于（<）运算
template <typename T>
// arr 为查找范围数组，rk 为需要查找的排名（从 0 开始），len 为数组长度
T find_kth_element(T arr[], int rk, const int len) {
if (len <= 1) 
    return arr[0];
// 随机选择基准（pivot）
const T pivot = arr[rand() % len];
// i：当前操作的元素下标
// arr[0, j)：存储小于 pivot 的元素
// arr[k, len)：存储大于 pivot 的元素
int i = 0, j = 0, k = len;
// 完成一趟三路快排，将序列分为：
// 小于 pivot 的元素 ｜ 等于 pivot 的元素 ｜ 大于 pivot 的元素
while (i < k) {
    if (arr[i] < pivot)
        swap(arr[i++], arr[j++]);
    else if (pivot < arr[i])
        swap(arr[i], arr[--k]);
    else
        i++;
}
// 根据要找的排名与两条分界线的位置，去不同的区间递归查找第 k 大的数
// 如果小于 pivot 的元素个数比k多，则第 k 大的元素一定是一个小于 pivot 的元素
if (rk < j) 
    return find_kth_element(arr, rk, j);
// 否则，如果小于 pivot 和等于 pivot 的元素加起来也没有 k 多，
// 则第 k 大的元素一定是一个大于 pivot 的元素
else if (rk >= k)
    return find_kth_element(arr + k, rk - k, len - k);
// 否则，pivot 就是第 k 大的元素
return pivot;
}
```

堆排序

Sun, 04 May 2025 00:00:00 GMT

堆排序使用到了二叉堆。

堆排序需要在建堆后进行二次操作。

template<typename T>
void HeapSort(T arr[], int n) {
    // 建堆   
    Heapify(arr, n);
    // 重新下沉
    for (int i = n - 1; i > 0; i--)
    {
        Swap(arr[0], arr[i]);
        ShiftDown(arr, i, 0);
    }
}

首先建堆能确保堆有序，这时候首元素一定是最大的。

取出首元素，将末尾元素作为新的根节点并进行下沉，下沉后能确保新的堆有序。

重复进行上述操作。

快速排序

Sun, 04 May 2025 00:00:00 GMT

定义

三路快速排序（英语：3-way Radix Quicksort）是快速排序和基数排序的混合。

过程

三路快速排序在随机选取分界点 $m$ 后，将待排数列划分为三个部分：小于 $m$ 、等于 $m$ 以及大于 $m$ 。这样做即实现了将与分界元素相等的元素聚集在分界元素周围这一效果。

实现

递归实现

template <class T>
void quick_sort(T arr[], const int len)
{
    if (len <= 1)
        return;

    const T pivot = arr[rand() % len];
    // i：当前下标
    // arr[0, j]，存储小于 pivot 的元素
    // arr[k, len - 1]，储大于 pivot 的元素
    int i = 0, j = 0, k = len;
    // 完成一趟三路快排，将序列分为：
    // 小于 pivot 的元素 | 等于 pivot 的元素 | 大于 pivot 的元素
    while (i < k)
    {
        if (arr[i] < pivot)
            swap(arr[i++], arr[j++]);
        else if (arr[i] > pivot)
            swap(arr[i], arr[k--])
        else
            i++;
    }
    // 递归完成对于两个子序列的快速排序
    quick_sort(arr, j);
    quick_sort(arr + k, len - k);
}

非递归实现

template <class T>
void quick_sort_non_recursive(T arr[], const int len) {
    if (len <= 1)
    return;

    // 使用栈来存储待排序的子数组的起始和结束位置
    stack<pair<int, int>> stk;
    stk.push({0, len - 1});

    while (!stk.empty()) {
        auto [left, right] = stk.top();
        stk.pop();

        if (left >= right) continue;

        // 选择基准值
        const T pivot = arr[left + rand() % (right - left + 1)];
        int i = left, j = left, k = right;

        // 三路划分
        while (i <= k) {
            if (arr[i] < pivot) {
                swap(arr[i++], arr[j++]);
            } else if (arr[i] > pivot) {
                swap(arr[i], arr[k--]);
            } else {
                i++;
            }
        }

        // 将子数组的边界压入栈中
        stk.push({left, j - 1});
        stk.push({k + 1, right});
    }
}

性质

稳定性

快速排序是一种不稳定的排序算法。

时间复杂度

快速排序的最优时间复杂度和平均时间复杂度为 $O(n\log n)$，最坏时间复杂度为 $n^2$。
对于最优情况，每一次选择的分界值都是序列的中位数。
对于最坏情况，每一次选择的分界值都是序列的最值。

Reference

快速排序 - OI Wiki

二叉堆

Sun, 04 May 2025 00:00:00 GMT

结构

从二叉堆的结构说起，它是一棵二叉树，并且是完全二叉树，每个结点中存有一个元素（或者说，有个权值）。

堆性质：父亲的权值不小于儿子的权值（大根堆）。同样的，我们可以定义小根堆。

由堆性质，树根存的是最大值（getmax 操作就解决了）。

节点结构

对于任意节点 $i$
节点的父节点：$\frac{i-1}{2}$
节点的左子节点：$2i+1$
节点的右子节点：$2i+2$

过程

堆的核心操作有两个：

堆化上浮：如果节点比父节点大,则与父节点交换,重复此过程直到根节点。操作结束后,能确保节点满足堆性质。

堆化下沉：在节点的子节点中,找到一个最大的,与该节点交换,重复此过程到底层。操作结束后,能确保节点满足堆性质。

辅助函数"

    int GetParent(int i) => (i - 1) / 2;  
    int GetLeftChild(int i) => (i * 2) + 1;  
    int GetRightChild(int i) => (i * 2) + 2;  
    int GetFirstLeaf(int n) => n / 2;

堆化下沉

// n 是堆的大小，i 是当前节点的索引  
template<typename T>  
void ShiftDown(T arr[], int n, int i) {  
    while (true)  
    {  
        int largest = i;  
        int left = GetLeftChild(i);  
        int right = GetRightChild(i);  
        if (left < n && arr[left] > arr[largest]) {  
            largest = left;  
        }  
        if (right < n && arr[right] > arr[largest]) {  
            largest = right;  
        }  
        if (largest == i)  
            break;

        Swap(arr[i], arr[largest]);
        i = largest;
    }
}

堆化上浮

template<typename T>  
void ShiftDown(T arr[], int n, int i) {  
    while (i > 0)  
    {  
        int parent = GetParent(i);  
        if (arr[parent] >= arr[i])  
            break;

        Swap(arr[parent], arr[i]);
        i = parent;                    
    }
}

建堆

上浮实现堆有序

template<typename T>  
void Heapify(T arr[], int n) {  
    for (int i = 0; i < n; i++)  
    {  
        ShiftUp(arr, n, i);  
    }  
}

对于第 $k$ 层的结点，向上调整的复杂度为 $O(k)$ 而不是 $O(\log n)$。

总复杂度：$\log 1 + \log 2 + \cdots + \log n = \Theta(n \log n)$。

上浮操作的复杂度是高于下沉的,所以一般采用下沉实现堆有序。

下沉实现堆有序

template<typename T>  
void Heapify(T arr[], int n) {  
    for (int i = GetFirstLeaf(n) - 1; i >= 0; i--)  
    {  
        ShiftDown(arr, n, i);  
    }  
}

每次合并两个已经调整好的堆，这说明了正确性。

注意到向下调整的复杂度，为 $O(\log n - k)$，另外注意到叶节点无需调整，因此可从序列约 $n/2$ 的位置开始调整，可减少部分常数但不影响复杂度。

总复杂度为$ O(n) $。

堆排序

优先级队列

Reference

二叉堆 - OI Wiki

简历归档

Tue, 29 Apr 2025 00:00:00 GMT

简历归档  Typst

#import "template.typ": *

// 主题颜色
#let theme-color = rgb("#26267d")
#let icon = icon.with(fill: theme-color)

// 设置图标, 来源: https://fontawesome.com/icons/
#let fa-award = icon("icons/fa-award.svg")
#let fa-building-columns = icon("icons/fa-building-columns.svg")
#let fa-code = icon("icons/fa-code.svg")
#let fa-envelope = icon("icons/fa-envelope.svg")
#let fa-github = icon("icons/fa-github.svg")
#let fa-graduation-cap = icon("icons/fa-graduation-cap.svg")
#let fa-linux = icon("icons/fa-linux.svg")
#let fa-phone = icon("icons/fa-phone.svg")
#let fa-windows = icon("icons/fa-windows.svg")
#let fa-wrench = icon("icons/fa-wrench.svg")
#let fa-work = icon("icons/fa-work.svg")

// 设置简历选项与头部
#show: resume.with(
  // 字体和基准大小
  size: 10pt,
  // 标题颜色
  theme-color: theme-color,
  // 控制纸张的边距
  margin: (
    top: 1.5cm,
    bottom: 2cm,
    left: 2cm,
    right: 2cm,
  ),

  // 如果需要姓名及联系信息居中，请删除下面关于头像的三行参数，并取消headerCenter的注释
  //headerCenter : true,

  // 如果不需要头像，则将下面三行的参数注释或删除
  // photograph: "profile.jpg",
  // photograph-width: 10em,
  // gutter-width: 2em,
)[
  = 王朝伟

  #info(
    color: theme-color,
    (
      icon: fa-phone,
      content: "(+86) 189-1869-1145",
    ),
    (
      icon: fa-envelope,
      content: "aizawaayame@outlook.com",
      link: "mailto:aizawaayame@outlook.com",
    ),
    (
      icon: fa-github,
      content: "github.com/aizawaayame/OnaGameSample",
      link: "https://github.com/aizawaayame/OnaGameSample",
    ),
  )
][
  #h(2em)

  拥有 #text(weight: "bold")[3 年] 游戏客户端开发经验，在米哈游期间，#text(weight: "bold")[主导并深度参与] 了多个核心系统的设计、开发与优化，包括基于 PCG 的表情系统、高性能编辑器 Canvas 渲染基建、灵活的 Playable 动画系统以及组件化相机约束系统。

  擅长*演出动画系统和工具链开发*，在提升内容创作效率方面有丰富经验。具备跨部门协作能力，能将复杂技术转化为高效生产工具。

  同时对 UE 反射系统、垃圾回收、动画系统有了解和个人项目实践经验。对UE技术有浓厚兴趣。
]


== #fa-graduation-cap 教育背景

#sidebar(with-line: true, side-width: 12%)[
  2018.09

  2022.07
][
  *哈尔滨工业大学* 

  计算机科学与技术专业
]

== #fa-work 工作经历
#sidebar(with-line: true, side-width: 12%)[
  2022.08

  至今
][
  *米哈游* · 原神组 · 客户端开发

    - 主导多个核心功能模块的架构设计与开发，包括表情系统、编辑器UI基础设施和动画系统
    - 深入优化编辑器性能，利用GPU合批和GPGPU思想，大幅度优化项目组的编辑器开发效率和性能
    - 建立内容创作工具链和自动化流程，提升团队工作效率，支持每6周稳定迭代6000+对话内容
    - 了解UE核心功能，了解Gameplay框架、反射系统、垃圾回收和动画系统底层机制
]

#sidebar(with-line: true, side-width: 12%)[
  2021.07

  2021.11
][
  *腾讯* · j2工作室-全境封锁项目组 · UE客户端开发实习

  - 参与behaviac行为树逻辑的维护
  - 学习UE的整体架构，了解UE行为树的设计
]

== #fa-wrench 专业技能

#sidebar(with-line: false, side-width: 12%)[
  *编程语言*
  
  *图形渲染*
  
  *动画系统*
  

  *工具开发*
][
  C++(熟悉)、C\#(熟练)、HLSL/GLSL(了解)
  
  GPU实例化、计算着色器、了解渲染管线、空间数据结构
  
  理解骨骼动画系统、Playable架构、状态机设计、动画混合空间
  

  编辑器扩展开发、自动化生产流水线设计、美术工具链构建
]


== #fa-code 项目经历

#item(
  [ *表情系统架构升级与 PCG 系统实现* ]
)

#tech[ 表情系统，PCG ]

基于 PCG 的表情构建管线

 - 主导设计并实现了程序化表情生成系统，实现从文本和音频到面部表情的自动映射，大幅度提升表情制作效率。
 - 整合MFCC音频特征提取和NLP情感分析算法，构建精确的语音-表情映射关系，支持多语言本地化。
 - 设计标记驱动的分层编辑架构，支持表情批量生成和精细调整两种工作流，实现每6周迭代稳定产出6000+对话表情。
#item(
  [ *编辑器 Canvas 图形系统重构* ]
)

#tech[ 编辑器, 图形编程, UI架构 ]

一个支持高性能绘制的编辑器UI系统

- 主导编辑器 UI 渲染基础设施的重构，采用 GPU 实例化合批技术，极大提升编辑器 UI 渲染性能。
- 应用 GPGPU 计算着色器技术处理大量 UI 元素的变换计算，特别针对曲线绘制场景有大幅度的性能优化。
- 实现了自定义的四叉树空间管理算法，优化了大量 UI 元素的剔除和渲染提交，提高了编辑器响应速度。
- 设计了高效的 GPU 资源管理机制，实现不同视口大小的无缝切换。

#item(
  [ *演出动画系统迭代与 Playable 技术引入* ]
)

#tech[ 动画系统, Playable ]

一个支持自由拓展的基于Playable的动画系统

- 参与引入 Playable 动画系统，实现了非侵入式的动画叠加功能，使演出动画与角色状态机解耦。
- 开发了动态动画创建和运行时混合框架，支持在任意游戏时刻无缝插入和融合复杂动画序列。

#item(
  [ *演出相机系统架构优化* ]
)

#tech[ 相机，演出系统 ]

一个支持多种约束的演出相机系统

- 参与设计并实现了组件化的相机约束系统，支持多种约束条件的组合与优先级管理。
- 实现美术最常用的曲线约束，跟随约束和目标点旋转约束等约束功能，优化演出效果，提高了美术的产能。

== #fa-github 个人项目

#item(
  link(
    "https://github.com/aizawaayame/OnaGameSample",
    [ *基于ALS的个人项目* ]
  )
)
#item(
link(
"https://www.tanedanobata.top/Project/OnaGameSample/",
[ 技术博客: OnaGameSample ]
)
)
#tech[ 相机，动画，ALS ]

用C++重写ALS并重构部分系统

- 使用纯C++重写了Advanced Locomotion System的核心功能，实现了轻量级、高性能的角色运动系统。
- 设计了模块化的Camera Stack架构，支持多种相机效果叠加和平滑过渡。

原首页履历（2025-04-02）

教育背景

学位：哈尔滨工业大学-计算机科学与技术专业-本科
时间段：2018 年 9 月-2022 年 7 月
学信网在线验证码：AVT75TLTCJ0RM8XV

求职意向

游戏客户端开发工程师 / Unreal Engine (UE) C++ 工程师

个人概述

拥有 3 年游戏客户端开发经验。在动画系统、相机系统及编辑器工具开发方面积累了一定经验。了解虚幻引擎核心机制，包括反射系统、垃圾回收、动画系统。
专注于动画模块，演出模块开发及工具链构建

专业技能

编程语言：C++(熟悉)、C#(熟练)
动画系统：熟悉 Unity Playable 动画系统，了解 UE 动画状态机
工具开发：构建面向内容创作的编辑器工具链、自动化流程设计
引擎使用：了解 UE Gameplay 架构，反射系统和垃圾回收机制

项目经验

米哈游|游戏客户端开发：2022 年7 月-至今

表情系统架构升级与 PCG 系统实现

主导设计并实现了基于程序化内容生成 (PCG) 的表情系统，大幅度提升表情制作效率。每 6 周迭代能稳定产出 6000+条对话的表情。
结合 MFCC 音频特征提取和 NLP 情感分析技术，构建了自动化表情生成管线，实现了从文本到面部表情的映射。
设计了标记驱动的表情系统编辑架构，支持批量生成和精细调整两种生产模式，满足不同品质需求。

编辑器 Canvas 图形系统重构

主导编辑器 UI 渲染基础设施的重构，采用 GPU 实例化合批技术，极大提升编辑器 UI 渲染性能。
应用 GPGPU 计算着色器技术处理大量 UI 元素的变换计算，特别针对曲线绘制场景有大幅度的性能优化。
实现了自定义的四叉树空间管理算法，优化了大量 UI 元素的剔除和渲染提交，提高了编辑器响应速度。
设计了高效的 GPU 资源管理机制，实现不同视口大小的无缝切换。

演出动画系统迭代与 Playable 技术引入

参与引入 Playable 动画系统，实现了非侵入式的动画叠加功能，使演出动画与角色状态机解耦。
开发了动态动画创建和运行时混合框架，支持在任意游戏时刻无缝插入和融合复杂动画序列。

演出相机系统架构优化

参与设计并实现了组件化的相机约束系统，支持多种约束条件的组合与优先级管理。
实现美术最常用的曲线约束，跟随约束和目标点旋转约束等约束功能，优化演出效果，提高了美术的产能。

个人项目

用UE C++重写ALS项目。实现文档走跑混合 - 柚子其实是蜜柑

用C++逻辑重写动画相关逻辑。
(进行中)用Camera Stack设计思路重构相机模块。
项目地址GitHub - aizawaayame/OnaGameSample: Rewrite the ALS project using C++.

TArray

Fri, 25 Apr 2025 00:00:00 GMT

概述

TArray是值类型

TArray 是一种值类型，不要使用 new 和 delete 创建和销毁 TArray 实例。

<details> <summary>quote</summary>

TArray is a value type, meaning that it should be treated similarly as any other built-in type, like int32 or float. It is not designed to be extended, and creating or destroying TArray instances with new and delete is not a recommended practice. The elements are also value types, and the array owns them. Destruction of a TArray will result in the destruction of any elements it still contains. Creating a TArray variable from another will copy its elements into the new variable; there is no shared state.

</details>

基础接口

创建

TArray<int32> IntArray;

这将创建一个空数组，用于保存整数序列。元素类型可以是任何值类型，这些类型可以根据常规 C++ 值规则进行复制和销毁，例如 int32 、 FString 、 TSharedPtr 等。由于未指定分配器，因此 TArray 将使用默认的基于堆的分配器。此时，尚未分配任何内存。

填充

核心有两个系列 Emplace 和 Add。

Emplace

template <typename... ArgsType>  
FORCEINLINE SizeType Emplace(ArgsType&&... Args)  
{  
    const SizeType Index = AddUninitialized();  
    new(GetData() + Index) ElementType(Forward<ArgsType>(Args)...);  
    return Index;  
}

根据传入参数，创建一个新的实例。

Add

左值

FORCEINLINE SizeType Add(const ElementType& Item)  
{  
    CheckAddress(&Item);  
    return Emplace(Item);  
}

右值

FORCEINLINE SizeType Add(ElementType&& Item)  
{  
    CheckAddress(&Item);  
    return Emplace(MoveTempIfPossible(Item));  
}

接口最终还是会调用到 Emplace，可以注意到，这个过程中会调用拷贝构造函数或移动构造函数，存在可能的开销。

删除

触发重排(Shuffling)

包含 Remove，RemoveSingle，RemoveAt，RemoveAll 接口。

保持数组中其余元素的原始顺序。
移动被删除位置后的所有元素来填补空缺。

不触发重排(Non-shuffling)

包含 RemoveSwap，RemoveAtSwap，RemoveAllSwap 接口。

不保持数组中其余元素的原始顺序。
用数组末尾的元素来填充被删除的位置

清空所有内容

Empty 接口能直接清空所有元素。

迭代

for

FString JoinedStr;  
for (auto& Str : StrArr)  
{  
    JoinedStr += Str;  
    JoinedStr += TEXT(" ");  
}  
// JoinedStr == "Hello Brave World of Tomorrow ! "

读写迭代器

for (auto It = StrArr.CreateConstIterator(); It; ++It)  
{  
    JoinedStr += *It;  
    JoinedStr += TEXT(" ");  
}

只读迭代器

for (auto It = StrArr.CreateIterator(); It; ++It)  
{  
    JoinedStr += *It;  
    JoinedStr += TEXT(" ");  
}

查询

Num

FORCEINLINE SizeType Num() const  
{  
    return ArrayNum;  
}

GetData

FORCEINLINE ElementType* GetData() UE_LIFETIMEBOUND  
{  
    return (ElementType*)AllocatorInstance.GetAllocation();  
}

获取数组的原始指针，此指针仅在数组存在期间以及对数组进行任何修改操作之前有效。

<details> <summary>quote</summary>

If you need direct access to the array memory, perhaps for interoperability with a C-style API, you can use the GetData function to return a pointer to the elements in the array. This pointer is only valid as long as the array exists and before any mutating operations are made to the array. Only the first Num indices from the StrPtr are dereferenceable

</details>

IsValidIndex

FORCEINLINE bool IsValidIndex(SizeType Index) const  
{  
    return Index >= 0 && Index < ArrayNum;  
}

Contains

包含 Contains 和 ContainsByPredicate，检查特定元素是否存在。

Find和IndexOf系列

查找特定元素。具体可见源码。遇到坑再记录。

Filter系列

函数检索与特定谓词匹配的元素数组。

驾照

Thu, 24 Apr 2025 00:00:00 GMT

驾照记录。

驾驶证申领和使用

考试科目及其合格标准

使用教练车或学车专用标识的车。

不得搭载教练以外的其他人。

科目二考倒车入库，侧方停车，曲线行驶，直角转弯。

申请条件

小车18无上限
轻牵20-70
大客，重牵22-63

客车轻重牵不能初次申领

不得申请：
假 1 吊 2 撤 3 骗 3 毒 3 饮3 醉 5 逃终生。
(关于作弊，考试中 1 年，得逞 3 年)
(注意，如果醉驾犯罪了就是终生了)
运营车辆饮5醉10
竞驶，超员，超速，违法危险运输构成犯罪的，5年

驾驶证审验

小车死人交通事故，记分周期结束后
客车大货重牵，每个积分周期有扣分的
70岁以上每年体检，记分周期结束后
30日内审验

驾驶证遗失

扣押，扣留期间不得补发
继续使用原驾驶证的，200以下罚款，收回原驾驶证

车找登记车管所，证找任意车管所

驾驶证有效期

6，10，长期

驾驶证注销

过期注销的，未满2考一，满二考一三，满三重考

过期一年未换证的，注销

(判断题注销选对，不会被注销选错)

申请增加准驾车型

小车满一年可以申请轻牵

实习期

上高速，三年司机陪同
实习开挂罚200(牵引挂车)

组织违规申领

虚假500，作弊1000，欺骗贿赂2000
五倍10万
组织作弊构成犯罪的，不严重3以下，严重3-7

审验教育：
作假1000，代替2000

学习驾驶证

科二科三分别可以约考5次
学习驾驶证明有效期3年

有效期满，转入，变更换证

期满的，90日内向任意车管所申请换证
变更信息30日
超过有效期一年未换证的，注销驾照
户籍迁出，向迁入地车管所申请换证。换地居住，向居住地车管所申请换证

准驾车型

C1 小车，低速货车，三轮汽车
C2 自动小车
A1 大客
A2 重牵
B1 中客
B2 大货

机动车登记和使用

机动车登记和行驶证

机动车登记证书和行驶证灭失, 丢失和损毁的, 向 登记地车管所 申请补领, 换领。
自受理日 15日内 补发, 换发号牌

年检

运营客车5年内每年一检，5年后半年一检
货车, 大中非运营客车10年内年检, 10年后半年一检
非运营小客车（面包车除外）, 摩托车, 6, 10 检查, 每两年申领检验标志，10年后年检

保险

保险期为1年
1 年未发生事故的, 保费降低

强制报废

驾驶报废车辆上路的, 吊销驾驶证
报废车交售给回收企业

临时号牌

临时号牌3日作废

交通违法记分

12

酒驾
轻伤以上的交通事故逃逸。
伪造, 变更车牌, 行驶证, 驾驶证.....

代替处罚牟利

掉头：
高速公路和城市快车道倒车, 逆行, 穿越中央分隔带掉头

超载, 超速：
校车, 公路客运汽车, 旅游客车超载20, 或者其他客车超过100
校车, 中型以上客车, 危险品货车在高速公路或城市快车道超速20 其他机动车在高速公路, 城市快车道超速50

9

未取得资格驾驶校车的；
驾驶证和驾驶车辆不符的；
遮挡或未悬挂车牌；
中客和危险品超过4小时没有停车休息20分钟的。

违停：
在高速公路或城市快速路上停车的；

超载, 超速：
7座以上超载50-100的
校车, 中型以上客车, 危险品货车在非高速公路或城市快车道超速50的

6

交通事故轻微伤逃逸
驾驶证暂扣期间驾驶机动车
闯红灯
运送危险物品未悬挂警告标识的或进入限制通行区域的

违法占用：
在高速公路或城市快速路上违法占用应急车道；

超载, 超速：
校车, 公路客运汽车, 旅游客车超载0-20,或7座客车20-50 或者其他客车超过50-100
校车, 中型以上客车, 危险品货车在快车道超速0-20, 或其他车道20-50
其他机动车在快车道超速20-50, 或其他车道50-100

3

快车道不按规定车道行驶
不按规定车道超车, 让行
非快车道逆行
玩手机
不礼让行人
不礼让校车
故障没有放置标识
未安全检查上路
货车4小时没有休息20分钟的
高速路上低于最低时速

超载, 超速：

1

安全带, 头盔, 以及其他乱七八遭的
非高速路倒车, 掉头

超载, 超速：

二分搜索

Thu, 24 Apr 2025 00:00:00 GMT

过程

以在一个升序数组中查找一个数为例。

internal static int InternalBinarySearch(  
  T[] array,  
  int index,  
  int length,  
  T value,  
  IComparer<T> comparer)  
{  
  int num1 = index;  
  int num2 = index + length - 1;  
  while (num1 <= num2)  
  {    
    int index1 = num1 + (num2 - num1 >> 1);  
    int num3 = comparer.Compare(array[index1], value);  
    if (num3 == 0)  
      return index1;  
    if (num3 < 0)  
      num1 = index1 + 1;  
    else  
      num2 = index1 - 1;  
  }  
  return ~num1;  
}

输出为正数则代表找到该元素，返回其索引。
输出为负数则代表未找到该元素，返回其插入位置的索引取反。其中 ~0 代表小于所有元素，~length 代表大于所有元素

性质

时间复杂度

二分查找的最优时间复杂度为 $O(1)$。

二分查找的平均时间复杂度和最坏时间复杂度均为 $O(\log n)$。因为在二分搜索过程中，算法每次都把查询的区间减半，所以对于一个长度为 $n$ 的数组，至多会进行 $O(\log n)$ 次查找。

空间复杂度

迭代版本的二分查找的空间复杂度为 $O(1)$

递归（无尾调用消除）版本的二分查找的空间复杂度为 $O(\log n)$

Reference

二分 - OI Wiki

BFS

Tue, 22 Apr 2025 00:00:00 GMT

概述

What Is

BFS 全称是 Breadth First Search，也就是广度优先搜索。

所谓广度优先。就是每次都尝试访问同一层的节点。如果同一层都访问完了，再访问下一层。

结果

这样做的结果是，BFS 算法找到的路径是从起点开始的最短合法路径。换言之，这条路径所包含的边数最小。

在 BFS 结束时，每个节点都是通过从起点到该点的最短路径访问的 。

本质

在实现 BFS 的时候，本质上我们把未被访问过的节点放在一个称为 open 的容器中，而把已经访问过了的节点放在一个称为 closed 容器中。

链式前向星实现

实现代码

链式前向星的实现见图的存储。

伪代码

bfs(s){
    q = new queue()
    q.push(s);
    visited[s] = true;
    while(!q.empty())
    {
        u = q.pop();
        for each edge(u, v)
        {
            if (!visited[v])
            {
                q.push(v);
                visited[v] = true;
            }
        }
    }
}

C++

struct Edge {
    int to;
    int next;
    int w;
};
// u代表起始的顶点
void bfs(int u) {
    queue<int> q;
    q.push(u);
    visited[u] = true;
    // 额外信息
    d[u] = 0;
    p[u] = -1;

    while (!q.empty())
    {
        u = q.front();
        q.pop();
        for (Edge e = head[u]; e.next != -1; e = edge[e.next].next)
        {
            if (!visited[e.to]) {
                q.push(e.to);
                visited[e.to] = true;

                d[e.to] = d[u] + 1;
                p[e.to] = u;
            }
        }
    }
}

执行流程

队列 Q 记录需要处理的节点，以 visited[] 类标记节点是否已经被访问。
初始化时，将起点 s 入队，并标记 visited[s] = true。
每次从队列 Q 中取出队首的节点 u，然后把与 u 相邻的所有节点 v 标记为已访问过并放入队列 Q。

性质

时间复杂度：$O(V + E)$
空间复杂度：$O(V)$

练习题

200. 岛屿数量 - 力扣（LeetCode）

图的存储

Tue, 22 Apr 2025 00:00:00 GMT

约定

$n$ 指代图的点数，$m$ 指代图的边数，$d^{+}(u)$ 指代点 $u$ 的出度。

邻接矩阵

方法

使用二维数组 adj 存边，其中 adj[u][v] 为 1 代表存在从 $u$ 到 $v$ 的边，0 表示不存在。如果是带权图，可以存储权重。

复杂度

查询是否存在某条边：$O(1)$
遍历一个点的所有出边：$O(n)$
遍历整张图：$O(n^2)$
空间复杂度：$O(n^2)$

应用

邻接矩阵只适用于没有重边（或重边可以忽略）的情况。
优点是可以以 $O(1)$ 查询边的存在性。
缺点是空间复杂度高，在稀疏图上空间浪费严重。

邻接表

邻接表 - 维基百科，自由的百科全书

方法

在邻接表的表示中，对于图中的每个顶点，将保存所有其它与之相连的顶点（即“邻接表”）。
在实现上使用一个支持动态增加元素的数据结构构成的数组，如 vector<int> adj[n + 1] 来存边，其中 adj[u] 存储的是点 $u$ 的所有出边的相关信息(终点，边权)。

复杂度

查询是否存在从 $u$ 到 $v$ 的边：$O(d^+(u))$
遍历 $u$ 的所有出边：$O(d^+(u))$
遍历整张图：$O(n+m)$
空间复杂度：$O(m)$

应用

具有通用性，特别是需要对一个点的所有出边进行排序的场合。

链式前向星(Chain Forward Star)

【图论02】动画说图的三种保存方式降低理解门槛邻接表链式前向星邻接矩阵_哔哩哔哩_bilibili

实现

以边为基本单位，记录每条边的目标点。

链式前向星是一种静态链表存储，用边集数组和邻接表相结合，可以快速访问一个顶点的所有邻接点。

链式前向星存储包括两种结构：

头结点数组：head[]，head[i]存以i为起点的最后一条边的下标（在edge[]中的下标）。
边数组：edge[]，edge[i] 表示第 i 条边。

struct node {
    int to; // 第 i 条边的目标点
    int w; // 第 i 条边的边权
    int next; // 第 i 条边同起点的下一跳边的位置
} edge[maxn]

// head[u]和cnt起始设置为-1
int head[maxn] = {-1, ..., -1}; // 头结点数组, 最近一输入的以 i 为起点的边在 edge[] 中的下标
int cnt = -1;

void add(int u, int v, int w) {
    ++cnt;
    
    edge[cnt].to = v;
    edge[cnt].next = head[u];
    edge[cnt].w = w;
    head[u] = cnt;
}

复杂度

查询是否存在从 $u$ 到 $v$ 的边：$O(d^+(u))$
遍历 $u$ 的所有出边：$O(d^+(u))$
遍历整张图：$O(n+m)$
空间复杂度：$O(m)$

应用

存各种图都很适合，但不能快速查询一条边是否存在，也不能方便地对一个点的出边进行排序。

优点是边都是带编号的。

BFS(搜索)

Tue, 22 Apr 2025 00:00:00 GMT

BFS 是图论中的一种遍历算法，详见 BFS

BFS 在搜索中也很常用，将每个状态对应为图中的一个点即可。

相机系统

Mon, 14 Apr 2025 00:00:00 GMT

整体流程

UE的相机系统相比于更加复杂，涉及到 CameraComponent，CameraActor，PlayerController，PlayerCameraManager 几个类。

classDiagram
    UWorld --> APlayerController
    UGameViewportClient --> ULocalPlayer : 渲染画面时获取摄像机的POV
    ULocalPlayer --> APlayerController : 获取POV
    APlayerController "1" <--> "1" APlayerCameraManager : APlayerController创建并驱动PlayerCameraManager
    APlayerCameraManager ..> AActor : 更新ViewTarget
    AActor o--> UCameraComponent : 计算POV
    APlayerCameraManager <--> UCameraModifier : 最后修改POV
    UCameraModifier --> UCameraModifier_CameraShake : 示例说明

    class UWorld {
        +Tick(...)
    }
    
    class UGameViewportClient {
        +Draw()
    }
    
    class ULocalPlayer {
        +CalcSceneView(...)
        +GetViewPoint(...)
    }
    
    class APlayerController {
        +SpawnPlayerCameraManager()
        +UpdateCameraManager()
        +GetPlayerViewPoint(...)
    }
    
    class APlayerCameraManager {
        +UpdateCamera(...)
        +UpdateViewTarget(...)
        +GetCameraCacheView()
    }
    
    class AActor {
        +CalcCamera()
    }
    
    class UCameraComponent {
        +GetCameraView(...)
    }
    
    class UCameraModifier {
        +ModifyCamera()
    }
    
    class UCameraModifier_CameraShake {
    }

CameraActor
1. CameraComponent 的包装容器，以使相机可以放置在关卡中。
CameraComponent
1. 代表相机的各种数据。
2. 并不直接处理数据。
PlayerCameraManager
1. 相机系统的核心，处理相机数据并应用到 ViewTarget。
2. 管理 ViewTarget，记录摄像机跟随对象Target和摄像机POV。

总体流程上：

初始化ViewTarget：

PlayerController 会在 PostInitializeComponents 函数中调用 SpawnPlayerCameraManager 函数。

SpawnPlayerCameraManager

// servers and owning clients get cameras
// If no archetype specified, spawn an Engine.PlayerCameraManager.  NOTE all games should specify an archetype.
FActorSpawnParameters SpawnInfo;
SpawnInfo.Owner = this;
SpawnInfo.Instigator = GetInstigator();
SpawnInfo.ObjectFlags |= RF_Transient;  // We never want to save camera managers into a map
if (PlayerCameraManagerClass != NULL)
{
    PlayerCameraManager = GetWorld()->SpawnActor<APlayerCameraManager>(PlayerCameraManagerClass, SpawnInfo);
}
else
{
    PlayerCameraManager = GetWorld()->SpawnActor<APlayerCameraManager>(SpawnInfo);
}

if (PlayerCameraManager != NULL)
{
    PlayerCameraManager->InitializeFor(this);
}
else
{
    // log
}

每个 PlayerController 都会在世界创建一个 PlayerCameraManager Actor。
针对每个创建的 PlayerCameraManager，都会调用 InitializeFor 函数初始化。

InitializeFor

FMinimalViewInfo DefaultFOVCache = GetCameraCacheView();
DefaultFOVCache.FOV = DefaultFOV;
SetCameraCachePOV(DefaultFOVCache);

PCOwner = PC;

SetViewTarget(PC);

// set the level default scale
SetDesiredColorScale(GetWorldSettings()->DefaultColorScale, 5.f);

// Force camera update so it doesn't sit at (0,0,0) for a full tick.
// This can have side effects with streaming.
UpdateCamera(0.f);

更新ViewTarget：

UWorld 会在 Tick 函数中调用 AplayerController::UpdateCameraManager，驱动 PlayerCameraManager::UpdateCamera 更新 ViewTarget。

World Tick

//...

for (int32 i = 0; i < LevelCollections.Num(); ++i)
{
    //...
    // Update cameras last. This needs to be done before NetUpdates, and after all actors have been ticked.
    for( FConstPlayerControllerIterator Iterator = GetPlayerControllerIterator(); Iterator; ++Iterator )
    {
        if (APlayerController* PlayerController = Iterator->Get())
        {
            if (!bIsPaused || PlayerController->ShouldPerformFullTickWhenPaused())
            {
                PlayerController->UpdateCameraManager(DeltaSeconds);
            }
            else if (PlayerController->PlayerCameraManager && FCameraPhotographyManager::IsSupported(this))
            {
                PlayerController->PlayerCameraManager->UpdateCameraPhotographyOnly();
            }
        }
    }
    //...
}
//...

PlayerController UpdateCameraManager

if (PlayerCameraManager != NULL)
{
    PlayerCameraManager->UpdateCamera(DeltaSeconds);
}

PlayerCameraManager UpdateCamera

if ((PCOwner->Player && PCOwner->IsLocalPlayerController()) || !bUseClientSideCameraUpdates || bDebugClientSideCamera)
{
    DoUpdateCamera(DeltaTime);
    //...
}

应用ViewTarget：

UGameViewportClient 的 Draw 方法渲染画面时，会通过 ULocalPlayer::CalcSceneView 方法，最终从 APlayerCameraManager 中获取 ViewTarget 中的POV数据用于渲染。

处理ViewTarget

FViewTarget 在 APlayerCameraManager::UpdateViewTarget 函数中进行更新。ViewTarget核心关注两个参数。

Target 相机看向的目标，后面的POV基于此进行计算。

USTRUCT(BlueprintType)  
struct FTViewTarget  
{  
    // ...
    /** Target Actor used to compute POV */  
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=TViewTarget)  
    TObjectPtr<class AActor> Target;  
    // ...
};

POV 相对看向目标的各种参数。

摄像机控制

角色旋转控制

摄像机旋转控制

攀爬

Fri, 11 Apr 2025 00:00:00 GMT

本篇基于 GitHub - aizawaayame/OnaGameSample: Rewrite the ALS project using C++. 项目。

具体为 OnaGameSample/Source/Ona/Private/CharacterLogic/CharacterMovement/OnaMantleComponent.cpp at master · aizawaayame/OnaGameSample · GitHub 部分

flowchart TD
    A["非攀爬状态"] --> |"玩家按下起跳键或角色处于下落状态时"| B["攀爬检测(Mantle Check)"]
    B --> C{"是否符合攀爬条件"}
    C -->|否| D["执行起跳或继续下落"]
    C -->|是| E["开始攀爬(Mantle Start)"]
    E --> F{"攀爬是否结束"}
    F -->|否| G["攀爬更新(Mantle Update)"]
    G --> F
    F -->|是| H["结束攀爬(Mantle End)"]
    H --> A
    
    style B fill:#00BFFF,stroke:#000,stroke-width:2px
    style E fill:#00BFFF,stroke:#000,stroke-width:2px
    style G fill:#00BFFF,stroke:#000,stroke-width:2px
    style H fill:#00BFFF,stroke:#000,stroke-width:2px

绑定和驱动

Ctor

PrimaryComponentTick.bCanEverTick = true;  
PrimaryComponentTick.bStartWithTickEnabled = true;

MantleTimeline = CreateDefaultSubobject<UTimelineComponent>(NAME_MantleTimeline);

创建 UTimelineComponent 对象以供后续驱动使用。

BeginPlay

FOnTimelineFloat TimelineUpdated;  
FOnTimelineEvent TimelineFinished;

TimelineUpdated.BindUFunction(this, NAME_MantleUpdate);
TimelineFinished.BindUFunction(this, NAME_MantleEnd);

MantleTimeline->SetTimelineFinishedFunc(TimelineFinished);
MantleTimeline->SetLooping(false);
MantleTimeline->SetTimelineLengthMode(TL_TimelineLength);
MantleTimeline->AddInterpFloat(MantleTimelineCurve, TimelineUpdated);

OwnerCharacter->JumpPressedDelegate.AddUniqueDynamic(this,
    &UOnaMantleComponent::OnOwnerJumpInput);

绑定 MantleUpdate 到 TimelineUpdate 事件，绑定 MantleEnd 到 TimelineFinished 事件。
绑定 MantleTimeline 的 MantleTimelineCurve 曲线事件为 TimelineUpdated。绑定 MantleTimeline 的结束事件为 TimelineFinished。
绑定 OwnerCharacter 的 JumpPressedDelegate 事件到 OnOwnerJumpInput 方法。

Tick

if (OwnerCharacter && OwnerCharacter->GetMovementState() == EOnaMovementState::InAir)  
{  
    if (OwnerCharacter->HasMovementInput())  
    {  
        MantleCheck(FallingTraceSettings, EDrawDebugTrace::Type::ForOneFrame);  
    }  
}

Tick MantleCheck

攀爬检测(Mantle Check)

检测是否符合攀爬条件。

核心思路是进行射线检测和碰撞检测，判断是否符合攀爬条件。
如果是，则关闭 Component 的 Tick 事件，并调用 MantleStart 方法。

从Pawn位置向前碰撞检测

向前打一个胶囊体来判断前面是否有可攀爬的障碍物。

const FVector& TraceDirection = OwnerCharacter->GetActorForwardVector();  
// GetCapsuleBaseLocation 获取 Capsule 底部位置
const FVector& CapsuleBaseLocation = 
    UOnaMathLibrary::GetCapsuleBaseLocation(
        2.f, 
        OwnerCharacter->GetCapsuleComponent());  
    
FVector TraceStart = CapsuleBaseLocation + TraceDirection * -30.f;  
TraceStart.Z += (TraceSettings.MaxLedgeHeight + TraceSettings.MinLedgeHeight) / 2.f;  

FVector TraceEnd = TraceStart + TraceDirection * TraceSettings.ReachDistance;  
float HalfHeight = 1.f + (TraceSettings.MaxLedgeHeight - TraceSettings.MinLedgeHeight) / 2.f;

FHitResult HitResult;  
{  
    const FCollisionShape CapsuleCollisionShape = 
        FCollisionShape::MakeCapsule(
            TraceSettings.ForwardTraceRadius, 
            HalfHeight);  
            
    const bool bHit = World->SweepSingleByProfile(
        HitResult, 
        TraceStart, 
        TraceEnd, 
        FQuat::Identity,
        MantleObjectDetectionProfile, 
        CapsuleCollisionShape, 
        Parameters);
}

<details open> <summary>TraceSetting</summary>

TraceSetting在外部定义，是根据动画来定义的。本项目只有高攀爬和低攀爬两组动画。

MinLedgeHeight，最低可攀爬障碍物的高度，低于这个高度就直接走过去，而不触发攀爬。
MaxLedegeHeight，最高可攀爬动画，高于这个高度，没有合适的动画进行匹配。
ForwardTraceRadius，根据当前角色的胶囊体设计的前向碰撞检测的胶囊体的半径。

</details>

Capsule：碰撞检测
Raduis: 由外部配置 TraceSetting.FrowarTraceRadius 决定。
Height: 高度就是整个可攀爬范围高度。
结合后面的TraceStart.Center的位置这个 Capsule 刚好覆盖整个可攀爬的范围。
TraceStart： Center放在可检测范围的中点，起始点有个-30的常量，相比当前角色胶囊体略微靠后。这样能防止角色靠近障碍物碰撞检测打出时 Penetrate 导致不正常触发攀爬。
TraceEnd： TraceStart+ TraceDirection * TraceSettings.ReachDistance。ReachDistance由动画的前倾动作来决定。

if (!HitResult.IsValidBlockingHit() || OwnerCharacter->GetCharacterMovement()->IsWalkable(HitResult))  
    return false;  
  
if (HitResult.GetComponent() != nullptr)  
{  
    UPrimitiveComponent* PrimitiveComponent = HitResult.GetComponent();  
    if (PrimitiveComponent && PrimitiveComponent->GetComponentVelocity().Size() > AcceptableVelocityWhileMantling)  
    {      
         return false;  
    }
}

未检测到障碍物退出。
障碍物 Iswalkable 退出
障碍物移动速度过快退出

从落脚点上方向下碰撞检测

检测落脚点是否能继续行走。

const FVector InitialTraceImpactPoint = HitResult.ImpactPoint;  
const FVector InitialTraceNormal = HitResult.ImpactNormal;  
  
FVector DownwardTraceEnd = InitialTraceImpactPoint;  
DownwardTraceEnd.Z = CapsuleBaseLocation.Z;  
DownwardTraceEnd += InitialTraceNormal * -15.0f;  

FVector DownwardTraceStart = DownwardTraceEnd;  
DownwardTraceStart.Z += TraceSettings.MaxLedgeHeight + TraceSettings.DownwardTraceRadius + 1.0f;  

{  
    const FCollisionShape SphereCollisionShape = 
        FCollisionShape::MakeSphere(TraceSettings.DownwardTraceRadius);  
    const bool bHit = 
        World->SweepSingleByChannel(
            HitResult, 
            DownwardTraceStart, 
            DownwardTraceEnd, 
            FQuat::Identity, 
            WalkableSurfaceDetectionChannel, 
            SphereCollisionShape);
}

<details open> <summary>TraceSetting.DownwardTraceRadius</summary>

和其他TraceSetting参数一样，在外部配置，该参数由角色的实际大小来决定。

</details>

Sphere：碰撞检测
Raduis: 由外部配置 TraceSetting.DownwardTraceRadius 决定。
TraceStart： $(x，y)$ 的位置根据第一次碰撞结果决定。$Z$ 先算出 TraceEnd，再加上 TraceSettings.MaxLedgeHeight + TraceSettings.DownwardTraceRadius + 1。
TraceEnd：取当前的角色胶囊体底部位置，并添加一个 InitialTraceNormal * -15 的偏移。15这个常量来源是源攀爬动画的根位移，执行一个攀爬动作，该动画在 $Y$ 方向上会+15。

if (!OwnerCharacter->GetCharacterMovement()->IsWalkable(HitResult))  
{  
    return false;  
}

如果落脚点 !IsWalkable 则退出。

检测落脚点是否有足够空间

逻辑比较简单，就是在落脚点处构造一个 Capsule 进行碰撞检测。

const FVector& CapsuleLocationFromBase = 
    UOnaMathLibrary::GetCapsuleLocationFromBase(
        DownTraceLocation, 
        2.f, 
        OwnerCharacter->GetCapsuleComponent());  
        
const bool bCapsuleHasRoom = 
    UOnaMathLibrary::CapsuleHasRoomCheck(
        OwnerCharacter->GetCapsuleComponent(), 
        CapsuleLocationFromBase, 
        0.f, 
        0.f, 
        DebugType, 
        OnaCharacterDebugComponent && OnaCharacterDebugComponent->GetShowTraces());  
        
if (!bCapsuleHasRoom)  
{  
    return false;  
}

触发MantleStart方法

触发 MantleStart，开始进行攀爬。

const FTransform TargetTransform(
    (InitialTraceNormal * FVector(-1, -1, 0)).ToOrientationRotator(),  
    CapsuleLocationFromBase,    
    FVector::OneVector);
    
const float MantleHeight = (CapsuleLocationFromBase - OwnerCharacter->GetActorLocation()).Z;  
EOnaMantleType MantleType;  
if (OwnerCharacter->GetMovementState() == EOnaMovementState::InAir)  
{  
    MantleType = EOnaMantleType::FallingCatch;  
}  
else  
{  
    MantleType = MantleHeight > 125.0f ? EOnaMantleType::HighMantle : EOnaMantleType::LowMantle;  
}

FOnaComponentAndTransform MantleWS;  
MantleWS.Component = HitComponent;  
MantleWS.Transform = TargetTransform;  
MantleStart(MantleHeight, MantleWS, MantleType);

根据当前状态和攀爬高度决定 MantleType (LowMantle，HighMantle，FallingCatch)。
传递 HitComponnet。
传递 TargetTransform，这个参数是根据，ImpactPoint 来动态构造的，注意这个 Transform 的 Rotator 的 $(X，Y)$ 和 ImpactNormal 的方向是相反的。这样就能指向 ImpactPoint 方向。

攀爬开始(Mantle Start)

该函数核心作用有两个

禁用组件Tick

组件每帧Tick会去进行MantleCheck，在开始攀爬后，暂时禁用Tick。

SetComponentTickEnabledAsync(false);

播放蒙太奇

完成了和动画匹配的Timeline逻辑驱动，执行蒙太奇动画播放。

if (MantleParams.AnimMontage && OwnerCharacter->GetMesh()->GetAnimInstance())  
{  
    OwnerCharacter->GetMesh()->GetAnimInstance()->Montage_Play(
                MantleParams.AnimMontage, 
                MantleParams.PlayRate,  
                EMontagePlayReturnType::MontageLength,  
                MantleParams.StartingPosition, 
                false);  
}

攀爬更新(Mantle Update)

MantleUpdate 实际上是由 MantleTimeline 进行驱动的。

核心逻辑是 执行和动画匹配的位移和旋转 。

攀爬结束(Mantle End)

MantleUpdate 实际上是由 MantleTimeline 进行驱动的。

在 Timeline 播放结束后，会触发该事件。

核心逻辑是重新打开组件的Tick，以使能进行 MantleCheck。

SetComponentTickEnabledAsync(true);

this指针

Fri, 11 Apr 2025 00:00:00 GMT

当类的成员函数被调用时，this 指针会被自动传递给该函数。

this 指针的类型是 const Type* const，它是一个只读指针，指向当前对象。

不能修改 this 指针的值，但可以通过 this 访问对象的成员。

空指针调用

空指针调用不访问this的成员函数

#include<iostream>
using namespace std;

class A {
public:
    void Print() {
        cout << "A::Print()" << endl;
    }
private:
    int _a;
};

int main() {
    A* p = nullptr;
    p->Print();  // 能否正常运行？
    return 0;
}

<div class="external-embed" data-pagefind-ignore><button type="button" data-embed-src="https://godbolt.org/e?readOnly=true&hideEditorToolbars=true#g:!((g:!((g:!((h:codeEditor,i:(filename:">点击加载交互代码示例</button><a href="https://godbolt.org/e?readOnly=true&hideEditorToolbars=true#g:!((g:!((g:!((h:codeEditor,i:(filename:" target="_blank" rel="noopener noreferrer">在原网站打开</a></div>

当调用 p->Print() 时，this 指针实际上等于 nullptr，但由于 Print() 函数没有访问任何成员变量，因此C++允许这个调用。
this 指针是隐含的，虽然在函数内部会传递 this，但是如果成员函数不访问任何成员变量，C++不需要解引用这个空指针，因此不会出现空指针访问的错误。

空指针调用访问this的成员函数

#include<iostream>
using namespace std;

class A {
public:
    void Print() {
        cout << "A::Print()" << endl;
        cout << _a << endl;
    }
private:
    int _a;
};

int main() {
    A* p = nullptr;
    p->Print();  // 能否正常运行？
    return 0;
}

当 this 指针为 nullptr 时，访问 this->_a 等同于尝试通过空指针访问成员变量。这是一种未定义行为，在大多数系统中会导致程序崩溃。
成员变量 _a 存储在对象的内存空间中，而通过空指针访问成员变量时，由于没有实际的对象空间可用，因此程序在运行时会发生崩溃。

[!NOTE] 空指针调用成员函数 总结来说，空指针调用成员函数本身并不会报错 ，因为成员函数本来就不在类中，所以不是解引用，编译时的汇编代码这里就只是一段函数的地址而已，只是这里没有对象，传过去的 this 指针就是空指针，但只要该成员函数不涉及访问成员变量或其他依赖对象内存的操作那就不会报错。

然而，一旦成员函数试图通过 this 指针访问成员变量，程序就会崩溃，因为 this 为 nullptr，没有有效的内存空间可供访问。

this指针存放位置

this 指针作为成员函数的一个隐含参数，存储在栈中。每当一个成员函数被调用时，this 指针会作为函数参数被压入栈中。

this指针其实就是函数的参数而已

轴向

Thu, 10 Apr 2025 00:00:00 GMT

每次都容易忘，故记录一下UE的轴向问题。

UE是左手系。

移动

/// caption
UE 的 X 轴向前(R)，Y 轴向右(G)，Z 轴向上(B)
///

旋转

/// Caption
X轴-Roll，Y轴-Pitch，Z轴-Yaw
///

Return Value Optimization

Thu, 10 Apr 2025 00:00:00 GMT

在函数返回值的传递过程中，可能会触发多次对象的拷贝构造或移动操作。为了减少这些不必要的拷贝，C++ 编译器会采用一些优化技术，如 拷贝省略 (1)、返回值优化 (2)和 命名返回值优化 (3)。

Copy Elision
Return Value Optimization，RVO
Named Return Value Optimization，NRVO

RVO和NRVO的启用条件

RVO 和 NRVO 是编译器自动完成的优化，但是这些优化并不总是启用，具体取决于编译器的实现和配置

在 C++17 之前，RVO 是一个可选优化，但在 C++17 标准之后，RVO 被强制启用，编译器必须在符合条件的情况下执行拷贝省略。
NRVO 通常依赖于编译器的智能分析，虽然大多数现代编译器都能支持 NRVO，但其效果和激进程度因编译器和版本的不同而有所差异。

按值传递和拷贝省略

不具名返回值优化

不具名返回值优化发生在返回一个无名对象或者临时对象,，一般是 Return 语句中直接创建并返回的对象。

URVO 从 C++98 开始已被许可，但是一直到 C++17 编译器才强制返回值优化。

无返回值优化

Data GetData()  
{  
    return Data{};  // ctro1  
                    // copy ctor2, dtor1  
}

int main()
{
    Data d = GetData(); // copy ctor3, dtor2
    return 0;           
                        // dtor3
}

对象发生多次拷贝。

其中第三次拷贝和赋值右值相关。

有返回值优化

Data GetData()  
{  
    return Data{};  // ctro1  
}

int main()
{
    Data d = GetData(); 
    return 0;           
                        // dtor1
}

对象只被构造一次。

具名返回值优化

具名返回值优化一般发生在返回一个已经创建的对象。

MSVC默认不开启具名返回值优化，如果需要开启优化，需要在 /O2 下编译。

容器返回值优化

对于容器来说，若整个容器发生拷贝，代价很高。

因此，非常有必要考虑返回值优化。C++17 开始，强制对容器进行返回值优化。

std::vector<Data> GetDataContainers() {
    //!!! case 1
    // return std::vector<Data>{Data{}};    // ctor 1, copy ctor 2, dtor 1

    //!!! case 2
    std::vector<Data> vec{Data{}};          // ctor 1, copy ctor 2, dtor 1
    return vec;
}                                          

int main() {
    auto d = GetDataContainers();    
    return 0;
}                                           // dtor 2

<div class="external-embed" data-pagefind-ignore><button type="button" data-embed-src="https://godbolt.org/e#z:OYLghAFBqd5QCxAYwPYBMCmBRdBLAF1QCcAaPECAMzwBtMA7AQwFtMQByARg9KtQYEAysib0QXACx8BBAKoBnTAAUAHpwAMvAFYTStJg1DIApACYAQuYukl9ZATwDKjdAGFUtAK4sGIM2akrgAyeAyYAHI%2BAEaYxP7SAA6oCoRODB7evv6ByamOAqHhUSyx8WbSdpgO6UIETMQEmT5%2BAbaY9gUMdQ0ERZExcQm29Y3N2W0Ko31hA6VDFQCUtqhexMjsHOYAzGHI3lgA1Cbbbk5TxJisJ9gmGgCCO3sHmMenyFPoWFQ3d49muwY%2By8RxObg%2BBGIYWAvweTyBLzebi8jlohAAnrD/oDgaDTgA3apEYhYv5TJiOZCHMIEQ5oLyCOInCyHAD0rLpq0ZxEORGpWEEeCo6OpDHJQMwCkOqCohyEfzJkK8DkOABEKUxjgB2KwPQ760W0vAmHWHDTa1XMv4Gw38q1wvUG9X1CCLQ4gO2m6zWenci3a3X3G02z4gFCrWlgsHHAIOEgxsxI6N4dBJ04JkwAVjcDHMZntQYNJstDsL%2BudTAgaDFtIr5gAbIcFG6PcbTQoAHR4C2kT0s72WX0EOL%2Bk2B4MG0PhlFptwJtCJEVxnl52f8td5rM5zfbcdFrUlx6O8sahvSxJxCkkE6qqsCKZq09mRvoDVusfWifUt6qw6v%2BpdgWX5NgQ6BhvSkanNGeYLiKTAKKkwAMAma7/kwXaplG6arnyq5YXOKYbgEW65sRu6fhOlwEGsyEAFQEAgeAKEB%2B6HhRhwAH4Vq6AbsSGoHgRGRFmOgxIofh64SZu2akfm5HHhaCoHgWipgSAhLLmCdbbNghwAOKYAQFYeIITCzMQCg8R%2BCnsmAdn2XS8GvFw7HsocVE0SBakacSWmnjpY51jqxYhbuNpucuhxcL2sF0mJgR/mJLmluFrL2Q5ohKIc%2BYKVOPnXqc2m6RpgWnsFynKWFwFshykXRZyi5xfGCWifGyVlu5hmeSV8mPAe1UDYNQ0Kg8NKHCwZkMFZwUKUwKKoH%2BP76YZxmyJNcSWYszI2uxHnEMhGgqf1Q0nadBpua1PJmBwyy0Jwma8H4HBaKQqCcG4A4sgoqzrK8Ow8KQBCaDdywANYSBoGj6Jwki8CwICZlDT0vW9HC8AoIBQ0Dz03aQcCwEgmCqNU81kBQEANMACjKIYHRCAgqAAO5PQDaAsIkdAUukNPhLQ9NM8jvBsxz9DxMAXBtMLdBxBErCbELqDs9LxAAPIovzzPA0ExPIPcxBU5wvBE9UdT4E9vD8IIIhiOwUgyIIigqOoOOkLo0UGEYKCffoeDRBjkDLKgiRdBjHAALSfDepiWNYZjmmHADqYi0IcidE5Cmphxer6CsgvCoISxBQlg/uuqQxAMo4bAACqoJ4pfLN9awbHonxhDzdMM5r3C8JCmCbADjPEEwiScDwt33Y9Wuo9gOuk4cqgABz1mH9aSIcwDIFSEsdomEAfTHli9rghDxv9iy98DizLAgVxYPEZd3RwsOkPDiOkILr2G7YmOA1fE8cG2FPF2qNL442vqQQuqRnCSCAA%3D%3D">点击加载交互代码示例</button><a href="https://godbolt.org/e#z:OYLghAFBqd5QCxAYwPYBMCmBRdBLAF1QCcAaPECAMzwBtMA7AQwFtMQByARg9KtQYEAysib0QXACx8BBAKoBnTAAUAHpwAMvAFYTStJg1DIApACYAQuYukl9ZATwDKjdAGFUtAK4sGIM2akrgAyeAyYAHI%2BAEaYxP7SAA6oCoRODB7evv6ByamOAqHhUSyx8WbSdpgO6UIETMQEmT5%2BAbaY9gUMdQ0ERZExcQm29Y3N2W0Ko31hA6VDFQCUtqhexMjsHOYAzGHI3lgA1Cbbbk5TxJisJ9gmGgCCO3sHmMenyFPoWFQ3d49muwY%2By8RxObg%2BBGIYWAvweTyBLzebi8jlohAAnrD/oDgaDTgA3apEYhYv5TJiOZCHMIEQ5oLyCOInCyHAD0rLpq0ZxEORGpWEEeCo6OpDHJQMwCkOqCohyEfzJkK8DkOABEKUxjgB2KwPQ760W0vAmHWHDTa1XMv4Gw38q1wvUG9X1CCLQ4gO2m6zWenci3a3X3G02z4gFCrWlgsHHAIOEgxsxI6N4dBJ04JkwAVjcDHMZntQYNJstDsL%2BudTAgaDFtIr5gAbIcFG6PcbTQoAHR4C2kT0s72WX0EOL%2Bk2B4MG0PhlFptwJtCJEVxnl52f8td5rM5zfbcdFrUlx6O8sahvSxJxCkkE6qqsCKZq09mRvoDVusfWifUt6qw6v%2BpdgWX5NgQ6BhvSkanNGeYLiKTAKKkwAMAma7/kwXaplG6arnyq5YXOKYbgEW65sRu6fhOlwEGsyEAFQEAgeAKEB%2B6HhRhwAH4Vq6AbsSGoHgRGRFmOgxIofh64SZu2akfm5HHhaCoHgWipgSAhLLmCdbbNghwAOKYAQFYeIITCzMQCg8R%2BCnsmAdn2XS8GvFw7HsocVE0SBakacSWmnjpY51jqxYhbuNpucuhxcL2sF0mJgR/mJLmluFrL2Q5ohKIc%2BYKVOPnXqc2m6RpgWnsFynKWFwFshykXRZyi5xfGCWifGyVlu5hmeSV8mPAe1UDYNQ0Kg8NKHCwZkMFZwUKUwKKoH%2BP76YZxmyJNcSWYszI2uxHnEMhGgqf1Q0nadBpua1PJmBwyy0Jwma8H4HBaKQqCcG4A4sgoqzrK8Ow8KQBCaDdywANYSBoGj6Jwki8CwICZlDT0vW9HC8AoIBQ0Dz03aQcCwEgmCqNU81kBQEANMACjKIYHRCAgqAAO5PQDaAsIkdAUukNPhLQ9NM8jvBsxz9DxMAXBtMLdBxBErCbELqDs9LxAAPIovzzPA0ExPIPcxBU5wvBE9UdT4E9vD8IIIhiOwUgyIIigqOoOOkLo0UGEYKCffoeDRBjkDLKgiRdBjHAALSfDepiWNYZjmmHADqYi0IcidE5Cmphxer6CsgvCoISxBQlg/uuqQxAMo4bAACqoJ4pfLN9awbHonxhDzdMM5r3C8JCmCbADjPEEwiScDwt33Y9Wuo9gOuk4cqgABz1mH9aSIcwDIFSEsdomEAfTHli9rghDxv9iy98DizLAgVxYPEZd3RwsOkPDiOkILr2G7YmOA1fE8cG2FPF2qNL442vqQQuqRnCSCAA%3D%3D" target="_blank" rel="noopener noreferrer">在原网站打开</a></div>

Reference

const

Thu, 10 Apr 2025 00:00:00 GMT

只需要记住 const是优先左匹配的。

nullptr

Thu, 10 Apr 2025 00:00:00 GMT

在 C++11 之前，使用 NULL 来表示空指针。NULL 在模版匹配和重载函数匹配语义不清晰，而 nullptr 具有更加确定和清晰的语义。

nullptr 是 c 11 中引入的新关键字，专门表示空指针，且具有特殊的类型 nullptr_t。
1. nullptr_t 是一个类型，nullptr 是一个实例。
2. nullptr_t 并不是指针类型，但能隐式转换为任意指针类型。
3. nullptr_t 能和指针类型进行关系运算。
<br/>

#ifndef NULL  
    #ifdef __cplusplus        
        #define NULL 0  
    #else  
        #define NULL ((void *)0)  
    #endif  
#endif

cpp 中 void* 类型不能隐式转换成其他的类型指针。int* p = (void*)0 在 cpp 中是非法的。
cpp 中 0 或 NULL 是能隐式转换成指针类型的。int* p = NULL 和 int* p = 0 是合法的。
cpp 中认为一个指针变量为 0 时为空指针。

MSVC 中如果存在函数 f(int) 和重载版本 f(int*)，那么 NULL 会被匹配到 f(int)，而 int* p = NULL 会被匹配到 f(int*)。

[!NOTE] Difference

nullptr

模版推导中，nullptr 会被推导为 nullptr_t 类型。且可隐式转换为指针类型。

NULL

模版推导中，NULL 会被推导为 int 类型。作为 int 类型，可以隐式转换为指针类型。

sizeof

Thu, 10 Apr 2025 00:00:00 GMT

指针:
1.指针大小永远固定。取决于 编译的目标平台的位数 。32 位就是 4 字节，64 位就是 8 字节。

数组：
1.数组 作为函数参数时会退化为指针 ，大小按指针计算。

类
1.struct 结构体要考虑 字节对齐 。
2.如果 class 配置了虚函数，则会在 头部添加虚函数表 。
3.空类会用 1 个字节进行占位。

static

Thu, 10 Apr 2025 00:00:00 GMT

局部变量：
1. 变量只被初始化一次，保留在 静态区 直到程序结束。

全局变量：
1. 变量具有 文件作用域 。

成员变量：
1. 变量不会绑定到对象上。

UE垃圾回收概述和应用

Wed, 09 Apr 2025 00:00:00 GMT

算法

分类	方式	描述
分类一	引用计数式	通过额外的计数来实时计算对单个对象的引用次数，当引用次数为0时回收对象。<br>如：微软COM对象。句柄功能的引用值以及C++中的智能指针都是通过引用计数来实现GC的
	追踪式（UE）	达到GC条件时（内存不够用，到达GC回收的时或者强制GC）通过引擎系统中是否有对象的引用来判断对象是否存活，然后回收无引用对象
分类二	保守式	不能准确识别某一个无用的对象（比如在32位程序中的一个4字节的值，它是不能判断出它是一个对象指针还是一个数字的），但是能保证在不会错误回收存活的对象的情况下回收一部分无用对象。<br>不需要额外的数据来支持查找对象的引用，它所有的内存数据假定为指针。通过一些条件来判定这个指针是否是一个合法的对象
	精确式（UE）	在回收过程中能准确得到别的回收每一个无用对象的GC方式，为了准确识别每一个对象的引用，通过需要一些额外的数据（比如在类中的属性UPROPERTY）
分类三	搬迁式	GC过程中需要移动对象在内存中的位置，当然移动对象位置后需要修正所有引用到这个对象的地方更新到新的位置（有的通过句柄来实现，而有的可能需要修改所有引用内存的指针）。
	非搬迁式（UE）	在GC过程中不需要移动对象的内存位置
分类五	增量式	不会在对象被弃时立即回收占用的内存资源，而是在GC达成一定条件时进行回收操作
	非增量式（UE）	在对象被抛弃时立即回收占用的内存资源

UE的垃圾回收机制采用 追踪式，精确式，非搬迁式，非渐进式 的 Mark-Sweep 算法。

直接或间接被根节点引用的方法

调用 AddToRoot 函数，将UObject对象添加到根节点。(1)
RemoveFromRoot 能去除 EInternalObjectFlags::RootSet 标记。
通过 UPROPERTY 保持引用。(1)
UPROPERTY 宏修饰 UObject* 成员变量。
UObject* 放在 UPROPERTY 宏修饰的 TArray、TMap 中也能保持引用。

Unreal implements a garbage collection scheme whereby UObjects that are no longer referenced or have been explicitly flagged for destruction will be cleaned up at regular intervals. The engine builds a reference graph to determine which UObjects are still in use and which ones are orphaned. At the root of this graph is a set of UObjects designated as the "root set". Any UObject can be added to the root set. When garbage collection occurs, the engine can track all referenced UObjects by searching the tree of known UObject references, starting from the root set. Any unreferenced UObjects, meaning those which are not found in the tree search, will be assumed to be unneeded, and will be removed.

Unreal Object Handling in Unreal Engine | Unreal Engine 5.5 Documentation | Epic Developer Community

针对UPROPERTY的优化设计

UE源码中，能看到很多的Property并没有被标记为 UPROPERTY。这种设计往往会通过持有引用的方式来保证不被垃圾回收。

这样做的目的是优化垃圾回收的性能，减少特别追踪的数量。

Actor Role and Remote Role

Wed, 09 Apr 2025 00:00:00 GMT

Get Role 接口

const ENetRole LocalRole = MyActor->GetLocalRole();

获取当前Actor的LocalRole

const ENetRole RemoteRole = MyActor->GetRemoteRole();

获取当前Actor的RemoteRole

Actor Role States

Role	Description
`ROLE_None`	无角色。此 Actor 不会被复制。
`ROLE_SimulatedProxy`	此 Actor 的模拟代理。此 Actor 模拟真实状态，但无权更改状态或调用远程函数。
`ROLE_AutonomousProxy`	此 Actor 的自主代理。此 Actor 模拟真实状态，并且有权更改状态和调用远程函数。
`ROLE_Authority`	对此 Actor 的权威控制。此 Actor 拥有网络连接的真实状态，并且有权更改状态和调用函数。此 Actor 还负责跟踪属性更改并将它们复制到连接的客户端。

void APawn::PossessedBy(AController* NewController)
{
    //...
    if (APlayerController* PlayerController = Cast<APlayerController>(Controller))
    {
        if (GetNetMode() != NM_Standalone)  
        {  
            SetReplicates(true);  
            SetAutonomousProxy(true);  
        }
    }
    //...
}

void AActor::SetAutonomousProxy(const bool bInAutonomousProxy, const bool bAllowForcePropertyCompare)
{
    if (bReplicates)
    {
        //...
        const TEnumAsByte<enum ENetRole> OldRemoteRole = RemoteRole;  
        RemoteRole = (bInAutonomousProxy ? ROLE_AutonomousProxy : ROLE_SimulatedProxy);
        //...
    }
    //...
}

在 PossessedBy 函数中这只 RemoteRole 。
设置函数为 Actor::SetAutonomousProxy, 如果存在主控客户端则设置为 ROLE_AutonomousProxy，否则默认为 ROLE_SimulatedProxy。

Actor Role Matrix

Local Role 本地角色	Remote Role 远程角色	Server or Client 服务器或客户端	Description 描述
`ROLE_Authority`	`ROLE_AutonomousProxy`	Server 服务器	此 Actor Pawn 由连接的客户端之一控制。
`ROLE_AutonomousProxy`	`ROLE_Authority`	Client 客户端	此 Actor Pawn 由此连接的客户端控制。
`ROLE_SimulatedProxy`	`ROLE_Authority`	Client 客户端	此 Actor Pawn 由其他连接的客户端之一控制。<br>未被任何客户端控制的复制 Actor 也可以具有此角色组合。
`ROLE_Authority`	`ROLE_None`	Client 客户端	这是一个未复制的 Actor。

相机模块设计

Wed, 09 Apr 2025 00:00:00 GMT

ALS的相机模块利用一个函数实现，在实际项目中，这样的做法存在很多问题：

多种相机模式耦合，不利于拓展和维护。
相机任何修改都需要QA全量回归，不利于项目迭代。

整体设计

整体设计上，采用Stack-State-Processor的架构。

Stack层：负责相机模式切换，并提供一个统一的接口给上层使用。
State层：负责相机的具体模式。
Processor层：负责处理相机单一职责，如跟随、视角转换等。

Actor

Wed, 09 Apr 2025 00:00:00 GMT

What Is :
Actor 是可以放置在关卡中的任何对象，例如摄像机、静态网格体或玩家起始位置。

What Can Do :
Actor 支持 3D 变换，例如平移、旋转和缩放。
Actor 可以通过游戏代码（C++或蓝图）创建（生成）和销毁。
Actor 的支持网络复制属性和函数调用。

组件

Actor 视为容纳称为组件的特殊类型对象的容器。不同类型的组件可用于控制 Actor 的移动方式、渲染方式等。

UActorComponent 是所有组件的基类。
USceneComponent 具有变换的 UActorComponent 。
Actor 的变换由 USceneComponent 层级结构根部的 USceneComponent 决定。
UPrimitiveComponent 是所有图形表示几何组件的基类。

根组件

What Is :
每个 Actor 都有一个 RootComponent 且 RootComponent 必须是 USceneComponent 的子类。
What Can Do :
提供世界的 Transform 信息。
提供层次化组织 Components 和 Actor 的能力。

类型为 USceneComponent*，是 Actor 的根场景组件，负责定义 Actor 在世界中的位置、旋转和缩放。
所有其他 USceneComponent 类型的组件（例如 UStaticMeshComponent、USkeletalMeshComponent）通过 AttachToComponent 形成层次结构，挂接到 RootComponent 或其他场景组件。
如果 RootComponent 为 nullptr，Actor 不会出现在场景中（无法进行变换）。

UPROPERTY(BlueprintGetter=K2_GetRootComponent, Category="Transformation")
TObjectPtr<USceneComponent> RootComponent;

/**
* Sets root component to be the specified component.  NewRootComponent's owner should be this actor.
* @return true if successful
*/
ENGINE_API bool SetRootComponent(USceneComponent* NewRootComponent);

Actor本身没有变换，Actor的变换由根 RootComponent 决定。

具体来说，如果此 Root Component 是 SceneComponent，它将提供 Actor 的变换信息。否则，Actor 将没有变换信息。

const FTransform& AActor::GetTransform() const  
{  
    return ActorToWorld();  
}

FORCEINLINE const FTransform& AActor::ActorToWorld() const  
{  
    return (RootComponent ? RootComponent->GetComponentTransform() : FTransform::Identity);  
}

AActor::GetTransform() 返回 ActorToWorld() 的结果。
ActorToWorld() 返回 RootComponent 的变换。如果没有 RootComponent ，则返回 FTransform::Identity 。

组件的绑定和注册

静态绑定

在 Blueprint 或 C++ 类中定义的组件通过 UPROPERTY() 宏标记组件为 AActor 的成员变量。
在构建函数中通过 CreateDefaultSubobject 创建实例绑定到变量。
如果是 SceneComponent，调用 SetupAttachment 函数设置层次结构。

<details open> <summary>SetupAttachment 和 AttachtoComponent</summary>

SetupAttachment 初始化组件预期附加的父组件(和插槽)信息，在组件注册时生效。

SetupAttachment
1. 设计上预期在构造函数中创建的组件应使用 SetupAttachment。
2. 只是设置预期的附加信息，不会立即执行附加操作。(仅设置AttachParent和AttachSocketName两个变量，并标记bShouldBeAttached)

<details open> <summary>Comments In SceneComponent.h</summary>

Initializes desired Attach Parent and SocketName to be attached to when the component is registered.

Generally intended to be called from its Owning Actor's constructor and should be preferred over AttachToComponent when a component is not registered.

</details>

AttachtoComponent
1. 设计上预期在运行时动态创建的组件应使用 AttachToComponent。
2. 会立即执行附加操作。
3. 无论是否注册，都可以调用这个方法。但是在注册前优先调用SetupAttachment。

<details open> <summary>Comments In SceneComponent.h</summary>

Attach this component to another scene component, optionally at a named socket. It is valid to call this on components whether or not they have been Registered, however from constructor or when not registered it is preferable to use SetupAttachment.

</details>

动态绑定

运行时通过 AActor::AddComponent 添加一个新组建到Actor，并分配所有权到该 Actor。

支持自动附加（第一个组件成为根组件，后续组件挂载到根下），但如果设置 bManualAttachment 为 true，则需要手动处理附加逻辑。

<details open> <summary>Comment In Actor.h</summary>

Creates a new component and assigns ownership to the Actor this is called for.

Automatic attachment causes the first component created to become the root, and all subsequent components to be attached under that root.

When bManualAttachment is set, automatic attachment is skipped and it is up to the user to attach the resulting component (or set it up as the root) themselves.

</details>

注册和注销

组件和Actor层级结构

graph LR
    A[Actor] --> B["Root Component(SceneComponent)"]
    A --> C[Actor Component]
    A --> D[Actor Component]
    A --> E["..."]
    B --> F[Scene Component]
    B --> G[Scene Component]
    F --> H[Scene Component]
    G --> I[Scene Component]

实现一个基础的智能指针

Tue, 08 Apr 2025 00:00:00 GMT

实现一个基础的智能指针。

智能指针想要解决的问题

class TestObject //测试用对象
{
public:
    //构造函数
    TestObject()
    {
        cout << "构造TestObject" << endl;
    }
    //析构函数
    ~TestObject()
    {
        cout << "析构TestObject" << endl;
    }
    //测试函数
    void TestFunc()
    {
        cout << "TestFunc" << endl;
    }
};

可以选择在“栈”中创建这个对象，或是在“堆”中创建这个对象（即用 new），但他们都面临各自的问题。

在栈中创建对象

int main()  
{  
    TestObject* ptr;    //声明一个对象指针  
    {  
        TestObject test;//创建一个对象  
        ptr = &test;    //指针指向这个对象  
    }  
    ptr->TestFunc();//此处虽然尝试调用，但是“test”已经被销毁了  
}

如果在“栈”中创建这个对象，那么对象保证可以释放掉内存。
但缺点是：它只能在作用域内起效，离开了作用域就将销毁。

在堆中创建对象

int main()  
{  
    TestObject* ptr = new TestObject();  
    ptr->TestFunc();  
}

在“堆”中创建对象，可以保证对象在离开作用域后仍然存在。
但缺点是：需要手动释放内存。

智能指针

智能指针既能在离开作用域之后继续使用，又不用额外的设计来放置对象不被销毁。
一种实现这种理想的方式是：引用计数 。

思路是维护一个 引用计数器 来统计这个对象被引用的次数，一旦其值变为0则销毁它。

template<typename T>
class SmartPointer //智能指针
{
private: //内部的定义：
    class Counter   //引用计数器，一个对象的所有智能指针应该公用一个计数器
    {
    public:
        T* ObjectPtr;       //对象的指针
        int ReferenceCount; //引用计数

        Counter(T* Ptr)//构造函数中得到对象指针，引用计数设为1
        {
            ObjectPtr = Ptr;
            ReferenceCount = 1;
        }
        ~Counter()//析构函数中销毁对象
        {
            delete ObjectPtr;
        }
    };

private: //私有成员：
    Counter* MyCounter;     //指向引用计数器的指针

public:
    //构造函数（使用普通对象指针）
    SmartPointer(T* Ptr)
    {
        MyCounter = new Counter(Ptr);
        cout << "使用普通对象指针来构造" << endl;
    }
    //构造函数（使用其他智能指针）
    SmartPointer(const SmartPointer &Other)
    {
        MyCounter = Other.MyCounter;
        MyCounter->ReferenceCount++;
        cout << "使用其他智能指针来构造，引用计数："<< MyCounter->ReferenceCount << endl;
    }
    //析构函数
    ~SmartPointer()
    {
        MyCounter->ReferenceCount--;
        cout << "智能指针对象析构，当前引用计数：" << MyCounter->ReferenceCount << endl;
        if (MyCounter->ReferenceCount == 0)
            delete MyCounter;   
    }
    //重载“->”运算符，让它能像普通对象指针一样使用
    T* operator->() const
    {
        return MyCounter->ObjectPtr;
    }
};

走跑混合

Tue, 08 Apr 2025 00:00:00 GMT

Ciallo ～(∠・ω< )⌒★!

知乎

本文讨论基于学习用的 ALSCPP 项目 GitHub - aizawaayame/OnaGameSample: Rewrite the ALS project using C++.

Concept

在一切开始前，先明确几个概念的约定，方便后续的讨论和实现。

步态 Gait：
1. 代表了角色处于 Walk，Run，Sprint 三个状态。这三个状态由用户输入决定，而不是取决于角色当前的速度。

步型 Walk/Run Blend：
1. 代表 Walk→Run 的混合度。不知道怎么命名了，就叫歩型吧。

步幅 Stride：
1. 角色迈步的幅度。作为混合空间的其中一个轴向。

步频 Play Rate：
1. 角色迈步的频率。作为动画播放的频率。

定义2D混合空间

/// caption
纵轴定义 Walk/Run 的混合，横轴定义了步幅。

Idle→walk→run 的一维混合空间无法处理直接起步跑的情景。而二维空间可以。
///

/// caption
混合空间左边起点设计了不同于 Idle 的起步姿势，且走跑各不相同。这是因为项目没有起步动画，而是通过 Idle 和起步姿势的混合来做到起步的。
///

步态，歩型，步幅和步频

Gait

由用户的输入进行切换。在 ALS 中，采用 Shift 和 Ctrl 进行切换。

逻辑步态
1. 根据玩家输入进行切换。
2. 存储在CharacterInformation.Gait，每帧更新。
动画步态
1. 当前实际播放的动画执行的步态。
2. 动画步态存储在骨骼曲线 Weight_Gait 中，由动画驱动更新。执行不同动画时会被动画动态修改。

Walk/Run Blend

return CharacterInformation.Gait.IsWalking() ? 0.0f : 1.0;

存储在 Grounded.WalkRunBlend。每帧由函数 CalclulateWalkRunBlend 计算。

计算非常简单，单纯检查当前步态。

Stride

Play Rate

Reference

UE4/UE5 骨骼动画高级运动系统走跑混合初步

八向移动

Thu, 20 Mar 2025 00:00:00 GMT

Ciallo ～(∠・ω< )⌒★!

本文讨论基于学习用的 ALSCPP 项目：
GitHub - aizawaayame/OnaGameSample: Rewrite the ALS project using C++.

1. 问题

在项目中我们有以下问题：

如何在缺少具有方向的八向动画下实现转向?
如何解决极端变换下导致的臀位扭转穿帮?
如何实现轴心切换时的前倾和后仰?

2. 思路

2.1. 转向思路

ALS 的只有六个动画。
分别是正前，正后，左进，左退，右进，右退。实际上只有四个方向的动画。
为了实现八向动画引入 YawOffset 来实现实际的转向。这个 YawOffset 会在代码中读取，并用于修改角色的 Rot。

2.2. 臀位思路

构建六向状态机，通过构造环形变换来限制极端变换的出现。这个见后文实现部分的描述。

2.3. 轴心切换思路

实现轴心切换可以在部分状态机切换时触发"pivot"事件，来添加前倾和后仰。后文的状态机切换部分会进行描述。

3. 实现

3.1. 数据

digraph G {
  graph [rankdir="TB"]; // Assuming a Top-to-Bottom layout

  // Define central nodes (adjust names based on the image)
  node [shape=ellipse, style=filled, fillcolor=lightblue];
  central_node1 [label="Data"];


  // Define intermediate nodes (adjust names and shapes)
  node [shape=box, style=rounded];
  intermediate_a [label="Movement Data"];
  intermediate_b [label="Anim Curve"];
  intermediate_c [label="Anim Skeleton"];

  // Define leaf nodes (adjust names and shapes)
  node [shape=plaintext];
  leaf_1 [label="MovementDirection"];
  leaf_2 [label="VelocityBlend"];
  leaf_3 [label="Feet_Crossin"];
  leaf_4 [label="HipOrientation_Bias"];
  leaf_YawOffset [label="YawOffset"];
  leaf_5 [label="Blend Profile"];


  // Define edges and their directions
  central_node1 -> intermediate_a;
  central_node1 -> intermediate_b;
  central_node1 -> intermediate_c;

  intermediate_a -> leaf_1;
  intermediate_a -> leaf_2;

  intermediate_b -> leaf_3;
  intermediate_b -> leaf_4;
  intermediate_b -> leaf_YawOffset
  
  intermediate_c -> leaf_5;

  // You might need to add more nodes and edges based on the image.
  // You can also customize node shapes, colors, and labels further.
}

3.1.1. Movement 数据

3.1.1.1. 移动方向 MovementDirection

digraph direction_diagram {
    // 设置图形属性
    bgcolor="#e0f0e0";
    layout=neato;
    size="6,6";
    
    // 隐藏默认节点和边的样式
    node [shape=none, fontname="Arial", fontsize=16];
    edge [color=blue, arrowhead=none];
    
    // 主要方向标签
    F [pos="0,2.5!", label="F", fontsize=24];
    B [pos="0,-2.5!", label="B", fontsize=24];
    L [pos="-2.5,0!", label="L", fontsize=24];
    R [pos="2.5,0!", label="R", fontsize=24];
    
    // 坐标轴标签
    X [pos="0.3,1.5!", label="x", fontsize=14];
    Y [pos="1.5,-0.2!", label="y", fontsize=14];
    
    // 象限标签
    FL [pos="-1.2,1.2!", label="FL"];
    FR [pos="1.2,1.2!", label="FR"];
    BL [pos="-1.2,-1.2!", label="BL"];
    BR [pos="1.2,-1.2!", label="BR"];
    
    // 角度标签
    angle70 [pos="0.5,0.3!", label="70°", fontsize=14];
    angle110 [pos="0.8,-0.3!", label="110°", fontsize=14];
    angle_neg70 [pos="-0.5,0.3!", label="-70°", fontsize=14];
    angle_neg110 [pos="-0.8,-0.3!", label="-110°", fontsize=14];
    
    // 坐标原点（隐藏）
    origin [pos="0,0!", shape=point, width=0.01, style=invis];
    
    // 坐标轴
    origin -> F [pos="0,0 0,2.5", color=blue, penwidth=1.5, arrowhead=normal];
    origin -> R [pos="0,0 2.5,0", color=blue, penwidth=1.5, arrowhead=normal];
    
    // 左区域框
    left_box_tl [pos="-2.2,1.7!", shape=point, width=0.01, style=invis];
    left_box_tr [pos="-0.7,1.7!", shape=point, width=0.01, style=invis];
    left_box_bl [pos="-2.2,-1.7!", shape=point, width=0.01, style=invis];
    left_box_br [pos="-0.7,-1.7!", shape=point, width=0.01, style=invis];
    
    left_box_tl -> left_box_tr -> left_box_br -> left_box_bl -> left_box_tl [color=blue, penwidth=2];
    
    // 右区域框
    right_box_tl [pos="0.7,1.7!", shape=point, width=0.01, style=invis];
    right_box_tr [pos="2.2,1.7!", shape=point, width=0.01, style=invis];
    right_box_bl [pos="0.7,-1.7!", shape=point, width=0.01, style=invis];
    right_box_br [pos="2.2,-1.7!", shape=point, width=0.01, style=invis];
    
    right_box_tl -> right_box_tr -> right_box_br -> right_box_bl -> right_box_tl [color=blue, penwidth=2];
    
    // 对角线（红色）
    dl1 [pos="-2.5,2.5!", shape=point, width=0.01, style=invis];
    dl2 [pos="2.5,-2.5!", shape=point, width=0.01, style=invis];
    dl3 [pos="-2.5,-2.5!", shape=point, width=0.01, style=invis];
    dl4 [pos="2.5,2.5!", shape=point, width=0.01, style=invis];
    
    dl1 -> dl2 [color=red, penwidth=1.5];
    dl3 -> dl4 [color=red, penwidth=1.5];
    
    // 角度弧线标记
    arc1 [pos="0.3,0.3!", shape=point, width=0.01, style=invis];
    arc2 [pos="0.3,-0.3!", shape=point, width=0.01, style=invis];
    arc3 [pos="-0.3,0.3!", shape=point, width=0.01, style=invis];
    arc4 [pos="-0.3,-0.3!", shape=point, width=0.01, style=invis];
    
    arc1 -> arc2 -> arc4 -> arc3 -> arc1 [color=blue, style=dashed, penwidth=0.5];
}

计算 VelocityBlend 分为两步：
计算当前 ControlledRotation 和 VelocityRotation 之间的插值 Delta
根据 Delta 决定当前的移动方向

3.1.1.2. 速度混合 VelocityBlend

计算 VelocityBlend 分为两步：
计算目标 VelocityBlend (TargetBlend)
插值 VelocityBlend

3.1.1.2.1. 获取 TargetBlend

const FVector LocRelativeVeclocityDir = CharacterInformation.CharacterActorRotation.UnrotateVector(CharacterInformation.Velocity.GetSafeNormal(0.1f));
  
const float Sum = FMath::Abs(LocRelativeVeclocityDir.X) + FMath::Abs(LocRelativeVeclocityDir.Y) + FMath::Abs(LocRelativeVeclocityDir.Z);  
const FVector RelativeDir = LocRelativeVeclocityDir / Sum;  
FOnaVelocityBlend TargetBlend;  
TargetBlend.F = FMath::Clamp(RelativeDir.X, 0.0f, 1.0f);  
TargetBlend.B = FMath::Abs(FMath::Clamp(RelativeDir.X, -1.0f, 0.0f));  
TargetBlend.L = FMath::Abs(FMath::Clamp(RelativeDir.Y, -1.0f, 0.0f));  
TargetBlend.R = FMath::Clamp(RelativeDir.Y, 0.0f, 1.0f);

向量归一化：
将速度向量归一化后从世界坐标系转换到角色的局部坐标系：

const FVector LocRelativeVeclocityDir = CharacterInformation.CharacterActorRotation.UnrotateVector(CharacterInformation.Velocity.GetSafeNormal(0.1f));

混合方向权重：
计算局部空间速度向量各分量绝对值的总和。这里使用绝对值是为了处理负方向值：const float Sum = FMath::Abs(LocRelativeVeclocityDir.X) + FMath::Abs(LocRelativeVeclocityDir.Y) + FMath::Abs(LocRelativeVeclocityDir.Z);
将局部空间速度向量除以前面计算的绝对值总和，得到一个特殊的"归一化"向量：const FVector RelativeDir = LocRelativeVeclocityDir / Sum;
计算混合权重

3.1.1.2.2. 插值 TargetBlend

const FOnaVelocityBlend& TargetBlend = CalculateVelocityBlend();  
VelocityBlend.F = FMath::FInterpTo(VelocityBlend.F, TargetBlend.F, DeltaSeconds, Config.VelocityBlendInterpSpeed);  
VelocityBlend.B = FMath::FInterpTo(VelocityBlend.B, TargetBlend.B, DeltaSeconds, Config.VelocityBlendInterpSpeed);  
VelocityBlend.L = FMath::FInterpTo(VelocityBlend.L, TargetBlend.L, DeltaSeconds, Config.VelocityBlendInterpSpeed);  
VelocityBlend.R = FMath::FInterpTo(VelocityBlend.R, TargetBlend.R, DeltaSeconds, Config.VelocityBlendInterpSpeed);

利用插值得到更加平滑的结果

3.1.2. 动画曲线

使用了HipOrientation_Bias（臀位朝向）与Feet_Crossing（是否交叉脚）让动画表现层更加顺滑。
使用 YawOffset 来实现旋转偏移。

3.1.2.1. 交叉脚曲线

Feet_Crossing：存在与ALS_N_[Walk, Run]_[LB, LF, RB, RF]中的曲线，功能是标识什么时候为交叉脚
1: 交叉脚，切换姿势会穿帮
0: 非交叉，可以正常进行姿势切换

3.1.2.2. 臀位朝向曲线

HipOrientation_Bias：臀部位置
<-0.5 臀位左
>0.5 臀位右

3.1.3. Blend Profile

3.2. 表现

3.2.1. States

State 内均采用四方向融合。分别对应 VelocityBlend.F(B，R，L)。
拥有六种动画资源 F，B，FL，BL，FR，BR。

融合方式采用对角融合，F-B，FL-BR，FR-BL。对角融合才能正确的融合出臀部的位置。
这样融合方式应该是
Move F → F，B， FL，RL
Move B → F，B，FB，RB
Move LF → F，B，LF，RB
……

3.2.2. Transition

切换路径是有限制，跳变切换的路径被禁止：
如没有从 LF →RF 的路径; RF→B 必须途径 RB…

切换规则分为三类：
ChangeDirection：由玩家输入产生的移动意图决定，对操控立即响应，插值生效
SwitchHip：又臀位和交叉脚部判断让融合效果更加自然

3.2.2.1. ChangeDirection 移动意图变换

由 MoveDirection 变量决定，该变量在数据章节中有叙述。会在 NativeUpdateAnimation 中进行更新。
路径：这种方式的变换经历所有的合法的变换路径。
通知：在 F←>B，FR←>BL，FL←>BR 会添加"Pivot"事件，通知轴心进行了更改

3.2.2.2. SwitchHip 臀部变换

由 HipOrientation_Bias 和 Feet_Crossing 决定变换。
Feet_Crossing 是一个消极变量，只有当为 0 时才能切换。原因是交叉脚时转身会出现明显的穿帮。
在这个变换中，忽略脚部，观察 FL 和 FR，发现一个其实就是左扭屁股，一个是右扭屁股。这个就可以用于类似瞄准等场景。
路径：因为这是由臀位变换导致的，所以只有 FL<→FR，BL←>BR

4. Reference

ALS高级运动系统解析 03 八向移动
 UE4 UE5 骨骼动画高级运动系统八向移动
 AdvancedLocomotion 拆解笔记 1：移动
 Site Unreachable
【新手向】虚幻4ARPG教程-重置版-第七集-使用弓箭时八方向移动状态_哔哩哔哩_bilibili
虚幻4（UE4）动画技术深入浅出高级运动系统_哔哩哔哩_bilibili