-
Notifications
You must be signed in to change notification settings - Fork 2
/
index.xml
152 lines (152 loc) · 14.8 KB
/
index.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
<channel>
<title>Box2D</title>
<link>https://box2d.org/</link>
<description>Recent content on Box2D</description>
<generator>Hugo</generator>
<language>en</language>
<lastBuildDate>Tue, 27 Aug 2024 00:00:00 +0000</lastBuildDate>
<atom:link href="https://box2d.org/index.xml" rel="self" type="application/rss+xml" />
<item>
<title>Determinism</title>
<link>https://box2d.org/posts/2024/08/determinism/</link>
<pubDate>Tue, 27 Aug 2024 00:00:00 +0000</pubDate>
<guid>https://box2d.org/posts/2024/08/determinism/</guid>
<description>Determinism means many things when it comes to game development and especially physics engines. Generally in game development we like things to be repeatable. This makes debugging easier. This doesn&rsquo;t rule out emergent behavior though because player input can be viewed as random.
Testing Determinism Determinism is a brittle feature. It is easy to break. Code changes can break it. Compiler versions can break it. So it needs to be tested using continuous integration, or CI for short.</description>
</item>
<item>
<title>SIMD Matters</title>
<link>https://box2d.org/posts/2024/08/simd-matters/</link>
<pubDate>Mon, 19 Aug 2024 00:00:00 +0000</pubDate>
<guid>https://box2d.org/posts/2024/08/simd-matters/</guid>
<description>SIMD in game development Often in game development we talk about SIMD. It is the holy grail of CPU performance, often out of reach. The conventional wisdom is that it is difficult to achieve real gains from SIMD.
It is tempting to build a math library around SIMD hoping to get some performance gains. However, it often has no proven benefit. It just feels good to be using something we know can improve performance.</description>
</item>
<item>
<title>Releasing Box2D 3.0</title>
<link>https://box2d.org/posts/2024/08/releasing-box2d-3.0/</link>
<pubDate>Fri, 09 Aug 2024 00:00:00 +0000</pubDate>
<guid>https://box2d.org/posts/2024/08/releasing-box2d-3.0/</guid>
<description>Over 18 months ago I announced that I was working on Box2D version 3.0 (v3 for short). And it has finally arrived! It has been a long journey and I&rsquo;ve learned a lot. There is more work to do, but the library is ready to be used for game development.
I&rsquo;d like to thank the Box2D users who tested v3 during the alpha and beta. Their feedback and bug reports have been super helpful!</description>
</item>
<item>
<title>Solver2D</title>
<link>https://box2d.org/posts/2024/02/solver2d/</link>
<pubDate>Mon, 05 Feb 2024 00:00:00 +0000</pubDate>
<guid>https://box2d.org/posts/2024/02/solver2d/</guid>
<description>I was recently testing the Box2D version 3.0 alpha and found a stability problem. I found a fix for the problem fairly quickly, however the experience left me thinking about the progression of v3.0 and how the engine has been getting more features and more complexity. There are several joint types now. There is island management, multithreading, SIMD, graph coloring, continuous collision, and so on. These are all important features, but there is a problem.</description>
</item>
<item>
<title>Simulation Islands</title>
<link>https://box2d.org/posts/2023/10/simulation-islands/</link>
<pubDate>Sun, 08 Oct 2023 00:00:00 +0000</pubDate>
<guid>https://box2d.org/posts/2023/10/simulation-islands/</guid>
<description>Island management is a fundamental low level feature of physics engines and can have a big impact on solver design and performance. This was one of the first problems I decided to work on for Box2D version 3 (v3).
Since I began working on v3 I&rsquo;ve been comparing several algorithms for island management. My goal has been to make island building scale better with multiple CPU cores. Here are the three approaches I&rsquo;ve considered:</description>
</item>
<item>
<title>Starting Box2D 3.0</title>
<link>https://box2d.org/posts/2023/01/starting-box2d-3.0/</link>
<pubDate>Sun, 15 Jan 2023 00:00:00 +0000</pubDate>
<guid>https://box2d.org/posts/2023/01/starting-box2d-3.0/</guid>
<description>Over the holidays I started working on version 3.0 of Box2D. I started closing out some issues for v2.4 and then moved onto a backlog task: speculative collision. Speculative collision is a technique for continuous collision that promises to remove the serial bottleneck of time of impact sub-stepping. I made good progress in my research and then I realized that this would be a major update to Box2D. And if I&rsquo;m doing a major update to Box2D I might as well tackle some other big features and make version 3.</description>
</item>
<item>
<title>Ghost Collisions</title>
<link>https://box2d.org/posts/2020/06/ghost-collisions/</link>
<pubDate>Sun, 21 Jun 2020 00:00:00 +0000</pubDate>
<guid>https://box2d.org/posts/2020/06/ghost-collisions/</guid>
<description>Dealing with ghost collisions is a challenging problem in game physics. The basic idea comes from motion across a flat surface. You may have several shapes joined together to make a flat surface, like a triangle mesh in 3D or a chain of edges in 2D. Convex shapes can hit the internal connections and have their motion blocked. This is undesirable, we would rather have the convex shape move smoothly across the surface.</description>
</item>
<item>
<title>Stuck Inside</title>
<link>https://box2d.org/posts/2020/04/stuck-inside/</link>
<pubDate>Sun, 12 Apr 2020 00:00:00 +0000</pubDate>
<guid>https://box2d.org/posts/2020/04/stuck-inside/</guid>
<description>There a several computational geometry algorithms that are relevant for preparing collision data: convex hull, mesh simplification, and convex decomposition.
Many implementations of these algorithms are developed outside the specific context of rigid body simulation. For example, qhull computes convex hulls and appears to be application agnostic. Simplygon is focused on simplifying render mesh.
On the other hand, convex decomposition algorithms such as V-HACD are developed with physics simulation in mind.</description>
</item>
<item>
<title>Predictive Joint Limits</title>
<link>https://box2d.org/posts/2020/04/predictive-joint-limits/</link>
<pubDate>Fri, 03 Apr 2020 00:00:00 +0000</pubDate>
<guid>https://box2d.org/posts/2020/04/predictive-joint-limits/</guid>
<description>Box2D has support for continuous collision. This solves the problem of fast moving objects passing through each other due to discrete time steps. The Box2D continuous collision algorithm uses a time of impact (TOI) collision algorithm along with time sub-stepping for the response.
There are other artifacts due to discrete time steps. Joint limits can also suffer from fast movement. For example, consider a filing cabinet where the drawers use prismatic (slider) joints.</description>
</item>
<item>
<title>About</title>
<link>https://box2d.org/about/</link>
<pubDate>Wed, 01 Jan 2020 00:00:00 +0000</pubDate>
<guid>https://box2d.org/about/</guid>
<description>Hello! I&rsquo;m Erin Catto. I work in the video game industry. I also created Box2D, a 2D physics engine for games.
I use this blog to give updates on Box2D and write about game physics and programming.
You can find Box2D on GitHub There is a Discord Server And there is a Subreddit This site was created using Hugo and a modified version of hello friend ng.</description>
</item>
<item>
<title>How to Transform a Plane</title>
<link>https://box2d.org/posts/2018/09/how-to-transform-a-plane/</link>
<pubDate>Wed, 05 Sep 2018 00:00:00 +0000</pubDate>
<guid>https://box2d.org/posts/2018/09/how-to-transform-a-plane/</guid>
<description>Suppose you have a plane equation in local space and you&rsquo;d like to express that plane equation in world space. The plane in local space is written as:
$$P := (n, w)$$where \(n\) is the plane normal and \(w\) is the plane offset.
A point \(x\) is on the plane if
$$n \cdot x = w$$Now define a transform \(A\) as
$$A := (R, p)$$where \(R\) is an orthonormal rotation matrix and \(p\) is a translation vector.</description>
</item>
<item>
<title>Box2D Subreddit</title>
<link>https://box2d.org/posts/2018/07/box2d-subreddit/</link>
<pubDate>Sat, 07 Jul 2018 21:53:34 +0000</pubDate>
<guid>https://box2d.org/posts/2018/07/box2d-subreddit/</guid>
<description>I&rsquo;m now a moderator on the Box2D subreddit. So I think this makes it the official!
r/box2d
I look forward to seeing Box2D discussion on reddit.</description>
</item>
<item>
<title>Box2D Discord Server</title>
<link>https://box2d.org/posts/2018/06/box2d-discord-server/</link>
<pubDate>Sun, 24 Jun 2018 11:03:23 +0000</pubDate>
<guid>https://box2d.org/posts/2018/06/box2d-discord-server/</guid>
<description>Hi All! I created a Box2D server on Discord.
Discord
On a related note, I&rsquo;m considering locking the forums because I&rsquo;d rather spend my limited free time working on Box2D than maintaining the forums. I&rsquo;ve looked for new moderators over the last year or so unsuccessfully. Also updating phpBB and dealing with spam is not my cup of tea.
In the future I&rsquo;d like to see most Box2D community interactions be on GitHub and Discord, with announcements on my Twitter account.</description>
</item>
<item>
<title>Balancing Dynamic Trees</title>
<link>https://box2d.org/posts/2014/08/balancing-dynamic-trees/</link>
<pubDate>Thu, 07 Aug 2014 09:36:34 +0000</pubDate>
<guid>https://box2d.org/posts/2014/08/balancing-dynamic-trees/</guid>
<description>I received this question on LinkedIn:
I&rsquo;m working on a 3d dynamic aabb tree based on the concepts of Presson&rsquo;s bullet contribution. I came across a bullet forum thread in which Dirk recommended looking at your box2d implementation. I noticed the major difference is that box2d is a balanced tree using a surface area heuristic while bullet&rsquo;s is unbalanced with manhattan distance heuristic.
My guess is that keeping your tree balanced resulted in increased maintenance overhead but decreased tree query times.</description>
</item>
<item>
<title>Computing a Basis</title>
<link>https://box2d.org/posts/2014/02/computing-a-basis/</link>
<pubDate>Mon, 03 Feb 2014 11:33:04 +0000</pubDate>
<guid>https://box2d.org/posts/2014/02/computing-a-basis/</guid>
<description>Given a normalized 3D vector, here’s an efficient method for computing a full basis. The computed basis is axis aligned if the input vector is axis aligned.
void ComputeBasis(const Vec&amp; a, Vec* b, Vec* c) { // Suppose vector a has all equal components and is a unit vector: // a = (s, s, s) // Then 3*s*s = 1, s = sqrt(1/3) = 0.57735. This means that at // least one component of a unit vector must be greater or equal // to 0.</description>
</item>
<item>
<title>Troublesome Triangle</title>
<link>https://box2d.org/posts/2014/01/troublesome-triangle/</link>
<pubDate>Fri, 31 Jan 2014 16:50:09 +0000</pubDate>
<guid>https://box2d.org/posts/2014/01/troublesome-triangle/</guid>
<description>I ran into a problem computing a polygon normal using Newell&rsquo;s method as described in Christer Ericson&rsquo;s excellent book Real-Time Collision Detection. In this case the polygon happens to a be a triangle that is close to the origin. So I would guess that Newell&rsquo;s method would yield a great result. However, this is not true. I only get 2 digits of accuracy in single precision.
Here is the triangle:</description>
</item>
<item>
<title>m128</title>
<link>https://box2d.org/posts/2012/08/m128/</link>
<pubDate>Fri, 31 Aug 2012 12:28:59 +0000</pubDate>
<guid>https://box2d.org/posts/2012/08/m128/</guid>
<description>The best way to use SSE is to use the __m128 intrinsic directly. Unfortunately Visual Studio displays the values backwards (w,z,y,x). Bleh. Here is a change to autoexp.dat to correct the order.
First comment out this line:
__m128=$BUILTIN(M128) And add this line:
__m128=&lt;m128_f32[0]&gt;, &lt;m128_f32[1]&gt;, &lt;m128_f32[2]&gt;, &lt;m128_f32[3]&gt; </description>
</item>
<item>
<title>Shape Coordinates</title>
<link>https://box2d.org/posts/2012/03/shape-coordinates/</link>
<pubDate>Sun, 25 Mar 2012 20:52:29 +0000</pubDate>
<guid>https://box2d.org/posts/2012/03/shape-coordinates/</guid>
<description>Keep in mind that a shape does not know about bodies and stand apart from the dynamics system. Shapes are stored in a compact form that is optimized for size and performance. As such, shapes are not easily moved around. You have to manually set the shape vertex positions to move a shape. However, when a shape is attached to a body using a fixture, the shapes move rigidly with the host body.</description>
</item>
<item>
<title>Pixels</title>
<link>https://box2d.org/posts/2011/12/pixels/</link>
<pubDate>Sat, 17 Dec 2011 17:10:25 +0000</pubDate>
<guid>https://box2d.org/posts/2011/12/pixels/</guid>
<description>Box2D uses MKS (meters, kilograms, and seconds) units and radians for angles. You may have trouble working with meters because your game is expressed in terms of pixels. To deal with this in the testbed I have the whole game work in meters and just use an OpenGL viewport transformation to scale the world into screen space.
float lowerX = -25.0f, upperX = 25.0f, lowerY = -5.0f, upperY = 25.0f; gluOrtho2D(lowerX, upperX, lowerY, upperY); If your game must work in pixel units then you should convert your length units from pixels to meters when passing values from Box2D.</description>
</item>
<item>
<title>Publications</title>
<link>https://box2d.org/publications/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://box2d.org/publications/</guid>
<description>Box2D v3 Benchmarks Benchmarks
Dynamic Bounding Volume Hierarchies &mdash; GDC 2019 GDC Slides Full Slides
Numerical Methods &mdash; GDC 2015 Slides
Understanding Constraints &mdash; GDC 2014 Slides Matlab Source YouTube
Continuous Collision &mdash; GDC 2013 Slides YouTube
Ragdolls &mdash; GDC 2012 Slides
Soft Constraints &mdash; GDC 2011 Slides
Computing Distance using GJK &mdash; GDC 2010 Slides Source
Numerical Integration &mdash; GDC 2009 Slides Source
Modeling and Solving Constraints &mdash; GDC 2009 Slides</description>
</item>
</channel>
</rss>