Vector Math for Game Development: A Linear Algebra Primer

A unit vector has a magnitude of exactly 1 while preserving its original direction. Any normal vector can be converted to a unit vector through normalization by dividing each component by the vector's magnitude: ũ = V / |V|. For a vector with original length L, the normalized components become x/L and y/L. Unit vectors are essential for representing pure direction without magnitude, allowing easy scaling to any desired distance by multiplying by a scalar value.

Vector normalization is the mathematical process of converting any vector into a unit vector (with magnitude 1) by dividing its components by its original magnitude, which ensures consistent movement speed in all directions and is essential for implementing directional mechanics like character movement, target following, and knockback forces in game development.

A unit vector is a special vector with exactly one length (magnitude). Unit vectors are denoted with a small roof symbol over their head. They are easier to work with when only direction matters because direction remains unchanged regardless of vector length. To create a unit vector (normalize a vector), divide each component by the vector's length: unit_vector = vector / length(vector). This operation preserves direction while setting magnitude to one, making it ideal for directional calculations in graphics programming and OpenGL.

Vector normalization is the process of converting a vector to a unit vector (a vector with magnitude of 1) while preserving its direction. The video explains that normalization is achieved by dividing a vector by its magnitude. Unit vectors are useful for representing pure direction without magnitude, which is essential for many applications in computer graphics and physics simulations. The video demonstrates how normalization is used to create direction vectors that can be scaled independently of their original magnitude, enabling consistent directional movement regardless of speed.

Normalization is the process of making a vector's magnitude equal to 1 while preserving its direction. For a Vector3(1,1,0), the magnitude is √2 ≈ 1.414, but after normalization, it becomes 1. In game development, normalization solves the diagonal movement problem where diagonal movement would be faster than horizontal or vertical movement. Movement is calculated as speed × direction, where direction is obtained through normalization. This ensures consistent player movement speed in all directions. NormalizedDirection returns a vector with magnitude 1 without modifying the original, while Normalized actually modifies the original vector. Normalization should be used whenever consistent movement speed in all directions is needed.

This section details the complete set of 4x4 transformation matrices used in 3D computer graphics. The translation matrix includes an extra row and column to accommodate the z-dimension and enable translation through matrix multiplication. The scaling matrix maintains the same structure as 2D but adds a z-scaling factor in row 3, column 3. Three distinct rotation matrices exist: z-rotation (affecting x and y only), y-rotation (leaving y unchanged), and x-rotation (leaving x unchanged). Each matrix type serves specific geometric transformations essential for manipulating 3D models.

Linear transformations in 3D are described using 3x3 matrices where the first column describes where î ends up, the second column describes where ĵ ends up, and the third column describes where k̂ ends up. For translation, augment the matrix with a translation column and a row of zeros ending with 1. The 3D identity matrix has ones on the diagonal and zeros elsewhere. Scaling matrices scale along each axis. Three separate rotation matrices are needed for 3D: one for rotation around the x-axis, one for the y-axis, and one for the z-axis.

Translation moves objects by adding parameters to each coordinate: x' = x + TX, y' = y + TY, z' = z + TZ. Matrix form adds translation vector to coordinate vector. Scaling changes size by multiplying: x' = x×SX, y' = y×SY, z' = z×SZ. Matrix uses diagonal scaling factors. Both extend 2D concepts by adding the third dimension, preserving the fundamental mathematical relationships while enabling manipulation in three-dimensional space.

This comprehensive section covers all fundamental 3D transformation matrices used in computational geometry. The identity transformation uses a 4x4 matrix with 1s on the diagonal and 0s elsewhere. Scaling transformations modify specific columns: X-scaling changes the first column, Y-scaling changes the second column, and Z-scaling changes the third column, with the scaling factor placed in the corresponding diagonal position. Uniform scaling applies the same factor to all three diagonal positions. Shearing in a direction proportional to other coordinates modifies the corresponding column with factors proportional to other coordinates. Rotation about axes uses 2D rotation matrices embedded in 4x4 matrices: rotation about X-axis keeps first row/column as identity and places rotation matrix in rows 2-3, columns 2-3; rotation about Y-axis keeps second row/column as identity and places rotation matrix in rows 1,3 and columns 1,3; rotation about Z-axis keeps third row/column as identity and places rotation matrix in rows 1-2, columns 1-2. Translation in X, Y, or Z direction by factor a, b, or c respectively places the factor in the corresponding row of the fourth column. Combined translation in all three directions places factors in the first, second, and third rows of the fourth column.

