Math is the backbone of any engine. But the math needed for simple games and real time physics simulation is not the same as the math needed for CAE or scientific computing.

The GusOnGames engine needs a math module that is:

• lightweight
• predictable
• fast
• easy to read
• easy to debug
• easy to integrate with OpenGL

This article defines the exact math foundations required for the engine — no more, no less.

Vectors and points are the fundamental building blocks for representing positions, directions, and displacements in 3D space. In the GusOnGames engine, we distinguish between points (which represent positions) and vectors (which represent directions and magnitudes).

The math module provides:

• vec2, vec3, vec4
• mat2, mat3, mat4
• quaternion (optional, later)
• Transform (composition of translation, rotation, scale)

These types must be:

• header only
• POD like (plain data, no hidden magic)
• predictable
• explicit
• safe

We avoid operator overloading that hides cost or intent.

Required operations:

• addition
• subtraction
• scalar multiplication
• dot product
• cross product (vec3 only)
• normalization
• length / squared length

Design principles:

• no implicit conversions
• no dynamic allocation
• no virtual functions
• no exceptions
• no hidden normalization

Summary:

Vectors must behave like simple structs with clear math operations.

Required operations:

• identity
• multiplication
• transform a vector
• transpose
• inverse (mat4 only, optional for mat3)

Design principles:

• column major storage (OpenGL friendly)
• explicit constructors
• no lazy evaluation
• no operator overloading for “magic” transforms

Summary:

Matrices must be predictable and compatible with GPU expectations.

A Transform represents:

• position
• rotation
• scale

Transforms must support:

• combine(parent, child)
• toMatrix()
• fromMatrix() (optional)

We start with:

• Euler angles (simple, intuitive)

Later articles may introduce:

• quaternions (for smooth rotation, camera control)

Transforms define movement between:

• local space
• world space
• view space
• projection space
• screen space

Understanding these spaces is essential for rendering.

The object’s own coordinate system.

All objects placed together.

The world as seen from the camera.

Perspective or orthographic projection.

Normalized device coordinates → viewport.

Every rendering operation is a chain of transforms:

vertex_local
→ model_matrix
→ world_space
→ view_matrix
→ view_space
→ projection_matrix
→ clip_space
→ screen_space

The math module must make this pipeline easy to express.

Real time engines face different numerical challenges than CAE tools.

• precision loss
• catastrophic cancellation
• drift over time
• unstable normalization

• normalize vectors only when needed
• avoid repeated matrix multiplications
• avoid unnecessary inverses
• use squared length for comparisons
• clamp values when needed
• use epsilon comparisons for equality

Physics simulations require:

• predictable math
• stable integration
• consistent floating point behavior

This is why the math module must be simple and explicit.

The math module must be:

• header only
• dependency free
• engine agnostic
• GPU friendly
• easy to debug

These headers define the core math types and operations for the engine.

engine/math/include
    vector.h
    matrix.h
    projections.h
    transformations.h
    math_utils.hpp

We avoid:

• GLM
• Eigen
• DirectXMath
• CAE math libraries

Why?

Because the engine needs:

• predictable behavior
• simple debugging
• minimal overhead
• clear educational value

Matrices must be column major to match OpenGL’s expectations.

Vectors must be contiguous and trivially copyable.

• explicit constructors
• no implicit conversions
• no hidden normalization
• no operator overloading that hides cost
• clear naming (normalize, not norm)
• predictable behavior

This makes the math module easy to use and easy to teach.

The following is a quick reference for the math module API:

The math module provides the foundational types and operations used throughout the GusOnGames engine:

• vectors
• matrices
• transforms
• utilities

It is:

• header only
• dependency free
• GPU friendly (column major matrices)
• explicit and predictable
• designed for real time rendering and physics simulation

vectors (vec2, vec3, vec4)

Members

• float x, y, (z, w)

Key Methods

• vecX operator+(vecX)
• vecX operator-(vecX)
• vecX operator*(float)
• float dot(vecX1, vecX2)
• float length()
• float length_squared()
• vecX normalized()

matX (mat2, mat3, mat4)

Storage

• float m[4] (column major) // for mat2
• float m[9] (column major) // for mat3
• float m[16] (column major) // for mat4

Key Methods

• static matX identity()
• matX operator*(matX)
• vecX operator*(vecX)
• matX transposed()

Transform

Members

• vec3 position
• vec3 rotation (Euler angles, radians)
• vec3 scale

Key Methods

• mat4 to_matrix()
• static Transform combine(parent, child)

math_utils

Functions

• bool nearly_equal(float a, float b, float eps)
• float clamp(float v, float min, float max)
• float radians(float degrees)
• float degrees(float radians)

• Explicit — no hidden conversions
• Predictable — no magic normalization
• Lightweight — no dynamic allocation
• GPU friendly — column major matrices
• Educational — readable and easy to debug
• Real time oriented — stable, simple operations