[Obsolete] Nifty GUI integration with JME2 SimpleGame + StandardGame example

[larynx]

Edit: 2010.04.15 this approach is obsolete as there is a JME2 renderer for nifty available

Please refer to thread: http://www.jmonkeyengine.com/forum/index.php?topic=13658.0

---

I have been using jme for about 3 month now and I want to thank you all for saving me from countless hours of trial and error.
So i thought i want to give back something to the forum.

About 2 weeks ago i came to the point where i had to think about a GUI.  
I looked at GBUI, FenGUI, TWL (l33tlabs) and Nifty-GUI.

The webstart demo of Nifty GUI 'blew me out of the water'  :P , so i started to try to integrate it into my jme2 project.
(wanted to have, this gui looks better than the whole rest of my game  XD)

I managed to get the nifty gui rendered above the jme scene and mouse and keyboard are mirrored from jme into the nifty framework. Note: works only with lwjgl as nifty is rendering direct to lwjgl.

First steps:
Install nifty 1.1 from source (http://nifty-gui.lessvoid.com/) as described in their wiki.
Get the demo de.lessvoid.nifty.examples.console running.
(all four svn links must be exported: nifty, default-controls, examples and style,
lots of eclipse fiddling with source, lib and native paths,
dont forget to point the lwjgl lib to your jme install)

If you can run the native nifty example from eclipse, the following code should work,
only one little change in the nifty tree is needed:
You should replace /nifty-examples/src/main/resources/background.png with a complete transparent one or
you will not see the monkey through it!

Updated 31.03.2010  to include the GL13.glActiveTexture(GL13.GL_TEXTURE0) call hinted by core-dump
and added a gamestate example:

Updated 13.04.2010 this code and thread is obsolete as there will be a Nifty Renderer for JME2 soon.

The simplegame test main:


package descented.tests;

import java.nio.IntBuffer;
import java.util.logging.Level;
import java.util.logging.Logger;

import org.lwjgl.BufferUtils;
import org.lwjgl.input.Mouse;
import org.lwjgl.opengl.GL11;

import com.jme.app.SimpleGame;
import com.jme.bounding.BoundingBox;
import com.jme.image.Texture;
import com.jme.input.InputSystem;
import com.jme.input.KeyInput;
import com.jme.input.MouseInput;
import com.jme.input.joystick.JoystickInput;
import com.jme.math.Vector3f;
import com.jme.scene.shape.Box;
import com.jme.scene.state.TextureState;
import com.jme.util.TextureManager;

import de.lessvoid.nifty.Nifty;
import de.lessvoid.nifty.lwjglslick.render.RenderDeviceLwjgl;
import de.lessvoid.nifty.lwjglslick.sound.SlickSoundDevice;
import de.lessvoid.nifty.sound.SoundSystem;
import de.lessvoid.nifty.tools.TimeProvider;

import descented.input.JmeNiftyInputSystem;

/**
 * <code>TestNiftyGUI</code> is an example implementation of Nifty-GUI 1.1 for JME2
 *
 * @author larynx.ckc@gmx.net
 */
public class TestNiftyGUI extends SimpleGame
{
    // the Nifty GUI object
    private Nifty nifty = null;

    // screen dimension for the nifty lwjgl rendering
    private int viewportWidth;
    private int viewportHeight;

    private static final Logger logger = Logger.getLogger(TestNiftyGUI.class.getName());
    
    /**
     * Main entry point for the nifty test,
     *
     * @param args
     */
    public static void main(String[] args)
    {
        try
        {
            JoystickInput.setProvider(InputSystem.INPUT_SYSTEM_LWJGL);
        }
        catch (Exception e)
        {
            logger.logp(Level.SEVERE, TestNiftyGUI.class.toString(), "main", "Exception", e);
        }
        TestNiftyGUI app = new TestNiftyGUI();
        app.setConfigShowMode(ConfigShowMode.AlwaysShow);
        app.start();
    }

    /**
     * builds the scene.
     *
     * @see com.jme.app.SimpleGame#initGame()
     */
    protected void simpleInitGame()
    {
        display.setTitle("Nifty GUI JME2 SimpleGame Test");
        
        // Allow mouse to leave the game window (very useful on debugging :)
        Mouse.setGrabbed(false);        
        // Set mouse cursor
      MouseInput.get().setHardwareCursor(TestNiftyGUI.class.getClassLoader().getResource("jmetest/data/cursor/cursor1.png"));
      
       
       // Create the monkey box
       Box floor = new Box("Floor", new Vector3f(), 100, 1, 100);
       floor.setModelBound(new BoundingBox());
       floor.updateModelBound();
       floor.getLocalTranslation().y = -20;
       TextureState ts = display.getRenderer().createTextureState();
       // The monkey texture
       Texture t0 = TextureManager.loadTexture(
          TestNiftyGUI.class.getClassLoader().getResource("jmetest/data/images/Monkey.jpg"),
           Texture.MinificationFilter.Trilinear,
           Texture.MagnificationFilter.Bilinear);
       t0.setWrap(Texture.WrapMode.Repeat);
       ts.setTexture(t0);
       floor.setRenderState(ts);
       floor.scaleTextureCoordinates(0, 5);
       rootNode.attachChild(floor);

       
       // Show debug grid
       //rootNode.attachChild(new AxisGrid().buildGeometry());      
           
            // Get the screen dimension for nifty
            viewportWidth = DisplaySystem.getDisplaySystem().getWidth();
            viewportHeight = DisplaySystem.getDisplaySystem().getHeight();
      
       // Create a jme <-> nifty input binding
       JmeNiftyInputSystem jmeNiftyinput = new JmeNiftyInputSystem();

       // Add jme mouse listener      
       MouseInput.get().addListener(jmeNiftyinput);
            
       // Add jme keyboard listener
       KeyInput.get().addListener(jmeNiftyinput);

       // Create a nifty
       nifty = new Nifty(new RenderDeviceLwjgl(),
                     new SoundSystem(new SlickSoundDevice()),
                     jmeNiftyinput,
                     new TimeProvider());
       // This starts the GUI - nearly everything is read from xml
       // location nifty-examples/src/main/resources/console/console.xml
       nifty.fromXml("console/console.xml", "start");
       
       // Bind the keyboard input to this new nifty
       jmeNiftyinput.bind(nifty);      
    }
      
    @Override
    protected void simpleUpdate()
    {       
    }

    /**
     * Black opengl render magic needed for nifty integration (lots of guessing in here)
     */
    @Override
    protected void simpleRender()
    {
       // Push JME attributes onto the stack
       GL11.glPushAttrib(GL11.GL_LIGHTING_BIT | GL11.GL_DEPTH_BUFFER_BIT | GL11.GL_ENABLE_BIT | GL11.GL_COLOR_BUFFER_BIT | GL11.GL_CURRENT_BIT | GL11.GL_TEXTURE_BIT | GL11.GL_TRANSFORM_BIT | GL11.GL_VIEWPORT_BIT);

        GL11.glMatrixMode(GL11.GL_PROJECTION);        
        // Put current projection matrix on the stack
        GL11.glPushMatrix();        
        GL11.glLoadIdentity();
        GL11.glOrtho(0, viewportWidth, viewportHeight, 0, -9999, 9999);

        GL11.glMatrixMode(GL11.GL_MODELVIEW);
        // Put current modelview matrix on the stack
        GL11.glPushMatrix();
        GL11.glLoadIdentity();

        // Prepare Rendermode - copied from nifty LwjglInitHelper        
        GL11.glDisable(GL11.GL_DEPTH_TEST);
        GL11.glEnable(GL11.GL_BLEND);
        GL11.glDisable(GL11.GL_CULL_FACE);

        GL11.glEnable(GL11.GL_ALPHA_TEST);
        GL11.glAlphaFunc(GL11.GL_NOTEQUAL, 0);

        GL11.glDisable(GL11.GL_LIGHTING);
        GL11.glDisable(GL11.GL_TEXTURE_2D);
        
        // Set back to first texture unit so GUI displays properly - from FenGUI example by Core-Dump
        // avoids a texture 'spill over' between JME and nifty
   GL13.glActiveTexture(GL13.GL_TEXTURE0);              
        
        //GL11.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
        //GL11.glClear(GL11.GL_COLOR_BUFFER_BIT);
   //GL11.glEnable(GL11.GL_TEXTURE_2D);
        //

---


        // render the GUI
       nifty.render(false);
              
       // check gl error at least once per frame
        int error = GL11.glGetError();
        if (error != GL11.GL_NO_ERROR)
        {
          String glerrmsg = GLU.gluErrorString(error);
          logger.warning("OpenGL Error: (" + error + ") " + glerrmsg);
        }
        
        // Get JME modelview and projection matrix from the stack
        GL11.glMatrixMode(GL11.GL_MODELVIEW);
        GL11.glPopMatrix();
        GL11.glMatrixMode(GL11.GL_PROJECTION);
        GL11.glPopMatrix();
        
        // Get JME attributes from the stack
        GL11.glPopAttrib();
    }
}


The Nifty - Jme input binding: (F11, F12 and PAUSE have been binded in here)


package descented.input;

import java.util.ArrayList;
import java.util.List;

import org.lwjgl.input.Keyboard;

import com.jme.input.MouseInputListener;
import com.jme.input.KeyInputListener;

import de.lessvoid.nifty.Nifty;
import de.lessvoid.nifty.input.mouse.MouseInputEvent;
import de.lessvoid.nifty.spi.input.InputSystem;

/**
 * Gets the mouse events from JME and dispatches them on request to a nifty class
 * Is used in the construction of a nifty menu object
 * @author larynx.ckc@gmx.net
 *
 */
public class JmeNiftyInputSystem implements /*Nifty*/InputSystem, /*JME*/MouseInputListener, /*JME*/KeyInputListener
{
  private boolean lastLeftMouseDown = false;

  // list of mouse events, gets filled by JME events and gets polled/resetted by Nifty GUI class
  private final List<MouseInputEvent> events = new ArrayList<MouseInputEvent>();

  // The nifty GUI which this input system is feeding keyboard into (mouse is polled from outside)
  private Nifty nifty = null;
  
  /**
   * Creates a new inputsystem to serve as binding between JME and Nifty mouse/keyboard
   * @param nifty
   */
  public JmeNiftyInputSystem()
  {
     this.nifty = null;
  }

  public void bind(Nifty nifty)
  {
     this.nifty = nifty;
  }

  /**
   * Returns a list of mouse events which have happened since the last poll from this function.
   * Event list gets emptied after this call.
   * Gets called from nifty
   */
  public List<MouseInputEvent> getMouseEvents()
  {
   // create a clone to return
    List<MouseInputEvent> resultList = new ArrayList<MouseInputEvent>(events);
    // clear master list
    events.clear();
    return resultList;
  }

  /**
   * JME keyboard input listener, F11/F12 enables debug console, PAUSE makes a screenshot
   * @param character
   * @param keyCode
   * @param pressed
   */
  public void onKey( char character, int keyCode, boolean pressed )
  {      
      nifty.keyEvent(keyCode, character, pressed);
            
      if (pressed && keyCode == Keyboard.KEY_PAUSE)
      {
         DisplaySystem.getDisplaySystem().getRenderer().takeScreenShot( "NiftyScreenShot" );
      }      
      if (pressed && keyCode == Keyboard.KEY_F12)
      {
         nifty.toggleElementsDebugConsole();
      }
      else if (pressed && keyCode == Keyboard.KEY_F11)
      {
         nifty.toggleEffectsDebugConsole();
      }
  }
  
 /**
  * JME MouseInputListener override onButton
  * gets called by JME after MouseInput.get().addListener(thisclass);
  */
@Override
public void onButton(int button, boolean pressed, int x, int y)
{
   lastLeftMouseDown = pressed;
    MouseInputEvent inputEvent = new MouseInputEvent(x, y, lastLeftMouseDown);
    events.add(inputEvent);   
}
/**
 * JME MouseInputListener override onMove
 * gets called by JME after MouseInput.get().addListener(thisclass);
 */
@Override
public void onMove(int xDelta, int yDelta, int newX, int newY)
{
    MouseInputEvent inputEvent = new MouseInputEvent(newX, newY, lastLeftMouseDown);
    events.add(inputEvent);
}
/**
 * JME MouseInputListener override onWheel
 * gets called by JME after MouseInput.get().addListener(thisclass);
 */
@Override
public void onWheel(int wheelDelta, int x, int y)
{
   // TODO: use also the wheel sometime
}

}


The Nifty Game state for a StandardGame (while im at it: thanks a lot to darkfrog for JGN and standardgame)
This gamestate should be added as the last one so the GUI is rendered above all other elements.


package descented.game.states;

import java.util.logging.Logger;

import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL13;
import org.lwjgl.util.glu.GLU;

import com.jme.input.KeyInput;
import com.jme.input.MouseInput;
import com.jme.system.DisplaySystem;
import com.jmex.game.state.BasicGameState;

import de.lessvoid.nifty.Nifty;
import de.lessvoid.nifty.lwjglslick.render.RenderDeviceLwjgl;
import de.lessvoid.nifty.lwjglslick.sound.SlickSoundDevice;
import de.lessvoid.nifty.sound.SoundSystem;
import de.lessvoid.nifty.tools.TimeProvider;

import descented.input.JmeNiftyInputSystem;

/**
 * <code>NiftyGameState</code> is an implementation of a gamestate using Nifty-GUI 1.1 for JME2
 *
 * @author larynx.ckc@gmx.net
 */
public class NiftyGameState extends BasicGameState
{   
    // the Nifty GUI object
    private Nifty nifty = null;

    // screen dimension for the nifty lwjgl rendering
    private int viewportWidth;
    private int viewportHeight;

    private static final Logger logger = Logger.getLogger(NiftyGameState.class.getName());
    
   public NiftyGameState ()
   {
      super("GUI");
               
       // Show debug grid
       //rootNode.attachChild(new AxisGrid().buildGeometry());                      
   }
   
   @Override
   public void update(float tpf)
   {
            if (nifty == null)
            {
           viewportWidth = DisplaySystem.getDisplaySystem().getWidth();
           viewportHeight = DisplaySystem.getDisplaySystem().getHeight();
           
      // Create a jme <-> nifty input binding
      JmeNiftyInputSystem jmeNiftyinput = new JmeNiftyInputSystem();
   
      // Add jme mouse listener      
      MouseInput.get().addListener(jmeNiftyinput);
               
      // Add jme keyboard listener
      KeyInput.get().addListener(jmeNiftyinput);
   
      // Create a nifty
      nifty = new Nifty(new RenderDeviceLwjgl(),
                        new SoundSystem(new SlickSoundDevice()),
                        jmeNiftyinput,
                        new TimeProvider());

      // Bind the keyboard input to this new nifty
      jmeNiftyinput.bind(nifty);
          
      // This starts the GUI - nearly everything is read from xml
      // location nifty-examples/src/main/resources/console/console.xml
      nifty.fromXml("console/console.xml", "start");   
            }
   }
   
   @Override
   public void cleanup()
   {
      if (nifty != null)
      {
         nifty.exit();
      }
   }

   @Override
   public void render(float tpf)
   {
      if (nifty != null)
      {               
          // Push JME attributes onto the stack
          GL11.glPushAttrib(GL11.GL_LIGHTING_BIT | GL11.GL_DEPTH_BUFFER_BIT | GL11.GL_ENABLE_BIT | GL11.GL_COLOR_BUFFER_BIT | GL11.GL_CURRENT_BIT | GL11.GL_TEXTURE_BIT | GL11.GL_TRANSFORM_BIT | GL11.GL_VIEWPORT_BIT);
   
           GL11.glMatrixMode(GL11.GL_PROJECTION);        
           // Put current projection matrix on the stack
           GL11.glPushMatrix();        
           GL11.glLoadIdentity();
           GL11.glOrtho(0, viewportWidth, viewportHeight, 0, -9999, 9999);
   
           GL11.glMatrixMode(GL11.GL_MODELVIEW);
           // Put current modelview matrix on the stack
           GL11.glPushMatrix();
           GL11.glLoadIdentity();
   
           // Prepare Rendermode - copied from nifty LwjglInitHelper        
           GL11.glDisable(GL11.GL_DEPTH_TEST);
           GL11.glEnable(GL11.GL_BLEND);
           GL11.glDisable(GL11.GL_CULL_FACE);
   
           GL11.glEnable(GL11.GL_ALPHA_TEST);
           GL11.glAlphaFunc(GL11.GL_NOTEQUAL, 0);
   
           GL11.glDisable(GL11.GL_LIGHTING);
           GL11.glDisable(GL11.GL_TEXTURE_2D);
           
           // Set back to first texture unit so GUI displays properly - from FenGUI example by Core-Dump
           // avoids a texture 'spill over' between JME and nifty
         GL13.glActiveTexture(GL13.GL_TEXTURE0);              
           
           //GL11.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
           //GL11.glClear(GL11.GL_COLOR_BUFFER_BIT);
         //GL11.glEnable(GL11.GL_TEXTURE_2D);
           //

---

   
   
           // render the GUI
          nifty.render(false);
          
          
          // check gl error at least once per frame
           int error = GL11.glGetError();
           if (error != GL11.GL_NO_ERROR)
           {
             String glerrmsg = GLU.gluErrorString(error);
             logger.warning("OpenGL Error: (" + error + ") " + glerrmsg);
           }
           
           // Get JME modelview and projection matrix from the stack
           GL11.glMatrixMode(GL11.GL_MODELVIEW);
           GL11.glPopMatrix();
           GL11.glMatrixMode(GL11.GL_PROJECTION);
           GL11.glPopMatrix();
           
           // Get JME attributes from the stack
           GL11.glPopAttrib();
      }
   }
}


[erlend_sh]

3 months and you haven’t asked for help once yet? I hope you haven’t made things difficult for yourself. A great first post though, welcome, and thanks a bunch!



I added this link to our wiki’s hud section. I’ll also make a /niftygui page, just like we have for GBUI and FengGUI. I only just found out about NiftyGUI so I’m sure you’ll have a couple additions; feel free to sign up for the wiki And once we’ve put this integration to the test there should definitely be a /niftygui:integration page made as well.

[larynx]

Thanks for your kind answer, there you can see how good the jme wiki and forum is 



I have found two issues today:

1. If screen resolution is < 1024x768 then the gui is not scaled correctly
   
2. The font of the Hello World button gets garbled when the cam is rotated (all other fonts seem ok)
   
   
   
   Im pretty sure number 2 has something to do with the backing up of the JME opengl attributes
   
   in the simpleRender function.

[normen]

This library looks very nice! No silly awt/swt bindings like FengGUI and still a completely professional appearance, I like it!

[InShadow]

Hmm, would be maybe cool to choose nifty for main GUI in JME3?

[normen]

InShadow said:

Hmm, would be maybe cool to choose nifty for main GUI in JME3?

I am still not sure about which options are best.
On the one hand I'd like to see a GUI system that is run by the JME3 system, using its tools an possibilities. This solution would also yield best portability of the GUI part (Android etc.).
On the other hand decoupling the GUI from the rest of the system like this allows "outsourcing" the creation of effects etc. needed by a GUI that would bloat the core jme3 engine. NiftyGUI is definitely some steps ahead of FegGUI in terms of compatibility and makes me indecisive again where I was looking more into the GBUI direction (jme-internal). The demos sure look hot.

[mjsimpson]

Thanks larynx for the contribution!

[larynx]

Im sorry to tell, but i think there are more ‘issues’ 



Today i have transfered the code to a gamestate, for use in my project which loads a quake3 level with lots of textures.



It seems i have a texture ‘spill over’ from jme into nifty:

(also lighting and/or cam rotation could have an influence)



The text at the center should read: Press F1 for best console evar

ImageBam



This are the credits from the nifty demo, instead of the NiN logo one of my quake textures is used:

ImageBam



The nifty main menu:

ImageBam



I will try and reproduce this in the SimpleGame example and also look at how FenGUI has been isolated.



If any OpenGL gurus reading, pls help and/or look into the simpleRender function which ‘should’ isolate jme from nifty

[Core_Dump]

The problem is in jme its not easy to use direct lwjgl calls, because texture id's and coordinates etc often are not correctly reset.

FengGUI suffers the same problem.



What you can try is render the nifty GUI in its own renderpass.

here: http://www.jmonkeyengine.com/wiki/doku.php/new_integrating_fenggui_with_jme  GL13.glActiveTexture(GL13.GL_TEXTURE0); is used to activate the first texture unit before drawing fenggui, maybe that helps in your case also.

[larynx]

Thanks a lot core-dump, the activate the first texture unit call made the texture spill over disappear. I did not need to render it

in its own renderpass. (but ill keep it in mind, one never knows what comes  )



Nifty now works for me in simplegame and in standardgame with it being the last gamestate.



I will edit my first post to show the updated example code for the gamestate as well as the updated simplegame, follows soon.

[larynx]

I have updated the first post code, thanks to core-dump now nifty gui is working for me:



Thats how it is and should look like:



Initial:

ImageBam



The console:

ImageBam



The main menu:

ImageBam



The credits:

ImageBam





From my point of view this is ready for acceptance 

(pls test it guys, nifty is really a wonderfull gui)

[Core_Dump]

nice work, the main menu looks pretty nice

[InShadow]

Is it possible with Nifty to dynamically change components sizes when player chooses different resolution in menu for example?

Because I am having problems, when a player changes resolution to smaller one, components get too big and vice versa…

[larynx]

Hello InShadow



The screen resolution is one of my 'need  to dive into' areas, because if it is < 1024x768 it starts to look not scaled correct.

(But that could be also in the xml gui settings and no jme<->nifty problem)



Im pretty sure this is resolvable, i just dont know how to currently. Today im happy that it runs at all, but im sure this will work out, too.



Pls try it your self, the more ppl use it the better.



(If you already tried and your changing the resolution on the fly, i could need an example to do so,

my users are only allowed to choose resolution at startup).

[InShadow]

Here is some code from the top of my head:


Quad q = new Quad("SomeQuad", 800, 600);

BlendState blendState = DisplaySystem.getDisplaySystem().getRenderer().createBlendState();
blendState.setBlendEnabled(true);
blendState.setSourceFunction(BlendState.SourceFunction.SourceAlpha);
blendState.setDestinationFunction(BlendState.DestinationFunction.OneMinusSourceAlpha);
blendState.setTestEnabled(true);
blendState.setTestFunction(BlendState.TestFunction.GreaterThan);
blendState.setEnabled(true);

Texture tex = TextureManager.loadTexture(imagePath, Texture.MinificationFilter.Trilinear, Texture.MagnificationFilter.Bilinear);
TextureState texState = DisplaySystem.getDisplaySystem().getRenderer().createTextureState();
texState.setTexture(tex);

ZBufferState zState = DisplaySystem.getDisplaySystem().getRenderer().createZBufferState();
zState.setEnabled(true);
zState.setFunction(ZBufferState.TestFunction.LessThanOrEqualTo);

q.setRenderState(blendState);
q.setRenderState(texState);
q.setRenderState(zState)
q.updateRenderState();
q.setRenderQueueMode(Renderer.QUEUE_ORTHO);


I am not really sure if ZBufferState is needed or would be better to just disable it. :)
Also, imagePath is an URL to the image and can be get with ResourceLocatorTool or with .class.getResource() or smth.
Also note, that this code is for JME2, I don't know yet how to do this in JME3. :)

