Mercurial > cortex

annotate org/body.org @ 205:d3a2abfac405

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
fixed tangling in body.org, added dialated time HUD display in cortex.util
author Robert McIntyre <rlm@mit.edu>
date Thu, 09 Feb 2012 04:15:09 -0700
parents 162b24a82712
children df46a609fed9
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
rlm@202 9 * Design Constraints
rlm@202 10
rlm@202 11 I use [[www.blender.org/][blender]] to design bodies. The design of the bodies is
rlm@202 12 determined by the requirements of the AI that will use them. The
rlm@202 13 bodies must be easy for an AI to sense and control, and they must be
rlm@202 14 relatively simple for jMonkeyEngine to compute.
rlm@202 15
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@202 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@202 25 of the armature. Withouth 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@202 27 physical body is by using its eyes. Also, armatures do not specify
rlm@202 28 any 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@202 36 #+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 37 [[../images/Eve.jpg]]
rlm@202 38
rlm@204 39 EVE's body is composed of several rigid components that are held
rlm@204 40 together by invisible joint constraints. This is what I mean by
rlm@204 41 "eve-like". The main reason that I use eve-style bodies is so that
rlm@204 42 there will be correspondence between the AI's vision and the physical
rlm@204 43 presence of its body. Each individual section is simulated by a
rlm@204 44 separate rigid body that corresponds exactly with its visual
rlm@204 45 representation and does not change. Sections are connected by
rlm@204 46 invisible joints that are well supported in jMonkyeEngine. Bullet, the
rlm@204 47 physics backend for jMonkeyEngine, can efficiently simulate hundreds
rlm@204 48 of rigid bodies connected by joints. Sections do not have to stay as
rlm@204 49 one piece forever; they can be dynamically replaced with multiple
rlm@204 50 sections to simulate splitting in two. This could be used to simulate
rlm@204 51 retractable claws or EVE's hands, which could coalece into one object
rlm@204 52 in the movie.
rlm@202 53
rlm@202 54 * Solidifying the Body
rlm@202 55
rlm@202 56 Here is a hand designed eve-style in blender.
rlm@202 57
rlm@203 58 #+attr_html: width="755"
rlm@202 59 [[../images/hand-screenshot0.png]]
rlm@202 60
rlm@202 61 If we load it directly into jMonkeyEngine, we get this:
rlm@202 62
rlm@205 63 #+name: test-1
rlm@202 64 #+begin_src clojure
rlm@202 65 (def hand-path "Models/test-creature/hand.blend")
rlm@202 66
rlm@202 67 (defn hand [] (load-blender-model hand-path))
rlm@202 68
rlm@202 69 (defn setup [world]
rlm@202 70 (let [cam (.getCamera world)]
rlm@202 71 (println-repl cam)
rlm@202 72 (.setLocation
rlm@202 73 cam (Vector3f.
rlm@202 74 -6.9015837, 8.644911, 5.6043186))
rlm@202 75 (.setRotation
rlm@202 76 cam
rlm@202 77 (Quaternion.
rlm@202 78 0.14046453, 0.85894054, -0.34301838, 0.3533118)))
rlm@202 79 (light-up-everything world)
rlm@202 80 (.setTimer world (RatchetTimer. 60))
rlm@202 81 world)
rlm@202 82
rlm@202 83 (defn test-one []
rlm@202 84 (world (hand)
rlm@202 85 standard-debug-controls
rlm@202 86 (comp
rlm@202 87 #(Capture/captureVideo
rlm@202 88 % (File. "/home/r/proj/cortex/render/body/1"))
rlm@202 89 setup)
rlm@202 90 no-op))
rlm@202 91 #+end_src
rlm@202 92
rlm@202 93
rlm@202 94 #+begin_src clojure :results silent
rlm@202 95 (.start (cortex.test.body/test-one))
rlm@202 96 #+end_src
rlm@202 97
rlm@202 98 #+begin_html
rlm@203 99 <div class="figure">
rlm@203 100 <center>
rlm@203 101 <video controls="controls" width="640">
rlm@202 102 <source src="../video/ghost-hand.ogg" type="video/ogg"
rlm@202 103 preload="none" poster="../images/aurellem-1280x480.png" />
rlm@202 104 </video>
rlm@203 105 </center>
rlm@203 106 <p>The hand model directly loaded from blender. It has no physical
rlm@203 107 presense in the simulation. </p>
rlm@203 108 </div>
rlm@202 109 #+end_html
rlm@202 110
rlm@202 111 You will notice that the hand has no physical presence -- it's a
rlm@204 112 hologram through which everything passes. Therefore, the first thing
rlm@202 113 to do is to make it solid. Blender has physics simulation on par with
rlm@202 114 jMonkeyEngine (they both use bullet as their physics backend), but it
rlm@202 115 can be difficult to translate between the two systems, so for now I
rlm@202 116 specify the mass of each object in blender and construct the physics
rlm@202 117 shape based on the mesh in jMonkeyEngine.
rlm@202 118
rlm@203 119 #+name: body-1
rlm@202 120 #+begin_src clojure
rlm@202 121 (defn physical!
rlm@202 122 "Iterate through the nodes in creature and make them real physical
rlm@202 123 objects in the simulation."
rlm@202 124 [#^Node creature]
rlm@202 125 (dorun
rlm@202 126 (map
rlm@202 127 (fn [geom]
rlm@202 128 (let [physics-control
rlm@202 129 (RigidBodyControl.
rlm@202 130 (HullCollisionShape.
rlm@202 131 (.getMesh geom))
rlm@202 132 (if-let [mass (meta-data geom "mass")]
rlm@202 133 (do
rlm@202 134 (println-repl
rlm@202 135 "setting" (.getName geom) "mass to" (float mass))
rlm@202 136 (float mass))
rlm@202 137 (float 1)))]
rlm@202 138 (.addControl geom physics-control)))
rlm@202 139 (filter #(isa? (class %) Geometry )
rlm@202 140 (node-seq creature)))))
rlm@202 141 #+end_src
rlm@202 142
rlm@202 143 =(physical!)= iterates through a creature's node structure, creating
rlm@202 144 CollisionShapes for each geometry with the mass specified in that
rlm@202 145 geometry's meta-data.
rlm@202 146
rlm@205 147 #+name: test-2
rlm@0 148 #+begin_src clojure
rlm@202 149 (in-ns 'cortex.test.body)
rlm@160 150
rlm@202 151 (def normal-gravity
rlm@202 152 {"key-g" (fn [world _]
rlm@202 153 (set-gravity world (Vector3f. 0 -9.81 0)))})
rlm@202 154
rlm@202 155 (defn floor []
rlm@202 156 (box 10 3 10 :position (Vector3f. 0 -10 0)
rlm@202 157 :color ColorRGBA/Gray :mass 0))
rlm@202 158
rlm@202 159 (defn test-two []
rlm@202 160 (world (nodify
rlm@202 161 [(doto (hand)
rlm@202 162 (physical!))
rlm@202 163 (floor)])
rlm@202 164 (merge standard-debug-controls normal-gravity)
rlm@202 165 (comp
rlm@202 166 #(Capture/captureVideo
rlm@202 167 % (File. "/home/r/proj/cortex/render/body/2"))
rlm@202 168 #(do (set-gravity % Vector3f/ZERO) %)
rlm@202 169 setup)
rlm@202 170 no-op))
rlm@202 171 #+end_src
rlm@202 172
rlm@202 173 #+begin_html
rlm@203 174 <div class="figure">
rlm@203 175 <center>
rlm@203 176 <video controls="controls" width="640">
rlm@202 177 <source src="../video/crumbly-hand.ogg" type="video/ogg"
rlm@202 178 preload="none" poster="../images/aurellem-1280x480.png" />
rlm@202 179 </video>
rlm@203 180 </center>
rlm@203 181 <p>The hand now has a physical presence, but there is nothing to hold
rlm@203 182 it together.</p>
rlm@203 183 </div>
rlm@202 184 #+end_html
rlm@202 185
rlm@202 186 Now that's some progress.
rlm@202 187
rlm@202 188
rlm@202 189 * Joints
rlm@202 190
rlm@202 191 Obviously, an AI is not going to be doing much just lying in pieces on
rlm@202 192 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@203 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@203 221 #+name: joints-2
rlm@203 222 #+begin_src clojure
rlm@203 223 (defvar
rlm@203 224 ^{:arglists '([creature])}
rlm@203 225 joints
rlm@203 226 (sense-nodes "joints")
rlm@203 227 "Return the children of the creature's \"joints\" node.")
rlm@203 228 #+end_src
rlm@202 229
rlm@203 230 The higher order function =(sense-nodes)= from cortex.sense makes our
rlm@203 231 first task very easy.
rlm@203 232
rlm@203 233 ** Joint Targets and Orientation
rlm@203 234
rlm@203 235 This technique for finding a joint's targets is very similiar to
rlm@203 236 =(cortex.sense/closest-node)=. A small cube, centered around the
rlm@203 237 empty-node, grows exponentially until it intersects two /physical/
rlm@203 238 objects. The objects are ordered according to the joint's rotation,
rlm@203 239 with the first one being the object that has more negative coordinates
rlm@203 240 in the joint's reference frame. Since the objects must be physical,
rlm@203 241 the empty-node itself escapes detection. Because the objects must be
rlm@203 242 physical, =(joint-targets)= must be called /after/ =(physical!)= is
rlm@203 243 called.
rlm@203 244
rlm@203 245 #+name: joints-3
rlm@202 246 #+begin_src clojure
rlm@135 247 (defn joint-targets
rlm@135 248 "Return the two closest two objects to the joint object, ordered
rlm@135 249 from bottom to top according to the joint's rotation."
rlm@135 250 [#^Node parts #^Node joint]
rlm@135 251 (loop [radius (float 0.01)]
rlm@135 252 (let [results (CollisionResults.)]
rlm@135 253 (.collideWith
rlm@135 254 parts
rlm@135 255 (BoundingBox. (.getWorldTranslation joint)
rlm@135 256 radius radius radius)
rlm@135 257 results)
rlm@135 258 (let [targets
rlm@135 259 (distinct
rlm@135 260 (map #(.getGeometry %) results))]
rlm@135 261 (if (>= (count targets) 2)
rlm@135 262 (sort-by
rlm@135 263 #(let [v
rlm@135 264 (jme-to-blender
rlm@135 265 (.mult
rlm@135 266 (.inverse (.getWorldRotation joint))
rlm@135 267 (.subtract (.getWorldTranslation %)
rlm@135 268 (.getWorldTranslation joint))))]
rlm@135 269 (println-repl (.getName %) ":" v)
rlm@135 270 (.dot (Vector3f. 1 1 1)
rlm@135 271 v))
rlm@135 272 (take 2 targets))
rlm@135 273 (recur (float (* radius 2))))))))
rlm@203 274 #+end_src
rlm@135 275
rlm@203 276 ** Generating Joints
rlm@203 277
rlm@203 278 This long chunk of code iterates through all the different ways of
rlm@203 279 specifying joints using blender meta-data and converts each one to the
rlm@203 280 appropriate jMonkyeEngine joint.
rlm@203 281
rlm@203 282 #+name: joints-4
rlm@203 283 #+begin_src clojure
rlm@160 284 (defmulti joint-dispatch
rlm@160 285 "Translate blender pseudo-joints into real JME joints."
rlm@160 286 (fn [constraints & _]
rlm@160 287 (:type constraints)))
rlm@141 288
rlm@160 289 (defmethod joint-dispatch :point
rlm@160 290 [constraints control-a control-b pivot-a pivot-b rotation]
rlm@160 291 (println-repl "creating POINT2POINT joint")
rlm@160 292 ;; bullet's point2point joints are BROKEN, so we must use the
rlm@160 293 ;; generic 6DOF joint instead of an actual Point2Point joint!
rlm@141 294
rlm@160 295 ;; should be able to do this:
rlm@160 296 (comment
rlm@160 297 (Point2PointJoint.
rlm@160 298 control-a
rlm@160 299 control-b
rlm@160 300 pivot-a
rlm@160 301 pivot-b))
rlm@141 302
rlm@160 303 ;; but instead we must do this:
rlm@160 304 (println-repl "substuting 6DOF joint for POINT2POINT joint!")
rlm@160 305 (doto
rlm@160 306 (SixDofJoint.
rlm@160 307 control-a
rlm@160 308 control-b
rlm@160 309 pivot-a
rlm@160 310 pivot-b
rlm@160 311 false)
rlm@160 312 (.setLinearLowerLimit Vector3f/ZERO)
rlm@203 313 (.setLinearUpperLimit Vector3f/ZERO)))
rlm@160 314
rlm@160 315 (defmethod joint-dispatch :hinge
rlm@160 316 [constraints control-a control-b pivot-a pivot-b rotation]
rlm@160 317 (println-repl "creating HINGE joint")
rlm@160 318 (let [axis
rlm@160 319 (if-let
rlm@160 320 [axis (:axis constraints)]
rlm@160 321 axis
rlm@160 322 Vector3f/UNIT_X)
rlm@160 323 [limit-1 limit-2] (:limit constraints)
rlm@160 324 hinge-axis
rlm@160 325 (.mult
rlm@160 326 rotation
rlm@160 327 (blender-to-jme axis))]
rlm@160 328 (doto
rlm@160 329 (HingeJoint.
rlm@160 330 control-a
rlm@160 331 control-b
rlm@160 332 pivot-a
rlm@160 333 pivot-b
rlm@160 334 hinge-axis
rlm@160 335 hinge-axis)
rlm@160 336 (.setLimit limit-1 limit-2))))
rlm@160 337
rlm@160 338 (defmethod joint-dispatch :cone
rlm@160 339 [constraints control-a control-b pivot-a pivot-b rotation]
rlm@160 340 (let [limit-xz (:limit-xz constraints)
rlm@160 341 limit-xy (:limit-xy constraints)
rlm@160 342 twist (:twist constraints)]
rlm@160 343
rlm@160 344 (println-repl "creating CONE joint")
rlm@160 345 (println-repl rotation)
rlm@160 346 (println-repl
rlm@160 347 "UNIT_X --> " (.mult rotation (Vector3f. 1 0 0)))
rlm@160 348 (println-repl
rlm@160 349 "UNIT_Y --> " (.mult rotation (Vector3f. 0 1 0)))
rlm@160 350 (println-repl
rlm@160 351 "UNIT_Z --> " (.mult rotation (Vector3f. 0 0 1)))
rlm@160 352 (doto
rlm@160 353 (ConeJoint.
rlm@160 354 control-a
rlm@160 355 control-b
rlm@160 356 pivot-a
rlm@160 357 pivot-b
rlm@160 358 rotation
rlm@160 359 rotation)
rlm@160 360 (.setLimit (float limit-xz)
rlm@160 361 (float limit-xy)
rlm@160 362 (float twist)))))
rlm@160 363
rlm@160 364 (defn connect
rlm@175 365 "Create a joint between 'obj-a and 'obj-b at the location of
rlm@175 366 'joint. The type of joint is determined by the metadata on 'joint.
rlm@175 367
rlm@175 368 Here are some examples:
rlm@160 369 {:type :point}
rlm@160 370 {:type :hinge :limit [0 (/ Math/PI 2)] :axis (Vector3f. 0 1 0)}
rlm@160 371 (:axis defaults to (Vector3f. 1 0 0) if not provided for hinge joints)
rlm@160 372
rlm@160 373 {:type :cone :limit-xz 0]
rlm@160 374 :limit-xy 0]
rlm@160 375 :twist 0]} (use XZY rotation mode in blender!)"
rlm@160 376 [#^Node obj-a #^Node obj-b #^Node joint]
rlm@160 377 (let [control-a (.getControl obj-a RigidBodyControl)
rlm@160 378 control-b (.getControl obj-b RigidBodyControl)
rlm@160 379 joint-center (.getWorldTranslation joint)
rlm@160 380 joint-rotation (.toRotationMatrix (.getWorldRotation joint))
rlm@160 381 pivot-a (world-to-local obj-a joint-center)
rlm@160 382 pivot-b (world-to-local obj-b joint-center)]
rlm@160 383
rlm@160 384 (if-let [constraints
rlm@160 385 (map-vals
rlm@160 386 eval
rlm@160 387 (read-string
rlm@160 388 (meta-data joint "joint")))]
rlm@160 389 ;; A side-effect of creating a joint registers
rlm@160 390 ;; it with both physics objects which in turn
rlm@160 391 ;; will register the joint with the physics system
rlm@160 392 ;; when the simulation is started.
rlm@160 393 (do
rlm@160 394 (println-repl "creating joint between"
rlm@160 395 (.getName obj-a) "and" (.getName obj-b))
rlm@160 396 (joint-dispatch constraints
rlm@160 397 control-a control-b
rlm@160 398 pivot-a pivot-b
rlm@160 399 joint-rotation))
rlm@160 400 (println-repl "could not find joint meta-data!"))))
rlm@203 401 #+end_src
rlm@160 402
rlm@203 403 Creating joints is now a matter applying =(connect)= to each joint
rlm@203 404 node.
rlm@160 405
rlm@205 406 #+name: joints-5
rlm@203 407 #+begin_src clojure
rlm@175 408 (defn joints!
rlm@175 409 "Connect the solid parts of the creature with physical joints. The
rlm@175 410 joints are taken from the \"joints\" node in the creature."
rlm@175 411 [#^Node creature]
rlm@160 412 (dorun
rlm@160 413 (map
rlm@160 414 (fn [joint]
rlm@175 415 (let [[obj-a obj-b] (joint-targets creature joint)]
rlm@160 416 (connect obj-a obj-b joint)))
rlm@175 417 (joints creature))))
rlm@203 418 #+end_src
rlm@160 419
rlm@203 420
rlm@203 421 ** Round 3
rlm@203 422
rlm@203 423 Now we can test the hand in all its glory.
rlm@203 424
rlm@205 425 #+name: test-3
rlm@203 426 #+begin_src clojure
rlm@203 427 (in-ns 'cortex.test.body)
rlm@203 428
rlm@203 429 (def debug-control
rlm@203 430 {"key-h" (fn [world val]
rlm@203 431 (if val (enable-debug world)))
rlm@205 432 "key-u" (fn [world _] (set-gravity world Vector3f/ZERO))})
rlm@203 433
rlm@203 434 (defn test-three []
rlm@203 435 (world (nodify
rlm@203 436 [(doto (hand)
rlm@205 437 (physical!)
rlm@205 438 (joints!))
rlm@203 439 (floor)])
rlm@203 440 (merge standard-debug-controls debug-control
rlm@203 441 normal-gravity)
rlm@203 442 (comp
rlm@203 443 #(Capture/captureVideo
rlm@203 444 % (File. "/home/r/proj/cortex/render/body/3"))
rlm@203 445 #(do (set-gravity % Vector3f/ZERO) %)
rlm@203 446 setup)
rlm@203 447 no-op))
rlm@203 448 #+end_src
rlm@203 449
rlm@203 450 =(physical!)= makes the hand solid, then =(joints!)= connects each
rlm@203 451 piece together.
rlm@203 452
rlm@203 453 #+begin_html
rlm@203 454 <div class="figure">
rlm@203 455 <center>
rlm@203 456 <video controls="controls" width="640">
rlm@203 457 <source src="../video/full-hand.ogg" type="video/ogg"
rlm@203 458 preload="none" poster="../images/aurellem-1280x480.png" />
rlm@203 459 </video>
rlm@203 460 </center>
rlm@203 461 <p>Now the hand is physical and has joints.</p>
rlm@203 462 </div>
rlm@203 463 #+end_html
rlm@203 464
rlm@203 465 The joints are visualized as green connections between each segment
rlm@203 466 for debug purposes. You can see that they correspond to the empty
rlm@203 467 nodes in the blender file.
rlm@203 468
rlm@203 469 * Wrap-Up!
rlm@203 470
rlm@203 471 It is convienent to combine =(physical!)= and =(joints!)= into one
rlm@203 472 function that completely creates the creature's physical body.
rlm@203 473
rlm@205 474 #+name: joints-6
rlm@203 475 #+begin_src clojure
rlm@175 476 (defn body!
rlm@175 477 "Endow the creature with a physical body connected with joints. The
rlm@175 478 particulars of the joints and the masses of each pody part are
rlm@175 479 determined in blender."
rlm@175 480 [#^Node creature]
rlm@175 481 (physical! creature)
rlm@175 482 (joints! creature))
rlm@64 483 #+end_src
rlm@63 484
rlm@205 485 * The Worm
rlm@205 486
rlm@205 487 Going forward, I will use a model that is less complicated than the
rlm@205 488 hand. It has two segments and one joint, and I call it the worm. All
rlm@205 489 of the senses described in the following posts will be applied to this
rlm@205 490 worm.
rlm@205 491
rlm@205 492 #+name: test-4
rlm@205 493 #+begin_src clojure
rlm@205 494 (in-ns 'cortex.test.body)
rlm@205 495
rlm@205 496 (defn worm-1 []
rlm@205 497 (let [timer (RatchetTimer. 60)]
rlm@205 498 (world
rlm@205 499 (nodify
rlm@205 500 [(doto
rlm@205 501 (load-blender-model
rlm@205 502 "Models/test-creature/worm.blend")
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@202 529 * Bookkeeping
rlm@175 530
rlm@203 531 Header; here for completeness.
rlm@203 532
rlm@205 533 #+name: body-header
rlm@202 534 #+begin_src clojure
rlm@202 535 (ns cortex.body
rlm@202 536 "Assemble a physical creature using the definitions found in a
rlm@202 537 specially prepared blender file. Creates rigid bodies and joints so
rlm@202 538 that a creature can have a physical presense in the simulation."
rlm@202 539 {:author "Robert McIntyre"}
rlm@202 540 (:use (cortex world util sense))
rlm@202 541 (:use clojure.contrib.def)
rlm@202 542 (:import
rlm@202 543 (com.jme3.math Vector3f Quaternion Vector2f Matrix3f)
rlm@202 544 (com.jme3.bullet.joints
rlm@202 545 SixDofJoint Point2PointJoint HingeJoint ConeJoint)
rlm@202 546 com.jme3.bullet.control.RigidBodyControl
rlm@202 547 com.jme3.collision.CollisionResults
rlm@202 548 com.jme3.bounding.BoundingBox
rlm@202 549 com.jme3.scene.Node
rlm@202 550 com.jme3.scene.Geometry
rlm@202 551 com.jme3.bullet.collision.shapes.HullCollisionShape))
rlm@202 552 #+end_src
rlm@133 553
rlm@205 554 #+name: test-header
rlm@205 555 #+begin_src clojure
rlm@205 556 (ns cortex.test.body
rlm@205 557 (:use (cortex world util body))
rlm@205 558 (:import
rlm@205 559 (com.aurellem.capture Capture RatchetTimer)
rlm@205 560 (com.jme3.math Quaternion Vector3f ColorRGBA)
rlm@205 561 java.io.File))
rlm@205 562 #+end_src
rlm@205 563
rlm@202 564 * Source
rlm@202 565
rlm@203 566 Dylan -- I'll fill these in later
rlm@203 567 - cortex.body
rlm@203 568 - cortex.test.body
rlm@203 569 - blender files
rlm@203 570
rlm@202 571 * COMMENT Examples
rlm@63 572
rlm@69 573 #+name: test-body
rlm@64 574 #+begin_src clojure
rlm@63 575
rlm@64 576 (defn worm-segments
rlm@64 577 "Create multiple evenly spaced box segments. They're fabulous!"
rlm@64 578 [segment-length num-segments interstitial-space radius]
rlm@64 579 (letfn [(nth-segment
rlm@64 580 [n]
rlm@64 581 (box segment-length radius radius :mass 0.1
rlm@64 582 :position
rlm@64 583 (Vector3f.
rlm@64 584 (* 2 n (+ interstitial-space segment-length)) 0 0)
rlm@64 585 :name (str "worm-segment" n)
rlm@64 586 :color (ColorRGBA/randomColor)))]
rlm@64 587 (map nth-segment (range num-segments))))
rlm@63 588
rlm@64 589 (defn connect-at-midpoint
rlm@64 590 "Connect two physics objects with a Point2Point joint constraint at
rlm@64 591 the point equidistant from both objects' centers."
rlm@64 592 [segmentA segmentB]
rlm@64 593 (let [centerA (.getWorldTranslation segmentA)
rlm@64 594 centerB (.getWorldTranslation segmentB)
rlm@64 595 midpoint (.mult (.add centerA centerB) (float 0.5))
rlm@64 596 pivotA (.subtract midpoint centerA)
rlm@64 597 pivotB (.subtract midpoint centerB)
rlm@64 598
rlm@64 599 ;; A side-effect of creating a joint registers
rlm@64 600 ;; it with both physics objects which in turn
rlm@64 601 ;; will register the joint with the physics system
rlm@64 602 ;; when the simulation is started.
rlm@64 603 joint (Point2PointJoint.
rlm@64 604 (.getControl segmentA RigidBodyControl)
rlm@64 605 (.getControl segmentB RigidBodyControl)
rlm@64 606 pivotA
rlm@64 607 pivotB)]
rlm@64 608 segmentB))
rlm@63 609
rlm@64 610 (defn eve-worm
rlm@72 611 "Create a worm-like body bound by invisible joint constraints."
rlm@64 612 []
rlm@64 613 (let [segments (worm-segments 0.2 5 0.1 0.1)]
rlm@64 614 (dorun (map (partial apply connect-at-midpoint)
rlm@64 615 (partition 2 1 segments)))
rlm@64 616 (nodify "worm" segments)))
rlm@63 617
rlm@64 618 (defn worm-pattern
rlm@64 619 "This is a simple, mindless motor control pattern that drives the
rlm@64 620 second segment of the worm's body at an offset angle with
rlm@64 621 sinusoidally varying strength."
rlm@64 622 [time]
rlm@64 623 (let [angle (* Math/PI (/ 9 20))
rlm@63 624 direction (Vector3f. 0 (Math/sin angle) (Math/cos angle))]
rlm@63 625 [Vector3f/ZERO
rlm@63 626 (.mult
rlm@63 627 direction
rlm@63 628 (float (* 2 (Math/sin (* Math/PI 2 (/ (rem time 300 ) 300))))))
rlm@63 629 Vector3f/ZERO
rlm@63 630 Vector3f/ZERO
rlm@63 631 Vector3f/ZERO]))
rlm@60 632
rlm@64 633 (defn test-motor-control
rlm@69 634 "Testing motor-control:
rlm@69 635 You should see a multi-segmented worm-like object fall onto the
rlm@64 636 table and begin writhing and moving."
rlm@60 637 []
rlm@64 638 (let [worm (eve-worm)
rlm@60 639 time (atom 0)
rlm@63 640 worm-motor-map (vector-motor-control worm)]
rlm@60 641 (world
rlm@60 642 (nodify [worm
rlm@60 643 (box 10 0.5 10 :position (Vector3f. 0 -5 0) :mass 0
rlm@60 644 :color ColorRGBA/Gray)])
rlm@60 645 standard-debug-controls
rlm@60 646 (fn [world]
rlm@60 647 (enable-debug world)
rlm@60 648 (light-up-everything world)
rlm@63 649 (comment
rlm@63 650 (com.aurellem.capture.Capture/captureVideo
rlm@63 651 world
rlm@63 652 (file-str "/home/r/proj/cortex/tmp/moving-worm")))
rlm@63 653 )
rlm@60 654
rlm@60 655 (fn [_ _]
rlm@60 656 (swap! time inc)
rlm@64 657 (Thread/sleep 20)
rlm@60 658 (dorun (worm-motor-map
rlm@60 659 (worm-pattern @time)))))))
rlm@60 660
rlm@130 661
rlm@135 662
rlm@130 663 (defn join-at-point [obj-a obj-b world-pivot]
rlm@130 664 (cortex.silly/joint-dispatch
rlm@130 665 {:type :point}
rlm@130 666 (.getControl obj-a RigidBodyControl)
rlm@130 667 (.getControl obj-b RigidBodyControl)
rlm@130 668 (cortex.silly/world-to-local obj-a world-pivot)
rlm@130 669 (cortex.silly/world-to-local obj-b world-pivot)
rlm@130 670 nil
rlm@130 671 ))
rlm@130 672
rlm@133 673 (import com.jme3.bullet.collision.PhysicsCollisionObject)
rlm@130 674
rlm@130 675 (defn blab-* []
rlm@130 676 (let [hand (box 0.5 0.2 0.2 :position (Vector3f. 0 0 0)
rlm@130 677 :mass 0 :color ColorRGBA/Green)
rlm@130 678 finger (box 0.5 0.2 0.2 :position (Vector3f. 2.4 0 0)
rlm@130 679 :mass 1 :color ColorRGBA/Red)
rlm@130 680 connection-point (Vector3f. 1.2 0 0)
rlm@130 681 root (nodify [hand finger])]
rlm@130 682
rlm@130 683 (join-at-point hand finger (Vector3f. 1.2 0 0))
rlm@130 684
rlm@130 685 (.setCollisionGroup
rlm@130 686 (.getControl hand RigidBodyControl)
rlm@130 687 PhysicsCollisionObject/COLLISION_GROUP_NONE)
rlm@130 688 (world
rlm@130 689 root
rlm@130 690 standard-debug-controls
rlm@130 691 (fn [world]
rlm@130 692 (enable-debug world)
rlm@130 693 (.setTimer world (com.aurellem.capture.RatchetTimer. 60))
rlm@130 694 (set-gravity world Vector3f/ZERO)
rlm@130 695 )
rlm@130 696 no-op)))
rlm@133 697 (comment
rlm@133 698
rlm@133 699 (defn proprioception-debug-window
rlm@133 700 []
rlm@133 701 (let [time (atom 0)]
rlm@133 702 (fn [prop-data]
rlm@133 703 (if (= 0 (rem (swap! time inc) 40))
rlm@133 704 (println-repl prop-data)))))
rlm@133 705 )
rlm@133 706
rlm@131 707 (comment
rlm@131 708 (dorun
rlm@131 709 (map
rlm@131 710 (comp
rlm@131 711 println-repl
rlm@131 712 (fn [[p y r]]
rlm@131 713 (format
rlm@131 714 "pitch: %1.2f\nyaw: %1.2f\nroll: %1.2f\n"
rlm@131 715 p y r)))
rlm@131 716 prop-data)))
rlm@131 717
rlm@130 718
rlm@130 719
rlm@137 720
rlm@64 721 (defn test-proprioception
rlm@69 722 "Testing proprioception:
rlm@69 723 You should see two foating bars, and a printout of pitch, yaw, and
rlm@64 724 roll. Pressing key-r/key-t should move the blue bar up and down and
rlm@64 725 change only the value of pitch. key-f/key-g moves it side to side
rlm@64 726 and changes yaw. key-v/key-b will spin the blue segment clockwise
rlm@64 727 and counterclockwise, and only affect roll."
rlm@60 728 []
rlm@145 729 (let [hand (box 0.2 1 0.2 :position (Vector3f. 0 0 0)
rlm@142 730 :mass 0 :color ColorRGBA/Green :name "hand")
rlm@145 731 finger (box 0.2 1 0.2 :position (Vector3f. 0 2.4 0)
rlm@132 732 :mass 1 :color ColorRGBA/Red :name "finger")
rlm@133 733 joint-node (box 0.1 0.05 0.05 :color ColorRGBA/Yellow
rlm@145 734 :position (Vector3f. 0 1.2 0)
rlm@145 735 :rotation (doto (Quaternion.)
rlm@145 736 (.fromAngleAxis
rlm@145 737 (/ Math/PI 2)
rlm@145 738 (Vector3f. 0 0 1)))
rlm@133 739 :physical? false)
rlm@145 740 joint (join-at-point hand finger (Vector3f. 0 1.2 0 ))
rlm@135 741 creature (nodify [hand finger joint-node])
rlm@145 742 finger-control (.getControl finger RigidBodyControl)
rlm@145 743 hand-control (.getControl hand RigidBodyControl)]
rlm@145 744
rlm@145 745
rlm@145 746 (let
rlm@135 747 ;; *******************************************
rlm@137 748
rlm@145 749 [floor (box 10 10 10 :position (Vector3f. 0 -15 0)
rlm@135 750 :mass 0 :color ColorRGBA/Gray)
rlm@137 751
rlm@137 752 root (nodify [creature floor])
rlm@133 753 prop (joint-proprioception creature joint-node)
rlm@139 754 prop-view (proprioception-debug-window)
rlm@139 755
rlm@139 756 controls
rlm@139 757 (merge standard-debug-controls
rlm@140 758 {"key-o"
rlm@139 759 (fn [_ _] (.setEnabled finger-control true))
rlm@140 760 "key-p"
rlm@139 761 (fn [_ _] (.setEnabled finger-control false))
rlm@140 762 "key-k"
rlm@140 763 (fn [_ _] (.setEnabled hand-control true))
rlm@140 764 "key-l"
rlm@140 765 (fn [_ _] (.setEnabled hand-control false))
rlm@139 766 "key-i"
rlm@139 767 (fn [world _] (set-gravity world (Vector3f. 0 0 0)))
rlm@142 768 "key-period"
rlm@142 769 (fn [world _]
rlm@142 770 (.setEnabled finger-control false)
rlm@142 771 (.setEnabled hand-control false)
rlm@142 772 (.rotate creature (doto (Quaternion.)
rlm@142 773 (.fromAngleAxis
rlm@142 774 (float (/ Math/PI 15))
rlm@142 775 (Vector3f. 0 0 -1))))
rlm@142 776
rlm@142 777 (.setEnabled finger-control true)
rlm@142 778 (.setEnabled hand-control true)
rlm@142 779 (set-gravity world (Vector3f. 0 0 0))
rlm@142 780 )
rlm@142 781
rlm@142 782
rlm@139 783 }
rlm@139 784 )
rlm@130 785
rlm@139 786 ]
rlm@139 787 (comment
rlm@139 788 (.setCollisionGroup
rlm@139 789 (.getControl hand RigidBodyControl)
rlm@139 790 PhysicsCollisionObject/COLLISION_GROUP_NONE)
rlm@139 791 )
rlm@140 792 (apply
rlm@140 793 world
rlm@140 794 (with-movement
rlm@140 795 hand
rlm@140 796 ["key-y" "key-u" "key-h" "key-j" "key-n" "key-m"]
rlm@140 797 [10 10 10 10 1 1]
rlm@140 798 (with-movement
rlm@140 799 finger
rlm@140 800 ["key-r" "key-t" "key-f" "key-g" "key-v" "key-b"]
rlm@145 801 [1 1 10 10 10 10]
rlm@140 802 [root
rlm@140 803 controls
rlm@140 804 (fn [world]
rlm@140 805 (.setTimer world (com.aurellem.capture.RatchetTimer. 60))
rlm@140 806 (set-gravity world (Vector3f. 0 0 0))
rlm@140 807 (light-up-everything world))
rlm@145 808 (fn [_ _] (prop-view (list (prop))))]))))))
rlm@138 809
rlm@64 810 #+end_src
rlm@56 811
rlm@130 812 #+results: test-body
rlm@130 813 : #'cortex.test.body/test-proprioception
rlm@130 814
rlm@60 815
rlm@63 816 * COMMENT code-limbo
rlm@61 817 #+begin_src clojure
rlm@61 818 ;;(.loadModel
rlm@61 819 ;; (doto (asset-manager)
rlm@61 820 ;; (.registerLoader BlenderModelLoader (into-array String ["blend"])))
rlm@61 821 ;; "Models/person/person.blend")
rlm@61 822
rlm@64 823
rlm@64 824 (defn load-blender-model
rlm@64 825 "Load a .blend file using an asset folder relative path."
rlm@64 826 [^String model]
rlm@64 827 (.loadModel
rlm@64 828 (doto (asset-manager)
rlm@64 829 (.registerLoader BlenderModelLoader (into-array String ["blend"])))
rlm@64 830 model))
rlm@64 831
rlm@64 832
rlm@61 833 (defn view-model [^String model]
rlm@61 834 (view
rlm@61 835 (.loadModel
rlm@61 836 (doto (asset-manager)
rlm@61 837 (.registerLoader BlenderModelLoader (into-array String ["blend"])))
rlm@61 838 model)))
rlm@61 839
rlm@61 840 (defn load-blender-scene [^String model]
rlm@61 841 (.loadModel
rlm@61 842 (doto (asset-manager)
rlm@61 843 (.registerLoader BlenderLoader (into-array String ["blend"])))
rlm@61 844 model))
rlm@61 845
rlm@61 846 (defn worm
rlm@61 847 []
rlm@61 848 (.loadModel (asset-manager) "Models/anim2/Cube.mesh.xml"))
rlm@61 849
rlm@61 850 (defn oto
rlm@61 851 []
rlm@61 852 (.loadModel (asset-manager) "Models/Oto/Oto.mesh.xml"))
rlm@61 853
rlm@61 854 (defn sinbad
rlm@61 855 []
rlm@61 856 (.loadModel (asset-manager) "Models/Sinbad/Sinbad.mesh.xml"))
rlm@61 857
rlm@61 858 (defn worm-blender
rlm@61 859 []
rlm@61 860 (first (seq (.getChildren (load-blender-model
rlm@61 861 "Models/anim2/simple-worm.blend")))))
rlm@61 862
rlm@61 863 (defn body
rlm@61 864 "given a node with a SkeletonControl, will produce a body sutiable
rlm@61 865 for AI control with movement and proprioception."
rlm@61 866 [node]
rlm@61 867 (let [skeleton-control (.getControl node SkeletonControl)
rlm@61 868 krc (KinematicRagdollControl.)]
rlm@61 869 (comment
rlm@61 870 (dorun
rlm@61 871 (map #(.addBoneName krc %)
rlm@61 872 ["mid2" "tail" "head" "mid1" "mid3" "mid4" "Dummy-Root" ""]
rlm@61 873 ;;"mid2" "mid3" "tail" "head"]
rlm@61 874 )))
rlm@61 875 (.addControl node krc)
rlm@61 876 (.setRagdollMode krc)
rlm@61 877 )
rlm@61 878 node
rlm@61 879 )
rlm@61 880 (defn show-skeleton [node]
rlm@61 881 (let [sd
rlm@61 882
rlm@61 883 (doto
rlm@61 884 (SkeletonDebugger. "aurellem-skel-debug"
rlm@61 885 (skel node))
rlm@61 886 (.setMaterial (green-x-ray)))]
rlm@61 887 (.attachChild node sd)
rlm@61 888 node))
rlm@61 889
rlm@61 890
rlm@61 891
rlm@61 892 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
rlm@61 893
rlm@61 894 ;; this could be a good way to give objects special properties like
rlm@61 895 ;; being eyes and the like
rlm@61 896
rlm@61 897 (.getUserData
rlm@61 898 (.getChild
rlm@61 899 (load-blender-model "Models/property/test.blend") 0)
rlm@61 900 "properties")
rlm@61 901
rlm@61 902 ;; the properties are saved along with the blender file.
rlm@61 903 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
rlm@61 904
rlm@61 905
rlm@61 906
rlm@61 907
rlm@61 908 (defn init-debug-skel-node
rlm@61 909 [f debug-node skeleton]
rlm@61 910 (let [bones
rlm@61 911 (map #(.getBone skeleton %)
rlm@61 912 (range (.getBoneCount skeleton)))]
rlm@61 913 (dorun (map #(.setUserControl % true) bones))
rlm@61 914 (dorun (map (fn [b]
rlm@61 915 (println (.getName b)
rlm@61 916 " -- " (f b)))
rlm@61 917 bones))
rlm@61 918 (dorun
rlm@61 919 (map #(.attachChild
rlm@61 920 debug-node
rlm@61 921 (doto
rlm@61 922 (sphere 0.1
rlm@61 923 :position (f %)
rlm@61 924 :physical? false)
rlm@61 925 (.setMaterial (green-x-ray))))
rlm@61 926 bones)))
rlm@61 927 debug-node)
rlm@61 928
rlm@61 929 (import jme3test.bullet.PhysicsTestHelper)
rlm@61 930
rlm@61 931
rlm@61 932 (defn test-zzz [the-worm world value]
rlm@61 933 (if (not value)
rlm@61 934 (let [skeleton (skel the-worm)]
rlm@61 935 (println-repl "enabling bones")
rlm@61 936 (dorun
rlm@61 937 (map
rlm@61 938 #(.setUserControl (.getBone skeleton %) true)
rlm@61 939 (range (.getBoneCount skeleton))))
rlm@61 940
rlm@61 941
rlm@61 942 (let [b (.getBone skeleton 2)]
rlm@61 943 (println-repl "moving " (.getName b))
rlm@61 944 (println-repl (.getLocalPosition b))
rlm@61 945 (.setUserTransforms b
rlm@61 946 Vector3f/UNIT_X
rlm@61 947 Quaternion/IDENTITY
rlm@61 948 ;;(doto (Quaternion.)
rlm@61 949 ;; (.fromAngles (/ Math/PI 2)
rlm@61 950 ;; 0
rlm@61 951 ;; 0
rlm@61 952
rlm@61 953 (Vector3f. 1 1 1))
rlm@61 954 )
rlm@61 955
rlm@61 956 (println-repl "hi! <3"))))
rlm@61 957
rlm@61 958
rlm@61 959 (defn test-ragdoll []
rlm@61 960
rlm@61 961 (let [the-worm
rlm@61 962
rlm@61 963 ;;(.loadModel (asset-manager) "Models/anim2/Cube.mesh.xml")
rlm@61 964 (doto (show-skeleton (worm-blender))
rlm@61 965 (.setLocalTranslation (Vector3f. 0 10 0))
rlm@61 966 ;;(worm)
rlm@61 967 ;;(oto)
rlm@61 968 ;;(sinbad)
rlm@61 969 )
rlm@61 970 ]
rlm@61 971
rlm@61 972
rlm@61 973 (.start
rlm@61 974 (world
rlm@61 975 (doto (Node.)
rlm@61 976 (.attachChild the-worm))
rlm@61 977 {"key-return" (fire-cannon-ball)
rlm@61 978 "key-space" (partial test-zzz the-worm)
rlm@61 979 }
rlm@61 980 (fn [world]
rlm@61 981 (light-up-everything world)
rlm@61 982 (PhysicsTestHelper/createPhysicsTestWorld
rlm@61 983 (.getRootNode world)
rlm@61 984 (asset-manager)
rlm@61 985 (.getPhysicsSpace
rlm@61 986 (.getState (.getStateManager world) BulletAppState)))
rlm@61 987 (set-gravity world Vector3f/ZERO)
rlm@61 988 ;;(.setTimer world (NanoTimer.))
rlm@61 989 ;;(org.lwjgl.input.Mouse/setGrabbed false)
rlm@61 990 )
rlm@61 991 no-op
rlm@61 992 )
rlm@61 993
rlm@61 994
rlm@61 995 )))
rlm@61 996
rlm@61 997
rlm@61 998 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
rlm@61 999 ;;; here is the ragdoll stuff
rlm@61 1000
rlm@61 1001 (def worm-mesh (.getMesh (.getChild (worm-blender) 0)))
rlm@61 1002 (def mesh worm-mesh)
rlm@61 1003
rlm@61 1004 (.getFloatBuffer mesh VertexBuffer$Type/Position)
rlm@61 1005 (.getFloatBuffer mesh VertexBuffer$Type/BoneWeight)
rlm@61 1006 (.getData (.getBuffer mesh VertexBuffer$Type/BoneIndex))
rlm@61 1007
rlm@61 1008
rlm@61 1009 (defn position [index]
rlm@61 1010 (.get
rlm@61 1011 (.getFloatBuffer worm-mesh VertexBuffer$Type/Position)
rlm@61 1012 index))
rlm@61 1013
rlm@61 1014 (defn bones [index]
rlm@61 1015 (.get
rlm@61 1016 (.getData (.getBuffer mesh VertexBuffer$Type/BoneIndex))
rlm@61 1017 index))
rlm@61 1018
rlm@61 1019 (defn bone-weights [index]
rlm@61 1020 (.get
rlm@61 1021 (.getFloatBuffer mesh VertexBuffer$Type/BoneWeight)
rlm@61 1022 index))
rlm@61 1023
rlm@61 1024
rlm@61 1025
rlm@61 1026 (defn vertex-bones [vertex]
rlm@61 1027 (vec (map (comp int bones) (range (* vertex 4) (+ (* vertex 4) 4)))))
rlm@61 1028
rlm@61 1029 (defn vertex-weights [vertex]
rlm@61 1030 (vec (map (comp float bone-weights) (range (* vertex 4) (+ (* vertex 4) 4)))))
rlm@61 1031
rlm@61 1032 (defn vertex-position [index]
rlm@61 1033 (let [offset (* index 3)]
rlm@61 1034 (Vector3f. (position offset)
rlm@61 1035 (position (inc offset))
rlm@61 1036 (position (inc(inc offset))))))
rlm@61 1037
rlm@61 1038 (def vertex-info (juxt vertex-position vertex-bones vertex-weights))
rlm@61 1039
rlm@61 1040 (defn bone-control-color [index]
rlm@61 1041 (get {[1 0 0 0] ColorRGBA/Red
rlm@61 1042 [1 2 0 0] ColorRGBA/Magenta
rlm@61 1043 [2 0 0 0] ColorRGBA/Blue}
rlm@61 1044 (vertex-bones index)
rlm@61 1045 ColorRGBA/White))
rlm@61 1046
rlm@61 1047 (defn influence-color [index bone-num]
rlm@61 1048 (get
rlm@61 1049 {(float 0) ColorRGBA/Blue
rlm@61 1050 (float 0.5) ColorRGBA/Green
rlm@61 1051 (float 1) ColorRGBA/Red}
rlm@61 1052 ;; find the weight of the desired bone
rlm@61 1053 ((zipmap (vertex-bones index)(vertex-weights index))
rlm@61 1054 bone-num)
rlm@61 1055 ColorRGBA/Blue))
rlm@61 1056
rlm@61 1057 (def worm-vertices (set (map vertex-info (range 60))))
rlm@61 1058
rlm@61 1059
rlm@61 1060 (defn test-info []
rlm@61 1061 (let [points (Node.)]
rlm@61 1062 (dorun
rlm@61 1063 (map #(.attachChild points %)
rlm@61 1064 (map #(sphere 0.01
rlm@61 1065 :position (vertex-position %)
rlm@61 1066 :color (influence-color % 1)
rlm@61 1067 :physical? false)
rlm@61 1068 (range 60))))
rlm@61 1069 (view points)))
rlm@61 1070
rlm@61 1071
rlm@61 1072 (defrecord JointControl [joint physics-space]
rlm@61 1073 PhysicsControl
rlm@61 1074 (setPhysicsSpace [this space]
rlm@61 1075 (dosync
rlm@61 1076 (ref-set (:physics-space this) space))
rlm@61 1077 (.addJoint space (:joint this)))
rlm@61 1078 (update [this tpf])
rlm@61 1079 (setSpatial [this spatial])
rlm@61 1080 (render [this rm vp])
rlm@61 1081 (getPhysicsSpace [this] (deref (:physics-space this)))
rlm@61 1082 (isEnabled [this] true)
rlm@61 1083 (setEnabled [this state]))
rlm@61 1084
rlm@61 1085 (defn add-joint
rlm@61 1086 "Add a joint to a particular object. When the object is added to the
rlm@61 1087 PhysicsSpace of a simulation, the joint will also be added"
rlm@61 1088 [object joint]
rlm@61 1089 (let [control (JointControl. joint (ref nil))]
rlm@61 1090 (.addControl object control))
rlm@61 1091 object)
rlm@61 1092
rlm@61 1093
rlm@61 1094 (defn hinge-world
rlm@61 1095 []
rlm@61 1096 (let [sphere1 (sphere)
rlm@61 1097 sphere2 (sphere 1 :position (Vector3f. 3 3 3))
rlm@61 1098 joint (Point2PointJoint.
rlm@61 1099 (.getControl sphere1 RigidBodyControl)
rlm@61 1100 (.getControl sphere2 RigidBodyControl)
rlm@61 1101 Vector3f/ZERO (Vector3f. 3 3 3))]
rlm@61 1102 (add-joint sphere1 joint)
rlm@61 1103 (doto (Node. "hinge-world")
rlm@61 1104 (.attachChild sphere1)
rlm@61 1105 (.attachChild sphere2))))
rlm@61 1106
rlm@61 1107
rlm@61 1108 (defn test-joint []
rlm@61 1109 (view (hinge-world)))
rlm@61 1110
rlm@61 1111 ;; (defn copier-gen []
rlm@61 1112 ;; (let [count (atom 0)]
rlm@61 1113 ;; (fn [in]
rlm@61 1114 ;; (swap! count inc)
rlm@61 1115 ;; (clojure.contrib.duck-streams/copy
rlm@61 1116 ;; in (File. (str "/home/r/tmp/mao-test/clojure-images/"
rlm@61 1117 ;; ;;/home/r/tmp/mao-test/clojure-images
rlm@61 1118 ;; (format "%08d.png" @count)))))))
rlm@61 1119 ;; (defn decrease-framerate []
rlm@61 1120 ;; (map
rlm@61 1121 ;; (copier-gen)
rlm@61 1122 ;; (sort
rlm@61 1123 ;; (map first
rlm@61 1124 ;; (partition
rlm@61 1125 ;; 4
rlm@61 1126 ;; (filter #(re-matches #".*.png$" (.getCanonicalPath %))
rlm@61 1127 ;; (file-seq
rlm@61 1128 ;; (file-str
rlm@61 1129 ;; "/home/r/media/anime/mao-temp/images"))))))))
rlm@61 1130
rlm@61 1131
rlm@61 1132
rlm@61 1133 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
rlm@61 1134
rlm@61 1135 (defn proprioception
rlm@61 1136 "Create a proprioception map that reports the rotations of the
rlm@61 1137 various limbs of the creature's body"
rlm@61 1138 [creature]
rlm@61 1139 [#^Node creature]
rlm@61 1140 (let [
rlm@61 1141 nodes (node-seq creature)
rlm@61 1142 joints
rlm@61 1143 (map
rlm@61 1144 :joint
rlm@61 1145 (filter
rlm@61 1146 #(isa? (class %) JointControl)
rlm@61 1147 (reduce
rlm@61 1148 concat
rlm@61 1149 (map (fn [node]
rlm@61 1150 (map (fn [num] (.getControl node num))
rlm@61 1151 (range (.getNumControls node))))
rlm@61 1152 nodes))))]
rlm@61 1153 (fn []
rlm@61 1154 (reduce concat (map relative-positions (list (first joints)))))))
rlm@61 1155
rlm@61 1156
rlm@63 1157 (defn skel [node]
rlm@63 1158 (doto
rlm@63 1159 (.getSkeleton
rlm@63 1160 (.getControl node SkeletonControl))
rlm@63 1161 ;; this is necessary to force the skeleton to have accurate world
rlm@63 1162 ;; transforms before it is rendered to the screen.
rlm@63 1163 (.resetAndUpdate)))
rlm@63 1164
rlm@63 1165 (defn green-x-ray []
rlm@63 1166 (doto (Material. (asset-manager)
rlm@63 1167 "Common/MatDefs/Misc/Unshaded.j3md")
rlm@63 1168 (.setColor "Color" ColorRGBA/Green)
rlm@63 1169 (-> (.getAdditionalRenderState)
rlm@63 1170 (.setDepthTest false))))
rlm@63 1171
rlm@63 1172 (defn test-worm []
rlm@63 1173 (.start
rlm@63 1174 (world
rlm@63 1175 (doto (Node.)
rlm@63 1176 ;;(.attachChild (point-worm))
rlm@63 1177 (.attachChild (load-blender-model
rlm@63 1178 "Models/anim2/joint-worm.blend"))
rlm@63 1179
rlm@63 1180 (.attachChild (box 10 1 10
rlm@63 1181 :position (Vector3f. 0 -2 0) :mass 0
rlm@63 1182 :color (ColorRGBA/Gray))))
rlm@63 1183 {
rlm@63 1184 "key-space" (fire-cannon-ball)
rlm@63 1185 }
rlm@63 1186 (fn [world]
rlm@63 1187 (enable-debug world)
rlm@63 1188 (light-up-everything world)
rlm@63 1189 ;;(.setTimer world (NanoTimer.))
rlm@63 1190 )
rlm@63 1191 no-op)))
rlm@63 1192
rlm@63 1193
rlm@63 1194
rlm@63 1195 ;; defunct movement stuff
rlm@63 1196 (defn torque-controls [control]
rlm@63 1197 (let [torques
rlm@63 1198 (concat
rlm@63 1199 (map #(Vector3f. 0 (Math/sin %) (Math/cos %))
rlm@63 1200 (range 0 (* Math/PI 2) (/ (* Math/PI 2) 20)))
rlm@63 1201 [Vector3f/UNIT_X])]
rlm@63 1202 (map (fn [torque-axis]
rlm@63 1203 (fn [torque]
rlm@63 1204 (.applyTorque
rlm@63 1205 control
rlm@63 1206 (.mult (.mult (.getPhysicsRotation control)
rlm@63 1207 torque-axis)
rlm@63 1208 (float
rlm@63 1209 (* (.getMass control) torque))))))
rlm@63 1210 torques)))
rlm@63 1211
rlm@63 1212 (defn motor-map
rlm@63 1213 "Take a creature and generate a function that will enable fine
rlm@63 1214 grained control over all the creature's limbs."
rlm@63 1215 [#^Node creature]
rlm@63 1216 (let [controls (keep #(.getControl % RigidBodyControl)
rlm@63 1217 (node-seq creature))
rlm@63 1218 limb-controls (reduce concat (map torque-controls controls))
rlm@63 1219 body-control (partial map #(%1 %2) limb-controls)]
rlm@63 1220 body-control))
rlm@63 1221
rlm@63 1222 (defn test-motor-map
rlm@63 1223 "see how torque works."
rlm@63 1224 []
rlm@63 1225 (let [finger (box 3 0.5 0.5 :position (Vector3f. 0 2 0)
rlm@63 1226 :mass 1 :color ColorRGBA/Green)
rlm@63 1227 motor-map (motor-map finger)]
rlm@63 1228 (world
rlm@63 1229 (nodify [finger
rlm@63 1230 (box 10 0.5 10 :position (Vector3f. 0 -5 0) :mass 0
rlm@63 1231 :color ColorRGBA/Gray)])
rlm@63 1232 standard-debug-controls
rlm@63 1233 (fn [world]
rlm@63 1234 (set-gravity world Vector3f/ZERO)
rlm@63 1235 (light-up-everything world)
rlm@63 1236 (.setTimer world (NanoTimer.)))
rlm@63 1237 (fn [_ _]
rlm@145 1238 (dorun (motor-map [0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0
rlm@145 1239 0]))))))
rlm@145 1240
rlm@145 1241 (defn joint-proprioception [#^Node parts #^Node joint]
rlm@145 1242 (let [[obj-a obj-b] (joint-targets parts joint)
rlm@145 1243 joint-rot (.getWorldRotation joint)
rlm@145 1244 pre-inv-a (.inverse (.getWorldRotation obj-a))
rlm@145 1245 x (.mult pre-inv-a (.mult joint-rot Vector3f/UNIT_X))
rlm@145 1246 y (.mult pre-inv-a (.mult joint-rot Vector3f/UNIT_Y))
rlm@145 1247 z (.mult pre-inv-a (.mult joint-rot Vector3f/UNIT_Z))
rlm@145 1248
rlm@145 1249 x Vector3f/UNIT_Y
rlm@145 1250 y Vector3f/UNIT_Z
rlm@145 1251 z Vector3f/UNIT_X
rlm@145 1252
rlm@145 1253
rlm@145 1254 tmp-rot-a (.getWorldRotation obj-a)]
rlm@145 1255 (println-repl "x:" (.mult tmp-rot-a x))
rlm@145 1256 (println-repl "y:" (.mult tmp-rot-a y))
rlm@145 1257 (println-repl "z:" (.mult tmp-rot-a z))
rlm@145 1258 (println-repl "rot-a" (.getWorldRotation obj-a))
rlm@145 1259 (println-repl "rot-b" (.getWorldRotation obj-b))
rlm@145 1260 (println-repl "joint-rot" joint-rot)
rlm@145 1261 ;; this function will report proprioceptive information for the
rlm@145 1262 ;; joint.
rlm@145 1263 (fn []
rlm@145 1264 ;; x is the "twist" axis, y and z are the "bend" axes
rlm@145 1265 (let [rot-a (.getWorldRotation obj-a)
rlm@145 1266 ;;inv-a (.inverse rot-a)
rlm@145 1267 rot-b (.getWorldRotation obj-b)
rlm@145 1268 ;;relative (.mult rot-b inv-a)
rlm@145 1269 basis (doto (Matrix3f.)
rlm@145 1270 (.setColumn 0 (.mult rot-a x))
rlm@145 1271 (.setColumn 1 (.mult rot-a y))
rlm@145 1272 (.setColumn 2 (.mult rot-a z)))
rlm@145 1273 rotation-about-joint
rlm@145 1274 (doto (Quaternion.)
rlm@145 1275 (.fromRotationMatrix
rlm@145 1276 (.mult (.invert basis)
rlm@145 1277 (.toRotationMatrix rot-b))))
rlm@145 1278 [yaw roll pitch]
rlm@145 1279 (seq (.toAngles rotation-about-joint nil))]
rlm@145 1280 ;;return euler angles of the quaternion around the new basis
rlm@145 1281 [yaw roll pitch]))))
rlm@145 1282
rlm@61 1283 #+end_src
rlm@0 1284
rlm@0 1285
rlm@0 1286
rlm@0 1287
rlm@0 1288
rlm@0 1289
rlm@0 1290
rlm@73 1291 * COMMENT generate Source
rlm@44 1292 #+begin_src clojure :tangle ../src/cortex/body.clj
rlm@205 1293 <<body-header>>
rlm@205 1294 <<body-1>>
rlm@205 1295 <<joints-2>>
rlm@205 1296 <<joints-3>>
rlm@205 1297 <<joints-4>>
rlm@205 1298 <<joints-5>>
rlm@205 1299 <<joints-6>>
rlm@0 1300 #+end_src
rlm@64 1301
rlm@69 1302 #+begin_src clojure :tangle ../src/cortex/test/body.clj
rlm@205 1303 <<test-header>>
rlm@205 1304 <<test-1>>
rlm@205 1305 <<test-2>>
rlm@205 1306 <<test-3>>
rlm@205 1307 <<test-4>>
rlm@64 1308 #+end_src
rlm@64 1309
rlm@64 1310
rlm@0 1311