view org/util.org @ 247:4e220c8fb1ed

first pass at rough draft complete
author Robert McIntyre <rlm@mit.edu>
date Sun, 12 Feb 2012 15:46:01 -0700
parents f5ea63245b3b
children d1206b11ae2d
line wrap: on
line source
1 #+title: Clojure Utilities for jMonkeyEngine3
2 #+author: Robert McIntyre
3 #+email: rlm@mit.edu
4 #+description:
5 #+keywords: JME3, clojure, import, utilities
6 #+SETUPFILE: ../../aurellem/org/setup.org
7 #+INCLUDE: ../../aurellem/org/level-0.org
9 [TABLE-OF-CONTENTS]
11 These are a collection of functions to make programming jMonkeyEngine
12 in clojure easier.
14 * Imports
16 #+name: import
17 #+begin_src clojure :results silent
18 (ns cortex.import
19 (:require swank.util.class-browse))
21 (defn permissive-import
22 [classname]
23 (eval `(try (import '~classname)
24 (catch java.lang.Exception e#
25 (println "couldn't import " '~classname))))
26 classname)
28 (defn jme-class? [classname]
29 (and
30 (.startsWith classname "com.jme3.")
31 ;; Don't import the Lwjgl stuff since it can throw exceptions
32 ;; upon being loaded.
33 (not (re-matches #".*Lwjgl.*" classname))))
35 (defn jme-classes
36 "returns a list of all jme3 classes"
37 []
38 (filter
39 jme-class?
40 (map :name
41 swank.util.class-browse/available-classes)))
43 (defn mega-import-jme3
44 "Import ALL the jme classes. For REPL use."
45 []
46 (doall
47 (map (comp permissive-import symbol) (jme-classes))))
48 #+end_src
50 jMonkeyEngine3 has a plethora of classes which can be overwhelming to
51 manage. This code uses reflection to import all of them. Once I'm
52 happy with the general structure of a namespace I can deal with
53 importing only the classes it actually needs.
55 The =mega-import-jme3= is quite usefull for debugging purposes since
56 it allows completion for almost all of JME's classes from the REPL.
58 Out of curiousity, let's see just how many classes =mega-import-jme3=
59 imports:
61 #+begin_src clojure :exports both :results output
62 (println (clojure.core/count (cortex.import/jme-classes)) "classes")
63 #+end_src
65 #+results:
66 : 955 classes
69 * Utilities
71 The utilities here come in three main groups:
72 - Changing settings in a running =Application=
73 - Creating objects
74 - Debug Actions
75 - Visualizing objects
77 *** Changing Settings
79 #+name: util
80 #+begin_src clojure
81 (ns cortex.util
82 "Utility functions for making jMonkeyEngine3 easier to program from
83 clojure."
84 {:author "Robert McIntyre"}
85 (:use cortex.world)
86 (:use clojure.contrib.def)
87 (:import com.jme3.math.Vector3f)
88 (:import com.jme3.math.Quaternion)
89 (:import com.jme3.asset.TextureKey)
90 (:import com.jme3.bullet.control.RigidBodyControl)
91 (:import com.jme3.bullet.collision.shapes.GImpactCollisionShape)
92 (:import com.jme3.scene.shape.Box)
93 (:import com.jme3.scene.Node)
94 (:import com.jme3.scene.shape.Sphere)
95 (:import com.jme3.light.AmbientLight)
96 (:import com.jme3.light.DirectionalLight)
97 (:import (com.jme3.math Triangle ColorRGBA))
98 (:import com.jme3.bullet.BulletAppState)
99 (:import com.jme3.material.Material)
100 (:import com.jme3.scene.Geometry)
101 (:import java.awt.image.BufferedImage)
102 (:import javax.swing.JPanel)
103 (:import javax.swing.JFrame)
104 (:import javax.swing.SwingUtilities)
105 (:import com.jme3.scene.plugins.blender.BlenderModelLoader)
106 (:import (java.util.logging Level Logger)))
108 (defvar println-repl
109 (bound-fn [& args] (apply println args))
110 "println called from the LWJGL thread will not go to the REPL, but
111 instead to whatever terminal started the JVM process. This function
112 will always output to the REPL")
114 (defn position-camera
115 "Change the position of the in-world camera."
116 ([world position direction up]
117 (doto (.getCamera world)
118 (.setLocation )
119 (.lookAt direction up)))
120 ([world position direction]
121 (position-camera
122 world position direction Vector3f/UNIT_Y)))
124 (defn enable-debug
125 "Turn on debug wireframes for every object in this simulation."
126 [world]
127 (.enableDebug
128 (.getPhysicsSpace
129 (.getState
130 (.getStateManager world)
131 BulletAppState))
132 (asset-manager)))
134 (defn speed-up
135 "Increase the dismally slow speed of the world's camera."
136 [world]
137 (.setMoveSpeed (.getFlyByCamera world)
138 (float 60))
139 (.setRotationSpeed (.getFlyByCamera world)
140 (float 3))
141 world)
144 (defn no-logging
145 "Disable all of jMonkeyEngine's logging."
146 []
147 (.setLevel (Logger/getLogger "com.jme3") Level/OFF))
149 (defn set-accuracy
150 "Change the accuracy at which the World's Physics is calculated."
151 [world new-accuracy]
152 (let [physics-manager
153 (.getState
154 (.getStateManager world) BulletAppState)]
155 (.setAccuracy
156 (.getPhysicsSpace physics-manager)
157 (float new-accuracy))))
160 (defn set-gravity
161 "In order to change the gravity of a scene, it is not only necessary
162 to set the gravity variable, but to \"tap\" every physics object in
163 the scene to reactivate physics calculations."
164 [world gravity]
165 (traverse
166 (fn [geom]
167 (if-let
168 ;; only set gravity for physical objects.
169 [control (.getControl geom RigidBodyControl)]
170 (do
171 (.setGravity control gravity)
172 ;; tappsies!
173 (.applyImpulse control Vector3f/ZERO Vector3f/ZERO))))
174 (.getRootNode world)))
176 (defn add-element
177 "Add the Spatial to the world's environment"
178 ([world element node]
179 (.addAll
180 (.getPhysicsSpace
181 (.getState
182 (.getStateManager world)
183 BulletAppState))
184 element)
185 (.attachChild node element))
186 ([world element]
187 (add-element world element (.getRootNode world))))
189 (defn apply-map
190 "Like apply, but works for maps and functions that expect an
191 implicit map and nothing else as in (fn [& {}]).
192 ------- Example -------
193 (defn demo [& {:keys [www] :or {www \"oh yeah\"} :as env}]
194 (println www))
195 (apply-map demo {:www \"hello!\"})
196 -->\"hello\""
197 [fn m]
198 (apply fn (reduce #(into %1 %2) [] m)))
200 (defn map-vals
201 "Transform a map by applying a function to its values,
202 keeping the keys the same."
203 [f m] (zipmap (keys m) (map f (vals m))))
205 (defn runonce
206 "Decorator. returns a function which will run only once.
207 Inspired by Halloway's version from Lancet."
208 {:author "Robert McIntyre"}
209 [function]
210 (let [sentinel (Object.)
211 result (atom sentinel)]
212 (fn [& args]
213 (locking sentinel
214 (if (= @result sentinel)
215 (reset! result (apply function args))
216 @result)))))
219 #+end_src
221 #+results: util
222 : #'cortex.util/apply-map
225 *** Creating Basic Shapes
227 #+name: shapes
228 #+begin_src clojure :results silent
229 (in-ns 'cortex.util)
231 (defn load-bullet
232 "Runnig this function unpacks the native bullet libraries and makes
233 them available."
234 []
235 (let [sim (world (Node.) {} no-op no-op)]
236 (doto sim
237 (.enqueue
238 (fn []
239 (.stop sim)))
240 (.start))))
243 (defrecord shape-description
244 [name
245 color
246 mass
247 friction
248 texture
249 material
250 position
251 rotation
252 shape
253 physical?
254 GImpact?
255 ])
257 (defvar base-shape
258 (shape-description.
259 "default-shape"
260 false
261 ;;ColorRGBA/Blue
262 1.0 ;; mass
263 1.0 ;; friction
264 ;; texture
265 "Textures/Terrain/BrickWall/BrickWall.jpg"
266 ;; material
267 "Common/MatDefs/Misc/Unshaded.j3md"
268 Vector3f/ZERO
269 Quaternion/IDENTITY
270 (Box. Vector3f/ZERO 0.5 0.5 0.5)
271 true
272 false)
273 "Basic settings for shapes.")
275 (defn make-shape
276 [#^shape-description d]
277 (let [asset-manager (asset-manager)
278 mat (Material. asset-manager (:material d))
279 geom (Geometry. (:name d) (:shape d))]
280 (if (:texture d)
281 (let [key (TextureKey. (:texture d))]
282 ;;(.setGenerateMips key true)
283 ;;(.setTexture mat "ColorMap" (.loadTexture asset-manager key))
284 ))
285 (if (:color d) (.setColor mat "Color" (:color d)))
286 (.setMaterial geom mat)
287 (if-let [rotation (:rotation d)] (.rotate geom rotation))
288 (.setLocalTranslation geom (:position d))
289 (if (:physical? d)
290 (let [physics-control
291 (if (:GImpact d)
292 ;; Create an accurate mesh collision shape if desired.
293 (RigidBodyControl.
294 (doto (GImpactCollisionShape.
295 (.getMesh geom))
296 (.createJmeMesh)
297 ;;(.setMargin 0)
298 )
299 (float (:mass d)))
300 ;; otherwise use jme3's default
301 (RigidBodyControl. (float (:mass d))))]
302 (.addControl geom physics-control)
303 ;;(.setSleepingThresholds physics-control (float 0) (float 0))
304 (.setFriction physics-control (:friction d))))
305 geom))
307 (defn box
308 ([l w h & {:as options}]
309 (let [options (merge base-shape options)]
310 (make-shape (assoc options
311 :shape (Box. l w h)))))
312 ([] (box 0.5 0.5 0.5)))
314 (defn sphere
315 ([r & {:as options}]
316 (let [options (merge base-shape options)]
317 (make-shape (assoc options
318 :shape (Sphere. 32 32 (float r))))))
319 ([] (sphere 0.5)))
321 (defn x-ray
322 "A usefull material for debuging -- it can be seen no matter what
323 object occuldes it."
324 [#^ColorRGBA color]
325 (doto (Material. (asset-manager)
326 "Common/MatDefs/Misc/Unshaded.j3md")
327 (.setColor "Color" color)
328 (-> (.getAdditionalRenderState)
329 (.setDepthTest false))))
331 (defn node-seq
332 "Take a node and return a seq of all its children
333 recursively. There will be no nodes left in the resulting
334 structure"
335 [#^Node node]
336 (tree-seq #(isa? (class %) Node) #(.getChildren %) node))
338 (defn nodify
339 "Take a sequence of things that can be attached to a node and return
340 a node with all of them attached"
341 ([name children]
342 (let [node (Node. name)]
343 (dorun (map #(.attachChild node %) children))
344 node))
345 ([children] (nodify "" children)))
347 (defn load-blender-model
348 "Load a .blend file using an asset folder relative path."
349 [^String model]
350 (.loadModel
351 (doto (asset-manager)
352 (.registerLoader BlenderModelLoader
353 (into-array String ["blend"]))) model))
356 #+end_src
359 *** Debug Actions
360 #+name: debug-actions
361 #+begin_src clojure :results silent
362 (in-ns 'cortex.util)
364 (defn basic-light-setup
365 "returns a sequence of lights appropiate for fully lighting a scene"
366 []
367 (conj
368 (doall
369 (map
370 (fn [direction]
371 (doto (DirectionalLight.)
372 (.setDirection direction)
373 (.setColor ColorRGBA/White)))
374 [;; six faces of a cube
375 Vector3f/UNIT_X
376 Vector3f/UNIT_Y
377 Vector3f/UNIT_Z
378 (.mult Vector3f/UNIT_X (float -1))
379 (.mult Vector3f/UNIT_Y (float -1))
380 (.mult Vector3f/UNIT_Z (float -1))]))
381 (doto (AmbientLight.)
382 (.setColor ColorRGBA/White))))
384 (defn light-up-everything
385 "Add lights to a world appropiate for quickly seeing everything
386 in the scene. Adds six DirectionalLights facing in orthogonal
387 directions, and one AmbientLight to provide overall lighting
388 coverage."
389 [world]
390 (dorun
391 (map
392 #(.addLight (.getRootNode world) %)
393 (basic-light-setup))))
395 (defn fire-cannon-ball
396 "Creates a function that fires a cannon-ball from the current game's
397 camera. The cannon-ball will be attached to the node if provided, or
398 to the game's RootNode if no node is provided."
399 ([node]
400 (fn [game value]
401 (if (not value)
402 (let [camera (.getCamera game)
403 cannon-ball
404 (sphere 0.7
405 :material "Common/MatDefs/Misc/Unshaded.j3md"
406 :color ColorRGBA/White
407 :name "cannonball!"
408 :position
409 (.add (.getLocation camera)
410 (.mult (.getDirection camera) (float 1)))
411 :mass 3)] ;200 0.05
412 (.setLinearVelocity
413 (.getControl cannon-ball RigidBodyControl)
414 (.mult (.getDirection camera) (float 50))) ;50
415 (add-element game cannon-ball (if node node (.getRootNode
416 game)))
417 cannon-ball))))
418 ([]
419 (fire-cannon-ball false)))
421 (def standard-debug-controls
422 {"key-space" (fire-cannon-ball)})
425 (defn tap [obj direction force]
426 (let [control (.getControl obj RigidBodyControl)]
427 (.applyTorque
428 control
429 (.mult (.getPhysicsRotation control)
430 (.mult (.normalize direction) (float force))))))
433 (defn with-movement
434 [object
435 [up down left right roll-up roll-down :as keyboard]
436 forces
437 [root-node
438 keymap
439 intilization
440 world-loop]]
441 (let [add-keypress
442 (fn [state keymap key]
443 (merge keymap
444 {key
445 (fn [_ pressed?]
446 (reset! state pressed?))}))
447 move-up? (atom false)
448 move-down? (atom false)
449 move-left? (atom false)
450 move-right? (atom false)
451 roll-left? (atom false)
452 roll-right? (atom false)
454 directions [(Vector3f. 0 1 0)(Vector3f. 0 -1 0)
455 (Vector3f. 0 0 1)(Vector3f. 0 0 -1)
456 (Vector3f. -1 0 0)(Vector3f. 1 0 0)]
457 atoms [move-left? move-right? move-up? move-down?
458 roll-left? roll-right?]
460 keymap* (reduce merge
461 (map #(add-keypress %1 keymap %2)
462 atoms
463 keyboard))
465 splice-loop (fn []
466 (dorun
467 (map
468 (fn [sym direction force]
469 (if @sym
470 (tap object direction force)))
471 atoms directions forces)))
473 world-loop* (fn [world tpf]
474 (world-loop world tpf)
475 (splice-loop))]
476 [root-node
477 keymap*
478 intilization
479 world-loop*]))
481 (import com.jme3.font.BitmapText)
482 (import com.jme3.scene.control.AbstractControl)
483 (import com.aurellem.capture.IsoTimer)
485 (defn display-dialated-time
486 "Shows the time as it is flowing in the simulation on a HUD display.
487 Useful for making videos."
488 [world timer]
489 (let [font (.loadFont (asset-manager) "Interface/Fonts/Default.fnt")
490 text (BitmapText. font false)]
491 (.setLocalTranslation text 300 (.getLineHeight text) 0)
492 (.addControl
493 text
494 (proxy [AbstractControl] []
495 (controlUpdate [tpf]
496 (.setText text (format
497 "%.2f"
498 (float (/ (.getTime timer) 1000)))))
499 (controlRender [_ _])))
500 (.attachChild (.getGuiNode world) text)))
501 #+end_src
504 *** Viewing Objects
506 #+name: world-view
507 #+begin_src clojure :results silent
508 (in-ns 'cortex.util)
510 (defprotocol Viewable
511 (view [something]))
513 (extend-type com.jme3.scene.Geometry
514 Viewable
515 (view [geo]
516 (view (doto (Node.)(.attachChild geo)))))
518 (extend-type com.jme3.scene.Node
519 Viewable
520 (view
521 [node]
522 (.start
523 (world
524 node
525 {}
526 (fn [world]
527 (enable-debug world)
528 (set-gravity world Vector3f/ZERO)
529 (light-up-everything world))
530 no-op))))
532 (extend-type com.jme3.math.ColorRGBA
533 Viewable
534 (view
535 [color]
536 (view (doto (Node.)
537 (.attachChild (box 1 1 1 :color color))))))
539 (defprotocol Textual
540 (text [something]
541 "Display a detailed textual analysis of the given object."))
543 (extend-type com.jme3.scene.Node
544 Textual
545 (text [node]
546 (println "Total Vertexes: " (.getVertexCount node))
547 (println "Total Triangles: " (.getTriangleCount node))
548 (println "Controls :")
549 (dorun (map #(text (.getControl node %)) (range (.getNumControls node))))
550 (println "Has " (.getQuantity node) " Children:")
551 (doall (map text (.getChildren node)))))
553 (extend-type com.jme3.animation.AnimControl
554 Textual
555 (text [control]
556 (let [animations (.getAnimationNames control)]
557 (println "Animation Control with " (count animations) " animation(s):")
558 (dorun (map println animations)))))
560 (extend-type com.jme3.animation.SkeletonControl
561 Textual
562 (text [control]
563 (println "Skeleton Control with the following skeleton:")
564 (println (.getSkeleton control))))
566 (extend-type com.jme3.bullet.control.KinematicRagdollControl
567 Textual
568 (text [control]
569 (println "Ragdoll Control")))
571 (extend-type com.jme3.scene.Geometry
572 Textual
573 (text [control]
574 (println "...geo...")))
576 (extend-type Triangle
577 Textual
578 (text [t]
579 (println "Triangle: " \newline (.get1 t) \newline
580 (.get2 t) \newline (.get3 t))))
582 #+end_src
584 Here I make the =Viewable= protocol and extend it to JME's types. Now
585 JME3's =hello-world= can be written as easily as:
587 #+begin_src clojure :results silent
588 (cortex.util/view (cortex.util/box))
589 #+end_src
592 * COMMENT code generation
593 #+begin_src clojure :tangle ../src/cortex/import.clj
594 <<import>>
595 #+end_src
598 #+begin_src clojure :tangle ../src/cortex/util.clj :noweb yes
599 <<util>>
600 <<shapes>>
601 <<debug-actions>>
602 <<world-view>>
603 #+end_src