jme-clj.core — jme-clj 0.1.10

*app* clj

*control* clj

action-listener clj

(action-listener f)

add-anim-listener clj

(add-anim-listener control listener)

add-control clj

(add-control spatial control)

add-light clj

(add-light spatial light)

add-light-to-root clj

(add-light-to-root light)

add-to-root clj

(add-to-root node)

analog-listener clj

(analog-listener f)

anim-listener clj

(anim-listener on-cycle-done on-anim-change)

app-settings clj

(app-settings load-defaults?
              &
              {:keys [fullscreen? vsync? width height frequency title frame-rate
                      resizable?]})

Creates an AppSettings instance.

app-state clj

(app-state kw & {:keys [init update on-enable on-disable cleanup]})

AppState represents continuously executing code inside the main loop.

e.g.: (app-state ::my-app-state :init (fn [] (println "App State initialized.")) :update (fn [tpf] (println "update:" tpf)) :on-enable (fn [] (println "on enable")) :on-disable (fn [] (println "on disable")) :cleanup (fn [] (println "cleaning")))

If any function returns a hash map, the hash map will be registered to the mutable global state under app-states entry.

Please have a look AppState and BaseAppState for more.

apply-input-mapping clj

(apply-input-mapping {:keys [triggers listeners] :as m})

asset-manager clj

(asset-manager)

attach clj

(attach app-state)

attach-child clj

(attach-child node s)

audio-node clj

(audio-node name type)

bitmap-text clj

(bitmap-text gui-font right-to-left)

box clj

(box x y z)

bullet-app-state clj

(bullet-app-state)

call* clj macro

(call* obj kw & args)

Java interop for methods. Since we can't wrap all functions of jMonkeyEngine, we can use a shortcut like this.

e.g.: (call* player :jump (vec3 0 20 0)) -> (.jump player (vec3 0 20 0))

cam clj

(cam)

capsule-collision-shape clj

(capsule-collision-shape radius height axi)

character-control clj

(character-control shape step-height)

clear clj

(clear app)

Detaches all child nodes and removes all local lights from the root node.

collide-with clj

(collide-with o collidable results)

collision-results clj

(collision-results)

color-rgba clj

(color-rgba r g b a)

context clj

(context)

control clj

(control kw & {:keys [update render]})

Controls are used to specify certain update and render logic for a Spatial.

If any function returns a hash map, the hash map will be registered to the mutable global state under controls entry.

(control ::my-control :update (fn [tpf] (println "update" tpf)) :render (fn [rm vp] (println "render" rm vp)))

Please have a look Control and AbstractControl for more.

control-enabled? clj

(control-enabled?)

create-channel clj

(create-channel control)

create-mesh-shape clj

(create-mesh-shape spatial)

defsimpleapp clj macro

(defsimpleapp name & {:keys [opts init update]})

Creates a SimpleApplication instance and binds with given name. Requires 3 parameters besides name. init (initialize fn, required) update (update fn, optional) opts (app settings, optional)

e.g.: (defsimpleapp app :opts {:show-settings? false :pause-on-lost-focus? false :settings {:title "My JME Game" :load-defaults? true :frame-rate 60}} :init init :update simple-update)

When init fn returns a hash map, this map registered to the mutable global state so it can be accessed from update fn and other fns. Also, this applies for the update fn, it's content merged to the mutable global state.

For other settings options, please have a look app-settings fn.

It's not recommended to create multiple defsimpleapp instances inside one JVM. Some odd behaviours might occur due to shared states. Please run new JVM instance per application.

If you would like to run another SimpleApplication instance inside the same JVM (same REPL), an option could be using unbind-app for unbinding current app (var), and re-defining app with defsimpleapp.

Please have a look at com.jme3.app.SimpleApplication for more.

detach clj

(detach app-state)

detach-all-child clj

(detach-all-child node)

emit-all-particles clj

(emit-all-particles pe)

fly-cam clj

(fly-cam)

generate clj

(generate mesh)

geo clj

(geo name mesh)

get* clj macro

(get* obj kw & args)

Java interop for methods with get prefix.

e.g.: (get* (cam) :rotation) -> (.getRotation (cam))

get-hm clj

(get-hm hm)

get-main-state clj

(get-main-state)

Returns the mutable global state map.

get-spatial clj

(get-spatial)

get-state clj

(get-state)

(get-state type)

gui-node clj

(gui-node)

image clj

(image texture)

image-based-hm clj

(image-based-hm img)

input-manager clj

(input-manager)

instances clj

A list of SimpleApplication instances created with defsimpleapp.

key-trigger clj

(key-trigger code)

letj clj macro

(letj bindings & body)

Executes the body and returns a hash map with key-val pairs that extracted from bindings. Ignores _ bindings.

e.g.: (letj [shootables (node "Shootables") _ (init-keys) _ (init-cross-hairs) mark (init-mark)] (-> shootables (add-to-root) (attach-child (make-cube "the Deputy" 1 0 -4)) (attach-child (make-floor)) (attach-child (make-char))))

