Physics Engine

Force

[Physics] An influence that can cause an object to change its velocity (Unit: Newton)

Mass

[Physics] An intrinsic property of a body measuring its resistance to acceleration (inertia) when a net force is applied (Unit: kg)

Normal Force

[Physics] A perpendicular reaction force exerted by a surface pushing back against an object

Friction Force

[Physics] The force resisting the relative motion of surfaces, proportional to the normal force

Impulse

[Physics] A force applied during a specific delta time

Physics Engine Loop

[Physics] A systematic 3-step loop: (1) Sum forces acting on an object, (2) update velocity according to time step (dt), and (3) update position according to velocity and dt

Newton’s First Law (Principle of Inertia)

[Physics] A body remains at rest or in motion at a constant speed in a straight line unless acted upon by a force

Newton’s Second Law

[Physics] Force is proportional to the change of motion (acceleration) over time.

Newton’s Third Law (Reaction Law)

[Physics] To every action, there is always an opposed and equal reaction

Gravitation Law

[Physics] The attractive force between two masses (‘m1’, ‘m2’) separated by distance ‘r’, where ‘G’ is the gravitational constant

Spring Force (Hooke’s Law)

[Physics] Force is proportional to extension, where ‘k’ is the spring stiffness factor

Vector

[Geometry] A geometric object characterized by a magnitude (length) and a direction, usually expressed in column notations

Dot Product

[Geometry] Sum of the products of the vector components. Results in a scalar value that indicates the angle or spatial projection of one vector onto another (a ‘dot’ b = 0 means orthogonal)

Cross Product

[Geometry] An operation unique to 3D space that outputs a vector perpendicular to both input vectors

Lerp

[Geometry] Linear interpolation between positions along a straight line

Slerp

[Geometry] Spherical linear interpolation, which smoothly transitions directional orientations along a curved arc

Determinant

[Geometry] A scalar attribute calculated from a square matrix. If det(A) =/= 0, the system yields a unique solution; if 0, it has no inverse or infinitely many solutions

Gaussian Elimination

[Geometry] An algebraic algorithm that applies row operations to reduce an augmented matrix into row echelon form to solve linear systems

Cramer’s Rule

[Geometry] An explicit formula for solving linear equations using quotients of matrix determinants

Orthogonal Matrix

[Geometry] A square matrix whose column vectors are entirely mutually perpendicular. If normalized, it becomes an orthonormal matrix where its inverse equals its transpose.

Pipelining

[Architecture] An execution technique that overlaps the stages of multiple instructions (Fetch, Decode, Execute, Write) to run simultaneously.

Pipeline Stall

[Architecture] Delays or gaps in the pipeline cycle caused by instruction hazards or waiting for data.

Latency

[Architecture] The number of cycles an instruction takes to navigate the entire pipeline

Throughput

[Architecture] The number of instructions completed per clock cycle (Instructions Per Clock / IPC)

Out-Of-Order Execution

[Architecture] A processing method where a CPU executes instructions based on data readiness rather than their original programmatic sequence

Register Renaming

[Architecture] A technique where the CPU secretly maps architectural registers to hardware registers to clear fake data dependencies in parallel execution loops

Cache Levels & Lines

[Architecture] Hierarchy designed to curb main RAM read latency. Caches read data inside fixed 64-byte lines. Moving from fastest/smallest to slowest/largest: L1 (Instruction/Data), L2, L3 (Last Level Cache / LLC).

Compute-Bound

[Architecture] Tasks that are limited by raw calculation performance (ALU speed)

Memory-Bound

[Architecture] Tasks that are limited by memory layout speeds and suffer high cache misses

Speculative Execution / Branch Prediction

[Architecture] The CPU guesses which branch direction a conditional check (‘if’ statement) will take to fetch instructions ahead of time. A Misprediction flushes the pipeline, causing severe cycle loss

SIMD (Single Instruction Multiple Data)

