160 lines
7.8 KiB
GDScript
160 lines
7.8 KiB
GDScript
extends RefCounted
|
|
# Distance-driven runway gait. Stance feet are fixed in world space, including turns.
|
|
const FLOOR_Y=0.012
|
|
const START_PHASE=0.25
|
|
var actor: Node3D
|
|
var skeleton: Skeleton3D
|
|
var bones={}
|
|
var feet=[]
|
|
var base_hip=Vector3.ZERO
|
|
var last_position=Vector3.ZERO
|
|
var phase=START_PHASE
|
|
var walk_weight=0.0
|
|
var distance_walked=0.0
|
|
var last_speed=0.0
|
|
var initialized=false
|
|
var moving=false
|
|
var stride=1.55
|
|
var last_direction=Vector3.ZERO
|
|
var stride_min=1.25
|
|
var stride_max=1.65
|
|
var track_width=.065
|
|
var swing_height=.15
|
|
|
|
func setup(owner_actor):
|
|
actor=owner_actor;skeleton=actor.find_children("*","Skeleton3D",true,false)[0]
|
|
for i in range(skeleton.get_bone_count()):bones[skeleton.get_bone_name(i)]=i
|
|
base_hip=actor.to_local(point("root"))
|
|
for side in ["L","R"]:
|
|
var foot="foot."+side
|
|
var p=actor.to_local(point(foot))
|
|
var q=actor.global_basis.orthonormalized().get_rotation_quaternion().inverse()*global_rotation(foot)
|
|
feet.append({"side":side,"offset":0.0 if side=="L" else .5,"rest":p,"rotation":q,"anchor":Vector3.ZERO,"target":Vector3.ZERO,"start":Vector3.ZERO,"landing":Vector3.ZERO,"start_phase":.5,"grounded":true,"last_phase":0.0,"yaw":0.0})
|
|
reset()
|
|
|
|
func point(bone):return skeleton.to_global(skeleton.get_bone_global_pose(bones[bone]).origin)
|
|
func global_rotation(bone):return skeleton.global_basis.orthonormalized().get_rotation_quaternion()*skeleton.get_bone_global_pose(bones[bone]).basis.orthonormalized().get_rotation_quaternion()
|
|
func ground_height(foot):return actor.get_parent().global_position.y+FLOOR_Y+foot.rest.y*actor.global_basis.get_scale().y
|
|
func reset():
|
|
phase=START_PHASE;walk_weight=0;last_speed=0;moving=false;last_direction=Vector3.ZERO
|
|
last_position=actor.global_position
|
|
for f in feet:
|
|
f.anchor=actor.to_global(f.rest);f.anchor.y=ground_height(f);f.target=f.anchor
|
|
f.start=f.anchor;f.landing=f.anchor;f.grounded=true;f.last_phase=fposmod(phase+f.offset,1)
|
|
f.yaw=actor.global_rotation.y
|
|
initialized=true
|
|
|
|
func rotate_world(bone,axis,angle):
|
|
set_rotation(bone,Quaternion(axis.normalized(),angle)*global_rotation(bone))
|
|
func set_rotation(bone,world_rotation):
|
|
var i=bones[bone];var parent=skeleton.get_bone_parent(i)
|
|
var q=skeleton.global_basis.orthonormalized().get_rotation_quaternion().inverse()*world_rotation
|
|
if parent>=0:q=skeleton.get_bone_global_pose(parent).basis.orthonormalized().get_rotation_quaternion().inverse()*q
|
|
skeleton.set_bone_pose_rotation(i,q);skeleton.force_update_all_bone_transforms()
|
|
func aim(bone,child,target):
|
|
var from=point(child)-point(bone);var to=target-point(bone)
|
|
if from.length_squared()<.00001 or to.length_squared()<.00001:return
|
|
set_rotation(bone,Quaternion(from.normalized(),to.normalized())*global_rotation(bone))
|
|
func leg(f,target):
|
|
var upper="upperleg01."+f.side;var lower="lowerleg01."+f.side;var end="foot."+f.side
|
|
var a=point(upper);var b=point(lower);var c=point(end)
|
|
var l1=a.distance_to(b);var l2=b.distance_to(c);var direction=(target-a).normalized()
|
|
var length=clampf(a.distance_to(target),absf(l1-l2)+.001,l1+l2-.001)
|
|
var along=(l1*l1-l2*l2+length*length)/(2*length)
|
|
var forward=actor.global_basis.z.normalized()
|
|
var bend=(forward-direction*forward.dot(direction)).normalized()
|
|
var knee=a+direction*along+bend*sqrt(maxf(0,l1*l1-along*along))
|
|
aim(upper,lower,knee);aim(lower,end,target)
|
|
|
|
func landing(f,progress,travel_direction):
|
|
var scale_y=actor.global_basis.get_scale().y
|
|
# Narrow catwalk track, with enough clearance for the boots to pass each other.
|
|
var side=1.0 if f.side=="L" else -1.0
|
|
var destination=actor.global_position+travel_direction*((1.0-progress)*stride+stride*.25)
|
|
destination+=actor.global_basis.x.normalized()*side*track_width*scale_y
|
|
destination.y=ground_height(f)
|
|
return destination
|
|
|
|
func update(dt):
|
|
if not initialized:return
|
|
var displacement=actor.global_position-last_position;displacement.y=0
|
|
last_position=actor.global_position
|
|
if displacement.length()>1.0:reset();displacement=Vector3.ZERO
|
|
var distance=displacement.length()
|
|
last_speed=distance/maxf(dt,.0001)
|
|
var was_moving=moving;moving=distance>.00015 and dt>0
|
|
var scale_y=actor.global_basis.get_scale().y
|
|
# Longer steps at higher upgrade speeds; phase still follows the actual distance.
|
|
stride=lerpf(stride_min,stride_max,clampf((last_speed/scale_y-1.3)/2.0,0,1))*scale_y
|
|
walk_weight=move_toward(walk_weight,1.0 if moving else 0.0,dt*7)
|
|
if moving:
|
|
distance_walked+=distance;phase=fposmod(phase+distance/stride,1.0)
|
|
var travel_direction=displacement.normalized() if moving else actor.global_basis.z.normalized()
|
|
if moving and last_direction.length_squared()>.5 and travel_direction.dot(last_direction)<.65:
|
|
# A corner starts a short pivot step on the current support foot.
|
|
var support=0 if feet[0].grounded else 1
|
|
phase=.25 if support==0 else .75
|
|
var swing=feet[1-support];swing.start=swing.target;swing.start_phase=.75;swing.grounded=false
|
|
walk_weight=minf(walk_weight,.8)
|
|
if moving:last_direction=travel_direction
|
|
for f in feet:
|
|
var p=fposmod(phase+f.offset,1.0)
|
|
if moving:
|
|
if p>=.5:
|
|
if f.grounded:
|
|
f.start=f.target;f.start_phase=p if not was_moving else .5;f.grounded=false
|
|
f.landing=landing(f,p,travel_direction)
|
|
var u=clampf((p-f.start_phase)/maxf(.01,1.0-f.start_phase),0,1)
|
|
var ease=u*u*(3-2*u)
|
|
f.target=f.start.lerp(f.landing,ease)
|
|
f.target.y=ground_height(f)+sin(u*PI)*swing_height*scale_y
|
|
else:
|
|
if not f.grounded:
|
|
f.anchor=f.landing;f.anchor.y=ground_height(f);f.yaw=actor.global_rotation.y;f.grounded=true
|
|
f.target=f.anchor
|
|
else:
|
|
# An interrupted swing settles vertically; support feet never skate to idle.
|
|
f.target.y=move_toward(f.target.y,ground_height(f),dt*.9*scale_y)
|
|
if absf(f.target.y-ground_height(f))<.0001:f.anchor=f.target;f.grounded=true
|
|
f.last_phase=p
|
|
# Keep the pelvis at a reachable height instead of lifting the whole mesh.
|
|
var sway=sin(phase*TAU)*.042*walk_weight
|
|
var bob=(-.05-cos(phase*TAU*2)*.05)*walk_weight
|
|
var desired_hip=base_hip+Vector3(sway,bob+FLOOR_Y/scale_y,0)
|
|
# During stopping, retain enough leg reach for the last planted stride.
|
|
var reach_drop=0.0
|
|
for f in feet:
|
|
var local=actor.to_local(f.target)
|
|
reach_drop=maxf(reach_drop,clampf((absf(local.z)-.12)*.28,0,.12))
|
|
desired_hip.y=minf(desired_hip.y,base_hip.y+FLOOR_Y/scale_y-reach_drop)
|
|
skeleton.set_bone_pose_position(bones["root"],skeleton.to_local(actor.to_global(desired_hip)))
|
|
skeleton.force_update_all_bone_transforms()
|
|
if not actor.striking:
|
|
rotate_world("root",actor.global_basis.z,sin(phase*TAU)*.045*walk_weight)
|
|
rotate_world("spine02",actor.global_basis.z,-sin(phase*TAU)*.045*walk_weight)
|
|
rotate_world("spine02",Vector3.UP,-sin(phase*TAU)*.045*walk_weight)
|
|
for side in ["L","R"]:
|
|
var sign_x=1.0 if side=="L" else -1.0
|
|
rotate_world("upperarm01."+side,actor.global_basis.x,sign_x*sin(phase*TAU)*.14*walk_weight)
|
|
rotate_world("lowerarm01."+side,actor.global_basis.x,-.06*walk_weight)
|
|
# Solve pelvis height from both leg reaches, including sideways steps on turns.
|
|
var lower_by=0.0
|
|
for f in feet:
|
|
var hip=point("upperleg01."+f.side);var knee=point("lowerleg01."+f.side);var ankle=point("foot."+f.side)
|
|
var reach=hip.distance_to(knee)+knee.distance_to(ankle)-.006*scale_y
|
|
var horizontal=Vector2(hip.x-f.target.x,hip.z-f.target.z).length_squared()
|
|
var available=sqrt(maxf(.01,reach*reach-horizontal))
|
|
lower_by=maxf(lower_by,hip.y-f.target.y-available)
|
|
if lower_by>0:
|
|
var root_position=point("root")-Vector3.UP*lower_by
|
|
skeleton.set_bone_pose_position(bones["root"],skeleton.to_local(root_position));skeleton.force_update_all_bone_transforms()
|
|
for f in feet:
|
|
leg(f,f.target)
|
|
set_rotation("foot."+f.side,foot_orientation(f,dt))
|
|
|
|
func foot_orientation(f,_dt):
|
|
var yaw=f.yaw if f.grounded else actor.global_rotation.y
|
|
var orientation=Quaternion(Vector3.UP,yaw)*f.rotation
|
|
if not f.grounded:orientation=Quaternion(actor.global_basis.x.normalized(),sin(maxf(0,f.last_phase-.5)*TAU)*-.12)*orientation
|
|
return orientation
|