Physics Simulation and Collision Detection Questions

Covers engine level physics concepts and collision systems used in games and interactive simulations. Topics include rigid body dynamics, velocity, acceleration, gravity, forces, constraints and constraint solving, and common numerical integration methods. Collision detection algorithms and pipelines are covered end to end: collision shapes and colliders such as boxes, spheres, and triangle meshes; broad phase and narrow phase strategies; axis aligned bounding box tests, sphere tests, swept collision and continuous collision detection, and raycast and sweep queries. Also include collision response, contact resolution, callbacks and query interfaces, and the use of collision layers and collision masks to control interactions. Spatial partitioning and acceleration structures such as uniform grids, quadtrees, octrees, and bounding volume hierarchies are discussed for performance. Performance and stability topics include sleeping, collision groups, collision matrices, solver iterations, fixed timestep versus variable timestep approaches, determinism concerns for networking, physics framerate, and optimization strategies when integrating with a game engine.

HardSystem Design

96 practiced

Explain how to implement contact resolution that produces stable stacking of boxes (e.g., crates stacked 10 high) without jitter. Cover contact-manifold generation, constraint formulation, solver iteration counts, warm-starting, position correction strategies (split-impulse, Baumgarte), friction tuning, and test cases you would use to validate stability.

Sample Answer

**Clarify goal**Produce deterministic, non-jittery stacking for many rigid boxes (e.g., 10-high crates) in real time on target platforms.

**Contact-manifold generation**- Produce persistent manifolds: detect contact pairs each frame, cluster nearby contact points into a stable manifold (plane + set of contact points) instead of single point per pair.- Track feature IDs so contacts persist across frames for warm-starting and friction history.

**Constraint formulation**- Form velocity-level non-penetration (normal) constraints and Coulomb friction constraints per manifold basis (tangent directions).- Use contact basis aligned to manifold normal to avoid switching.

**Solver strategy**- Iterative projected Gauss-Seidel (PGS) or sequential impulse. Use 8–20 solver iterations for velocity solve for stable stacks; fewer (2–4) for mobile platforms but compensate elsewhere.- Warm-starting: initialize impulses from previous frame per contact ID to reduce drift and oscillation.- Limit per-iteration impulse clamping to maintain convergence.

**Position correction**- Prefer split-impulse: separate positional correction from velocity solve to avoid artificial energy injection. Apply small position corrections only for deep penetrations.- Baumgarte can be used with tiny beta (0.01–0.05) for slow drift but avoid large values that cause jitter.

**Friction tuning**- Use friction cones approximated by two tangents or directional friction that’s stable under iterations.- Lower static/dynamic friction slightly for tall stacks to avoid lock/unlock; increase solver iterations or use exact friction projection for accuracy.

**Performance/stability trade-offs**- More iterations + warm-start → stability; split-impulse → less jitter but extra complexity.- Determinism: fixed timestep + fixed solver iteration count + consistent contact ordering.

**Validation test cases**- Single column: 10 crates aligned, no initial velocity — should remain stable indefinitely.- Add small impulse to top crate — stack settles without exploding.- Alternating orientation crates (edge contact) to test manifold robustness.- Vary timestep and run on low-iteration budget to observe failure modes.- Long-run stress test with thousands of drops to check accumulation of error.

This combination—persistent manifolds, warm-started iterative solver with moderate iterations, split-impulse/controlled positional correction, and tuned friction—yields stable, low-jitter stacks suitable for games.

EasyTechnical

153 practiced

Contrast discrete collision detection with continuous collision detection (CCD). Explain the tunneling problem, swept tests, time-of-impact (TOI), conservative advancement, and when CCD or substepping is required versus simpler fixes like 'fat' colliders or limiting object speed.

EasyTechnical

72 practiced

Implement a ray vs AABB intersection test in C++ that returns whether the ray intersects and the entry and exit t values. Use the slab method and handle ray direction components near zero. Signature: bool RayAABB(const Ray& ray, const AABB& box, float& tmin, float& tmax). Assume Ray has origin and direction.

Sample Answer

**Approach (brief)**

