在C++ 11的标准制定过程中，Bjarne Stroustrup（C++之父）觉得Java的内存管理比较好，想要参考Java的方法改进C++。

当他给C++标准委员会提起这件事的时候，来自Microsoft和IBM等公司的代表马上不乐意了。代表们说，如果C++采用Java的内存模型，Java的运行速度至少会慢上一倍，你可不能这么对Java。

英文原文

Bjarne Stroustrup: We thought, at least I thought that Java had a pretty good memory model, so why don't we adopt that, and it'll save us a lot of work. So i mentioned this, and the representatives from various important groups such as Microsoft and IBM says, you can't do that, because if you adopt the Java memory model for C++, our Java implementations will slow down by at least a factor of two, and you just can't do that to Java.

视频链接

Core C++ 2021 :: Bjarne Stroustrup :: Thriving in a crowded and changing world: C++ 2006-2020

封面图来自WIRES on Behance

最近在忙着投稿毕业小论文，在这里简单记录一下计算机图形学领域的一些投稿心得。本文主要内容如下：

• 👨‍🔬 投稿期刊和会议的区别？
• 🔍 如何查询期刊/会议是否是SCI/CCF？
• 🧾 2021年 计算机图形学 SCI期刊列表
• 📆 2021年 计算机图形学 CCF会议 截稿时间列表
• 👨‍🎓 如何写出一篇好的图形学论文？
• ✍ 结语

👨‍🔬 投稿期刊和会议的区别？

一般而言，会议（Conference）有明确的截稿时间、结果通知时间，审稿周期相对更短，通常在1~2个月就会给出初步的审稿结果。而期刊（Journal）虽然全年随时都可以投，但审稿周期则相对较长，运气不好的时候半年、一年都有可能。

另外，有的会议（如IEEE VR，ISMAR）会有多个track，一个track会将收录的论文推荐到其他的期刊（如TVCG）进行发表，另一个track则留在自己的会议论文集发表。SIGGRAPH ASIA则是将所有论文都推荐到TOG上进行发表，所以虽然SIGGRAPH ASIA本身并不在CCF名单中，但是TOG则属于SCI顶刊，因而可以放心的拿来毕业。

这种推荐机制使投稿者既可以享受会议的短期审稿周期，也可以让自己的论文在高水平的期刊上发表。所以综合而言，研究生投稿会议论文更加合适。

🔍 如何查询期刊/会议是否是SCI/CCF？

CCF的列表在中国计算机学会推荐国际学术会议和期刊目录可以看到。每年CCF列表中的评级可能会变化，学校的要求一般是“按照申请人入学后的列表并集处理”，也就是只要某个期刊/会议在你就读研究生期间曾出现在CCF上，就可以算作CCF。

SCI只针对期刊，进入官方查询界面，在搜索框里输入期刊名，Web of Science Core Collection栏目中显示Science Citation Index Expanded (SCIE) 就对啦。SCIE和SCI本质是稍有区别的，但是现在各个学校基本上已不再区分。

🧾 2021年 计算机图形学 SCI期刊列表

SCI并没有像CCF那样提供一个官方的每个学科的列表，所以自己要统计起来会比较头疼。以下更改自刘更代老师整理的SCI-Indexed Journals，在原有基础上删去了一个不再收稿的期刊，并更新了部分期刊的网址：

Graphics: (Computer Graphics, Visualization, Animation and Applications)

• ACM Transactions on Graphics
• IEEE Transactions on Visualization and Computer Graphics
• IEEE Computer Graphics and Applications
• Graphical Models
• Computer Animation and Virtual Worlds
• The Visual Computer
• Computer Graphics Forum
• Computers & Graphics

Virtual Reality: (including VR, Multimedia and Simulation)

• Presence: Teleoperators & Virtual Environments
• ACM Transactions on Applied Perception
• Journal of Visual Languages and Computing
• Multimedia Tools and Applications
• Mathematics and Computers in Simulation

Human-Computer Interaction:

• ACM Transactions on Computer-Human Interaction
• International Journal of Human-Computer Interaction
• International Journal of Human-Computer Studies
• Personal and Ubiquitous Computing

General: (Computer Engineering and Application)

• IEICE Transactions on Information and Systems
• Journal of Computer Science and Technology
• Computers and Industrial Engineering
• Computers & Education
• Engineering with Computers
• International Journal of Innovative Computing, Information and Control
• Computing in Science & Engineering
• Computer Applications in Engineering Education

📆 2021年 计算机图形学 CCF会议 截稿时间列表

以下按Full Paper截稿时间排序。部分会议会要求提前一周左右提交论文Abstract。

备注：

• 部分会议/期刊没有公布2021年的截稿时间，所以表格写的是2020年的截稿时间，以供参考。
• 大部分的图形学顶级会议论文可以在Resources for Computer Graphics中找到。
• 部分会议提供Rebuttal机制，也就是在获得论文reviewer的评价之后，可以针对评价进行一次辩解。Reviwer们会再根据你提供的辩解内容，决定最终是录用还是拒稿。

👨‍🎓 如何写出一篇好的图形学论文？

在这里给大家推荐一些大佬们的资料：

• 📋 How to write a SIGGRAPH paper：SIGGRAPH Course教你怎么写SIGGRAPH论文
• 📋 How to do research：MIT教授Bill Freeman告诉你如何做研究
• 📋 Elements of a successful graduate career：MIT教授Bill Freeman找众多教授收集的成功秘诀
• 📋 Notes on writing：MIT教授Fredo Durand的写论文秘诀
• 📋 Graduate student survival guide：Waterloo大学教授撰写的研究生生存指南

✍ 结语

投论文的过程中遇到失败总是难免的。希望大家保持积极心态，早日上岸🚀！

📄 论文：Detailed Rigid Body Simulation with Extended Position Based Dynamics

引言

刚体物理仿真是游戏引擎以及CG特效中一个极为重要的功能。然而为了实现刚体运动的模拟，我们通常需要求解一些极为复杂的数学公式：

难道只有数学巫师才配研究刚体物理仿真吗？😿

基于位置的动力学（Position Based Dynamics, PBD）^[2]是Müller等人于2006年发表的一种物理仿真方法。此前的方法都是基于力进行解算的，而PBD方法的独特点则在于它选择基于位置进行解算。

这样做有很多好处，一个是避免加速度到速度，速度到位置的多次积分，因而提升性能；另一方面则是具有更好的可控性，比如下图中，为了将两个碰撞的物体分离，基于力的方法需要很精妙的设计，才能找到一个合适的力将两个物体分离开。而基于位置的方法，直接将物体挪走就完成了。除此之外，PBD方法还具有易于实现、稳定的优点，这使其十分契合实时应用的需求。

PBD方法是基于粒子的。仿真场景中的所有物体都由粒子组成，再加上各类约束（Constraint），保证物体满足特定的性质。因此，PBD方法可以在一套统一的框架下同时模拟刚体、布料、软体、流体等不同物理性质的物体极及其交互^[3]。

PBD使用粒子表示各种物体，这使得其实现相比传统物理引擎会简单很多。因为所有的计算操作，都只需要针对没有旋转自由度的球体进行。然而，这也是PBD方法的一个缺点。使用粒子表示物体，意味着物体的体积越大，需要的粒子越多，这使其Scalability较差。并且，基于粒子的方法难以实现稳定的冲量传导和关节效果。

本论文名为Detailed Rigid Body Simulation with Extended Position Based Dynamics^[1]，目标就是在继承PBD方法的简单性的同时，加入对任意形状刚体以及关节效果的支持。

思考

刚体和粒子的区别其实不大。粒子因为是完全对称的，所以不需要考虑角度和角速度。而刚体则因为可能具有任意的形状，在受力时需要加入对角度和角速度的计算。

传统物理引擎的复杂性，主要是因为使用了Global Solver，也就是企图使用一个矩阵连立所有已知方程，一下子把所有物体的物理更新计算出来。求解矩阵对于计算机来说很简单，但是对于人类的理解而言则带来了很多困难。所以本文想要继续采取PBD方法的Local Solver，以每个物体为单位，单独的进行迭代求解。

