Physics Engine in Odin from Scratch, Part IV
In the forth part, we learn about Separation Axis Theorem and we implement both collision detection and resolution.
Stay updated with the latest posts from my blog.
In the forth part, we learn about Separation Axis Theorem and we implement both collision detection and resolution.
In the third part, we'll start with physics.odin file, and at the end, our cubes will fall under the influence of gravity.
In the second part, we'll revise some topics from Newtonian physics, and we'll also talk about numerical integration.
In the first part, we'll set up the project and look at the architecture of a physics engine from a bird's eye view.
In the final part, we're going to introduce the concept of a model and add support for rendering more than one in our scene.
In the thirteenth part, we're going to implement support for multiple lights with different colors and learn how to blend them.
In the twelfth part, we're going to implement switching between orthographic and perspective projection at runtime.
In the eleventh part, we're going to talk about optimizations, and by the end, we will significantly improve performance.
In the tenth part, we are going to learn about Phong shading by implementing a pair of new rendering modes.
In the ninth part, we're going to implement an OBJ loader to load a mesh from a file created, for example, in Blender.
In the eighth part, we're going to learn how to load an image and project it onto the surface of our cube as a texture.
In the seventh part, we're going to add flat shading to adjust triangle brightness based on their orientation to light.
In the sixth part, we're going to rasterize triangles to render our cube in a solid color and we implement a depth buffer.
In the fifth part, we're going to start implementing the draw.odin file, beginning with rendering a cube in wireframe mode.
In the fourth part, we're going to talk about the anatomy of a mesh, and we'll implement mesh.odin with a hardcoded cube.
In the third part, we'll talk about perspective projection, transformations and implement the matrix.odin file.
In the second part, we'll refresh some math topics related to graphics programming, and then we'll implement vectors.odin.
In the first part of the longest series yet, I'll outline what's coming, and we'll lay a cornerstone for the project.
In this post, I'll walk you through the implementation of a two-dimensional cloth simulation based on Verlet integration.
In the second part, we make a simple editor tool to automate assembly of a combination lock from the previous part.
Today, we build the foundation for a cylindrical combination lock, commonly found on suitcases and featured in game puzzles.
In the second part, I'll cover the internal implementation of a plugin that provides a screen recording subsystem.
In the first part, I'll guide you through the initial steps of creating a plugin that provides a screen recording subsystem.
Today, I'll show you how to create a sequence in C++, bind an object, and add keyframes from your own struct or other sequence.
In this short post, I'll show you a very simple PowerShell script to add cloud-saving functionality to almost any game.
In the addendum, we'll modify the foundation from previous parts to create an RPN (Reverse Polish Notation) calculator.
In the third part of this tutorial series, we're going to port our project with an already fully functional calculator to VR.
In the second part, we're going to build a tokenizer, a recursive descent parser, and a foundation for the Abstract Syntax Tree.
In the first part we'll learn how to animate a button with coroutines, work with Unity events and utilize TextMesh Pro.
In today's post, I'll show you how to get an image from a public API and create a material from this image at runtime.
In the second part, we're going to build on top of our maze array an actual maze from modular pieces using pattern matching.
In the first part, we'll create a maze as an array we're going to use next time to build an actual maze from modular pieces.
In the final part of the series about AI senses, we'll continue with an implementation of patrolling and reactive behavior.
In the first of two parts series about game AI, I'm going to guide you through an implementation of eyes and ears in Unity.
In this post, I'm going to show you how to use Blender to prepare almost any model for UE including material preparation.