Use the slab method: for each axis compute t0 and t1 where ray intersects the two planes; keep the running interval [tmin,tmax]. Handle near-zero directions by using a large inverse or testing origin inside slab.

cpp

// C++ implementation — assumes Vec3 has x,y,z and operator[].
struct Ray { Vec3 origin, dir; };
struct AABB { Vec3 min, max; };

bool RayAABB(const Ray& ray, const AABB& box, float& outTmin, float& outTmax) {
    const float kEps = 1e-8f;
    float tmin = -FLT_MAX;
    float tmax =  FLT_MAX;

    for (int i = 0; i < 3; ++i) {
        float o = ray.origin[i];
        float d = ray.dir[i];
        float bmin = box.min[i];
        float bmax = box.max[i];

        if (fabsf(d) < kEps) {
            // Ray parallel: if origin not between slabs -> no hit
            if (o < bmin || o > bmax) return false;
            continue;
        }

        float invD = 1.0f / d;
        float t0 = (bmin - o) * invD;
        float t1 = (bmax - o) * invD;
        if (t0 > t1) std::swap(t0, t1);

        tmin = t0 > tmin ? t0 : tmin;
        tmax = t1 < tmax ? t1 : tmax;
        if (tmax < tmin) return false;
    }

    outTmin = tmin;
    outTmax = tmax;
    return true;
}

Explanation, complexity, edge cases- Works by intersecting 1D intervals (slabs) per axis, taking their intersection.- O(1) time, O(1) memory.- Handles near-zero directions by treating as parallel; if origin inside slab it's okay.- Watch for numerical precision (kEps), inverted boxes (ensure min<=max), and wanting only positive t (ray forward) — clamp by checking outTmax >= 0 and outTmin <= outTmax if needed.

EasyTechnical

77 practiced

Explain the differences between Axis-Aligned Bounding Boxes (AABB) and Oriented Bounding Boxes (OBB) in game physics. Discuss memory cost, transform handling, rotation support, cost of overlap tests, and typical use-cases (dynamic players, static level geometry, fast projectiles). When would you choose one over the other for mobile vs console?

EasyTechnical

85 practiced

Explain the difference between explicit (forward) Euler and semi-implicit (symplectic) Euler integration for rigid body motion in games. Discuss numerical stability, energy behavior over time, order of accuracy, and give short pseudocode for both integrators updating velocity and position under constant acceleration.

Sample Answer

**Difference — high level**- Explicit (forward) Euler uses current velocity to step position: x_{n+1} = x_n + v_n * dt. - Semi-implicit (symplectic) Euler first updates velocity then uses the new velocity for position: v_{n+1} = v_n + a * dt; x_{n+1} = x_n + v_{n+1} * dt. Both are first-order accurate in time, but their stability and energy behavior differ.

**Numerical stability & energy**- Explicit Euler: conditionally stable; tends to artificially increase energy for oscillatory systems (energy can blow up), often unstable for stiff problems unless dt is tiny. - Semi-implicit (symplectic) Euler: better long-term qualitative behavior for Hamiltonian/rigid-body motion — it is symplectic so it tends to conserve a modified energy and bounds energy error (no secular drift), giving more stable orbits even with larger dt.

**Order of accuracy**- Both are first-order (O(dt)), so local error O(dt^2), global O(dt).

**When to use in games**- Use symplectic Euler for simple rigid-body motion and orbital/oscillatory problems where energy behavior matters and you want larger stable timesteps. Explicit Euler only for very cheap, small-dt updates or pedagogical purposes.

**Pseudocode (constant acceleration a)**

// Explicit (Forward) Euler
// Inputs: x, v, a, dt
x = x + v * dt;
v = v + a * dt;

// Semi-implicit (Symplectic) Euler
// Inputs: x, v, a, dt
v = v + a * dt;
x = x + v * dt; // uses updated velocity

**Notes**- For rotations/rigid bodies, apply same pattern to angular velocity and orientation (use normalized quaternions after integration). - If accuracy beyond first order is needed, consider RK2/Verlet or implicit solvers for stiffness.

Unlock Full Question Bank

Get access to hundreds of Physics Simulation and Collision Detection interview questions and detailed answers.

Join thousands of developers preparing for their dream job.