Solium - personal research and development

kuligs2

fire7side that is not the root problem im having. I do know how to blend animations, but the problem is that for some reason, going from one anim to another resets root motion velocity to zero while other case does not.

fire7side

It sounds like it has something to do with the root bone and I haven't used it. If I get an animation looking half decent, I'm happy.

kuligs2

fire7side At first glance from memory, the root bone positions were synced and movement over the frames was linear. I havent had much time to investigate more. Same principle was for running animation, and switching between walk and run works as expected - no velocity reset to 0.0.

kuligs2

Doing some investigation:

Noticing that walk animation and run animation, root bone Y position is linear like straight line at an angle.

But the walk_start has like this:

That horizontal line before 1st frame and after frame 5 could be the culprit.

Now im remembering that the walk and run has curve modifier "cycles"

Fixed:

Lets test this out in game:
Nope, it still upon switch from walk_start animation to walk animation, drops velocity to zero.

I still cant figure out what is resetting my velocity. code for all state switches is the same.

walk_start.gd

extends StateInterface

class_name WalkStartState

var character: Player
var is_blocking:bool = false

func enter(_prev_state: String = "")-> void:
	character = state_machine.owner
	character.animation_player.animation_finished.connect(on_animation_finished)
	character.animation_player.play("Walk_start")
	character.is_root_motion = true
	is_blocking = true
	
func exit() -> void:
	if character.animation_player.animation_finished.is_connected(on_animation_finished):
		character.animation_player.animation_finished.disconnect(on_animation_finished)
		
func physics_update(_delta: float) -> void:
	if character.direction:
		var up := Vector3.UP
		# For root motion
		var forward : Vector3 = character.direction # Check this value if its in correct way
		var right := up.cross(forward).normalized()
		var corrected_up := forward.cross(right).normalized()
		var target_basis := Basis(right, corrected_up, forward).orthonormalized() 
		var a = character.transform.basis.get_rotation_quaternion()
		var b = target_basis.get_rotation_quaternion()
		var c = a.slerp(b,0.3)
		character.transform.basis = Basis(c).orthonormalized()

		character.velocity = character.get_quaternion() * character.animation_player.get_root_motion_position() / _delta
		character.set_quaternion(character.get_quaternion() * character.animation_player.get_root_motion_rotation())
	#else:
		#state_machine.change_state("idle")

	if not character.is_on_floor():
		state_machine.change_state("Jump_midair_90")
		return
		

	if not is_blocking:
		_decide_next_state()
	
	character.move_and_slide()
	
	
func on_animation_finished(_animation_name):
	character.animation_player.animation_finished.disconnect(on_animation_finished)
	is_blocking = false
	
func _decide_next_state():
	if Input.get_vector("k_left", "k_right", "k_forward", "k_backward"):
		if Input.is_action_pressed("k_sprint"):
			state_machine.change_state("Run_16")
			return
		if Input.is_action_pressed("k_crouch"):
			state_machine.change_state("Crouch_walk_32")
			return
		state_machine.change_state("walk")
		return
		
	if Input.is_action_just_pressed("k_jump") and character.is_on_floor():
		state_machine.change_state("Jump_ascend_9")
		return
		
	if Input.is_action_pressed("k_crouch"):
		state_machine.change_state("Crouch_90")
		return
			
	state_machine.change_state("walk_stop")
	return

walk.gd

extends StateInterface

class_name WalkState

var character: Player

func enter(_prev_state: String = "")-> void:
	character = state_machine.owner
	character.animation_player.play("Walk_32")
	character.is_root_motion = true

func physics_update(_delta: float) -> void:
	if character.direction:
		var up := Vector3.UP
		# For root motion
		var forward : Vector3 = character.direction # Check this value if its in correct way
		var right := up.cross(forward).normalized()
		var corrected_up := forward.cross(right).normalized()
		var target_basis := Basis(right, corrected_up, forward).orthonormalized() 
		var a = character.transform.basis.get_rotation_quaternion()
		var b = target_basis.get_rotation_quaternion()
		var c = a.slerp(b,0.3)
		character.transform.basis = Basis(c).orthonormalized()

		character.velocity = character.get_quaternion() * character.animation_player.get_root_motion_position() / _delta
		character.set_quaternion(character.get_quaternion() * character.animation_player.get_root_motion_rotation())
	else:
		state_machine.change_state("walk_stop")

	if not character.is_on_floor():
		state_machine.change_state("Jump_midair_90")
		return
		
	character.move_and_slide()

