cortex: org/body.org comparison

comparison org/body.org @ 203:0e5d5ee5a914

first draft of body.org complete

author	Robert McIntyre <rlm@mit.edu>
date	Wed, 08 Feb 2012 08:53:12 -0700
parents	d5c597a7aed4
children	162b24a82712

comparison

equal deleted inserted replaced

-:d5c597a7aed4
+:0e5d5ee5a914
 #+caption: EVE from the movie WALL-E.  This body plan turns out to be much better suited to my purposes than a more human-like one.
 [[../images/Eve.jpg]]
 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="755"
-#+attr_html: width="500"
 [[../images/hand-screenshot0.png]]
 If we load it directly into jMonkeyEngine, we get this:
 #+name: test-0
 #+begin_src clojure :results silent
 (.start (cortex.test.body/test-one))
 #+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
 hologram through witch everything passes.  Therefore, the first thing
 to do is to make it solid.  Blender has physics simulation on par with
 jMonkeyEngine (they both use bullet as their physics backend), but it
 can be difficult to translate between the two systems, so for now I
 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
 objects in the simulation."
 [#^Node creature]
 =(physical!)= iterates through a creature's node structure, creating
 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)
 (def normal-gravity
 {"key-g" (fn [world _]
 setup)
 no-op))
 #+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.
 So, I will use the same system for specifying joints as I will do for
 some senses.  Each joint is specified by an empty node whose parent
 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:
-#+name: joints-2
+- 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
+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
 from bottom to top according to the joint's rotation."
 [#^Node parts #^Node joint]
 (println-repl (.getName %) ":" v)
 (.dot (Vector3f. 1 1 1)
 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 & _]
 (:type constraints)))
 control-b
 pivot-a
 pivot-b
 false)
 (.setLinearLowerLimit Vector3f/ZERO)
-(.setLinearUpperLimit Vector3f/ZERO)
+(.setLinearUpperLimit Vector3f/ZERO)))
-;;(.setAngularLowerLimit (Vector3f. 1 1 1))
-;;(.setAngularUpperLimit (Vector3f. 0 0 0))
-))
 (defmethod joint-dispatch :hinge
 [constraints control-a control-b pivot-a pivot-b rotation]
 (println-repl "creating HINGE joint")
 (let [axis
 (joint-dispatch constraints
 control-a control-b
 pivot-a pivot-b
 joint-rotation))
 (println-repl "could not find joint meta-data!"))))
+#+end_src
-(defvar
-^{:arglists '([creature])}
+Creating joints is now a matter applying =(connect)= to each joint
-joints
+node.
-(sense-nodes "joints")
-"Return the children of the creature's \"joints\" 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."
 [#^Node creature]
 (dorun
 (map
 (fn [joint]
 (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
 determined in blender."
 [#^Node creature]
 (physical! creature)
 (joints! creature))
 #+end_src
 * Bookkeeping
+Header; here for completeness.
 #+name: body-0
 #+begin_src clojure
 (ns cortex.body
 "Assemble a physical creature using the definitions found in a
 com.jme3.scene.Geometry
 com.jme3.bullet.collision.shapes.HullCollisionShape))
 #+end_src
 * Source
+Dylan -- I'll fill these in later
+- cortex.body
+- cortex.test.body
+- blender files
 * COMMENT Examples
 #+name: test-body
 #+begin_src clojure

Mercurial > cortex

comparison org/body.org @ 203:0e5d5ee5a914