Collision detection systems show up in all sorts of video games and simulations. But how do you actually build these systems? Turns out that the key ideas behind these systems show up all over a field of computer science called computer graphics.

We start off with the basics of animation and then branch off into ideas in discrete and continuous collision detection. We break them down in the context of some simple simulations of a small number of particles, but scaling up these simulations is another challenge entirely. We present big ideas in broad phase optimization schemes for speeding up collision detection including the sweep and prune algorithm, uniform grids, K-D trees, and bounding volume hierarchies. 

0:00 Introduction
1:25 Intro to Animation
2:46 Discrete Collision Detection and Response
5:50 Implementation
6:50 Discrete Collision Detection Limitations
8:10 Continuous Collision Detection
11:42 Two Particle Simulations
13:13 Scaling Up Simulations
15:42 Sweep and Prune Algorithm
19:05 Uniform Grid Space Partitioning
20:43 KD Trees
23:51 Bounding Volume Hierarchies
27:12 Recap

Correction: At 9:02, the linear interpolation equations should be x(t) = t * x(1) + (1 - t) * x(0) and y(t) = t * y(1) + (1 - t) * y(0). All subsequent derivations have the x(0) switched with x(1). All y(0) should also be switched with y(1) for the same reason.

Post-correction 2: I ran the experiment with the naive solution of checking every pair of particles  with an added inefficiency in rendering the animations so the comparison wasn't fair and that's why the number was so high. The actual speed up is still fairly significant, but not THAT significant.

Minor correction: p.vel is updated and used in the next line at 6:28, p.vel and p.pos should be updated simultaneously

This video is supported by a community of Patreons
Special Thanks to the following Patreons:
Burt Humburg
Justin Hiester
Michael Nawenstein
Richard Wells
Zac Landis

Support: https://www.patreon.com/reducible
Twitter: https://twitter.com/Reducible20

This video wouldn't be possible without the open source library manim created by 3blue1brown: https://github.com/3b1b/manim

Here is link to the repository that contains the code used to generate the animations in this video: https://github.com/nipunramk/Reducible

2D Collision Response Vector Equation Derivation Walkthrough: https://www.vobarian.com/collisions/2dcollisions2.pdf 

Bounding Volume Hierarchy Traversal Algorithm for Broad Phase: https://thegeneralsolution.wordpress.com/2011/12/13/broad-phase-collision-detection-bounding-volume-hierarchies-1/

The ideas and presentation in this video were inspired by a culmination of resources -- here are some that I found particularly nice for further exploration:
https://www.toptal.com/game/video-game-physics-part-ii-collision-detection-for-solid-objects
Game Physics Engine Development by Ian Millington Ch. 12
https://github.com/mattleibow/jitterphysics/wiki/Sweep-and-Prune
http://www.mcihanozer.com/tips/computer-graphics/collision-detection-related/uniform-grid-based/

Building Collision Simulations: An Introduction to Computer Graphics

In 1988, three engineers came together and developed one of the most clever solutions to the problem of detecting when two complex objects collide. Their solution, the Gilbert Johnson Keerthi (GJK) algorithm, named after the authors, made an incredible impact in the fields of robotics, control, and computer graphics. This video is about understanding this ingenious algorithm from first principles.

The video covers a broad range of topics from Minkowski sums and differences to support functions to the full implementation of the 2D GJK algorithm. But what I hope you get out of this is an appreciation of the incredible shifts in perspective that lead to the final algorithm. Coming up with the algorithm is an amazing feat and useful for specific applications, but the overarching problem solving techniques that come through in the journey to the solution is truly invaluable. 

0:00 Introducing the Problem
2:02 Convexity
3:15 Infinite Point Perspective
4:07 Minkowski Sums and Differences
6:37 Triangles inside Minkowski Differences
7:41 Simplexes
8:57 Support Functions
13:05 Core GJK Algorithm: Broad Perspective
17:15 Remaining Key Questions
17:56 How to determine if a point passed the origin?
19:10 The line case
20:41 The triangle case
26:25 GJK Implementation
29:38 Recap and quick note about original GJK paper

This video is supported by a community of Patreons
Special Thanks to the following Patreons:
Burt Humburg
Justin Hiester
Michael Nawenstein
Richard Wells
Sebastian Gamboa
Zac Landis

