#+title: A world for the creatures to live

 #+author: Robert McIntyre

 #+email: rlm@mit.edu

 #+description: Simulating senses for AI research using JMonkeyEngine3

 #+SETUPFILE: ../../aurellem/org/setup.org

 #+INCLUDE: ../../aurellem/org/level-0.org

 #+babel: :mkdirp yes :noweb yes :exports both

 

 

 

 *** World

 

 It is comvienent to wrap the JME elements that deal with creating a

 world, creation of basic objects, and Keyboard input with a nicer

 interface (at least for my purposes).

 

 #+srcname: world-inputs

 #+begin_src clojure :results silent

 (ns cortex.world)

 (require 'cortex.import)

 (use 'clojure.contrib.def)

 (rlm.rlm-commands/help)

 (cortex.import/mega-import-jme3)

 

 (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")))

 

 (defmacro no-exceptions

   "Sweet relief like I never knew."

   [& forms]

   `(try ~@forms (catch Exception e# (.printStackTrace e#))))

 

 (defn thread-exception-removal []

   (println "removing exceptions from " (Thread/currentThread))

   (.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)))

 

 (use '[pokemon [lpsolve :only [constant-map]]])

 

 (defn no-op [& _])

 

 (defn all-keys

   "Construct a map of strings representing all the manual inputs from

    either the keyboard or mouse." 

   []

   (let [inputs (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"

   [game  input-manager key-map]

   (doall (map (fn [[name trigger]]

 		(.addMapping ^InputManager input-manager

 			     name (into-array (class trigger) [trigger]))) key-map))

   (doall (map (fn [name] 

 		(.addListener ^InputManager input-manager game

 			      (into-array String  [name]))) (keys key-map))))

 

 #+end_src

 

 These functions are all for debug controlling of the world through

 keyboard and mouse. 

 

 We reuse  =constant-map= from =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)

 #+end_src

 

 #+results:

 : -------------------------

 : 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

 

 

 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

 apparent. =all-keys= also adds the three mouse button controls to the

 map.

 

 #+srcname: world

 #+begin_src clojure :results silent

 (in-ns 'cortex.world)

 

 (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

   [root-node key-map setup-fn update-fn]

   (let [physics-manager (BulletAppState.)

 	shadow-renderer (BasicShadowRenderer. (asset-manager) (int 256))

 	;;maybe use a better shadow renderer someday!

 	;;shadow-renderer (PssmShadowRenderer. (asset-manager) 256 1)

 	]   	

   (doto

       (proxy [SimpleApplication ActionListener] []

 	(simpleInitApp

 	 []

 	 (no-exceptions

 	  (.setTimer this (IsoTimer. 60))

 	  ;; Create key-map.

 	  (.setFrustumFar (.getCamera this) 300)

 	  (initialize-inputs this (.getInputManager this) (all-keys))

 	  ;; Don't take control of the mouse

 	  (org.lwjgl.input.Mouse/setGrabbed false)

 	  ;; add all objects to the world

 	  (.attachChild (.getRootNode this) root-node)

 	  ;; enable physics

 	  ;; add a physics manager

 	  (.attach (.getStateManager this) physics-manager)

 	  (.setGravity (.getPhysicsSpace physics-manager) gravity)

 

 

 	  ;; go through every object and add it to the physics manager

 	  ;; if relavant.

 	   (traverse (fn [geom]

 		       (dorun

 			(for [n (range (.getNumControls geom))]

 			  (do

 			    (println-repl "adding control " (.getControl geom n))

 			    (.add (.getPhysicsSpace physics-manager)

 				  (.getControl geom n))))))

 		     (.getRootNode this))

 	  ;;(.addAll (.getPhysicsSpace physics-manager) (.getRootNode this))

 

 	  (setup-fn this)

 	  (.setDirection shadow-renderer

 			 (.normalizeLocal (Vector3f. -1 -1 -1)))

 	  (.addProcessor (.getViewPort this) shadow-renderer)

 	  (.setShadowMode (.getRootNode this) RenderQueue$ShadowMode/Off)

 	  ))

 	(simpleUpdate

 	 [tpf]

 	 (no-exceptions

 	  (update-fn this tpf))) 

 	(onAction

 	 [binding value tpf]

 	 ;; whenever a key is pressed, call the function returned from

 	 ;; key-map.

 	 (no-exceptions

 	  (if-let [react (key-map binding)]

 	    (react this value)))))

     ;; don't show a menu to change options.

     

     (.setShowSettings false)

     (.setPauseOnLostFocus false)

     (.setSettings *app-settings*))))

 

 (defn apply-map

   "Like apply, but works for maps and functions that expect an implicit map

    and nothing else as in (fn [& {}]).

 ------- Example -------

  (defn jjj [& {:keys [www] :or {www \"oh yeah\"} :as env}] (println www))

  (apply-map jjj {:www \"whatever\"})

   -->\"whatever\""

   [fn m]

   (apply fn (reduce #(into %1 %2) [] m)))

 

 #+end_src 

 

 

 =world= is the most important function here.  

 ***  TODO more documentation

 

 #+srcname: world-shapes

 #+begin_src clojure :results silent

 (in-ns 'cortex.world)

 (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.