jMonkeyEngine

https://wiki.jmonkeyengine.org/docs/3.8
Admin
jMonkeyEngine is an open-source 3D game engine for Java developers, providing tools and libraries...
Tokens:321,454
Snippets:3,604
Trust Score:9.3
Update:3 months ago
Show doc for...
Tokens:
Raw
### TonegodGUI Quick Start Example

Source: https://wiki.jmonkeyengine.org/docs/3.8/contributions/gui/tonegodgui/quickstart.html

This example demonstrates how to initialize a TonegodGUI screen, create a main window, add a button to it, and handle button clicks to create new windows.

```java
public int winCount = 0;
private Screen screen;

public final void createNewWindow(String someWindowTitle) {
    Window nWin = new Window(
        screen,
        "Window" + winCount,
        new Vector2f( (screen.getWidth()/2)-175, (screen.getHeight()/2)-100 )
    );
    nWin.setWindowTitle(someWindowTitle);
    screen.addElement(nWin);
    winCount++;
}

public void simpleInitApp() {
    screen = new Screen(this, "tonegod/gui/style/def/style_map.xml");
    screen.initialize();
    guiNode.addControl(screen);

    // Add window
    Window win = new Window(screen, "win", new Vector2f(15, 15));

    // create button and add to window
    ButtonAdapter makeWindow = new ButtonAdapter( screen, "Btn1", new Vector2f(15, 55) ) {
        @Override
        public void onButtonMouseLeftUp(MouseButtonEvent evt, boolean toggled) {
            createNewWindow("New Window " + winCount);
        }
    };

    // Add it to our initial window
    win.addChild(makeWindow);

    // Add window to the screen
   screen.addElement(win);
}
```

--------------------------------

### Sample VR Application Setup and Update Loop

Source: https://wiki.jmonkeyengine.org/docs/3.8/core/vr/virtualrealitycontrollers.html

A comprehensive example demonstrating the initialization of a VR environment, setting up the application, and updating controller positions, rotations, and button states in the main loop. It also includes visual markers for controller positions.

```java
public class Main extends SimpleApplication{

    public static void main(String[] args) {
        AppSettings settings = new AppSettings(true);
        settings.put(VRConstants.SETTING_VRAPI, VRConstants.SETTING_VRAPI_OPENVR_LWJGL_VALUE);

        VREnvironment env = new VREnvironment(settings);

        env.initialize();

        if (env.isInitialized()){
            VRAppState vrAppState = new VRAppState(settings, env);

            Main app = new Main(vrAppState);
            app.setLostFocusBehavior(LostFocusBehavior.Disabled);
            app.setSettings(settings);
            app.setShowSettings(false);
            app.start();
        }
    }

    public Main(AppState... appStates) {
        super(appStates);
    }

    @Override
    public void simpleInitApp() {
        Box b = new Box(1, 1, 1);
        Geometry geom = new Geometry("Box", b);

        Material mat = new Material(assetManager, "Common/MatDefs/Misc/Unshaded.j3md");
        mat.setColor("Color", ColorRGBA.Blue);
        geom.setMaterial(mat);

        rootNode.attachChild(geom);
    }

    List<Geometry> handGeometries = new ArrayList<>();

    @Override
    public void simpleUpdate(float tpf) {
        VRAppState vrAppState = getStateManager().getState(VRAppState.class);
        int numberOfControllers = vrAppState.getVRinput().getTrackedControllerCount(); //almost certainly 2, one for each hand

        //build as many geometries as hands, as markers for the demo (Will only tigger on first loop or if number of controllers changes)
        while(handGeometries.size()<numberOfControllers){
            Box b = new Box(0.1f, 0.1f, 0.1f);
            Geometry handMarker = new Geometry("hand", b);
            Material mat = new Material(assetManager, "Common/MatDefs/Misc/Unshaded.j3md");
            mat.setColor("Color", ColorRGBA.Red);
            handMarker.setMaterial(mat);
            rootNode.attachChild(handMarker);
            handGeometries.add(handMarker);
        }

        VRInputAPI vrInput = vrAppState.getVRinput();
        for(int i=0;i<numberOfControllers;i++){
            if (vrInput.isInputDeviceTracking(i)){
                Vector3f position = vrInput.getFinalObserverPosition(i);
                Quaternion rotation = vrInput.getFinalObserverRotation(i);

                Geometry geometry = handGeometries.get(i);
                geometry.setLocalTranslation(position);
                geometry.setLocalRotation(rotation);
                boolean grip = vrInput.isButtonDown(i, VRInputType.ViveGripButton); //<--Don't worry about the way it says "Vive", anything that supports SteamVR/OpenVR will work with this

                if (grip){
                    geometry.getMaterial().setColor("Color", ColorRGBA.Green);
                }else{
                    geometry.getMaterial().setColor("Color", ColorRGBA.Red);
                }

                boolean trigger = vrInput.wasButtonPressedSinceLastCall(i, VRInputType.ViveTriggerAxis);
                if (trigger){
                    vrInput.triggerHapticPulse(i, 0.3f);
                }
            }
        }
    }
}
```

--------------------------------

### jMonkeyEngine Hello Input System Example

Source: https://wiki.jmonkeyengine.org/docs/3.8/tutorials/beginner/hello_input_system.html

This is a complete jMonkeyEngine application demonstrating custom input mapping for game actions. It includes setup for discrete actions (like pausing) and continuous actions (like movement and rotation).