There's a lot more to the GJK algorithm to learn for those interested. Here are some resources I recommend:
https://www.youtube.com/watch?v=Qupqu1xe7Io - a full walkthrough of how to implement GJK in 3D by Casey Muratori, the game developer/engineer that came up with some of the clever optimizations that I present in this video.
http://www.dyn4j.org/2010/04/gjk-gilbert-johnson-keerthi/ - a really nice writeup on GJK
https://www.youtube.com/watch?v=MDusDn8oTSE - A quick intro to GJK and an implementation in C++
https://www.toptal.com/game/video-game-physics-part-ii-collision-detection-for-solid-objects - solid resource for collision detection in general and goes deeper into the theory.
https://box2d.org/files/ErinCatto_GJK_GDC2010.pdf - an alternative perspective to GJK using barycentric coordinates -- I really wanted to cover this in this video, but it would have been an hour long instead of half an hour long so I'll compromise and give you this resource :)

Support: https://www.patreon.com/reducible
Twitter: https://twitter.com/Reducible20

This video wouldn't be possible without the open source library manim created by 3blue1brown: https://github.com/3b1b/manim

Here is link to the repository that contains the code used to generate the animations in this video: https://github.com/nipunramk/Reducible

Music attributions:
Midsummer Sky by Kevin MacLeod is licensed under a Creative Commons Attribution 4.0 license. https://creativecommons.org/licenses/by/4.0/
Source: http://incompetech.com/music/royalty-free/index.html?isrc=USUAN1100158
Artist: http://incompetech.com/
Luminous Rain by Kevin MacLeod is licensed under a Creative Commons Attribution 4.0 license. https://creativecommons.org/licenses/by/4.0/
Source: http://incompetech.com/music/royalty-free/index.html?isrc=USUAN1100169
Artist: http://incompetech.com/
Prelude No. 23 by Chris Zabriskie is licensed under a Creative Commons Attribution 4.0 license. https://creativecommons.org/licenses/by/4.0/
Source: http://chriszabriskie.com/preludes/
Artist: http://chriszabriskie.com/
All other tracks by Aakash Gandhi

A Strange But Elegant Approach to a Surprisingly Hard Problem (GJK Algorithm)

In this video, we take a look at Big O notation. We go through how Big O notation came about and why it's so useful as a method of measuring efficiency of algorithms. We then go through some examples of you can find the Big O runtime of various algorithms. 

Support: https://www.patreon.com/reducible

This video wouldn't be possible without the open source manim library created by 3blue1brown: https://github.com/3b1b/manim

Here is link to the repository that contains the code used to generate the animations in this video: https://github.com/nipunramk/Reducible

Music: 
October by Kai Engel https://freemusicarchive.org/music/Kai_Engel/Chapter_Four__Fall/Kai_Engel_-_Chapter_Four_-_Fall_-_05_October
November by Kai Engel
https://freemusicarchive.org/music/Kai_Engel/Chapter_Four__Fall/Kai_Engel_-_Chapter_Four_-_Fall_-_08_November
Cobweb Morning by Kai Engel
https://freemusicarchive.org/music/Kai_Engel/Chapter_Four__Fall/Kai_Engel_-_Chapter_Four_-_Fall_-_04_Cobweb_Morning

What Is Big O Notation?

This video is about an in depth look at one of the most challenging recursive problems for computer science students: Towers of Hanoi. We first take the perspective of how we would solve it if it was just a puzzle, where we look specifically at developing a general strategy. Afterwards, we then convert this strategy into a complete recursive solution to the problem. On the way to this solution, we learn a framework to think about and solve tough recursive problems like this one. We finish the video by take a step back and analyzing the recursive solution and how the recursion unravels. 

Support: https://www.patreon.com/reducible

This video wouldn't be possible without the open source manim library created by 3blue1brown: https://github.com/3b1b/manim

Here is link to the repository that contains the code used to generate the animations in this video: https://github.com/nipunramk/Reducible

Music: 
October by Kai Engel https://freemusicarchive.org/music/Kai_Engel/Chapter_Four__Fall/Kai_Engel_-_Chapter_Four_-_Fall_-_05_October
November by Kai Engel
https://freemusicarchive.org/music/Kai_Engel/Chapter_Four__Fall/Kai_Engel_-_Chapter_Four_-_Fall_-_08_November
Cobweb Morning by Kai Engel
https://freemusicarchive.org/music/Kai_Engel/Chapter_Four__Fall/Kai_Engel_-_Chapter_Four_-_Fall_-_04_Cobweb_Morning

