Mercurial > cortex

annotate org/body.org @ 495:c816594fbbe6

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