Anyway, in my opinion it is very important for any real graphical engine to have a good GUI. Since jMonkeyEngine doesn't have it yet, it would be really cool if it could get one. :) Especially such, that could dynamically change its component sizes, based on some percent of the width and height of the parent, as you mentioned. I once tried to do my own GUI in JME, and found out, that the only way to properly rescale the components was to call some function of menu interface, which would basically build all the components and fonts of the menu from start, based on new resolution. I don't know if there is more simple way to do this (except for scaling the quads, which doesn't produce so nice results) :)

Oh, and btw, epic work with Nifty! :)
Thanks also to larynx, didn't even know about Nifty before that. :)

[void256]

Thanks for the code example. That doesn't look so hard I think I'll give it a try. This weekend is a long weekend with the easter holidays here in germany. Maybe I'll find some time to try this



The actual problem with the scaling are the bitmap based fonts. Brute force scaling of the fonts wouldn't look to good, I guess - although Nifty - as mentioned in the sf.net nifty forum thread - supports scaling them. It's just not connected to the screen resolution for automatic rescaling because it's currently only used for a textsize effect (the hover text scale effect in the tutorial/demo).



The best solution IMHO would probably be to somehow register different fonts (or other element attributes) for the different resolutions so that Nifty can automatically switch them when the screen resolution changes. Use font x for 640x480 and font y for 800x600 and so on. I still need to think about that tho

