2D Game Physics Programming

Learn all the theory and the math behind 2D game physics and create a simple rigid-body physics engine from scratch with C++.

This course is a gentle introduction into the world of 2D game physics! We’ll review all the beautiful math that provides the foundation for most physics engines, starting with a strong review of vectors, matrices, basic trigonometry, rigid-body collision, and touching a little bit of calculus as well.
The lectures are designed to teach all concepts from first principles. In our journey, we’ll review several topics from physics, like velocity, acceleration, integration, mass, forces, gravity, drag, friction, rigid body dynamics, collision detection, constraints, etc.

We’ll also put theory into practice by coding a very simple 2D physics engine from scratch using the C++ programming language.

We’ll start by writing a simulation of particle physics, which is a good start for us to address concepts like movement, forces, displacement, and integration.

We’ll then proceed to work with rigid bodies by adding shapes to our objects, like circles, rectangles, and polygons. We’ll also learn how to code the collision detection and collision resolution between these rigid bodies.
We’ll conclude our C++ implementation by adding constraints to our physics engine, which will help us add different types of objects to our engine, like joints and ragdolls. Ultimately, constraints will help us improve the stability of our engine, and they are a great opportunity for us to discuss some interesting ideas from calculus.

MP4 | 视频：h264，1920X1080 | 音频：AAC，44.1千赫，2声道
类型：电子学习 | 语言：英语 | 时长：191课时（35小时8分钟）| 大小：6.96 GB 含课程文件