```Java
package jme3.helloworld;

import com.jme3.app.SimpleApplication;
import com.jme3.material.Material;
import com.jme3.math.Vector3f;
import com.jme3.scene.Geometry;
import com.jme3.scene.shape.Box;
import com.jme3.math.ColorRGBA;
import com.jme3.input.KeyInput;
import com.jme3.input.MouseInput;
import com.jme3.input.controls.ActionListener;
import com.jme3.input.controls.AnalogListener;
import com.jme3.input.controls.KeyTrigger;
import com.jme3.input.controls.MouseButtonTrigger;

/** Sample 5 - how to map keys and mouse buttons to actions */

public class HelloInput extends SimpleApplication {

    public static void main(String[] args) {
        HelloInput app = new HelloInput();
        app.start();
    }

    private Geometry player;
    private Boolean isRunning = true;

    @Override
    public void simpleInitApp() {
        Box b = new Box(1, 1, 1);
        player = new Geometry("Player", b);
        Material mat = new Material(assetManager, "Common/MatDefs/Misc/Unshaded.j3md");
        mat.setColor("Color", ColorRGBA.Blue);
        player.setMaterial(mat);
        rootNode.attachChild(player);
        initKeys(); // load my custom keybinding
    }

    /** Custom Keybinding: Map named actions to inputs. */
    private void initKeys() {
        /* You can map one or several inputs to one named mapping. */
        inputManager.addMapping("Pause",  new KeyTrigger(KeyInput.KEY_P));
        inputManager.addMapping("Left",   new KeyTrigger(KeyInput.KEY_J));
        inputManager.addMapping("Right",  new KeyTrigger(KeyInput.KEY_K));
        inputManager.addMapping("Rotate", new KeyTrigger(KeyInput.KEY_SPACE),
                                          new MouseButtonTrigger(MouseInput.BUTTON_LEFT));
        /* Add the named mappings to the action listeners. */
        inputManager.addListener(actionListener, "Pause");
        inputManager.addListener(analogListener, "Left", "Right", "Rotate");

    }

  /** Use this listener for KeyDown/KeyUp events */
    final private ActionListener actionListener = new ActionListener() {
        @Override
        public void onAction(String name, boolean keyPressed, float tpf) {
            if (name.equals("Pause") && !keyPressed) {
                isRunning = !isRunning;
            }
        }
    };

  /** Use this listener for continuous events */
    final private AnalogListener analogListener = new AnalogListener() {
        @Override
        public void onAnalog(String name, float value, float tpf) {
            if (isRunning) {
                if (name.equals("Rotate")) {
                    player.rotate(0, value, 0);
                }
                if (name.equals("Right")) {
                    player.move((new Vector3f(value, 0,0)) );
                }
                if (name.equals("Left")) {
                    player.move(new Vector3f(-value, 0,0));
                }
            } else {
                System.out.println("Press P to unpause.");
            }
        }
    };
}
```

--------------------------------

### Sample jMonkeyEngine VR Application Setup

Source: https://wiki.jmonkeyengine.org/docs/3.8/core/vr/legacyOpenVr.html

Demonstrates initializing a jMonkeyEngine application with OpenVR support using LWJGL bindings and enabling a mirror window. Includes basic scene setup.

```java
public class Main extends SimpleApplication {

    public static void main(String[] args) {
        AppSettings settings = new AppSettings(true);
        settings.put(VRConstants.SETTING_VRAPI, VRConstants.SETTING_VRAPI_OPENVR_LWJGL_VALUE);
        settings.put(VRConstants.SETTING_ENABLE_MIRROR_WINDOW, true);

        VREnvironment env = new VREnvironment(settings);
        env.initialize();

    	// Checking if the VR environment is well initialized
    	// (access to the underlying VR system is effective, VR devices are detected).
    	if (env.isInitialized()){
            VRAppState vrAppState = new VRAppState(settings, env);
            vrAppState.setMirrorWindowSize(1024, 800);
            Main app = new Main(vrAppState);
            app.setLostFocusBehavior(LostFocusBehavior.Disabled);
            app.setSettings(settings);
            app.setShowSettings(false);
            app.start();
        }
    }

    public Main(AppState... appStates) {
        super(appStates);
    }

    @Override
    public void simpleInitApp() {
        Box b = new Box(1, 1, 1);
        Geometry geom = new Geometry("Box", b);

        Material mat = new Material(assetManager, "Common/MatDefs/Misc/Unshaded.j3md");
        mat.setColor("Color", ColorRGBA.Blue);
        geom.setMaterial(mat);

        rootNode.attachChild(geom);
    }

    @Override
    public void simpleUpdate(float tpf) {
        //TODO: add update code
    }

    @Override
    public void simpleRender(RenderManager rm) {
        //TODO: add render code
    }
}
```

--------------------------------

### Initialize and Start Server

Source: https://wiki.jmonkeyengine.org/docs/3.8/networking/networking.html

Creates and starts a network server on a specified communication port within the application's initialization phase.

```java
@Override
public void simpleInitApp() {
  ...
  Server myServer = Network.createServer(6143);
  myServer.start();
  ...
}
```

--------------------------------

### Start the JME3 Application

Source: https://wiki.jmonkeyengine.org/docs/3.8/tutorials/beginner/hello_simpleapplication.html

The main method instantiates your SimpleApplication subclass and calls start() to launch the game engine.

```java
public static void main(String[] args){
    HelloJME3 app = new HelloJME3(); // instantiate the game
    app.start();                     // start the game!
}
```

--------------------------------

### Basic Nifty GUI Java Layout Example

Source: https://wiki.jmonkeyengine.org/docs/3.8/core/gui/nifty_gui_java_layout.html

This snippet demonstrates the fundamental structure for creating a Nifty GUI screen with a layer, a panel, and a button using Java builders. It includes necessary imports and setup for a SimpleApplication.