关于Global Solver和Local Solver的区别可见下图。左边是Global Solver，在一次迭代中会考虑所有的Constraint一并进行更新，即$\nabla C_1+\nabla C_2$。右边是Local Solver，每次迭代会依次遍历所有Constraint，分别进行更新，也就是交替的修正$\nabla C_1$和$\nabla C_2$。

Local Solver可能存在一会南辕，一会北辙的情况，所以以往Local Solver的缺陷在于收敛速度相对较慢。而PBD方法就在前几年引入了sub-stepping^[4]的机制，可以在很大程度上缓解收敛速度慢的问题。

改进

这篇文章的主要增量工作，就是在原来只考虑位置和速度更新的PBD方法中，加入了角度和角速度的更新。下图左侧是PBD方法中的步骤，右边是本文的增量工作。可以看出角速度和速度其实是很类似的，只是需要涉及到转动惯量等角度专用的物理属性。

同理，约束相关的公式也需要加入对角度相关属性的计算，就可以实现支持通用刚体形状的各类约束，把这些约束像API一样使用，就可以实现包括Attachment, Contact, Static Friction, Hinge Joint等效果。

本文中的方法在Core-i7 CPU @ 3.6GHz的CPU上就可以达到实时的性能。

并且因为PBD本身是一种类似于隐式的方法，所以可以很好的保留空间及时间维度上的细节。比如下图中，本文的方法可以稳定模拟一堆玻璃珠在高度复杂的轨道形状上滚动的效果。而传统的方法要么性能太差，要么会遭受穿透。

总结

本文提出了一种基于PBD的通用物理引擎框架，相比传统物理引擎更加容易实现，并且能更好的保留时空细节。继承了XPBD方法的简单性和能够处理无限刚硬（Infinitely stiff）关节的优点。通过substepping，能够在一个时间步内处理大质量比的物体交互以及快速的转动变化。

目前的缺陷在于substepping会使得一些过高频率的扰动也被保留下来，在特定情况下会让人看到物体在颤动。另外一方面是在模拟大量层层相叠的物体时会有不稳定的情况，这也是本文的未来研究方向。

引用

1. Müller, Matthias, et al. "Detailed rigid body simulation with extended position based dynamics." Computer Graphics Forum. Vol. 39. No. 8. 2020.
2. Müller, Matthias, et al. "Position based dynamics." Journal of Visual Communication and Image Representation 18.2 (2007): 109-118.
3. Macklin, Miles, et al. "Unified particle physics for real-time applications." ACM Transactions on Graphics (TOG) 33.4 (2014): 1-12.
4. Macklin, Miles, et al. "Small steps in physics simulation." Proceedings of the 18th annual ACM SIGGRAPH/Eurographics Symposium on Computer Animation. 2019.

📄 You can download PDF version for better readability

Contents

1 Introduction

The World Wide Web is a great invention that benefits all of us today. Anyone can share information online with nearly zero cost. However, the convenience of publishing websites also leads to trouble. Since web pages proliferate free of quality control or publishing cost, the Internet is flooded with useless or even harmful information.

Luckily, search engines come to our rescue. Just by typing in the keyword, the search engine will find the most relevant pages for us automatically and instantly. Highest mountain, tallest man on earth, favorite food of a celebrity. Google is capable of answering a large variety of questions.

But have you ever considered how do the search engines work? How is it possible that search engines can figure out what web pages are most likely useful to you among billions of web pages? Suppose you are searching for “SJTU” on Google, what logic and algorithm make Google decide to put the home page of SJTU on top of everything else?

PageRank^[1] is one of the algorithm that is responsible for these decisions. It is developed by Larry Page and Sergey Brin (founders of Google) at Stanford University in 1996 and became one of the most famous and fundamental algorithms behind the Google search engine.

In a nutshell, PageRank is a link analysis algorithm that assigns numerical weights to each element of a hyperlinked set of documents, with the purpose of measuring its relative importance within the set ^[2].

In the following sections, we will describe PageRank in more detail.

2 PageRank

2.1 Definition

The basic idea of PageRank is that the importance of a web page depends on the pages that link to it.

Given page $A$, if there are a lot of pages link to this page, then it is considered important on the web. On the other hand, if page $A$ has only one backlink, but this link is from an authoritative web page $B$ (such as www.bbc.com or www.yahoo.com), we also think $A$ is important because page $B$ can transfer its popularity or authority to $A$.

In the PageRank algorithm, the connections between web pages are represented by a graph. Each web page is considered as a vertex, and each hyperlink is considered as a directed edge. Forward links correspond to out-edges, and backlinks correspond to in-edges. Links from a page to itself are ignored. Multiple outbound links from one page to another page are treated as a single link.

With these intuitions, we begin by defining a simple ranking $SPR$, which is a slightly simplified version of PageRank.

Definition 1 (Simple PageRank). Let $u$ be a web page. $F_u$ is the set of pages $u$ points to, and $B_u$ is the set of pages that points to $u$. Let $N_u = |F_u|$ be the number of links from $u$. Then, the Simple PageRank of a set of Web pages is an assignment SPR to the Web pages which satisfies

\begin{equation} \begin {split} SPR(u) &= \sum_{v \in B_u} \frac{SPR(v)}{N_v} \\ \sum_{u\in V}SPR(u) &= 1 \end {split}\end{equation}

Note that the rank of a page is divided among its forward links evenly to contribute to the ranks of the pages they point to.

Now let’s look at an example to see how this works. Suppose there are three web pages $A$, $B$, and $C$. $A$ has two edges to $B$ and $C$. $B$ has one edge to $C$, and $C$ has one edge to $A$.

Since $A$ has two out-edges, it contributes half of its rank to $B$ and $C$. $B$ and $C$ on the other hand, have only one out-edge, thus they give all of their ranks to the target. Therefore, we can easily calculate the PageRank for each page.

\begin{equation}\begin{split} SPR(A) &= SPR(C) = 0.4\\ SPR(B) &= \frac{SPR(A)}{2} = 0.2 \\ SPR(C) &= \frac{SPR(A)}{2} + SPR(B) = 0.4 \\ \end{split}\end{equation}

Figure 1 demonstrate the graph representation for this example.

However, there are some problems with this simplified ranking function ^[3].

Disconnected Components. If our web graph has two or more disconnected components, the rank from one component has no way to get into the other component. This means the initial assignment of rank will influence the final ranking assignment in the stable state.

Dangling Nodes. There are some pages that do not have any out-links (referred to as dangling nodes), and the importance received by these pages cannot be propagated. They affect the model because it is not clear where their weight should be distributed, and there are a large number of them. Often these dangling nodes are simply pages that have not been downloaded yet since it is hard to sample the entire web.

Rank Sinks. Consider two web pages that point to each other but to no other page. And suppose there are some web pages which point to one of them. Then, during iteration, the loop will accumulate rank but never distribute any rank (since there are no out-edges). The loop forms a sort of trap that we call a rank sink.

To solve the dangling nodes problem, dangling nodes are assumed to link out to all other pages in the collection. Their PageRank scores are therefore divided evenly among all other pages. In other words, to be fair with pages that are not dangling, these random transitions are added to all nodes in the Web.

In order to deal with the problem with rank sinks and disconnected components, a positive constant $d$ between 0 and 1 (typically set to 0.85 ^[4]) is introduced, which we call the damping factor.

Finally, the definition of PageRank is modified as follows:

Definition 2 (PageRank). Let $u$ be a web page. $F_u$ is the set of pages $u$ points to, and $B_u$ is the set of pages that points to $u$. Let $N_u = |F_u|$ be the number of links from $u$. Then, the PageRank of a set of Web pages is an assignment PR to the Web pages which satisfies

\begin{equation}\begin{split} PR(u) &= \frac{1-d}{N} + d\big(\sum_{v \in B_u} \frac{PR(v)}{N_v}\big) \\ \sum_{u\in V}PR(u) &= 1 \end{split}\end{equation}

2.2 Matrix Forms

Let $A$ be a square matrix with the rows and columns corresponding to web pages. We define the entries of matrix $A$ by

