jme3与nifty gui1.3结合，修改使其支持中文的输入与显示

1、nifty gui1.3中修改代码，使其支持中文的输入：

com.jme3.input.awt.AwtKeyInput类，添加toAWTCode(int key)方法，将jme3中的keyCode转换成awt中的keyCode：

public static int toAWTCode(int key) {
switch (key) {
case KEY_ESCAPE:
return KeyEvent.VK_ESCAPE;
case KEY_1:
return KeyEvent.VK_1;
case KEY_2:
return KeyEvent.VK_2;
case KEY_3:
return KeyEvent.VK_3;
case KEY_4:
return KeyEvent.VK_4;
case KEY_5:
return KeyEvent.VK_5;
case KEY_6:
return KeyEvent.VK_6;
case KEY_7:
return KeyEvent.VK_7;
case KEY_8:
return KeyEvent.VK_8;
case KEY_9:
return KeyEvent.VK_9;
case KEY_0:
return KeyEvent.VK_0;
case KEY_MINUS:
return KeyEvent.VK_MINUS;
case KEY_EQUALS:
return KeyEvent.VK_EQUALS;
case KEY_BACK:
return KeyEvent.VK_BACK_SPACE;
case KEY_TAB:
return KeyEvent.VK_TAB;
case KEY_Q:
return KeyEvent.VK_Q;
case KEY_W:
return KeyEvent.VK_W;
case KEY_E:
return KeyEvent.VK_E;
case KEY_R:
return KeyEvent.VK_R;
case KEY_T:
return KeyEvent.VK_T;
case KEY_Y:
return KeyEvent.VK_Y;
case KEY_U:
return KeyEvent.VK_U;
case KEY_I:
return KeyEvent.VK_I;
case KEY_O:
return KeyEvent.VK_O;
case KEY_P:
return KeyEvent.VK_P;
case KEY_LBRACKET:
return KeyEvent.VK_OPEN_BRACKET;
case KEY_RBRACKET:
return KeyEvent.VK_CLOSE_BRACKET;
case KEY_RETURN:
return KeyEvent.VK_ENTER;
case KEY_LCONTROL:
return KeyEvent.VK_CONTROL;
case KEY_A:
return KeyEvent.VK_A;
case KEY_S:
return KeyEvent.VK_S;
case KEY_D:
return KeyEvent.VK_D;
case KEY_F:
return KeyEvent.VK_F;
case KEY_G:
return KeyEvent.VK_G;
case KEY_H:
return KeyEvent.VK_H;
case KEY_J:
return KeyEvent.VK_J;
case KEY_K:
return KeyEvent.VK_K;
case KEY_L:
return KeyEvent.VK_L;
case KEY_SEMICOLON:
return KeyEvent.VK_SEMICOLON;
case KEY_APOSTROPHE:
return KeyEvent.VK_QUOTE;
case KEY_GRAVE:
return KeyEvent.VK_DEAD_GRAVE;
case KEY_LSHIFT:
return KeyEvent.VK_SHIFT;
case KEY_BACKSLASH:
return KeyEvent.VK_BACK_SLASH;
case KEY_Z:
return KeyEvent.VK_Z;
case KEY_X:
return KeyEvent.VK_X;
case KEY_C:
return KeyEvent.VK_C;
case KEY_V:
return KeyEvent.VK_V;
case KEY_B:
return KeyEvent.VK_B;
case KEY_N:
return KeyEvent.VK_N;
case KEY_M:
return KeyEvent.VK_M;
case KEY_COMMA:
return KeyEvent.VK_COMMA;
case KEY_PERIOD:
return KeyEvent.VK_PERIOD;
case KEY_SLASH:
return KeyEvent.VK_SLASH;
case KEY_RSHIFT:
return KeyEvent.VK_SHIFT;
case KEY_MULTIPLY:
return KeyEvent.VK_MULTIPLY;
case KEY_SPACE:
return KeyEvent.VK_SPACE;
case KEY_CAPITAL:
return KeyEvent.VK_CAPS_LOCK;
case KEY_F1:
return KeyEvent.VK_F1;
case KEY_F2:
return KeyEvent.VK_F2;
case KEY_F3:
return KeyEvent.VK_F3;
case KEY_F4:
return KeyEvent.VK_F4;
case KEY_F5:
return KeyEvent.VK_F5;
case KEY_F6:
return KeyEvent.VK_F6;
case KEY_F7:
return KeyEvent.VK_F7;
case KEY_F8:
return KeyEvent.VK_F8;
case KEY_F9:
return KeyEvent.VK_F9;
case KEY_F10:
return KeyEvent.VK_F10;
case KEY_NUMLOCK:
return KeyEvent.VK_NUM_LOCK;
case KEY_SCROLL:
return KeyEvent.VK_SCROLL_LOCK;
case KEY_NUMPAD7:
return KeyEvent.VK_NUMPAD7;
case KEY_NUMPAD8:
return KeyEvent.VK_NUMPAD8;
case KEY_NUMPAD9:
return KeyEvent.VK_NUMPAD9;
case KEY_SUBTRACT:
return KeyEvent.VK_SUBTRACT;
case KEY_NUMPAD4:
return KeyEvent.VK_NUMPAD4;
case KEY_NUMPAD5:
return KeyEvent.VK_NUMPAD5;
case KEY_NUMPAD6:
return KeyEvent.VK_NUMPAD6;
case KEY_ADD:
return KeyEvent.VK_ADD;
case KEY_NUMPAD1:
return KeyEvent.VK_NUMPAD1;
case KEY_NUMPAD2:
return KeyEvent.VK_NUMPAD2;
case KEY_NUMPAD3:
return KeyEvent.VK_NUMPAD3;
case KEY_NUMPAD0:
return KeyEvent.VK_NUMPAD0;
case KEY_DECIMAL:
return KeyEvent.VK_DECIMAL;
case KEY_F11:
return KeyEvent.VK_F11;
case KEY_F12:
return KeyEvent.VK_F12;
case KEY_F13:
return KeyEvent.VK_F13;
case KEY_F14:
return KeyEvent.VK_F14;
case KEY_F15:
return KeyEvent.VK_F15;
case KEY_KANA:
return KeyEvent.VK_KANA;
case KEY_CONVERT:
return KeyEvent.VK_CONVERT;
case KEY_NOCONVERT:
return KeyEvent.VK_NONCONVERT;
case KEY_NUMPADEQUALS:
return KeyEvent.VK_EQUALS;
case KEY_CIRCUMFLEX:
return KeyEvent.VK_CIRCUMFLEX;
case KEY_AT:
return KeyEvent.VK_AT;
case KEY_COLON:
return KeyEvent.VK_COLON;
case KEY_UNDERLINE:
return KeyEvent.VK_UNDERSCORE;
case KEY_STOP:
return KeyEvent.VK_STOP;
case KEY_NUMPADENTER:
return KeyEvent.VK_ENTER;
case KEY_RCONTROL:
return KeyEvent.VK_CONTROL;
case KEY_NUMPADCOMMA:
return KeyEvent.VK_COMMA;
case KEY_DIVIDE:
return KeyEvent.VK_DIVIDE;
case KEY_PAUSE:
return KeyEvent.VK_PAUSE;
case KEY_HOME:
return KeyEvent.VK_HOME;
case KEY_UP:
return KeyEvent.VK_UP;
case KEY_PRIOR:
return KeyEvent.VK_PAGE_UP;
case KEY_LEFT:
return KeyEvent.VK_LEFT;
case KEY_RIGHT:
return KeyEvent.VK_RIGHT;
case KEY_END:
return KeyEvent.VK_END;
case KEY_DOWN:
return KeyEvent.VK_DOWN;
case KEY_NEXT:
return KeyEvent.VK_PAGE_DOWN;
case KEY_INSERT:
return KeyEvent.VK_INSERT;
case KEY_DELETE:
return KeyEvent.VK_DELETE;
case KEY_LMENU:
return KeyEvent.VK_ALT; //todo: location left
case KEY_RMENU:
return KeyEvent.VK_ALT; //todo: location right
}
logger.warning("unsupported key:" + key);
return 0x10000 + key;
}

