/*
* Copyright (c) 2009-2012 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of 'jMonkeyEngine' nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.jme3.niftygui;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.FloatBuffer;
import java.nio.ShortBuffer;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import com.jme3.asset.TextureKey;
import com.jme3.material.Material;
import com.jme3.material.RenderState;
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.Type;
import com.jme3.scene.VertexBuffer.Usage;
import com.jme3.texture.Image.Format;
import com.jme3.texture.Texture.MagFilter;
import com.jme3.texture.Texture.MinFilter;
import com.jme3.texture.Texture2D;
import com.jme3.texture.image.ColorSpace;
import com.jme3.util.BufferUtils;
import de.lessvoid.nifty.render.batch.spi.BatchRenderBackend;
import de.lessvoid.nifty.render.BlendMode;
import de.lessvoid.nifty.spi.render.MouseCursor;
import de.lessvoid.nifty.tools.Color;
import de.lessvoid.nifty.tools.Factory;
import de.lessvoid.nifty.tools.ObjectPool;
import de.lessvoid.nifty.tools.resourceloader.NiftyResourceLoader;
import java.util.HashMap;
import java.util.Map;
/**
* Nifty GUI BatchRenderBackend Implementation for jMonkeyEngine.
* @author void
*/
public class JmeBatchRenderBackend implements BatchRenderBackend {
private static Logger log = Logger.getLogger(JmeBatchRenderBackend.class.getName());
private final ObjectPool<Batch> batchPool;
private final List<Batch> batches = new ArrayList<Batch>();
// a modify texture call needs a jme Renderer to execute. if we're called to modify a texture but don't
// have a Renderer yet - since it was not initialized on the jme side - we'll cache the modify texture calls
// in here and execute them later (at the next beginFrame() call).
private final List<ModifyTexture> modifyTextureCalls = new ArrayList<ModifyTexture>();
private RenderManager renderManager;
private NiftyJmeDisplay display;
private Map<Integer, Texture2D> textures = new HashMap<Integer, Texture2D>();
private int textureAtlasId = 1;
private Batch currentBatch;
private Matrix4f tempMat = new Matrix4f();
private ByteBuffer initialData;
// this is only used for debugging purpose and will make the removed textures filled with a color
// please note: the old way to init this via a system property has been
// removed since it's now possible to configure it using the
// BatchRenderConfiguration class when you create the NiftyJmeDisplay instance
private boolean fillRemovedTexture = false;
public JmeBatchRenderBackend(final NiftyJmeDisplay display) {
this.display = display;
this.batchPool = new ObjectPool<Batch>(new Factory<Batch>() {
@Override
public Batch createNew() {
return new Batch();
}
});
}
public void setRenderManager(final RenderManager rm) {
this.renderManager = rm;
}
@Override
public void setResourceLoader(final NiftyResourceLoader resourceLoader) {
}
@Override
public int getWidth() {
return display.getWidth();
}
@Override
public int getHeight() {
return display.getHeight();
}
@Override
public void beginFrame() {
log.fine("beginFrame()");
for (int i=0; i<batches.size(); i++) {
batchPool.free(batches.get(i));
}
batches.clear();
// in case we have pending modifyTexture calls we'll need to execute them now
if (!modifyTextureCalls.isEmpty()) {
Renderer renderer = display.getRenderer();
for (int i=0; i<modifyTextureCalls.size(); i++) {
modifyTextureCalls.get(i).execute(renderer);
}
modifyTextureCalls.clear();
}
}
@Override
public void endFrame() {
log.fine("endFrame");
}
@Override
public void clear() {
}
// TODO: Cursor support
@Override
public MouseCursor createMouseCursor(final String filename, final int hotspotX, final int hotspotY) throws IOException {
return new MouseCursor() {
@Override
public void dispose() {
}
@Override
public void enable() {
}
@Override
public void disable() {
}
};
}
@Override
public void enableMouseCursor(final MouseCursor mouseCursor) {
}
@Override
public void disableMouseCursor() {
}
@Override
public int createTextureAtlas(final int width, final int height) {
try {
int atlasId = addTexture(createAtlasTextureInternal(width, height));
// we just initialize a second buffer here that will replace the texture atlas image
initialData = BufferUtils.createByteBuffer(width*height*4);
for (int i=0; i<width*height; i++) {
initialData.put((byte) 0x00);
initialData.put((byte) 0xff);
initialData.put((byte) 0x00);
initialData.put((byte) 0xff);
}
return atlasId;
} catch (Exception e) {
log.log(Level.WARNING, e.getMessage(), e);
return 0; // TODO Nifty always expects this call to be successfull
// there currently is no way to return failure or something :/
}
}
@Override
public void clearTextureAtlas(final int atlasId) {
initialData.rewind();
getTextureAtlas(atlasId).getImage().setData(initialData);
}
@Override
public Image loadImage(final String filename) {
TextureKey key = new TextureKey(filename, false);
key.setAnisotropy(0);
key.setGenerateMips(false);
Texture2D texture = (Texture2D) display.getAssetManager().loadTexture(key);
return new ImageImpl(texture.getImage());
}
@Override
public Image loadImage(final ByteBuffer imageData, final int imageWidth, final int imageHeight) {
return new ImageImpl(new com.jme3.texture.Image(Format.RGBA8, imageWidth, imageHeight, imageData));
}
@Override
public void addImageToAtlas(final Image image, final int x, final int y, final int atlasTextureId) {
ImageImpl imageImpl = (ImageImpl) image;
imageImpl.modifyTexture(this, getTextureAtlas(atlasTextureId), x, y);
}
@Override
public int createNonAtlasTexture(final Image image) {
ImageImpl imageImpl = (ImageImpl) image;
Texture2D texture = new Texture2D(imageImpl.image);
texture.setMinFilter(MinFilter.NearestNoMipMaps);
texture.setMagFilter(MagFilter.Nearest);
return addTexture(texture);
}
@Override
public void deleteNonAtlasTexture(final int textureId) {
textures.remove(textureId);
}
@Override
public boolean existsNonAtlasTexture(final int textureId) {
return textures.containsKey(textureId);
}
@Override
public void beginBatch(final BlendMode blendMode, final int textureId) {
batches.add(batchPool.allocate());
currentBatch = batches.get(batches.size() - 1);
currentBatch.begin(blendMode, getTextureAtlas(textureId));
}
@Override
public void addQuad(
final float x,
final float y,
final float width,
final float height,
final Color color1,
final Color color2,
final Color color3,
final Color color4,
final float textureX,
final float textureY,
final float textureWidth,
final float textureHeight,
final int textureId) {
if (!currentBatch.canAddQuad()) {
beginBatch(currentBatch.getBlendMode(), textureId);
}
currentBatch.addQuadInternal(x, y, width, height, color1, color2, color3, color4, textureX, textureY, textureWidth, textureHeight);
}
@Override
public int render() {
for (int i=0; i<batches.size(); i++) {
Batch batch = batches.get(i);
batch.render();
}
return batches.size();
}
@Override
public void removeImageFromAtlas(final Image image, final int x, final int y, final int w, final int h, final int atlasTextureId) {
// Since we clear the whole texture when we switch screens it's not really necessary to remove data from the
// texture atlas when individual textures are removed. If necessary this can be enabled with a system property.
if (!fillRemovedTexture) {
return;
}
ByteBuffer initialData = BufferUtils.createByteBuffer(image.getWidth()*image.getHeight()*4);
for (int i=0; i<image.getWidth()*image.getHeight(); i++) {
initialData.put((byte) 0xff);
initialData.put((byte) 0x00);
initialData.put((byte) 0x00);
initialData.put((byte) 0xff);
}
initialData.rewind();
modifyTexture(
getTextureAtlas(atlasTextureId),
new com.jme3.texture.Image(Format.RGBA8, image.getWidth(), image.getHeight(), initialData, ColorSpace.sRGB),
x,
y);
}
/**
* Whether or not to render textures with high quality settings. Usually, setting to true will result in slower
* performance, but nicer looking textures, and vice versa. How high quality textures are rendered versus low quality
* textures will vary depending on the {@link de.lessvoid.nifty.render.batch.spi.BatchRenderBackend} implementation.
*/
@Override
public void useHighQualityTextures(final boolean shouldUseHighQualityTextures) {
// TODO when true this should use something like linear filtering
// not sure right now how to tell jme about that ... might not be
// necessary to be set?
}
/**
* Whether or not to overwrite previously used atlas space with blank data. Setting to true will result in slower
* performance, but may be useful in debugging when visually inspecting the atlas, since there will not be portions
* of old images visible in currently unused atlas space.
*/
@Override
public void fillRemovedImagesInAtlas(final boolean shouldFill) {
fillRemovedTexture = shouldFill;
}
// internal implementations
private Texture2D createAtlasTextureInternal(final int width, final int height) throws Exception {
ByteBuffer initialData = BufferUtils.createByteBuffer(width*height*4);
for (int i=0; i<width*height*4; i++) {
initialData.put((byte) 0x00);
}
initialData.rewind();
Texture2D texture = new Texture2D(new com.jme3.texture.Image(Format.RGBA8, width, height, initialData, ColorSpace.sRGB));
texture.setMinFilter(MinFilter.NearestNoMipMaps);
texture.setMagFilter(MagFilter.Nearest);
return texture;
}
private void modifyTexture(
final Texture2D textureAtlas,
final com.jme3.texture.Image image,
final int x,
final int y) {
Renderer renderer = display.getRenderer();
if (renderer == null) {
// we have no renderer (yet) so we'll need to cache this call to the next beginFrame() call
modifyTextureCalls.add(new ModifyTexture(textureAtlas, image, x, y));
return;
}
// all is well, we can execute the modify right away
renderer.modifyTexture(textureAtlas, image, x, y);
}
private Texture2D getTextureAtlas(final int atlasId) {
return textures.get(atlasId);
}
private int addTexture(final Texture2D texture) {
final int atlasId = textureAtlasId++;
textures.put(atlasId, texture);
return atlasId;
}
/**
* Simple BatchRenderBackend.Image implementation that will transport the dimensions of an image as well as the
* actual bytes from the loadImage() to the addImageToTexture() method.
*
* @author void
*/
private static class ImageImpl implements BatchRenderBackend.Image {
private final com.jme3.texture.Image image;
public ImageImpl(final com.jme3.texture.Image image) {
this.image = image;
}
public void modifyTexture(
final JmeBatchRenderBackend backend,
final Texture2D textureAtlas,
final int x,
final int y) {
backend.modifyTexture(textureAtlas, image, x, y);
}
@Override
public int getWidth() {
return image.getWidth();
}
@Override
public int getHeight() {
return image.getHeight();
}
}
/**
* Used to delay ModifyTexture calls in case we don't have a JME3 Renderer yet.
* @author void
*/
private static class ModifyTexture {
private Texture2D atlas;
private com.jme3.texture.Image image;
private int x;
private int y;
private ModifyTexture(final Texture2D atlas, final com.jme3.texture.Image image, final int x, final int y) {
this.atlas = atlas;
this.image = image;
this.x = x;
this.y = y;
}
public void execute(final Renderer renderer) {
renderer.modifyTexture(atlas, image, x, y);
}
}
/**
* This class helps us to manage the batch data. We'll keep a bunch of instances of this class around that will be
* reused when needed. Each Batch instance provides room for a certain amount of vertices and we'll use a new Batch
* when we exceed this amount of data.
*
* @author void
*/
private class Batch {
// 4 vertices per quad and 8 vertex attributes for each vertex:
// - 2 x pos
// - 2 x texture
// - 4 x color
//
// stored into 3 different buffers: position, texture coords, vertex color
// and an additional buffer for indexes
//
// there is a fixed amount of primitives per batch. if we run out of vertices we'll start a new batch.
private final static int BATCH_MAX_QUADS = 2000;
private final static int BATCH_MAX_VERTICES = BATCH_MAX_QUADS * 4;
// individual buffers for all the vertex attributes
private final VertexBuffer vertexPos = new VertexBuffer(Type.Position);
private final VertexBuffer vertexTexCoord = new VertexBuffer(Type.TexCoord);
private final VertexBuffer vertexColor = new VertexBuffer(Type.Color);
private final VertexBuffer indexBuffer = new VertexBuffer(Type.Index);
private final Mesh mesh = new Mesh();
private final Geometry meshGeometry = new Geometry("nifty-quad", mesh);
private final RenderState renderState = new RenderState();
private FloatBuffer vertexPosBuffer;
private FloatBuffer vertexTexCoordBuffer;
private FloatBuffer vertexColorBuffer;
private ShortBuffer indexBufferBuffer;
// number of quads already added to this batch.
private int quadCount;
private short globalVertexIndex;
// current blend mode
private BlendMode blendMode = BlendMode.BLEND;
private Texture2D texture;
private Material material;
public Batch() {
// setup mesh
vertexPos.setupData(Usage.Stream, 2, VertexBuffer.Format.Float, BufferUtils.createFloatBuffer(BATCH_MAX_VERTICES * 2));
vertexPosBuffer = (FloatBuffer) vertexPos.getData();
mesh.setBuffer(vertexPos);
vertexTexCoord.setupData(Usage.Stream, 2, VertexBuffer.Format.Float, BufferUtils.createFloatBuffer(BATCH_MAX_VERTICES * 2));
vertexTexCoordBuffer = (FloatBuffer) vertexTexCoord.getData();
mesh.setBuffer(vertexTexCoord);
vertexColor.setupData(Usage.Stream, 4, VertexBuffer.Format.Float, BufferUtils.createFloatBuffer(BATCH_MAX_VERTICES * 4));
vertexColorBuffer = (FloatBuffer) vertexColor.getData();
mesh.setBuffer(vertexColor);
indexBuffer.setupData(Usage.Stream, 3, VertexBuffer.Format.UnsignedShort, BufferUtils.createShortBuffer(BATCH_MAX_QUADS * 2 * 3));
indexBufferBuffer = (ShortBuffer) indexBuffer.getData();
mesh.setBuffer(indexBuffer);
material = new Material(display.getAssetManager(), "Common/MatDefs/Misc/Unshaded.j3md");
material.setBoolean("VertexColor", true);
renderState.setDepthTest(false);
renderState.setDepthWrite(false);
}
public void begin(final BlendMode blendMode, final Texture2D texture) {
this.blendMode = blendMode;
this.texture = texture;
quadCount = 0;
globalVertexIndex = 0;
vertexPosBuffer.clear();
vertexTexCoordBuffer.clear();
vertexColorBuffer.clear();
indexBufferBuffer.clear();
}
public BlendMode getBlendMode() {
return blendMode;
}
public void render() {
renderState.setBlendMode(convertBlend(blendMode));
vertexPosBuffer.flip();
vertexPos.updateData(vertexPosBuffer);
vertexTexCoordBuffer.flip();
vertexTexCoord.updateData(vertexTexCoordBuffer);
vertexColorBuffer.flip();
vertexColor.updateData(vertexColorBuffer);
indexBufferBuffer.flip();
indexBuffer.updateData(indexBufferBuffer);
tempMat.loadIdentity();
renderManager.setWorldMatrix(tempMat);
renderManager.setForcedRenderState(renderState);
material.setTexture("ColorMap", texture);
mesh.updateCounts();
material.render(meshGeometry, renderManager);
renderManager.setForcedRenderState(null);
}
private RenderState.BlendMode convertBlend(final BlendMode blendMode) {
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();
}
}
public boolean canAddQuad() {
return (quadCount + 1) < BATCH_MAX_QUADS;
}
private void addQuadInternal(
final float x,
final float y,
final float width,
final float height,
final Color color1,
final Color color2,
final Color color3,
final Color color4,
final float textureX,
final float textureY,
final float textureWidth,
final float textureHeight) {
indexBufferBuffer.put((short)(globalVertexIndex + 0));
indexBufferBuffer.put((short)(globalVertexIndex + 3));
indexBufferBuffer.put((short)(globalVertexIndex + 2));
indexBufferBuffer.put((short)(globalVertexIndex + 0));
indexBufferBuffer.put((short)(globalVertexIndex + 2));
indexBufferBuffer.put((short)(globalVertexIndex + 1));
addVertex(x, y, textureX, textureY, color1);
addVertex(x + width, y, textureX + textureWidth, textureY, color2);
addVertex(x + width, y + height, textureX + textureWidth, textureY + textureHeight, color4);
addVertex(x, y + height, textureX, textureY + textureHeight, color3);
quadCount++;
globalVertexIndex += 4;
}
private void addVertex(final float x, final float y, final float tx, final float ty, final Color c) {
vertexPosBuffer.put(x);
vertexPosBuffer.put(getHeight() - y);
vertexTexCoordBuffer.put(tx);
vertexTexCoordBuffer.put(ty);
vertexColorBuffer.put(c.getRed());
vertexColorBuffer.put(c.getGreen());
vertexColorBuffer.put(c.getBlue());
vertexColorBuffer.put(c.getAlpha());
}
}
}