```java
package mygame;

import com.jme3.app.Application;
import com.jme3.app.SimpleApplication;
import com.jme3.app.state.BaseAppState;
import com.jme3.niftygui.NiftyJmeDisplay;
import de.lessvoid.nifty.Nifty;
import de.lessvoid.nifty.builder.LayerBuilder;
import de.lessvoid.nifty.builder.PanelBuilder;
import de.lessvoid.nifty.builder.ScreenBuilder;
import de.lessvoid.nifty.controls.button.builder.ButtonBuilder;
import de.lessvoid.nifty.screen.DefaultScreenController;

public class MyStartScreen extends BaseAppState {

    @Override
    protected void initialize(Application app) {
        //It is technically safe to do all initialization and cleanup in the
        //onEnable()/onDisable() methods. Choosing to use initialize() and
        //cleanup() for this is a matter of performance specifics for the
        //implementor.
        //TODO: initialize your AppState, e.g. attach spatials to rootNode
    }

    @Override
    protected void cleanup(Application app) {
        //TODO: clean up what you initialized in the initialize method,
        //e.g. remove all spatials from rootNode
    }

    //onEnable()/onDisable() can be used for managing things that should
    //only exist while the state is enabled. Prime examples would be scene
    //graph attachment or input listener attachment.
    @Override
    protected void onEnable() {
        NiftyJmeDisplay niftyDisplay = NiftyJmeDisplay.newNiftyJmeDisplay(
                getApplication().getAssetManager(),
                getApplication().getInputManager(),
                getApplication().getAudioRenderer(),
                getApplication().getGuiViewPort());

        Nifty nifty = niftyDisplay.getNifty();
        getApplication().getGuiViewPort().addProcessor(niftyDisplay);
        ((SimpleApplication) getApplication()).getFlyByCamera().setDragToRotate(true);

        nifty.loadStyleFile("nifty-default-styles.xml");
        nifty.loadControlFile("nifty-default-controls.xml");

        // <screen>
        nifty.addScreen("Screen_ID", new ScreenBuilder("Hello Nifty Screen"){{
            controller(new DefaultScreenController()); // Screen properties

            // <layer>
            layer(new LayerBuilder("Layer_ID") {{
                childLayoutVertical(); // layer properties, add more...

                // <panel>
                panel(new PanelBuilder("Panel_ID") {{
                   childLayoutCenter(); // panel properties, add more...

                    // GUI elements
                    control(new ButtonBuilder("Button_ID", "Hello Nifty"){{
                        alignCenter();
                        valignCenter();
                        height("5%");
                        width("15%");
                    }});

                    //.. add more GUI elements here

                }});
                // </panel>
              }});
            // </layer>
          }}.build(nifty));
        // </screen>

        nifty.gotoScreen("Screen_ID"); // start the screen
    }

    @Override
    protected void onDisable() {
        //Called when the state was previously enabled but is now disabled
        //either because setEnabled(false) was called or the state is being
        //cleaned up.
    }

    @Override
    public void update(float tpf) {
        //TODO: implement behavior during runtime
    }

}

```

--------------------------------

### InstancedNode Example

Source: https://wiki.jmonkeyengine.org/docs/3.8/core/scene/instancednode.html

Demonstrates how to create and configure an InstancedNode with multiple geometries and enable instancing.

```java
InstancedNode instancedNode = new InstancedNode();

Geometry geometry = new Geometry("randomGeom", mesh);
geometry.setLocalTranslation(2, 0, 0);

Geometry geometry2 = new Geometry("randomGeom2", mesh);
geometry2.setLocalTranslation(-2, 0, 0);

Material material = new Material(assetManager, "Common/MatDefs/Misc/Unshaded.j3md");
material.setBoolean("UseInstancing", true);
geometry.setMaterial(material);
geometry2.setMaterial(material);

instancedNode.attachChild(geometry);
instancedNode.attachChild(geometry2);

instancedNode.instance();
```

--------------------------------

### Example pipelineRender Implementation

Source: https://wiki.jmonkeyengine.org/docs/3.8/core/renderer/render_pipeline.html

An example implementation of the pipelineRender method, demonstrating how to set up the frame buffer, clear buffers, set background color, and render geometries within a viewport.

```java
@Override
public void pipelineRender(RenderManager rm, MyPipelineContext context, ViewPort vp, float tpf) {
    // apply viewport to rendering context
    rm.getRenderer().setFrameBuffer(vp.getOutputFrameBuffer());
    rm.getRenderer().clearBuffers(true, true, true);
    rm.getRenderer().setBackgroundColor(vp.getBackgroundColor());
    rm.setCamera(vp.getCamera(), false);
    // render each geometry in all viewport scenes
    for (Spatial scene : vp.getScenes()) {
        scene.depthFirstTraversal(s -> {
            if (s instanceof Geometry) {
                rm.renderGeometry((Geometry)s);
            }
        });
    }
    // reset clip rect
    rm.getRenderer().clearClipRect();
}
```

--------------------------------

### Start Video Recording with VideoRecorderAppState

Source: https://wiki.jmonkeyengine.org/docs/3.8/core/app/state/capture_audio_video_to_a_file.html

Attach the VideoRecorderAppState to start recording video. Recording begins when the state is attached and ends when the application quits or the state is detached. Video files are saved to the user home directory by default.

```java
stateManager.attach(new VideoRecorderAppState()); //start recording
```

--------------------------------

### Setup Keys for Continuous Input

Source: https://wiki.jmonkeyengine.org/docs/3.8/tutorials/beginner/hello_input_system/timekeypressed.html

Maps input actions to specific keys for continuous input handling. This setup is crucial for actions that should repeat while a key is held down.

```java
private void setupKeys() {
    inputManager.addMapping("Left", new KeyTrigger(KeyInput.KEY_A));
    inputManager.addMapping("Right", new KeyTrigger(KeyInput.KEY_D));
    inputManager.addMapping("Up", new KeyTrigger(KeyInput.KEY_W));
    inputManager.addMapping("Down", new KeyTrigger(KeyInput.KEY_S));

    inputManager.addListener(this, "Left", "Right", "Up", "Down");
}
```

--------------------------------

### Start Screen with Load Game Button

Source: https://wiki.jmonkeyengine.org/docs/3.8/core/gui/loading_screen.html

Defines the 'start' screen, which displays a button to initiate the game loading process. This screen serves as a simple main menu UI.

```XML
<screen id="start" controller = "jme3test.TestLoadingScreen">
    <layer id="layer" childLayout="center">
        <panel id = "panel2" height="30%" width="50%" align="center" valign="center"
          childLayout="vertical" visibleToMouse="true">
            <control id="startGame" name="button" backgroundColor="#0000" label="Load Game"
              align="center"> <interact onClick="showLoadingMenu()" />
            </control>
        </panel>
    </layer>
</screen>
```

--------------------------------

### Example jMonkeyEngine SDK Log Entry

