walk

procwalk/walk.py

@@ -0,0 +1,130 @@
+import hou
+import math
+import random
+
+this_node = hou.pwd()
+
+
+
+parent = hou.node('../model/')
+
+legs = hou.node('../l_parents').outputs()
+#legs = hou.node(this_node.parm('leg_root').eval()).outputs()
+
+#print legs
+
+
+
+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
+    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
+    return hou.Vector3(x, y, z)
+
+
+
+# /// 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):
+        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 leg_restpos(leg, index, maxlegs):
+    spacing = 1
+    legs_per_side = round(maxlegs/2)
+    offset = (spacing * legs_per_side - spacing)/2
+
+    if index < legs_per_side:
+        t = hou.hmath.buildTranslate(2, 0, index*spacing-offset)
+        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)
+        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
+
+        #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
+    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])
+            leg.setParmTransform(t)
+
+#move_legs_maxlen()