func handle_input(_event: InputEvent) -> void:
	if Input.is_action_just_pressed("k_jump") and character.is_on_floor():
		state_machine.change_state("Jump_ascend_9")
		return
		
	if Input.is_action_pressed("k_sprint"):
		state_machine.change_state("Run_16")
		return
		
	if Input.is_action_pressed("k_crouch"):
		state_machine.change_state("Crouch_walk_32")
		return

run.gd

extends StateInterface

class_name RunState

var character: Player

func enter(_prev_state: String = "")-> void:
	character = state_machine.owner
	character.animation_player.play("Run_16")
	character.is_root_motion = true

func physics_update(_delta: float) -> void:
	if character.direction:
		var up := Vector3.UP
		# For root motion
		var forward : Vector3 = character.direction # Check this value if its in correct way
		var right := up.cross(forward).normalized()
		var corrected_up := forward.cross(right).normalized()
		var target_basis := Basis(right, corrected_up, forward).orthonormalized() 
		var a = character.transform.basis.get_rotation_quaternion()
		var b = target_basis.get_rotation_quaternion()
		var c = a.slerp(b,0.3)
		character.transform.basis = Basis(c).orthonormalized()

		character.velocity = character.get_quaternion() * character.animation_player.get_root_motion_position() / _delta
		character.set_quaternion(character.get_quaternion() * character.animation_player.get_root_motion_rotation())
	else:
		state_machine.change_state("idle")

	if not character.is_on_floor():
		state_machine.change_state("Jump_midair_90")
		return
		
	character.move_and_slide()

func handle_input(_event: InputEvent) -> void:
	if Input.is_action_just_pressed("k_jump") and character.is_on_floor():
		state_machine.change_state("Jump_ascend_9")
		return
		
	if Input.is_action_just_released("k_sprint"):
		print("Sprint released")
		state_machine.change_state("walk")
		return
		
	if Input.is_action_pressed("k_crouch"):
		state_machine.change_state("Crouch_walk_32")
		return

Velocity continues if walk -> run
Velocity sets to zero if walk_start -> walk

fire7side

It looks like you can adjust the speed in the animation editor:
If you want the entire animation—including the root bone's translation—to play faster, adjust the playback speed directly.Via AnimationPlayer: Select your AnimationPlayer node, look at the top toolbar of the animation editor, and increase the Speed Scale (e.g., change 1.0 to 1.5).
Maybe that's what you are doing or you are doing something more sophisticated. I don't even get what that graph you are showing does.

kuligs2

fire7side please re-read few posts before this one, and watch the video and see what im dealing with. it has nothing to do with what youre saying.

fire7side

oh, nevermind.

kuligs2

I have ran out of ideas to try to test..

Maybe someone dealing with 3D animations can help me understand how to set up animations in blender? I dont use mixamo, it might be the problem but i dont want to be limited by bogus licences..

I have triple checked animations and they are linear. But in godot it resets to zero.. my hunch is that maybe.. maybe 4 frame animation is too short for godot to understand and calculate the root position so it defaults to zero.. so my question is what is the the shortest in terms of frames, animation you can use in godot?

kuligs2

So here is a picture of what is going on. Debug messages are printed in physics process.
It prints currents animation/state character velocity and root motion position.
As you can see that when i go from idle > walk_start > walk the velocity drops to 0.0 which creates this jitter that im trying to fix. And it just looks awful.
But when animation goes from walk > run the velocity ramps up and no slowdown.

All animations have blending of 0.2
Same thing happens of blend is set to 0.0.

