Pyppet - WebGL Streaming

Check out Three.js on github and get ready to be blown away, so much power in 380KB.

Websockets Streaming Mesh - WebGL Client

Websockify by Joel Martin has got everything you need to get websockets going in Python3.

Supported Streaming Modifiers

• Cast,
• Curve,
• Displace,
• Hook,
• Lattice,
• MeshDeform,
• ShrinkWrap,
• SimpleDeform,
• Smooth,
• Warp,
• Wave

Streaming the default blender monkey head (500 vertices) to the web-client creates a load of about 350KB per-second. This is still using ASCII Json for transport, so hopefully in the future a binary stream or other packing method could cut this down even more.

Pyppet2 - Audio Analysis

Prototype for real-time musical performance at live events, concerts. TODO: OSC integration to support pro music hardware, sample mixer integrated with physics system (collisions trigger sounds), particles, multiple full screen windows and camera switching driver input.

Blenderartists thread

pyppet 1.9.3b source code

Update

linux install guide

feature requests approved:

• "assign multiple movement and rotation controls to one OSC input"


• "adjust scale, and attack/release function" (callbacks)

Pyppet2 - Biped Solver - Part2

 def update(self, context):
  AbstractArmature.update(self,context)

  step_left = step_right = False

  if not self.left_foot_loc:
   self.left_foot_loc = self.left_foot.shadow_parent.location
   step_left = True
  if not self.right_foot_loc:
   self.right_foot_loc = self.right_foot.shadow_parent.location
   step_right = True

  x,y,z = self.chest.get_velocity_local()

  sideways = None
  sideways_rate = abs( x )
  if x < -2: sideways = 'RIGHT'
  elif x > 2: sideways = 'LEFT'

  moving = None
  motion_rate = abs( y )
  if y < -0.5: moving = 'FORWARD'
  elif y > 0.5: moving = 'BACKWARD'

  loc,rot,scl = self.pelvis.shadow.matrix_world.decompose()
  euler = rot.to_euler()
  tilt = sum( [abs(math.degrees(euler.x)), abs(math.degrees(euler.y))] ) / 2.0  # 0-45


  x,y,z = self.pelvis.get_location()
  current_pelvis_height = z
  falling = current_pelvis_height < self.pelvis.rest_height * (1.0-self.standing_height_threshold)

  hx,hy,hz = self.head.get_location()
  x = (x+hx)/2.0
  y = (y+hy)/2.0
  ob = self.pelvis.shadow
  ob.location = (x,y,-0.5)
  loc,rot,scale = ob.matrix_world.decompose()
  euler = rot.to_euler()

  heading = math.degrees( euler.z )
  spin = self.prev_heading - heading
  self.prev_heading = heading
  turning = None
  turning_rate =  abs(spin) #/ 360.0
  if abs(spin) < 300: # ignore euler flip
   if spin < -1.0: turning = 'LEFT'
   elif spin > 1.0: turning = 'RIGHT'


  if turning == 'LEFT':
   if moving == 'BACKWARD':
    self.left_foot.shadow.location.x = -(motion_rate * 0.25)
    self.right_foot.shadow.location.x = -0.5

   elif moving == 'FORWARD':
    self.left_foot.shadow.location.x = 0.1
    self.right_foot.shadow.location.x = 0.2
    if motion_rate > 2:
     if random() > 0.8:
      step_right = True
      self.left_foot.shadow.location.x = -(motion_rate * 0.25)
     self.right_foot.shadow.location.x = motion_rate * 0.25

   if not step_right and random() > 0.2:
    if random() > 0.1: step_left = True
    else: step_right = True

  elif turning == 'RIGHT':
   if moving == 'BACKWARD':
    self.right_foot.shadow.location.x = -(motion_rate * 0.25)
    self.left_foot.shadow.location.x = -0.5

   elif moving == 'FORWARD':
    self.right_foot.shadow.location.x = 0.1
    self.left_foot.shadow.location.x = 0.2
    if motion_rate > 2:
     if random() > 0.8:
      step_left = True
      self.right_foot.shadow.location.x = -(motion_rate * 0.25)
     self.left_foot.shadow.location.x = motion_rate * 0.25

   if not step_left and random() > 0.2:
    if random() > 0.1: step_right = True
    else: step_left = True


  hand_swing_targets = []
  v = self.left_hand.biped_solver['swing-target'].location
  hand_swing_targets.append( v )
  v.x = -( self.left_foot.biped_solver['target'].location.x )

  v = self.right_hand.biped_solver['swing-target'].location
  hand_swing_targets.append( v )
  v.x = -( self.right_foot.biped_solver['target'].location.x )

  v = self.left_foot.biped_solver['target'].location
  if v.x < 0:  # if foot moving backward only pull on heel/foot
   self.left_toe.biped_solver['TARGET'].weight = 0.0
  elif v.x > 0: # if foot moving forward only pull on toe
   self.left_foot.biped_solver['TARGET'].weight = 0.0

  v = self.right_foot.biped_solver['target'].location
  if v.x < 0:  # if foot moving backward only pull on heel/foot
   self.right_toe.biped_solver['TARGET'].weight = 0.0
  elif v.x > 0: # if foot moving forward only pull on toe
   self.right_foot.biped_solver['TARGET'].weight = 0.0


  if moving == 'BACKWARD': # hands forward if moving backwards
   for v in hand_swing_targets: v.x += 0.1

  if step_left:
   rad = euler.z - math.radians(90+self.primary_heading)
   cx = math.sin( -rad )
   cy = math.cos( -rad )
   v = self.left_foot.shadow_parent.location
   v.x = x+cx
   v.y = y+cy
   v.z = .0
   self.left_foot_loc = v
  if step_right:
   rad = euler.z + math.radians(90+self.primary_heading)
   cx = math.sin( -rad )
   cy = math.cos( -rad )
   v = self.right_foot.shadow_parent.location
   v.x = x+cx
   v.y = y+cy
   v.z = .0
   self.right_foot_loc = v


  #################### falling ####################
  if falling:

   if current_pelvis_height < 0.2:
    for foot in (self.left_foot, self.right_foot):
     target = foot.biped_solver[ 'TARGET:pelvis' ]
     if target.weight < 50: target.weight += 1.0

     foot.add_local_torque( -30, 0, 0 )

   else:
    for foot in (self.left_foot, self.right_foot):
     target = foot.biped_solver[ 'TARGET:pelvis' ]
     target.weight *= 0.9


   for target in self.foot_solver_targets: # reduce foot step force
    target.weight *= 0.9

   #for target in self.hand_solver_targets: # increase hand plant force
   # if target.weight < self.when_falling_hand_target_goal_weight:
   #  target.weight += 1

   for hand in (self.left_hand, self.right_hand):
    self.head.add_local_torque( -self.when_falling_head_curl, 0, 0 )
    u = self.when_falling_pull_hands_down_by_tilt_factor * tilt
    hand.add_force( 0,0, -u )

    x,y,z = hand.get_location()
    if z < 0.1:
     self.head.add_force( 
      0,
      0, 
      tilt * self.when_falling_and_hands_down_lift_head_by_tilt_factor
     )
     hand.add_local_force( 0, -10, 0 )
    else:
     hand.add_local_force( 0, 3, 0 )

  else: # standing

   for foot in (self.left_foot, self.right_foot):
    target = foot.biped_solver[ 'TARGET:pelvis' ]
    target.weight *= 0.9


   for target in self.foot_solver_targets:
    if target.weight < self.when_standing_foot_target_goal_weight:
     target.weight += 1

   #for target in self.hand_solver_targets: # reduce hand plant force
   # target.weight *= 0.9


   head_lift = self.when_standing_head_lift
   for toe in ( self.left_toe, self.right_toe ):
    x,y,z = toe.get_location()
    if z < 0.1:
     self.head.add_force( 0,0, head_lift*0.5 )

   ## lift feet ##
   foot = self.left_foot
   v1 = foot.get_location().copy()
   if v1.z < 0.1: self.head.add_force( 0,0, head_lift*0.5 )

   v2 = self.left_foot_loc.copy()
   v1.z = .0; v2.z = .0
   dist = (v1 - v2).length
   if dist > 0.5:
    foot.add_force( 0, 0, self.when_standing_foot_step_far_lift)
   elif dist < 0.25:
    foot.add_force( 0, 0, -self.when_standing_foot_step_near_pull)

   foot = self.right_foot
   v1 = foot.get_location().copy()
   if v1.z < 0.1: self.head.add_force( 0,0, head_lift*0.5 )

   v2 = self.right_foot_loc.copy()
   v1.z = .0; v2.z = .0
   dist = (v1 - v2).length
   if dist > 0.5:
    foot.add_force( 0, 0, self.when_standing_foot_step_far_lift)
   elif dist < 0.25:
    foot.add_force( 0, 0, -self.when_standing_foot_step_near_pull)