\begin{equation}A_{u,v} = \left\{\begin{array}{rcl}\frac{1}{N_u} & & {\text{if there is an edge from v to u,}}\\\frac{1}{N-1} & & {\text{if node v is a dangling node and } u \ne v}\\0 & & {\text{otherwise,}}\end{array}\right.\end{equation}

We treat $R$ as a vector over web pages, that is

\begin{equation}R = \left[ \begin{matrix} PR(u_1) \\ PR(u_2) \\ \vdots \\ PR(u_n) \end{matrix} \right]\end{equation}

Finally, we have the following matrix equation to calculate PageRank for all web pages.

\begin{equation} R = \frac{1-d}{N} \mathbf{1}+ dAR\end{equation}

where $\mathbf 1$ is the vector consisting of all ones.

2.3 Random Surfer Model

The definition of PageRank above has another intuitive basis in random walks on graphs. The random surfer simply keeps clicking on successive links at random. The simplified version corresponds to the standing probability distribution of a random walk on the graph of the Web.

However, if a real Web surfer ever gets into a small loop of web pages, it is unlikely that the surfer will continue in the loop forever. Instead, the surfer will jump to some other page. The additional parameter $d$ can be viewed as a way of modeling this behavior: the surfer periodically “gets bored” and jumps to a random page.

2.4 Calculation Method

PageRank can be computed either iteratively or algebraically ^[2]. The iterative method can be viewed as the power iteration or the power method. The basic mathematical operations performed by these two methods are similar.

2.4.1 Power Method

At $t=0$, an initial probability distribution is assumed, usually

\begin{equation} PR(u_i;0) = \frac{1}{N}\end{equation}

where $N$ is the total number of pages, and $PR(u_i;0)$ denotes rank for page $u_i$ at time 0.

At each time step, the computation, as detailed above, yields

\begin{equation} PR(u_i;t+1) = \frac{1-d}{N} + d\left(\sum_{v \in B_{u_i}} \frac{PR(v;t)}{N_v}\right)\end{equation}

or in matrix notation

\begin{equation} R(t+1) = \frac{1-d}{N} + dAR(t) \label{eq:matrix}\end{equation}

Since $R$ is a probability distribution (i.e.$|R|=1$), we have

\begin{equation} \begin{split} ER &= \mathbf 1 \times (PR(u_1) + PR(u_2) + ... + PR(u_n)) \\ &= \mathbf 1 \end{split} \end{equation}

where $\mathbf 1$ is a vector of all ones, and $E$ is a matrix of all ones.

Therefore, Equation 9 can be rewrite as

\begin{equation} R(t+1) = (\frac{1-d}{N}E + dA)R(t) \label{eq:complex_matrix}\end{equation}

Let $`$\hat A = \frac{1-d}{N}E + dA$`$, and Equation 11 can be further simplified as

\begin{equation} R(t+1) = \hat A R(t)\end{equation}

Now we can see that the PageRank $R$ we want to calculate is actually the principal eigenvector of matrix $\hat A$ with eigenvalue $1$.

The probability calculation is repeated for several iterations until convergence is achieved, that is

\begin{equation} |R(t+1)-R(t)|<\epsilon\end{equation}

2.4.2 Algebraic Method

For $t\rightarrow\infty$ (i.e., in the steady state), Equation 9 can be rewrite as

\begin{equation} R = \frac{1-d}{N} \mathbf 1 + dAR\end{equation}

Hence,

\begin{align}(I-dA) R &= \frac{1-d}{N} \mathbf 1 \\R &= (I-dA)^{-1} \frac{1-d}{N} \mathbf 1\end{align}

where $I$ is the identity matrix.

The solution exists and is unique for $0 < d < 1$. This can be seen by noting that $A$ is by construction a stochastic matrix (i.e. the elements of each column sum up to 1) and hence has an eigenvalue equal to one as a consequence of the Perron-Frobenius theorem.

However, since the time complexity of matrix inversion is $O(n^3)$, this method is impractical for industrial usage where billions of webpages are involved.

3 Key Properties

3.1 Proof of Convergence

Claim 3. The power method for calculating PageRank always converge to true solution for any given $\epsilon$ (error tolerance parameter) ^[5].

Proof. First, we define $`$R^\star$`$ as the true PageRank assignments, and $PR^\star(v)$ as the true PageRank for page $v$. We have

\begin{equation} R^\star = \left[ \begin{matrix} PR^\star(u_1) \\ PR^\star(u_2) \\ \vdots \\ PR^\star(u_n) \end{matrix} \right]\end{equation}

Then we can define the total error at step $t$ to be:

\begin{equation} Err(t) = \sum_{v \in V} |PR(v;t)-PR^\star(v)|\end{equation}

Since $PR^\star$ is the true solution, we know that it must satisfy the PageRank equations exactly:

\begin{equation} PR^\star (u) = \frac{1-d}{N} + d\left(\sum_{v \in B_u}\frac{PR^\star (u)}{N_v}\right)\end{equation}

To find the error between true solution and current time step, we subtract this from the iterative method equation, and obtain:

\begin{equation} PR(u;t) - PR^\star (u) = d\left(\sum_{v \in B_u}\frac{PR(u;t-1) - PR^\star (u)}{N_v}\right)\end{equation}

Using the Triangle Inequality, we can get this expression for the error in PageRank $v$ at step $t$:

\begin{equation} |PR(u;t) - PR^\star (u)| \le d\left(\sum_{v \in B_u}\frac{|PR(u;t-1) - PR^\star (u)|}{N_v}\right)\end{equation}

Now we can sum over all v to get the total error $Err(t)$. Notice that the page $v$ will occur $N_v$ times on the right-hand side, and since there is also a $N_v$ on the denominator, they will cancel each other.

\begin{equation} \begin{split} Err(t) &= \sum_{u \in V} |PR(u;t) - PR^\star (u)| \\ &\le d \left( \sum_{v\in B_u} |PR(u;t-1) - PR^\star (u)| \right) \end{split}\end{equation}

We are left with $d$ times the total error at time $t-1$ on the right-hand side.

\begin{equation} Err(t) \le d Error(t-1)\end{equation}

This shows fast convergence of power method, because the decrease in total error is compounding. From this inequality, we can also see that the damping parameter $d$ is essential for convergence.

3.2 Time Complexity

PageRank is computed for several iterations until termination condition $Err(t) \le \epsilon$ is met. In each iteration, every vertex will compute a new PageRank by accumulating all of its neighbors’ contributions. Thus the time complexity of one iteration is $O(m+n)$, where $n$ is the number of vertices, and $m$ is the number of edges.

In the following, we prove that there exists an upper bound for the number of iterations.

Claim 4. The number of iteration is bounded by $`$log_d(\frac{\epsilon}{n})$`$, where $n$ is the number of vertices, $\epsilon$ is the tolerance parameter, and $d$ is the damping factor.

Proof. According to our previous analysis on convergence, we have

\begin{align} Err(t) &= \sum_{v \in V} |PR(v;t)-PR^\star(v)| \label{eq:err} \\ Err(t) &\le d Error(t-1) \label{eq:reduction} \end{align}

Since $PR(v;t)\in [0,1]$, From equation 24 we can obtain

\begin{equation} Err(0) = \sum_{v \in V} |PR(v;0)-PR^\star(v)| \le \sum_{v \in V} 1 \le n \end{equation}

Combinated with Equation 25, and we get

\begin{equation} Err(t) \le d Error(t-1) \le d^t Error(0) \le d^t n \label{eq:dtn} \end{equation}

The condition for iteration to terminate is

\begin{equation} Err(t) \le \epsilon \label{eq:eps}\end{equation}

Putting Equation 27 and 28 together and we obtain an upper bound for iteration number $t$.

\begin{align} d^tn &\le \epsilon \\ t &\le log_d(\frac{\epsilon}{n}) \end{align}

Finally, since the number of iteration is bounded by $`$log_d(\frac{\epsilon}{n})$`$, and the time complexity of one iteration is $O(m+n)$, the total time complexity of PageRank is $`$O((m+n)log_d(\frac{\epsilon}{n}))$`$.

According to the original paper ^[1], PageRank on a large 322 million link database converges to a reasonable tolerance in roughly 52 iterations. The convergence on half the data takes roughly 45 iterations. This suggests that PageRank will scale very well even for an extremely large collection.

The actual time complexity for industrial use can get quite more complex. Due to the large scale of webpages, the graph can hardly be stored in memory on a single machine. Distributed algorithms such as ^[6] are developed to solve this problem.

4 Conclusion

4.1 Summary

In this note, we described PageRank, a ranking algorithm for webpages based on their importance. The intuition behind PageRank is that it uses information that is external to the Web pages themselves - their backlinks, which provide a kind of peer review ^[1]. PageRank works by counting the number and quality of links to a page to determine a rough estimate of how important the website is. The underlying assumption is that more important websites are likely to receive more links from other websites.

First, we show a simplified version of PageRank, which works well in some cases, but can’t handle problems like dangling nodes, rank sinks, and disconnected components. Therefore, the damping factor and some other modifications are introduced to solve these problems.

The behavior of PageRank can be thought of as modeling the behavior of a random surfer. The random surfer simply keeps clicking on successive links at random, and the PageRank corresponds to the standing probability distribution.

PageRank can be calculated iteratively or algebraically. However, the algebraical method is time-consuming since it involves matrix inversion, making it impractical for industrial usage. Iterative methods such as Power Method are preferred, and gives an approximate result for PageRank with much better performance. The proof of convergence and time complexity analysis for the iterative method is described in detail in Section 3.

PageRank method was developed to evaluate the importance of web-pages via their link structure. The mathematics of PageRank, however, is entirely general and applies to any graph or network in any domain ^[7]. Thus, PageRank is now regularly used in other fields, such as bibliometrics, social and information network analysis, link prediction, and recommendation.

4.2 Extensions

Following the discovery of PageRank, there has been a huge amount of work to improve or extend PageRank. Here are a few:

• Intelligent Surfing^[8]. This paper proposes a method to improve PageRank by using a more intelligent surfer, one that is guided by a probabilistic model of the relevance of a page to a query.
• TrustRank^[9]. Web spam pages use various techniques to achieve higher-than-deserved rankings in a search engine’s results. This paper proposes techniques to semi-automatically separate reputable, good pages from spam.
• PigeonRank^[10]. PigeonRank is developed by Google to provide preference to local search results. This is quite useful for the user and local businesses.
• Fast Distributed PageRank Computation^[6]. Due to the large scale of webpages, PageRank can benefit a lot from distributed computation. This paper presents fast random walk-based distributed algorithms for computing PageRanks in general graphs and prove strong bounds on the round complexity.

References

1. Lawrence Page, Sergey Brin, Rajeev Motwani, and Terry Winograd. The pagerank citation ranking: Bringing order to the web. Technical report, Stanford InfoLab, 1999.
2. Wikipedia contributors. Pagerank — Wikipedia, the free encyclopedia. https://en.wikipedia.org/w/index.php?title=PageRank&oldid=961815901, 2020. [Online; accessed 14-June-2020].
3. Ryan Tibshirani. Pagerank. https://www.stat.cmu.edu/~ryantibs/datamining/lectures/03-pr.pdf, 2013.
4. Sergey Brin and Lawrence Page. The anatomy of a large-scale hypertextual web search engine. 1998.
5. Rio Goodman. Lecture 10: Pagerank. https://web.stanford.edu/~ashishg/msande235/spr08_09/Lecture10.pdf, 2009.
6. Atish Das Sarma, Anisur Rahaman Molla, Gopal Pandurangan, and Eli Upfal. Fast distributed pagerank computation. In International Conference on Distributed Computing and Networking, pages 11–26. Springer, 2013.
7. David F Gleich. Pagerank beyond the web. SIAM Review, 57(3):321–363, 2015.
8. Matthew Richardson and Pedro Domingos. The intelligent surfer: Probabilistic combination of link and content information in pagerank. In Advances in neural information processing systems, pages 1441–1448, 2002.
9. Zoltan Gyongyi, Hector Garcia-Molina, and Jan Pedersen. Combating web spam with trustrank. In Proceedings of the 30th international conference on very large data bases (VLDB), 2004.
10. Wikipedia contributors. Google pigeon — Wikipedia, the free encyclopedia. https://en.wikipedia.org/w/index.php?title=Google_Pigeon&oldid=945252161, 2020. [Online; accessed
    15-June-2020].