Source: https://wiki.jmonkeyengine.org/docs/3.8/sdk/log_files.html

This snippet shows an example of a log session entry from the jMonkeyEngine SDK, including system information such as product version, operating system, Java details, and directory paths.

```log
>Log Session: Saturday, September 24, 2011 10:45:30 AM CEST
>System Info:
  Product Version         = jMonkeyPlatform Alpha-4
  Operating System        = Mac OS X version 10.6.8 running on i386
  Java; VM; Vendor        = 1.6.0_26; Java HotSpot(TM) Client VM 20.1-b02-384; Apple Inc.
  Runtime                 = Java(TM) SE Runtime Environment 1.6.0_26-b03-384-10M3425
  Java Home               = /System/Library/Java/JavaVirtualMachines/1.6.0.jdk/Contents/Home
  System Locale; Encoding = de_DE (jmonkeyplatform); MacRoman
  Home Directory          = /Users/joemonkey
  Current Directory       = /
  User Directory          = /Users/joemonkey/Library/Application Support/jmonkeyplatform/dev
  Installation            = /Applications/jmonkeyplatform.app/Contents/Resources/jmonkeyplatform/jmonkeyplatform
  ...

```

--------------------------------

### Modern Graphic Card Capabilities Example

Source: https://wiki.jmonkeyengine.org/docs/3.8/tutorials/how-to/java/read_graphic_card_capabilites.html

This example log output shows the capabilities of a modern graphic card, including support for OpenGL 2.1 and NonPowerOfTwoTextures.

```log
INFO: Running on jMonkeyEngine 3.0.0
INFO: Using LWJGL 2.8.2
INFO: Selected display mode: 1280 x 720 x 0 @0Hz
INFO: Adapter: null
INFO: Driver Version: null
INFO: Vendor: ATI Technologies Inc.
INFO: OpenGL Version: 2.1 ATI-7.14.5
INFO: Renderer: AMD Radeon HD 6770M OpenGL Engine
INFO: GLSL Ver: 1.20
INFO: Timer resolution: 1.000 ticks per second
INFO: Capabilities: [FrameBuffer, FrameBufferMRT, FrameBufferMultisample,
OpenGL20, OpenGL21, ARBprogram, GLSL100, GLSL110, GLSL120,
VertexTextureFetch, TextureArray, FloatTexture,
FloatColorBuffer, FloatDepthBuffer, PackedFloatTexture, SharedExponentTexture, PackedFloatColorBuffer,
TextureCompressionLATC, NonPowerOfTwoTextures, MeshInstancing]
```

--------------------------------

### Nifty GUI Panels for Start Screen

Source: https://wiki.jmonkeyengine.org/docs/3.8/core/gui/nifty_gui_xml_layout.html

Defines panels within the 'start' screen's foreground layer. These panels serve as containers for content and are arranged using specified dimensions and alignment.

```XML
<panel id="panel_top" height="25%" width="75%" align="center" childLayout="center"
  backgroundColor="#f008">
</panel>
<panel id="panel_mid" height="50%" width="75%" align="center" childLayout="center"
  backgroundColor="#0f08">
</panel>
<panel id="panel_bottom" height="25%" width="75%" align="center" childLayout="horizontal"
  backgroundColor="#00f8">
  <panel id="panel_bottom_left" height="50%" width="50%" valign="center" childLayout="center"
    backgroundColor="#44f8">
  </panel>
  <panel id="panel_bottom_right" height="50%" width="50%" valign="center" childLayout="center"
    backgroundColor="#88f8">
  </panel>
</panel>
```

--------------------------------

### Respond to Animation Start

Source: https://wiki.jmonkeyengine.org/docs/3.8/core/animation/animation.html

Implements the onAnimChange method to react just before an animation starts playing. This example transitions from 'Walk' to 'Reset' animation.

```java
public void onAnimChange(AnimControl control, AnimChannel channel, String animName) {
    // test for a condition you are interested in, e.g. ...
    if (animName.equals("Walk")) {
      // respond to the event here, e.g. ...
      channel.setAnim("Reset", 0.50f);
    }
  }
```

--------------------------------

### Get Number of VR Controllers

Source: https://wiki.jmonkeyengine.org/docs/3.8/core/vr/virtualrealitycontrollers.html

Retrieves the total number of tracked VR controllers. This is typically 2 for a standard VR setup but is not guaranteed.

```java
vrAppState.getVRinput().getTrackedControllerCount(); //very likely to be 2, for the 2 hands but this is not guaranteed
```

--------------------------------

### Creating and Displaying a Menu Example

Source: https://wiki.jmonkeyengine.org/docs/3.8/contributions/gui/tonegodgui/menu.html

Demonstrates how to set up the jMonkeyEngine environment, create a sub-menu, add menu items with different configurations, and display the main menu when a button is clicked.

```java
flyCam.setDragToRotate(true);
inputManager.setCursorVisible(true);

screen = new Screen(this);
guiNode.addControl(screen);

Menu subMenu = new Menu(
    screen,
    new Vector2f(0,0),
    false
) {
    @Override
    public void onMenuItemClicked(int index, Object value, boolean isToggled) {  }
};
// Add a menu item
subMenu.addMenuItem("Some string caption 1", null, null);
// Add a toggle-able menu item (checkbox)
subMenu.addMenuItem("Some string caption 2", null, null, true);
// Add a toggle-able menu item and set the default state of the checkbox to checked
subMenu.addMenuItem("Some string caption 3", null, null, true, true);
screen.addElement(subMenu);

final Menu menu = new Menu(
    screen,
    new Vector2f(0,0),
    false
) {
    @Override
    public void onMenuItemClicked(int index, Object value, boolean isToggled) {  }
};
// Add subMenu as a sub-menu to this menu item
menu.addMenuItem("Some caption", null, subMenu);
screen.addElement(menu);

ButtonAdapter b = new ButtonAdapter(screen, new Vector2f(50,50)) {
    @Override
    public void onButtonMouseLeftUp(MouseButtonEvent evt, boolean isToggled) {
        menu.showMenu(null, getAbsoluteX(), getAbsoluteY()-menu.getHeight());
    }
};
b.setText("Show Menu");
screen.addElement(b);
```

