Early experimentation of this project https://youtu.be/1vXl_lay8fQ.

Unstable Star experimentation

00:00 Introduction
01:21 Rendering
03:20 Shapes
05:16 Colors
06:16 Ending

A big thanks to AlexIsLouis for the music :D
His channel https://www.youtube.com/channel/UCUWRUMnMP50v4x0CI2WMVHw

Real time Fire Simulation

Quick and easy setup of a JavaScript 3d Physics Engine in three.js and ammo.js.

Support me on:
Patreon: https://www.patreon.com/simondevyt

Follow me on:
Twitter: https://twitter.com/iced_coffee_dev
Instagram: https://www.instagram.com/beer_and_code/
Github: https://github.com/simondevyoutube/

In this project I'll show you how to use ammo.js and three.js to setup a simple 3d scene with phyics in just a few minutes. We'll step through the basics of how to instantiate your physics world, and what the various options are, which can server to add a whole new dimension of possibilities to your 3D scenes.

What we'll cover:
* Three.js and Ammo.js initialization, how to instantiate your 3d physics world
* Creating rigid bodies and simple shapes such as boxes and spheres
* Using MotionState to synchronize transforms between the physics world and 3d scene.

There's a lot of options for JavaScript 3d engines, like Ammo.js, oimo.js. cannon.js, etc. They're all extremely capable physics engines, but we'll be focusing on one in particular, ammo.js which is a wrapper around the Bullet physics engine.

Full source code for the project is available, so if you're interested in fiddling with the code, screwing around with it, or improving it.

Building a Simple 3D Scene with Physics in JavaScript & Three.js

In this video I present the process of creating a little physics based brick breaker.

Executable demo soon.

00:00 Intro
01:25 Base version
01:37 Add Physics
02:26 Add Sounds
02:56 Add Special Blocks
04:28 A First Level
05:12 Removing Gravity
06:05 Add Upward Gravity

Creating a Brick Breaker with my PHYSICS ENGINE

Keep exploring at https://brilliant.org/TheCherno/ Get started for free, and hurry—the first 200 people get 20% off an annual premium subscription.

Patreon ► https://patreon.com/thecherno
Instagram ► https://instagram.com/thecherno

Twitter ► https://twitter.com/thecherno
Discord ► https://discord.gg/thecherno

Code ► https://github.com/St0wy/GPR4400-PhysicsEngine
Designing a Physics Engine in 5 minutes ►  https://youtu.be/-_IspRG548E

Send an email to chernoreview@gmail.com with your source code, a brief explanation, and what you need help with/want me to review and you could be in the next episode of my Code Review series! Also let me know if you would like to remain anonymous.

CHAPTERS
0:00 - Recap
1:14 - How to design an API
2:52 - 2D Physics Engine design
9:02 - Pointers and ownership semantics
13:00 - Using std::weak_ptr to be "safer"
14:39 - More physics
16:42 - Spatial partitioning for optimization
22:55 - Be careful when trying to optimize!
26:37 - Physics solvers
31:50 - Final thoughts and extra challenges

This video is sponsored by Brilliant.

#CodeReview

2D Physics Engine! // Code Review

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

This demo has been made in C++ and SFML.

Github https://github.com/johnBuffer/Smoke

00:00 Intro
00:16 Particles Motion
00:53 Particles Transformations
02:15 Explosions
02:40 Examples
03:36 Ending

How I like to program Smoke

Source code https://github.com/johnBuffer/VerletSFML

Music used https://pixabay.com/music/ambient-mindfulness-relaxation-amp-meditation-music-22174/