Towers of Hanoi: A Complete Recursive Visualization

In this video, I explain the fundamental ideas behind the Depth First Search (DFS) graph algorithm. We first introduce the concept of a graph traversal. We then go through several examples of DFS to provide intuition. Afterwards, we then go through both a recursive and iterative implementation with provided code. We discuss the differences between the implementation and also make a distinction between a preorder and post order DFS traversal. We then finish the video off with some practical and fun applications of depth first search in graph theory.

0:00 Intro and Preview
0:50  Graph Traversal
1:20 DFS Walkthrough and Examples
6:26 Recursive Implementation
11:08 Iterative Implementation
15:06 Preorder vs Postorder DFS
17:01 DFS Applications

Support: https://www.patreon.com/reducible

This video wouldn't be possible without the open source manim library created by 3blue1brown: https://github.com/3b1b/manim

Here is link to the repository that contains the code used to generate the animations in this video: https://github.com/nipunramk/Reducible

Depth First Search (DFS) Explained: Algorithm, Examples, and Code

Bézier curves - how do they do?

They're used for animation, text rendering, and all sorts of curved shapes! But how do they actually work? well, like, that's what the video is about, so, watch it to find out etc!!


• Lots of love to
💛 Jazz "queenjazz" Mickle for making the music ❱ https://queenjazz.bandcamp.com/
💙 Grant "3Blue1Brown" Sanderson for pushing me to finally do this ❱ https://youtube.com/3blue1brown
🐦 Pomax for their wonderful writeup on Bézier curves ❱ https://pomax.github.io/bezierinfo
🐈 Thor the cat for.. hanging out.. when I was trying to record audio with no interruptions
🇫🇷 French subtitles by @damqui on Twitter

• How was this video made?
🔨 Created in the Unity game engine
⭕ Using Shapes, my vector graphics plugin ❱ https://u3d.as/1W37
📈 Using Mathfs, my math library ❱ https://github.com/FreyaHolmer/Mathfs
...along with a bunch of hacky, partially broken, procedural animation tools I made specifically for this video

• Did you know that "osculating" isn't pronounced that way?
✅ yes I do now in fact please stop commenting on it ;-; ❱ https://twitter.com/FreyaHolmer/status/1429472399389507591

• Links
💖 Patreon ❱ https://www.patreon.com/acegikmo
🐦 Twitter ❱ https://twitter.com/FreyaHolmer
📺 Twitch ❱ https://www.twitch.tv/acegikmo
💬 Discord ❱ https://discord.gg/v5VWuga
🌸 Instagram ❱ https://instagram.com/freya_holmer

00:00 Intro
01:06 Use Cases of Bézier Curves
01:56 Lerp
02:34 Quadratic Béziers
03:07 Cubic Béziers
03:57 De Casteljau's Algorithm
04:25 Bernstein Polynomial Form
06:18 1st Derivative (Velocity)
07:31 Tangents & Normals
08:03 2nd Derivative (Acceleration)
08:31 3rd Derivative (Jerk/Jolt)
09:07 Curvature
11:05 Bounding Box
14:14 Arc Length
15:07 Arc Length Parameterization & Uniform Animation
19:13 Outro
19:54 Credits
23:57 Thor helping me record this at 2am

The Beauty of Bézier Curves

Welcome to the first part in a series teaching pathfinding for video games. In this episode we take a look at the A* algorithm and how it works.

Some great A* learning resources:
http://theory.stanford.edu/~amitp/GameProgramming/
http://www.policyalmanac.org/games/aStarTutorial.htm

Source code: https://github.com/SebLague/Pathfinding

If you'd like to support the creation of more programming videos, I'd greatly appreciate your support on patreon:
https://www.patreon.com/SebastianLague

Background music is 32. The Hidden Path by longzijun.

A* Pathfinding (E01: algorithm explanation)

Introduction to Algorithms

Introduction to course.

Why we write Algorithm?
Who writes Algorithm?
When Algorithms are written?

Differences between Algorithms and Programs

PATREON : https://www.patreon.com/bePatron?u=20475192

Courses on Udemy
================
Java Programming
https://www.udemy.com/course/java-se-programming/?referralCode=C71BADEAA4E7332D62B6

Data Structures using C and C++
https://www.udemy.com/course/datastructurescncpp/?referralCode=BD2EF8E61A98AB5E011D

C++ Programming
https://www.udemy.com/course/cpp-deep-dive/?referralCode=E4246A516919D7E84225