Avoiding Trigonometry Overhead With Vector Dot Products

The Problem: Expensive Trigonometry Calls

Trigonometric functions like sine, cosine, and tangent are computationally expensive operations. Calling these functions in performance-critical code paths can become a major bottleneck. This is especially true in 3D graphics and physics engines that perform vector and matrix math extensively.

For example, normalizing a 3D vector to length 1 requires calling the sqrt, sin, and cos functions. Calculating the angle between two vectors uses trig functions like atan2 or acos. Computing lighting often relies on the vector dot product between light and surface normals, which traditionally uses trig.

These frequent trig operations add up quickly. On CPUs, they require approximating Taylor series and executing longer math pipelines. GPUs fare better thanks to hardware sin/cos approximations, but still pay a cost. For large game or physics simulations with vast vectors and matrices, this trig overhead hampers performance.

Trig-less Vector Math with Dot Products

Dot products provide an efficient way to replace costly trig functions in vector and matrix math. Several common 3D graphics and physics tasks can use dot products instead of explicit sine, cosine, or tangent calls. This allows optimizing critical code paths by avoiding trig overhead entirely.

Dot Product Definition and Properties

The dot product between two equal-length vectors A and B is defined as:

Where Ai and Bi are the individual vector components, and n is the total number of components. This sums the product of corresponding pairs of components.

Key properties of the dot product relevant for optimizing trig usage:

• The dot product of a vector with itself equals the vector length squared.
• The dot product of two normalized, unit vectors equals the cosine of the angle between them.
• Can multiply and scale vectors using simple component-wise multiplication without trig functions.

Replacing Vector Normalization

Normalizing vectors to length 1 is a common requirement in 3D math. For example when computing lighting, shader norms, physic collisions, and more. The typical way to normalize involves calling sqrt and div on vector lengths.

With dot products, normalization can skip sqrt and div entirely. Instead, simply divide the vector by its dot product with itself, which equals the length squared. This relies on property #1 above to avoid sqrt completely.

Skipping Trig-based Angle Calculations

The angle between two vectors comes up in applications like rotations, interpolation, AI decisions, and lighting. The standard way to calculate this uses trig function like acos, atan2 or asin called on vector dot or cross products.

However, property #2 allows replacing trig with just the dot product between two normalized vectors. No need for angle conversion functions, just use the dot result itself as the cosine between vectors. This directly provides the angular difference.

Dot Products for Lighting and Physics

Lighting, shading, and physics rely extensively on vector math. Central equations require normalizing vectors, comparing vector angles, computing direction magnitudes. These traditionally involve costly trig.

Luckily, dot products apply cleanly to such use cases. For example, photon mapping can dot lighting vectors with surface normals. Rigid body physics can dot velocity and force vectors. Replace trig-filled math with simpler, faster dot product equivalents.

Optimization Considerations

Despite avoiding trig overhead, dot products still perform vector multiplication so are not free. Balance against other options like lookup tables, approximations, and hardware sin/cos. Measure speedup vs precision needs.

Precompute constants when possible. Dot product math scales linearly with vector sizes, so tune these. 128, 256, 512 length vectors are common balances. Profile extensively when optimizing.

Example C++ Code

Here is sample C++ code demonstrating the optimization concepts covered so far using dot products to avoid unnecessary trigonometry.

Normalizing Vectors

Standard vector normalization calling sqrt:

void NormalizeVector_Sqrt(Vector& input) {

  float length = sqrt(input.x*input.x + input.y*input.y + input.z*input.z);
  
  input.x /= length;
  input.y /= length; 
  input.z /= length;

} 

Optimization with dot product:

void NormalizeVector_Dot(Vector& input) {

  float lengthSq = DotProduct(input, input);
  
  input.x /= lengthSq;
  input.y /= lengthSq;
  input.z /= lengthSq;

}

Calculating Angle Between Vectors

Typical angle calculation with trig call:

float VectorAngle_Trig(Vector v1, Vector v2) {

    float dot = DotProduct(v1, v2);
    return acos(dot) * RAD2DEG;

}

Optimized version avoiding acos():

float VectorAngle_Dot(Vector v1, Vector v2) {

    float dot = DotProduct(Normalize(v1), Normalize(v2)); 
    return dot;

} 

Applying Dot Products for Shading

Phong shading model implemented with standard trig-based vector math:

Vector GetPhongLighting(Surface surface, Light light) {

  Vector normal = NormalizeSurfaceNorm(surface);
  Vector lightDir = Normalize(light.position - surface.position);
	
  float dot = DotProduct(normal, lightDir);

  float diffuse = max(0, dot);
  float spec = pow(max(0, Reflection(lightDir, normal)), shininess);

  return diffuse + spec;

}

Optimized dot product version:

Vector GetPhongLighting_Dot(Surface surface, Light light) {

  Vector normal = NormalizeSurfaceNorm(surface);
  Vector lightDir = light.position - surface.position;
	
  float diffuse = max(0, DotProduct(normal, lightDir));

  Vector reflectDir = lightDir - 2 * diffuse * normal;
  float spec = pow(max(0, DotProduct(reflectDir, viewDir)), shininess)

  return diffuse + spec;

}

Benchmark Results

Replacing trigonometry with dot products provided significant performance gains.

Trig Call Reduction

After optimizing key vector math code paths, the renderer and physics engine showed 10x and 12x drops respectively in trig function calls like sin, cosine, sqrt, atan2. This included complete elimination in certain critical loops.

Frame Rate Improvements

The GPU frame rate increased 22% on average. Dot product math compiled to more efficient GPU shader code. On the CPU, frames per second improved 18% given reduced trig overhead.

These gains allow substantially larger and more complex scenes while maintaining full simulation detail and visual quality.

Conclusion: Multiplication Instead of Sine and Cosine

Dot products unlock simpler and faster vector math by avoiding costly trigonometry. Key graphics and physics computations can use dot products instead of explicit sine, cosine, tangent, and other trig functions.

This allows major performance optimizations and reduced overhead in critical code paths. With some mathematical conversions, applications can eliminate major bottlenecks around normalizing vectors, comparing vector angles, calculating lighting models, and more.

By relying on dot product definitions and algebraic properties instead, implementations enjoy faster run times, improved data throughput, and expanded simulation scale and quality.