jme-clj.core — jme-clj 0.1.0

*app* 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.

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)

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 global mutable 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 global mutable 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-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 global mutable state map for the whole application.

get-state clj

(get-state)

Returns value of :jme-clj.core/app key. It's used for keeping SimpleApplication's state.

gui-node clj

(gui-node)

image clj

(image texture)

image-based-hm clj

(image-based-hm img)

input-manager clj

(input-manager)

instances clj

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

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)

Removes a key inside :jme-clj.core/app entry. It's used for updating SimpleApplication's state.

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)

Sets a key-value pair inside :jme-clj.core/app entry. It's used for updating SimpleApplication's state.

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. Should be used for development purposes only. 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

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. Should be used for development purposes only. 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 ks f & args)

Updates :jme-clj.core/app entry. It's used for updating SimpleApplication's state.

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)