ground based walk

procwalk/walk.py

@@ -1,9 +1,8 @@
 import hou
 import math
-import random
 
 
-# /// utils
+# /////////////////////////////////////// utils
 def lerp(t, a, b):
     return a + t * (b - a)
 
@@ -17,18 +16,10 @@ def roundVec(v, fac, seed):
     return hou.Vector3(x, y, z)
 
 
-def floorVec(v, fac, seed):
-    seed = 0.1 * seed
-    x = (math.floor(v[0] * fac + seed)) / fac
-    y = (math.floor(v[1] * fac + seed)) / fac
-    z = (math.floor(v[2] * fac + seed)) / fac
-    return hou.Vector3(x, y, z)
-
-
-def find_nearest(v, node, maxdist=4):
+def find_nearest(v, node, maxdist=3):
     # TODO probably take the nearest topmost point
     geo = node.displayNode().geometry()
-    nearest = [maxdist, None]
+    nearest = [maxdist, v]
     for p in geo.points():
         dist = p.position().distanceTo(v)
         if dist < nearest[0]:
@@ -37,18 +28,11 @@ def find_nearest(v, node, maxdist=4):
     return nearest[1]
 
 
-# /// setup
-def distribute_legs():
-    spacing = 1
-    legs_per_side = round(len(LEGS) / 2)
-    offset = (spacing * legs_per_side - spacing) / 2
-
-    for no, leg in enumerate(LEGS):
-        # print leg.name(), no
-        p = leg_restpos(leg, no, len(LEGS))
-        #t = hou.hmath.buildTranslate(p)
-        # leg.setParmTransform(p)
-        leg.restpos = p.extractTranslates()
+# /////////////////////////////////////// setup
+def leg_capturepos(leg):
+    p = leg.capture_pos
+    t = hou.hmath.buildTranslate(p[0], p[1], p[2])
+    return t * PARENT_WT
 
 
 def place_legs():
@@ -58,33 +42,6 @@ def place_legs():
         leg.restpos = p.extractTranslates()
 
 
-def leg_restpos(leg, index, maxlegs):
-    spacing = 1
-    side_factor = 2
-    legs_per_side = round(maxlegs / 2)
-    offset = (spacing * legs_per_side - spacing) / 2
-    #d = lt_r.distanceTo(PARENT_TRANSFORM)*0.3
-
-    if index < legs_per_side:
-        leg_pos = index * spacing - offset
-        x = side_factor - math.fabs(leg_pos) * 0.2
-        t = hou.hmath.buildTranslate(x, 0, leg_pos)
-        # leg.setParmTransform(t*PARENT_WT)
-        return t * PARENT_WT
-    else:
-        leg_pos = (index * spacing - legs_per_side * spacing) - offset
-        x = side_factor - math.fabs(leg_pos) * 0.2
-        t = hou.hmath.buildTranslate(-x, 0, leg_pos)
-        # leg.setParmTransform(t*PARENT_WT)
-        return t * PARENT_WT
-
-
-def leg_capturepos(leg):
-    p = leg.capture_pos
-    t = hou.hmath.buildTranslate(p[0], p[1], p[2])
-    return t * PARENT_WT
-
-
 def move_legs_gnd():
     # distribute_legs()
     place_legs()
@@ -93,8 +50,7 @@ def move_legs_gnd():
         lt = hou.Vector3(leg.parmTuple("t").eval())
         next_p = find_nearest(lt, GROUND)
         dist = next_p.distanceTo(leg.restpos)
-        print dist
-        if dist > 0.6:
+        if dist > COMFORT_LENGTH:
             # print 'setting', leg
             next_restp = find_nearest(leg.restpos, GROUND)
             t = hou.hmath.buildTranslate(
@@ -121,16 +77,21 @@ def set_keys():
     """
     Set keyframe for all legs
     """
+    frame = hou.frame()
+
+    if frame == CAPTURE_FRAME:
+        return
+
     for leg in LEGS:
         pos = hou.Vector3(leg.parmTuple("t").eval())
         kfx = hou.Keyframe()
-        kfx.setFrame(hou.frame())
+        kfx.setFrame(frame)
         kfx.setValue(pos[0])
         kfy = hou.Keyframe()
-        kfy.setFrame(hou.frame())
+        kfy.setFrame(frame)
         kfy.setValue(pos[1])
         kfz = hou.Keyframe()
-        kfz.setFrame(hou.frame())
+        kfz.setFrame(frame)
         kfz.setValue(pos[2])
         tchanx = hou.parm('../' + leg.name() + '/tx')
         tchany = hou.parm('../' + leg.name() + '/ty')
@@ -140,15 +101,14 @@ def set_keys():
         tchanz.setKeyframe(kfz)
 
 
-# globals
+# /////////////////////////////////////// globals
 THIS_NODE = hou.pwd()
 PARENT = THIS_NODE.inputs()[0]
 LEGS = hou.node('../l_parents').outputs()
 GROUND = hou.node('../ground')
 CAPTURE_FRAME = 1
-#legs = hou.node(THIS_NODE.parm('leg_root').eval()).outputs()
 PARENT_WT = PARENT.worldTransform()
-#PARENT_TRANSFORM = hou.Vector3(PARENT.parmTuple("t").eval())
+COMFORT_LENGTH = 1
 
 
 def main():
@@ -173,6 +133,7 @@ def main():
             p = hou.Vector3(leg.parmTuple("up").eval())
             leg.capture_pos = p
         move_legs_gnd()
+        set_keys()
 
 
 main()