cortex: org/world.org comparison

comparison org/world.org @ 23:cab2da252494

split off the rest of cortex.org

author	Robert McIntyre <rlm@mit.edu>
date	Sun, 23 Oct 2011 23:54:26 -0700
parents
children	e965675ec4d0

comparison

equal deleted inserted replaced

-:157b416152ea
+:cab2da252494
+#+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.

Mercurial > cortex

comparison org/world.org @ 23:cab2da252494