Question 3rd person character rotate to camera and rotate to terrain slope

Hello!
I have been browsing the Unity answers for 3 days but have not gotten any results that are usable.
I have a 3rd person character controller that will rotate the character to look in the direction the camera is facing (this works).
I also have a "terrain stick" algorithm that rotates the character to match the angle that the terrain is at (this works).
However, when I combine the two, it most certainly doesn't work. I was wondering if anyone might be able to toss an assist on this (it is driving me batty!)
I am using a character controller with no rigidbody
The movement script is applied to the "Player" object
Hierarchy:
https://imgur.com/ZERfCcw

Any other help would be greatly appreciated! (entire post of pictures: https://imgur.com/a/4OiC9hr )

Code (CSharp):

1.  
2. [Header("Rotation Type B")]
3. public Transform backLeft;
4. public Transform backRight;
5. public Transform frontLeft;
6. public Transform frontRight;
7. public RaycastHit lr;
8. public RaycastHit rr;
9. public RaycastHit lf;
10. public RaycastHit rf;
11. public Vector3 upDir;
12.  
13.    
14. void Update()
15. {
16.         //Movement - This all works with no issue
17.         float h = Input.GetAxis("Horizontal");
18.         float v = Input.GetAxis("Vertical");
19.         float moveDelta = Mathf.Clamp01(Mathf.Abs(h) + Mathf.Abs(v));
20.  
21.         var moveInput = new Vector3(h, 0, v).normalized;
22.         var moveDir = cameraController.PlanarRotation * moveInput; //Gives camera forward
23.         GroundCheck();
24.  
25.         transform.position += moveDir * moveSpeed * Time.deltaTime;
26.  
27.         Vector3 velocity = moveDir * moveSpeed;
28.         if(isGrounded) // Applying gravity, works fine
29.         {
30.             ySpeed = -0.5f;
31.         }
32.         else
33.         {
34.             ySpeed += Physics.gravity.y * Time.deltaTime;
35.         }
36.  
37.         velocity.y = ySpeed;
38.         charController.Move(velocity * Time.deltaTime);
39.  
40.         //Rotation - This is where things are getting fun
41.  
42.         // Calculate rotation to get character to look in camera forward
43.         if (moveDelta > 0)
44.         {
45.             targetRotation = Quaternion.LookRotation(moveDir);
46.         }
47.  
48.         //Vector3 down = transform.TransformDirection(Vector3.down);
49.         Vector3 down = Vector3.down;
50.  
51.         //This gives the proper Y rotation to make the character look in the direction the camera is facing
52.         facingRotation = Quaternion.RotateTowards(transform.rotation, targetRotation, rotationSmoothing * Time.deltaTime);
53.         //This works in isolation
54.         //transform.rotation = facingRotation;
55.         // see: https://imgur.com/pkT4E2n , https://imgur.com/miMeqlo
56.  
57.         //More specific raycasting for better terrain sticking
58.         Vector3 down = transform.TransformDirection(Vector3.down); //Have used Vector3.down as well
59.         Physics.Raycast(backLeft.position, down, out lr, 10f, groundCheckLayerMask);
60.         Physics.Raycast(backRight.position, down, out rr, 10f, groundCheckLayerMask);
61.         Physics.Raycast(frontLeft.position, down, out lf, 10f, groundCheckLayerMask);
62.         Physics.Raycast(frontRight.position, down, out rf, 10f, groundCheckLayerMask);
63.         Debug.DrawRay(rr.point, Vector3.down, Color.green);
64.         Debug.DrawRay(lr.point, Vector3.down, Color.green);
65.         Debug.DrawRay(lf.point, Vector3.down, Color.green);
66.         Debug.DrawRay(rf.point, Vector3.down, Color.green);
67.  
68.         Vector3 a = rr.point - lr.point;
69.         Vector3 b = rf.point - rr.point;
70.         Vector3 c = lf.point - rf.point;
71.         Vector3 d = rr.point - lf.point;
72.  
73.         // Get the normal at each corner
74.         Vector3 crossBA = Vector3.Cross(b, a);
75.         Vector3 crossCB = Vector3.Cross(c, b);
76.         Vector3 crossDC = Vector3.Cross(d, c);
77.         Vector3 crossAD = Vector3.Cross(a, d);
78.  
79.         // Calculate composite normal
80.         upDir = (crossBA + crossCB + crossDC + crossAD).normalized;
81.  
82.         Vector3 upVector = Vector3.Lerp(transform.up, upDir, Time.deltaTime);
83.  
84.         if (isGrounded)
85.             uprightRotation = Quaternion.FromToRotation(Vector3.up, upVector);
86.         else
87.             uprightRotation = Quaternion.identity;
88.  
89.         //This works in isolation
90.         //transform.rotation = uprightRotation;
91.         // see: https://imgur.com/ZzqlvhC , https://imgur.com/UtVUWSX
92.  
93.  
94.         // This doesn't work, it spams between two rotations
95.         finalRotation = uprightRotation * facingRotation;
96.         //transform.rotation = finalRotation;
97.         // see: https://imgur.com/eae7Uet , https://imgur.com/OScvAix and https://imgur.com/gLa93KM , https://imgur.com/fhllUQe
98.  
99.         // This doesnt work, is just bad, have learned lesson
100.         //Figure out a way to combine upright and facing
101.         //finalRotation = facingRotation;
102.         //finalRotation.x = uprightRotation.x;
103.         //finalRotation.z = uprightRotation.z;
104.         //transform.rotation = finalRotation;
105.  
106.         //THIS DIDNT WORK BUT IT IS A NEW STEP
107.         Vector3 newPos;
108.         Vector3 normal = upVector;
109.      
110.         curNormal = Vector3.Lerp(curNormal, normal, 2 * Time.deltaTime);
111.         newPos = moveDir;
112.         newPos.y = 0;
113.      
114.         // Doesn't work, character follows camera facing while moving, snaps to the left when at rest.
115.         // Does not follow terrain
116.         finalRotation = Quaternion.FromToRotation(Vector3.up, curNormal);
117.         finalRotation = finalRotation * Quaternion.FromToRotation(Vector3.forward, newPos);
118.         // transform.rotation = finalRotation;
119.         // see: https://imgur.com/AudyNW3 , https://imgur.com/AKegU8m
120.  
121.  
122.         // Doesn't work - Character snaps to terrain, but doesn't rotate towards camera forward
123.         finalRotation = uprightRotation * Quaternion.Euler(0, facingRotation.y, 0);
124.         //transform.rotation = finalRotation;
125.         // see: https://imgur.com/DDqfHx6 , https://imgur.com/TILrSNV
126.  
127.         // Doesn't work -- character jitters, is never looking at facing, sometimes upside down
128.         transform.rotation = facingRotation;
129.         transform.rotation = uprightRotation * transform.rotation;
130.         // see: https://imgur.com/OCGDcn2 , https://imgur.com/Igcy5rp
131.  
132.         animator.SetFloat(Words.moveAmount.ToString(), moveDelta, 0.2f, Time.deltaTime);
133. }
134.  

 

Generally combining rotations is best done with separate transforms.

If you want the camera to tilt when you're standing on the side of a mountain, tilt it.

But don't do that on the same transform you're using to look around.

For instance, something like this:

PlayerTransform

   PartThatTiltsWithMountainSlopes

       PartThatRotatesAround

            Camera

Depending on what you want you may wish to reverse the stacking of the two center transforms above, but I suspect the above is what you want.

You can test it trivially in about 30 seconds by just making the above four (4) GameObjects and moving them by hand without even running code until you know it's what you need.

 

I appreciate the reply!
I'm trying to get the player to rotate (the camera itself is outside the system) ... I adjusted to similar, but the results still only let me do one or the other (more particularly, the most nested one) .... It feels like in theory it should work, and it works with dummy empty objects being manually manipulated, but for some reason in reality it breaks apart

Camera

PlayerController

    PartThatTiltsWithSlope (EmptyGO)

        PartThatRotates (EmptyGO)

            FrontLeft/BackLeft/FrontRight/BackRight Empty GO's

            PlayerMesh

CodeThatTiltsWithSlope:

Code (CSharp):

1. using System.Collections;
2. using System.Collections.Generic;
3. using UnityEngine;
4.  
5. public class TerrainAlignment : MonoBehaviour
6. {
7.     [Header("Rotation Type B")]
8.     public Transform backLeft;
9.     public Transform backRight;
10.     public Transform frontLeft;
11.     public Transform frontRight;
12.     public RaycastHit lr;
13.     public RaycastHit rr;
14.     public RaycastHit lf;
15.     public RaycastHit rf;
16.     public Vector3 upDir;
17.     public Quaternion uprightRotation;
18.     [SerializeField] LayerMask groundCheckLayerMask;
19.  
20.  
21.     [SerializeField] PlayerController playerController;
22.  
23.     void Update()
24.     {
25.         Vector3 down = transform.TransformDirection(Vector3.down);
26.  
27.         //More specific raycasting for better terrain sticking
28.         Physics.Raycast(backLeft.position, down, out lr, 10f, groundCheckLayerMask);
29.         Physics.Raycast(backRight.position, down, out rr, 10f, groundCheckLayerMask);
30.         Physics.Raycast(frontLeft.position, down, out lf, 10f, groundCheckLayerMask);
31.         Physics.Raycast(frontRight.position, down, out rf, 10f, groundCheckLayerMask);
32.         Debug.DrawRay(rr.point, Vector3.down, Color.red);
33.         Debug.DrawRay(lr.point, Vector3.down, Color.red);
34.         Debug.DrawRay(lf.point, Vector3.down, Color.red);
35.         Debug.DrawRay(rf.point, Vector3.down, Color.red);
36.  
37.         Vector3 a = rr.point - lr.point;
38.         Vector3 b = rf.point - rr.point;
39.         Vector3 c = lf.point - rf.point;
40.         Vector3 d = rr.point - lf.point;
41.  
42.         // Get the normal at each corner
43.  
44.         Vector3 crossBA = Vector3.Cross(b, a);
45.         Vector3 crossCB = Vector3.Cross(c, b);
46.         Vector3 crossDC = Vector3.Cross(d, c);
47.         Vector3 crossAD = Vector3.Cross(a, d);
48.  
49.         // Calculate composite normal
50.         upDir = (crossBA + crossCB + crossDC + crossAD).normalized;
51.  
52.         Vector3 upVector = Vector3.Lerp(transform.up, upDir, Time.deltaTime);
53.  
54.         if (playerController.IsGrounded)
55.             uprightRotation = Quaternion.FromToRotation(Vector3.up, upVector);
56.         else
57.             uprightRotation = Quaternion.identity;
58.  
59.         transform.rotation = uprightRotation;
60.     }
61. }
62.  

CodeThatRotates

Code (CSharp):

1. using System.Collections;
2. using System.Collections.Generic;
3. using UnityEngine;
4.  
5. public class RotateToCameraFacing : MonoBehaviour
6. {
7.     [SerializeField] float rotationSmoothing = 500f;
8.  
9.     Quaternion targetRotation;
10.     CameraController cameraController;
11.  
12.     private void Awake()
13.     {
14.         cameraController = Camera.main.GetComponent<CameraController>();
15.     }
16.  
17.     // Update is called once per frame
18.     void Update()
19.     {
20.         //TODO: Get these directly from the Player Controller
21.         float h = Input.GetAxis("Horizontal");
22.         float v = Input.GetAxis("Vertical");
23.         var moveDelta = Mathf.Clamp01(Mathf.Abs(h) + Mathf.Abs(v));
24.  
25.         var moveInput = new Vector3(h, 0, v).normalized;
26.         var moveDir = cameraController.PlanarRotation * moveInput;
27.         if (moveDelta > 0)
28.         {
29.             targetRotation = Quaternion.LookRotation(moveDir);
30.         }
31.  
32.         transform.rotation = Quaternion.RotateTowards(transform.rotation, targetRotation, rotationSmoothing * Time.deltaTime);
33.  
34.     }
35. }
36.  

PlayerController Code:

Code (CSharp):

1.  
2. using System.Collections;
3. using System.Collections.Generic;
4. using System.Runtime.CompilerServices;
5. using UnityEngine;
6.  
7. public class PlayerController : MonoBehaviour
8. {
9.     [Header("Movement Speed Settings")]
10.     [SerializeField] float moveSpeed = 5f;
11.     [SerializeField] float rotationSmoothing = 500f;
12.  
13.     [Header("Ground Check Settings")]
14.     [SerializeField] LayerMask groundCheckLayerMask;
15.     [Space]
16.     [SerializeField] float groundCheckRadius = 0.2f;
17.     [SerializeField] Vector3 groundCheckOffset;
18.     [Space]
19.     [SerializeField] bool isGrounded;
20.     [SerializeField] float ySpeed;
21.  
22.     //Camera Settings
23.     CameraController cameraController;
24.  
25.     //Animation Settings
26.     Quaternion targetRotation;
27.     Animator animator;
28.  
29.     CharacterController charController;
30.  
31.  
32.  
33.     // Awake is called when the object is loaded
34.     private void Awake()
35.     {
36.         cameraController = Camera.main.GetComponent<CameraController>();
37.         animator = GetComponent<Animator>();
38.         charController = GetComponent<CharacterController>();
39.     }
40.  
41.     enum Words
42.     {
43.         moveAmount
44.     }
45.     // Start is called before the first frame update
46.     void Start()
47.     {
48.      
49.     }
50.  
51.     // Update is called once per frame
52.     void Update()
53.     {
54.         //Movement
55.         float h = Input.GetAxis("Horizontal");
56.         float v = Input.GetAxis("Vertical");
57.         var moveDelta = Mathf.Clamp01(Mathf.Abs(h) + Mathf.Abs(v));
58.  
59.         var moveInput = new Vector3(h, 0, v).normalized;
60.         var moveDir = cameraController.PlanarRotation * moveInput;
61.         GroundCheck();
62.  
63.         transform.position += moveDir * moveSpeed * Time.deltaTime;
64.  
65.         Vector3 velocity = moveDir * moveSpeed;
66.         if(isGrounded)
67.         {
68.             ySpeed = -0.5f;
69.         }
70.         else
71.         {
72.             ySpeed += Physics.gravity.y * Time.deltaTime;
73.         }
74.  
75.         velocity.y = ySpeed;
76.         charController.Move(velocity * Time.deltaTime);
77.  
78.         animator.SetFloat(Words.moveAmount.ToString(), moveDelta, 0.2f, Time.deltaTime);
79.     }
80.     void GroundCheck()
81.     {
82.         isGrounded = Physics.CheckSphere(transform.TransformPoint(groundCheckOffset), groundCheckRadius, groundCheckLayerMask);
83.  
84.     }
85.  
86.     public bool IsGrounded => isGrounded;
87.  
88.  
89.     private void OnDrawGizmosSelected()
90.     {
91.         Gizmos.color = new Color(0, 1, 0, 0.5f);
92.  
93.         if (Physics.CheckSphere(transform.TransformPoint(groundCheckOffset), groundCheckRadius, groundCheckLayerMask))
94.             Gizmos.color = new Color(0, 1, 0, 0.5f);
95.         else
96.             Gizmos.color = new Color(1, 0, 0, 0.5f);
97.  
98.         Gizmos.DrawSphere(transform.TransformPoint(groundCheckOffset), groundCheckRadius);
99.  
100.     }
101. }
102.  
103.  

 

https://gamedev.stackexchange.com/questions/151659/rotating-according-to-ground-normal-on-unity-3d
For future reference if any1 is googling this, by referencing the above article, I came up with something.

A couple things to note:

• You don't HAVE to do the 4 raycasts down like I am doing in the code below. There are various different methods out there to get the terrain normal (some use a single raycast, some use a spherecast, some use more than 4 points, etc.) The most important thing is being able to get the terrain normal from *somewhere*.
• This is *not* using the rigidbody system, this is using a character controller
• This script is attached similar to how @Kurt-Dekker was describing above - I liked separating the rotation from the rest of the calculations

Code (CSharp):

1. Player (With Character Controller)
2.     Rotation Controller (Empty GO with the RotationController script)
3.     Mesh
4.     Objects for raycasting to get terrain normal

Code (CSharp):

1. using UnityEngine;
2.  
3. [RequireComponent(typeof(CharacterController))]
4. [RequireComponent(typeof(CameraController))]
5. public class PlayerController : MonoBehaviour
6. {
7.     [Header("Movement Speed Settings")]
8.     [SerializeField] float moveSpeed = 5f;
9.     private bool isMoving;
10.     private Vector3 moveDir;
11.     public bool IsMoving => isMoving;
12.     public Vector3 MoveDir => moveDir;
13.  
14.  
15.  
16.     [Header("Ground Check Settings")]
17.     [SerializeField] LayerMask groundCheckLayerMask;
18.     [SerializeField] float groundCheckRadius = 0.2f;
19.     [SerializeField] Vector3 groundCheckOffset;
20.  
21.     private bool isGrounded;
22.     public bool IsGrounded => isGrounded;
23.     private float ySpeed;
24.  
25.     //Loaded Components
26.     private Animator animator;
27.     private CharacterController charController;
28.     private CameraController cameraController;
29.  
30.  
31.     // Awake is called when the object is loaded
32.     private void Awake()
33.     {
34.         cameraController = Camera.main.GetComponent<CameraController>();
35.         animator = GetComponent<Animator>();
36.         charController = GetComponent<CharacterController>();
37.     }
38.  
39.     private enum Words
40.     {
41.         moveAmount
42.     }
43.  
44.     // Update is called once per frame
45.     void Update()
46.     {
47.         float h = Input.GetAxis("Horizontal");
48.         float v = Input.GetAxis("Vertical");
49.         float moveDelta = Mathf.Clamp01(Mathf.Abs(h) + Mathf.Abs(v));
50.         isMoving = moveDelta > 0;
51.        
52.         //Movement
53.         var moveInput = new Vector3(h, 0, v).normalized;
54.         moveDir = cameraController.PlanarRotation * moveInput;
55.         GroundCheck();
56.  
57.         transform.position += moveDir * moveSpeed * Time.deltaTime;
58.  
59.         //Gravity
60.         Vector3 velocity = moveDir * moveSpeed;
61.         if(isGrounded)
62.             ySpeed = -0.5f;
63.         else
64.             ySpeed += Physics.gravity.y * Time.deltaTime;
65.  
66.         velocity.y = ySpeed;
67.  
68.         // Final
69.         charController.Move(velocity * Time.deltaTime);
70.         animator.SetFloat(Words.moveAmount.ToString(), moveDelta, 0.2f, Time.deltaTime);
71.     }
72.  
73.     void GroundCheck()
74.     {
75.         isGrounded = Physics.CheckSphere(transform.TransformPoint(groundCheckOffset), groundCheckRadius, groundCheckLayerMask);
76.  
77.     }
78.    
79.     private void OnDrawGizmosSelected()
80.     {
81.         Gizmos.color = new Color(0, 1, 0, 0.5f);
82.  
83.         if (Physics.CheckSphere(transform.TransformPoint(groundCheckOffset), groundCheckRadius, groundCheckLayerMask))
84.             Gizmos.color = new Color(0, 1, 0, 0.5f);
85.         else
86.             Gizmos.color = new Color(1, 0, 0, 0.5f);
87.  
88.         Gizmos.DrawSphere(transform.TransformPoint(groundCheckOffset), groundCheckRadius);
89.  
90.     }
91. }
92.  

Code (CSharp):

1. using System.Collections;
2. using System.Collections.Generic;
3. using UnityEngine;
4.  
5. public class RotationController : MonoBehaviour
6. {
7.     public Transform backLeft;
8.     public Transform backRight;
9.     public Transform frontLeft;
10.     public Transform frontRight;
11.    
12.     RaycastHit lr;
13.     RaycastHit rr;
14.     RaycastHit lf;
15.     RaycastHit rf;
16.     Vector3 upDir;
17.  
18.     [SerializeField] float rotationSmoothing = 500f;
19.     [SerializeField] PlayerController playerController;
20.     [SerializeField] LayerMask groundCheckLayerMask;
21.  
22.     // Update is called once per frame
23.     void Update()
24.     {
25.         // If the character is moving
26.         if (playerController.IsMoving)
27.         {
28.             //Get slope rotation from world up
29.             Quaternion slopeRotation = Quaternion.FromToRotation(Vector3.up, terrainNormal());
30.            
31.             // Calc the rotation if we wanted to look towards the camera
32.             Quaternion targetRotation = Quaternion.LookRotation(playerController.MoveDir);
33.            
34.             // Rotate the object, combining the slope rotation with the look rotation, using a smoothing to make it nicer
35.             transform.rotation = Quaternion.Slerp(transform.rotation, slopeRotation * targetRotation,
36.                 rotationSmoothing * Time.deltaTime);
37.         }
38.         // Character is not moving
39.         else
40.         {
41.             // Get the slope rotation with the transform.up instead of world up
42.             Quaternion slopeRotation = Quaternion.FromToRotation(transform.up, terrainNormal());
43.            
44.             //Rotate the object, combining the slope rotation with our current rotation
45.             transform.rotation = Quaternion.Slerp(transform.rotation, slopeRotation * transform.rotation,
46.                 rotationSmoothing * Time.deltaTime);
47.         }
48.     }
49.     Vector3 terrainNormal()
50.     {
51.         Vector3 down = -transform.up;
52.  
53.         //More specific raycasting for better terrain sticking
54.         Physics.Raycast(backLeft.position, down, out lr, 10f, groundCheckLayerMask);
55.         Physics.Raycast(backRight.position, down, out rr, 10f, groundCheckLayerMask);
56.         Physics.Raycast(frontLeft.position, down, out lf, 10f, groundCheckLayerMask);
57.         Physics.Raycast(frontRight.position, down, out rf, 10f, groundCheckLayerMask);
58.         //Debug.DrawRay(rr.point, Vector3.up, Color.red);
59.         //Debug.DrawRay(lr.point, Vector3.up, Color.red);
60.         //Debug.DrawRay(lf.point, Vector3.up, Color.red);
61.         //Debug.DrawRay(rf.point, Vector3.up, Color.red);
62.  
63.         Vector3 a = rr.point - lr.point;
64.         Vector3 b = rf.point - rr.point;
65.         Vector3 c = lf.point - rf.point;
66.         Vector3 d = rr.point - lf.point;
67.  
68.         // Get the normal at each corner
69.         Vector3 crossBA = Vector3.Cross(b, a);
70.         Vector3 crossCB = Vector3.Cross(c, b);
71.         Vector3 crossDC = Vector3.Cross(d, c);
72.         Vector3 crossAD = Vector3.Cross(a, d);
73.  
74.         // Calculate composite normal
75.         upDir = (crossBA + crossCB + crossDC + crossAD).normalized;
76.  
77.         Vector3 upVector = Vector3.Lerp(transform.up, upDir, Time.deltaTime);
78.  
79.         return upVector;
80.     }
81.    
82. }
83.