Fundamentals of Vector Mathematics for 2D/3D Graphics in PHP

A vector in PHP graphics represents position, direction, or velocity using a class like Vector3D with x, y, z components. 2. Basic operations include addition, subtraction, scalar multiplication, and division for movement and scaling. 3. Magnitude is calculated via the Pythagorean theorem, and normalization converts a vector to a unit vector for consistent direction. 4. The dot product determines alignment between vectors, useful for lighting and angle calculations. 5. The cross product in 3D yields a perpendicular vector, essential for normals and rotations. 6. Distance between points is derived from the magnitude of their difference. 7. Linear interpolation (lerp) enables smooth transitions between vectors for animations. 8. Practical PHP use cases include game logic simulation, SVG generation, and pathfinding, where vector math ensures accurate spatial reasoning despite PHP’s non-real-time nature.

When working with 2D or 3D graphics in PHP—especially in contexts like game development, image manipulation, or procedural animations—you’ll often need to handle positions, directions, and transformations. While PHP isn’t traditionally used for high-performance graphics, understanding vector mathematics is essential for implementing logic like movement, collision detection, or camera systems in custom engines or backend simulations.

Here’s a practical breakdown of the fundamentals of vector math you need, tailored for 2D/3D graphics, and how to implement them in PHP.

1. What Is a Vector?

In graphics programming, a vector is a mathematical object that has both magnitude (length) and direction. It's commonly used to represent:

• Position (e.g., (x, y) or (x, y, z))
• Velocity (how fast and in what direction something moves)
• Acceleration
• Direction (e.g., light direction, surface normals)

In PHP, you can represent a 2D or 3D vector using a simple class:

class Vector3D {
    public $x, $y, $z;

    public function __construct($x = 0, $y = 0, $z = 0) {
        $this->x = $x;
        $this->y = $y;
        $this->z = $z;
    }

    // For 2D, just use $z = 0 and ignore it
}

2. Basic Vector Operations

These are the building blocks of vector math.

Vector Addition and Subtraction

• Addition: Combine two vectors (e.g., move by velocity).
• Subtraction: Get the direction from one point to another.

public function add(Vector3D $v): Vector3D {
    return new Vector3D($this->x   $v->x, $this->y   $v->y, $this->z   $v->z);
}

public function subtract(Vector3D $v): Vector3D {
    return new Vector3D($this->x - $v->x, $this->y - $v->y, $this->z - $v->z);
}

Example:

$position = new Vector3D(1, 2, 0);
$velocity = new Vector3D(0.5, -0.3, 0);
$newPosition = $position->add($velocity); // (1.5, 1.7, 0)

Scalar Multiplication and Division

Used to scale a vector (e.g., slow down movement).

public function multiply(float $scalar): Vector3D {
    return new Vector3D($this->x * $scalar, $this->y * $scalar, $this->z * $scalar);
}

public function divide(float $scalar): Vector3D {
    if ($scalar == 0) throw new InvalidArgumentException("Cannot divide by zero");
    return new Vector3D($this->x / $scalar, $this->y / $scalar, $this->z / $scalar);
}

3. Magnitude and Normalization

Magnitude (Length)

The length of a vector is calculated using the Pythagorean theorem.

For 3D:

|v| = √(x²   y²   z²)

public function magnitude(): float {
    return sqrt($this->x**2   $this->y**2   $this->z**2);
}

Normalization

Makes a vector have a length of 1 (unit vector), useful for directions.

public function normalize(): Vector3D {
    $mag = $this->magnitude();
    if ($mag == 0) return new Vector3D(0, 0, 0);
    return $this->divide($mag);
}

Example:

$direction = new Vector3D(3, 4, 0);
$unit = $direction->normalize(); // (0.6, 0.8, 0) — length is now 1

4. Dot Product

The dot product tells you how much two vectors are aligned. It's a scalar value.

Formula:

a · b = ax*bx   ay*by   az*bz

Also:

a · b = |a||b|cos(θ)

Useful for:

• Checking if two directions are facing the same way
• Back-face culling
• Lighting calculations (angle between light and surface)

public function dot(Vector3D $v): float {
    return $this->x * $v->x   $this->y * $v->y   $this->z * $v->z;
}

Example:

$forward = new Vector3D(1, 0, 0);
$other = new Vector3D(0.7, 0.7, 0);
$angleCos = $forward->dot($other); // 0.7 → about 45 degrees

5. Cross Product (3D Only)

Returns a vector perpendicular to two input vectors. Crucial for:

• Finding surface normals
• Calculating torque or rotation axes

Formula (simplified):

a × b = (ay*bz - az*by, az*bx - ax*bz, ax*by - ay*bx)

public function cross(Vector3D $v): Vector3D {
    return new Vector3D(
        $this->y * $v->z - $this->z * $v->y,
        $this->z * $v->x - $this->x * $v->z,
        $this->x * $v->y - $this->y * $v->x
    );
}

Note: The cross product is anti-commutative: a × b = -(b × a)

6. Distance Between Two Points

Treat positions as vectors. Distance is the magnitude of the difference.

public static function distance(Vector3D $a, Vector3D $b): float {
    return $a->subtract($b)->magnitude();
}

7. Linear Interpolation (Lerp)

Smoothly transition between two vectors. Used in animations, camera movement.

public function lerp(Vector3D $target, float $t): Vector3D {
    // $t is between 0 (start) and 1 (end)
    $t = max(0, min(1, $t));
    return new Vector3D(
        $this->x   ($target->x - $this->x) * $t,
        $this->y   ($target->y - $this->y) * $t,
        $this->z   ($target->z - $this->z) * $t
    );
}

8. Practical Use Cases in PHP

Even if PHP isn’t rendering graphics directly, you might:

• Simulate object movement on a server
• Validate game logic
• Generate SVG or canvas coordinates
• Precompute paths or collision zones

Example: Move an object toward a target

$position = new Vector3D(0, 0, 0);
$target = new Vector3D(10, 5, 0);
$direction = $target->subtract($position)->normalize();
$speed = 0.2;
$position = $position->add($direction->multiply($speed));

Bonus: 2D vs 3D

• For 2D, just set $z = 0 and ignore it.
• Use Vector2D class if you want to optimize (fewer operations).
• Cross product doesn’t exist in 2D, but you can compute the perpendicular vector: (-y, x) or (y, -x).

Final Notes

• PHP is not optimized for real-time graphics, but vector math is easy to implement and useful for backend logic.
• Consider caching magnitude if used often (square magnitude comparisons avoid sqrt).
• Always check for zero vectors before normalizing.

Basically, once you have vector addition, subtraction, dot product, and normalization, you can build most motion and spatial logic needed in 2D/3D environments—even in PHP. It’s not about speed; it’s about correctness and clarity.

The above is the detailed content of Fundamentals of Vector Mathematics for 2D/3D Graphics in PHP. For more information, please follow other related articles on the PHP Chinese website!