State: jump_landed_9 Velocity: 0.000 RM: (0.0, 0.0, 0.0)
State: jump_landed_9 Velocity: 0.000 RM: (0.0, 0.0, 0.0)
State: jump_landed_9 Velocity: 0.000 RM: (0.0, 0.0, 0.0)
Changing state to: idle
State: idle Velocity: 0.000 RM: (0.0, 0.0, 0.0)
State: idle Velocity: 0.000 RM: (0.0, 0.0, 0.0)
State: idle Velocity: 0.000 RM: (0.0, 0.0, 0.0)
State: idle Velocity: 0.000 RM: (0.0, 0.0, 0.0)
State: idle Velocity: 0.000 RM: (0.0, 0.0, 0.0)
State: idle Velocity: 0.000 RM: (0.0, 0.0, 0.0)
State: idle Velocity: 0.000 RM: (0.0, 0.0, 0.0)
State: idle Velocity: 0.000 RM: (0.0, 0.0, 0.0)
State: idle Velocity: 0.000 RM: (0.0, 0.0, 0.0)
State: idle Velocity: 0.000 RM: (0.0, 0.0, 0.0)
State: idle Velocity: 0.000 RM: (0.0, 0.0, 0.0)
State: idle Velocity: 0.000 RM: (0.0, 0.0, 0.0)
State: idle Velocity: 0.000 RM: (0.0, 0.0, 0.0)
State: idle Velocity: 0.000 RM: (0.0, 0.0, 0.0)
State: idle Velocity: 0.000 RM: (0.0, 0.0, 0.0)
State: idle Velocity: 0.000 RM: (0.0, 0.0, 0.0)
Changing state to: walk_start
State: walk_start Velocity: 0.000 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 0.000 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 0.242 RM: (0.0, 0.0, 0.004698)
State: walk_start Velocity: 0.524 RM: (0.0, 0.0, 0.009396)
State: walk_start Velocity: 0.676 RM: (0.0, 0.0, 0.011664)
State: walk_start Velocity: 0.726 RM: (0.0, 0.0, 0.012312)
State: walk_start Velocity: 0.771 RM: (0.0, 0.0, 0.01296)
State: walk_start Velocity: 0.813 RM: (0.0, 0.0, 0.013609)
State: walk_start Velocity: 0.854 RM: (0.0, 0.0, 0.014257)
State: walk_start Velocity: 0.893 RM: (0.0, 0.0, 0.014905)
State: walk_start Velocity: 0.933 RM: (0.0, 0.0, 0.015553)
Changing state to: walk
State: walk Velocity: 0.000 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 0.000 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 0.000 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 0.236 RM: (0.0, 0.0, 0.003931)
State: walk Velocity: 0.472 RM: (0.0, 0.0, 0.007862)
State: walk Velocity: 0.708 RM: (0.0, 0.0, 0.011793)
State: walk Velocity: 0.943 RM: (0.0, 0.0, 0.015723)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
Changing state to: run_16
State: run_16 Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: run_16 Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: run_16 Velocity: 1.745 RM: (0.0, 0.0, 0.029086)
State: run_16 Velocity: 2.311 RM: (0.0, 0.0, 0.038519)
State: run_16 Velocity: 2.877 RM: (0.0, 0.0, 0.047951)
State: run_16 Velocity: 3.443 RM: (0.0, 0.0, 0.057383)
State: run_16 Velocity: 4.009 RM: (0.0, 0.0, 0.066814)
State: run_16 Velocity: 4.009 RM: (0.0, 0.0, 0.066815)
State: run_16 Velocity: 4.009 RM: (0.0, 0.0, 0.066815)
State: run_16 Velocity: 4.009 RM: (0.0, 0.0, 0.066815)
State: run_16 Velocity: 4.009 RM: (0.0, 0.0, 0.066815)
State: run_16 Velocity: 4.009 RM: (0.0, 0.0, 0.066815)
State: run_16 Velocity: 4.009 RM: (0.0, 0.0, 0.066815)
State: run_16 Velocity: 4.009 RM: (0.0, 0.0, 0.066815)
State: run_16 Velocity: 4.009 RM: (0.0, 0.0, 0.066815)
State: run_16 Velocity: 4.009 RM: (0.0, 0.0, 0.066815)
State: run_16 Velocity: 4.009 RM: (0.0, 0.0, 0.066815)
State: run_16 Velocity: 4.009 RM: (0.0, 0.0, 0.066815)
State: run_16 Velocity: 4.009 RM: (0.0, 0.0, 0.066815)
State: run_16 Velocity: 4.009 RM: (0.0, 0.0, 0.066815)
State: run_16 Velocity: 4.009 RM: (0.0, 0.0, 0.066815)
State: run_16 Velocity: 4.009 RM: (0.0, 0.0, 0.066815)
State: run_16 Velocity: 4.009 RM: (0.0, 0.0, 0.066815)
State: run_16 Velocity: 4.009 RM: (0.0, 0.0, 0.066815)
State: run_16 Velocity: 4.009 RM: (0.0, 0.0, 0.066815)
State: run_16 Velocity: 4.009 RM: (0.0, 0.0, 0.066815)
State: run_16 Velocity: 4.009 RM: (0.0, 0.0, 0.066815)
State: run_16 Velocity: 4.009 RM: (0.0, 0.0, 0.066815)
State: run_16 Velocity: 4.009 RM: (0.0, 0.0, 0.066815)
State: run_16 Velocity: 4.009 RM: (0.0, 0.0, 0.066815)

fire7side