[Architecture] Performing calculations across multiple pieces of uniform data simultaneously in specialized wide registers (e.g., SSE, AVX), distinct from multi-threading.

Profiling

[Profiling] Measuring the runtime characteristics of a program (e.g., execution time, memory usage, bandwidth, hardware utilization).

Hotspot

[Profiling] A specific area or section of code within a program that consumes a high amount of execution time or resources.

Bottleneck

[Profiling] A point in execution that limits the overall performance of the application.

Sampling

[Profiling] A profiling method that periodically interrupts the program to record the call stack, yielding statistical averages (e.g., Intel VTune, Linux perf)

Instrumentation

[Profiling] A profiling method requiring manual code hooks inserted into the source code to collect exact business-logic metrics (e.g., Tracy, Optick).

High CPU Time

[Profiling] Inefficient algorithm execution where the processor spends excessive time inside computations, loops, or branch mispredictions.

High Wait Time

[Profiling] Idle processor states where code blocks wait for async tasks, disk I/O, network calls, or mutex locks to finish

Real-Time Safe Code

[Profiling] Code with deterministic, known-in-advance worst-case execution times that must complete before a specific deadline. Rule of thumb: Avoid 3rd party code, mutexes, memory allocation/deallocation, and I/O on the hot path.

static

[C++] Holds many different depending on how you use it. In a free function/global space, it establishes internal linkage (hidden from other units). Inside a function block, it defines a persistent local variable initialized only once on the first run

constexpr

[C++] It permits functions to execute at either compile-time or run-time depending on inputs

consteval

[C++] It guarantees execution occurs exclusively at compile time.

Tweening

[Math] Mathematical interpolation adjustments (e.g., SmoothStart, SmoothStop, SmoothStep) that transform linear transitions into natural-looking accelerations or decelerations.

Gimbal Lock

[Math] A critical constraint encountered when using Euler angles (Yaw, Pitch, Roll) where the loss of one degree of freedom occurs when two rotational axes align on a 90 degres pitch.

Quaternion

[Math] A four-dimensional coordinate representation (w, x, y, z) composed of one real component and three imaginary components (i, j, j). Quaternions avoid Gimbal Lock and provide an efficient way to calculate smooth, non-linear 3D spatial rotations via spatial vector operations.

Complex Numbers

[Math] An algebraic field expansion built using the imaginary unit. Restricting complex numbers to unit length enables them to model 2D rotations.

General Purpose Registers

[Assembly] Fast-access storage units on the CPU. Key system boundaries include RSP (Stack Pointer), RBP (Base Pointer), and RAX/EAX/AX/AL (Return Values).

Size Mapping

[Assembly] Bool = 1 Byte

Int/Float = Double-word (4 Bytes)

Pointer/Long/Double = Quadword (8 Bytes)

Sign Extension (movsx / movsxd)

[Assembly] Moving smaller signed numbers into larger memory formats while preserving the sign bit.

LEA (Load Effective Address)

[Assembly] Copies an address from source to destination; frequently used by compilers for fast addition and power-of-2 multiplication.

Endianness

[Assembly] Byte ordering scheme in memory. x86_64 architecture uses Little-endian, placing the least significant byte first.

std::array

[C++] A stack-based container with a compile-time fixed size; the optimal "go-to" structural choice for low-level performance.

std::vector

[C++] A heap-based dynamic container that handles variable size execution using pointers (begin, end, capacity). Allocates memory dynamically when resizing or pushing back.

std::map

[C++] A linked-list structure organized as a node-based red-black tree. It causes heavy performance issues on cache-oriented layouts due to partial/rebalancing traversals.

std::unordered_map

[C++] A hash map using continuous constant lookup bounds via key hashing. Potential drawbacks include cache misses (buckets use linked lists) and hash collision penalties.

Small String Optimization (SS)

[C++ concept] A compiler optimization technique where small strings are stored directly on the stack to bypass dynamic heap allocation overhead.