Smoothed Particle Hydrodynamics (SPH)方法会频繁的涉及Kernel的计算。Kernel可以理解为一种加权平均的函数，越相近的部分会获得更高的权值，以此就可以使用附近粒子的平均属性估算空间中某一点的属性（例如密度）。

Kernel有很多种计算公式，在不同场景下会选择不同的Kernel。DFSPH论文中使用的是Cubic Spline Kernel，计算公式如下：

虽然这个式子本身没有特别复杂，但是因为是分段函数，需要执行if语句（if语句在GPU上是开销比较高的)，又因为Kernel在每次迭代中都需要执行非常多的次数，所以整体而言消耗了比较多的性能。因而，论文就提出，可以使用Lookup tables的方法对Kernel计算进行优化。

Lookup Tables

Lookup tables方法首先会对函数进行预计算，每隔一定间隔进行采样，并将结果以table形式存储在内存。在之后的运行中，就可以直接从table中查到近似的函数值。

以下面这个线性函数为例：
$$
w(q)=q, q \in [0, 1]
$$
假设采样频率为0.01，那么我们会创建一个表格table[101]，并根据如下公式进行初始化
$$
table[i*0.01]=w(i*0.01), i\in[0,100]
$$
在运行时，假设我们需要取 $w(0.054)$ 的值，我们会首先我们会从table中读取，而不再使用原公式进行计算。读取的下标为$i=0.054/0.01=5$，因而最终获取到的值为$table[i*0.01]=0.05$。

在这个例子中，我们可以看到最终获取的结果和精确值之间存在 $(0.054-0.05)/0.05=8$% 的误差。但通过设置足够高的采样频率，我们可以使得计算误差任意的小。在这个示例中我们使用的函数计算很简单，可能体现不出来lookup tables的优势。而其实对于任意复杂的函数，我们都可以使用类似的优化方法，相当于是将原本的任意次加减乘除以及if判断指令，替换为单次内存读取操作。理论上而言，可以取得非常多的性能提升。

实现

于是乎，我就把lookup tables的方法实现在了我GPU加速的流体项目中。不幸的是，性能不仅没有提高，反而有一定幅度的下降。原本的帧率在91~92FPS左右，开启lookup tables优化后，下降到了77~78FPS。

这是为什么呢？经过一番搜寻后，我找到了大致的原因。使用lookup tables后，执行的指令数量确实是大幅下降了，但是内存读取操作却带来了新的问题。内存读取的性能，很大程度上依赖Cache的命中率，如果进行连续读取，Cache命中率可以很高；而在实际应用中，lookup tables通常都是被随机访问的，这引入了大量的Cache Miss。Cache Miss的开销通常远高于省去的加减乘除的开销，最终使得性能反而下降。

在操作系统Linux的讨论邮件中也有涉及这个问题。Linus Torvalds指出：

Lookup tables are only faster in benchmarks, they are almost always slower in real life. You only need to miss in the cache once on the lookup to lose all the time you won on the previous one hundred calls.

为证实这一猜想，我将lookup table的Resolution（也就是table的size）由10000降至了32，此时性能提升到了95~96FPS，略高于原来的性能。但是这么低的Resolution，计算误差是比较大的，再鉴于如此轻微的性能提升，还不如不进行优化。

总结

优化不总是一件好事，理论也不一定能与实践相符。以Linus Torvalds的话收尾：

"Small and simple" is almost always better than the alternatives.

《蜘蛛侠》（Marvel's Spider Man）是由Insomniac Games开发并由索尼互动娱乐发行于PlayStation 4平台的动作冒险游戏，同时也是Insomniac获得授权后基于漫威漫画超级英雄蜘蛛侠制作的作品。游戏包含着全新的蜘蛛侠故事，且与现有的漫画、电子游戏和电影没有任何关联，同时也会展现一个年龄更大且更有经验的蜘蛛侠。作品已于2018年9月7日在全球发售。

