cortex: org/body.org comparison

comparison org/body.org @ 209:e49c690d2bcf

minor edits.

author	Robert McIntyre <rlm@mit.edu>
date	Thu, 09 Feb 2012 05:02:21 -0700
parents	bb3b75bf1664
children	384ed3437948

comparison

equal deleted inserted replaced

-:30bd811c5dcb
+:e49c690d2bcf
 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
+retractable claws or EVE's hands, which are able to coalece into one
-in the movie.
+object in the movie.
 * Solidifying the Body
 Here is a hand designed eve-style in blender.
 You will notice that the hand has no physical presence -- it's a
 hologram through which 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
+specify the mass of each object as meta-data in blender and construct
-shape based on the mesh in jMonkeyEngine.
+the physics shape based on the mesh in jMonkeyEngine.
 #+name: body-1
 #+begin_src clojure
 (defn physical!
 "Iterate through the nodes in creature and make them real physical
 #+name: test-2
 #+begin_src clojure
 (in-ns 'cortex.test.body)
-(def normal-gravity
+(def gravity-control
 {"key-g" (fn [world _]
-(set-gravity world (Vector3f. 0 -9.81 0)))})
+(set-gravity world (Vector3f. 0 -9.81 0)))
+"key-u" (fn [world _] (set-gravity world Vector3f/ZERO))})
 (defn floor []
 (box 10 3 10 :position (Vector3f. 0 -10 0)
 :color ColorRGBA/Gray :mass 0))
 (defn test-two []
 (world (nodify
 [(doto (hand)
 (physical!))
 (floor)])
-(merge standard-debug-controls normal-gravity)
+(merge standard-debug-controls gravity-control)
 (comp
 #(Capture/captureVideo
 % (File. "/home/r/proj/cortex/render/body/2"))
 #(do (set-gravity % Vector3f/ZERO) %)
 setup)
 Now that's some progress.
 * Joints
-Obviously, an AI is not going to be doing much just lying in pieces on
+Obviously, an AI is not going to be doing much while lying in pieces
-the floor.  So, the next step to making a proper body is to connect
+on the floor.  So, the next step to making a proper body is to connect
 those pieces together with joints.  jMonkeyEngine has a large array of
 joints available via bullet, such as Point2Point, Cone, Hinge, and a
 generic Six Degree of Freedom joint, with or without spring
 restitution.
 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
+#+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
+The higher order function =(sense-nodes)= from =cortex.sense= simplifies
+the first task.
 #+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
 (loop [radius (float 0.01)]
 (let [results (CollisionResults.)]
 (.collideWith
 parts
 (BoundingBox. (.getWorldTranslation joint)
-radius radius radius)
+radius radius radius) results)
-results)
 (let [targets
 (distinct
 (map  #(.getGeometry %) results))]
 (if (>= (count targets) 2)
 (sort-by
-#(let [v
+#(let [joint-ref-frame-position
 (jme-to-blender
 (.mult
 (.inverse (.getWorldRotation joint))
 (.subtract (.getWorldTranslation %)
 (.getWorldTranslation joint))))]
-(println-repl (.getName %) ":" v)
+(.dot (Vector3f. 1 1 1) joint-ref-frame-position))
-(.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
+This section 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
 pivot-a pivot-b
 joint-rotation))
 (println-repl "could not find joint meta-data!"))))
 #+end_src
-Creating joints is now a matter applying =(connect)= to each joint
+Creating joints is now a matter of applying =(connect)= to each joint
 node.
 #+name: joints-5
 #+begin_src clojure
 (defn joints!
 #+begin_src clojure
 (in-ns 'cortex.test.body)
 (def debug-control
 {"key-h" (fn [world val]
-(if val (enable-debug world)))
+(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)
+gravity-control)
 (comp
 #(Capture/captureVideo
 % (File. "/home/r/proj/cortex/render/body/3"))
 #(do (set-gravity % Vector3f/ZERO) %)
 setup)
 <p>This worm model will be the platform onto which future senses will
 be grafted.</p>
 </div>
 #+end_html
-* Bookkeeping
+* Headers
-Headers; here for completeness.
 #+name: body-header
 #+begin_src clojure
 (ns cortex.body
 "Assemble a physical creature using the definitions found in a
 specially prepared blender file. Creates rigid bodies and joints so
 * Source
 - [[../src/cortex/body.clj][cortex.body]]
 - [[../src/cortex/test/body.clj][cortex.test.body]]
 - [[../assets/Models/test-creature/hand.blend][hand.blend]]
+- [[../assets/Models/test-creature/palm.png][UV-map-1]]
 - [[../assets/Models/test-creature/worm.blend][worm.blend]]
 - [[../assets/Models/test-creature/retina-small.png][UV-map-1]]
 - [[../assets/Models/test-creature/tip.png][UV-map-2]]
 * COMMENT Generate Source

Mercurial > cortex

comparison org/body.org @ 209:e49c690d2bcf