#+title: Clojure Utilities for jMonkeyEngine3

 #+author: Robert McIntyre

 #+email: rlm@mit.edu

 #+description: 

 #+keywords: JME3, clojure, import, utilities

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

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

 

 * Utilities

 

 These are a collection of functions to make programming jMonkeyEngine

 in clojure easier.

 

 ** Imports

 

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

 

 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 :results output

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

 #+end_src

 

 #+results:

 : 955 classes

 

 

 ** Utilities

 

 The utilities here come in three main groups:

  - Changing settings in a running =Application=

  - Creating objects

  - Visualizing objects

 

 

 *** Changing Settings

 

 #+srcname: util

 #+begin_src clojure 

 (ns cortex.util

   "Utility functions for making jMonkeyEngine easier to program from

    clojure"

   {:author "Robert McIntyre"}

   (:use cortex.world)

   (:use clojure.contrib.def)

   (:import com.jme3.math.Vector3f)

   (:import com.jme3.math.Quaternion)

   (:import com.jme3.asset.TextureKey)

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

          ;; tappsies!

 	 (.applyImpulse control Vector3f/ZERO Vector3f/ZERO))))

    (.getRootNode game)))

 

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

    GImpact?

    ])

 

 (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

       false))

 

 (defn make-shape

   [#^shape-description d]

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

 	(.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 [physics-control

             (if (:GImpact d)

               ;; Create an accurate mesh collision shape if desired. 

               (RigidBodyControl.

                (doto (GImpactCollisionShape. 

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

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

 #+end_src

 

 

 *** Viewing Objects

 

 #+srcname: world-view

 #+begin_src clojure :results silent

 (in-ns 'cortex.util)

 

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

         (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 :noweb yes

 <<util>>

 <<shapes>>

 <<world-view>>

 #+end_src