--------------------------------

### Hello Animation Example

Source: https://wiki.jmonkeyengine.org/docs/3.8/tutorials/beginner/hello_animation.html

This Java code demonstrates loading a model, setting up an animation controller, defining animation actions (like 'stand', 'Walk', 'halt', 'advance'), and mapping keyboard input to trigger these animations. It includes a callback for when an animation sequence completes.

```Java
package jme3test.helloworld;

import com.jme3.anim.AnimComposer;
import com.jme3.anim.tween.Tween;
import com.jme3.anim.tween.Tweens;
import com.jme3.anim.tween.action.Action;
import com.jme3.anim.tween.action.BlendSpace;
import com.jme3.anim.tween.action.LinearBlendSpace;
import com.jme3.app.SimpleApplication;
import com.jme3.input.KeyInput;
import com.jme3.input.controls.ActionListener;
import com.jme3.input.controls.KeyTrigger;
import com.jme3.light.DirectionalLight;
import com.jme3.math.ColorRGBA;
import com.jme3.math.Vector3f;
import com.jme3.scene.Node;

/** Sample 7 - how to load an OgreXML model and play an animation,
 * using AnimComposer */
public class HelloAnimation extends SimpleApplication{

    private AnimComposer control;
    private Action advance;

    Node player;
    public static void main(String[] args) {
        HelloAnimation app = new HelloAnimation();
        app.start();
    }

    @Override
    public void simpleInitApp() {
        viewPort.setBackgroundColor(ColorRGBA.LightGray);
        initKeys();
        DirectionalLight dl = new DirectionalLight();
        dl.setDirection(new Vector3f(-0.1f, -1f, -1).normalizeLocal());
        rootNode.addLight(dl);
        player = (Node) assetManager.loadModel("Models/Oto/Oto.mesh.xml");
        player.setLocalScale(0.5f);
        rootNode.attachChild(player);
        control = player.getControl(AnimComposer.class);
        control.setCurrentAction("stand");

        /* Compose an animation action named "halt"
        that transitions from "Walk" to "stand" in half a second. */
        BlendSpace quickBlend = new LinearBlendSpace(0f, 0.5f);
        Action halt = control.actionBlended("halt", quickBlend, "stand", "Walk");
        halt.setLength(0.5);

        /* Compose an animation action named "advance"
        that walks for one cycle, then halts, then invokes onAdvanceDone(). */
        Action walk = control.action("Walk");
        Tween doneTween = Tweens.callMethod(this, "onAdvanceDone");
        advance = control.actionSequence("advance", walk, halt, doneTween);
    }

    /**
     * Callback to indicate that the "advance" animation action has completed.
     */
    void onAdvanceDone() {
        /*
         * Play the "stand" animation action.
         */
        control.setCurrentAction("stand");
    }

    /**
     * Map the spacebar to the "Walk" input action, and add a listener to initiate
     * the "advance" animation action each time it's pressed.
     */
    private void initKeys() {
        inputManager.addMapping("Walk", new KeyTrigger(KeyInput.KEY_SPACE));

        ActionListener handler = new ActionListener() {
            @Override
            public void onAction(String name, boolean keyPressed, float tpf) {
                if (keyPressed && control.getCurrentAction() != advance) {
                    control.setCurrentAction("advance");
                }
            }
        };
        inputManager.addListener(handler, "Walk");
    }
}
```

--------------------------------

### ScrollArea Configuration Methods

Source: https://wiki.jmonkeyengine.org/docs/3.8/contributions/gui/tonegodgui/scrollarea.html

Provides examples of common configuration methods for the ScrollArea class, including getting and setting padding, and retrieving scrollable height.

```java
// Config methods
scrollArea.getIsTextOnly();
scrollArea.setPadding(float padding);
scrollArea.getPadding();
scrollArea.getScrollableHeight();
```

--------------------------------

### Copy Libraries to Project

Source: https://wiki.jmonkeyengine.org/docs/3.8/getting-started/simpleapplication_from_the_commandline.html

This step copies all necessary JAR libraries from the jMonkeyEngine 3 installation to your project's library folder. This is a one-time setup for each new JME3 build.

```bash
mkdir HelloJME3/build
mkdir HelloJME3/lib
cp jme3/lib/*.* HelloJME3/lib
```

--------------------------------

### Hello Audio - jMonkeyEngine 3 Tutorial

Source: https://wiki.jmonkeyengine.org/docs/3.8/tutorials/beginner/hello_audio.html

This is the main class for the Hello Audio tutorial. It demonstrates setting up 3D audio, including positional and looping sounds, and triggering sound effects via mouse clicks.