[larynx]

Hi void, great to see you here 



As far as i know your using eclipse - this is the wiki link to setup jme

http://www.jmonkeyengine.com/wiki/doku.php/setting_up_eclipse_to_build_jme_2



There is a test example of how to render text, ortho mode is turned on in BitmapText

/jme/src/jmetest/text/TestBitmapFont.java

[void256]

Hey larynx, great work with the Nifty/JME Example  and thanks for pointing me to the eclipse setup link!



Here is a quick update what has happend so far:

• I was able to check out and build jme without any problems and I've seen the TestBitmapFont example. Nice!
  
  
  
• I've just finished and commited the nifty rendering code extraction. This is a big one for Nifty and has been planned since a long time.
  
  
  
• There is now a separate project "nifty-lwjgl-slick-renderer" available. This is a "Nifty Renderer Implementation" based on LWJGL and SLICK2D (this was - up until now - a part of the main nifty jar). The main Nifty project is now free from any dependencies to those libs!
  
  
  
  This now completly opens up the way for a "JME Nifty Renderer" implementation. I'll look into this next. Stay tuned

[normen]

void256 said:

This now completly opens up the way for a "JME Nifty Renderer" implementation. I'll look into this next. Stay tuned :D

This is fantastic news, we'll keep our eyes on this :)

[erlend_sh]

+1 on that note! Great to see you come by the forum and get involved with the community man, appreciate it. This is looking up to be quite the go-to solution for jME GUI. Competitors better step up their game!