std::unique_ptr

[C++] A smart pointer that completely owns a piece of memory. It cannot be copied or shared, ensuring the memory is deleted safely when it goes out of scope.

std::shared_ptr

[C++] A smart pointer that tracks how many owners point to a piece of memory. The memory is only deleted when the very last owner stops using it.

Rule of Zero

[C++ concept] A modern rule stating you should design classes so they don't need custom cleanup code at all, leaving it entirely to automated smart pointers and standard containers.

Broadphase Collision

[Physics] A quick, cheap screening phase that weeds out objects that are nowhere near each other using simple bounding boxes.

Narrowphase Collision

[Physics] The precise, secondary phase that takes the remaining close objects and calculates exactly where and how they are hitting each other.

Seperating Axis Theorem (SAT)

[Physics] A rule stating that if you can fit a straight flat line between two shapes without touching either, they are not colliding.

Convex Polygon

[Physics] A shape with no inward dents. If you draw a line between any two points inside the shape, the line never crosses outside the border.

Semi-Implicit Euler Integration

[Physics] A formula for moving objects where you calculate the new velocity first, and then immediately use that new velocity to find the next position. It is highly stable and popular in game loops.

MRU/MRUA

[Physics] Physics equations detailing uniform straight-line motion (constant speed, zero acceleration) versus uniformly accelerated linear motion (constant acceleration altering speed over time).

Centripetal Acceleration

[Physics] The inward-pulling acceleration that forces an object moving at a constant speed to turn in a perfect circle.

Superscalar Execution

[CPU] The CPU’s ability to process multiple separate instructions at the exact same time during a single clock cycle.

Conflict Cache Miss

[CPU] A mistake that happens when data is kicked out of the cache prematurely because multiple active memory addresses are fighting over the exact same cache slot, even if other slots are completely empty.

Branchless Programming

[CPU] Writing code without using if statements. Instead, you use math or logic tricks so the CPU can run in a straight, uninterrupted line.

Leaf Function

[Assembly] A function that doesn't call any other functions. Because it is an "end point," it saves time by skipping the setup of a formal memory stack frame.

Packed Instructions (addps)

[SIMD] A parallel instruction that calculates a whole bundle of numbers (like four floats) at the exact same time in a single step.

Scalar Instructions (addss)

[SIMD] A traditional instruction that calculates only a single number at a time, leaving the rest of the CPU's parallel pathways completely empty.

Array of Structures (AoS)

[SIMD] Organizing data by object ([Player1: X, Y, Z], [Player2: X, Y, Z]). This is easy to read but slow for the CPU to process in bulk.

Structure of Arrays (SoA)

[SIMD] Organizing data by property ([All Xs], [All Ys], [All Zs]). This allows the CPU to grab exactly what it needs in bulk without wasting cache space.

RAII

[C++ concept] A core rule in C++: binding a resource (like allocated memory) to the lifespan of an object. The object grabs the memory when it's born and automatically deletes it when it dies.

Devirtualization

[C++ concept] An optimization where the compiler figures out exactly which function will be called ahead of time, bypassing the slow vtable lookup completely.

Move Semantics

[C++ concept] Transferring ownership of data from one object to another without duplicating or copying the underlying data, usually using std::move.

CPU

[Core Hardware] The computer’s brain that executes code and runs calculations

RAM

[Core Hardware] The computer’s temporary main memory; it is fast but clears completely when turned off

Cache

[Core Hardware] Ultra-fast, tiny memory built directly inside the CPU to store recently used data

Stack

[Core Hardware] An ultra-fast, organized memory scratchpad where local function variables live and die automatically

Heap

[Core Hardware] A large, unorganized pool of memory used for variables that change size dynamically; must be managed manually

Pointer

[C++ concept] A variable that holds a memory address (a location) instead of an actual value

Reference

[C++ concept] A safe nickname or alias for an existing variable that doesn't copy the data