```Java
package jme3test.helloworld;

import com.jme3.app.SimpleApplication;
import com.jme3.audio.AudioNode;
import com.jme3.audio.AudioData.DataType;
import com.jme3.input.MouseInput;
import com.jme3.input.controls.ActionListener;
import com.jme3.input.controls.MouseButtonTrigger;
import com.jme3.material.Material;
import com.jme3.math.ColorRGBA;
import com.jme3.scene.Geometry;
import com.jme3.scene.shape.Box;

/** Sample 11 - playing 3D audio. */
public class HelloAudio extends SimpleApplication {

  private AudioNode audio_gun;

  public static void main(String[] args) {
    HelloAudio app = new HelloAudio();
    app.start();
  }

  @Override
  public void simpleInitApp() {
    flyCam.setMoveSpeed(40);

    /** just a blue box floating in space */
    Box box1 = new Box(1, 1, 1);
    Geometry player = new Geometry("Player", box1);
    Material mat1 = new Material(assetManager,"Common/MatDefs/Misc/Unshaded.j3md");
    mat1.setColor("Color", ColorRGBA.Blue);
    player.setMaterial(mat1);
    rootNode.attachChild(player);

    /** custom init methods, see below */
    initKeys();
    initAudio();
  }

  /** We create two audio nodes. */
  private void initAudio() {
    /* gun shot sound is to be triggered by a mouse click. */
    audio_gun = new AudioNode(assetManager, "Sound/Effects/Gun.wav", DataType.Buffer);
    audio_gun.setPositional(false);
    audio_gun.setLooping(false);
    audio_gun.setVolume(2);
    rootNode.attachChild(audio_gun);

    /* nature sound - keeps playing in a loop. */
    AudioNode audio_nature = new AudioNode(assetManager, "Sound/Environment/Ocean Waves.ogg", DataType.Stream);
    audio_nature.setLooping(true);  // activate continuous playing
    audio_nature.setPositional(true);
    audio_nature.setVolume(3);
    rootNode.attachChild(audio_nature);
    audio_nature.play(); // play continuously!
  }

  /** Declaring "Shoot" action, mapping it to a trigger (mouse left click). */
  private void initKeys() {
    inputManager.addMapping("Shoot", new MouseButtonTrigger(MouseInput.BUTTON_LEFT));
    inputManager.addListener(actionListener, "Shoot");
  }

  /** Defining the "Shoot" action: Play a gun sound. */
  final private ActionListener actionListener = new ActionListener() {
    @Override
    public void onAction(String name, boolean keyPressed, float tpf) {
      if (name.equals("Shoot") && !keyPressed) {
        audio_gun.playInstance(); // play each instance once!
      }
    }
  };

  /** Move the listener with the a camera - for 3D audio. */
  @Override
  public void simpleUpdate(float tpf) {
    listener.setLocation(cam.getLocation());
    listener.setRotation(cam.getRotation());
  }

}
```

--------------------------------

### Configure and Apply SimpleWaterProcessor

Source: https://wiki.jmonkeyengine.org/docs/3.8/core/effect/water.html

This snippet demonstrates the core setup for the SimpleWaterProcessor, including setting the reflection scene, defining the water plane, configuring wave properties, and attaching the processor to the viewport. It also shows how to create and configure the water geometry itself.

```java
SimpleWaterProcessor waterProcessor = new SimpleWaterProcessor(assetManager);
waterProcessor.setReflectionScene(mainScene);

Vector3f waterLocation=new Vector3f(0,-6,0);
waterProcessor.setPlane(new Plane(Vector3f.UNIT_Y, waterLocation.dot(Vector3f.UNIT_Y)));
viewPort.addProcessor(waterProcessor);

waterProcessor.setWaterDepth(40);
waterProcessor.setDistortionScale(0.05f);
waterProcessor.setWaveSpeed(0.05f);

Quad quad = new Quad(400,400);
quad.scaleTextureCoordinates(new Vector2f(6f,6f));

Geometry water=new Geometry("water", quad);
water.setLocalRotation(new Quaternion().fromAngleAxis(-FastMath.HALF_PI, Vector3f.UNIT_X));
water.setLocalTranslation(-200, -6, 250);
water.setShadowMode(ShadowMode.Receive);
water.setMaterial(waterProcessor.getMaterial());
rootNode.attachChild(water);
```

--------------------------------

### Create Standard Game Client

Source: https://wiki.jmonkeyengine.org/docs/3.8/networking/networking.html

Extends SimpleApplication to create a client that opens a display window and listens for user input.

```java
public class ClientMain extends SimpleApplication {
  public static void main(String[] args) {
    ClientMain app = new ClientMain();
    app.start(JmeContext.Type.Display); // standard display type
  }
}
```

--------------------------------

### Xcode Header Search Path Configuration

Source: https://wiki.jmonkeyengine.org/docs/3.8/sdk/ios.html

If 'xcode-select --install' does not resolve jni.h errors, manually set the header search path in your Xcode project settings. This example uses SDK version 11.3 and Xcode version 9.3.

```bash
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk/System/Library/Frameworks/JavaVM.framework/Headers/
```

--------------------------------

### Initialize Nifty GUI and Load Styles

Source: https://wiki.jmonkeyengine.org/docs/3.8/core/gui/nifty_gui_java_layout.html

Sets up the Nifty GUI display, loads default styles and controls, and adds a screen controller. This is typically done within the onEnable method of an AppState.

```java
package mygame;

import com.jme3.app.Application;
import com.jme3.app.SimpleApplication;
import com.jme3.app.state.BaseAppState;
import com.jme3.niftygui.NiftyJmeDisplay;
import de.lessvoid.nifty.Nifty;
import de.lessvoid.nifty.builder.ImageBuilder;
import de.lessvoid.nifty.builder.LayerBuilder;
import de.lessvoid.nifty.builder.PanelBuilder;
import de.lessvoid.nifty.builder.ScreenBuilder;
import de.lessvoid.nifty.builder.TextBuilder;
import de.lessvoid.nifty.controls.button.builder.ButtonBuilder;
import de.lessvoid.nifty.controls.label.builder.LabelBuilder;
import de.lessvoid.nifty.screen.DefaultScreenController;

public class Screen extends BaseAppState {

    @Override
    protected void initialize(Application app) {
        //It is technically safe to do all initialization and cleanup in the
        //onEnable()/onDisable() methods. Choosing to use initialize() and
        //cleanup() for this is a matter of performance specifics for the
        //implementor.
        //TODO: initialize your AppState, e.g. attach spatials to rootNode
    }

    @Override
    protected void cleanup(Application app) {
        //TODO: clean up what you initialized in the initialize method,
        //e.g. remove all spatials from rootNode
    }

    //onEnable()/onDisable() can be used for managing things that should
    //only exist while the state is enabled. Prime examples would be scene
    //graph attachment or input listener attachment.
    @Override
    protected void onEnable() {
        NiftyJmeDisplay niftyDisplay = NiftyJmeDisplay.newNiftyJmeDisplay(
                getApplication().getAssetManager(),
                getApplication().getInputManager(),
                getApplication().getAudioRenderer(),
                getApplication().getGuiViewPort());

        Nifty nifty = niftyDisplay.getNifty();
        getApplication().getGuiViewPort().addProcessor(niftyDisplay);
        ((SimpleApplication) getApplication()).getFlyByCamera().setDragToRotate(true);

        nifty.loadStyleFile("nifty-default-styles.xml");
        nifty.loadControlFile("nifty-default-controls.xml");

        nifty.addScreen("start", new ScreenBuilder("start") {{
            controller(new DefaultScreenController());
            // layer added
            layer(new LayerBuilder("background") {{
                childLayoutCenter();
//                backgroundColor("#000f");

                // add image
                image(new ImageBuilder() {{ 
                    filename("Interface/start-background.png");
                }});
            }});

            layer(new LayerBuilder("foreground") {{ 
                childLayoutVertical();
//                backgroundColor("#0000");

                // panel added
                panel(new PanelBuilder("panel_top") {{ 
                    childLayoutCenter();
                    alignCenter();
//                    backgroundColor("#f008");
                    height("25%");
                    width("75%");

                    text(new TextBuilder() {{ 
                        text("My Cool Game");
                        font("Interface/Fonts/Arial.fnt");
                        height("100%");
                        width("100%");
                    }});
                }});

                panel(new PanelBuilder("panel_mid") {{ 
                    childLayoutCenter();
                    alignCenter();
//                    backgroundColor("#0f08");
                    height("50%");
                    width("75%");

                    // add text
                    text(new TextBuilder() {{ 
                        text("Here goes some text describing the game and the rules and stuff. "
                           + "Incidentally, the text is quite long and needs to wrap at the end of lines. ");
                        font("Interface/Fonts/Arial.fnt");
                        wrap(true);
                        height("100%");
                        width("100%");
                    }});
                }});

                panel(new PanelBuilder("panel_bottom") {{ 
                    childLayoutHorizontal();
                    alignCenter();
//                    backgroundColor("#00f8");
                    height("25%");
                    width("75%");

                    panel(new PanelBuilder("panel_bottom_left") {{ 
                        childLayoutCenter();
                        valignCenter();
//                        backgroundColor("#44f8");
                        height("50%");
                        width("50%");

```

