view org/util.org @ 55:8b95180f5c69

getting basic hinges to work
author Robert McIntyre <rlm@mit.edu>
date Tue, 15 Nov 2011 17:48:10 -0700
parents b1b90c4ab0bf
children e5e627f50a3a
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 #+srcname: 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
79 *** Changing Settings
81 #+srcname: util
82 #+begin_src clojure
83 (ns cortex.util
84 "Utility functions for making jMonkeyEngine3 easier to program from
85 clojure."
86 {:author "Robert McIntyre"}
87 (:use cortex.world)
88 (:use clojure.contrib.def)
89 (:import com.jme3.math.Vector3f)
90 (:import com.jme3.math.Quaternion)
91 (:import com.jme3.asset.TextureKey)
92 (:import com.jme3.bullet.control.RigidBodyControl)
93 (:import com.jme3.bullet.collision.shapes.GImpactCollisionShape)
94 (:import com.jme3.scene.shape.Box)
95 (:import com.jme3.scene.Node)
96 (:import com.jme3.scene.shape.Sphere)
97 (:import com.jme3.light.AmbientLight)
98 (:import com.jme3.light.DirectionalLight)
99 (:import com.jme3.math.ColorRGBA)
100 (:import com.jme3.bullet.BulletAppState)
101 (:import com.jme3.material.Material)
102 (:import com.jme3.scene.Geometry)
103 (:import (java.util.logging Level Logger)))
107 (defvar println-repl
108 (bound-fn [& args] (apply println args))
109 "println called from the LWJGL thread will not go to the REPL, but
110 instead to whatever terminal started the JVM process. This function
111 will always output to the REPL")
113 (defn position-camera
114 "Change the position of the in-world camera."
115 ([world position direction up]
116 (doto (.getCamera world)
117 (.setLocation )
118 (.lookAt direction up)))
119 ([world position direction]
120 (position-camera
121 world position direction Vector3f/UNIT_Y)))
123 (defn enable-debug
124 "Turn on debug wireframes for every object in this simulation."
125 [world]
126 (.enableDebug
127 (.getPhysicsSpace
128 (.getState
129 (.getStateManager world)
130 BulletAppState))
131 (asset-manager)))
133 (defn no-logging
134 "Disable all of jMonkeyEngine's logging."
135 []
136 (.setLevel (Logger/getLogger "com.jme3") Level/OFF))
138 (defn set-accuracy
139 "Change the accuracy at which the World's Physics is calculated."
140 [world new-accuracy]
141 (let [physics-manager
142 (.getState
143 (.getStateManager world) BulletAppState)]
144 (.setAccuracy
145 (.getPhysicsSpace physics-manager)
146 (float new-accuracy))))
149 (defn set-gravity
150 "In order to change the gravity of a scene, it is not only necessary
151 to set the gravity variable, but to \"tap\" every physics object in
152 the scene to reactivate physics calculations."
153 [world gravity]
154 (traverse
155 (fn [geom]
156 (if-let
157 ;; only set gravity for physical objects.
158 [control (.getControl geom RigidBodyControl)]
159 (do
160 (.setGravity control gravity)
161 ;; tappsies!
162 (.applyImpulse control Vector3f/ZERO Vector3f/ZERO))))
163 (.getRootNode world)))
165 (defn add-element
166 "Add the Spatial to the world's environment"
167 ([world element node]
168 (.addAll
169 (.getPhysicsSpace
170 (.getState
171 (.getStateManager world)
172 BulletAppState))
173 element)
174 (.attachChild node element))
175 ([world element]
176 (add-element world element (.getRootNode world))))
178 (defn apply-map
179 "Like apply, but works for maps and functions that expect an
180 implicit map and nothing else as in (fn [& {}]).
181 ------- Example -------
182 (defn demo [& {:keys [www] :or {www \"oh yeah\"} :as env}]
183 (println www))
184 (apply-map demo {:www \"hello!\"})
185 -->\"hello\""
186 [fn m]
187 (apply fn (reduce #(into %1 %2) [] m)))
189 #+end_src
191 #+results: util
192 : #'cortex.util/apply-map
195 *** Creating Basic Shapes
197 #+srcname: shapes
198 #+begin_src clojure :results silent
199 (in-ns 'cortex.util)
201 (defrecord shape-description
202 [name
203 color
204 mass
205 friction
206 texture
207 material
208 position
209 rotation
210 shape
211 physical?
212 GImpact?
213 ])
215 (defvar base-shape
216 (shape-description.
217 "default-shape"
218 false
219 ;;ColorRGBA/Blue
220 1.0 ;; mass
221 1.0 ;; friction
222 ;; texture
223 "Textures/Terrain/BrickWall/BrickWall.jpg"
224 ;; material
225 "Common/MatDefs/Misc/Unshaded.j3md"
226 Vector3f/ZERO
227 Quaternion/IDENTITY
228 (Box. Vector3f/ZERO 0.5 0.5 0.5)
229 true
230 false)
231 "Basic settings for shapes.")
233 (defn make-shape
234 [#^shape-description d]
235 (let [asset-manager (asset-manager)
236 mat (Material. asset-manager (:material d))
237 geom (Geometry. (:name d) (:shape d))]
238 (if (:texture d)
239 (let [key (TextureKey. (:texture d))]
240 ;;(.setGenerateMips key true)
241 ;;(.setTexture mat "ColorMap" (.loadTexture asset-manager key))
242 ))
243 (if (:color d) (.setColor mat "Color" (:color d)))
244 (.setMaterial geom mat)
245 (if-let [rotation (:rotation d)] (.rotate geom rotation))
246 (.setLocalTranslation geom (:position d))
247 (if (:physical? d)
248 (let [physics-control
249 (if (:GImpact d)
250 ;; Create an accurate mesh collision shape if desired.
251 (RigidBodyControl.
252 (doto (GImpactCollisionShape.
253 (.getMesh geom))
254 (.createJmeMesh)
255 (.setMargin 0))
256 (float (:mass d)))
257 ;; otherwise use jme3's default
258 (RigidBodyControl. (float (:mass d))))]
259 (.addControl geom physics-control)
260 ;;(.setSleepingThresholds physics-control (float 0) (float 0))
261 (.setFriction physics-control (:friction d))))
262 geom))
264 (defn box
265 ([l w h & {:as options}]
266 (let [options (merge base-shape options)]
267 (make-shape (assoc options
268 :shape (Box. l w h)))))
269 ([] (box 0.5 0.5 0.5)))
271 (defn sphere
272 ([r & {:as options}]
273 (let [options (merge base-shape options)]
274 (make-shape (assoc options
275 :shape (Sphere. 32 32 (float r))))))
276 ([] (sphere 0.5)))
277 #+end_src
280 *** Debug Actions
281 #+srcname: debug-actions
282 #+begin_src clojure :results silent
283 (defn basic-light-setup
284 "returns a sequence of lights appropiate for fully lighting a scene"
285 []
286 (conj
287 (doall
288 (map
289 (fn [direction]
290 (doto (DirectionalLight.)
291 (.setDirection direction)
292 (.setColor ColorRGBA/White)))
293 [;; six faces of a cube
294 Vector3f/UNIT_X
295 Vector3f/UNIT_Y
296 Vector3f/UNIT_Z
297 (.mult Vector3f/UNIT_X (float -1))
298 (.mult Vector3f/UNIT_Y (float -1))
299 (.mult Vector3f/UNIT_Z (float -1))]))
300 (doto (AmbientLight.)
301 (.setColor ColorRGBA/White))))
303 (defn light-up-everything
304 "Add lights to a world appropiate for quickly seeing everything
305 in the scene. Adds six DirectionalLights facing in orthogonal
306 directions, and one AmbientLight to provide overall lighting
307 coverage."
308 [world]
309 (dorun
310 (map
311 #(.addLight (.getRootNode world) %)
312 (basic-light-setup))))
314 (defn fire-cannon-ball
315 "Creates a function that fires a cannon-ball from the current game's
316 camera. The cannon-ball will be attached to the node if provided, or
317 to the game's RootNode if no node is provided."
318 ([node]
319 (fn [game value]
320 (if (not value)
321 (let [camera (.getCamera game)
322 cannon-ball
323 (sphere 0.7
324 :material "Common/MatDefs/Misc/Unshaded.j3md"
325 :texture "Textures/PokeCopper.jpg"
326 :position
327 (.add (.getLocation camera)
328 (.mult (.getDirection camera) (float 1)))
329 :mass 3)] ;200 0.05
330 (.setLinearVelocity
331 (.getControl cannon-ball RigidBodyControl)
332 (.mult (.getDirection camera) (float 50))) ;50
333 (add-element game cannon-ball (if node node (.getRootNode game)))))))
334 ([]
335 (fire-cannon-ball false)))
336 #+end_src
339 *** Viewing Objects
341 #+srcname: world-view
342 #+begin_src clojure :results silent
343 (in-ns 'cortex.util)
345 (defprotocol Viewable
346 (view [something]))
348 (extend-type com.jme3.scene.Geometry
349 Viewable
350 (view [geo]
351 (view (doto (Node.)(.attachChild geo)))))
353 (extend-type com.jme3.scene.Node
354 Viewable
355 (view
356 [node]
357 (.start
358 (world
359 node
360 {}
361 (fn [world]
362 (enable-debug world)
363 (set-gravity world Vector3f/ZERO)
364 (light-up-everything world))
365 no-op))))
366 #+end_src
368 Here I make the =Viewable= protocol and extend it to JME's types. Now
369 JME3's =hello-world= can be written as easily as:
371 #+begin_src clojure :results silent
372 (cortex.util/view (cortex.util/box))
373 #+end_src
376 * COMMENT code generation
377 #+begin_src clojure :tangle ../src/cortex/import.clj
378 <<import>>
379 #+end_src
382 #+begin_src clojure :tangle ../src/cortex/util.clj :noweb yes
383 <<util>>
384 <<shapes>>
385 <<debug-actions>>
386 <<world-view>>
387 #+end_src