Lerp smoothly along the Y axis.

Minesteal

Hey, I'm new to Godot and programming in general, but I'm steadily learning. I've made a pretty simple third person character controller but I'm having an issue with getting lerp to fuction in my script. This would be to rotate along the Y axis and in the direction that the player would be moving. Thanks for the advice.

`func _ready():
Input.mouse_mode = Input.MOUSE_MODE_CAPTURED

func _input(event):
if event is InputEventMouseMotion:
rotate_y(deg_to_rad(-event.relative.x * sens_horizontal))
visuals.rotate_y(deg_to_rad(event.relative.x * sens_horizontal))
camera_mount.rotate_x(deg_to_rad(event.relative.y * sens_vertical))
camera_mount.rotation.x = clamp(camera_mount.rotation.x, deg_to_rad(-50), deg_to_rad(65))

func _physics_process(delta):
#Declare lock fuction. Means the player cant move but can look around.
if !animation_player.is_playing():
is_locked = false

#Handle Kick.
if Input.is_action_just_pressed("kick"):
	if animation_player.current_animation != "animation-library/Kick":
		animation_player.play("animation-library/Kick")
		is_locked = true

#Handle Run.
if Input.is_action_pressed("move_run"):
	speed = running_speed
	running = true
else:
	speed = walking_speed
	running = false

# Add the gravity.
if not is_on_floor():
	velocity.y -= gravity * delta
	

# Handle Jump.
if Input.is_action_just_pressed("ui_accept") and is_on_floor():
	velocity.y = jump_velocity

# Get the input direction and handle the movement/deceleration.
# As good practice, you should replace UI actions with custom gameplay actions.
var input_dir = Input.get_vector("move_right", "move_left", "move_backward", "move_forward")
var direction = (transform.basis * Vector3(input_dir.x, 0, input_dir.y)).normalized()
if direction:
	if !is_locked:
		if running:
			if animation_player.current_animation != "running-anim/Running":
				animation_player.play("running-anim/Running")
		else:
			if animation_player.current_animation != "Walk":
				animation_player.play("Walk")
				
		visuals.look_at(position - direction)
		
	velocity.x = direction.x * speed
	velocity.z = direction.z * speed
	
else:
	if !is_locked:
		if animation_player.current_animation != "Idle":
			animation_player.play("Idle")
	velocity.x = move_toward(velocity.x, 0, speed)
	velocity.z = move_toward(velocity.z, 0, speed)
if !is_locked:
	move_and_slide()`

KhimairaStudio

Minesteal All you need to do is create a new interpolated value to plug into the argument of your look_at method. First, declare a variable of type Vector3 called something like "smooth_dir" -- or whatever you like -- and give it the @onready tag

@onready var smooth_dir : Vector3 = position

You can hardcode in your lerp weight, or you could declare a variable of type float called rotation_stiffness and give it the @export_range tag:

@export_range(0,1) var rotation_stiffness : float = 0.2

Then, within _physics_process, have the smooth_dir Vector interpolate between itself and the desired look_at position.

smooth_dir = lerp(smooth_dir, position - direction, rotation_smoothing)

Then plug that into the look_at method:

visuals.look_at(smooth_dir)

Hope that makes sense!

award

Which particular part of the code is not working?

Minesteal

award The current code works fine. When I turn the character with WASD and I don't turn the camera it snaps to the direction. I need help with where to put Lerp or interpolation to make is smoother.

Minesteal

KhimairaStudio This is what I was looking for and it was easy to understand! I have one more question though. This works fantastic for for the character is moving forward and I press right but it still instantly swaps when going from left to right, if that makes sense. Is there a way to make it gradually move in a circle when moving left to right? I think I saw someone explain it like lerp_angle would do something like that.

xyz

Minesteal Lerping a single direction vector is not a very good way to do this. Also look_at() is not really useful as you deal with orientation, not points at which you need to look

The current orientation of your node in 3D space is stored in node's transform.basis. You need to maintain additional basis object that represent the orientation you want to gradually achieve.

So every time a movement command is issued, construct a basis that represents the wanted direction and then each frame spherically interpolate between current and wanted basis using Basis::slerp(). Alternatively you can use node's quaternion instead of basis. They do the same thing but if node is scaled then using quaternion is an easier option since basis encodes scaling as well while quaternion holds only node's orientation.

Here are examples of gradual orientation change using basis/quaternion I posted as an answer to another member.
https://godotforums.org/d/37326-i-need-help-rotating-a-node3d-with-tween-360-limit/5