本作以纽约为原型，实现了一个拥有庞大地图的开放世界游戏。庞大的地图给开发者们带来了渲染、存储等多方面的挑战；蜘蛛侠在城市中飞檐走壁的高速移动，也给开放世界的动态加载带来了前所未有的难题。

目录

• 目录
• 串流（Streamming）
• 文件空间占用
• 大规模渲染
• Lighting（光照）
• Pedestrian（行人）
• Photo Mode（拍照模式）
• 总结
• 参考

串流（Streamming）

大型开放世界游戏，通常都采用串流的方式，将地图数据进行动态地异步加载。整个游戏地图会被分为一个一个小块，当角色靠近新的小块时，就只需要读取这个小块即可。常用的几种划分方法如下图，这些划分方式可以保证整个地图能够无线的拼凑和延申。

本作采取的方法是第一种，矩形划分，整个城市被分为一个一个矩形块进行单独的存储及加载。并出于简化计算量的考虑，在实际进行相交判断时，实际上是使用的圆形的范围，如下图所示。

在玩家进行移动时，每移动一个区块，就会需要相应地读入附近的5个新区块。

然而，本作和其他开放世界游戏的一个差别，在于主角蜘蛛侠，可以通过吐丝的方式在城市中以极快的速度进行移动。如此快的移动速度，意味着需要在更短的时间内加载更多的区块，IO带宽的压力成倍增加。

所以首先的一个优化思路，就是减少读取区块的数量。考虑到玩家大部分时间都是进行近似的直线运动，所以只需要加载正前方的三块区块就行了，这样大大减少了带宽消耗。

有人可能会想了，那玩家转弯怎么办？幸运的是，在本游戏中，蜘蛛侠转弯大概需要花将近1s的时间，这完全足够异步加载系统重新进行规划和读取了。

除此之外，另外一个优化策略是Delayed Loading，对区块中部分内容进行延迟加载。考虑到蜘蛛侠在进行快速移动时，镜头模糊会使周围的视线都很模糊，这个时候附近的模型可以直接使用Texture中Mipmap的最模糊层级即可，其他层级的贴图则可以暂时延后。除此之外，当蜘蛛侠在空中快速移动时，街边小店中的各种模型也都是看不见的，所以也可以一并进行Delayed Loading。这样的方法省下了相当大的带宽。

文件空间占用

对于很多PS平台游戏来说，Duplication是一种比较常用的一个IO性能优化方法。因为Play Station使用的是机械硬盘，机械硬盘在进行连续读取的时候有很好的性能，但当需要进行seek（寻址）的时候就会浪费很多时间。所以，游戏开发者通常会将同一份数据在磁盘中进行冗余存储，如果A地图区块和B地图区块都需要用到模型X，则他们会在自己的区块上各存储一份，这样一个区块的内容可以在一次连续读取中完成。

然而，因为纽约地图实在是太过巨大，在游戏还未完成的阶段，游戏的预估占用空间就已经超过了一张蓝光碟的存储容量。这一方面会增加发行成本，另外一方面对于游戏玩家来说，在多张光碟间切换也是十分糟糕的体验。

所以，我们需要重新审视Duplication。Duplication的初衷是什么？空间换时间。这也是程序开发中一个常见的优化思路。然而对于本游戏而言，因为使用了高度定制化的自研引擎，本身CPU性能是十分充裕的，而空间方面却是十分吃紧。所以，我们需要避免之前那种Naive的Duplication（即无论任何情况都Duplicate），而改为更加聪明的Duplication策略。

具体而言，就是不再Duplicate特定类型的文件。首先是可以进行Delayed Loading的文件类型，因为这类文件本身没有很高的及时性要求，例如Texture mipmap的精细层级和音效等。除此之外，文件体积大于4MB的，冗余次数大于400次的都不再进行冗余。

文件空间占用的另外一个优化方法，更加是“走火入魔”：本作在传统的模型存储格式上进行了修改。传统的模型存储格式中有很大一部分空间，存储的是每个三角面片对应的顶点index。而在本作中，这些顶点index被修改为与上一位置之间的差值。例如原本存储的是74,75,76，在修改后就成为了74,+1,+1。这样做的一方面原因，是因为三角面片中的顶点通常都是相连的，这使得如果我们存储差值的话，其中会有更多的重复数值；另一方面原因，就是本作使用了LZ4格式对文件进行压缩，而文件中的数据重复越多，就能取得更高的压缩率。最后经过计算，通过这样的压缩，模型文件的空间占用减少了多达20%。

大规模渲染

在纽约的帝国大厦天台，玩家可以纵览整个纽约城。如此庞大的城市，也带来了前所未有的渲染压力。

为了渲染如此宏大的场景，使用的第一个优化技巧，称为Imposter（假冒者）。Imposter是一些“轻量级”的场景物体，应用于视线远端的各类低精度建筑。他们的轻量，一方面在于对数据结构进行了简化，只存储必要的一些数据（Transform，模型等），另一方面则是使用更加简化的渲染管线（没有uv，没有法线，主要都靠离线烘培）。

另外一类物体称为Hibernates，主要用于建筑顶端的各类装饰品，例如太阳能板、烟囱等，这些小东西看上去并不起眼，但是对于提升城市的真实感而言却至关重要。

这些装饰性物品长期性的处于玩家视线之中。然而糟糕的是，整个城市中有60万个这类物体，每个物体的原始空间占用为384bytes，这意味着光是存储这些物体的信息就会占用600k*384bytes=230.4MB的内存。

这也是使用Hibernates的原因，和Imposter类似，Hibernates也对数据结构进行了精简，只存储极少的必要信息。例如位置信息，通过存储到地区区块中心的偏移量，可以使用一个16位的变量即可进行存储。在优化后，每个Hibernate只占用40 bytes，全体hibernates的内存占用也从230.4MB优化到了24MB。在角色足够靠近这些hibernates的时候，他们又会动态切换为正常的Game Object，以实现动画、玩家交互等功能。

Lighting（光照）

对于真实感渲染的游戏而言，一个必不可少的元素是环境探测球（Environment Probe），例如水面、金属等材质的镜面反射效果就离不开它。

环境探测球的生成并不复杂，只需要在探测球位置对上下左右前后六个方向进行快照即可获得。出于实时性能的考量，通常的做法是进行离线烘培并存储在磁盘中。但是，对于纽约如此庞大的城市来说，光是环境探测球就会占据8GB的空间，这是很难承受的。出于和之前Duplication部分的同样想法（CPU算力充足，而空间占用紧缺），本作采用了实时渲染的方法。当玩家进入新的区域后，如果当前有充裕的计算资源，则会异步的生成附近的环境探测球，并且为了减少重复计算量，会对生成的环境探测球进行适当的缓存。这样的做法完全是0磁盘占用。

Pedestrian（行人）

只要是游戏中会动的东西，总会有玩家想去和它进行交互。

为了增加游戏的真实感及沉浸感，开发者们决定给行人们加上更加交互性的AI逻辑。然而，纽约城市中，来来往往的行人数量繁多，如果所有行人都使用同样复杂的AI逻辑，则会给游戏带来巨大的性能压力。

因此，AI逻辑部分也使用了LOD（Level of Detail）的优化思路。在游戏中，行人默认使用十分轻量级的AI逻辑。每隔30秒，玩家附近的一个行人会被切换为完全体AI（Full AI Bot），从默认的几类交互事件中随机选取一类并执行。默认的交互事件包括和玩家进行动作交互（如合照、签名等），向玩家报案（在本作中，玩家需要像警察一样到处去逞凶除恶），指引玩家前往附近的重要区域等等。当行人离玩家很远（例如只占据几个像素左右时），或者被遮挡的情况下，行人的动画、AI全都会暂停，只在原地进行左右的随机平移，给玩家带来他们仍然在移动的错觉。

Photo Mode（拍照模式）

起初整个项目组只是打算将拍照模式做一个很简单的版本，这样就足以他们对外宣传“我们有拍照模式！”了。但随着用户反馈的收集，开发者们发现拍照模式的意义远比他们想象中的更大。玩家很享受在纽约城中的各个角落自拍、拍景色、甚至是拍遇到的BUG，并在各大社交平台上分享，这给游戏带来了相当多的曝光度。因此，开发者对拍照模式投入了额外的精力，加入了滤镜、贴花等功能，更好的满足玩家的拍照需求。

