#+title: Helper Utilities

 #+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

 

 ** 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))

 

 (defn permissive-import

   [classname]

   (eval `(try (import '~classname)

               (catch java.lang.Exception e#

                 (println "couldn't import " '~classname))))

   classname)

 

 (defn jme-class? [classname]

   (and

    (.startsWith classname "com.jme3.")

    ;; Don't import the Lwjgl stuff since it can throw exceptions

    ;;  upon being loaded.

    (not (re-matches #".*Lwjgl.*" classname))))

 

 (defn jme-classes

   "returns a list of all jme3 classes"

   []

   (filter

    jme-class?

    (map :name

         swank.util.class-browse/available-classes)))

   

 (defn mega-import-jme3

   "Import ALL the jme classes. For REPL use."

   []

   (doall

    (map (comp permissive-import symbol) (jme-classes))))

 #+end_src  

 

 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

 (clojure.core/count (cortex.import/jme-classes))

 #+end_src

 

 #+results:

 : 955

 

 

 #+srcname: world-view

 #+begin_src clojure :results silent

 (ns cortex.util)

 (require 'cortex.import)

 (cortex.import/mega-import-jme3)

 (use 'cortex.world)

 (defprotocol Viewable

   (view [something]))

 

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

 

 (def println-repl (bound-fn [& args] (apply println args)))

 

 (defn position-camera [game]

   (doto (.getCamera game)

     (.setLocation (Vector3f. 0 6 6))

     (.lookAt Vector3f/ZERO (Vector3f. 0 1 0))))

 

 (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

 

 

 #+srcname: shapes

 #+begin_src clojure :results silent

 (in-ns 'cortex.util)

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

 

 

 

 * COMMENT code generation

 #+begin_src clojure :tangle ../src/cortex/import.clj

 <<import>>

 #+end_src

 

 

 #+begin_src clojure :tangle ../src/cortex/util.clj

 <<world-view>>

 <<util>>

 <<shapes>>

 #+end_src