--------------------------------

### Add Start Button to Start Screen

Source: https://wiki.jmonkeyengine.org/docs/3.8/core/gui/nifty_gui_java_layout.html

Adds a 'Start' button to the bottom panel of the 'start' screen. The button is centered within its panel.

```Java
panel(new PanelBuilder("panel_bottom_left") {{ 
    childLayoutCenter();
    valignCenter();
    backgroundColor("#44f8");
    height("50%");
    width("50%");

    // add control
    control(new ButtonBuilder("StartButton", "Start") {{ 
        alignCenter();
        valignCenter();
        height("50%");
        width("50%");
    }});
}});
```

--------------------------------

### Add Start and Quit Buttons

Source: https://wiki.jmonkeyengine.org/docs/3.8/core/gui/nifty_gui_xml_layout.html

Add Start and Quit buttons to the bottom panel of the 'start' screen using the <control> element.

```xml
<panel id="panel_bottom_left" height="50%" width="50%" valign="center" childLayout="center">
  <control name="button" label="Start" id="StartButton" align="center" valign="center">
  </control>
</panel>
<panel id="panel_bottom_right" height="50%" width="50%" valign="center" childLayout="center">
  <control name="button" label="Quit" id="QuitButton" align="center" valign="center">
  </control>
</panel>
```

--------------------------------

### Set Up Sample Project Directory Structure

Source: https://wiki.jmonkeyengine.org/docs/3.8/getting-started/simpleapplication_from_the_commandline.html

These commands establish the basic directory layout for your jMonkeyEngine 3 game project, including source and asset folders. The project directory should be on the same level as the main 'jme3' directory.

```bash
mkdir HelloJME3
mkdir HelloJME3/src
mkdir HelloJME3/src/mygame
```

--------------------------------

### Instantiating and Registering a Nifty GUI Screen Controller

Source: https://wiki.jmonkeyengine.org/docs/3.8/core/gui/nifty_gui_scenarios.html

This example demonstrates how to instantiate a custom ScreenController, attach it to the application's state manager, and load a Nifty GUI screen, referencing the controller.

```java
public class TestNiftyGui extends SimpleApplication {
  public void simpleInitApp() {
     StartScreenState startScreenState = new StartScreenState();
     stateManager.attach(startScreenState);
     // [...] boilerplate init nifty omitted
     nifty.fromXml("Interface/myGui.xml", "start", startScreenState); //one of the XML screen elements needs to reference StartScreenState controller class
  }
}
```

--------------------------------

### Screen Class Constructors

Source: https://wiki.jmonkeyengine.org/docs/3.8/contributions/gui/tonegodgui/screen.html

Demonstrates how to create a Screen instance, either with default settings or with a custom style theme.

```APIDOC
## Screen Class Constructors

### Description
Instantiates a new Screen object. The first constructor uses default settings, while the second allows specifying a path to a custom style theme XML file.

### Constructors
1. `Screen(JMEApplication this)`
2. `Screen(JMEApplication this, String styleThemePath)`

### Usage
```java
// Using default style
Screen screen = new Screen(this);
guiNode.addControl(screen);

// Using a custom style theme
Screen screen = new Screen(this, "tonegod/gui/style/def/style_map.xml");
guiNode.addControl(screen);
```
```

--------------------------------

### Install Server Database (Linux/MacOS)

Source: https://wiki.jmonkeyengine.org/docs/3.8/contributions/networking/open_game_finder.html

Installs or updates the Apache Derby database for the OGF server on Linux or MacOS systems.

```bash
java -jar lib/Server-0.1.jar install
java -jar lib/Server-0.1.jar update
```

--------------------------------

### Initializing Game Settings

Source: https://wiki.jmonkeyengine.org/docs/3.8/tutorials/beginner/hello_collision.html

Sets the background color, configures the fly camera for first-person use, and calls auxiliary methods for setting up keys and lights.

```java
viewPort.setBackgroundColor(new ColorRGBA(0.7f,0.8f,1f,1f));
flyCam.setMoveSpeed(100);
setUpKeys();
setUpLight();
```

--------------------------------

### JmeGeometry SceneExplorer Node Example

Source: https://wiki.jmonkeyengine.org/docs/3.8/sdk/development/sceneexplorer.html