修改com.jme3.input.lwjgl.LwjglKeyInput中的update方法，使其能处理接收到的中文字符：

package com.jme3.input.lwjgl;

import com.jme3.input.KeyInput;
import com.jme3.input.event.KeyInputEvent;
import com.jme3.input.RawInputListener;
import com.jme3.system.lwjgl.LwjglAbstractDisplay;
import com.jme3.system.lwjgl.LwjglTimer;
import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.SwingUtilities;
import org.lwjgl.LWJGLException;
import org.lwjgl.Sys;
import org.lwjgl.input.Keyboard;

public class LwjglKeyInput implements KeyInput {

private static final Logger logger = Logger.getLogger(LwjglKeyInput.class.getName());

private LwjglAbstractDisplay context;

private RawInputListener listener;

public LwjglKeyInput(LwjglAbstractDisplay context) {
this.context = context;
}

public void initialize() {
if (!context.isRenderable())
return;

try {
Keyboard.create();
Keyboard.enableRepeatEvents(true);
logger.info("Keyboard created.");
} catch (LWJGLException ex) {
logger.log(Level.SEVERE, "Error while creating keyboard.", ex);
}
}

public int getKeyCount() {
return Keyboard.KEYBOARD_SIZE;
}

char chcode = 0;

public void update() {
if (!context.isRenderable())
return;

Keyboard.poll();
while (Keyboard.next()) {
//不支持中文的
// int keyCode = Keyboard.getEventKey();
// char keyChar = Keyboard.getEventCharacter();
// System.out.println("keyCode=========" + keyCode);
// System.out.println("character==========" + keyChar);
// boolean pressed = Keyboard.getEventKeyState();
// boolean down = Keyboard.isRepeatEvent();
// long time = Keyboard.getEventNanoseconds();
// KeyInputEvent evt = new KeyInputEvent(keyCode, keyChar, pressed, down);
// evt.setTime(time);
// listener.onKeyEvent(evt);

//注意：以后如果有部分特殊按键输入出问题的话，最有可能出问题的地方时keyCode的重新计算

//若接受到的是中文
char character = Keyboard.getEventCharacter();
if (chcode == 0) {
chcode = character;
if (character > 127) {
return;
}
} else {
chcode = (char) (character + (chcode << 8));
}

try {
SwingUtilities.invokeAndWait(new Runnable() {
public void run() {
long time = Keyboard.getEventNanoseconds();
if (Keyboard.getEventKeyState()) // if pressed
{
sendEvent(time, Keyboard.getEventKey(), chcode, true);
} else {
sendEvent(time, Keyboard.getEventKey(), chcode, false);
}
chcode = 0;
}
});
} catch (InterruptedException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
}

private Map<Int, Char> characters = new HashMap<Int, Char>();
private static Int anInt = new Int(0);

private void handEvent(long time, int keyCode, char character, boolean pressed) {
KeyInputEvent evt = new KeyInputEvent(keyCode, character, pressed, Keyboard.isRepeatEvent());
evt.setTime(time);
listener.onKeyEvent(evt);
}

private void sendEvent(long time, int keyCode2, char character, boolean pressed) {
int keyCode = com.jme3.input.awt.AwtKeyInput.toAWTCode(keyCode2);
try {
if (keyCode != 0) {
// if (character == '\0') {
// character = KeyEvent.CHAR_UNDEFINED;
// }
if (pressed) {
// if (character != KeyEvent.CHAR_UNDEFINED) {
if (character <= 255) {
//英文和特殊字符，即之前不支持中文时的字符
handEvent(time, keyCode2, character, pressed);
}

anInt.value = keyCode;
Char c = characters.get(anInt);
if (c == null) {
characters.put(new Int(keyCode), new Char(character));
} else {
c.value = character;
}
}
if (!pressed) {
anInt.value = keyCode;
if (character > 255 && character < 65535) {
char s = new String(new byte[]{(byte) (character / 256), (byte) (character % 256)}, "gbk").toCharArray()[0];
//中文
handEvent(time, keyCode, s, true);
handEvent(time, keyCode, s, false);

} else {
//英文和特殊字符，即之前不支持中文时的字符
handEvent(time, keyCode2, character, false);
}
}
}
} catch (Exception e) {
// logger.info("");
}
}

private static class Int {
public Int(int value) {
this.value = value;
}

public boolean equals(Object obj) {
return obj instanceof Int && ((Int) obj).value == value;
}

public int hashCode() {
return value;
}

int value;
}

private static class Char {
public Char(char value) {
this.value = value;
}

char value;
}

public void destroy() {
if (!context.isRenderable())
return;

Keyboard.destroy();
logger.info("Keyboard destroyed.");
}

public boolean isInitialized() {
return Keyboard.isCreated();
}

public void setInputListener(RawInputListener listener) {
this.listener = listener;
}

public long getInputTimeNanos() {
return Sys.getTime() * LwjglTimer.LWJGL_TIME_TO_NANOS;
}
}

2、上面只是能接收到中文了，但是仍还不能显示中文在界面上，下面将渲染包含中文字符在界面上。

在com.jme3.niftygui包中添加类RenderFontAWT：

package com.jme3.niftygui;

import de.lessvoid.nifty.spi.render.RenderFont;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.image.BufferedImage;

public class RenderFontAWT implements RenderFont {

private FontMetrics fontMetrics;

public RenderFontAWT() {
BufferedImage image = new BufferedImage(1, 1, BufferedImage.TYPE_INT_ARGB_PRE);
Font awtFont = new Font("黑体", java.awt.Font.PLAIN, 12);
fontMetrics = image.createGraphics().getFontMetrics(awtFont);
}

@Override
public int getWidth(String text) {
if (text.length() == 0) {
return 0;
}
return fontMetrics.stringWidth(text);
}

@Override
public int getHeight() {
return (fontMetrics.getMaxAscent() + fontMetrics.getMaxDescent());
}

@Override
public Integer getCharacterAdvance(char currentCharacter, char nextCharacter, float size) {
return null;
}

@Override
public void dispose() {
//To change body of implemented methods use File | Settings | File Templates.
}
}

在com.jme3.niftygui包中添加类RenderDeviceAWT：

package com.jme3.niftygui;

import com.jme3.material.Material;
import com.jme3.material.RenderState;
import com.jme3.math.ColorRGBA;
import com.jme3.math.Matrix4f;
import com.jme3.renderer.RenderManager;
import com.jme3.renderer.Renderer;
import com.jme3.scene.Geometry;
import com.jme3.scene.Mesh;
import com.jme3.scene.VertexBuffer;
import com.jme3.scene.VertexBuffer.Format;
import com.jme3.scene.VertexBuffer.Type;
import com.jme3.scene.VertexBuffer.Usage;
import com.jme3.scene.shape.Quad;
import com.jme3.texture.Texture;
import com.jme3.texture.Texture2D;
import com.jme3.util.BufferUtils;
import de.lessvoid.nifty.render.BlendMode;
import de.lessvoid.nifty.spi.render.*;
import de.lessvoid.nifty.tools.Color;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.Transparency;
import java.awt.image.BufferedImage;
import java.awt.image.DataBuffer;
import java.awt.image.DataBufferByte;
import java.nio.ByteBuffer;
import java.nio.FloatBuffer;

public class RenderDeviceAWT implements RenderDevice {
private FontMetrics fontMetrics;
private Font awtFont = null;
private NiftyJmeDisplay display;
private RenderManager rm;
private Renderer r;

private final Quad quad = new Quad(1, -1, true);
private final Geometry quadGeom = new Geometry("nifty-quad", quad);
private final Material niftyMat;

private boolean clipWasSet = false;
private BlendMode blendMode = null;

private VertexBuffer quadDefaultTC = quad.getBuffer(Type.TexCoord);
private VertexBuffer quadModTC = quadDefaultTC.clone();
private VertexBuffer quadColor;

private Matrix4f tempMat = new Matrix4f();
private ColorRGBA tempColor = new ColorRGBA();

public RenderDeviceAWT(NiftyJmeDisplay display) {
this.display = display;
BufferedImage image = new BufferedImage(1, 1, BufferedImage.TYPE_INT_ARGB_PRE);
awtFont = new Font("黑体", java.awt.Font.PLAIN, 12);
fontMetrics = image.createGraphics().getFontMetrics(awtFont);
quadColor = new VertexBuffer(Type.Color);
quadColor.setNormalized(true);
ByteBuffer bb = BufferUtils.createByteBuffer(4 * 4);
quadColor.setupData(Usage.Stream, 4, Format.UnsignedByte, bb);
quad.setBuffer(quadColor);
quadModTC.setUsage(Usage.Stream);
niftyMat = new Material(display.getAssetManager(), "Common/MatDefs/Nifty/Nifty.j3md");
niftyMat.getAdditionalRenderState().setDepthTest(false);
}

public void setRenderManager(RenderManager rm) {
this.rm = rm;
this.r = rm.getRenderer();
}

// TODO: Cursor support
public MouseCursor createMouseCursor(String str, int x, int y){
return new MouseCursor() {
public void dispose() {
}
};
}

public void enableMouseCursor(MouseCursor cursor){
}

public void disableMouseCursor(){
}

public RenderImage createImage(String filename, boolean linear) {
return new RenderImageJme(filename, linear, display);
}

public RenderFont createFont(String filename) {
// return new RenderFontJme(filename, display);
return new RenderFontAWT();
}

public void beginFrame() {
}

public void endFrame() {
}

public int getWidth() {
return display.getWidth();
}

public int getHeight() {
return display.getHeight();
}

public void clear() {
}

public void setBlendMode(BlendMode blendMode) {
if (this.blendMode != blendMode) {
this.blendMode = blendMode;
}
}

private RenderState.BlendMode convertBlend(){
if (blendMode == null)
return RenderState.BlendMode.Off;
else if (blendMode == BlendMode.BLEND)
return RenderState.BlendMode.Alpha;
else if (blendMode == BlendMode.MULIPLY)
return RenderState.BlendMode.Modulate;
else
throw new UnsupportedOperationException();
}

private int convertColor(Color color){
int color2 = 0;
color2 |= ((int)(255.0 * color.getAlpha())) << 24;
color2 |= ((int)(255.0 * color.getBlue())) << 16;
color2 |= ((int)(255.0 * color.getGreen())) << 8;
color2 |= ((int)(255.0 * color.getRed()));
return color2;
}

private ColorRGBA convertColor(Color inColor, ColorRGBA outColor){
return outColor.set(inColor.getRed(), inColor.getGreen(), inColor.getBlue(), inColor.getAlpha());
}

private void setColor(Color color){
ByteBuffer buf = (ByteBuffer) quadColor.getData();
buf.rewind();

int color2 = convertColor(color);
buf.putInt(color2);
buf.putInt(color2);
buf.putInt(color2);
buf.putInt(color2);

buf.flip();
quadColor.updateData(buf);
}

public void renderFont(RenderFont font, String str, int x, int y, Color color, float size) {
//多行时还不知道有没有问题
if (str.length() == 0) {
return;
}
// if (font instanceof TextRenderer.RenderFontNull) {
// return;
// }
Texture texture = createTexture2D(str);

// WARNING: Not compatible with OpenGL1 implementations..
niftyMat.setColor("Color", convertColor(color, tempColor));

niftyMat.setBoolean("UseTex", true);
niftyMat.setTexture("Texture", texture);
// niftyMat.setInt("m_Mode", 3);
niftyMat.getAdditionalRenderState().setBlendMode(convertBlend());

float width = texture.getImage().getWidth();
float height = texture.getImage().getHeight();

Mesh text1 = new Quad(width, height);
Geometry text2 = new Geometry("text", text1);

float x0 = x + 0.5f * width * (1f - size);
float y0 = y + 0.5f * height * (1f - size) + height;

tempMat.loadIdentity();
tempMat.setTranslation(x0, getHeight() - y0, 0);
tempMat.setScale(size, size, 0);
rm.setWorldMatrix(tempMat);
niftyMat.render(text2, rm);
}

private Texture2D createTexture2D(String str) {
BufferedImage bi = new BufferedImage(fontMetrics.stringWidth(str), fontMetrics.getMaxAscent() + fontMetrics.getMaxDescent(),
BufferedImage.TYPE_INT_ARGB);
java.awt.Color renderColor = java.awt.Color.WHITE;
Graphics2D g = (Graphics2D) bi.getGraphics();
g.setColor(renderColor);
g.setBackground(java.awt.Color.WHITE);
g.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
g.setFont(awtFont);
g.drawString(str, 0, fontMetrics.getMaxAscent() - 1);
Texture2D texture2d = new Texture2D(load(bi, true));
texture2d.setMagFilter(Texture.MagFilter.Bilinear);
texture2d.setMinFilter(Texture.MinFilter.BilinearNoMipMaps);
return texture2d;
}

private com.jme3.texture.Image load(BufferedImage img, boolean flipY) {
int width = img.getWidth();
int height = img.getHeight();

switch (img.getType()) {
case BufferedImage.TYPE_3BYTE_BGR: // most common in JPEG images
byte[] dataBuf = extractImageData(img);
if (flipY) {
flipImage(dataBuf, width, height, 24);
}
ByteBuffer data = BufferUtils.createByteBuffer(img.getWidth() * img.getHeight() * 3);
data.put(dataBuf);
return new com.jme3.texture.Image(com.jme3.texture.Image.Format.BGR8, width, height, data);
case BufferedImage.TYPE_BYTE_GRAY: // grayscale fonts
byte[] dataBuf2 = extractImageData(img);
if (flipY) {
flipImage(dataBuf2, width, height, 8);
}
ByteBuffer data2 = BufferUtils.createByteBuffer(img.getWidth() * img.getHeight());
data2.put(dataBuf2);
return new com.jme3.texture.Image(com.jme3.texture.Image.Format.Luminance8, width, height, data2);
default:
break;
}

if (img.getTransparency() == Transparency.OPAQUE) {
ByteBuffer data = BufferUtils.createByteBuffer(img.getWidth() * img.getHeight() * 3);
// no alpha
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
int ny = y;
if (flipY) {
ny = height - y - 1;
}

int rgb = img.getRGB(x, ny);
byte r = (byte) ((rgb & 0x00FF0000) >> 16);
byte g = (byte) ((rgb & 0x0000FF00) >> 8);
byte b = (byte) ((rgb & 0x000000FF));
data.put(r).put(g).put(b);
}
}
data.flip();
return new com.jme3.texture.Image(com.jme3.texture.Image.Format.RGB8, width, height, data);
} else {
ByteBuffer data = BufferUtils.createByteBuffer(img.getWidth() * img.getHeight() * 4);
// no alpha
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
int ny = y;
if (flipY) {
ny = height - y - 1;
}

int rgb = img.getRGB(x, ny);
byte a = (byte) ((rgb & 0xFF000000) >> 24);
byte r = (byte) ((rgb & 0x00FF0000) >> 16);
byte g = (byte) ((rgb & 0x0000FF00) >> 8);
byte b = (byte) ((rgb & 0x000000FF));
data.put(r).put(g).put(b).put(a);
}
}
data.flip();
return new com.jme3.texture.Image(com.jme3.texture.Image.Format.RGBA8, width, height, data);
}
}

