maxlen-style pathing

procwalk/walk.py

@@ -3,20 +3,16 @@ import math
 import random
 
 
-
-
 this_node = hou.pwd()
-
-
-
-parent = hou.node('../model/')
-
+parent = this_node.inputs()[0]
 legs = hou.node('../l_parents').outputs()
-#legs = hou.node(this_node.parm('leg_root').eval()).outputs()
-
-#print legs
+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())
@@ -26,9 +22,8 @@ def lerp(t, a, b):
     return a + t * (b - a)
 
 def roundVec(v, fac, seed):
-
     #seed = random.random()*0.1
-    seed = 0.1*seed
+    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
@@ -42,13 +37,33 @@ def floorVec(v, fac, seed):
     return hou.Vector3(x, y, z)
 
 
+def find_nearest(v, node, maxdist=1.5):
+    #TODO probably take the nearest topmost point
+    geo = node.displayNode().geometry()
+    nearest = [maxdist, None]
+    for p in  geo.points():
+        dist = p.position().distanceTo(v)
+        if dist < nearest[0]:
+            nearest[0] = dist
+            nearest[1] = p.position()
+    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()
+
+        continue
+        
         if no < legs_per_side:
             t = hou.hmath.buildTranslate(2, 0, no*spacing-offset)
             leg.setParmTransform(t*parent_wt)
@@ -59,116 +74,107 @@ def distribute_legs():
 
 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:
-        t = hou.hmath.buildTranslate(2, 0, index*spacing-offset)
-        leg.setParmTransform(t*parent_wt)
+        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:
-        t = hou.hmath.buildTranslate(-2, 0, (index*spacing-legs_per_side*spacing)-offset)
-        leg.setParmTransform(t*parent_wt)
+        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
-        
+
 
 # /// movement
 def move_legs_insect():
     distribute_legs()
     for no, leg in enumerate(legs):
-
-        #print 'leg', leg
         lt = hou.Vector3(leg.parmTuple("t").eval())
-        #print lt
-
         #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
-
+        #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)
 
-
-move_legs_insect()
-
-def move_legs_maxlen():
-    maxlen = 2.6
-    minlen = 1.7
+def move_legs_gnd():
+    distribute_legs()
+    
     for no, leg in enumerate(legs):
-
         lt = hou.Vector3(leg.parmTuple("t").eval())
-       
-        #print lt
-        lt_r = roundVec(lt, 1, no)
-        d = lt_r.distanceTo(parent_transform)
-        print 'DIST', d
-
-        if d > maxlen or d < minlen:
-            #r = leg_restpos(leg, no, len(legs))
-            #t = hou.hmath.buildTranslate(r)
-            #leg.setParmTransform(t)
-            print leg_restpos(leg, no, len(legs))
-
-        else:
-            t = hou.hmath.buildTranslate(lt_r[0], 0, lt_r[2])
+        next_p = find_nearest(lt, ground)
+        dist = next_p.distanceTo(leg.restpos)
+        #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])
             leg.setParmTransform(t)
+            
+            
+        else:
+            pass
+            #t = hou.hmath.buildTranslate(next_p[0], next_p[1], next_p[2])
+            #leg.setParmTransform(t)
+            
 
-#move_legs_maxlen()
 
 
-if hou.frame() == 1:
-    """
-    delete all keyframes if rewound
-    """
-    for no, leg in enumerate(legs):
-        parm = leg.parmTuple("t")
-        parm.deleteAllKeyframes()
+def remove_keyframes():
+    if hou.frame() == 1:
+        """
+        delete all keyframes if rewound
+        (@ frame 1)
+        """
+        for leg in legs:
+            parm = leg.parmTuple("t")
+            parm.deleteAllKeyframes()
 
 
 def set_keys():
     """
     Set keyframe for all legs
     """
-    for no, leg in enumerate(legs):
-
+    for leg in legs:
         pos = hou.Vector3(leg.parmTuple("t").eval())
-
         kfx = hou.Keyframe()
         kfx.setFrame(hou.frame())
         kfx.setValue(pos[0])
-
         kfy = hou.Keyframe()
         kfy.setFrame(hou.frame())
         kfy.setValue(pos[1])
-
         kfz = hou.Keyframe()
         kfz.setFrame(hou.frame())
         kfz.setValue(pos[2])
-
         tchanx = hou.parm('../' + leg.name() + '/tx')
         tchany = hou.parm('../' + leg.name() + '/ty')
         tchanz = hou.parm('../' + leg.name() + '/tz')
-
         tchanx.setKeyframe(kfx)
         tchany.setKeyframe(kfy)
         tchanz.setKeyframe(kfz)
 
 
-set_keys()
+move_legs_gnd()
+#remove_keyframes()
+#distribute_legs()
+#set_keys()