总结

在本次演讲中，演讲者Elan Ruskin总结出了四个技术实现的信条（Moral）：

简单的实现就是好的实现（Simple is Good）。简单的实现有更低的开发成本和很高的可扩展度，在进行技术实现时，如果简单的实现方法可行，就不要一味去追求各类天花乱坠的高端方法。

因地制宜的采取技术方案（Fit Tech To Context）。本作中相当多的优化方法，都是根据游戏的具体情况，所采取的极度定制化的优化思路。并且从这些优化思路中也可以看出来，为什么极具创新性和开创性的游戏通常都会采用自研引擎。例如模型格式的修改、多级别的Game Object、以及Mipmap的分级分离存储，这些修改在没有游戏引擎源码并高度熟悉游戏引擎架构的情况下都是很难实现的。自研引擎的核心优势，就是在于可以根据自己游戏的需求，无限制的对引擎中的各个功能进行魔改。

重新进行空间和速度间的权衡（Revisit Speed-Space Tradeoffs）。传统游戏引擎中，有相当多的功能是以空间换时间的，例如各类预渲染和预计算。但随着游戏规模的不断扩大以及软硬件优化技术的提升，很多时候需要重新进行权衡，根据自身需求做出修改。

做游戏的首要目标是开心（If There's No Fun Then What is Even The Point）。做游戏其实就是做玩具，而玩具的首要任务就是让用户感受到快乐。一个无法带来快乐的游戏，还有什么意义呢？

参考

[1] Marvel's Spider-Man: A Technical Postmortem - Youtube. https://www.youtube.com/watch?v=KDhKyIZd3O8Hi

自从COVID-19爆发以来，我之前服务器的网络状况就不断恶化（不知道两者之间是否存在联系），最近更是已经完全无法支撑流畅观看Youtube视频的需求了。

之前用的VPS供应商是一个很小众的公司VirMach。相同配置的价格比别家都要低一些，但是稳定性就比较差了，所以打算购置新的VPS。

Hostwinds

昨天在知乎上看到一个疯狂安利Hostwinds的博主，整个Google搜索记录上几乎只有他在安利。一番权衡后决定先买三个月试一下。

价格方面，Hostwinds最便宜的VPS是5美元一个月，首次付费九折，配置很一般，但是对于我这种小打小闹的人还是基本足够。

评测

实际拿到手之后大概对比了一下我的俩服务器。

首先是明面上的数据，VirMach虽然价格便宜（现在新服务器的价格也贵了，这是一年前活动的价格），但是各种配置却要好一些。

再用网上的脚本测试一下实际的数据。

# I/O and Network$ wget -qO- bench.sh | bash# Performance$ wget --no-check-certificate https://github.com/teddysun/across/raw/master/unixbench.sh$ chmod +x unixbench.sh$ ./unixbench.sh

网络速度和延迟都差不太多，但是I/O的速度差别很大，猜测VirMach并没有用SSD（虽然我记得它宣称用的是SSD）。性能评分部分，Hostwinds也要高不少。目前两天的使用情况看来，Hostwinds的整体稳定性也是比VirMach好的。

结语

作为一个死宅程序猿，每台服务器都会有自己的名字。之前的那一台叫做VTai，VT取自我的英文名Vital，ai取自人工智能的英语AI。新的这一台叫做VRay，V取自Vital，而Ray取自在上面安装的第一个软件，用于翻墙的V2Ray（手工打码）。之后有空的话可能还可以写一下服务器的迁移过程。最后祝愿VRay能够平安长寿，肺炎的风波也早一点结束。

后记

买了服务器没过几天找到了一个综合型介绍科学上网相关知识的文章[3]，介绍了常用的VPS供应商以及网络线路相关的知识，可以之后再参考一下。

参考

1. 秋水逸冰 » Linux性能测试UnixBench一键脚本
2. 秋水逸冰 » 一键测试脚本bench.sh
3. 科学上网 | 左耳朵

1 总览

Bullet，是一个实时物理仿真引擎，在VR、游戏、视觉特效、机器人、机器学习等领域都有应用。Bullet的著名客户包括侠盗飞车5、荒野大镖客、闪电狗、Blender、Cinema 4D等等。

评价物理引擎主要有四方面的指标，性能、仿真精度、功能广度、易用性。鱼和熊掌不可兼得，各个物理引擎主要的差别就在于对这些方面进行了不同的取舍。Bullet文档中写道“Bullet is physics simulation software, in particular for rigid body dynamics and collision detection”，其主要的侧重点在于刚体模拟、碰撞检测和易用性，从官网的动态来看近来比较受科研工作者的喜爱（如机器人仿真方向的研究团队Google Brain, Stanford AI Lab, Open AI）。

但因为Bullet是一个没有商业机构运作的引擎，仅仅依靠开源社区支持，所以相比其他引擎，它的功能较少、代码及文档质量不佳，这使得其在商用方面逐渐式微[1]。并且其在OpenCL并行加速方面的工作还处于Experimental的状态，可能整体性能不如PhysX、Havok等引擎。

下面列举一下官方的“王婆卖瓜，自卖自夸”（译自官方源码中提供的文档Bullet_User_Manual），可以比较直观的了解Bullet引擎的特性：

• 同时支持离散(Discrete)及连续(Continuous)碰撞检测以及射线及凸扫描测试(convex sweep test)。引擎支持的碰撞体形状包括凸状网格、凹状网格以及所有基本形状(basic primitives)。
• 支持最高6自由度的刚体模拟及约束连接，以及基于关节体算法（Articulated body algorithm）使用移动器（mobilizers）实现的多刚体(Multibody)系统。
• 实现了快速、稳定的刚体动力学约束解算器，车辆动力学(Vehicle Dynamics)，角色控制器(Character Controller)，滑块(Slider)，铰链(Hinge)，通用的6自由度Constrain以及用于实现布娃娃(Ragdoll)模拟的Cone Twist Constraint。
• 使用柔体动力学实现布料、绳、可变形物的模拟，支持柔体与刚体的双向交互(Two-way Interaction)，并提供了对约束(Constraint)的支持。
• Bullet是Zlib许可下的开源项目，可以免费用于商业项目，并提供了广泛的平台支持(PS3, XBox 360, Wii, PC, Linux, Mac OSX, Android, iPhone)。
• 提供了Maya Dynamica插件，Blender集成，原生二进制.bullet序列化等文件及辅助功能。引擎支持URDP，.obj，.bsp等格式资源的导入。
• 提供了Example Browser示例程序展示Bullet SDK的功能。示例程序可以使用OpenGL3渲染模拟结果，也可以直接在控制台进行输出。
• 提供了上手指南、源码文档、Wiki和论坛，能够帮助开发者更轻松地了解引擎功能。

2 架构

物理引擎的主要任务是进行碰撞检测，并根据碰撞及其他约束进行修正，最后提供一个实时更新的Transform（包括位置及旋转信息）。

Bullet的主要功能模块如下图：

2.1 Rigid Body Dynamics

在下图中，上半部分是流程中用到的主要数据结构，下半部分是刚体物理解算流程。蓝色箭头代表读取数据，红色箭头代表读写数据。

在Bullet引擎中，整个上述流程都被封装在dynamics world中。当对dynamics world调用 stepSimulation 方法时，就会执行一次上述解算流程。并且开发者可以根据自身需求，替换甚至是重写其中的每个部分，如broadphase collision detection，narrowphase collision detection以及constraint solver。

2.2 Collision Detection

首先是broadphase碰撞检测，会根据Axis aligned bounding box (AABB)进行重叠检测，粗略的筛选出有较大可能性碰撞的物体对(pair)。Bullet会对重叠物体对进行缓存，这样之后重复碰撞时可以使用上一次缓存的信息加速约束解析的收敛速度。

Collision dispatcher会对所有物体对进行遍历，根据它们的形状类型找到合适的碰撞算法，并执行找到的碰撞算法求出接触点（Contact Point）。