=> {:mark mark :shootables shootables}

light clj

(light type)

listener clj

(listener)

load-asset clj

(load-asset path)

load-font clj

(load-font path)

load-hm clj

(load-hm hm)

load-model clj

(load-model path)

load-texture clj

(load-texture path)

look-at clj

(look-at pos world-up-vec)

(look-at cam pos world-up-vec)

map->app-settings clj

(map->app-settings settings)

material clj

(material path)

Matrix clj protocol

add clj

(add this v)

(add this x y)

(add this x y z)

add-loc clj

(add-loc this v)

(add-loc this x y z)

mult clj

(mult this scalar)

mult-loc clj

(mult-loc this scalar)

negate clj

(negate this)

setv clj

(setv this v)

(setv this x y)

(setv this x y z)

mouse-ax-trigger clj

(mouse-ax-trigger code negative?)

mouse-trigger clj

(mouse-trigger code)

node clj

(node name)

particle-emitter clj

(particle-emitter name type num-particles)

play clj

(play an)

play-ins clj

(play-ins an)

raw-input-listener clj

(raw-input-listener &
                    {:keys [begin-input end-input on-joy-axis-event
                            on-joy-button-event on-mouse-motion-event
                            on-mouse-button-event on-key-event on-touch-event]})

ray clj

(ray origin direction)

re-init clj

(re-init init-fn)

Re-initializes the app with given init fn. It does not stop the app. Can be used when new code changes needed for the init fn.

register-locator clj

(register-locator path locator)

remove-from-root clj

(remove-from-root node)

remove-light clj

(remove-light spatial light)

remove-state clj

(remove-state ks)

(remove-state type ks)

rigid-body-control clj

(rigid-body-control mass)

(rigid-body-control shape mass)

root-node clj

(root-node)

rotate clj

(rotate spatial x y z)

run clj macro

(run app & body)

Every code that changes the state should be wrapped with run macro. Otherwise Make sure you do not modify the scene from another thread! exception will be thrown.

running? clj

(running? app)

scale clj

(scale spatial s)

(scale spatial x y z)

scale-texture-coords clj

(scale-texture-coords mesh scale-factor)

set* clj macro

(set* obj kw & args)

Java interop for methods with set prefix. Since it returns the given object, this fn can be chained with other set*s using the thread-first -> macro.

e.g.: (set* channel :speed 1.0) -> (.setSpeed channel 1.0)

set-display-fps clj

(set-display-fps show)

set-display-stat-view clj

(set-display-stat-view show)

set-state clj

(set-state ks v)

(set-state type ks v)

setc clj macro

(setc obj & args)

Compact version of set* e.g.: (setc debris :material mat-debris :images-x 3 :images-y 3 :rotate-speed 4 :select-random-image true :start-color ColorRGBA/White :gravity [0 6 0] :low-life 1 :high-life 3)

When you need to pass multiple parameters, use a vector. e.g.: (setc :local-translation [0.0 -5.0 -2.0])

size clj

(size o)

sphere clj

(sphere x y z)

(sphere x y z use-even-slices? interior?)

start clj

(start app)

Starts the SimpleApplication instance.

It's not recommended to call start fn after calling stop fn. Some odd behaviours might occur such as JVM crash (based on the app, apps use Bullet API [not always]).

If you would like to re-start the app then use unbind-app instead of stop, after re-defining app with defsimpleapp then call start again.

state-manager clj

(state-manager)

states clj

The mutable global state of the application. It keeps app, app-state, control states and others.

stop clj

(stop app)

Stops the SimpleApplication instance. Can be used when the user wants to exit from the game.

It's not recommended to call start fn after calling stop fn. Some odd behaviours might occur such as JVM crash (based on the app, apps use Bullet API [not always]).

If you would like to re-start the app then use unbind-app instead of stop, after re-defining app with defsimpleapp then call start again.

terrain-lod-control clj

(terrain-lod-control terrain camera)

terrain-quad clj

(terrain-quad name path-size total-size hm)

unbind-all clj

(unbind-all)

Unbinds all SimpleApplication instances from the vars. Should be used for development purposes only. Can be used for some leftover instances in the REPL.

e.g.: (unbind-all)

After calling unbind-all, app can be re-defined with defsimpleapp.

unbind-app clj

(unbind-app v)

Unbinds the SimpleApplication instance from the var. Should be used for development purposes only.

e.g.: (unbind-app #'my-ns/app)

After calling unbind-app, app can be re-defined with defsimpleapp.

unshaded-mat clj

(unshaded-mat)

update-state clj

(update-state type ks f & args)

vec2 clj

(vec2)

(vec2 x y)

(vec2 x y normalize)

vec3 clj

(vec3)

(vec3 x y z)

(vec3 x y z normalize)

view-port clj

(view-port)