cortex: org/util.org comparison

comparison org/util.org @ 29:6372c108c5c6

cleaned up util.org

author	Robert McIntyre <rlm@mit.edu>
date	Mon, 24 Oct 2011 12:35:15 -0700
parents	122f12f81dc1
children	0206878c28b4

comparison

equal deleted inserted replaced

-:122f12f81dc1
+:6372c108c5c6
-#+title: Helper Utilities
+#+title: Clojure Utilities for jMonkeyEngine3
 #+author: Robert McIntyre
 #+email: rlm@mit.edu
-#+description: Simulating senses for AI research using JMonkeyEngine3
+#+description:
+#+keywords: JME3, clojure, import, utilities
 #+SETUPFILE: ../../aurellem/org/setup.org
 #+INCLUDE: ../../aurellem/org/level-0.org
-#+babel: :mkdirp yes :noweb yes :exports both
+* Utilities
+These are a collection of functions to make programming jMonkeyEngine
+in clojure easier.
 ** Imports
-jMonkeyEngine has a plethora of classes which can be overwhelming at
-first. So that I one can get right to coding, it's good to take the
-time right now and make a "import all" function which brings in all of
-the important jme3 classes. Once I'm happy with the general structure
-of a namespace I can deal with importing only the classes it actually
-needs.
 #+srcname: import
 #+begin_src clojure :results silent
 (ns cortex.import
 (:require swank.util.class-browse))
 []
 (doall
 (map (comp permissive-import symbol) (jme-classes))))
 #+end_src
+jMonkeyEngine3 has a plethora of classes which can be overwhelming to
+manage. This code uses reflection to import all of them. Once I'm
+happy with the general structure of a namespace I can deal with
+importing only the classes it actually needs.
 The =mega-import-jme3= is quite usefull for debugging purposes since
 it allows completion for almost all of JME's classes.
 Out of curiousity, let's see just how many classes =mega-import-jme3=
 imports:
-#+begin_src clojure :exports both
+#+begin_src clojure :exports both :results output
-(clojure.core/count (cortex.import/jme-classes))
+(println (clojure.core/count (cortex.import/jme-classes)) "classes")
 #+end_src
 #+results:
-: 955
+: 955 classes
-#+srcname: world-view
+** Utilities
-#+begin_src clojure :results silent
-(ns cortex.util)
+The utilities here come in three main groups:
-(require 'cortex.import)
+- Changing settings in a running =Application=
-(cortex.import/mega-import-jme3)
+- Creating objects
-(use 'cortex.world)
+- Visualizing objects
-(defprotocol Viewable
-(view [something]))
+*** Changing Settings
-(extend-type com.jme3.scene.Geometry
-Viewable
-(view [geo]
-	(view (doto (Node.)(.attachChild geo)))))
-(extend-type com.jme3.scene.Node
-Viewable
-(view [node]
-	(.start
-	 (world node
-		{}
-		(fn [world]
-		  (.enableDebug
-		   (.getPhysicsSpace
-		    (.getState
-		     (.getStateManager world)
-		     BulletAppState))
-		   (asset-manager))
-		  (set-gravity* world Vector3f/ZERO)
-;;		  (set-gravity* world (Vector3f. 0 (float -0.4) 0))
-		  (let [sun (doto (DirectionalLight.)
-			      (.setDirection (.normalizeLocal (Vector3f. 1 0 -2)))
-			      (.setColor ColorRGBA/White))]
-		    (.addLight (.getRootNode world) sun)))
-		no-op))))
-#+end_src
-Here I make the =Viewable= protocol and extend it to JME's types.  Now
-hello-world can be written as easily as:
-#+begin_src clojure :results silent
-(cortex.world/view (cortex.world/box))
-#+end_src
 #+srcname: util
 #+begin_src clojure
-(in-ns 'cortex.util)
+(ns cortex.util
+"Utility functions for making jMonkeyEngine easier to program from
-(def println-repl (bound-fn [& args] (apply println args)))
+clojure"
+{:author "Robert McIntyre"}
-(defn position-camera [game]
+(:use cortex.world)
-(doto (.getCamera game)
+(:use clojure.contrib.def)
-(.setLocation (Vector3f. 0 6 6))
+(:import com.jme3.math.Vector3f)
-(.lookAt Vector3f/ZERO (Vector3f. 0 1 0))))
+(:import com.jme3.math.Quaternion)
+(:import com.jme3.asset.TextureKey)
-(defn set-gravity*
+(:import com.jme3.bullet.control.RigidBodyControl)
+(:import com.jme3.bullet.collision.shapes.GImpactCollisionShape)
+(:import com.jme3.scene.shape.Box)
+(:import com.jme3.scene.Node)
+(:import com.jme3.scene.shape.Sphere)
+(:import com.jme3.light.DirectionalLight)
+(:import com.jme3.math.ColorRGBA)
+(:import com.jme3.bullet.BulletAppState)
+(:import com.jme3.material.Material)
+(:import com.jme3.scene.Geometry))
+(defvar println-repl
+(bound-fn [& args] (apply println args))
+"println called from the LWJGL thread will not go to the REPL, but
+instead to whatever terminal started the JVM process. This function
+will always output to the REPL")
+(defn position-camera
+([game position direction up]
+(doto (.getCamera game)
+(.setLocation )
+(.lookAt direction up)))
+([game position direction]
+(position-camera
+game position direction Vector3f/UNIT_Y)))
+(defn enable-debug
+"Turn on the debug wireframes for every object in this simulation"
+[world]
+(.enableDebug
+(.getPhysicsSpace
+(.getState
+(.getStateManager world)
+BulletAppState))
+(asset-manager)))
+(defn set-gravity
+"In order to change the gravity of a scene, it is not only necessary
+to set the gravity variable, but to \"tap\" every physics object in
+the scene to reactivate physics calculations."
 [game gravity]
 (traverse
 (fn [geom]
 (if-let
+;; only set gravity for physical objects.
 	 [control (.getControl geom RigidBodyControl)]
 (do
 	 (.setGravity control gravity)
-	 (.applyImpulse control Vector3f/ZERO Vector3f/ZERO)
+;; tappsies!
-	 )))
+	 (.applyImpulse control Vector3f/ZERO Vector3f/ZERO))))
 (.getRootNode game)))
-#+end_src
+(defn add-element
+"Add the Spatial to the game's environment"
+([game element node]
+(.addAll
+(.getPhysicsSpace
+(.getState
+(.getStateManager game)
+BulletAppState))
+element)
+(.attachChild node element))
+([game element]
+(add-element game element (.getRootNode game))))
+(defn apply-map
+"Like apply, but works for maps and functions that expect an
+implicit map and nothing else as in (fn [& {}]).
+------- Example -------
+(defn demo [& {:keys [www] :or {www \"oh yeah\"} :as env}]
+(println www))
+(apply-map demo {:www \"hello!\"})
+-->\"hello\""
+[fn m]
+(apply fn (reduce #(into %1 %2) [] m)))
+#+end_src
+*** Creating Basic Shapes
 #+srcname: shapes
 #+begin_src clojure :results silent
 (in-ns 'cortex.util)
 (defrecord shape-description
 [name
 color
 mass
 friction
 texture
 material
 position
 rotation
 shape
-physical?])
+physical?
+GImpact?
+])
 (def base-shape
 (shape-description.
 "default-shape"
 false
 ;; material
 "Common/MatDefs/Misc/Unshaded.j3md"
 Vector3f/ZERO
 Quaternion/IDENTITY
 (Box. Vector3f/ZERO 0.5 0.5 0.5)
-true))
+true
+false))
 (defn make-shape
 [#^shape-description d]
-(let [asset-manager (if (:asset-manager d) (:asset-manager d) (asset-manager))
+(let [asset-manager (asset-manager)
 mat (Material. asset-manager (:material d))
 	geom (Geometry. (:name d) (:shape d))]
 (if (:texture d)
 (let [key (TextureKey. (:texture d))]
 	(.setGenerateMips key true)
 (if (:color d) (.setColor mat "Color" (:color d)))
 (.setMaterial geom mat)
 (if-let [rotation (:rotation d)] (.rotate geom rotation))
 (.setLocalTranslation geom (:position d))
 (if (:physical? d)
-(let [impact-shape (doto (GImpactCollisionShape.
+(let [physics-control
-(.getMesh geom)) (.setMargin 0))
+(if (:GImpact d)
-	    physics-control (RigidBodyControl.
+;; Create an accurate mesh collision shape if desired.
-			     ;;impact-shape ;; comment to disable
+(RigidBodyControl.
-			     (float (:mass d)))]
+(doto (GImpactCollisionShape.
-	(.createJmeMesh impact-shape)
+(.getMesh geom))
+(.createJmeMesh)
+(.setMargin 0))
+(float (:mass d)))
+;; otherwise use jme3's default
+(RigidBodyControl. (float (:mass d))))]
 	(.addControl geom physics-control)
 	;;(.setSleepingThresholds physics-control (float 0) (float 0))
 	(.setFriction physics-control (:friction d))))
-;;the default is to keep this node in the physics engine forever.
-;;these commands must come after the control is added to the geometry.
-;;
 geom))
 (defn box
 ([l w h & {:as options}]
 (let [options (merge base-shape options)]
 ([r & {:as options}]
 (let [options (merge base-shape options)]
 (make-shape (assoc options
 		     :shape (Sphere. 32 32 (float r))))))
 ([] (sphere 0.5)))
+#+end_src
-(defn add-element
-([game element node]
-(.addAll
+*** Viewing Objects
-(.getPhysicsSpace
-(.getState
+#+srcname: world-view
-(.getStateManager game)
+#+begin_src clojure :results silent
-BulletAppState))
+(in-ns 'cortex.util)
-element)
-(.attachChild node element))
+(defprotocol Viewable
-([game element]
+(view [something]))
-(add-element game element (.getRootNode game))))
+(extend-type com.jme3.scene.Geometry
+Viewable
-(defn apply-map
+(view [geo]
-"Like apply, but works for maps and functions that expect an
+	(view (doto (Node.)(.attachChild geo)))))
-implicit map and nothing else as in (fn [& {}]).
-------- Example -------
+(extend-type com.jme3.scene.Node
-(defn demo [& {:keys [www] :or {www \"oh yeah\"} :as env}]
+Viewable
-(println www))
+(view
-(apply-map demo {:www \"hello!\"})
+[node]
--->\"hello\""
+(.start
-[fn m]
+(world
-(apply fn (reduce #(into %1 %2) [] m)))
+node
+{}
-#+end_src
+(fn [world]
+(enable-debug world)
+(set-gravity world Vector3f/ZERO)
+(let [sun
+(doto (DirectionalLight.)
+(.setDirection
+(.normalizeLocal (Vector3f. 1 0 -2)))
+(.setColor ColorRGBA/White))]
+(.addLight (.getRootNode world) sun)))
+no-op))))
+#+end_src
+Here I make the =Viewable= protocol and extend it to JME's types.  Now
+hello-world can be written as easily as:
+#+begin_src clojure :results silent
+(cortex.util/view (cortex.util/box))
+#+end_src
 * COMMENT code generation
 #+begin_src clojure :tangle ../src/cortex/import.clj
 <<import>>
 #+end_src
-#+begin_src clojure :tangle ../src/cortex/util.clj
+#+begin_src clojure :tangle ../src/cortex/util.clj :noweb yes
-<<world-view>>
 <<util>>
 <<shapes>>
-#+end_src
+<<world-view>>
+#+end_src

Mercurial > cortex

comparison org/util.org @ 29:6372c108c5c6