Bullet支持许多种类的形状，并给出了一个图让开发者能够直观的选择适合自身需求的类型。

Collision Dispatcher会根据物体对中双方的形状，在下表中映射到对应的解析算法，且开发者可以根据需要修改这个映射表。其中GJK全称是Gilbert, Johnson和Keerthi，他们是Convex distance calculation algorithm的发明者。GJK通常会和EPA一起使用，EPA是用于穿透深度计算的方法，全称为Expanding Polythope Algorithm，由Gina van den Bergen发明。

另外，Bullet还提供了Collision Filtering的机制，允许开发者去除掉指定物体之间的碰撞。

2.3 Constraints

Bullet提供了许多种Constrain的实现，以下分别列举。

2.3.1 Point to Point Constrain

Point to Point Constrain可以使两个刚体的给定轴点(pivot point)保持重合，可以用于将刚体像锁链一样连接。示例代码如下：

btPoint2PointConstraint(btRigidBody& rbA,const btVector3& pivotInA);btPoint2PointConstraint(btRigidBody& rbA,btRigidBody& rbB, const btVector3& pivotInA,const btVector3& pivotInB);

2.3.2 Hinge Constrain

Hinge Constrain又叫Revolute joint，限制两个方向的旋转角度，保证刚体只能绕单个方向(即hinge axis)进行旋转，可以用来模拟门或轮胎。示例代码如下：

btHingeConstraint(btRigidBody& rbA,const btTransform& rbAFrame, bool useReferenceFrameA = false);btHingeConstraint(btRigidBody& rbA,const btVector3& pivotInA,btVector3& axisInA, bool useReferenceFrameA = false);btHingeConstraint(btRigidBody& rbA,btRigidBody& rbB, const btVector3& pivotInA,const btVector3& pivotInB, btVector3& axisInA, btVector3& axisInB, bool useReferenceFrameA = false);btHingeConstraint(btRigidBody& rbA,btRigidBody& rbB, const btTransform& rbAFrame, const btTransform& rbBFrame, bool useReferenceFrameA = false);

2.3.3 Slider Constrain

Slider Constrain限制物体只能绕单个轴进行旋转，只能沿单个轴进行平移。

btSliderConstraint(btRigidBody& rbA, btRigidBody& rbB, const btTransform& frameInA, const btTransform& frameInB, bool useLinearReferenceFrameA);

2.3.4 Cone Twist Constrain

Cone twist constrain常被用于模拟Ragdoll的四肢。It is a special point to point constraint that adds cone and twist axis limits.

btConeTwistConstraint(btRigidBody& rbA,const btTransform& rbAFrame);btConeTwistConstraint(btRigidBody& rbA,btRigidBody& rbB, const btTransform& rbAFrame, const btTransform& rbBFrame);

2.3.5 Generic 6 Dof Constrain

开发者可以针对6个自由度（3个位置自由度，3个旋转自由度）单独设定constrain。每个自由度可以处于锁定(locked)、自由(free)和受限(limited)三种状态。

btGeneric6DofConstraint(btRigidBody& rbA, btRigidBody& rbB, const btTransform& frameInA, const btTransform& frameInB, bool useLinearReferenceFrameA);

2.4 Soft Body Dynamics

本模块在刚体动力学基础上增加了对绳、布料、体积软体(volumetric soft bodies)的支持。并且软体可以和刚体之间进行双向交互(Two-way interaction)。

使用函数 btSoftBodyHelpers::CreateFromTriMesh 可以从面片模型生成软体。默认的情况下，软体的碰撞检测是在顶点和面片之间进行的，因而需要很稠密的细分（dense tessellation）才能进行正确的碰撞检测。Bullet另外还实现了一种基于Automatic decomposition convex deformable clusters的改进方法，通过如下代码启用：

psb->generateClusters(numSubdivisions);//enable cluster collision between soft body and rigid bodypsb->m_cfg.collisions += btSoftBody::fCollision::CL_RS;//enable cluster collision between soft body and soft bodypsb->m_cfg.collisions += btSoftBody::fCollision::CL_SS;

Bullet支持对软体或软体的单个顶点施加力：

softbody ->addForce(const btVector3& forceVector);softbody ->addForce(const btVector3& forceVector,int node);

Bullet支持对单个顶点添加约束，以实现各种效果。如固定软体中单个顶点的位置：

softbody->setMass(node,0.f);

或者将软体中某个顶点附着在刚体上：

softbody->appendAnchor(int node,btRigidBody* rigidbody, bool disableCollisionBetweenLinkedBodies=false);

3 Hello World 源码分析

Bullet引擎中在 ·examples/HelloWorld/HelloWorld.cpp· 文件中提供了一个Hello World版本，也就是一个简易的Demo，能够让我们初步了解Bullet引擎的基本使用方法。

主要分为四个部分：

• 创建dynamics world进行参数配置。
• 添加仿真物体，并设置物体信息。
• 循环更新逻辑，逐帧输出物体位置数据。
• 释放分配的资源及指针。

3.1 创建Dynamics world

首先是include头文件 ·btBulletDynamicsCommon.h· 。这个文件内部包含了常用的API。

#include "btBulletDynamicsCommon.h"#include <stdio.h>

然后创建dynamics world，并设置重力大小、使用的Solver类型以及配置等参数。

///collision configuration contains default setup for memory, collision setup. Advanced users can create their own configuration.btDefaultCollisionConfiguration* collisionConfiguration = new btDefaultCollisionConfiguration();///use the default collision dispatcher. For parallel processing you can use a diffent dispatcher (see Extras/BulletMultiThreaded)btCollisionDispatcher* dispatcher = new btCollisionDispatcher(collisionConfiguration);///btDbvtBroadphase is a good general purpose broadphase. You can also try out btAxis3Sweep.btBroadphaseInterface* overlappingPairCache = new btDbvtBroadphase();///the default constraint solver. For parallel processing you can use a different solver (see Extras/BulletMultiThreaded)btSequentialImpulseConstraintSolver* solver = new btSequentialImpulseConstraintSolver;btDiscreteDynamicsWorld* dynamicsWorld = new btDiscreteDynamicsWorld(dispatcher, overlappingPairCache, solver, collisionConfiguration);dynamicsWorld->setGravity(btVector3(0, -10, 0));

3.2 添加仿真物体

接着就是添加需要仿真的物体，这里以Sphere为例。需要设置物体的形状、Transform、质量、运动状态(Motion State)等信息，最后添加到dynamics world中。

//btCollisionShape* colShape = new btBoxShape(btVector3(1,1,1));btCollisionShape* colShape = new btSphereShape(btScalar(1.));collisionShapes.push_back(colShape);/// Create Dynamic ObjectsbtTransform startTransform;startTransform.setIdentity();btScalar mass(1.f);//rigidbody is dynamic if and only if mass is non zero, otherwise staticbool isDynamic = (mass != 0.f);btVector3 localInertia(0, 0, 0);if (isDynamic)colShape->calculateLocalInertia(mass, localInertia);startTransform.setOrigin(btVector3(2, 10, 0));//using motionstate is recommended, it provides interpolation capabilities, and only synchronizes 'active' objectsbtDefaultMotionState* myMotionState = new btDefaultMotionState(startTransform);btRigidBody::btRigidBodyConstructionInfo rbInfo(mass, myMotionState, colShape, localInertia);btRigidBody* body = new btRigidBody(rbInfo);dynamicsWorld->addRigidBody(body);

3.3 循环更新

准备工作就此完成，现在就可以正式进入程序的循环更新逻辑了。主要就是遍历dynamics world中的所有物体，并输出其位置信息。具体的物理仿真逻辑都隐藏在Bullet SDK中了，开发者无需涉足。

