cortex: org/world.org comparison

comparison org/world.org @ 25:775d97247dd0

cleaning up world.org

author	Robert McIntyre <rlm@mit.edu>
date	Mon, 24 Oct 2011 05:25:01 -0700
parents	e965675ec4d0
children	bbffa41a12a9

comparison

equal deleted inserted replaced

-:e965675ec4d0
+:775d97247dd0
-#+title: A world for the creatures to live
+#+title: A World for the Creatures
 #+author: Robert McIntyre
 #+email: rlm@mit.edu
-#+description: Simulating senses for AI research using JMonkeyEngine3
+#+description: Creating a Virtual World for AI constructs using clojure and JME3
+#+keywords: JME3, clojure, virtual world, exception handling
 #+SETUPFILE: ../../aurellem/org/setup.org
 #+INCLUDE: ../../aurellem/org/level-0.org
 #+babel: :mkdirp yes :noweb yes :exports both
+* The  World
-*** World
+There's no point in having senses if there's nothing to experience. In
+this section I make some tools with which to build virtual worlds for
-It is comvienent to wrap the JME elements that deal with creating a
+my characters to inhabit. If you look at the tutorials at [[http://www.jmonkeyengine.org/wiki/doku.php/jme3:beginner][the jme3
-world, creation of basic objects, and Keyboard input with a nicer
+website]], you will see a pattern in how virtual worlds are normally
-interface (at least for my purposes).
+built. I call this "the Java way" of making worlds.
-#+srcname: world-inputs
+- The Java way:
-#+begin_src clojure :results silent
+- Create a class that extends =SimpleApplication= or =Application=
-(ns cortex.world)
+- Implement setup functions that create all the scene objects using
-(require 'cortex.import)
+the inherited =assetManager= and call them by overriding the
-(use 'clojure.contrib.def)
+=simpleInitApp= method.
-(rlm.rlm-commands/help)
+- Create =ActionListeners= and add them to the =inputManager=
-(cortex.import/mega-import-jme3)
+inherited from =Application= to handle key-bindings.
+- Override =simpleUpdate= to implement game logic.
+- Running/Testing an Application involves creating a new JVM,
+running the App, and then closing everything down.
+- A more Clojureish way:
+- Use a map from keys->functions to specify key-bindings.
+- Use functions to create objects separately from any particular
+application.
+- Use an REPL -- this means that there's only ever one JVM, and
+Applications come and go.
+Since most development work using jMonkeyEngine is done in Java, jme3
+supports "the Java way" quite well out of the box. To work "the
+clojure way", it necessary to wrap the jme3 elements that deal with
+the Application life-cycle with a REPL driven interface.
+The most important modifications are:
+- Separation of Object life-cycles with the Application life-cycle.
+- Functional interface to the underlying =Application= and
+=SimpleApplication= classes.
+** Header
+#+srcname: header
+#+begin_src clojure :results silent
+(ns cortex.world
+"World Creation, abstracion over jme3's input system, and REPL
+driven exception handling"
+{:author "Robert McIntyre"}
+(:use (clojure.contrib (def :only (defvar))))
+(:use [pokemon [lpsolve :only [constant-map]]])
+(:use [clojure.contrib [str-utils :only [re-gsub]]])
+(:import com.jme3.math.Vector3f)
+(:import com.jme3.scene.Node)
+(:import com.jme3.system.AppSettings)
+(:import com.jme3.system.JmeSystem)
+(:import com.jme3.system.IsoTimer)
+(:import com.jme3.input.KeyInput)
+(:import com.jme3.input.controls.KeyTrigger)
+(:import com.jme3.input.controls.MouseButtonTrigger)
+(:import com.jme3.input.InputManager)
+(:import com.jme3.bullet.BulletAppState)
+(:import com.jme3.shadow.BasicShadowRenderer)
+(:import com.jme3.app.SimpleApplication)
+(:import com.jme3.input.controls.ActionListener)
+(:import com.jme3.renderer.queue.RenderQueue$ShadowMode)
+(:import org.lwjgl.input.Mouse))
+#+end_src
+** General Settings
+#+srcname: settings
+#+begin_src clojure
+(in-ns 'cortex.world)
 (defvar *app-settings*
 (doto (AppSettings. true)
 (.setFullscreen false)
 (.setTitle "Aurellem.")
 ;; disable 32 bit stuff for now
 ;;(.setAudioRenderer "Send")
 )
 "These settings control how the game is displayed on the screen for
 debugging purposes.  Use binding forms to change this if desired.
 Full-screen mode does not work on some computers.")
 (defn asset-manager
 "returns a new, configured assetManager" []
 (JmeSystem/newAssetManager
 (.getResource
 (.getContextClassLoader (Thread/currentThread))
 "com/jme3/asset/Desktop.cfg")))
+#+end_src
+Normally, people just use the =AssetManager= inherited from
+=Application= whenever they extend that class. However,
+=AssetManagers= are useful on their own to create objects/ materials,
+independent from any particular application. =(asset-manager)= makes
+object creation less tightly bound to Application initialization.
+** Exception Protection
+#+srcname: exceptions
+#+begin_src clojure
+(in-ns 'cortex.world)
 (defmacro no-exceptions
 "Sweet relief like I never knew."
 [& forms]
 `(try ~@forms (catch Exception e# (.printStackTrace e#))))
-(defn thread-exception-removal []
+(defn thread-exception-removal
-(println "removing exceptions from " (Thread/currentThread))
+"Exceptions thrown in the graphics rendering thread generally cause
+the entire REPL to crash! It is good to suppress them while trying
+things out to shorten the debug loop."
+[]
 (.setUncaughtExceptionHandler
 (Thread/currentThread)
 (proxy [Thread$UncaughtExceptionHandler] []
 (uncaughtException
 [thread thrown]
 (println "uncaught-exception thrown in " thread)
 (println (.getMessage thrown))))))
-(def println-repl (bound-fn [& args] (apply println args)))
+#+end_src
-(use '[pokemon [lpsolve :only [constant-map]]])
+Exceptions thrown in the LWJGL render thread, if not caught, will
+destroy the entire JVM process including the REPL and slow development
-(defn no-op [& _])
+to a crawl.  It is better to try to continue on in the face of
+exceptions and keep the REPL alive as long as possible.  Normally it
+is possible to just exit the faulty Application, fix the bug,
+reevaluate the appropriate forms, and be on your way, without
+restarting the JVM.
+** Input
+#+srcname: input
+#+begin_src clojure
+(in-ns 'cortex.world)
 (defn all-keys
-"Construct a map of strings representing all the manual inputs from
+"Uses reflection to generate a map of string names to jme3 trigger
-either the keyboard or mouse."
+objects, which govern input from the keyboard and mouse"
 []
-(let [inputs (constant-map KeyInput)]
+(let [inputs (pokemon.lpsolve/constant-map KeyInput)]
 (assoc
 	(zipmap (map (fn [field]
 		       (.toLowerCase (re-gsub #"_" "-" field))) (vals inputs))
 		(map (fn [val] (KeyTrigger. val)) (keys inputs)))
 ;;explicitly add mouse controls
 "mouse-left" (MouseButtonTrigger. 0)
 "mouse-middle" (MouseButtonTrigger. 2)
 "mouse-right" (MouseButtonTrigger. 1))))
 (defn initialize-inputs
-"more java-interop cruft to establish keybindings for a particular virtual world"
+"Establish key-bindings for a particular virtual world."
 [game  input-manager key-map]
-(doall (map (fn [[name trigger]]
+(doall
-		(.addMapping ^InputManager input-manager
+(map (fn [[name trigger]]
-			     name (into-array (class trigger) [trigger]))) key-map))
+(.addMapping
-(doall (map (fn [name]
+^InputManager input-manager
-		(.addListener ^InputManager input-manager game
+name (into-array (class trigger)
-			      (into-array String  [name]))) (keys key-map))))
+[trigger]))) key-map))
+(doall
-#+end_src
+(map (fn [name]
+(.addListener
-These functions are all for debug controlling of the world through
+^InputManager input-manager game
-keyboard and mouse.
+(into-array String  [name]))) (keys key-map))))
-We reuse  =constant-map= from =pokemon.lpsolve= to get the numerical
+#+end_src
+These functions are for controlling the world through the keyboard and
+mouse.
+I reuse =constant-map= from [[../../pokemon-types/html/lpsolve.html#sec-3-3-4][=pokemon.lpsolve=]] to get the numerical
 values for all the keys defined in the =KeyInput= class. The
 documentation for =constant-map= is:
 #+begin_src clojure :results output
 (doc pokemon.lpsolve/constant-map)
 : ([class])
 :   Takes a class and creates a map of the static constant integer
 :   fields with their names.  This helps with C wrappers where they have
 :   just defined a bunch of integer constants instead of enums
+=(all-keys)= converts the constant names like =KEY_J= to the more
-Then, =all-keys= converts the constant names like =KEY_J= to the more
 clojure-like =key-j=, and returns a map from these keys to
-jMonkeyEngine KeyTrigger objects, the use of which will soon become
+jMonkeyEngine =KeyTrigger= objects, which jMonkeyEngine3 uses as it's
-apparent. =all-keys= also adds the three mouse button controls to the
+abstraction over the physical keys. =all-keys= also adds the three
-map.
+mouse button controls to the map.
+#+begin_src clojure :exports both :results output
+(require 'clojure.contrib.pprint)
+(clojure.contrib.pprint/pprint
+(take 10 (keys (cortex.world/all-keys))))
+#+end_src
+#+results:
+#+begin_example
+("key-n"
+"key-apps"
+"key-pgup"
+"key-f8"
+"key-o"
+"key-at"
+"key-f9"
+"key-0"
+"key-p"
+"key-subtract")
+#+end_example
+#+begin_src clojure :exports both :results output
+(clojure.contrib.pprint/pprint
+(take 10 (vals (cortex.world/all-keys))))
+#+end_src
+#+results:
+#+begin_example
+(#<KeyTrigger com.jme3.input.controls.KeyTrigger@6ec21e52>
+#<KeyTrigger com.jme3.input.controls.KeyTrigger@a54d24d>
+#<KeyTrigger com.jme3.input.controls.KeyTrigger@1ba5e91b>
+#<KeyTrigger com.jme3.input.controls.KeyTrigger@296af9cb>
+#<KeyTrigger com.jme3.input.controls.KeyTrigger@2e3593ab>
+#<KeyTrigger com.jme3.input.controls.KeyTrigger@3f71d740>
+#<KeyTrigger com.jme3.input.controls.KeyTrigger@4aeacb4a>
+#<KeyTrigger com.jme3.input.controls.KeyTrigger@7cc88db2>
+#<KeyTrigger com.jme3.input.controls.KeyTrigger@52cee11e>
+#<KeyTrigger com.jme3.input.controls.KeyTrigger@c1da30b>)
+#+end_example
+** World Creation
 #+srcname: world
 #+begin_src clojure :results silent
 (in-ns 'cortex.world)
+(defn no-op
+"Takes any number of arguments and does nothing."
+[& _])
 (defn traverse
 "apply f to every non-node, deeply"
 [f node]
 (if (isa? (class node) Node)
 (dorun (map (partial traverse f) (.getChildren node)))
 (f node)))
-(def gravity (Vector3f. 0 -9.81 0))
 (defn world
+"the =world= function takes care of the details of initializing a
+SimpleApplication.
+***** Arguments:
+- root-node : a com.jme3.scene.Node object which contains all of
+the objects that should be in the simulation.
+- key-map : a map from strings describing keys to functions that
+should be executed whenever that key is pressed.
+the functions should take a SimpleApplication object and a
+boolean value.  The SimpleApplication is the current simulation
+that is running, and the boolean is true if the key is being
+pressed, and false if it is being released. As an example,
+{\"key-j\" (fn [game value] (if value (println \"key j pressed\")))}
+is a valid key-map which will cause the simulation to print a
+message whenever the 'j' key on the keyboard is pressed.
+- setup-fn : a function that takes a SimpleApplication object. It
+is called once when initializing the simulation. Use it to
+create things like lights, change the gravity, initialize debug
+nodes, etc.
+- update-fn : this function takes a SimpleApplication object and a
+float and is called every frame of the simulation.  The float
+tells how many seconds is has been since the last frame was
+rendered, according to whatever clock jme is currently
+using. The default is to use IsoTimer which will result in this
+value always being the same.
+"
 [root-node key-map setup-fn update-fn]
 (let [physics-manager (BulletAppState.)
-	shadow-renderer (BasicShadowRenderer. (asset-manager) (int 256))
+	shadow-renderer (BasicShadowRenderer.
-	;;maybe use a better shadow renderer someday!
+(asset-manager) (int 256))]
-	;;shadow-renderer (PssmShadowRenderer. (asset-manager) 256 1)
+(doto
-	]
+(proxy [SimpleApplication ActionListener] []
-(doto
+(simpleInitApp
-(proxy [SimpleApplication ActionListener] []
+[]
-	(simpleInitApp
+(no-exceptions
-	 []
+;; allow AI entities as much time as they need to think.
-	 (no-exceptions
+(.setTimer this (IsoTimer. 60))
-	  (.setTimer this (IsoTimer. 60))
+(.setFrustumFar (.getCamera this) 300)
-	  ;; Create key-map.
+;; Create default key-map.
-	  (.setFrustumFar (.getCamera this) 300)
+(initialize-inputs this (.getInputManager this) (all-keys))
-	  (initialize-inputs this (.getInputManager this) (all-keys))
+;; Don't take control of the mouse
-	  ;; Don't take control of the mouse
+(org.lwjgl.input.Mouse/setGrabbed false)
-	  (org.lwjgl.input.Mouse/setGrabbed false)
+;; add all objects to the world
-	  ;; add all objects to the world
+(.attachChild (.getRootNode this) root-node)
-	  (.attachChild (.getRootNode this) root-node)
+;; enable physics
-	  ;; enable physics
+;; add a physics manager
-	  ;; add a physics manager
+(.attach (.getStateManager this) physics-manager)
-	  (.attach (.getStateManager this) physics-manager)
+(.setGravity (.getPhysicsSpace physics-manager)
-	  (.setGravity (.getPhysicsSpace physics-manager) gravity)
+(Vector3f. 0 -9.81 0))
+;; go through every object and add it to the physics
+;; manager if relevant.
-	  ;; go through every object and add it to the physics manager
+(traverse (fn [geom]
-	  ;; if relavant.
+(dorun
-	   (traverse (fn [geom]
+(for [n (range (.getNumControls geom))]
-		       (dorun
+(do
-			(for [n (range (.getNumControls geom))]
+(.add (.getPhysicsSpace physics-manager)
-			  (do
+(.getControl geom n))))))
-			    (println-repl "adding control " (.getControl geom n))
+(.getRootNode this))
-			    (.add (.getPhysicsSpace physics-manager)
+;;(.addAll (.getPhysicsSpace physics-manager) (.getRootNode this))
-				  (.getControl geom n))))))
-		     (.getRootNode this))
+;; set some basic defaults for the shadow renderer.
-	  ;;(.addAll (.getPhysicsSpace physics-manager) (.getRootNode this))
+;; these can be undone in the setup function
+(.setDirection shadow-renderer
-	  (setup-fn this)
+(.normalizeLocal (Vector3f. -1 -1 -1)))
-	  (.setDirection shadow-renderer
+(.addProcessor (.getViewPort this) shadow-renderer)
-			 (.normalizeLocal (Vector3f. -1 -1 -1)))
+(.setShadowMode (.getRootNode this)
-	  (.addProcessor (.getViewPort this) shadow-renderer)
+RenderQueue$ShadowMode/Off)
-	  (.setShadowMode (.getRootNode this) RenderQueue$ShadowMode/Off)
+;; call the supplied setup-fn
-	  ))
+(if setup-fn
-	(simpleUpdate
+(setup-fn this))))
-	 [tpf]
+(simpleUpdate
-	 (no-exceptions
+[tpf]
-	  (update-fn this tpf)))
+(no-exceptions
-	(onAction
+(update-fn this tpf)))
-	 [binding value tpf]
+(onAction
-	 ;; whenever a key is pressed, call the function returned from
+[binding value tpf]
-	 ;; key-map.
+;; whenever a key is pressed, call the function returned
-	 (no-exceptions
+;; from key-map.
-	  (if-let [react (key-map binding)]
+(no-exceptions
-	    (react this value)))))
+(if-let [react (key-map binding)]
-;; don't show a menu to change options.
+(react this value)))))
+;; don't show a menu to change options.
 (.setShowSettings false)
-(.setPauseOnLostFocus false)
+;; continue running simulation even if the window has lost
-(.setSettings *app-settings*))))
+;; focus.
+(.setPauseOnLostFocus false)
+(.setSettings *app-settings*))))
 (defn apply-map
-"Like apply, but works for maps and functions that expect an implicit map
+"Like apply, but works for maps and functions that expect an
-and nothing else as in (fn [& {}]).
+implicit map and nothing else as in (fn [& {}]).
 ------- Example -------
-(defn jjj [& {:keys [www] :or {www \"oh yeah\"} :as env}] (println www))
+(defn demo [& {:keys [www] :or {www \"oh yeah\"} :as env}]
-(apply-map jjj {:www \"whatever\"})
+(println www))
--->\"whatever\""
+(apply-map demo {:www \"hello!\"})
+-->\"hello\""
 [fn m]
 (apply fn (reduce #(into %1 %2) [] m)))
 #+end_src
-=world= is the most important function here.
+=(world)= is the most important function here. It presents a more
-***  TODO more documentation
+functional interface to the Application life-cycle, and all it's
+objects except =root-node= are plain clojure data structures. It's now
-#+srcname: world-shapes
+possible to extend functionally by composing multiple functions
-#+begin_src clojure :results silent
+together, and to add more keyboard-driven actions by combining clojure
-(in-ns 'cortex.world)
+maps.
-(defrecord shape-description
-[name
-color
-mass
-friction
-texture
-material
-position
-rotation
-shape
-physical?])
-(def base-shape
-(shape-description.
-"default-shape"
-false
-;;ColorRGBA/Blue
-1.0 ;; mass
-1.0 ;; friction
-;; texture
-"Textures/Terrain/BrickWall/BrickWall.jpg"
-;; material
-"Common/MatDefs/Misc/Unshaded.j3md"
-Vector3f/ZERO
-Quaternion/IDENTITY
-(Box. Vector3f/ZERO 0.5 0.5 0.5)
-true))
-(defn make-shape
-[#^shape-description d]
-(let [asset-manager (if (:asset-manager d) (:asset-manager d) (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)
-	(.setTexture mat "ColorMap" (.loadTexture asset-manager key))))
-(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.
-(.getMesh geom)) (.setMargin 0))
-	    physics-control (RigidBodyControl.
-			     ;;impact-shape ;; comment to disable
-			     (float (:mass d)))]
-	(.createJmeMesh impact-shape)
-	(.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)]
-(make-shape (assoc options
-		     :shape (Box. l w h)))))
-([] (box 0.5 0.5 0.5)))
-(defn sphere
-([r & {:as options}]
-(let [options (merge base-shape options)]
-(make-shape (assoc options
-		     :shape (Sphere. 32 32 (float r))))))
-([] (sphere 0.5)))
-(defn add-element
-([game element node]
-(.addAll
-(.getPhysicsSpace
-(.getState
-(.getStateManager game)
-BulletAppState))
-element)
-(.attachChild node element))
-([game element]
-(add-element game element (.getRootNode game))))
-(defn set-gravity*
-[game gravity]
-(traverse
-(fn [geom]
-(if-let
-	 [control (.getControl geom RigidBodyControl)]
-(do
-	 (.setGravity control gravity)
-	 (.applyImpulse control Vector3f/ZERO Vector3f/ZERO)
-	 )))
-(.getRootNode game)))
-#+end_src
-These are convienence functions for creating JME objects and
-manipulating a world.
 * COMMENT code generation
 #+begin_src clojure :tangle ../src/cortex/world.clj
-<<world-inputs>>
+<<header>>
+<<settings>>
+<<exceptions>>
+<<input>>
 <<world>>
-<<world-shapes>>
+#+end_src
-#+end_src

Mercurial > cortex

comparison org/world.org @ 25:775d97247dd0