# HG changeset patch
# User Robert McIntyre <rlm@mit.edu>
# Date 1328716392 25200
# Node ID 0e5d5ee5a914cf50a73d4bc3b61303f4f6770edb
# Parent  d5c597a7aed47ef78b2e0f52061a35e50fcb1117
first draft of body.org complete

diff -r d5c597a7aed4 -r 0e5d5ee5a914 assets/Models/test-creature/hand.blend
Binary file assets/Models/test-creature/hand.blend has changed
diff -r d5c597a7aed4 -r 0e5d5ee5a914 org/body.org
--- a/org/body.org	Wed Feb 08 05:50:15 2012 -0700
+++ b/org/body.org	Wed Feb 08 08:53:12 2012 -0700
@@ -38,14 +38,22 @@
 
 The main reason that I use eve-style bodies is so that there will be
 correspondence between the AI's vision and the physical presence of
-its body. 
+its body. Each individual section is simulated by a separate rigid
+body that corresponds exactly with its visual representation and does
+not change. Sections are connected by invisible joints that are well
+supported in jMonkyeEngine. Bullet, the physics backend for
+jMonkeyEngine, can efficiently simulate hundreds of rigid bodies
+connected by joints. Sections do not have to stay as one piece
+forever; they can be dynamically replaced with multiple sections to
+simulate splitting in two. This could be used to simulate retractable
+claws or EVE's hands, which could coalece into one object in the
+movie.
 
 * Solidifying the Body
 
 Here is a hand designed eve-style in blender.
 
-
-#+attr_html: width="500"
+#+attr_html: width="755"
 [[../images/hand-screenshot0.png]]
 
 If we load it directly into jMonkeyEngine, we get this:
@@ -92,10 +100,16 @@
 #+end_src
 
 #+begin_html
-<video controls="controls" width="755">
+<div class="figure">
+<center>
+<video controls="controls" width="640">
   <source src="../video/ghost-hand.ogg" type="video/ogg"
 	  preload="none" poster="../images/aurellem-1280x480.png" />
 </video>
+</center>
+<p>The hand model directly loaded from blender. It has no physical
+  presense in the simulation. </p>
+</div>
 #+end_html
 
 You will notice that the hand has no physical presence -- it's a
@@ -106,7 +120,7 @@
 specify the mass of each object in blender and construct the physics
 shape based on the mesh in jMonkeyEngine.
 
-#+name: joints-1
+#+name: body-1
 #+begin_src clojure
 (defn physical!
   "Iterate through the nodes in creature and make them real physical
@@ -134,6 +148,7 @@
 CollisionShapes for each geometry with the mass specified in that
 geometry's meta-data.
 
+#+name: test-1
 #+begin_src clojure 
 (in-ns 'cortex.test.body)
 
@@ -160,10 +175,16 @@
 #+end_src
 
 #+begin_html
-<video controls="controls" width="755">
+<div class="figure">
+<center>
+<video controls="controls" width="640">
   <source src="../video/crumbly-hand.ogg" type="video/ogg"
 	  preload="none" poster="../images/aurellem-1280x480.png" />
 </video>
+</center>
+<p>The hand now has a physical presence, but there is nothing to hold
+it together.</p>
+</div>
 #+end_html
 
 Now that's some progress.
@@ -188,12 +209,44 @@
 has the name "joints". Their orientation and meta-data determine what
 joint is created.
 
+#+attr_html: width="755"
+#+caption: joints hack in blender. Each empty node here will be transformed into a joint in jMonkeyEngine
 [[../images/hand-screenshot1.png]]
 
+The empty node in the upper right, highlighted in yellow, is the
+parent node of all the emptys which represent joints. The following
+functions must do three things to translate these into real joints:
 
+ - Find the children of the "joints" node.
+ - Determine the two spatials the joint it meant to connect.
+ - Create the joint based on the meta-data of the empty node.
 
+** Finding the Joints 
+#+name: joints-2 
+#+begin_src clojure
+(defvar 
+  ^{:arglists '([creature])}
+  joints
+  (sense-nodes "joints")
+  "Return the children of the creature's \"joints\" node.")
+#+end_src
 
-#+name: joints-2
+The higher order function =(sense-nodes)= from cortex.sense makes our
+first task very easy.
+
+** Joint Targets and Orientation
+
+This technique for finding a joint's targets is very similiar to
+=(cortex.sense/closest-node)=.  A small cube, centered around the
+empty-node, grows exponentially until it intersects two /physical/
+objects. The objects are ordered according to the joint's rotation,
+with the first one being the object that has more negative coordinates
+in the joint's reference frame. Since the objects must be physical,
+the empty-node itself escapes detection. Because the objects must be
+physical, =(joint-targets)= must be called /after/ =(physical!)= is
+called.
+
+#+name: joints-3
 #+begin_src clojure 
 (defn joint-targets
   "Return the two closest two objects to the joint object, ordered
@@ -222,7 +275,16 @@
                     v))                  
            (take 2 targets))
           (recur (float (* radius 2))))))))