An example implementation of a SceneExplorerNode for Geometry objects. It extends JmeSpatial and customizes the properties displayed in the SceneExplorer.

```java
@org.openide.util.lookup.ServiceProvider(service=SceneExplorerNode.class)
public class JmeGeometry extends JmeSpatial {

    private static Image smallImage =
            ImageUtilities.loadImage("com/jme3/gde/core/sceneexplorer/nodes/icons/geometry.gif");
    private Geometry geom;

    public JmeGeometry() {
    }

    public JmeGeometry(Geometry spatial, SceneExplorerChildren children) {
        super(spatial, children);
        getLookupContents().add(spatial);
        this.geom = spatial;
        setName(spatial.getName());
    }

    @Override
    public Image getIcon(int type) {
        return smallImage;
    }

    @Override
    public Image getOpenedIcon(int type) {
        return smallImage;
    }

    @Override
    protected Sheet createSheet() {
        Sheet sheet = super.createSheet();
        Sheet.Set set = Sheet.createPropertiesSet();
        set.setDisplayName("Geometry");
        set.setName(Geometry.class.getName());
        Geometry obj = geom;//getLookup().lookup(Geometry.class);
        if (obj == null) {
            return sheet;
        }

        set.put(makeProperty(obj, int.class, "getLodLevel", "setLodLevel", "Lod Level"));
        set.put(makeProperty(obj, Material.class, "getMaterial", "setMaterial", "Material"));
        set.put(makeProperty(obj, Mesh.class, "getMesh", "Mesh"));

        sheet.put(set);
        return sheet;

    }

    public Class getExplorerObjectClass() {
        return Geometry.class;
    }

    public Class getExplorerNodeClass() {
        return JmeGeometry.class;
    }

    public org.openide.nodes.Node[] createNodes(Object key, Object key2, boolean readOnly) {
        SceneExplorerChildren children=new SceneExplorerChildren((com.jme3.scene.Spatial)key);
        children.setReadOnly(readOnly);
        return new org.openide.nodes.Node[]{new JmeGeometry((Geometry) key, children).setReadOnly(readOnly)};
    }
}

```

--------------------------------

### Application Initialization with Audio Setup

Source: https://wiki.jmonkeyengine.org/docs/3.8/core/app/state/capture_audio_video_to_a_file.html

Initializes the JMonkeyEngine application, setting the timer, initializing audio components, creating the scene, and preparing multiple audio 'ears' for sound processing.

```Java
this.setTimer(new IsoTimer(60));
		initAudio();

		createScene();

		prepareEar(ear1, 1);
		prepareEar(ear2, 1);
		prepareEar(ear3, 1);

		motionControl.play();
```

--------------------------------

### Initialize Screen with Default Style

Source: https://wiki.jmonkeyengine.org/docs/3.8/contributions/gui/tonegodgui/screen.html

Creates a new Screen instance using the default style. This is the most basic way to set up the GUI screen.

```java
Screen screen = new Screen(this);
guiNode.addControl(screen);
```

--------------------------------

### Add Quit Button to Start Screen

Source: https://wiki.jmonkeyengine.org/docs/3.8/core/gui/nifty_gui_java_layout.html

Adds a 'Quit' button to the bottom panel of the 'start' screen. The button is centered within its panel.

```Java
panel(new PanelBuilder("panel_bottom_right") {{ 
    childLayoutCenter();
    valignCenter();
    backgroundColor("#88f8");
    height("50%");
    width("50%");

    // add control
    control(new ButtonBuilder("QuitButton", "Quit") {{ 
        alignCenter();
        valignCenter();
        height("50%");
        width("50%");
    }});
}});
```

--------------------------------

### Install Xcode Command Line Tools

Source: https://wiki.jmonkeyengine.org/docs/3.8/sdk/ios.html

Run this command in the terminal to install the necessary command line tools for Xcode if you encounter jni.h not found errors.

```bash
xcode-select --install
```

--------------------------------

### Example style_map.xml Configuration

Source: https://wiki.jmonkeyengine.org/docs/3.8/contributions/gui/tonegodgui/styles.html

A sample style_map.xml file demonstrating how to list various style definitions for different UI controls. Ensure the 'path' attributes correctly point to your custom style XML files.

```xml
<?xml version="1.0" encoding="UTF-8"?>
<root>
	<cursors path="somePath/Cursors.xml" />
	<audio path="somePath/Audio.xml" />
	<style control="Font" path="somePath/Fonts.xml" />
	<style control="Common" path="somePath/Common.xml" />
	<style control="Scrolling" path="somePath/Scrolling.xml" />
	<style control="Window" path="somePath/Window.xml" />
	<style control="Button" path="somePath/Button.xml" />
	<style control="Menu" path="somePath/Menu.xml" />
	<style control="Label" path="somePath/Label.xml" />
	<style control="Slider" path="somePath/Slider.xml" />
	<style control="TextField" path="somePath/TextField.xml" />
	<style control="ChatBox" path="somePath/ChatBox.xml" />
	<style control="Indicator" path="somePath/Indicator.xml" />
</root>
```

--------------------------------

### Create and Configure Material Instance in Java

Source: https://wiki.jmonkeyengine.org/docs/3.8/core/material/material_specification.html

Java code demonstrating how to programmatically create a material instance, load a texture with a flip flag, and set material parameters.

```java
// Create a material instance
Material mat = new Material(assetManager, "Common/MatDefs/Misc/
    TestMaterial.j3md");
// Load the texture. Specify "true" for the flip flag in the TextureKey
Texture tex =
assetManager.loadTexture(new TextureKey("Textures/GrassTex.jpg", true));
// Set the parameters
mat.setTexture("MyTex", tex);
mat.setFloat("Shininess", 20.0f);
```

--------------------------------

### Run OGF Server (Linux/MacOS)

Source: https://wiki.jmonkeyengine.org/docs/3.8/contributions/networking/open_game_finder.html

Starts the Open Game Finder server on Linux or MacOS systems.

```bash
java -jar lib/Server-1.0.jar
```
Tokens:
Raw