private byte[] extractImageData(BufferedImage img) {
DataBuffer buf = img.getRaster().getDataBuffer();
switch (buf.getDataType()) {
case DataBuffer.TYPE_BYTE:
DataBufferByte byteBuf = (DataBufferByte) buf;
return byteBuf.getData();
}
return null;
}

private void flipImage(byte[] img, int width, int height, int bpp) {
int scSz = (width * bpp) / 8;
byte[] sln = new byte[scSz];
int y2;
for (int y1 = 0; y1 < height / 2; y1++) {
y2 = height - y1 - 1;
System.arraycopy(img, y1 * scSz, sln, 0, scSz);
System.arraycopy(img, y2 * scSz, img, y1 * scSz, scSz);
System.arraycopy(sln, 0, img, y2 * scSz, scSz);
}
}

public void renderImage(RenderImage image, int x, int y, int w, int h,
int srcX, int srcY, int srcW, int srcH,
Color color, float scale,
int centerX, int centerY) {

RenderImageJme jmeImage = (RenderImageJme) image;
Texture2D texture = jmeImage.getTexture();

niftyMat.getAdditionalRenderState().setBlendMode(convertBlend());
niftyMat.setColor("Color", ColorRGBA.White);
niftyMat.setTexture("Texture", texture);
niftyMat.setBoolean("UseTex", true);
setColor(color);

float imageWidth = texture.getImage().getWidth();
float imageHeight = texture.getImage().getHeight();
FloatBuffer texCoords = (FloatBuffer) quadModTC.getData();

float startX = srcX / imageWidth;
float startY = srcY / imageHeight;
float endX = startX + (srcW / imageWidth);
float endY = startY + (srcH / imageHeight);

startY = 1f - startY;
endY = 1f - endY;

texCoords.rewind();
texCoords.put(startX).put(startY);
texCoords.put(endX).put(startY);
texCoords.put(endX).put(endY);
texCoords.put(startX).put(endY);
texCoords.flip();
quadModTC.updateData(texCoords);

quad.clearBuffer(VertexBuffer.Type.TexCoord);
quad.setBuffer(quadModTC);

float x0 = centerX + (x - centerX) * scale;
float y0 = centerY + (y - centerY) * scale;

tempMat.loadIdentity();
tempMat.setTranslation(x0, getHeight() - y0, 0);
tempMat.setScale(w * scale, h * scale, 0);

rm.setWorldMatrix(tempMat);
niftyMat.render(quadGeom, rm);
}

