* Initial docs for com.jme3.scene.debug, com.jme3.scene.shape, com.jme3.scene.control

* Javadocs for com.jme3.scene.mesh * Formatting for com.jme3.terrain classes * Terrain updating thread now called "jME3 Terrain Thread" git-svn-id: https://jmonkeyengine.googlecode.com/svn/trunk@7667 75d07b2b-3a1a-0410-a2c5-0572b91ccdca
14 years ago · a6300ba55b
parent d62952a16e
commit a6300ba55b
25 changed files with 869 additions and 654 deletions
--- a/engine/src/core/com/jme3/scene/CameraNode.java
+++ b/engine/src/core/com/jme3/scene/CameraNode.java
@ -36,7 +36,8 @@ import com.jme3.scene.control.CameraControl;
 import com.jme3.scene.control.CameraControl.ControlDirection;

 /**
- * This Node is a shorthand for using a CameraControl.
+ * <code>CameraNode</code> simply uses {@link CameraControl} to implement
+ * linking of camera and node data.
 *
 * @author Tim8Dev
 */
@ -45,7 +46,7 @@ public class CameraNode extends Node {
    private CameraControl camControl;

    /**
-     * for IO purpose
+     * Serialization only. Do not use.
     */
    public CameraNode() {
    }
--- a/engine/src/core/com/jme3/scene/control/package.html
+++ b/engine/src/core/com/jme3/scene/control/package.html
@ -0,0 +1,17 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+
+<head>
+<title></title>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+</head>
+<body>
+
+The <code>com.jme3.control</code> package provides 
+{@link com.jme3.scene.control.Control controls}. 
+Controls represent the "logical" programming of scene graph elements, containing
+callbacks for when a {@link com.jme3.scene.Spatial} is rendered or updated
+by the engine.
+
+</body>
+</html>
--- a/engine/src/core/com/jme3/scene/debug/Arrow.java
+++ b/engine/src/core/com/jme3/scene/debug/Arrow.java
@ -37,9 +37,17 @@ import com.jme3.scene.Mesh;
 import com.jme3.scene.VertexBuffer.Type;
 import java.nio.FloatBuffer;

+/**
+ * The <code>Arrow</code> debug shape represents an arrow.
+ * An arrow is simply a line going from the original toward an extent
+ * and at the tip there will be triangle-like shape.
+ * 
+ * @author Kirill Vainer
+ */
 public class Arrow extends Mesh {
-    Quaternion tempQuat = new Quaternion();
-    Vector3f tempVec = new Vector3f();
+    
+    private Quaternion tempQuat = new Quaternion();
+    private Vector3f tempVec = new Vector3f();

    private static final float[] positions = new float[]{
        0, 0, 0,
@ -50,15 +58,25 @@ public class Arrow extends Mesh {
        0, -0.05f, 0.9f, // tip buttom
    };

+    /**
+     * Serialization only. Do not use.
+     */
    public Arrow() {
    }

+    /**
+     * Creates an arrow mesh with the given extent.
+     * The arrow will start at the origin (0,0,0) and finish
+     * at the given extent.
+     * 
+     * @param extent Extent of the arrow from origin
+     */
    public Arrow(Vector3f extent) {
        float len = extent.length();
        Vector3f dir = extent.normalize();

        tempQuat.lookAt(dir, Vector3f.UNIT_Y);
-        tempQuat.normalize();
+        tempQuat.normalizeLocal();

        float[] newPositions = new float[positions.length];
        for (int i = 0; i < positions.length; i += 3) {
@ -87,12 +105,18 @@ public class Arrow extends Mesh {
        updateCounts();
    }

+    /**
+     * Sets the arrow's extent.
+     * This will modify the buffers on the mesh.
+     * 
+     * @param extent the arrow's extent.
+     */
    public void setArrowExtent(Vector3f extent) {
        float len = extent.length();
 //        Vector3f dir = extent.normalize();

        tempQuat.lookAt(extent, Vector3f.UNIT_Y);
-        tempQuat.normalize();
+        tempQuat.normalizeLocal();

        FloatBuffer buffer = getFloatBuffer(Type.Position);
        buffer.rewind();
--- a/engine/src/core/com/jme3/scene/debug/Grid.java
+++ b/engine/src/core/com/jme3/scene/debug/Grid.java
@ -39,8 +39,19 @@ import com.jme3.util.BufferUtils;
 import java.nio.FloatBuffer;
 import java.nio.ShortBuffer;

+/**
+ * Simple grid shape.
+ * 
+ * @author Kirill Vainer
+ */
 public class Grid extends Mesh {

+    /**
+     * Creates a grid debug shape.
+     * @param xLines
+     * @param yLines
+     * @param lineDist 
+     */
    public Grid(int xLines, int yLines, float lineDist){
        xLines -= 2;
        yLines -= 2;
@ -90,4 +101,5 @@ public class Grid extends Mesh {
        updateBound();
        updateCounts();
    }
+    
 }
--- a/engine/src/core/com/jme3/scene/mesh/IndexBuffer.java
+++ b/engine/src/core/com/jme3/scene/mesh/IndexBuffer.java
@ -42,8 +42,35 @@ import java.nio.Buffer;
 * @author lex
 */
 public abstract class IndexBuffer {
+    /**
+     * Returns the vertex index for the given index in the index buffer.
+     * 
+     * @param i The index inside the index buffer
+     * @return 
+     */
    public abstract int get(int i);
+    
+    /**
+     * Puts the vertex index at the index buffer's index.
+     * Implementations may throw an {@link UnsupportedOperationException}
+     * if modifying the IndexBuffer is not supported (e.g. virtual index
+     * buffers).
+     */
    public abstract void put(int i, int value);
+    
+    /**
+     * Returns the size of the index buffer.
+     * 
+     * @return the size of the index buffer.
+     */
    public abstract int size();
+    
+    /**
+     * Returns the underlying data-type specific {@link Buffer}.
+     * Implementations may return null if there's no underlying
+     * buffer.
+     * 
+     * @return the underlying {@link Buffer}.
+     */
    public abstract Buffer getBuffer();
 }
--- a/engine/src/core/com/jme3/scene/mesh/IndexByteBuffer.java
+++ b/engine/src/core/com/jme3/scene/mesh/IndexByteBuffer.java
@ -36,7 +36,8 @@ import java.nio.Buffer;
 import java.nio.ByteBuffer;

 /**
- *
+ * IndexBuffer implementation for {@link ByteBuffer}s.
+ * 
 * @author lex
 */
 public class IndexByteBuffer extends IndexBuffer {
--- a/engine/src/core/com/jme3/scene/mesh/IndexIntBuffer.java
+++ b/engine/src/core/com/jme3/scene/mesh/IndexIntBuffer.java
@ -36,7 +36,8 @@ import java.nio.Buffer;
 import java.nio.IntBuffer;

 /**
- *
+ * IndexBuffer implementation for {@link IntBuffer}s.
+ * 
 * @author lex
 */
 public class IndexIntBuffer extends IndexBuffer {
--- a/engine/src/core/com/jme3/scene/mesh/IndexShortBuffer.java
+++ b/engine/src/core/com/jme3/scene/mesh/IndexShortBuffer.java
@ -36,7 +36,8 @@ import java.nio.Buffer;
 import java.nio.ShortBuffer;

 /**
- *
+ * IndexBuffer implementation for {@link ShortBuffer}s.
+ * 
 * @author lex
 */
 public class IndexShortBuffer extends IndexBuffer {
--- a/engine/src/core/com/jme3/scene/mesh/VirtualIndexBuffer.java
+++ b/engine/src/core/com/jme3/scene/mesh/VirtualIndexBuffer.java
@ -3,12 +3,28 @@ package com.jme3.scene.mesh;
 import com.jme3.scene.Mesh.Mode;
 import java.nio.Buffer;

+/**
+ * IndexBuffer implementation that generates vertex indices sequentially
+ * based on a specific Mesh {@link Mode}.
+ * The generated indices are as if the mesh is in the given mode
+ * but contains no index buffer, thus this implementation will
+ * return the indices if the index buffer was there and contained sequential
+ * triangles.
+ * Example:
+ * <ul>
+ * <li>{@link Mode#Triangles}: 0, 1, 2 | 3, 4, 5 | 6, 7, 8 | ...</li>
+ * <li>{@link Mode#TriangleStrip}: 0, 1, 2 | 2, 1, 3 | 2, 3, 4 | ...</li>
+ * <li>{@link Mode#TriangleFan}: 0, 1, 2 | 0, 2, 3 | 0, 3, 4 | ...</li>
+ * </ul>
+ * 
+ * @author Kirill Vainer
+ */
 public class VirtualIndexBuffer extends IndexBuffer {

    protected int numVerts = 0;
    protected int numIndices = 0;
    protected Mode meshMode;
-
+ 
    public VirtualIndexBuffer(int numVerts, Mode meshMode){
        this.numVerts = numVerts;
        this.meshMode = meshMode;
--- a/engine/src/core/com/jme3/scene/mesh/WrappedIndexBuffer.java
+++ b/engine/src/core/com/jme3/scene/mesh/WrappedIndexBuffer.java
@ -9,9 +9,12 @@ import java.nio.IntBuffer;
 import java.nio.ShortBuffer;

 /**
- * <code>WrappedIndexBuffer</code> converts from one representation of mesh
- * data to another. For example it can be used to read TriangleStrip data
- * as if it was in Triangle format.
+ * <code>WrappedIndexBuffer</code> converts vertex indices from a non list based
+ * mesh mode such as {@link Mode#TriangleStrip} or {@link Mode#LineLoop}
+ * into a list based mode such as {@link Mode#Triangles} or {@link Mode#Lines}.
+ * As it is often more convenient to read vertex data in list format
+ * than in a non-list format, using this class is recommended to avoid
+ * convoluting classes used to process mesh data from an external source.
 * 
 * @author Kirill Vainer
 */
--- a/engine/src/core/com/jme3/scene/mesh/package.html
+++ b/engine/src/core/com/jme3/scene/mesh/package.html
@ -0,0 +1,25 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+
+<head>
+<title></title>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+</head>
+<body>
+
+The <code>com.jme3.scene.mesh</code> package contains utilities
+for reading from {@link com.jme3.scene.mesh.IndexBuffer index buffers}.
+Several implementations are provided of the {@link com.jme3.scene.mesh.IndexBuffer}
+class:
+<ul>
+    <li>{@link com.jme3.scene.mesh.IndexByteBuffer} - For reading 8-bit index buffers</li>
+    <li>{@link com.jme3.scene.mesh.IndexShortBuffer} - For reading 16-bit index buffers</li>
+    <li>{@link com.jme3.scene.mesh.IndexIntBuffer} - For reading 32-bit index buffers</li>
+    <li>{@link com.jme3.scene.mesh.VirtualIndexBuffer} - For reading "virtual indices", for
+    those meshes that do not have an index buffer</li>
+    <li>{@link com.jme3.scene.mesh.WrappedIndexBuffer} - For converting from 
+    non-list based mode indices to list based</li>
+</ul>
+
+</body>
+</html>
--- a/engine/src/core/com/jme3/scene/package.html
+++ b/engine/src/core/com/jme3/scene/package.html
@ -0,0 +1,26 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+
+<head>
+<title></title>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+</head>
+<body>
+
+The <code>com.jme3.input</code> package contains the scene graph implementation
+in jMonkeyEngine.
+
+<p>
+    The scene graph is the most important package in jME, as it is the API
+    used to manage scene elements so that they can be rendered. 
+    The {@link com.jme3.scene.Spatial} class provides a common base class
+    for all scene graph elements. The {@link com.jme3.scene.Node} class provides
+    the "branches" in the graph, used to organize elements in a tree
+    hierarchy. The {@link com.jme3.scene.Geometry} is the leaf class that
+    will contain a {@link com.jme3.scene.Mesh} object (geometry data
+    such as vertex positions, normals, etc) and a {@link com.jme3.scene.Material}
+    object containing information on how the geometry should be shaded.
+</p>
+
+</body>
+</html>
--- a/engine/src/core/com/jme3/scene/shape/AbstractBox.java
+++ b/engine/src/core/com/jme3/scene/shape/AbstractBox.java
@ -48,7 +48,7 @@ import java.io.IOException;
 * a way as to generate an axis-aligned box.
 * <p>
 * This class does not control how the geometry data is generated, see {@link Box}
- * and {@link StripBox} for that.
+ * for that.
 *
 * @author <a href="mailto:ianp@ianp.org">Ian Phillips</a>
 * @version $Revision: 4131 $, $Date: 2009-03-19 16:15:28 -0400 (Thu, 19 Mar 2009) $
@ -87,7 +87,7 @@ public abstract class AbstractBox extends Mesh {
    }

    /**
-     * Convert the indices into the list of vertices that define the box's tri-mesh.
+     * Convert the indices into the list of vertices that define the box's geometry.
     */
    protected abstract void duUpdateGeometryIndices();
    
@ -111,22 +111,30 @@ public abstract class AbstractBox extends Mesh {
     */
    protected abstract void duUpdateGeometryVertices();

-    /** Get the centre point of this box. */
+    /** 
+     * Get the center point of this box. 
+     */
    public final Vector3f getCenter() {
        return center;
    }

-    /** Get the x-axis size (extent) of this box. */
+    /** 
+     * Get the x-axis size (extent) of this box. 
+     */
    public final float getXExtent() {
        return xExtent;
    }

-    /** Get the y-axis size (extent) of this box. */
+    /** 
+     * Get the y-axis size (extent) of this box. 
+     */
    public final float getYExtent() {
        return yExtent;
    }

-    /** Get the z-axis size (extent) of this box. */
+    /** 
+     * Get the z-axis size (extent) of this box.
+     */
    public final float getZExtent() {
        return zExtent;
    }
@ -180,6 +188,7 @@ public abstract class AbstractBox extends Mesh {
        updateGeometry(center, x, y, z);
    }

+    @Override
    public void read(JmeImporter e) throws IOException {
        super.read(e);
        InputCapsule capsule = e.getCapsule(this);
@ -189,6 +198,7 @@ public abstract class AbstractBox extends Mesh {
        center.set((Vector3f) capsule.readSavable("center", Vector3f.ZERO.clone()));
    }

+    @Override
    public void write(JmeExporter e) throws IOException {
        super.write(e);
        OutputCapsule capsule = e.getCapsule(this);
--- a/engine/src/core/com/jme3/scene/shape/Curve.java
+++ b/engine/src/core/com/jme3/scene/shape/Curve.java
@ -39,7 +39,11 @@ import java.util.Iterator;
 import java.util.List;

 /**
- *
+ * A <code>Curve</code> is a visual, line-based representation of a {@link Spline}.
+ * The underlying Spline will be sampled N times where N is the number of 
+ * segments as specified in the constructor. Each segment will represent
+ * one line in the generated mesh.
+ * 
 * @author Nehon
 */
 public class Curve extends Mesh {
@ -48,8 +52,15 @@ public class Curve extends Mesh {
    private Vector3f temp = new Vector3f();

    /**
-     * Create a curve mesh
+     * Serialization only. Do not use.
+     */
+    public Curve(){
+    }
+    
+    /**
+     * Create a curve mesh.
     * Use a CatmullRom spline model that does not cycle.
+     * 
     * @param controlPoints the control points to use to create this curve
     * @param nbSubSegments the number of subsegments between the control points
     */
@ -59,6 +70,7 @@ public class Curve extends Mesh {

    /**
     * Create a curve mesh from a Spline
+     * 
     * @param spline the spline to use
     * @param nbSubSegments the number of subsegments between the control points
     */
--- a/engine/src/core/com/jme3/scene/shape/Dome.java
+++ b/engine/src/core/com/jme3/scene/shape/Dome.java
@ -70,7 +70,7 @@ public class Dome extends Mesh {
    private boolean outsideView = true;

    /**
-     * Constructs a dome. By default the dome has not geometry data or center.
+     * Serialization only. Do not use.
     */
    public Dome() {
    }
@ -140,25 +140,29 @@ public class Dome extends Mesh {
        return center;
    }

-    /** Get the number of planar segments along the z-axis of the dome. */
+    /** 
+     * Get the number of planar segments along the z-axis of the dome. 
+     */
    public int getPlanes() {
        return planes;
    }

-    /** Get the number of samples radially around the main axis of the dome. */
+    /** 
+     * Get the number of samples radially around the main axis of the dome. 
+     */
    public int getRadialSamples() {
        return radialSamples;
    }

-    /** Get the radius of the dome. */
+    /** 
+     * Get the radius of the dome. 
+     */
    public float getRadius() {
        return radius;
    }

    /**
-     * Are the triangles connected in such a way as to present aview out from the dome or not.
-     * 
-     * @return
+     * Are the triangles connected in such a way as to present a view out from the dome or not.
     */
    public boolean isOutsideView() {
        return outsideView;
@ -298,6 +302,7 @@ public class Dome extends Mesh {
        updateBound();
    }

+    @Override
    public void read(JmeImporter e) throws IOException {
        super.read(e);
        InputCapsule capsule = e.getCapsule(this);
@ -307,9 +312,7 @@ public class Dome extends Mesh {
        center = (Vector3f) capsule.readSavable("center", Vector3f.ZERO.clone());
    }

-    /**
-     * Generates the connections
-     */
+    @Override
    public void write(JmeExporter e) throws IOException {
        super.write(e);
        OutputCapsule capsule = e.getCapsule(this);
--- a/engine/src/core/com/jme3/scene/shape/Line.java
+++ b/engine/src/core/com/jme3/scene/shape/Line.java
@ -40,7 +40,6 @@ import com.jme3.math.Vector3f;
 import com.jme3.scene.Mesh;
 import com.jme3.scene.VertexBuffer;
 import com.jme3.scene.VertexBuffer.Type;
-import com.jme3.util.BufferUtils;
 import java.io.IOException;
 import java.nio.FloatBuffer;

--- a/engine/src/core/com/jme3/scene/shape/PQTorus.java
+++ b/engine/src/core/com/jme3/scene/shape/PQTorus.java
@ -45,7 +45,6 @@ import static com.jme3.util.BufferUtils.*;

 import java.io.IOException;
 import java.nio.FloatBuffer;
-import java.nio.IntBuffer;
 import java.nio.ShortBuffer;

 /**
--- a/engine/src/core/com/jme3/scene/shape/Quad.java
+++ b/engine/src/core/com/jme3/scene/shape/Quad.java
@ -32,24 +32,48 @@

 package com.jme3.scene.shape;

-import com.jme3.scene.*;
+import com.jme3.scene.Mesh;
 import com.jme3.scene.VertexBuffer.Type;

+/**
+ * <code>Quad</code> represents a rectangular plane in space
+ * defined by 4 vertices. The quad's lower-left side is contained
+ * at the local space origin (0, 0, 0), while the upper-right
+ * side is located at the width/height coordinates (width, height, 0).
+ * 
+ * @author Kirill Vainer
+ */
 public class Quad extends Mesh {

    private float width;
    private float height;

    /**
-     * Do not use this constructor. Serialization purposes only.
+     * Serialization only. Do not use.
     */
    public Quad(){
    }

+    /**
+     * Create a quad with the given width and height. The quad
+     * is always created in the XY plane.
+     * 
+     * @param width The X extent or width
+     * @param height The Y extent or width
+     */
    public Quad(float width, float height){
        updateGeometry(width, height);
    }

+    /**
+     * Create a quad with the given width and height. The quad
+     * is always created in the XY plane.
+     * 
+     * @param width The X extent or width
+     * @param height The Y extent or width
+     * @param flipCoords If true, the texture coordinates will be flipped
+     * along the Y axis.
+     */
    public Quad(float width, float height, boolean flipCoords){
        updateGeometry(width, height, flipCoords);
    }
--- a/engine/src/core/com/jme3/scene/shape/Sphere.java
+++ b/engine/src/core/com/jme3/scene/shape/Sphere.java
@ -58,11 +58,16 @@ import java.nio.ShortBuffer;
 public class Sphere extends Mesh {

    public enum TextureMode {
-        /** Wrap texture radially and along z-axis */
+        /** 
+         * Wrap texture radially and along z-axis 
+         */
        Original,
-        /** Wrap texure radially, but spherically project along z-axis */
+        /** 
+         * Wrap texure radially, but spherically project along z-axis 
+         */
        Projected,
-        /** Apply texture to each pole.  Eliminates polar distortion,
+        /** 
+         * Apply texture to each pole.  Eliminates polar distortion,
         * but mirrors the texture across the equator 
         */
        Polar
@ -86,7 +91,7 @@ public class Sphere extends Mesh {
    protected TextureMode textureMode = TextureMode.Original;

    /**
-     * Empty constructor for serialization only, do not use.
+     * Serialization only. Do not use.
     */
    public Sphere(){
    }
--- a/engine/src/terrain/com/jme3/terrain/MapUtils.java
+++ b/engine/src/terrain/com/jme3/terrain/MapUtils.java
@ -4,6 +4,7 @@ import java.awt.image.BufferedImage;
 import java.io.File;
 import java.io.IOException;
 import java.nio.FloatBuffer;
+import java.util.logging.Level;
 import java.util.logging.Logger;

 import javax.imageio.ImageIO;
@ -12,51 +13,51 @@ import org.novyon.noise.ShaderUtils;

 public class MapUtils {

-	public static FloatBuffer clip(FloatBuffer src, int origSize, int newSize, int offset) {
-		FloatBuffer result = FloatBuffer.allocate(newSize * newSize);
-
-		float[] orig = src.array();
-		for (int i = offset; i < offset + newSize; i++) {
-			result.put(orig, i * origSize + offset, newSize);
-		}
-
-		return result;
-	}
-
-	public static BufferedImage toGrayscale16Image(FloatBuffer buff, int size) {
-		BufferedImage retval = new BufferedImage(size, size, BufferedImage.TYPE_USHORT_GRAY);
-		buff.rewind();
-		for (int y = 0; y < size; y++) {
-			for (int x = 0; x < size; x++) {
-				short c = (short) (ShaderUtils.clamp(buff.get(), 0, 1) * 65532);
-				retval.getRaster().setDataElements(x, y, new short[] { c });
-			}
-		}
-		return retval;
-	}
-
-	public static BufferedImage toGrayscaleRGBImage(FloatBuffer buff, int size) {
-		BufferedImage retval = new BufferedImage(size, size, BufferedImage.TYPE_INT_ARGB);
-		buff.rewind();
-		for (int y = 0; y < size; y++) {
-			for (int x = 0; x < size; x++) {
-				int c = (int) (ShaderUtils.clamp(buff.get(), 0, 1) * 255);
-				retval.setRGB(x, y, 0xFF000000 | c << 16 | c << 8 | c);
-			}
-		}
-		return retval;
-	}
-
-	public static void saveImage(BufferedImage im, String file) {
-		MapUtils.saveImage(im, new File(file));
-	}
-
-	public static void saveImage(BufferedImage im, File file) {
-		try {
-			ImageIO.write(im, "PNG", file);
-			Logger.getLogger(MapUtils.class.getCanonicalName()).info("Saved image as : " + file.getAbsolutePath());
-		} catch (IOException e) {
-			e.printStackTrace();
-		}
-	}
+    public static FloatBuffer clip(FloatBuffer src, int origSize, int newSize, int offset) {
+        FloatBuffer result = FloatBuffer.allocate(newSize * newSize);
+
+        float[] orig = src.array();
+        for (int i = offset; i < offset + newSize; i++) {
+            result.put(orig, i * origSize + offset, newSize);
+        }
+
+        return result;
+    }
+
+    public static BufferedImage toGrayscale16Image(FloatBuffer buff, int size) {
+        BufferedImage retval = new BufferedImage(size, size, BufferedImage.TYPE_USHORT_GRAY);
+        buff.rewind();
+        for (int y = 0; y < size; y++) {
+            for (int x = 0; x < size; x++) {
+                short c = (short) (ShaderUtils.clamp(buff.get(), 0, 1) * 65532);
+                retval.getRaster().setDataElements(x, y, new short[]{c});
+            }
+        }
+        return retval;
+    }
+
+    public static BufferedImage toGrayscaleRGBImage(FloatBuffer buff, int size) {
+        BufferedImage retval = new BufferedImage(size, size, BufferedImage.TYPE_INT_ARGB);
+        buff.rewind();
+        for (int y = 0; y < size; y++) {
+            for (int x = 0; x < size; x++) {
+                int c = (int) (ShaderUtils.clamp(buff.get(), 0, 1) * 255);
+                retval.setRGB(x, y, 0xFF000000 | c << 16 | c << 8 | c);
+            }
+        }
+        return retval;
+    }
+
+    public static void saveImage(BufferedImage im, String file) {
+        MapUtils.saveImage(im, new File(file));
+    }
+
+    public static void saveImage(BufferedImage im, File file) {
+        try {
+            ImageIO.write(im, "PNG", file);
+            Logger.getLogger(MapUtils.class.getCanonicalName()).log(Level.INFO, "Saved image as : {0}", file.getAbsolutePath());
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
 }
--- a/engine/src/terrain/com/jme3/terrain/ProgressMonitor.java
+++ b/engine/src/terrain/com/jme3/terrain/ProgressMonitor.java
@ -29,7 +29,6 @@
 * 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.terrain;

 /**
--- a/engine/src/terrain/com/jme3/terrain/Terrain.java
+++ b/engine/src/terrain/com/jme3/terrain/Terrain.java
@ -29,7 +29,6 @@
 * 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.terrain;

 import com.jme3.material.Material;
@ -64,7 +63,7 @@ public interface Terrain {
     * @return the height, unscaled and uninterpolated
     */
    public float getHeightmapHeight(Vector2f xz);
-	
+
    /**
     * Set the height at the specified X-Z coordinate.
     * To set the height of the terrain and see it, you will have
@ -129,7 +128,7 @@ public interface Terrain {
     * and the less detailed it will be.
     */
    public int getMaxLod();
-	
+
    /**
     * Called in the update (pre or post, up to you) method of your game.
     * Calculates the level of detail of the terrain and adjusts its geometry.
@ -139,7 +138,7 @@ public interface Terrain {
     * @param location often the Camera's location
     */
    public void update(List<Vector3f> location);
-	
+
    /**
     * Get the spatial instance of this Terrain. Right now just used in the 
     * terrain editor in JMP.
@ -162,7 +161,6 @@ public interface Terrain {
     */
    public void generateEntropy(ProgressMonitor monitor);

-
    /**
     * Returns the material that this terrain uses.
     * This does not necessarily have to guarantee the material
@ -195,5 +193,4 @@ public interface Terrain {
     * texture scales.
     */
    public float getTextureCoordinateScale();
-    
 }
--- a/engine/src/terrain/com/jme3/terrain/geomipmap/LODGeomap.java
+++ b/engine/src/terrain/com/jme3/terrain/geomipmap/LODGeomap.java
--- a/engine/src/terrain/com/jme3/terrain/geomipmap/TerrainGrid.java
+++ b/engine/src/terrain/com/jme3/terrain/geomipmap/TerrainGrid.java
@ -28,7 +28,8 @@ import com.jme3.terrain.heightmap.HeightMapGrid;
 */
 public class TerrainGrid extends TerrainQuad {

-    private static Logger log = Logger.getLogger(TerrainGrid.class.getCanonicalName());
+    private static final Logger log = Logger.getLogger(TerrainGrid.class.getCanonicalName());
+    
    private Vector3f currentCell;
    private int quarterSize;
    private int quadSize;
--- a/engine/src/terrain/com/jme3/terrain/geomipmap/TerrainQuad.java
+++ b/engine/src/terrain/com/jme3/terrain/geomipmap/TerrainQuad.java
@ -111,6 +111,7 @@ public class TerrainQuad extends Node implements Terrain {
    protected ExecutorService executor = Executors.newSingleThreadExecutor(new ThreadFactory() {
        public Thread newThread(Runnable r) {
            Thread th = new Thread(r);
+            th.setName("jME Terrain Thread");
            th.setDaemon(true);
            return th;
        }