Why is Vector3.ProjectOnPlane() "drifting" further from desired rotation on steep slopes

Question

I'm writing a simple player movement script in Unity 3D, and I've been using Vector3.ProjectOnPlane() to accomplish slope/ramp movement. For the most part, this works on smaller slopes but I've noticed that the steeper the slope is, the more the direction seems to drift further away than expected, causing the player to walk further to one side than the input would suggest.

(To clarify, orientationTransform is rotated via the Mouse Input, thus only needing to use transform.forward/right in the movement calculation.)

Code:

// Excerpt from main movement loop
Vector3 movementDirection = (orientationTransform.forward.normalized * inputs.y + orientationTransform.right.normalized * inputs.x).normalized;

if (stateHandler.IsGrounded) {
  if(stateHandler.IsOnSlope) {
    Debug.DrawRay(orientationTransform.position, movementDirection.normalized * 3f, Color.magenta);
    return GetVectorOnSlope(movementDirection) * movementForce * Time.fixedDeltaTime;
  } else {
    return movementDirection * movementForce * Time.fixedDeltaTime;
  }
}

// Vector Function
Vector3 GetVectorOnSlope(Vector3 vector) {
  RaycastHit hitInfo;
  if (Physics.Raycast(orientationTransform.transform.position, Vector3.down, out hitInfo, 
  1f, groundLayer)) {
    Debug.DrawRay(orientationTransform.position, Vector3.ProjectOnPlane(vector, 
    hitInfo.normal) * 2f, Color.red);
    return Vector3.ProjectOnPlane(vector, hitInfo.normal).normalized;
  } else {
    return vector;
  }
}

Example:
Desired Direction - Magenta
ProjectOnPlane Direction - Red

I've tried normalizing the result and experimenting with Vector3.Cross() as well as attempting to skip using Vector3.ProjectOnPlane() altogether, but I've not had much luck.

Is this the correct way for me to be implementing this? I feel like Vector3.ProjectOnPlane() is behaving exactly as it should, but I can't figure out an alternative to achieve what I'm looking for.

Any help is greatly appreciated!

Answer 1

If you wanted to achieve a similar result without using projections, you might want to try just rotating the vector. This should be relatively easy to do knowing the normal of the plane.

I would take the cross product of Vector3.up and the plane normal to find the rotation axis, and then create a quaternion with the Quaternion.AngleAxis() function. The angle can be found with Vector3.SignedAngle(), using our newly calculated axis.

Once you have that, quaternion*vector should give you the rotated vector.

Answer 2

I think you want something more like this:

// Use ClampMagnitude to allow analog movement up to but not exceeding a magnitude of 1.
// If using a force, do not multiply by delta time. 
// (And if using a speed/displacement, don't name your variable "force" - that misleads)
var movement = Vector2.ClampMagnitude(inputs, 1.0f) * movementForce;

// Track the slope we're standing on - assume flat, level ground by default.
Vector3 intoTerrain = Vector3.down;

// Splitting out our ray struct helps avoid a long wrapping line in the if condition.
var ray = new Ray(orientationTransform.position, Vector3.down);
if ( Physics.Raycast(ray, out var hitInfo, 1f, groundLayer)) {
    intoTerrain = -hitInfo.normal;
}
 
// Make an orientation where y+ points along the terrain in the "into the screen" direction
// and x+ points along the terrain in the "right / across the screen" direction.
var terrainOrientation = Quaternion.LookRotation(
                            intoTerrain, 
                            Camera.main.transform.forward
                         );

// Transform our movement using this coordinate frame.
return terrainOrientation * movement;