public void renderImage(RenderImage image, int x, int y, int width, int height,
Color color, float imageScale) {

RenderImageJme jmeImage = (RenderImageJme) image;

niftyMat.getAdditionalRenderState().setBlendMode(convertBlend());
niftyMat.setColor("Color", ColorRGBA.White);
niftyMat.setTexture("Texture", jmeImage.getTexture());
niftyMat.setBoolean("UseTex", true);
setColor(color);

quad.clearBuffer(VertexBuffer.Type.TexCoord);
quad.setBuffer(quadDefaultTC);

float x0 = x + 0.5f * width * (1f - imageScale);
float y0 = y + 0.5f * height * (1f - imageScale);

tempMat.loadIdentity();
tempMat.setTranslation(x0, getHeight() - y0, 0);
tempMat.setScale(width * imageScale, height * imageScale, 0);

rm.setWorldMatrix(tempMat);
niftyMat.render(quadGeom, rm);
}

public void renderQuad(int x, int y, int width, int height, Color color) {
niftyMat.getAdditionalRenderState().setBlendMode(convertBlend());
niftyMat.setColor("Color", ColorRGBA.White);
niftyMat.clearParam("Texture");
niftyMat.setBoolean("UseTex", false);
setColor(color);

tempMat.loadIdentity();
tempMat.setTranslation(x, getHeight() - y, 0);
tempMat.setScale(width, height, 0);

rm.setWorldMatrix(tempMat);
niftyMat.render(quadGeom, rm);
}

