Mercurial > cortex

annotate org/body.org @ 215:f283c62bd212

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
fixed long standing problem with orientation of eyes in blender, fleshed out text in vision.org
author Robert McIntyre <rlm@mit.edu>
date Fri, 10 Feb 2012 02:19:24 -0700
parents 97b8caf66824
children 7bf3e3d8fb26
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@209 50 retractable claws or EVE's hands, which are able to coalece into one
rlm@209 51 object 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@209 115 specify the mass of each object as meta-data in blender and construct
rlm@209 116 the physics 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@209 150 (def gravity-control
rlm@202 151 {"key-g" (fn [world _]
rlm@209 152 (set-gravity world (Vector3f. 0 -9.81 0)))
rlm@209 153 "key-u" (fn [world _] (set-gravity world Vector3f/ZERO))})
rlm@209 154
rlm@202 155
rlm@202 156 (defn floor []
rlm@202 157 (box 10 3 10 :position (Vector3f. 0 -10 0)
rlm@202 158 :color ColorRGBA/Gray :mass 0))
rlm@202 159
rlm@202 160 (defn test-two []
rlm@202 161 (world (nodify
rlm@202 162 [(doto (hand)
rlm@202 163 (physical!))
rlm@202 164 (floor)])
rlm@209 165 (merge standard-debug-controls gravity-control)
rlm@202 166 (comp
rlm@202 167 #(Capture/captureVideo
rlm@202 168 % (File. "/home/r/proj/cortex/render/body/2"))
rlm@202 169 #(do (set-gravity % Vector3f/ZERO) %)
rlm@202 170 setup)
rlm@202 171 no-op))
rlm@202 172 #+end_src
rlm@202 173
rlm@202 174 #+begin_html
rlm@203 175 <div class="figure">
rlm@203 176 <center>
rlm@203 177 <video controls="controls" width="640">
rlm@202 178 <source src="../video/crumbly-hand.ogg" type="video/ogg"
rlm@202 179 preload="none" poster="../images/aurellem-1280x480.png" />
rlm@202 180 </video>
rlm@203 181 </center>
rlm@203 182 <p>The hand now has a physical presence, but there is nothing to hold
rlm@203 183 it together.</p>
rlm@203 184 </div>
rlm@202 185 #+end_html
rlm@202 186
rlm@202 187 Now that's some progress.
rlm@202 188
rlm@202 189 * Joints
rlm@202 190
rlm@209 191 Obviously, an AI is not going to be doing much while lying in pieces
rlm@209 192 on the floor. So, the next step to making a proper body is to connect
rlm@202 193 those pieces together with joints. jMonkeyEngine has a large array of
rlm@202 194 joints available via bullet, such as Point2Point, Cone, Hinge, and a
rlm@202 195 generic Six Degree of Freedom joint, with or without spring
rlm@202 196 restitution.
rlm@202 197
rlm@202 198 Although it should be possible to specify the joints using blender's
rlm@202 199 physics system, and then automatically import them with jMonkeyEngine,
rlm@202 200 the support isn't there yet, and there are a few problems with bullet
rlm@202 201 itself that need to be solved before it can happen.
rlm@202 202
rlm@202 203 So, I will use the same system for specifying joints as I will do for
rlm@202 204 some senses. Each joint is specified by an empty node whose parent
rlm@202 205 has the name "joints". Their orientation and meta-data determine what
rlm@202 206 joint is created.
rlm@202 207
rlm@203 208 #+attr_html: width="755"
rlm@209 209 #+caption: Joints hack in blender. Each empty node here will be transformed into a joint in jMonkeyEngine
rlm@202 210 [[../images/hand-screenshot1.png]]
rlm@202 211
rlm@203 212 The empty node in the upper right, highlighted in yellow, is the
rlm@203 213 parent node of all the emptys which represent joints. The following
rlm@203 214 functions must do three things to translate these into real joints:
rlm@202 215
rlm@203 216 - Find the children of the "joints" node.
rlm@203 217 - Determine the two spatials the joint it meant to connect.
rlm@203 218 - Create the joint based on the meta-data of the empty node.
rlm@202 219
rlm@203 220 ** Finding the Joints
rlm@209 221
rlm@209 222 The higher order function =(sense-nodes)= from =cortex.sense= simplifies
rlm@209 223 the first task.
rlm@209 224
rlm@203 225 #+name: joints-2
rlm@203 226 #+begin_src clojure
rlm@203 227 (defvar
rlm@203 228 ^{:arglists '([creature])}
rlm@203 229 joints
rlm@203 230 (sense-nodes "joints")
rlm@203 231 "Return the children of the creature's \"joints\" node.")
rlm@203 232 #+end_src
rlm@202 233
rlm@203 234
rlm@203 235 ** Joint Targets and Orientation
rlm@203 236
rlm@203 237 This technique for finding a joint's targets is very similiar to
rlm@203 238 =(cortex.sense/closest-node)=. A small cube, centered around the
rlm@203 239 empty-node, grows exponentially until it intersects two /physical/
rlm@203 240 objects. The objects are ordered according to the joint's rotation,
rlm@203 241 with the first one being the object that has more negative coordinates
rlm@203 242 in the joint's reference frame. Since the objects must be physical,
rlm@203 243 the empty-node itself escapes detection. Because the objects must be
rlm@203 244 physical, =(joint-targets)= must be called /after/ =(physical!)= is
rlm@203 245 called.
rlm@203 246
rlm@203 247 #+name: joints-3
rlm@202 248 #+begin_src clojure
rlm@135 249 (defn joint-targets
rlm@135 250 "Return the two closest two objects to the joint object, ordered
rlm@135 251 from bottom to top according to the joint's rotation."
rlm@135 252 [#^Node parts #^Node joint]
rlm@135 253 (loop [radius (float 0.01)]
rlm@135 254 (let [results (CollisionResults.)]
rlm@135 255 (.collideWith
rlm@135 256 parts
rlm@135 257 (BoundingBox. (.getWorldTranslation joint)
rlm@209 258 radius radius radius) results)
rlm@135 259 (let [targets
rlm@135 260 (distinct
rlm@135 261 (map #(.getGeometry %) results))]
rlm@135 262 (if (>= (count targets) 2)
rlm@135 263 (sort-by
rlm@209 264 #(let [joint-ref-frame-position
rlm@135 265 (jme-to-blender
rlm@135 266 (.mult
rlm@135 267 (.inverse (.getWorldRotation joint))
rlm@135 268 (.subtract (.getWorldTranslation %)
rlm@135 269 (.getWorldTranslation joint))))]
rlm@209 270 (.dot (Vector3f. 1 1 1) joint-ref-frame-position))
rlm@135 271 (take 2 targets))
rlm@135 272 (recur (float (* radius 2))))))))
rlm@203 273 #+end_src
rlm@135 274
rlm@203 275 ** Generating Joints
rlm@203 276
rlm@209 277 This section of code iterates through all the different ways of
rlm@203 278 specifying joints using blender meta-data and converts each one to the
rlm@203 279 appropriate jMonkyeEngine joint.
rlm@203 280
rlm@203 281 #+name: joints-4
rlm@203 282 #+begin_src clojure
rlm@160 283 (defmulti joint-dispatch
rlm@160 284 "Translate blender pseudo-joints into real JME joints."
rlm@160 285 (fn [constraints & _]
rlm@160 286 (:type constraints)))
rlm@141 287
rlm@160 288 (defmethod joint-dispatch :point
rlm@160 289 [constraints control-a control-b pivot-a pivot-b rotation]
rlm@160 290 (println-repl "creating POINT2POINT joint")
rlm@160 291 ;; bullet's point2point joints are BROKEN, so we must use the
rlm@160 292 ;; generic 6DOF joint instead of an actual Point2Point joint!
rlm@141 293
rlm@160 294 ;; should be able to do this:
rlm@160 295 (comment
rlm@160 296 (Point2PointJoint.
rlm@160 297 control-a
rlm@160 298 control-b
rlm@160 299 pivot-a
rlm@160 300 pivot-b))
rlm@141 301
rlm@160 302 ;; but instead we must do this:
rlm@160 303 (println-repl "substuting 6DOF joint for POINT2POINT joint!")
rlm@160 304 (doto
rlm@160 305 (SixDofJoint.
rlm@160 306 control-a
rlm@160 307 control-b
rlm@160 308 pivot-a
rlm@160 309 pivot-b
rlm@160 310 false)
rlm@160 311 (.setLinearLowerLimit Vector3f/ZERO)
rlm@203 312 (.setLinearUpperLimit Vector3f/ZERO)))
rlm@160 313
rlm@160 314 (defmethod joint-dispatch :hinge
rlm@160 315 [constraints control-a control-b pivot-a pivot-b rotation]
rlm@160 316 (println-repl "creating HINGE joint")
rlm@160 317 (let [axis
rlm@160 318 (if-let
rlm@160 319 [axis (:axis constraints)]
rlm@160 320 axis
rlm@160 321 Vector3f/UNIT_X)
rlm@160 322 [limit-1 limit-2] (:limit constraints)
rlm@160 323 hinge-axis
rlm@160 324 (.mult
rlm@160 325 rotation
rlm@160 326 (blender-to-jme axis))]
rlm@160 327 (doto
rlm@160 328 (HingeJoint.
rlm@160 329 control-a
rlm@160 330 control-b
rlm@160 331 pivot-a
rlm@160 332 pivot-b
rlm@160 333 hinge-axis
rlm@160 334 hinge-axis)
rlm@160 335 (.setLimit limit-1 limit-2))))
rlm@160 336
rlm@160 337 (defmethod joint-dispatch :cone
rlm@160 338 [constraints control-a control-b pivot-a pivot-b rotation]
rlm@160 339 (let [limit-xz (:limit-xz constraints)
rlm@160 340 limit-xy (:limit-xy constraints)
rlm@160 341 twist (:twist constraints)]
rlm@160 342
rlm@160 343 (println-repl "creating CONE joint")
rlm@160 344 (println-repl rotation)
rlm@160 345 (println-repl
rlm@160 346 "UNIT_X --> " (.mult rotation (Vector3f. 1 0 0)))
rlm@160 347 (println-repl
rlm@160 348 "UNIT_Y --> " (.mult rotation (Vector3f. 0 1 0)))
rlm@160 349 (println-repl
rlm@160 350 "UNIT_Z --> " (.mult rotation (Vector3f. 0 0 1)))
rlm@160 351 (doto
rlm@160 352 (ConeJoint.
rlm@160 353 control-a
rlm@160 354 control-b
rlm@160 355 pivot-a
rlm@160 356 pivot-b
rlm@160 357 rotation
rlm@160 358 rotation)
rlm@160 359 (.setLimit (float limit-xz)
rlm@160 360 (float limit-xy)
rlm@160 361 (float twist)))))
rlm@160 362
rlm@160 363 (defn connect
rlm@175 364 "Create a joint between 'obj-a and 'obj-b at the location of
rlm@175 365 'joint. The type of joint is determined by the metadata on 'joint.
rlm@175 366
rlm@175 367 Here are some examples:
rlm@160 368 {:type :point}
rlm@160 369 {:type :hinge :limit [0 (/ Math/PI 2)] :axis (Vector3f. 0 1 0)}
rlm@160 370 (:axis defaults to (Vector3f. 1 0 0) if not provided for hinge joints)
rlm@160 371
rlm@160 372 {:type :cone :limit-xz 0]
rlm@160 373 :limit-xy 0]
rlm@160 374 :twist 0]} (use XZY rotation mode in blender!)"
rlm@160 375 [#^Node obj-a #^Node obj-b #^Node joint]
rlm@160 376 (let [control-a (.getControl obj-a RigidBodyControl)
rlm@160 377 control-b (.getControl obj-b RigidBodyControl)
rlm@160 378 joint-center (.getWorldTranslation joint)
rlm@160 379 joint-rotation (.toRotationMatrix (.getWorldRotation joint))
rlm@160 380 pivot-a (world-to-local obj-a joint-center)
rlm@160 381 pivot-b (world-to-local obj-b joint-center)]
rlm@160 382
rlm@160 383 (if-let [constraints
rlm@160 384 (map-vals
rlm@160 385 eval
rlm@160 386 (read-string
rlm@160 387 (meta-data joint "joint")))]
rlm@160 388 ;; A side-effect of creating a joint registers
rlm@160 389 ;; it with both physics objects which in turn
rlm@160 390 ;; will register the joint with the physics system
rlm@160 391 ;; when the simulation is started.
rlm@160 392 (do
rlm@160 393 (println-repl "creating joint between"
rlm@160 394 (.getName obj-a) "and" (.getName obj-b))
rlm@160 395 (joint-dispatch constraints
rlm@160 396 control-a control-b
rlm@160 397 pivot-a pivot-b
rlm@160 398 joint-rotation))
rlm@160 399 (println-repl "could not find joint meta-data!"))))
rlm@203 400 #+end_src
rlm@160 401
rlm@209 402 Creating joints is now a matter of applying =(connect)= to each joint
rlm@203 403 node.
rlm@160 404
rlm@205 405 #+name: joints-5
rlm@203 406 #+begin_src clojure
rlm@175 407 (defn joints!
rlm@175 408 "Connect the solid parts of the creature with physical joints. The
rlm@175 409 joints are taken from the \"joints\" node in the creature."
rlm@175 410 [#^Node creature]
rlm@160 411 (dorun
rlm@160 412 (map
rlm@160 413 (fn [joint]
rlm@175 414 (let [[obj-a obj-b] (joint-targets creature joint)]
rlm@160 415 (connect obj-a obj-b joint)))
rlm@175 416 (joints creature))))
rlm@203 417 #+end_src
rlm@160 418
rlm@203 419
rlm@203 420 ** Round 3
rlm@203 421
rlm@203 422 Now we can test the hand in all its glory.
rlm@203 423
rlm@205 424 #+name: test-3
rlm@203 425 #+begin_src clojure
rlm@203 426 (in-ns 'cortex.test.body)
rlm@203 427
rlm@203 428 (def debug-control
rlm@203 429 {"key-h" (fn [world val]
rlm@209 430 (if val (enable-debug world)))})
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@209 439 gravity-control)
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@215 494 (defn worm []
rlm@215 495 (load-blender-model
rlm@215 496 "Models/test-creature/worm.blend"))
rlm@215 497
rlm@205 498 (defn worm-1 []
rlm@205 499 (let [timer (RatchetTimer. 60)]
rlm@205 500 (world
rlm@205 501 (nodify
rlm@215 502 [(doto (worm)
rlm@205 503 (body!))
rlm@205 504 (floor)])
rlm@205 505 (merge standard-debug-controls debug-control)
rlm@205 506 #(do
rlm@205 507 (speed-up %)
rlm@205 508 (light-up-everything %)
rlm@205 509 (.setTimer % timer)
rlm@205 510 (cortex.util/display-dialated-time % timer)
rlm@205 511 (Capture/captureVideo
rlm@205 512 % (File. "/home/r/proj/cortex/render/body/4")))
rlm@205 513 no-op)))
rlm@205 514 #+end_src
rlm@205 515
rlm@205 516 #+begin_html
rlm@205 517 <div class="figure">
rlm@205 518 <center>
rlm@205 519 <video controls="controls" width="640">
rlm@205 520 <source src="../video/worm-1.ogg" type="video/ogg"
rlm@205 521 preload="none" poster="../images/aurellem-1280x480.png" />
rlm@205 522 </video>
rlm@205 523 </center>
rlm@205 524 <p>This worm model will be the platform onto which future senses will
rlm@205 525 be grafted.</p>
rlm@205 526 </div>
rlm@205 527 #+end_html
rlm@205 528
rlm@209 529 * Headers
rlm@205 530 #+name: body-header
rlm@202 531 #+begin_src clojure
rlm@202 532 (ns cortex.body
rlm@202 533 "Assemble a physical creature using the definitions found in a
rlm@202 534 specially prepared blender file. Creates rigid bodies and joints so
rlm@202 535 that a creature can have a physical presense in the simulation."
rlm@202 536 {:author "Robert McIntyre"}
rlm@202 537 (:use (cortex world util sense))
rlm@202 538 (:use clojure.contrib.def)
rlm@202 539 (:import
rlm@202 540 (com.jme3.math Vector3f Quaternion Vector2f Matrix3f)
rlm@202 541 (com.jme3.bullet.joints
rlm@202 542 SixDofJoint Point2PointJoint HingeJoint ConeJoint)
rlm@202 543 com.jme3.bullet.control.RigidBodyControl
rlm@202 544 com.jme3.collision.CollisionResults
rlm@202 545 com.jme3.bounding.BoundingBox
rlm@202 546 com.jme3.scene.Node
rlm@202 547 com.jme3.scene.Geometry
rlm@202 548 com.jme3.bullet.collision.shapes.HullCollisionShape))
rlm@202 549 #+end_src
rlm@133 550
rlm@205 551 #+name: test-header
rlm@205 552 #+begin_src clojure
rlm@205 553 (ns cortex.test.body
rlm@205 554 (:use (cortex world util body))
rlm@205 555 (:import
rlm@205 556 (com.aurellem.capture Capture RatchetTimer)
rlm@205 557 (com.jme3.math Quaternion Vector3f ColorRGBA)
rlm@205 558 java.io.File))
rlm@205 559 #+end_src
rlm@205 560
rlm@202 561 * Source
rlm@210 562
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@209 566 - [[../assets/Models/test-creature/palm.png][UV-map-1]]
rlm@207 567 - [[../assets/Models/test-creature/worm.blend][worm.blend]]
rlm@207 568 - [[../assets/Models/test-creature/retina-small.png][UV-map-1]]
rlm@207 569 - [[../assets/Models/test-creature/tip.png][UV-map-2]]
rlm@211 570 #+html: <ul> <li> <a href="../org/body.org">This org file</a> </li> </ul>
rlm@211 571
rlm@211 572 * Next
rlm@211 573 The body I have made here exists without any senses or effectors. In
rlm@211 574 the [[./vision.org][next post]], I'll give the creature eyes.
rlm@63 575
rlm@206 576 * COMMENT Generate Source
rlm@44 577 #+begin_src clojure :tangle ../src/cortex/body.clj
rlm@205 578 <<body-header>>
rlm@205 579 <<body-1>>
rlm@205 580 <<joints-2>>
rlm@205 581 <<joints-3>>
rlm@205 582 <<joints-4>>
rlm@205 583 <<joints-5>>
rlm@205 584 <<joints-6>>
rlm@0 585 #+end_src
rlm@64 586
rlm@69 587 #+begin_src clojure :tangle ../src/cortex/test/body.clj
rlm@205 588 <<test-header>>
rlm@205 589 <<test-1>>
rlm@205 590 <<test-2>>
rlm@205 591 <<test-3>>
rlm@205 592 <<test-4>>
rlm@64 593 #+end_src
rlm@64 594
rlm@64 595
rlm@0 596
rlm@206 597