+#+end_src
 
+** Generating Joints
+
+This long chunk of code iterates through all the different ways of
+specifying joints using blender meta-data and converts each one to the
+appropriate jMonkyeEngine joint.
+
+#+name: joints-4
+#+begin_src clojure
 (defmulti joint-dispatch
   "Translate blender pseudo-joints into real JME joints."
   (fn [constraints & _] 
@@ -252,12 +314,7 @@
        pivot-b
        false)
     (.setLinearLowerLimit Vector3f/ZERO)
-    (.setLinearUpperLimit Vector3f/ZERO)
-    ;;(.setAngularLowerLimit (Vector3f. 1 1 1))
-    ;;(.setAngularUpperLimit (Vector3f. 0 0 0))
-
-))
-
+    (.setLinearUpperLimit Vector3f/ZERO)))
 
 (defmethod joint-dispatch :hinge
   [constraints control-a control-b pivot-a pivot-b rotation]
@@ -345,13 +402,12 @@
                         pivot-a pivot-b
                         joint-rotation))
       (println-repl "could not find joint meta-data!"))))
+#+end_src
 
-(defvar 
-  ^{:arglists '([creature])}
-  joints
-  (sense-nodes "joints")
-  "Return the children of the creature's \"joints\" node.")
+Creating joints is now a matter applying =(connect)= to each joint
+node.
 
+#+begin_src clojure
 (defn joints!
   "Connect the solid parts of the creature with physical joints. The
    joints are taken from the \"joints\" node in the creature."
@@ -362,7 +418,66 @@
       (let [[obj-a obj-b] (joint-targets creature joint)]
         (connect obj-a obj-b joint)))
     (joints creature))))
+#+end_src
 
+
+** Round 3
+
+Now we can test the hand in all its glory.
+
+#+begin_src clojure 
+(in-ns 'cortex.test.body)
+
+(def debug-control 
+  {"key-h" (fn [world val]
+             (if val (enable-debug world)))
+
+   "key-u" (fn [world _] (set-gravity world Vector3f/ZERO))
+   })
+  
+(defn test-three []
+  (world (nodify
+          [(doto (hand)
+           (physical!)
+           (joints!) )
+           (floor)])
+         (merge standard-debug-controls debug-control
+                normal-gravity)
+         (comp
+          #(Capture/captureVideo
+            % (File. "/home/r/proj/cortex/render/body/3"))
+          #(do (set-gravity % Vector3f/ZERO) %)
+          setup)
+         no-op))
+#+end_src
+
+=(physical!)= makes the hand solid, then =(joints!)= connects each
+piece together. 
+
+
+#+begin_html
+<div class="figure">
+<center>
+<video controls="controls" width="640">
+  <source src="../video/full-hand.ogg" type="video/ogg"
+	  preload="none" poster="../images/aurellem-1280x480.png" />
+</video>
+</center>
+<p>Now the hand is physical and has joints.</p>
+</div>
+#+end_html
+
+The joints are visualized as green connections between each segment
+for debug purposes. You can see that they correspond to the empty
+nodes in the blender file.
+
+* Wrap-Up!
+
+It is convienent to combine =(physical!)= and =(joints!)= into one
+function that completely creates the creature's physical body.
+
+#+name: joints-4
+#+begin_src clojure
 (defn body!
   "Endow the creature with a physical body connected with joints.  The
    particulars of the joints and the masses of each pody part are
@@ -374,6 +489,8 @@
 
 * Bookkeeping
 
+Header; here for completeness.
+
 #+name: body-0
 #+begin_src clojure
 (ns cortex.body
@@ -397,6 +514,11 @@
 
 * Source 
 
+Dylan -- I'll fill these in later
+- cortex.body
+- cortex.test.body
+- blender files
+
 * COMMENT Examples
 
 #+name: test-body