public void renderQuad(int x, int y, int width, int height,
Color topLeft, Color topRight, Color bottomRight, Color bottomLeft) {

VertexBuffer colors = quad.getBuffer(VertexBuffer.Type.Color);
ByteBuffer buf = (ByteBuffer) colors.getData();
buf.rewind();
buf.putInt(convertColor(bottomRight));
buf.putInt(convertColor(bottomLeft));
buf.putInt(convertColor(topLeft));
buf.putInt(convertColor(topRight));
buf.flip();
colors.updateData(buf);

niftyMat.getAdditionalRenderState().setBlendMode(convertBlend());
niftyMat.setColor("Color", ColorRGBA.White);
niftyMat.clearParam("Texture");
niftyMat.setBoolean("UseTex", false);

tempMat.loadIdentity();
tempMat.setTranslation(x, getHeight() - y, 0);
tempMat.setScale(width, height, 0);

rm.setWorldMatrix(tempMat);
niftyMat.render(quadGeom, rm);
}

public void enableClip(int x0, int y0, int x1, int y1) {
clipWasSet = true;
r.setClipRect(x0, getHeight() - y1, x1 - x0, y1 - y0);
}

public void disableClip() {
if (clipWasSet) {
r.clearClipRect();
clipWasSet = false;
}
}

}

