Import current DEMON v0.19 source, assets and development handoff
This commit is contained in:
@@ -0,0 +1,152 @@
|
||||
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
|
||||
|
||||
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*.065*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(1.25,1.65,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)*.15*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)
|
||||
var yaw=f.yaw if f.grounded else actor.global_rotation.y
|
||||
var foot_rotation=Quaternion(Vector3.UP,yaw)*f.rotation
|
||||
if not f.grounded:foot_rotation=Quaternion(actor.global_basis.x.normalized(),sin(maxf(0,f.last_phase-.5)*TAU)*-.12)*foot_rotation
|
||||
set_rotation("foot."+f.side,foot_rotation)
|
||||
Reference in New Issue
Block a user