Axis-Aligned Bounding Boxes (AABB) are rectangles aligned with the x and y axes used for efficient collision detection in 2D games. Collision detection involves checking if two AABBs intersect by verifying both horizontal and vertical overlap: horizontal overlap occurs when the top of each box is higher than the bottom of the other, and vertical overlap occurs when the left of each box is to the left of the right of the other. Collision resolution involves determining the direction of collision (top, bottom, left, or right) by comparing the current and previous frame's overlap values, then resolving the collision by pushing the entity out along the appropriate axis to prevent overlap while maintaining realistic physics behavior.

Collision detection in games involves two stages: first determining if two entities intersect (geometric problem), then resolving the physics of what happens when they collide (game mechanics dependent). Axis Aligned Bounding Boxes (AABB) are rectangles aligned with the x and y axes, enabling efficient collision checks. Two AABBs intersect if they overlap both horizontally (top of each box is higher than bottom of the other) and vertically (left of each box is less than right of the other). The overlap amount is calculated by comparing the distance between centers against half-widths and half-heights. Collision resolution involves pushing objects back out of overlap, with direction determined by previous frame overlap or velocity vectors to prevent sliding and ensure realistic interactions.

This lecture explains how to detect and resolve collisions between game entities using Axis-Aligned Bounding Boxes (AABB), which are rectangles aligned with the X and Y axes for efficient collision detection. The process involves two main stages: first, detecting if two AABBs intersect by checking for both horizontal and vertical overlap (where the top of each box is higher than the bottom of the other and the left of each box is to the left of the right of the other); second, resolving the collision by calculating the overlap area and pushing entities apart based on their movement direction, which requires examining the previous frame's overlap data to determine if the collision came from above/below or left/right.

This tutorial explains how to implement basic Axis-Aligned Bounding Box (AABB) collision detection and response in SFML 2.4, covering the mathematical principles of checking whether two axis-aligned rectangles intersect by comparing the absolute delta between their centers against their combined half-sizes, and resolving collisions by pushing objects apart based on a configurable 'push' factor that determines how much each object is displaced during collision resolution.

This segment covers ray casting implementation for object detection. The developer explains Axis-Aligned Bounding Box (AABB) collision detection, which tests if a ray intersects with objects by checking position and direction against object bounds. The segment covers calculating UV coordinates from hit points by subtracting object center and dividing by scale. The developer demonstrates the mathematical transformations needed to convert world space hit points into UV coordinates for texture sampling.

This segment explains the complete movement vector system used in Unity games. The input vector is created by querying horizontal and vertical axis values, then combined into a vector3. This vector is scaled by the player's maximum speed and time delta to ensure consistent movement regardless of game speed. The scaled vector is added to the player's current position to calculate the new position. Visual examples show how gamepad thumbstick inputs translate to directional vectors, and how scaling creates appropriate movement distance per frame.

The Projectile Movement Actor Component in Unreal Engine 4 is a built-in component that enables actors to move as projectiles using fake physics rather than the full physics engine, with key parameters including velocity (direction and speed), initial speed and max speed (movement limits), gravity scale (downward force), and homing (target-seeking behavior), while collision detection and bouncing require physics simulation on the projectile itself for proper interaction with the game world.

Make projectiles move by assigning velocity to their Rigidbody component. Calculate the direction vector as (destination - firePoint.position). Normalize this vector to get a unit direction, then multiply by a projectile speed value (e.g., 30). Assign this to rigidBody.velocity. This makes projectiles fly toward the calculated destination point while maintaining consistent speed regardless of distance.

Instead of moving projectiles via Transform.position, you can use Unity's physics system by adding force to a Rigidbody2D component. The projectile receives a Rigidbody2D with dynamic mode (not kinematic), zero angular drag, and zero gravity. In the projectile's Update() method, you get the Rigidbody2D component and call AddForce() with the shoot direction multiplied by a speed value, using ForceMode.Impulse to apply an instantaneous force. This approach leverages Unity's physics engine for realistic movement including collision responses and interactions with other physics-based objects.

This comprehensive segment covers the entire process of implementing a projectile system in Unreal Engine. The workflow includes: creating a Blueprint Class for projectiles with Static Mesh and Projectile Movement Components, configuring velocity and gravity settings, creating a Fire Event in the weapon's Blueprint, spawning projectiles at the weapon's location using a Socket for the firing position, configuring Input Actions to map player buttons to actions, creating a Reference Variable to hold the weapon, and calling the Fire Event when the player activates the input. This demonstrates the complete pipeline from projectile creation to player-triggered firing.