intermediate working version

procwalk/walk.py

@@ -3,45 +3,33 @@ import math
 import random
 
 
-this_node = hou.pwd()
-parent = this_node.inputs()[0]
-legs = hou.node('../l_parents').outputs()
-ground = hou.node('../ground')
-
-#legs = hou.node(this_node.parm('leg_root').eval()).outputs()
-
-for l in legs:
-    pass
-    #print 'leg', l
-
-parent_wt = parent.worldTransform()
-parent_transform = hou.Vector3(parent.parmTuple("t").eval())
-
 # /// utils
 def lerp(t, a, b):
     return a + t * (b - a)
 
+
 def roundVec(v, fac, seed):
     #seed = random.random()*0.1
-    seed = 0.1*seed - 0.05*seed
-    x = (round(v[0]*fac + seed))/fac
-    y = (round(v[1]*fac + seed))/fac
-    z = (round(v[2]*fac + seed))/fac
+    seed = 0.1 * seed - 0.05 * seed
+    x = (round(v[0] * fac + seed)) / fac
+    y = (round(v[1] * fac + seed)) / fac
+    z = (round(v[2] * fac + seed)) / fac
     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
+    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=1.5):
-    #TODO probably take the nearest topmost point
+def find_nearest(v, node, maxdist=4):
+    # TODO probably take the nearest topmost point
     geo = node.displayNode().geometry()
     nearest = [maxdist, None]
-    for p in  geo.points():
+    for p in geo.points():
         dist = p.position().distanceTo(v)
         if dist < nearest[0]:
             nearest[0] = dist
@@ -52,92 +40,70 @@ def find_nearest(v, node, maxdist=1.5):
 # /// setup
 def distribute_legs():
     spacing = 1
-    legs_per_side = round(len(legs)/2)
-    offset = (spacing * legs_per_side - spacing)/2
+    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))
+    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.setParmTransform(p)
         leg.restpos = p.extractTranslates()
 
-        continue
-        
-        if no < legs_per_side:
-            t = hou.hmath.buildTranslate(2, 0, no*spacing-offset)
-            leg.setParmTransform(t*parent_wt)
-        else:
-            t = hou.hmath.buildTranslate(-2, 0, (no*spacing-legs_per_side*spacing)-offset)
-            leg.setParmTransform(t*parent_wt)
+
+def place_legs():
+    for no, leg in enumerate(LEGS):
+        # print leg.name(), no
+        p = leg_capturepos(leg)
+        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
+    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        
+        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
+        # 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        
+        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
+        # leg.setParmTransform(t*PARENT_WT)
+        return t * PARENT_WT
 
 
-# /// movement
-def move_legs_insect():
-    distribute_legs()
-    for no, leg in enumerate(legs):
-        lt = hou.Vector3(leg.parmTuple("t").eval())
-        #print roundVec(lt, 3)
-        #offset = 0.05*no
-        #lt_r = hou.Vector3(round(lt[0]+offset), round(lt[1]), round(lt[2]+offset))
-        lt_r = roundVec(lt, 1, no)
-        #d = lt.distanceTo(lt_r)
-        d = lt_r.distanceTo(parent_transform)*0.3
-        #print 'dist', d
-        #t = hou.hmath.buildTranslate(lt_r[0], 0, lt_r[2])
-        #t = hou.hmath.buildTranslate(round(lt[0]+offset), 0, round(lt[2]+offset))
-        #this_node.parmTuple('snap_l' + str(no+1) ).set(hou.Vector3(lt_r[0], lt_r[1], lt_r[2]))
-        ramp = this_node.parm('p_ramp').eval()
-        ramp_up = this_node.parm('p_up').eval()
-        #print ramp.lookup(d)
-        intp_x = lerp(ramp.lookup(d), lt[0], lt_r[0])
-        intp_z = lerp(ramp.lookup(d), lt[2], lt_r[2])
-        intp_y = ramp_up.lookup(d)
-        t = hou.hmath.buildTranslate(intp_x, intp_y, intp_z)
-        leg.setParmTransform(t)
+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()
-    
-    for no, leg in enumerate(legs):
+    # distribute_legs()
+    place_legs()
+
+    for no, leg in enumerate(LEGS):
         lt = hou.Vector3(leg.parmTuple("t").eval())
-        next_p = find_nearest(lt, ground)
+        next_p = find_nearest(lt, GROUND)
         dist = next_p.distanceTo(leg.restpos)
-        #print dist
+        print dist
         if dist > 0.6:
-            #print 'setting', leg
-            next_restp = find_nearest(leg.restpos, ground)
-            t = hou.hmath.buildTranslate(next_restp[0], next_restp[1], next_restp[2])
+            # print 'setting', leg
+            next_restp = find_nearest(leg.restpos, GROUND)
+            t = hou.hmath.buildTranslate(
+                next_restp[0], next_restp[1], next_restp[2])
             leg.setParmTransform(t)
-            
-            
         else:
             pass
             #t = hou.hmath.buildTranslate(next_p[0], next_p[1], next_p[2])
-            #leg.setParmTransform(t)
-            
-
+            # leg.setParmTransform(t)
 
 
 def remove_keyframes():
@@ -146,7 +112,7 @@ def remove_keyframes():
         delete all keyframes if rewound
         (@ frame 1)
         """
-        for leg in legs:
+        for leg in LEGS:
             parm = leg.parmTuple("t")
             parm.deleteAllKeyframes()
 
@@ -155,7 +121,7 @@ def set_keys():
     """
     Set keyframe for all legs
     """
-    for leg in legs:
+    for leg in LEGS:
         pos = hou.Vector3(leg.parmTuple("t").eval())
         kfx = hou.Keyframe()
         kfx.setFrame(hou.frame())
@@ -174,7 +140,39 @@ def set_keys():
         tchanz.setKeyframe(kfz)
 
 
-move_legs_gnd()
-#remove_keyframes()
-#distribute_legs()
-#set_keys()
+# 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())
+
+
+def main():
+    # This is our 'capture' frame
+
+    if hou.frame() == CAPTURE_FRAME:
+        """
+        Basically, do nothing in the capture frame.
+        Just store the actual leg position in the up vector
+        to access it in any other frame as the capture position.
+        """
+        for leg in LEGS:
+            # we use the up vector to store the capture pose per leg
+            pos = hou.Vector3(leg.parmTuple("t").eval())
+            leg.parmTuple('up').set(pos)
+            print leg, pos
+            leg.capture_pos = pos
+        # move_legs_gnd()
+    else:
+        # do the dance
+        for leg in LEGS:
+            p = hou.Vector3(leg.parmTuple("up").eval())
+            leg.capture_pos = p
+        move_legs_gnd()
+
+
+main()