Orient vehicle to ground normal (terrain hugging)

Question

So the problem I'm having is trying to orient a vehicle to the ground based on a raycast. The raycast works, the movement works, and aligning the normal of the ground to the transform.up works. However, together these don't work. It won't rotate.

alt text

I think the problem is that aligning the transform.up = hit.normal overrides any rotation. My question would be, how exactly do I form an algorithm that will translate rotation into the normal. I figure if I can rotate the normal before I set it to the up vector that rotation should be possible. And I don't want it to rotate and snap back, which I found out how to do.

Here is my code (C#):

 if (Physics.Raycast(transform.position, -transform.up, out hit))
     {
         Quaternion grndTilt = Quaternion.FromToRotation(transform.up, hit.normal);
         transform.rotation = Quaternion.Euler(0, Input.GetAxis("Horizontal") * turnSpeed * 100 * Time.deltaTime, 0) * grndTilt;
         //transform.up = hit.normal;    
     }
     Vector3 movDir;
     //transform.Rotate(0, Input.GetAxis("Horizontal") * turnSpeed * Time.deltaTime,0);
     movDir = transform.forward*Input.GetAxis("Vertical")*speed;
     // moves the character in horizontal direction
     controller.Move(movDir*Time.deltaTime-Vector3.up*0.1f);

I've been all over the internet, and nothing seems to be working!

EDIT:

Removed the code because it was incorrect. The solution:

Two parts - a composite vector from each of the corners to give you the direction to orient (my original issue) - and separating the mesh to a sub gameobject. Keep your controller as the root (or even another sub object). Very clean movement. Forgive me for no code example. :)

Answer 1

For the rotation, it snaps back because your code says the rotation is the current value of the arrow keys. Of course when you let go it snaps to 0. Use the arrows to add to rotation (the answer above.)

For raycast wiggling, use -Vector3.up as the aim dir instead of -transform.up. The latter is down from our tilt. So, tilting changes the raycast dir, which hits the ground somewhere else, which gets a diff normal, which makes you tilt a different dir... . You'll wiggle any time you stand still on a curved surface. The effect is worse as your (0,0,0) gets further off the ground. -Vector3.up is always straight down, which won't change as we tilt.

Setting transform.up wants to override any previous tilt you have. It's actually doing a bit of math to figure out how to get up to point that way. Using *grndTilt (if it stands for the tilt from "no change" to "ground normal" changes your up while keeping everything the same.

To apply the grndTilt, the order multiplying quaternions matters, and it's usually backwards to how you think. Try flipping *grndtilt to in front instead of in back (that's in the answer above, but is easy to miss, since we are so used to thinking a*b and b*a are the same.) Or, you can think of doing the tilt as: transform.rotation = tilt*transform.rotation;

Answer 2

I had the same problem: assigning transform.up seems to be equivalent to transform.rotation = Quaternion.FromToRotation(Vector3.up, newNormal). The solution for me was to keep a "compass" variable which showed the current rotation angle from forward: thus I "rotated" this angle and applied to the object using Euler:

float curDir = 0f; // compass indicating direction
float vertSpeed = 0f; // vertical speed (see note)
...
void Update(){
    float turn = Input.GetAxis("Horizontal") * turnSpeed * 100 * Time.deltaTime,
    curDir = (curDir + turn) % 360; // rotate angle modulo 360 according to input
    if (Physics.Raycast(transform.position, -transform.up, out hit))
    {
        Quaternion grndTilt = Quaternion.FromToRotation(transform.up, hit.normal);
        transform.rotation = grndTilt * Quaternion.Euler(0, curDir, 0);
    }
    Vector3 movDir;
    movDir = transform.forward*Input.GetAxis("Vertical")*speed;
    // moves the character in horizontal direction (gravity changed!)
    if (controller.isGrounded) vertSpeed = 0; // zero v speed when grounded
    vertSpeed -= 9.8f * Time.deltaTime; // apply gravity
    movDir.y = vertSpeed; // keep the current vert speed
    controller.Move(movDir*Time.deltaTime);
    ...

An alternative way to do that is using the OnControllerColliderHit event to get the normal - but only if its Y coordinate is > 0.3 (or some other suitable value) or else the car can stick to walls or to other vehicles during lateral collisions!
NOTE: I changed the way gravity is applied - it gives a better behaviour when "flying" after a hill. Discard these changes if you don't want them - the rotation thing is at the beginning, and has nothing to do with gravity.

EDITED: There was an error in the script above: the rotation was being calculated from transform.up to the normal (it should be Vector3.up to normal) what was causing the crazy instability.
In my tests, I also noticed that the vehicle was following the terrain normal immediately, what was producing a strange behaviour. I added a new variable - curNormal - which smoothly followed the terrain normal using Lerp, and also was used in the Raycast to avoid other instabilities. The result is very convincent - hope you like it too:

 float curDir = 0f; // compass indicating direction
 float vertSpeed = 0f; // vertical speed (see note)
 Vector3 curNormal = Vector3.up; // smoothed terrain normal
 
 void Update(){
     float turn = Input.GetAxis("Horizontal") * turnSpeed * 100 * Time.deltaTime;
     curDir = (curDir + turn) % 360; // rotate angle modulo 360 according to input
     RaycastHit hit;
     if (Physics.Raycast(transform.position, -curNormal, out hit)){
         curNormal = Vector3.Lerp(curNormal, hit.normal, 4*Time.deltaTime);
         Quaternion grndTilt = Quaternion.FromToRotation(Vector3.up, curNormal);
         transform.rotation = grndTilt * Quaternion.Euler(0, curDir, 0);
     }
     Vector3 movDir;
     movDir = transform.forward*Input.GetAxis("Vertical")*speed;
     // moves the character in horizontal direction (gravity changed!)
     if (controller.isGrounded) vertSpeed = 0; // zero v speed when grounded
     vertSpeed -= 9.8f * Time.deltaTime; // apply gravity
     movDir.y = vertSpeed; // keep the current vert speed
     controller.Move(movDir*Time.deltaTime);
 }

JAVASCRIPT VERSION:

 private var curDir: float = 0f; // compass indicating direction
 private var vertSpeed: float = 0f; // vertical speed (see note)
 private var curNormal = Vector3.up; // smoothed terrain normal
 
 function Update(){
     var turn = Input.GetAxis("Horizontal") * turnSpeed * 100 * Time.deltaTime;
     curDir = (curDir + turn) % 360; // rotate angle modulo 360 according to input
     var hit: RaycastHit;
     if (Physics.Raycast(transform.position, -curNormal, hit)){
         curNormal = Vector3.Lerp(curNormal, hit.normal, 4*Time.deltaTime);
         var grndTilt = Quaternion.FromToRotation(Vector3.up, curNormal);
         transform.rotation = grndTilt * Quaternion.Euler(0, curDir, 0);
     }
     var movDir = transform.forward*Input.GetAxis("Vertical")*speed;
     // moves the character in horizontal direction (gravity changed!)
     if (controller.isGrounded) vertSpeed = 0; // zero v speed when grounded
     vertSpeed -= 9.8f * Time.deltaTime; // apply gravity
     movDir.y = vertSpeed; // keep the current vert speed
     controller.Move(movDir*Time.deltaTime);
 }

Orient vehicle to ground normal (terrain hugging)

7 Replies

Your answer

Welcome to Unity Answers

Follow this Question

Related Questions