课程目录：
001. Introduction & Learning Outcomes
002. How to Take this Course
003. What is Game Physics
004. A Quick Review of Vector Math
005. Vector & Scalar Quantities
006. Using the P5js Web Editor
007. Visualizing Errors in the Web Editor
008. Coding a Vec2 Class
009. Vector Magnitude
010. Vector Addition & Subtraction
011. Methods for Vector Addition & Subtraction
012. Vector Equality
013. Scaling Vectors
014. Static Methods
015. Applications of Vector Addition & Subtraction
016. Dot Product
017. Is the Dot Product Commutative
018. Cross Product
019. Coding the Cross Product Method
020. Exercise Perpendicular 2D Vector
021. Perpendicular 2D Vector
022. Exercise Vec3 Methods
023. Vec3 Methods
024. Vector Normalization
025. Coding the Normalization Method
026. Scaling, Translating, and Rotating Vectors
027. Quick Review of Sine & Cosine
028. Vector Rotation Proof (x-component)
029. Vector Rotation Proof (y-component)
030. Coding the Vec2 Rotate Method
031. Concluding our JavaScript Vector Class
032. Vec2 C++ Header File
033. A Quick Look at C++ Vec2 Syntax
034. Vec2 Operator Overloading
035. Technologies & Dependencies
036. Folder Structure
037. Initial Project Files
038. Compiling using GCC & Linux
039. Makefile
040. Configuring Visual Studio on Windows
041. Introduction to Particle Physics
042. Particle Class
043. Particle Velocity
044. Using the + Operator to Add Vectors
045. Controlling our Framerate
046. Framerate Independent Movement
047. Clamping Invalid DeltaTime Values
048. Moving in a Constant Velocity
049. Changing the Particle’s Velocity
050. Keeping the Particle Inside the Window
051. Constant Acceleration
052. Discrete vs. Continuous
053. Integration & Movement Simulation
054. Different Integration Methods
055. Particle Integrate Function
056. Applying Forces to Particles
057. Function to Add Force
058. Particles with Different Mass
059. The Weight Force
060. Inverse of the Mass
061. Applying Forces with the Keyboard
062. Drag Force
063. Drag Force Function
064. Handling Mouse Clicks with SDL
065. Unexpected Drag Behavior
066. Friction Force
067. Friction Force Function
068. Gravitational Attraction Force
069. Gravitational Attraction Force Function
070. Spring Force
071. Spring Force Function
072. Exercise Spring Forces
073. Multiple Particles Chain
074. Multiple Particles Soft body
075. Soft Bodies & Verlet Integration
076. Rigid-Bodies
077. Shapes
078. Shape Class
079. Shape Class Implementation
080. Circle Shape
081. Angular Velocity & Angular Acceleration
082. Torque & Moment of Inertia
083. Circle Shape Angular Motion
084. Box Vertices
085. Local Space vs. World Space
086. Body Update Function
087. Why Not a Shape Draw Function
088. No Draw Method in the Shape Class
089. Circle-Circle Collision Detection
090. Circle-Circle Collision Class
091. Circle-Circle Collision Implementation
092. Collision Contact Information
093. Collision Information Code
094. Broad Phase & Narrow Phase
095. The Projection Method
096. Objects with Infinite Mass
097. Impulse Method & Momentum
098. Impulse
099. Deriving the Linear Impulse Formula
100. Simplifying the Impulse Method Formula
101. Coding the Linear Impulse Method
102. Is Linear Collision Response Enough
103. AABB Collision Detection
104. SAT Separating Axis Theorem
105. Finding Minimum Separation with SAT
106. Polygon-Polygon Collision Code
107. Code to Find SAT Minimum Separation
108. Refactoring the SAT Separation Function
109. Finding Extra Collision Information with SAT
110. Polygon-Polygon Collision Information
111. Linear & Angular Velocity At Point
112. Post-Collision Velocity At Point
113. Computing Linear & Angular Impulse
114. Collision Distance Vectors Ra-Rb
115. 2D Cross Product Simplification
116. Coding the Impulse Along Normal
117. Exercise Impulse Along Tangent
118. Friction Impulse Along Tangent
119. Removing Window Boundaries Check
120. Circle-Polygon Collision Detection
121. Finding Polygon’s Nearest Edge with Circle
122. Exercise Circle-Polygon Edge Regions
123. Circle-Polygon Collision Information
124. Circle-Polygon Collision Resolution
125. Exercise Polygons with Multiple Vertices
126. Polygon with Multiple Vertices
127. Loading SDL Textures
128. Rendering Circle Texture
129. World Class
130. Implementing World Functions
131. Refactoring Function to Update Vertices
132. Local Solvers vs. Global Solvers
133. A Naive Iterative Positional Correction
134. Constrained Rigid-Body Physics
135. Position vs. Velocity Constraints
136. Example Velocity Constraint & Bias Factor
137. Example Distance Constraint & Bias Factor
138. Constraint Forces & Constrained Movement
139. Force-Based vs. Impulse-Based Constraints
140. The Constraint Class
141. VecN Class
142. Implementing VecN Functions
143. VecN Operator Overloading
144. Matrices
145. MatMN Class
146. Matrix Transpose
147. Matrix Multiplication
148. Matrix Multiplication Function
149. Seeing Beyond the Matrix
150. Generalized Velocity Constraint
151. Solving Violated Velocity Constraints
152. Constraint Class Inheritance
153. Distance Constraint
154. Joint Constraint Class
155. Converting World Space to Local Space
156. World List of Constraints
157. Refactoring Body Update
158. Deriving the Distance Jacobian
159. Populating the Distance Jacobian
160. Solving System of Equations (Ax=b)
161. Gauss-Seidel Method
162. Constrained Pendulum
163. Solving System of Constraints Iteratively
164. Warm Starting
165. Adding the Bias Term
166. Ragdoll with Joint Constraints
167. Preventing NaN Errors
168. Penetration Constraint
169. Deriving the Penetration Jacobian
170. Penetration Constraint Class
171. Solving Penetration Constraints
172. Penetration Warm Starting
173. Penetration Constraint Friction
174. Clamping Friction Magnitude Values
175. Penetration Constraint Bounciness
176. Unstable Stack of Boxes
177. Allowing for Multiple Contact Points
178. Reference & Incident Edges
179. Finding Incident Edge
180. Getting Ready for Clipping
181. Clipping Function
182. Testing Multi-Contact Boxes
183. Testing Multiple Objects & Constraints
184. Contact Caching
185. Continuous Collision Detection
186. Broad & Narrow Split
187. Euler Integration Review
188. MidPoint & RK4 Integrators
189. Verlet Integration
190. Stick Constraints
191. Conclusion & Next Steps