It kind of looks like animation tree is more setup for root motion. Might be worth a try. Then again, you might have exactly the same problem.

kuligs2

Been a while since i got time to get to the end of this problem.. still fighting..

Now made a godot forum post.. maybe other chads can suggest me something since yall dont know whats wrong.

https://forum.godotengine.org/t/root-motion-looses-momentum-when-changing-animations/142643

kuligs2

Alright, getting closer.
https://forum.godotengine.org/t/root-motion-looses-momentum-when-changing-animations/142643/28?u=kuligs2

As per the post, i guess i have to use hacky solutions to hacky problems.

According

They talk about how the animation_finished signal should emit only after the last animation frame, which in my case is a “no no” Because the last frame is what resets value for root motion.

Now as for my gripe with adding manual call function tracks to animations, i figured i could use process_function to:

func check_anim_player_pos():
	
	if character.animation_player.current_animation_position >= character.animation_player.current_animation_length-0.1:
		is_blocking = false
		print("check_anim_player_pos: unblock")

And in my physics_process() i check that blocking var, if its false then i decide next state while im still in current state of animation and havent lost the velocity.

func physics_update(_delta: float) -> void:
	
	if not is_blocking:
		_decide_next_state()

	character.move_and_slide()

All these functions are in the state code.

And whit this i get somewhat smooth transition.

State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.020911)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.020912)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.020911)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.020911)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.020911)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.020911)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.020911)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.020912)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.020912)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.020911)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.020911)
check_anim_player_pos: unblock
Changing state to: walk
State: walk Velocity: 1.255 RM: (0.0, 0.0, 0.020911)
State: walk Velocity: 1.255 RM: (0.0, 0.0, 0.020911)
State: walk Velocity: 1.240 RM: (0.0, 0.0, 0.02066)
State: walk Velocity: 1.225 RM: (0.0, 0.0, 0.020409)
State: walk Velocity: 1.209 RM: (0.0, 0.0, 0.020157)
State: walk Velocity: 1.194 RM: (0.0, 0.0, 0.019906)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654)

Its a hacky solution, but i guess life is made of many hacky solution to make sense.

Animation_finished signal gets fired after the last frame of animation was played (logically), and this is what was resetting my root motion velocity back to zero while the engine took the time to process that 1 frame and decide the next state to switch to.

So instead of adding custom tracks to every oneshot animation to trigger slightly before the end of animation, i just abuse the process_function where i keep checking if its around the end of animation to trigger the unblock state and move on to another state.

Wish devs would have added a checkbox for when root motion is used to fire animation finished signal on the last frame, and or keep the velocity cached for 1 frame after it fires or somehting (a special case for root motion).

Oh and note to self: make longer animations. to have better transitions.

kuligs2

Adding to my previous post.. its not that simple unfortunately..
Im having sync problems with animations in this case.. also if the blend value is larger than what you subtract from animation_length then you get slowdown in velocity during switch..

And adding that blend_time ammount crossover/fade delay introduces thing where if your previous animation is putting foot down lower than knee, and the next animation starts with a foot already down, then you get some sort of ghost step and not a smooth transition.. leaving blend time to 0.0 will give you this 0.0 velocity for few engine frames..

AAAAAnd if you do this with animation tree, you still get the same 0.0 velocity garbage.. even worse performance..

State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.046 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.230 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.217 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.204 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.192 RM: (0.0, 0.0, 0.0)
On_animation_finished: Walk_start_long
Changing state to: walk
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 0.983 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 0.786 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 0.590 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 0.393 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 0.197 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 0.000 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 0.000 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 0.418 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 0.627 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 0.836 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.046 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.255 RM: (0.0, 0.0, 0.0)

IDK what to do here .. guess will have to live with basic - press forward, do walk animation like caveman.. this is stupid..

kuligs2

Hacked the animation player to have it work like this:
Start animation plays, and in the animation i add call method track at "blend_time" ammount before anim finishes to switch the state.
Walk state starts animation at double the blend time seek(-0.2)
And now its smooth..
What a mess..

With seek

without seek

kuligs2

kuligs2 Forgot to add. Using the update() function that triggers every engine frame not physics frame, and have a function to check if animation position is over the trigger time, introduces slight visual delay.. its smoother with added animation track to call function for some reason..

kuligs2

Had done some thinkin during shower:
If i use animation player, im limited to static animations and cant mix for instance hand movement animation for sword swing with leg animation running. For this you need animationmixer a.k.a. animation tree.

