Mercurial > cortex

annotate org/body.org @ 204:162b24a82712

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