修改com.jme3.niftygui.NiftyJmeDisplay类，将其中用到RenderDeviceJme的地方改成RenderDeviceAWT即可：

package com.jme3.niftygui;

import com.jme3.asset.AssetInfo;
import com.jme3.asset.AssetKey;
import com.jme3.asset.AssetManager;
import com.jme3.audio.AudioRenderer;
import com.jme3.input.InputManager;
import com.jme3.post.SceneProcessor;
import com.jme3.renderer.RenderManager;
import com.jme3.renderer.Renderer;
import com.jme3.renderer.ViewPort;
import com.jme3.renderer.queue.RenderQueue;
import com.jme3.texture.FrameBuffer;
import de.lessvoid.nifty.Nifty;
import de.lessvoid.nifty.spi.render.RenderDevice;
import de.lessvoid.nifty.tools.TimeProvider;
import de.lessvoid.nifty.tools.resourceloader.ResourceLoader;
import de.lessvoid.nifty.tools.resourceloader.ResourceLocation;
import java.io.InputStream;
import java.net.URL;

public class NiftyJmeDisplay implements SceneProcessor {

protected boolean inited = false;
protected Nifty nifty;
protected AssetManager assetManager;
protected RenderManager renderManager;
// protected RenderDeviceJme renderDev;
protected RenderDeviceAWT renderDev;
protected InputSystemJme inputSys;
protected SoundDeviceJme soundDev;
protected Renderer renderer;
protected ViewPort vp;

protected ResourceLocationJme resourceLocation;

protected int w, h;

protected class ResourceLocationJme implements ResourceLocation {

public InputStream getResourceAsStream(String path) {
AssetKey<Object> key = new AssetKey<Object>(path);
AssetInfo info = assetManager.locateAsset(key);
return info.openStream();
}

public URL getResource(String path) {
throw new UnsupportedOperationException();
}
}

//Empty constructor needed for jMP to create replacement input system
public NiftyJmeDisplay() {
}

public NiftyJmeDisplay(AssetManager assetManager,
InputManager inputManager,
AudioRenderer audioRenderer,
ViewPort vp){
this.assetManager = assetManager;

w = vp.getCamera().getWidth();
h = vp.getCamera().getHeight();

resourceLocation = new ResourceLocationJme();
ResourceLoader.removeAllResourceLocations();
ResourceLoader.addResourceLocation(resourceLocation);

soundDev = new SoundDeviceJme(assetManager, audioRenderer);
// renderDev = new RenderDeviceJme(this);
renderDev = new RenderDeviceAWT(this);
inputSys = new InputSystemJme(inputManager);
if (inputManager != null)
inputManager.addRawInputListener(inputSys);

nifty = new Nifty(renderDev, soundDev, inputSys, new TimeProvider());
inputSys.setNifty(nifty);
}

public void initialize(RenderManager rm, ViewPort vp) {
this.renderManager = rm;
renderDev.setRenderManager(rm);
inited = true;
this.vp = vp;
this.renderer = rm.getRenderer();

inputSys.setHeight(vp.getCamera().getHeight());
}

public Nifty getNifty() {
return nifty;
}

// RenderDeviceJme getRenderDevice() {
RenderDevice getRenderDevice() {
return renderDev;
}

AssetManager getAssetManager() {
return assetManager;
}

RenderManager getRenderManager() {
return renderManager;
}

int getHeight() {
return h;
}

int getWidth() {
return w;
}

Renderer getRenderer(){
return renderer;
}

public void reshape(ViewPort vp, int w, int h) {
this.w = w;
this.h = h;
inputSys.setHeight(h);
}

public boolean isInitialized() {
return inited;
}

public void preFrame(float tpf) {
}

public void postQueue(RenderQueue rq) {
// render nifty before anything else
renderManager.setCamera(vp.getCamera(), true);
//nifty.update();
nifty.render(false);
renderManager.setCamera(vp.getCamera(), false);
}

public void postFrame(FrameBuffer out) {
}

public void cleanup() {
inited = false;
// nifty.exit();
}

}