So Now im exploring using animation tree, where i would have movement node -> statemachine and fight node -> statemachine and then use blend node to mix them when needed based on code or whatever.

Alright this would work, but now i want to have the behavior of my animationplayer setup in animationtree.

Its not well documented on how, but i found you can get signals when state is finished like this:

var movement_playback: AnimationNodeStateMachinePlayback

func _ready() -> void:
	movement_playback = animation_tree.get("parameters/MovementStateMachine/playback")

And then in my coded states i could use something like this:

extends StateInterface

class_name JumpLandedState

var character: Player
var is_blocking:bool = false

func enter(_prev_state: String = "")-> void:
	character = state_machine.owner
	character.movement_playback.state_finished.connect(on_state_finished) # <-------------------
	character.animation_tree.set("parameters/MovementStateMachine/conditions/idle",false)
	character.animation_tree.set("parameters/MovementStateMachine/conditions/landed",true)
	character.animation_tree.set("parameters/MovementStateMachine/conditions/midair",false)
	character.animation_tree.set("parameters/MovementStateMachine/conditions/move",false)
	
	character.is_root_motion = false
	is_blocking = true

func physics_update(_delta: float) -> void:	
	if not character.is_on_floor():
		state_machine.change_state("Jump_midair_90")
		return
		
	character.velocity = (character.animation_tree.get_root_motion_rotation_accumulator().inverse() * character.get_quaternion()) * character.animation_tree.get_root_motion_position() / _delta
	character.move_and_slide()
	
	if not is_blocking:
		_decide_next_state()

func on_state_finished(_animation_name):
	if _animation_name == "Jump_landed_9":
		print("Landed state finished: ",_animation_name)
		character.movement_playback.state_finished.disconnect(on_state_finished)
		is_blocking = false

And then tried out walking routine and it seems that it dont loose the velocity -> no more 0.0 frames

State: idle Velocity: 0.000 RM: (0.0, 0.0, 0.0)
State: idle Velocity: 0.000 RM: (0.0, 0.0, 0.0)
State: idle Velocity: 0.000 RM: (0.0, 0.0, 0.0)
State: idle Velocity: 0.000 RM: (0.0, 0.0, 0.0)
Changing state to: walk_start
State: walk_start Velocity: 0.000 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 0.000 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 0.000 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 0.418 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 0.627 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 0.836 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.046 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
Unblocked state
Changing state to: walk
State: walk Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.046 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.230 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.217 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.204 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.192 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.0)

But it oddly dips below the next animation velocity.. both animations have linear root motion translation with 0.1 blending between animations
State: walk Velocity: 1.046 RM: (0.0, 0.0, 0.0)
With having blending - 0.1 on the switch from walk_start to walk animation introduces slight misstep in feet animation and looks clunky, removing the blending - 0.0 eliminates any desync and its smooth. Because both animations start and end on the same frame (-1) so it dont need any blending.

TLDR:

Seems like animationtree is usable in my case. Bummer is that for each movement state i have to define the switch states like:

Is there a better way to "toggle" switch states, or is it evil we have to live with?

kuligs2

Hmm.. maybe someone here could help me out?

As im wiring up my animations, the transition relationships between all animations.. i am starting to think maybe its not a good idea afterall..

Look:

And this is just movement
and on every connection i have to define the condition variable.. imagine reworking that..

and then you need to set all of these condition variables inside each state when you enter that state in order for animation to start work.

aaaand you have to remember which transitions need to have fade times and which dont..

what am i doing wrong? this feels dirty..

Dad3353

kuligs2

Whilst I don't pretend to understand all of the implications, could you consider having, for each of these movements, only its potential outgoings, and not those incoming..? Once done for each, all of the combinations would be covered, with maybe greater clarity..? I've done a brief sketch of just two (Idle and Crouch...); this would need to be repeated for each, but only the outgoing. Any use, or just ignorance on my part..?

kuligs2

Dad3353 but as you can see kinda from my picture, almost all animations are connected to each other.. only few are dead end animations.. because to have flexible character there are very many numbers of combinations on how it can move..

atm i dont see how i could use your method .. i would still end up with "states" for each animation that is connected to every other animation..

for readability maybe its easier..

Dad3353

kuligs2

But you only have to concern yourself, and treat, the outgoings. The 'return' information is superfluous and redundant. Your system is complex, so needs treating in complex fashion. No need, however, to render it more difficult than it already by its nature. That's all. Hope this helps, even just a little.

kuligs2

Dad3353 can you explain from your example with only outgoing, how do you connect the incomming?

« Previous Page Next Page »