Mercurial > cortex

annotate org/body.org @ 207:bb3b75bf1664

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
fixed source links
author Robert McIntyre <rlm@mit.edu>
date Thu, 09 Feb 2012 04:28:31 -0700
parents df46a609fed9
children e49c690d2bcf
rev   line source
rlm@202 1 #+title: Building a Body
rlm@0 2 #+author: Robert McIntyre
rlm@0 3 #+email: rlm@mit.edu
rlm@4 4 #+description: Simulating a body (movement, touch, propioception) in jMonkeyEngine3.
rlm@4 5 #+SETUPFILE: ../../aurellem/org/setup.org
rlm@4 6 #+INCLUDE: ../../aurellem/org/level-0.org
rlm@4 7
rlm@202 8 * Design Constraints
rlm@202 9
rlm@202 10 I use [[www.blender.org/][blender]] to design bodies. The design of the bodies is
rlm@202 11 determined by the requirements of the AI that will use them. The
rlm@202 12 bodies must be easy for an AI to sense and control, and they must be
rlm@202 13 relatively simple for jMonkeyEngine to compute.
rlm@202 14
rlm@202 15 ** Bag of Bones
rlm@202 16
rlm@202 17 How to create such a body? One option I ultimately rejected is to use
rlm@202 18 blender's [[http://wiki.blender.org/index.php/Doc:2.6/Manual/Rigging/Armatures][armature]] system. The idea would have been to define a mesh
rlm@202 19 which describes the creature's entire body. To this you add an
rlm@202 20 (skeleton) which deforms this mesh. This technique is used extensively
rlm@202 21 to model humans and create realistic animations. It is hard to use for
rlm@202 22 my purposes because it is difficult to update the creature's Physics
rlm@202 23 Collision Mesh in tandem with its Geometric Mesh under the influence
rlm@202 24 of the armature. Withouth this the creature will not be able to grab
rlm@202 25 things in its environment, and it won't be able to tell where its
rlm@202 26 physical body is by using its eyes. Also, armatures do not specify
rlm@202 27 any rotational limits for a joint, making it hard to model elbows,
rlm@202 28 shoulders, etc.
rlm@202 29
rlm@202 30 ** EVE
rlm@202 31
rlm@202 32 Instead of using the human-like "deformable bag of bones" approach, I
rlm@202 33 decided to base my body plans on the robot EVE from the movie wall-E.
rlm@202 34
rlm@202 35 #+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.
rlm@202 36 [[../images/Eve.jpg]]
rlm@202 37
rlm@204 38 EVE's body is composed of several rigid components that are held
rlm@204 39 together by invisible joint constraints. This is what I mean by
rlm@204 40 "eve-like". The main reason that I use eve-style bodies is so that
rlm@204 41 there will be correspondence between the AI's vision and the physical
rlm@204 42 presence of its body. Each individual section is simulated by a
rlm@204 43 separate rigid body that corresponds exactly with its visual
rlm@204 44 representation and does not change. Sections are connected by
rlm@204 45 invisible joints that are well supported in jMonkyeEngine. Bullet, the
rlm@204 46 physics backend for jMonkeyEngine, can efficiently simulate hundreds
rlm@204 47 of rigid bodies connected by joints. Sections do not have to stay as
rlm@204 48 one piece forever; they can be dynamically replaced with multiple
rlm@204 49 sections to simulate splitting in two. This could be used to simulate
rlm@204 50 retractable claws or EVE's hands, which could coalece into one object
rlm@204 51 in the movie.
rlm@202 52
rlm@202 53 * Solidifying the Body
rlm@202 54
rlm@202 55 Here is a hand designed eve-style in blender.
rlm@202 56
rlm@203 57 #+attr_html: width="755"
rlm@202 58 [[../images/hand-screenshot0.png]]
rlm@202 59
rlm@202 60 If we load it directly into jMonkeyEngine, we get this:
rlm@202 61
rlm@205 62 #+name: test-1
rlm@202 63 #+begin_src clojure
rlm@202 64 (def hand-path "Models/test-creature/hand.blend")
rlm@202 65
rlm@202 66 (defn hand [] (load-blender-model hand-path))
rlm@202 67
rlm@202 68 (defn setup [world]
rlm@202 69 (let [cam (.getCamera world)]
rlm@202 70 (println-repl cam)
rlm@202 71 (.setLocation
rlm@202 72 cam (Vector3f.
rlm@202 73 -6.9015837, 8.644911, 5.6043186))
rlm@202 74 (.setRotation
rlm@202 75 cam
rlm@202 76 (Quaternion.
rlm@202 77 0.14046453, 0.85894054, -0.34301838, 0.3533118)))
rlm@202 78 (light-up-everything world)
rlm@202 79 (.setTimer world (RatchetTimer. 60))
rlm@202 80 world)
rlm@202 81
rlm@202 82 (defn test-one []
rlm@202 83 (world (hand)
rlm@202 84 standard-debug-controls
rlm@202 85 (comp
rlm@202 86 #(Capture/captureVideo
rlm@202 87 % (File. "/home/r/proj/cortex/render/body/1"))
rlm@202 88 setup)
rlm@202 89 no-op))
rlm@202 90 #+end_src
rlm@202 91
rlm@202 92
rlm@202 93 #+begin_src clojure :results silent
rlm@202 94 (.start (cortex.test.body/test-one))
rlm@202 95 #+end_src
rlm@202 96
rlm@202 97 #+begin_html
rlm@203 98 <div class="figure">
rlm@203 99 <center>
rlm@203 100 <video controls="controls" width="640">
rlm@202 101 <source src="../video/ghost-hand.ogg" type="video/ogg"
rlm@202 102 preload="none" poster="../images/aurellem-1280x480.png" />
rlm@202 103 </video>
rlm@203 104 </center>
rlm@203 105 <p>The hand model directly loaded from blender. It has no physical
rlm@203 106 presense in the simulation. </p>
rlm@203 107 </div>
rlm@202 108 #+end_html
rlm@202 109
rlm@202 110 You will notice that the hand has no physical presence -- it's a
rlm@204 111 hologram through which everything passes. Therefore, the first thing
rlm@202 112 to do is to make it solid. Blender has physics simulation on par with
rlm@202 113 jMonkeyEngine (they both use bullet as their physics backend), but it
rlm@202 114 can be difficult to translate between the two systems, so for now I
rlm@202 115 specify the mass of each object in blender and construct the physics
rlm@202 116 shape based on the mesh in jMonkeyEngine.
rlm@202 117
rlm@203 118 #+name: body-1
rlm@202 119 #+begin_src clojure
rlm@202 120 (defn physical!
rlm@202 121 "Iterate through the nodes in creature and make them real physical
rlm@202 122 objects in the simulation."
rlm@202 123 [#^Node creature]
rlm@202 124 (dorun
rlm@202 125 (map
rlm@202 126 (fn [geom]
rlm@202 127 (let [physics-control
rlm@202 128 (RigidBodyControl.
rlm@202 129 (HullCollisionShape.
rlm@202 130 (.getMesh geom))
rlm@202 131 (if-let [mass (meta-data geom "mass")]
rlm@202 132 (do
rlm@202 133 (println-repl
rlm@202 134 "setting" (.getName geom) "mass to" (float mass))
rlm@202 135 (float mass))
rlm@202 136 (float 1)))]
rlm@202 137 (.addControl geom physics-control)))
rlm@202 138 (filter #(isa? (class %) Geometry )
rlm@202 139 (node-seq creature)))))
rlm@202 140 #+end_src
rlm@202 141
rlm@202 142 =(physical!)= iterates through a creature's node structure, creating
rlm@202 143 CollisionShapes for each geometry with the mass specified in that
rlm@202 144 geometry's meta-data.
rlm@202 145
rlm@205 146 #+name: test-2
rlm@0 147 #+begin_src clojure
rlm@202 148 (in-ns 'cortex.test.body)
rlm@160 149
rlm@202 150 (def normal-gravity
rlm@202 151 {"key-g" (fn [world _]
rlm@202 152 (set-gravity world (Vector3f. 0 -9.81 0)))})
rlm@202 153
rlm@202 154 (defn floor []
rlm@202 155 (box 10 3 10 :position (Vector3f. 0 -10 0)
rlm@202 156 :color ColorRGBA/Gray :mass 0))
rlm@202 157
rlm@202 158 (defn test-two []
rlm@202 159 (world (nodify
rlm@202 160 [(doto (hand)
rlm@202 161 (physical!))
rlm@202 162 (floor)])
rlm@202 163 (merge standard-debug-controls normal-gravity)
rlm@202 164 (comp
rlm@202 165 #(Capture/captureVideo
rlm@202 166 % (File. "/home/r/proj/cortex/render/body/2"))
rlm@202 167 #(do (set-gravity % Vector3f/ZERO) %)
rlm@202 168 setup)
rlm@202 169 no-op))
rlm@202 170 #+end_src
rlm@202 171
rlm@202 172 #+begin_html
rlm@203 173 <div class="figure">
rlm@203 174 <center>
rlm@203 175 <video controls="controls" width="640">
rlm@202 176 <source src="../video/crumbly-hand.ogg" type="video/ogg"
rlm@202 177 preload="none" poster="../images/aurellem-1280x480.png" />
rlm@202 178 </video>
rlm@203 179 </center>
rlm@203 180 <p>The hand now has a physical presence, but there is nothing to hold
rlm@203 181 it together.</p>
rlm@203 182 </div>
rlm@202 183 #+end_html
rlm@202 184
rlm@202 185 Now that's some progress.
rlm@202 186
rlm@202 187 * Joints
rlm@202 188
rlm@202 189 Obviously, an AI is not going to be doing much just lying in pieces on
rlm@202 190 the floor. So, the next step to making a proper body is to connect
rlm@202 191 those pieces together with joints. jMonkeyEngine has a large array of
rlm@202 192 joints available via bullet, such as Point2Point, Cone, Hinge, and a
rlm@202 193 generic Six Degree of Freedom joint, with or without spring
rlm@202 194 restitution.
rlm@202 195
rlm@202 196 Although it should be possible to specify the joints using blender's
rlm@202 197 physics system, and then automatically import them with jMonkeyEngine,
rlm@202 198 the support isn't there yet, and there are a few problems with bullet
rlm@202 199 itself that need to be solved before it can happen.
rlm@202 200
rlm@202 201 So, I will use the same system for specifying joints as I will do for
rlm@202 202 some senses. Each joint is specified by an empty node whose parent
rlm@202 203 has the name "joints". Their orientation and meta-data determine what
rlm@202 204 joint is created.
rlm@202 205
rlm@203 206 #+attr_html: width="755"
rlm@203 207 #+caption: joints hack in blender. Each empty node here will be transformed into a joint in jMonkeyEngine
rlm@202 208 [[../images/hand-screenshot1.png]]
rlm@202 209
rlm@203 210 The empty node in the upper right, highlighted in yellow, is the
rlm@203 211 parent node of all the emptys which represent joints. The following
rlm@203 212 functions must do three things to translate these into real joints:
rlm@202 213
rlm@203 214 - Find the children of the "joints" node.
rlm@203 215 - Determine the two spatials the joint it meant to connect.
rlm@203 216 - Create the joint based on the meta-data of the empty node.
rlm@202 217
rlm@203 218 ** Finding the Joints
rlm@203 219 #+name: joints-2
rlm@203 220 #+begin_src clojure
rlm@203 221 (defvar
rlm@203 222 ^{:arglists '([creature])}
rlm@203 223 joints
rlm@203 224 (sense-nodes "joints")
rlm@203 225 "Return the children of the creature's \"joints\" node.")
rlm@203 226 #+end_src
rlm@202 227
rlm@203 228 The higher order function =(sense-nodes)= from cortex.sense makes our
rlm@203 229 first task very easy.
rlm@203 230
rlm@203 231 ** Joint Targets and Orientation
rlm@203 232
rlm@203 233 This technique for finding a joint's targets is very similiar to
rlm@203 234 =(cortex.sense/closest-node)=. A small cube, centered around the
rlm@203 235 empty-node, grows exponentially until it intersects two /physical/
rlm@203 236 objects. The objects are ordered according to the joint's rotation,
rlm@203 237 with the first one being the object that has more negative coordinates
rlm@203 238 in the joint's reference frame. Since the objects must be physical,
rlm@203 239 the empty-node itself escapes detection. Because the objects must be
rlm@203 240 physical, =(joint-targets)= must be called /after/ =(physical!)= is
rlm@203 241 called.
rlm@203 242
rlm@203 243 #+name: joints-3
rlm@202 244 #+begin_src clojure
rlm@135 245 (defn joint-targets
rlm@135 246 "Return the two closest two objects to the joint object, ordered
rlm@135 247 from bottom to top according to the joint's rotation."
rlm@135 248 [#^Node parts #^Node joint]
rlm@135 249 (loop [radius (float 0.01)]
rlm@135 250 (let [results (CollisionResults.)]
rlm@135 251 (.collideWith
rlm@135 252 parts
rlm@135 253 (BoundingBox. (.getWorldTranslation joint)
rlm@135 254 radius radius radius)
rlm@135 255 results)
rlm@135 256 (let [targets
rlm@135 257 (distinct
rlm@135 258 (map #(.getGeometry %) results))]
rlm@135 259 (if (>= (count targets) 2)
rlm@135 260 (sort-by
rlm@135 261 #(let [v
rlm@135 262 (jme-to-blender
rlm@135 263 (.mult
rlm@135 264 (.inverse (.getWorldRotation joint))
rlm@135 265 (.subtract (.getWorldTranslation %)
rlm@135 266 (.getWorldTranslation joint))))]
rlm@135 267 (println-repl (.getName %) ":" v)
rlm@135 268 (.dot (Vector3f. 1 1 1)
rlm@135 269 v))
rlm@135 270 (take 2 targets))
rlm@135 271 (recur (float (* radius 2))))))))
rlm@203 272 #+end_src
rlm@135 273
rlm@203 274 ** Generating Joints
rlm@203 275
rlm@203 276 This long chunk of code iterates through all the different ways of
rlm@203 277 specifying joints using blender meta-data and converts each one to the
rlm@203 278 appropriate jMonkyeEngine joint.
rlm@203 279
rlm@203 280 #+name: joints-4
rlm@203 281 #+begin_src clojure
rlm@160 282 (defmulti joint-dispatch
rlm@160 283 "Translate blender pseudo-joints into real JME joints."
rlm@160 284 (fn [constraints & _]
rlm@160 285 (:type constraints)))
rlm@141 286
rlm@160 287 (defmethod joint-dispatch :point
rlm@160 288 [constraints control-a control-b pivot-a pivot-b rotation]
rlm@160 289 (println-repl "creating POINT2POINT joint")
rlm@160 290 ;; bullet's point2point joints are BROKEN, so we must use the
rlm@160 291 ;; generic 6DOF joint instead of an actual Point2Point joint!
rlm@141 292
rlm@160 293 ;; should be able to do this:
rlm@160 294 (comment
rlm@160 295 (Point2PointJoint.
rlm@160 296 control-a
rlm@160 297 control-b
rlm@160 298 pivot-a
rlm@160 299 pivot-b))
rlm@141 300
rlm@160 301 ;; but instead we must do this:
rlm@160 302 (println-repl "substuting 6DOF joint for POINT2POINT joint!")
rlm@160 303 (doto
rlm@160 304 (SixDofJoint.
rlm@160 305 control-a
rlm@160 306 control-b
rlm@160 307 pivot-a
rlm@160 308 pivot-b
rlm@160 309 false)
rlm@160 310 (.setLinearLowerLimit Vector3f/ZERO)
rlm@203 311 (.setLinearUpperLimit Vector3f/ZERO)))
rlm@160 312
rlm@160 313 (defmethod joint-dispatch :hinge
rlm@160 314 [constraints control-a control-b pivot-a pivot-b rotation]
rlm@160 315 (println-repl "creating HINGE joint")
rlm@160 316 (let [axis
rlm@160 317 (if-let
rlm@160 318 [axis (:axis constraints)]
rlm@160 319 axis
rlm@160 320 Vector3f/UNIT_X)
rlm@160 321 [limit-1 limit-2] (:limit constraints)
rlm@160 322 hinge-axis
rlm@160 323 (.mult
rlm@160 324 rotation
rlm@160 325 (blender-to-jme axis))]
rlm@160 326 (doto
rlm@160 327 (HingeJoint.
rlm@160 328 control-a
rlm@160 329 control-b
rlm@160 330 pivot-a
rlm@160 331 pivot-b
rlm@160 332 hinge-axis
rlm@160 333 hinge-axis)
rlm@160 334 (.setLimit limit-1 limit-2))))
rlm@160 335
rlm@160 336 (defmethod joint-dispatch :cone
rlm@160 337 [constraints control-a control-b pivot-a pivot-b rotation]
rlm@160 338 (let [limit-xz (:limit-xz constraints)
rlm@160 339 limit-xy (:limit-xy constraints)
rlm@160 340 twist (:twist constraints)]
rlm@160 341
rlm@160 342 (println-repl "creating CONE joint")
rlm@160 343 (println-repl rotation)
rlm@160 344 (println-repl
rlm@160 345 "UNIT_X --> " (.mult rotation (Vector3f. 1 0 0)))
rlm@160 346 (println-repl
rlm@160 347 "UNIT_Y --> " (.mult rotation (Vector3f. 0 1 0)))
rlm@160 348 (println-repl
rlm@160 349 "UNIT_Z --> " (.mult rotation (Vector3f. 0 0 1)))
rlm@160 350 (doto
rlm@160 351 (ConeJoint.
rlm@160 352 control-a
rlm@160 353 control-b
rlm@160 354 pivot-a
rlm@160 355 pivot-b
rlm@160 356 rotation
rlm@160 357 rotation)
rlm@160 358 (.setLimit (float limit-xz)
rlm@160 359 (float limit-xy)
rlm@160 360 (float twist)))))
rlm@160 361
rlm@160 362 (defn connect
rlm@175 363 "Create a joint between 'obj-a and 'obj-b at the location of
rlm@175 364 'joint. The type of joint is determined by the metadata on 'joint.
rlm@175 365
rlm@175 366 Here are some examples:
rlm@160 367 {:type :point}
rlm@160 368 {:type :hinge :limit [0 (/ Math/PI 2)] :axis (Vector3f. 0 1 0)}
rlm@160 369 (:axis defaults to (Vector3f. 1 0 0) if not provided for hinge joints)
rlm@160 370
rlm@160 371 {:type :cone :limit-xz 0]
rlm@160 372 :limit-xy 0]
rlm@160 373 :twist 0]} (use XZY rotation mode in blender!)"
rlm@160 374 [#^Node obj-a #^Node obj-b #^Node joint]
rlm@160 375 (let [control-a (.getControl obj-a RigidBodyControl)
rlm@160 376 control-b (.getControl obj-b RigidBodyControl)
rlm@160 377 joint-center (.getWorldTranslation joint)
rlm@160 378 joint-rotation (.toRotationMatrix (.getWorldRotation joint))
rlm@160 379 pivot-a (world-to-local obj-a joint-center)
rlm@160 380 pivot-b (world-to-local obj-b joint-center)]
rlm@160 381
rlm@160 382 (if-let [constraints
rlm@160 383 (map-vals
rlm@160 384 eval
rlm@160 385 (read-string
rlm@160 386 (meta-data joint "joint")))]
rlm@160 387 ;; A side-effect of creating a joint registers
rlm@160 388 ;; it with both physics objects which in turn
rlm@160 389 ;; will register the joint with the physics system
rlm@160 390 ;; when the simulation is started.
rlm@160 391 (do
rlm@160 392 (println-repl "creating joint between"
rlm@160 393 (.getName obj-a) "and" (.getName obj-b))
rlm@160 394 (joint-dispatch constraints
rlm@160 395 control-a control-b
rlm@160 396 pivot-a pivot-b
rlm@160 397 joint-rotation))
rlm@160 398 (println-repl "could not find joint meta-data!"))))
rlm@203 399 #+end_src
rlm@160 400
rlm@203 401 Creating joints is now a matter applying =(connect)= to each joint
rlm@203 402 node.
rlm@160 403
rlm@205 404 #+name: joints-5
rlm@203 405 #+begin_src clojure
rlm@175 406 (defn joints!
rlm@175 407 "Connect the solid parts of the creature with physical joints. The
rlm@175 408 joints are taken from the \"joints\" node in the creature."
rlm@175 409 [#^Node creature]
rlm@160 410 (dorun
rlm@160 411 (map
rlm@160 412 (fn [joint]
rlm@175 413 (let [[obj-a obj-b] (joint-targets creature joint)]
rlm@160 414 (connect obj-a obj-b joint)))
rlm@175 415 (joints creature))))
rlm@203 416 #+end_src
rlm@160 417
rlm@203 418
rlm@203 419 ** Round 3
rlm@203 420
rlm@203 421 Now we can test the hand in all its glory.
rlm@203 422
rlm@205 423 #+name: test-3
rlm@203 424 #+begin_src clojure
rlm@203 425 (in-ns 'cortex.test.body)
rlm@203 426
rlm@203 427 (def debug-control
rlm@203 428 {"key-h" (fn [world val]
rlm@203 429 (if val (enable-debug world)))
rlm@205 430 "key-u" (fn [world _] (set-gravity world Vector3f/ZERO))})
rlm@203 431
rlm@203 432 (defn test-three []
rlm@203 433 (world (nodify
rlm@203 434 [(doto (hand)
rlm@205 435 (physical!)
rlm@205 436 (joints!))
rlm@203 437 (floor)])
rlm@203 438 (merge standard-debug-controls debug-control
rlm@203 439 normal-gravity)
rlm@203 440 (comp
rlm@203 441 #(Capture/captureVideo
rlm@203 442 % (File. "/home/r/proj/cortex/render/body/3"))
rlm@203 443 #(do (set-gravity % Vector3f/ZERO) %)
rlm@203 444 setup)
rlm@203 445 no-op))
rlm@203 446 #+end_src
rlm@203 447
rlm@203 448 =(physical!)= makes the hand solid, then =(joints!)= connects each
rlm@203 449 piece together.
rlm@203 450
rlm@203 451 #+begin_html
rlm@203 452 <div class="figure">
rlm@203 453 <center>
rlm@203 454 <video controls="controls" width="640">
rlm@203 455 <source src="../video/full-hand.ogg" type="video/ogg"
rlm@203 456 preload="none" poster="../images/aurellem-1280x480.png" />
rlm@203 457 </video>
rlm@203 458 </center>
rlm@203 459 <p>Now the hand is physical and has joints.</p>
rlm@203 460 </div>
rlm@203 461 #+end_html
rlm@203 462
rlm@203 463 The joints are visualized as green connections between each segment
rlm@203 464 for debug purposes. You can see that they correspond to the empty
rlm@203 465 nodes in the blender file.
rlm@203 466
rlm@203 467 * Wrap-Up!
rlm@203 468
rlm@203 469 It is convienent to combine =(physical!)= and =(joints!)= into one
rlm@203 470 function that completely creates the creature's physical body.
rlm@203 471
rlm@205 472 #+name: joints-6
rlm@203 473 #+begin_src clojure
rlm@175 474 (defn body!
rlm@175 475 "Endow the creature with a physical body connected with joints. The
rlm@175 476 particulars of the joints and the masses of each pody part are
rlm@175 477 determined in blender."
rlm@175 478 [#^Node creature]
rlm@175 479 (physical! creature)
rlm@175 480 (joints! creature))
rlm@64 481 #+end_src
rlm@63 482
rlm@205 483 * The Worm
rlm@205 484
rlm@205 485 Going forward, I will use a model that is less complicated than the
rlm@205 486 hand. It has two segments and one joint, and I call it the worm. All
rlm@205 487 of the senses described in the following posts will be applied to this
rlm@205 488 worm.
rlm@205 489
rlm@205 490 #+name: test-4
rlm@205 491 #+begin_src clojure
rlm@205 492 (in-ns 'cortex.test.body)
rlm@205 493
rlm@205 494 (defn worm-1 []
rlm@205 495 (let [timer (RatchetTimer. 60)]
rlm@205 496 (world
rlm@205 497 (nodify
rlm@205 498 [(doto
rlm@205 499 (load-blender-model
rlm@205 500 "Models/test-creature/worm.blend")
rlm@205 501 (body!))
rlm@205 502 (floor)])
rlm@205 503 (merge standard-debug-controls debug-control)
rlm@205 504 #(do
rlm@205 505 (speed-up %)
rlm@205 506 (light-up-everything %)
rlm@205 507 (.setTimer % timer)
rlm@205 508 (cortex.util/display-dialated-time % timer)
rlm@205 509 (Capture/captureVideo
rlm@205 510 % (File. "/home/r/proj/cortex/render/body/4")))
rlm@205 511 no-op)))
rlm@205 512 #+end_src
rlm@205 513
rlm@205 514 #+begin_html
rlm@205 515 <div class="figure">
rlm@205 516 <center>
rlm@205 517 <video controls="controls" width="640">
rlm@205 518 <source src="../video/worm-1.ogg" type="video/ogg"
rlm@205 519 preload="none" poster="../images/aurellem-1280x480.png" />
rlm@205 520 </video>
rlm@205 521 </center>
rlm@205 522 <p>This worm model will be the platform onto which future senses will
rlm@205 523 be grafted.</p>
rlm@205 524 </div>
rlm@205 525 #+end_html
rlm@205 526
rlm@202 527 * Bookkeeping
rlm@175 528
rlm@207 529 Headers; here for completeness.
rlm@203 530
rlm@205 531 #+name: body-header
rlm@202 532 #+begin_src clojure
rlm@202 533 (ns cortex.body
rlm@202 534 "Assemble a physical creature using the definitions found in a
rlm@202 535 specially prepared blender file. Creates rigid bodies and joints so
rlm@202 536 that a creature can have a physical presense in the simulation."
rlm@202 537 {:author "Robert McIntyre"}
rlm@202 538 (:use (cortex world util sense))
rlm@202 539 (:use clojure.contrib.def)
rlm@202 540 (:import
rlm@202 541 (com.jme3.math Vector3f Quaternion Vector2f Matrix3f)
rlm@202 542 (com.jme3.bullet.joints
rlm@202 543 SixDofJoint Point2PointJoint HingeJoint ConeJoint)
rlm@202 544 com.jme3.bullet.control.RigidBodyControl
rlm@202 545 com.jme3.collision.CollisionResults
rlm@202 546 com.jme3.bounding.BoundingBox
rlm@202 547 com.jme3.scene.Node
rlm@202 548 com.jme3.scene.Geometry
rlm@202 549 com.jme3.bullet.collision.shapes.HullCollisionShape))
rlm@202 550 #+end_src
rlm@133 551
rlm@205 552 #+name: test-header
rlm@205 553 #+begin_src clojure
rlm@205 554 (ns cortex.test.body
rlm@205 555 (:use (cortex world util body))
rlm@205 556 (:import
rlm@205 557 (com.aurellem.capture Capture RatchetTimer)
rlm@205 558 (com.jme3.math Quaternion Vector3f ColorRGBA)
rlm@205 559 java.io.File))
rlm@205 560 #+end_src
rlm@205 561
rlm@202 562 * Source
rlm@207 563 - [[../src/cortex/body.clj][cortex.body]]
rlm@207 564 - [[../src/cortex/test/body.clj][cortex.test.body]]
rlm@207 565 - [[../assets/Models/test-creature/hand.blend][hand.blend]]
rlm@207 566 - [[../assets/Models/test-creature/worm.blend][worm.blend]]
rlm@207 567 - [[../assets/Models/test-creature/retina-small.png][UV-map-1]]
rlm@207 568 - [[../assets/Models/test-creature/tip.png][UV-map-2]]
rlm@63 569
rlm@206 570 * COMMENT Generate Source
rlm@44 571 #+begin_src clojure :tangle ../src/cortex/body.clj
rlm@205 572 <<body-header>>
rlm@205 573 <<body-1>>
rlm@205 574 <<joints-2>>
rlm@205 575 <<joints-3>>
rlm@205 576 <<joints-4>>
rlm@205 577 <<joints-5>>
rlm@205 578 <<joints-6>>
rlm@0 579 #+end_src
rlm@64 580
rlm@69 581 #+begin_src clojure :tangle ../src/cortex/test/body.clj
rlm@205 582 <<test-header>>
rlm@205 583 <<test-1>>
rlm@205 584 <<test-2>>
rlm@205 585 <<test-3>>
rlm@205 586 <<test-4>>
rlm@64 587 #+end_src
rlm@64 588
rlm@64 589
rlm@0 590
rlm@206 591