for (i = 0; i < 150; i++){dynamicsWorld->stepSimulation(1.f / 60.f, 10);//print positions of all objectsfor (int j = dynamicsWorld->getNumCollisionObjects() - 1; j >= 0; j--){btCollisionObject* obj = dynamicsWorld->getCollisionObjectArray()[j];btRigidBody* body = btRigidBody::upcast(obj);btTransform trans;if (body && body->getMotionState()){body->getMotionState()->getWorldTransform(trans);}else{trans = obj->getWorldTransform();}printf("world pos object %d = %f,%f,%f\n", j, float(trans.getOrigin().getX()),float(trans.getOrigin().getY()),float(trans.getOrigin().getZ()));}}

最后一步是释放掉各种分配的资源和指针，具体代码就不列出了。

4 功能演示

Bullet源码[2]中提供了一个Example Browser，用于浏览Bullet引擎中提供的各种实例场景，可以很直观的看到Bullet引擎提供的各类功能，并且用户可以使用鼠标拖拽移动场景中的物体进行交互。下面按照该Browser的划分来简单介绍功能。

4.1 API

展示Bullet引擎提供的基础API，如碰撞响应、摩擦力、Constrain以及各种物体类型刚体、Hinge、弹簧、陀螺仪、柔体。

4.2 Multibody

展示多个刚体之间的交互，主要是使用关节进行连接。

4.3 Physics Client-Server

Bullet支持使用CS架构调用其他进程进行物理仿真计算。其他进程可以在本地运行，也可以在其他机器上运行（通过TCP/UDP网络进行通信）。

4.4 Inverse Dynamics

反向动力学。拖拽其中一个位置之后，其他关节也会被带动进行旋转。

4.5 Inverse Kinematics

反向运动学。示例程序中的物体由多个关节相连，动作像随风摇摆的树一样。Inverse Kinematics和Inverse Dynamics有一定相似之处，但是两个算法具有不同的目标和初始假设[3]。

Inverse Dynamics是给定指定点在一段时间内的位置及速度，求各关节的转矩(torques)。

Inverse Kinematics (IK)要计算的则是保证指定点处于指定位置的情况下，各关节的旋转度数。IK经常被用于进行骨骼动画和物理的融合，常用于游戏及Robotics。

4.6 Deformable Body

主要是可变形物体的展示，如布料（自碰撞、摩擦力）、可变形物体以及可变形物体与刚体的交互。

4.7 Soft Body

柔体的模拟，好像和Deformable Body就是一样的东西，不知道为什么会单独列出。包括布料、柔体、体积/压强约束、绳子的模拟，同时也有一个空气动力学的Demo。

4.8 Benchmarks

小方块碰撞性能测试。3000个小方块从空中落下、碰撞并散开。支持多线程和SIMD加速。

4.9 Importers

展示Bullet引擎为各类文件格式提供的导入器，包括自己的.bullet格式以及其他常用格式如URDF（Unified Robot Description Format），MJCF（Multi-Joint Dynamics with Contact Format），SDF（Spatial Data File）等文件。这些文件主要是储存场景物体模型及状态信息。

4.10 Raycast

射线功能被广泛应用于游戏等应用，实现鼠标选中三维物体等功能。在示例场景中，一条水平方向的射线在垂直方向上下移动，并显示该射线在场景物体上的交点及交点位置处的法线。

4.11 Experiments

夹子模拟。类似于抓娃娃机一样的行为，使用一个夹子抓取地面上的方块。

4.12 Rendering

Bullet SDK同时支持CPU渲染及GPU渲染。

4.13 Evolution

神经网络驱动的自动行走的小蜘蛛。

5 “前车之鉴”

最后大致总结一下Bullet引擎中值得参考和学习的地方：

• 开发语言。Bullet引擎本体使用C++进行开发，目前正在开发PyBullet，将接口暴露在Python语言中，通过pip install命令即可安装，让开发者能够更轻松的上手。
• 编译工具。Bullet同时支持Premake[4]和CMake[5]两种方式。
• 源码文档。Bullet使用了Doxygen[6]实现源码文档的自动生成。
• 接口设计。基础方面Bullet将整个物理引擎分割为了许多的模块如Configuration，Broadphase，Narrowphase等，每个模块都提供了几种默认类型供选择，开发者也可以自己继承基类实现自己的计算方法。并且Bullet加入了许多callback支持开发者的自定义行为。
• 物理引擎实现原理。Bullet官网列出了与其实现相关的三个SIGGRAPH 2015 course的slides[7][8][9]，讲解了物理引擎的基本实现原理、优化算法和并行加速。

6 References

1. 为什么Physx会成为目前大部分主流游戏引擎的选择，相比较bullet优势在哪里？. https://www.zhihu.com/question/309154499/answer/578649506
2. bulletphysics/bullet3 源码. https://github.com/bulletphysics/bullet3
3. Inverse Dynamics – Wikipedia. https://en.wikipedia.org/wiki/Inverse_dynamics
4. Premake: Powerfully simple build configuration. https://premake.github.io/
5. CMake: An open-source, cross-platform family of tools designed to build, test and package software. https://cmake.org/
6. Doxygen: Generate documentation from source code. http://www.doxygen.nl/
7. Introduction to rigid body pipeline, collision detection. https://docs.google.com/presentation/d/1-UqEzGEHdskq8blwNWqdgnmUDwZDPjlZUvg437z7XCM/edit#slide=id.ga4b37291a_0_0
8. Advances in constraint solving, Featherstone Articulated Body Algorithm. https://docs.google.com/presentation/d/1wGUJ4neOhw5i4pQRfSGtZPE3CIm7MfmqfTp5aJKuFYM/edit#slide=id.ga4b37291a_0_0
9. Acceleration of the full collision detection and constraint solver on GPU. https://docs.google.com/presentation/d/1BW5-2ADy88-Eo_v_bknTNDOoBNYjRL4XCF_tYLYUL3g/edit#slide=id.ga4b37291a_0_0

Abstract

In chemistry, and natural sciences in general, experimental and laboratory work is one of the most effective methods for acquiring knowledge. Students can have a more intuitive and thorough understanding of subject knowledge through various well-designed experiments. However, traditional physical laboratories have several limitations, such as high maintenance costs, limited resources, and potential safety issues. Therefore, we try to take advantage of computer simulation technology to enable users to engage in chemistry experiments in a more convenient and efficient way in the virtual world.

First, we present the design and implementation of ChemiX, a general and efficient chemistry experiment simulation engine. A highly scalable database is implemented for inputting and storing information about chemical substances and chemical reactions. We also proposed a general and efficient method to calculate the reaction rate based on the principle of chemical kinetics, which supports the unified simulation of common chemical reactions in our system.

Second, we developed ChemiX Lab, a virtual chemistry lab based on our simulation engine. We implemented a user-friendly interface and powerful simulation features such as event-based process guidance and automated demonstration. Our system has great simulation capabilities while preserving high performance and scalability, and can be applied in many fields such as chemistry experiment simulation and teaching tool.

Finally, our system provides well-designed interfaces and powerful simulation features, making it effortless to extend. Other developer can easily build their own virtual chemistry lab based on our system by adding scenes, experiments, or focusing on improving certain feature such as interaction and rendering.

ScreenShots

• Demonstration

• Overall architecture

• Basic user interface

• Database Configuration

我们提供了Windows 64位可执行版本，欢迎试玩~

Vincent's Dream is a puzzle game about dream and redemption. In this game, you are going to help Vincent Van Gogh to accomplish his dreams about travling to Japan.

This game is made using Unreal Engine 4, one of the most powerful game engine ever on earch. You can know more about the stories behind Vincent's magnificent painting and solve mistery along the way.

Screenshots

• Stories to be told

• Lost to be found

• Mistery to be solved

Download

• Source Code
• Win64 Build

Several techniques and libraries are used in this program:

• Core-profile Mode and Instanced Rendering are used to achieve better performance
• Assimp library for loading model
• Stb_image library for loading texture
• Freetype for font rendering

Screenshots

• Custom shader

• Self-made model: Evil robot

Download

• Release Date: March 2018
• Source: https://github.com/vitalight/OpenGL-Solar-System

Features

• Real-time preview
• Contrast Adjustment
• Edge detection
• Hough transform
• Mathematical Morphology

Download

• Release Date: Jan 2018
• Source: https://github.com/vitalight/Visionary

• MySQL as database
• Java for backend with SSH framework
• JSP and jQuery for frontend

Screenshots

• Portfolio page

• Tutorial page

• Chat page

• Project page

• User page