Files
Diabolo/Demon_v0.19/catwalk.gd
T

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