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

author shadowislord <shadowislord@75d07b2b-3a1a-0410-a2c5-0572b91ccdca>

Sat, 18 Jun 2011 21:05:04 +0000 (21:05 +0000)

committer shadowislord <shadowislord@75d07b2b-3a1a-0410-a2c5-0572b91ccdca>

Sat, 18 Jun 2011 21:05:04 +0000 (21:05 +0000)
author shadowislord <shadowislord@75d07b2b-3a1a-0410-a2c5-0572b91ccdca>
Sat, 18 Jun 2011 21:05:04 +0000 (21:05 +0000)
committer shadowislord <shadowislord@75d07b2b-3a1a-0410-a2c5-0572b91ccdca>
Sat, 18 Jun 2011 21:05:04 +0000 (21:05 +0000)
diff --git a/engine/src/core/com/jme3/scene/CameraNode.java b/engine/src/core/com/jme3/scene/CameraNode.java

index c78f6c3..c6bb48b 100644 (file)
--- 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() {
      }
diff --git a/engine/src/core/com/jme3/scene/control/package.html b/engine/src/core/com/jme3/scene/control/package.html

new file mode 100644 (file)

index 0000000..a387840
--- /dev/null
+++ 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>
diff --git a/engine/src/core/com/jme3/scene/debug/Arrow.java b/engine/src/core/com/jme3/scene/debug/Arrow.java

index fcd76fc..0b26839 100644 (file)
--- 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();
diff --git a/engine/src/core/com/jme3/scene/debug/Grid.java b/engine/src/core/com/jme3/scene/debug/Grid.java

index 3cf2181..ea6225c 100644 (file)
--- 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();
      }
+    
  }
diff --git a/engine/src/core/com/jme3/scene/mesh/IndexBuffer.java b/engine/src/core/com/jme3/scene/mesh/IndexBuffer.java

index 8bc7c21..08e9239 100644 (file)
--- 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();
  }
diff --git a/engine/src/core/com/jme3/scene/mesh/IndexByteBuffer.java b/engine/src/core/com/jme3/scene/mesh/IndexByteBuffer.java

index 649c6bd..fd3bec4 100644 (file)
--- 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 {
diff --git a/engine/src/core/com/jme3/scene/mesh/IndexIntBuffer.java b/engine/src/core/com/jme3/scene/mesh/IndexIntBuffer.java

index e062cfd..3369301 100644 (file)
--- 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 {
diff --git a/engine/src/core/com/jme3/scene/mesh/IndexShortBuffer.java b/engine/src/core/com/jme3/scene/mesh/IndexShortBuffer.java

index 8abccb7..5017e6f 100644 (file)
--- 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 {
diff --git a/engine/src/core/com/jme3/scene/mesh/VirtualIndexBuffer.java b/engine/src/core/com/jme3/scene/mesh/VirtualIndexBuffer.java

index 463e7ad..c1499cc 100644 (file)
--- 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;
diff --git a/engine/src/core/com/jme3/scene/mesh/WrappedIndexBuffer.java b/engine/src/core/com/jme3/scene/mesh/WrappedIndexBuffer.java

index e4c059c..38e833d 100644 (file)
--- 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
   */
diff --git a/engine/src/core/com/jme3/scene/mesh/package.html b/engine/src/core/com/jme3/scene/mesh/package.html

new file mode 100644 (file)

index 0000000..5362c52
--- /dev/null
+++ 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>
diff --git a/engine/src/core/com/jme3/scene/package.html b/engine/src/core/com/jme3/scene/package.html

new file mode 100644 (file)

index 0000000..53f8105
--- /dev/null
+++ 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>
diff --git a/engine/src/core/com/jme3/scene/shape/AbstractBox.java b/engine/src/core/com/jme3/scene/shape/AbstractBox.java

index bd1e4ba..ef23349 100644 (file)
--- 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);
diff --git a/engine/src/core/com/jme3/scene/shape/Curve.java b/engine/src/core/com/jme3/scene/shape/Curve.java

index db032fb..fbeda59 100644 (file)
--- 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
       */
diff --git a/engine/src/core/com/jme3/scene/shape/Dome.java b/engine/src/core/com/jme3/scene/shape/Dome.java

index 0e9a3da..96bc9aa 100644 (file)
--- 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);
diff --git a/engine/src/core/com/jme3/scene/shape/Line.java b/engine/src/core/com/jme3/scene/shape/Line.java

index 55f54bc..1edbba7 100644 (file)
--- 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;
  
diff --git a/engine/src/core/com/jme3/scene/shape/PQTorus.java b/engine/src/core/com/jme3/scene/shape/PQTorus.java

index 20fd343..1230098 100644 (file)
--- 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;
  
  /**
diff --git a/engine/src/core/com/jme3/scene/shape/Quad.java b/engine/src/core/com/jme3/scene/shape/Quad.java

index a9464fc..1945358 100644 (file)
--- 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);
      }
diff --git a/engine/src/core/com/jme3/scene/shape/Sphere.java b/engine/src/core/com/jme3/scene/shape/Sphere.java

index 1e20347..8f0ace8 100644 (file)
--- 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 {\r
  \r
      public enum TextureMode {\r
-        /** Wrap texture radially and along z-axis */\r
+        /** \r
+         * Wrap texture radially and along z-axis \r
+         */\r
          Original,\r
-        /** Wrap texure radially, but spherically project along z-axis */\r
+        /** \r
+         * Wrap texure radially, but spherically project along z-axis \r
+         */\r
          Projected,\r
-        /** Apply texture to each pole.  Eliminates polar distortion,\r
+        /** \r
+         * Apply texture to each pole.  Eliminates polar distortion,\r
           * but mirrors the texture across the equator \r
           */\r
          Polar\r
@@ -86,7 +91,7 @@ public class Sphere extends Mesh {
      protected TextureMode textureMode = TextureMode.Original;\r
  \r
      /**\r
-     * Empty constructor for serialization only, do not use.\r
+     * Serialization only. Do not use.\r
       */\r
      public Sphere(){\r
      }\r
diff --git a/engine/src/terrain/com/jme3/terrain/MapUtils.java b/engine/src/terrain/com/jme3/terrain/MapUtils.java

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

index 43481a2..4664231 100644 (file)
--- 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;
  
  /**
diff --git a/engine/src/terrain/com/jme3/terrain/Terrain.java b/engine/src/terrain/com/jme3/terrain/Terrain.java

index 72b783a..85dd32e 100644 (file)
--- 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\r
   * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
   */\r
-\r
  package com.jme3.terrain;\r
  \r
  import com.jme3.material.Material;\r
@@ -64,7 +63,7 @@ public interface Terrain {
       * @return the height, unscaled and uninterpolated\r
       */\r
      public float getHeightmapHeight(Vector2f xz);\r
-       \r
+\r
      /**\r
       * Set the height at the specified X-Z coordinate.\r
       * To set the height of the terrain and see it, you will have\r
@@ -129,7 +128,7 @@ public interface Terrain {
       * and the less detailed it will be.\r
       */\r
      public int getMaxLod();\r
-       \r
+\r
      /**\r
       * Called in the update (pre or post, up to you) method of your game.\r
       * Calculates the level of detail of the terrain and adjusts its geometry.\r
@@ -139,7 +138,7 @@ public interface Terrain {
       * @param location often the Camera's location\r
       */\r
      public void update(List<Vector3f> location);\r
-       \r
+\r
      /**\r
       * Get the spatial instance of this Terrain. Right now just used in the \r
       * terrain editor in JMP.\r
@@ -162,7 +161,6 @@ public interface Terrain {
       */\r
      public void generateEntropy(ProgressMonitor monitor);\r
  \r
-\r
      /**\r
       * Returns the material that this terrain uses.\r
       * This does not necessarily have to guarantee the material\r
@@ -195,5 +193,4 @@ public interface Terrain {
       * texture scales.\r
       */\r
      public float getTextureCoordinateScale();\r
-    \r
  }\r
diff --git a/engine/src/terrain/com/jme3/terrain/geomipmap/LODGeomap.java b/engine/src/terrain/com/jme3/terrain/geomipmap/LODGeomap.java

index 0d67c7a..f4bd569 100644 (file)
--- a/engine/src/terrain/com/jme3/terrain/geomipmap/LODGeomap.java
+++ b/engine/src/terrain/com/jme3/terrain/geomipmap/LODGeomap.java
@@ -29,7 +29,6 @@
   * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r
   * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
   */\r
-\r
  package com.jme3.terrain.geomipmap;\r
  \r
  import com.jme3.export.InputCapsule;\r
@@ -67,341 +66,347 @@ import java.io.IOException;
   */\r
  public class LODGeomap extends BufferGeomap {\r
  \r
-    public LODGeomap() {}\r
+    public LODGeomap() {\r
+    }\r
  \r
      public LODGeomap(int size, FloatBuffer heightMap) {\r
-               super(heightMap, null, size, size, 1);\r
-       }\r
-\r
-       public Mesh createMesh(Vector3f scale, Vector2f tcScale, Vector2f tcOffset, float offsetAmount, int totalSize, boolean center) {\r
-               return this.createMesh(scale, tcScale, tcOffset, offsetAmount, totalSize, center, 1, false,false,false,false);\r
-       }\r
-\r
-       public Mesh createMesh(Vector3f scale, Vector2f tcScale, Vector2f tcOffset, float offsetAmount, int totalSize, boolean center, int lod, boolean rightLod, boolean topLod, boolean leftLod, boolean bottomLod){\r
-               FloatBuffer pb = writeVertexArray(null, scale, center);\r
-               FloatBuffer tb = writeTexCoordArray(null, tcOffset, tcScale, offsetAmount, totalSize);\r
-               FloatBuffer nb = writeNormalArray(null, scale);\r
-               IntBuffer ib = writeIndexArrayLodDiff(null, lod, rightLod, topLod, leftLod, bottomLod);\r
-               Mesh m = new Mesh();\r
-               m.setMode(Mode.TriangleStrip);\r
-               m.setBuffer(Type.Position, 3, pb);\r
-               m.setBuffer(Type.Normal, 3, nb);\r
-               m.setBuffer(Type.TexCoord, 2, tb);\r
-               m.setBuffer(Type.Index, 3, ib);\r
-               m.setStatic();\r
-               m.updateBound();\r
-               return m;\r
-       }\r
+        super(heightMap, null, size, size, 1);\r
+    }\r
  \r
+    public Mesh createMesh(Vector3f scale, Vector2f tcScale, Vector2f tcOffset, float offsetAmount, int totalSize, boolean center) {\r
+        return this.createMesh(scale, tcScale, tcOffset, offsetAmount, totalSize, center, 1, false, false, false, false);\r
+    }\r
+\r
+    public Mesh createMesh(Vector3f scale, Vector2f tcScale, Vector2f tcOffset, float offsetAmount, int totalSize, boolean center, int lod, boolean rightLod, boolean topLod, boolean leftLod, boolean bottomLod) {\r
+        FloatBuffer pb = writeVertexArray(null, scale, center);\r
+        FloatBuffer tb = writeTexCoordArray(null, tcOffset, tcScale, offsetAmount, totalSize);\r
+        FloatBuffer nb = writeNormalArray(null, scale);\r
+        IntBuffer ib = writeIndexArrayLodDiff(null, lod, rightLod, topLod, leftLod, bottomLod);\r
+        Mesh m = new Mesh();\r
+        m.setMode(Mode.TriangleStrip);\r
+        m.setBuffer(Type.Position, 3, pb);\r
+        m.setBuffer(Type.Normal, 3, nb);\r
+        m.setBuffer(Type.TexCoord, 2, tb);\r
+        m.setBuffer(Type.Index, 3, ib);\r
+        m.setStatic();\r
+        m.updateBound();\r
+        return m;\r
+    }\r
  \r
      protected void removeNormalBuffer() {\r
          ndata = null;\r
      }\r
  \r
-       public FloatBuffer writeTexCoordArray(FloatBuffer store, Vector2f offset, Vector2f scale, float offsetAmount, int totalSize){\r
-               if (store!=null){\r
-                       if (store.remaining() < getWidth()*getHeight()*2)\r
-                               throw new BufferUnderflowException();\r
-               }else{\r
-                       store = BufferUtils.createFloatBuffer(getWidth()*getHeight()*2);\r
-               }\r
+    public FloatBuffer writeTexCoordArray(FloatBuffer store, Vector2f offset, Vector2f scale, float offsetAmount, int totalSize) {\r
+        if (store != null) {\r
+            if (store.remaining() < getWidth() * getHeight() * 2) {\r
+                throw new BufferUnderflowException();\r
+            }\r
+        } else {\r
+            store = BufferUtils.createFloatBuffer(getWidth() * getHeight() * 2);\r
+        }\r
  \r
-               if (offset == null)\r
-                       offset = new Vector2f();\r
+        if (offset == null) {\r
+            offset = new Vector2f();\r
+        }\r
  \r
-               Vector2f tcStore = new Vector2f();\r
+        Vector2f tcStore = new Vector2f();\r
  \r
-               for (int y = 0; y < getHeight(); y++){\r
+        for (int y = 0; y < getHeight(); y++) {\r
  \r
-                       for (int x = 0; x < getWidth(); x++){\r
-                               getUV(x,y,tcStore, offset, offsetAmount, totalSize);\r
-                               float tx = tcStore.x * scale.x;\r
-                               float ty = tcStore.y * scale.y;\r
-                               store.put( tx );\r
-                               store.put( ty );\r
-                       }\r
-               }\r
+            for (int x = 0; x < getWidth(); x++) {\r
+                getUV(x, y, tcStore, offset, offsetAmount, totalSize);\r
+                float tx = tcStore.x * scale.x;\r
+                float ty = tcStore.y * scale.y;\r
+                store.put(tx);\r
+                store.put(ty);\r
+            }\r
+        }\r
  \r
-               return store;\r
-       }\r
+        return store;\r
+    }\r
  \r
-       public Vector2f getUV(int x, int y, Vector2f store, Vector2f offset, float offsetAmount, int totalSize){\r
-               float offsetX = offset.x + (offsetAmount * 1.0f);//stepScale.x);\r
+    public Vector2f getUV(int x, int y, Vector2f store, Vector2f offset, float offsetAmount, int totalSize) {\r
+        float offsetX = offset.x + (offsetAmount * 1.0f);//stepScale.x);\r
          float offsetY = offset.y + (offsetAmount * 1.0f);//stepScale.z);\r
  \r
-        store.set( ( ((float)x)+offsetX) / (float)totalSize, // calculates percentage of texture here\r
-                   ( ((float)y)+offsetY) / (float)totalSize );\r
+        store.set((((float) x) + offsetX) / (float) totalSize, // calculates percentage of texture here\r
+                (((float) y) + offsetY) / (float) totalSize);\r
          return store;\r
      }\r
  \r
-       /**\r
-        * Create the LOD index array that will seam its edges with its neighbour's LOD.\r
-        * This is a scary method!!! It will break your mind.\r
-        *\r
-        * @param store to store the index buffer\r
-        * @param lod level of detail of the mesh\r
-        * @param rightLod LOD of the right neighbour\r
-        * @param topLod LOD of the top neighbour\r
-        * @param leftLod LOD of the left neighbour\r
-        * @param bottomLod LOD of the bottom neighbour\r
-        * @return the LOD-ified index buffer\r
-        */\r
-       public IntBuffer writeIndexArrayLodDiff(IntBuffer store, int lod, boolean rightLod, boolean topLod, boolean leftLod, boolean bottomLod){\r
-\r
-               IntBuffer buffer2 = store;\r
-               int numIndexes = calculateNumIndexesLodDiff(lod);\r
-               if (store == null)\r
-                       buffer2 = BufferUtils.createIntBuffer(numIndexes);\r
-               VerboseIntBuffer buffer = new VerboseIntBuffer(buffer2);\r
-\r
-\r
-               // generate center squares minus the edges\r
-               //System.out.println("for (x="+lod+"; x<"+(getWidth()-(2*lod))+"; x+="+lod+")");\r
-               //System.out.println("  for (z="+lod+"; z<"+(getWidth()-(1*lod))+"; z+="+lod+")");\r
-               for (int r=lod; r<getWidth()-(2*lod); r+=lod) { // row\r
-                       int rowIdx = r*getWidth();\r
-                       int nextRowIdx = (r+1*lod)*getWidth();\r
-                       for (int c=lod; c<getWidth()-(1*lod); c+=lod) { // column\r
-                               int idx = rowIdx+c;\r
-                               buffer.put(idx);\r
-                               idx = nextRowIdx+c;\r
-                               buffer.put(idx);\r
-                       }\r
-\r
-                       // add degenerate triangles\r
-                       if (r < getWidth()-(3*lod)) {\r
-                               int idx = nextRowIdx+getWidth()-(1*lod)-1;\r
-                               buffer.put(idx);\r
-                               idx = nextRowIdx+(1*lod); // inset by 1\r
-                               buffer.put(idx);\r
-                               //System.out.println("");\r
-                       }\r
-               }\r
-               //System.out.println("\nright:");\r
-\r
-               //int runningBufferCount = buffer.getCount();\r
-               //System.out.println("buffer start: "+runningBufferCount);\r
-\r
-\r
-               // right\r
-               int br = getWidth()*(getWidth()-lod)-1-lod;\r
-               buffer.put(br); // bottom right -1\r
-               int corner = getWidth()*getWidth()-1;\r
-               buffer.put(corner);     // bottom right corner\r
-               if (rightLod) { // if lower LOD\r
-                       for (int row=getWidth()-lod; row>=1+lod; row-=2*lod) {\r
-                               int idx = (row)*getWidth()-1-lod;\r
-                               buffer.put(idx);\r
-                               idx = (row-lod)*getWidth()-1;\r
-                               buffer.put(idx);\r
-                               if (row > lod+1) { //if not the last one\r
-                                       idx = (row-lod)*getWidth()-1-lod;\r
-                                       buffer.put(idx);\r
-                                       idx = (row-lod)*getWidth()-1;\r
-                                       buffer.put(idx);\r
-                               } else {\r
-\r
-                               }\r
-                       }\r
-               } else {\r
-                       buffer.put(corner);//br+1);//degenerate to flip winding order\r
-                       for (int row=getWidth()-lod; row>lod; row-=lod) {\r
-                               int idx = row*getWidth()-1; // mult to get row\r
-                               buffer.put(idx);\r
-                               buffer.put(idx-lod);\r
-                       }\r
-\r
-               }\r
-\r
-               buffer.put(getWidth()-1);\r
-\r
-\r
-               //System.out.println("\nbuffer right: "+(buffer.getCount()-runningBufferCount));\r
-               //runningBufferCount = buffer.getCount();\r
-\r
-\r
-               //System.out.println("\ntop:");\r
-\r
-               // top                  (the order gets reversed here so the diagonals line up)\r
-               if (topLod) { // if lower LOD\r
-                       if (rightLod)\r
-                               buffer.put(getWidth()-1);\r
-                       for (int col=getWidth()-1; col>=lod; col-=2*lod) {\r
-                               int idx = (lod*getWidth())+col-lod; // next row\r
-                               buffer.put(idx);\r
-                               idx = col-2*lod;\r
-                               buffer.put(idx);\r
-                               if (col > lod*2) { //if not the last one\r
-                                       idx = (lod*getWidth())+col-2*lod;\r
-                                       buffer.put(idx);\r
-                                       idx = col-2*lod;\r
-                                       buffer.put(idx);\r
-                               } else {\r
-\r
-                               }\r
-                       }\r
-               } else {\r
-                       if (rightLod)\r
-                               buffer.put(getWidth()-1);\r
-                       for (int col=getWidth()-1-lod; col>0; col-=lod) {\r
-                               int idx = col + (lod*getWidth());\r
-                               buffer.put(idx);\r
-                               idx = col;\r
-                               buffer.put(idx);\r
-                       }\r
-                       buffer.put(0);\r
-               }\r
-               buffer.put(0);\r
-\r
-               //System.out.println("\nbuffer top: "+(buffer.getCount()-runningBufferCount));\r
-               //runningBufferCount = buffer.getCount();\r
-\r
-               //System.out.println("\nleft:");\r
-\r
-               // left\r
-               if (leftLod) { // if lower LOD\r
-                       if (topLod)\r
-                               buffer.put(0);\r
-                       for (int row=0; row<getWidth()-lod; row+=2*lod) {\r
-                               int idx = (row+lod)*getWidth()+lod;\r
-                               buffer.put(idx);\r
-                               idx = (row+2*lod)*getWidth();\r
-                               buffer.put(idx);\r
-                               if (row < getWidth()-lod-2-1) { //if not the last one\r
-                                       idx = (row+2*lod)*getWidth()+lod;\r
-                                       buffer.put(idx);\r
-                                       idx = (row+2*lod)*getWidth();\r
-                                       buffer.put(idx);\r
-                               } else {\r
-\r
-                               }\r
-                       }\r
-               } else {\r
-                       if (!topLod)\r
-                               buffer.put(0);\r
-                       //buffer.put(getWidth()+1); // degenerate\r
-                       //buffer.put(0); // degenerate winding-flip\r
-                       for (int row=lod; row<getWidth()-lod; row+=lod) {\r
-                               int idx = row*getWidth();\r
-                               buffer.put(idx);\r
-                               idx = row*getWidth()+lod;\r
-                               buffer.put(idx);\r
-                       }\r
-\r
-               }\r
-               buffer.put(getWidth()*(getWidth()-1));\r
-\r
-\r
-               //System.out.println("\nbuffer left: "+(buffer.getCount()-runningBufferCount));\r
-               //runningBufferCount = buffer.getCount();\r
-\r
-               //if (true) return buffer.delegate;\r
-               //System.out.println("\nbottom");\r
-\r
-               // bottom\r
-               if (bottomLod) { // if lower LOD\r
-                       if (leftLod)\r
-                               buffer.put(getWidth()*(getWidth()-1));\r
-                       // there was a slight bug here when really high LOD near maxLod\r
-                       // far right has extra index one row up and all the way to the right, need to skip last index entered\r
-                       // seemed to be fixed by making "getWidth()-1-2-lod" this: "getWidth()-1-2*lod", which seems more correct\r
-                       for (int col=0; col<getWidth()-lod; col+=2*lod) {\r
-                               int idx = getWidth()*(getWidth()-1-lod)+col+lod;\r
-                               buffer.put(idx);\r
-                               idx = getWidth()*(getWidth()-1)+col+2*lod;\r
-                               buffer.put(idx);\r
-                               if (col < getWidth()-1-2*lod) { //if not the last one\r
-                                       idx = getWidth()*(getWidth()-1-lod)+col+2*lod;\r
-                                       buffer.put(idx);\r
-                                       idx = getWidth()*(getWidth()-1)+col+2*lod;\r
-                                       buffer.put(idx);\r
-                               } else {\r
-\r
-                               }\r
-                       }\r
-               } else {\r
-                       if (leftLod) {\r
-                               buffer.put(getWidth()*(getWidth()-1));\r
-                       }\r
-                       for (int col=lod; col<getWidth()-lod; col+=lod) {\r
-                               int idx = getWidth()*(getWidth()-1-lod) + col; // up\r
-                               buffer.put(idx);\r
-                               idx = getWidth()*(getWidth()-1) + col; // down\r
-                               buffer.put(idx);\r
-                       }\r
-                       //buffer.put(getWidth()*getWidth()-1-lod); // <-- THIS caused holes at the end!\r
-               }\r
-\r
-               buffer.put(getWidth()*getWidth()-1);\r
-\r
-               //System.out.println("\nbuffer bottom: "+(buffer.getCount()-runningBufferCount));\r
-               //runningBufferCount = buffer.getCount();\r
-\r
-               //System.out.println("\nBuffer size: "+buffer.getCount());\r
-\r
-               // fill in the rest of the buffer with degenerates, there should only be a couple\r
-               for (int i=buffer.getCount(); i<numIndexes; i++)\r
-                       buffer.put(getWidth()*getWidth()-1);\r
-\r
-               return buffer.delegate;\r
-       }\r
-\r
-    public IntBuffer writeIndexArrayLodVariable(IntBuffer store, int lod, int rightLod, int topLod, int leftLod, int bottomLod){\r
-\r
-               IntBuffer buffer2 = store;\r
-               int numIndexes = calculateNumIndexesLodDiff(lod);\r
-               if (store == null)\r
-                       buffer2 = BufferUtils.createIntBuffer(numIndexes);\r
-               VerboseIntBuffer buffer = new VerboseIntBuffer(buffer2);\r
-\r
-\r
-               // generate center squares minus the edges\r
-               //System.out.println("for (x="+lod+"; x<"+(getWidth()-(2*lod))+"; x+="+lod+")");\r
-               //System.out.println("  for (z="+lod+"; z<"+(getWidth()-(1*lod))+"; z+="+lod+")");\r
-               for (int r=lod; r<getWidth()-(2*lod); r+=lod) { // row\r
-                       int rowIdx = r*getWidth();\r
-                       int nextRowIdx = (r+1*lod)*getWidth();\r
-                       for (int c=lod; c<getWidth()-(1*lod); c+=lod) { // column\r
-                               int idx = rowIdx+c;\r
-                               buffer.put(idx);\r
-                               idx = nextRowIdx+c;\r
-                               buffer.put(idx);\r
-                       }\r
-\r
-                       // add degenerate triangles\r
-                       if (r < getWidth()-(3*lod)) {\r
-                               int idx = nextRowIdx+getWidth()-(1*lod)-1;\r
-                               buffer.put(idx);\r
-                               idx = nextRowIdx+(1*lod); // inset by 1\r
-                               buffer.put(idx);\r
-                               //System.out.println("");\r
-                       }\r
-               }\r
-               //System.out.println("\nright:");\r
-\r
-               //int runningBufferCount = buffer.getCount();\r
-               //System.out.println("buffer start: "+runningBufferCount);\r
-\r
-\r
-               // right\r
-               int br = getWidth()*(getWidth()-lod)-1-lod;\r
-               buffer.put(br); // bottom right -1\r
-               int corner = getWidth()*getWidth()-1;\r
-               buffer.put(corner);     // bottom right corner\r
-               if (rightLod>lod) { // if lower LOD\r
+    /**\r
+     * Create the LOD index array that will seam its edges with its neighbour's LOD.\r
+     * This is a scary method!!! It will break your mind.\r
+     *\r
+     * @param store to store the index buffer\r
+     * @param lod level of detail of the mesh\r
+     * @param rightLod LOD of the right neighbour\r
+     * @param topLod LOD of the top neighbour\r
+     * @param leftLod LOD of the left neighbour\r
+     * @param bottomLod LOD of the bottom neighbour\r
+     * @return the LOD-ified index buffer\r
+     */\r
+    public IntBuffer writeIndexArrayLodDiff(IntBuffer store, int lod, boolean rightLod, boolean topLod, boolean leftLod, boolean bottomLod) {\r
+\r
+        IntBuffer buffer2 = store;\r
+        int numIndexes = calculateNumIndexesLodDiff(lod);\r
+        if (store == null) {\r
+            buffer2 = BufferUtils.createIntBuffer(numIndexes);\r
+        }\r
+        VerboseIntBuffer buffer = new VerboseIntBuffer(buffer2);\r
+\r
+\r
+        // generate center squares minus the edges\r
+        //System.out.println("for (x="+lod+"; x<"+(getWidth()-(2*lod))+"; x+="+lod+")");\r
+        //System.out.println(" for (z="+lod+"; z<"+(getWidth()-(1*lod))+"; z+="+lod+")");\r
+        for (int r = lod; r < getWidth() - (2 * lod); r += lod) { // row\r
+            int rowIdx = r * getWidth();\r
+            int nextRowIdx = (r + 1 * lod) * getWidth();\r
+            for (int c = lod; c < getWidth() - (1 * lod); c += lod) { // column\r
+                int idx = rowIdx + c;\r
+                buffer.put(idx);\r
+                idx = nextRowIdx + c;\r
+                buffer.put(idx);\r
+            }\r
+\r
+            // add degenerate triangles\r
+            if (r < getWidth() - (3 * lod)) {\r
+                int idx = nextRowIdx + getWidth() - (1 * lod) - 1;\r
+                buffer.put(idx);\r
+                idx = nextRowIdx + (1 * lod); // inset by 1\r
+                buffer.put(idx);\r
+                //System.out.println("");\r
+            }\r
+        }\r
+        //System.out.println("\nright:");\r
+\r
+        //int runningBufferCount = buffer.getCount();\r
+        //System.out.println("buffer start: "+runningBufferCount);\r
+\r
+\r
+        // right\r
+        int br = getWidth() * (getWidth() - lod) - 1 - lod;\r
+        buffer.put(br); // bottom right -1\r
+        int corner = getWidth() * getWidth() - 1;\r
+        buffer.put(corner);    // bottom right corner\r
+        if (rightLod) { // if lower LOD\r
+            for (int row = getWidth() - lod; row >= 1 + lod; row -= 2 * lod) {\r
+                int idx = (row) * getWidth() - 1 - lod;\r
+                buffer.put(idx);\r
+                idx = (row - lod) * getWidth() - 1;\r
+                buffer.put(idx);\r
+                if (row > lod + 1) { //if not the last one\r
+                    idx = (row - lod) * getWidth() - 1 - lod;\r
+                    buffer.put(idx);\r
+                    idx = (row - lod) * getWidth() - 1;\r
+                    buffer.put(idx);\r
+                } else {\r
+                }\r
+            }\r
+        } else {\r
+            buffer.put(corner);//br+1);//degenerate to flip winding order\r
+            for (int row = getWidth() - lod; row > lod; row -= lod) {\r
+                int idx = row * getWidth() - 1; // mult to get row\r
+                buffer.put(idx);\r
+                buffer.put(idx - lod);\r
+            }\r
+\r
+        }\r
+\r
+        buffer.put(getWidth() - 1);\r
+\r
+\r
+        //System.out.println("\nbuffer right: "+(buffer.getCount()-runningBufferCount));\r
+        //runningBufferCount = buffer.getCount();\r
+\r
+\r
+        //System.out.println("\ntop:");\r
+\r
+        // top                         (the order gets reversed here so the diagonals line up)\r
+        if (topLod) { // if lower LOD\r
+            if (rightLod) {\r
+                buffer.put(getWidth() - 1);\r
+            }\r
+            for (int col = getWidth() - 1; col >= lod; col -= 2 * lod) {\r
+                int idx = (lod * getWidth()) + col - lod; // next row\r
+                buffer.put(idx);\r
+                idx = col - 2 * lod;\r
+                buffer.put(idx);\r
+                if (col > lod * 2) { //if not the last one\r
+                    idx = (lod * getWidth()) + col - 2 * lod;\r
+                    buffer.put(idx);\r
+                    idx = col - 2 * lod;\r
+                    buffer.put(idx);\r
+                } else {\r
+                }\r
+            }\r
+        } else {\r
+            if (rightLod) {\r
+                buffer.put(getWidth() - 1);\r
+            }\r
+            for (int col = getWidth() - 1 - lod; col > 0; col -= lod) {\r
+                int idx = col + (lod * getWidth());\r
+                buffer.put(idx);\r
+                idx = col;\r
+                buffer.put(idx);\r
+            }\r
+            buffer.put(0);\r
+        }\r
+        buffer.put(0);\r
+\r
+        //System.out.println("\nbuffer top: "+(buffer.getCount()-runningBufferCount));\r
+        //runningBufferCount = buffer.getCount();\r
+\r
+        //System.out.println("\nleft:");\r
+\r
+        // left\r
+        if (leftLod) { // if lower LOD\r
+            if (topLod) {\r
+                buffer.put(0);\r
+            }\r
+            for (int row = 0; row < getWidth() - lod; row += 2 * lod) {\r
+                int idx = (row + lod) * getWidth() + lod;\r
+                buffer.put(idx);\r
+                idx = (row + 2 * lod) * getWidth();\r
+                buffer.put(idx);\r
+                if (row < getWidth() - lod - 2 - 1) { //if not the last one\r
+                    idx = (row + 2 * lod) * getWidth() + lod;\r
+                    buffer.put(idx);\r
+                    idx = (row + 2 * lod) * getWidth();\r
+                    buffer.put(idx);\r
+                } else {\r
+                }\r
+            }\r
+        } else {\r
+            if (!topLod) {\r
+                buffer.put(0);\r
+            }\r
+            //buffer.put(getWidth()+1); // degenerate\r
+            //buffer.put(0); // degenerate winding-flip\r
+            for (int row = lod; row < getWidth() - lod; row += lod) {\r
+                int idx = row * getWidth();\r
+                buffer.put(idx);\r
+                idx = row * getWidth() + lod;\r
+                buffer.put(idx);\r
+            }\r
+\r
+        }\r
+        buffer.put(getWidth() * (getWidth() - 1));\r
+\r
+\r
+        //System.out.println("\nbuffer left: "+(buffer.getCount()-runningBufferCount));\r
+        //runningBufferCount = buffer.getCount();\r
+\r
+        //if (true) return buffer.delegate;\r
+        //System.out.println("\nbottom");\r
+\r
+        // bottom\r
+        if (bottomLod) { // if lower LOD\r
+            if (leftLod) {\r
+                buffer.put(getWidth() * (getWidth() - 1));\r
+            }\r
+            // there was a slight bug here when really high LOD near maxLod\r
+            // far right has extra index one row up and all the way to the right, need to skip last index entered\r
+            // seemed to be fixed by making "getWidth()-1-2-lod" this: "getWidth()-1-2*lod", which seems more correct\r
+            for (int col = 0; col < getWidth() - lod; col += 2 * lod) {\r
+                int idx = getWidth() * (getWidth() - 1 - lod) + col + lod;\r
+                buffer.put(idx);\r
+                idx = getWidth() * (getWidth() - 1) + col + 2 * lod;\r
+                buffer.put(idx);\r
+                if (col < getWidth() - 1 - 2 * lod) { //if not the last one\r
+                    idx = getWidth() * (getWidth() - 1 - lod) + col + 2 * lod;\r
+                    buffer.put(idx);\r
+                    idx = getWidth() * (getWidth() - 1) + col + 2 * lod;\r
+                    buffer.put(idx);\r
+                } else {\r
+                }\r
+            }\r
+        } else {\r
+            if (leftLod) {\r
+                buffer.put(getWidth() * (getWidth() - 1));\r
+            }\r
+            for (int col = lod; col < getWidth() - lod; col += lod) {\r
+                int idx = getWidth() * (getWidth() - 1 - lod) + col; // up\r
+                buffer.put(idx);\r
+                idx = getWidth() * (getWidth() - 1) + col; // down\r
+                buffer.put(idx);\r
+            }\r
+            //buffer.put(getWidth()*getWidth()-1-lod); // <-- THIS caused holes at the end!\r
+        }\r
+\r
+        buffer.put(getWidth() * getWidth() - 1);\r
+\r
+        //System.out.println("\nbuffer bottom: "+(buffer.getCount()-runningBufferCount));\r
+        //runningBufferCount = buffer.getCount();\r
+\r
+        //System.out.println("\nBuffer size: "+buffer.getCount());\r
+\r
+        // fill in the rest of the buffer with degenerates, there should only be a couple\r
+        for (int i = buffer.getCount(); i < numIndexes; i++) {\r
+            buffer.put(getWidth() * getWidth() - 1);\r
+        }\r
+\r
+        return buffer.delegate;\r
+    }\r
+\r
+    public IntBuffer writeIndexArrayLodVariable(IntBuffer store, int lod, int rightLod, int topLod, int leftLod, int bottomLod) {\r
+\r
+        IntBuffer buffer2 = store;\r
+        int numIndexes = calculateNumIndexesLodDiff(lod);\r
+        if (store == null) {\r
+            buffer2 = BufferUtils.createIntBuffer(numIndexes);\r
+        }\r
+        VerboseIntBuffer buffer = new VerboseIntBuffer(buffer2);\r
+\r
+\r
+        // generate center squares minus the edges\r
+        //System.out.println("for (x="+lod+"; x<"+(getWidth()-(2*lod))+"; x+="+lod+")");\r
+        //System.out.println(" for (z="+lod+"; z<"+(getWidth()-(1*lod))+"; z+="+lod+")");\r
+        for (int r = lod; r < getWidth() - (2 * lod); r += lod) { // row\r
+            int rowIdx = r * getWidth();\r
+            int nextRowIdx = (r + 1 * lod) * getWidth();\r
+            for (int c = lod; c < getWidth() - (1 * lod); c += lod) { // column\r
+                int idx = rowIdx + c;\r
+                buffer.put(idx);\r
+                idx = nextRowIdx + c;\r
+                buffer.put(idx);\r
+            }\r
+\r
+            // add degenerate triangles\r
+            if (r < getWidth() - (3 * lod)) {\r
+                int idx = nextRowIdx + getWidth() - (1 * lod) - 1;\r
+                buffer.put(idx);\r
+                idx = nextRowIdx + (1 * lod); // inset by 1\r
+                buffer.put(idx);\r
+                //System.out.println("");\r
+            }\r
+        }\r
+        //System.out.println("\nright:");\r
+\r
+        //int runningBufferCount = buffer.getCount();\r
+        //System.out.println("buffer start: "+runningBufferCount);\r
+\r
+\r
+        // right\r
+        int br = getWidth() * (getWidth() - lod) - 1 - lod;\r
+        buffer.put(br); // bottom right -1\r
+        int corner = getWidth() * getWidth() - 1;\r
+        buffer.put(corner);    // bottom right corner\r
+        if (rightLod > lod) { // if lower LOD\r
              int idx = corner;\r
-            int it = (getWidth()-1)/rightLod; // iterations\r
-            int lodDiff = rightLod/lod;\r
-                       for (int i=it; i>0; i--) { // for each lod level of the neighbour\r
-                idx = getWidth()*(i*rightLod+1)-1;\r
-                for (int j=1; j<=lodDiff; j++) { // for each section in that lod level\r
-                    int idxB = idx - (getWidth()*(j*lod)) - lod;\r
+            int it = (getWidth() - 1) / rightLod; // iterations\r
+            int lodDiff = rightLod / lod;\r
+            for (int i = it; i > 0; i--) { // for each lod level of the neighbour\r
+                idx = getWidth() * (i * rightLod + 1) - 1;\r
+                for (int j = 1; j <= lodDiff; j++) { // for each section in that lod level\r
+                    int idxB = idx - (getWidth() * (j * lod)) - lod;\r
  \r
                      if (j == lodDiff && i == 1) {// the last one\r
-                        buffer.put(getWidth()-1);\r
+                        buffer.put(getWidth() - 1);\r
                      } else if (j == lodDiff) {\r
                          buffer.put(idxB);\r
-                        buffer.put(idxB+lod);\r
+                        buffer.put(idxB + lod);\r
                      } else {\r
                          buffer.put(idxB);\r
                          buffer.put(idx);\r
@@ -409,87 +414,88 @@ public class LODGeomap extends BufferGeomap {
                  }\r
              }\r
              // reset winding order\r
-            buffer.put(getWidth()*(lod+1)-lod-1); // top-right +1row\r
-            buffer.put(getWidth()-1);// top-right\r
-\r
-               } else {\r
-                       buffer.put(corner);//br+1);//degenerate to flip winding order\r
-                       for (int row=getWidth()-lod; row>lod; row-=lod) {\r
-                               int idx = row*getWidth()-1; // mult to get row\r
-                               buffer.put(idx);\r
-                               buffer.put(idx-lod);\r
-                       }\r
-            buffer.put(getWidth()-1);\r
-               }\r
+            buffer.put(getWidth() * (lod + 1) - lod - 1); // top-right +1row\r
+            buffer.put(getWidth() - 1);// top-right\r
+\r
+        } else {\r
+            buffer.put(corner);//br+1);//degenerate to flip winding order\r
+            for (int row = getWidth() - lod; row > lod; row -= lod) {\r
+                int idx = row * getWidth() - 1; // mult to get row\r
+                buffer.put(idx);\r
+                buffer.put(idx - lod);\r
+            }\r
+            buffer.put(getWidth() - 1);\r
+        }\r
  \r
  \r
-               //System.out.println("\nbuffer right: "+(buffer.getCount()-runningBufferCount));\r
-               //runningBufferCount = buffer.getCount();\r
+        //System.out.println("\nbuffer right: "+(buffer.getCount()-runningBufferCount));\r
+        //runningBufferCount = buffer.getCount();\r
  \r
  \r
-               //System.out.println("\ntop:");\r
+        //System.out.println("\ntop:");\r
  \r
-               // top                  (the order gets reversed here so the diagonals line up)\r
-               if (topLod>lod) { // if lower LOD\r
-                       if (rightLod>lod) {\r
+        // top                         (the order gets reversed here so the diagonals line up)\r
+        if (topLod > lod) { // if lower LOD\r
+            if (rightLod > lod) {\r
                  // need to flip winding order\r
-                               buffer.put(getWidth()-1);\r
-                buffer.put(getWidth()*lod -1);\r
-                buffer.put(getWidth()-1);\r
-            }\r
-                       int idx = getWidth()-1;\r
-            int it = (getWidth()-1)/topLod; // iterations\r
-            int lodDiff = topLod/lod;\r
-                       for (int i=it; i>0; i--) { // for each lod level of the neighbour\r
-                idx = (i*topLod);\r
-                for (int j=1; j<=lodDiff; j++) { // for each section in that lod level\r
-                    int idxB = lod*getWidth() +(i*topLod) - (j*lod);\r
+                buffer.put(getWidth() - 1);\r
+                buffer.put(getWidth() * lod - 1);\r
+                buffer.put(getWidth() - 1);\r
+            }\r
+            int idx = getWidth() - 1;\r
+            int it = (getWidth() - 1) / topLod; // iterations\r
+            int lodDiff = topLod / lod;\r
+            for (int i = it; i > 0; i--) { // for each lod level of the neighbour\r
+                idx = (i * topLod);\r
+                for (int j = 1; j <= lodDiff; j++) { // for each section in that lod level\r
+                    int idxB = lod * getWidth() + (i * topLod) - (j * lod);\r
  \r
                      if (j == lodDiff && i == 1) {// the last one\r
                          buffer.put(0);\r
                      } else if (j == lodDiff) {\r
                          buffer.put(idxB);\r
-                        buffer.put(idx-topLod);\r
+                        buffer.put(idx - topLod);\r
                      } else {\r
                          buffer.put(idxB);\r
                          buffer.put(idx);\r
                      }\r
                  }\r
              }\r
-               } else {\r
-                       if (rightLod>lod)\r
-                               buffer.put(getWidth()-1);\r
-                       for (int col=getWidth()-1-lod; col>0; col-=lod) {\r
-                               int idx = col + (lod*getWidth());\r
-                               buffer.put(idx);\r
-                               idx = col;\r
-                               buffer.put(idx);\r
-                       }\r
-                       buffer.put(0);\r
-               }\r
-               buffer.put(0);\r
-\r
-               //System.out.println("\nbuffer top: "+(buffer.getCount()-runningBufferCount));\r
-               //runningBufferCount = buffer.getCount();\r
-\r
-               //System.out.println("\nleft:");\r
-\r
-               // left\r
-               if (leftLod>lod) { // if lower LOD\r
-\r
-                       int idx = 0;\r
-            int it = (getWidth()-1)/leftLod; // iterations\r
-            int lodDiff = leftLod/lod;\r
-                       for (int i=0; i<it; i++) { // for each lod level of the neighbour\r
-                idx = getWidth()*(i*leftLod);\r
-                for (int j=1; j<=lodDiff; j++) { // for each section in that lod level\r
-                    int idxB = idx +(getWidth()*(j*lod)) +lod;\r
-\r
-                    if (j == lodDiff && i == it-1) {// the last one\r
-                        buffer.put(getWidth()*getWidth() - getWidth());\r
+        } else {\r
+            if (rightLod > lod) {\r
+                buffer.put(getWidth() - 1);\r
+            }\r
+            for (int col = getWidth() - 1 - lod; col > 0; col -= lod) {\r
+                int idx = col + (lod * getWidth());\r
+                buffer.put(idx);\r
+                idx = col;\r
+                buffer.put(idx);\r
+            }\r
+            buffer.put(0);\r
+        }\r
+        buffer.put(0);\r
+\r
+        //System.out.println("\nbuffer top: "+(buffer.getCount()-runningBufferCount));\r
+        //runningBufferCount = buffer.getCount();\r
+\r
+        //System.out.println("\nleft:");\r
+\r
+        // left\r
+        if (leftLod > lod) { // if lower LOD\r
+\r
+            int idx = 0;\r
+            int it = (getWidth() - 1) / leftLod; // iterations\r
+            int lodDiff = leftLod / lod;\r
+            for (int i = 0; i < it; i++) { // for each lod level of the neighbour\r
+                idx = getWidth() * (i * leftLod);\r
+                for (int j = 1; j <= lodDiff; j++) { // for each section in that lod level\r
+                    int idxB = idx + (getWidth() * (j * lod)) + lod;\r
+\r
+                    if (j == lodDiff && i == it - 1) {// the last one\r
+                        buffer.put(getWidth() * getWidth() - getWidth());\r
                      } else if (j == lodDiff) {\r
                          buffer.put(idxB);\r
-                        buffer.put(idxB-lod);\r
+                        buffer.put(idxB - lod);\r
                      } else {\r
                          buffer.put(idxB);\r
                          buffer.put(idx);\r
@@ -497,135 +503,138 @@ public class LODGeomap extends BufferGeomap {
                  }\r
              }\r
  \r
-               } else {\r
-                               buffer.put(0);\r
-                buffer.put(getWidth()*lod + lod);\r
-                buffer.put(0);\r
-                       for (int row=lod; row<getWidth()-lod; row+=lod) {\r
-                               int idx = row*getWidth();\r
-                               buffer.put(idx);\r
-                               idx = row*getWidth()+lod;\r
-                               buffer.put(idx);\r
-                       }\r
-            buffer.put(getWidth()*(getWidth()-1));\r
-               }\r
-               //buffer.put(getWidth()*(getWidth()-1));\r
-\r
-\r
-               //System.out.println("\nbuffer left: "+(buffer.getCount()-runningBufferCount));\r
-               //runningBufferCount = buffer.getCount();\r
-\r
-               //if (true) return buffer.delegate;\r
-               //System.out.println("\nbottom");\r
-\r
-               // bottom\r
-               if (bottomLod>lod) { // if lower LOD\r
-                       if (leftLod>lod) {\r
-                               buffer.put(getWidth()*(getWidth()-1));\r
-                buffer.put(getWidth()*(getWidth()-lod));\r
-                buffer.put(getWidth()*(getWidth()-1));\r
-            }\r
-\r
-                       int idx = getWidth()*getWidth() - getWidth();\r
-            int it = (getWidth()-1)/bottomLod; // iterations\r
-            int lodDiff = bottomLod/lod;\r
-                       for (int i=0; i<it; i++) { // for each lod level of the neighbour\r
-                idx = getWidth()*getWidth() - getWidth() + (i*bottomLod);\r
-                for (int j=1; j<=lodDiff; j++) { // for each section in that lod level\r
-                    int idxB = idx - (getWidth()*lod) +j*lod;\r
-\r
-                    if (j == lodDiff && i == it-1) {// the last one\r
-                        buffer.put(getWidth()*getWidth()-1);\r
+        } else {\r
+            buffer.put(0);\r
+            buffer.put(getWidth() * lod + lod);\r
+            buffer.put(0);\r
+            for (int row = lod; row < getWidth() - lod; row += lod) {\r
+                int idx = row * getWidth();\r
+                buffer.put(idx);\r
+                idx = row * getWidth() + lod;\r
+                buffer.put(idx);\r
+            }\r
+            buffer.put(getWidth() * (getWidth() - 1));\r
+        }\r
+        //buffer.put(getWidth()*(getWidth()-1));\r
+\r
+\r
+        //System.out.println("\nbuffer left: "+(buffer.getCount()-runningBufferCount));\r
+        //runningBufferCount = buffer.getCount();\r
+\r
+        //if (true) return buffer.delegate;\r
+        //System.out.println("\nbottom");\r
+\r
+        // bottom\r
+        if (bottomLod > lod) { // if lower LOD\r
+            if (leftLod > lod) {\r
+                buffer.put(getWidth() * (getWidth() - 1));\r
+                buffer.put(getWidth() * (getWidth() - lod));\r
+                buffer.put(getWidth() * (getWidth() - 1));\r
+            }\r
+\r
+            int idx = getWidth() * getWidth() - getWidth();\r
+            int it = (getWidth() - 1) / bottomLod; // iterations\r
+            int lodDiff = bottomLod / lod;\r
+            for (int i = 0; i < it; i++) { // for each lod level of the neighbour\r
+                idx = getWidth() * getWidth() - getWidth() + (i * bottomLod);\r
+                for (int j = 1; j <= lodDiff; j++) { // for each section in that lod level\r
+                    int idxB = idx - (getWidth() * lod) + j * lod;\r
+\r
+                    if (j == lodDiff && i == it - 1) {// the last one\r
+                        buffer.put(getWidth() * getWidth() - 1);\r
                      } else if (j == lodDiff) {\r
                          buffer.put(idxB);\r
-                        buffer.put(idx+bottomLod);\r
+                        buffer.put(idx + bottomLod);\r
                      } else {\r
                          buffer.put(idxB);\r
                          buffer.put(idx);\r
                      }\r
                  }\r
              }\r
-               } else {\r
-                       if (leftLod>lod) {\r
-                               buffer.put(getWidth()*(getWidth()-1));\r
-                buffer.put(getWidth()*getWidth() - (getWidth()*lod)+lod);\r
-                buffer.put(getWidth()*(getWidth()-1));\r
-                       }\r
-                       for (int col=lod; col<getWidth()-lod; col+=lod) {\r
-                               int idx = getWidth()*(getWidth()-1-lod) + col; // up\r
-                               buffer.put(idx);\r
-                               idx = getWidth()*(getWidth()-1) + col; // down\r
-                               buffer.put(idx);\r
-                       }\r
-                       //buffer.put(getWidth()*getWidth()-1-lod); // <-- THIS caused holes at the end!\r
-               }\r
-\r
-               buffer.put(getWidth()*getWidth()-1);\r
-\r
-               //System.out.println("\nbuffer bottom: "+(buffer.getCount()-runningBufferCount));\r
-               //runningBufferCount = buffer.getCount();\r
-\r
-               //System.out.println("\nBuffer size: "+buffer.getCount());\r
-\r
-               // fill in the rest of the buffer with degenerates, there should only be a couple\r
-               for (int i=buffer.getCount(); i<numIndexes; i++)\r
-                       buffer.put(getWidth()*getWidth()-1);\r
-\r
-               return buffer.delegate;\r
-       }\r
-\r
-\r
-       /*private int calculateNumIndexesNormal(int lod) {\r
-               int length = getWidth()-1;\r
-               int num = ((length/lod)+1)*((length/lod)+1)*2;\r
-               System.out.println("num: "+num);\r
-               num -= 2*((length/lod)+1);\r
-               System.out.println("num2: "+num);\r
-               // now get the degenerate indexes that exist between strip rows\r
-               num += 2*(((length/lod)+1)-2); // every row except the first and last\r
-               System.out.println("Index buffer size: "+num);\r
-               return num;\r
-       }*/\r
-\r
-       /**\r
-        * calculate how many indexes there will be.\r
-        * This isn't that precise and there might be a couple extra.\r
-        */\r
-       private int calculateNumIndexesLodDiff(int lod) {\r
-               if (lod == 0)\r
+        } else {\r
+            if (leftLod > lod) {\r
+                buffer.put(getWidth() * (getWidth() - 1));\r
+                buffer.put(getWidth() * getWidth() - (getWidth() * lod) + lod);\r
+                buffer.put(getWidth() * (getWidth() - 1));\r
+            }\r
+            for (int col = lod; col < getWidth() - lod; col += lod) {\r
+                int idx = getWidth() * (getWidth() - 1 - lod) + col; // up\r
+                buffer.put(idx);\r
+                idx = getWidth() * (getWidth() - 1) + col; // down\r
+                buffer.put(idx);\r
+            }\r
+            //buffer.put(getWidth()*getWidth()-1-lod); // <-- THIS caused holes at the end!\r
+        }\r
+\r
+        buffer.put(getWidth() * getWidth() - 1);\r
+\r
+        //System.out.println("\nbuffer bottom: "+(buffer.getCount()-runningBufferCount));\r
+        //runningBufferCount = buffer.getCount();\r
+\r
+        //System.out.println("\nBuffer size: "+buffer.getCount());\r
+\r
+        // fill in the rest of the buffer with degenerates, there should only be a couple\r
+        for (int i = buffer.getCount(); i < numIndexes; i++) {\r
+            buffer.put(getWidth() * getWidth() - 1);\r
+        }\r
+\r
+        return buffer.delegate;\r
+    }\r
+\r
+\r
+    /*private int calculateNumIndexesNormal(int lod) {\r
+    int length = getWidth()-1;\r
+    int num = ((length/lod)+1)*((length/lod)+1)*2;\r
+    System.out.println("num: "+num);\r
+    num -= 2*((length/lod)+1);\r
+    System.out.println("num2: "+num);\r
+    // now get the degenerate indexes that exist between strip rows\r
+    num += 2*(((length/lod)+1)-2); // every row except the first and last\r
+    System.out.println("Index buffer size: "+num);\r
+    return num;\r
+    }*/\r
+    /**\r
+     * calculate how many indexes there will be.\r
+     * This isn't that precise and there might be a couple extra.\r
+     */\r
+    private int calculateNumIndexesLodDiff(int lod) {\r
+        if (lod == 0) {\r
              lod = 1;\r
-               int length = getWidth()-1; // make it even for lod calc\r
-               int side = (length/lod)+1 -(2);\r
-               //System.out.println("side: "+side);\r
-               int num = side*side*2;\r
-               //System.out.println("num: "+num);\r
-               num -= 2*side;  // remove one first row and one last row (they are only hit once each)\r
-               //System.out.println("num2: "+num);\r
-               // now get the degenerate indexes that exist between strip rows\r
-               int degenerates = 2*(side-(2)); // every row except the first and last\r
-               num += degenerates;\r
-               //System.out.println("degenerates: "+degenerates);\r
-\r
-               //System.out.println("center, before edges: "+num);\r
-\r
-               num += (getWidth()/lod)*2 *4;\r
-               num++;\r
-\r
-               num+=10;// TODO remove me: extra\r
-               //System.out.println("Index buffer size: "+num);\r
-               return num;\r
-       }\r
+        }\r
+        int length = getWidth() - 1; // make it even for lod calc\r
+        int side = (length / lod) + 1 - (2);\r
+        //System.out.println("side: "+side);\r
+        int num = side * side * 2;\r
+        //System.out.println("num: "+num);\r
+        num -= 2 * side;       // remove one first row and one last row (they are only hit once each)\r
+        //System.out.println("num2: "+num);\r
+        // now get the degenerate indexes that exist between strip rows\r
+        int degenerates = 2 * (side - (2)); // every row except the first and last\r
+        num += degenerates;\r
+        //System.out.println("degenerates: "+degenerates);\r
+\r
+        //System.out.println("center, before edges: "+num);\r
+\r
+        num += (getWidth() / lod) * 2 * 4;\r
+        num++;\r
+\r
+        num += 10;// TODO remove me: extra\r
+        //System.out.println("Index buffer size: "+num);\r
+        return num;\r
+    }\r
  \r
      @Override\r
      public FloatBuffer writeNormalArray(FloatBuffer store, Vector3f scale) {\r
-         if (!isLoaded())\r
+        if (!isLoaded()) {\r
              throw new NullPointerException();\r
+        }\r
  \r
-        if (store!=null){\r
-            if (store.remaining() < getWidth()*getHeight()*3)\r
+        if (store != null) {\r
+            if (store.remaining() < getWidth() * getHeight() * 3) {\r
                  throw new BufferUnderflowException();\r
-        }else{\r
-            store = BufferUtils.createFloatBuffer(getWidth()*getHeight()*3);\r
+            }\r
+        } else {\r
+            store = BufferUtils.createFloatBuffer(getWidth() * getHeight() * 3);\r
          }\r
          store.rewind();\r
  \r
@@ -635,67 +644,67 @@ public class LODGeomap extends BufferGeomap {
          Vector3f topPoint = new Vector3f();\r
          Vector3f bottomPoint = new Vector3f();\r
  \r
-         // calculate normals for each polygon\r
-        for (int r=0; r<getHeight(); r++) {\r
-            for (int c=0; c<getWidth(); c++) {\r
+        // calculate normals for each polygon\r
+        for (int r = 0; r < getHeight(); r++) {\r
+            for (int c = 0; c < getWidth(); c++) {\r
  \r
-                rootPoint.set(c, getValue(c,r), r);\r
+                rootPoint.set(c, getValue(c, r), r);\r
                  Vector3f normal = new Vector3f();\r
  \r
                  if (r == 0) { // first row\r
                      if (c == 0) { // first column\r
-                        rightPoint.set(c+1, getValue(c+1,r), r);\r
-                        bottomPoint.set(c, getValue(c,r+1), r+1);\r
+                        rightPoint.set(c + 1, getValue(c + 1, r), r);\r
+                        bottomPoint.set(c, getValue(c, r + 1), r + 1);\r
                          normal.set(getNormal(bottomPoint, rootPoint, rightPoint));\r
-                    } else if (c == getWidth()-1) { // last column\r
-                        leftPoint.set(c-1, getValue(c-1,r), r);\r
-                        bottomPoint.set(c, getValue(c,r+1), r+1);\r
+                    } else if (c == getWidth() - 1) { // last column\r
+                        leftPoint.set(c - 1, getValue(c - 1, r), r);\r
+                        bottomPoint.set(c, getValue(c, r + 1), r + 1);\r
                          normal.set(getNormal(leftPoint, rootPoint, bottomPoint));\r
                      } else { // all middle columns\r
-                        leftPoint.set(c-1, getValue(c-1,r), r);\r
-                        rightPoint.set(c+1, getValue(c+1,r), r);\r
-                        bottomPoint.set(c, getValue(c,r+1), r+1);\r
+                        leftPoint.set(c - 1, getValue(c - 1, r), r);\r
+                        rightPoint.set(c + 1, getValue(c + 1, r), r);\r
+                        bottomPoint.set(c, getValue(c, r + 1), r + 1);\r
                          Vector3f n1 = getNormal(leftPoint, rootPoint, bottomPoint);\r
                          Vector3f n2 = getNormal(bottomPoint, rootPoint, rightPoint);\r
                          normal.set(n1.add(n2).normalizeLocal());\r
                      }\r
-                } else if (r == getHeight()-1) { // last row\r
+                } else if (r == getHeight() - 1) { // last row\r
                      if (c == 0) { // first column\r
-                        topPoint.set(c, getValue(c,r-1), r-1);\r
-                        rightPoint.set(c+1, getValue(c+1, r), r);\r
+                        topPoint.set(c, getValue(c, r - 1), r - 1);\r
+                        rightPoint.set(c + 1, getValue(c + 1, r), r);\r
                          normal.set(getNormal(rightPoint, rootPoint, topPoint));\r
-                    } else if (c == getWidth()-1) { // last column\r
-                        topPoint.set(c, getValue(c,r-1), r-1);\r
-                        leftPoint.set(c-1, getValue(c-1,r), r);\r
+                    } else if (c == getWidth() - 1) { // last column\r
+                        topPoint.set(c, getValue(c, r - 1), r - 1);\r
+                        leftPoint.set(c - 1, getValue(c - 1, r), r);\r
                          normal.set(getNormal(topPoint, rootPoint, leftPoint));\r
                      } else { // all middle columns\r
-                        topPoint.set(c, getValue(c,r-1), r-1);\r
-                        leftPoint.set(c-1, getValue(c-1,r), r);\r
-                        rightPoint.set(c+1, getValue(c+1,r), r);\r
+                        topPoint.set(c, getValue(c, r - 1), r - 1);\r
+                        leftPoint.set(c - 1, getValue(c - 1, r), r);\r
+                        rightPoint.set(c + 1, getValue(c + 1, r), r);\r
                          Vector3f n1 = getNormal(topPoint, rootPoint, leftPoint);\r
                          Vector3f n2 = getNormal(rightPoint, rootPoint, topPoint);\r
                          normal.set(n1.add(n2).normalizeLocal());\r
                      }\r
                  } else { // all middle rows\r
                      if (c == 0) { // first column\r
-                        topPoint.set(c, getValue(c,r-1), r-1);\r
-                        rightPoint.set(c+1, getValue(c+1,r), r);\r
-                        bottomPoint.set(c, getValue(c,r+1), r+1);\r
+                        topPoint.set(c, getValue(c, r - 1), r - 1);\r
+                        rightPoint.set(c + 1, getValue(c + 1, r), r);\r
+                        bottomPoint.set(c, getValue(c, r + 1), r + 1);\r
                          Vector3f n1 = getNormal(rightPoint, rootPoint, topPoint);\r
                          Vector3f n2 = getNormal(bottomPoint, rootPoint, rightPoint);\r
                          normal.set(n1.add(n2).normalizeLocal());\r
-                    } else if (c == getWidth()-1) { // last column\r
-                        topPoint.set(c, getValue(c,r-1), r-1);\r
-                        leftPoint.set(c-1, getValue(c-1,r), r);\r
-                        bottomPoint.set(c, getValue(c,r+1), r+1);\r
+                    } else if (c == getWidth() - 1) { // last column\r
+                        topPoint.set(c, getValue(c, r - 1), r - 1);\r
+                        leftPoint.set(c - 1, getValue(c - 1, r), r);\r
+                        bottomPoint.set(c, getValue(c, r + 1), r + 1);\r
                          Vector3f n1 = getNormal(topPoint, rootPoint, leftPoint);\r
                          Vector3f n2 = getNormal(leftPoint, rootPoint, bottomPoint);\r
                          normal.set(n1.add(n2).normalizeLocal());\r
                      } else { // all middle columns\r
-                        topPoint.set(c, getValue(c,r-1), r-1);\r
-                        leftPoint.set(c-1, getValue(c-1,r), r);\r
-                        rightPoint.set(c+1, getValue(c+1,r), r);\r
-                        bottomPoint.set(c, getValue(c,r+1), r+1);\r
+                        topPoint.set(c, getValue(c, r - 1), r - 1);\r
+                        leftPoint.set(c - 1, getValue(c - 1, r), r);\r
+                        rightPoint.set(c + 1, getValue(c + 1, r), r);\r
+                        bottomPoint.set(c, getValue(c, r + 1), r + 1);\r
                          Vector3f n1 = getNormal(topPoint, rootPoint, leftPoint);\r
                          Vector3f n2 = getNormal(leftPoint, rootPoint, bottomPoint);\r
                          Vector3f n3 = getNormal(bottomPoint, rootPoint, rightPoint);\r
@@ -704,7 +713,7 @@ public class LODGeomap extends BufferGeomap {
                      }\r
                  }\r
  \r
-                BufferUtils.setInBuffer(normal, store, (r*getWidth()+c)); // save the normal\r
+                BufferUtils.setInBuffer(normal, store, (r * getWidth() + c)); // save the normal\r
  \r
              }\r
          }\r
@@ -714,34 +723,35 @@ public class LODGeomap extends BufferGeomap {
  \r
      private Vector3f getNormal(Vector3f firstPoint, Vector3f rootPoint, Vector3f secondPoint) {\r
          Vector3f normal = new Vector3f();\r
-        normal.set(firstPoint).subtractLocal(rootPoint)\r
-                  .crossLocal(secondPoint.subtract(rootPoint)).normalizeLocal();\r
+        normal.set(firstPoint).subtractLocal(rootPoint).crossLocal(secondPoint.subtract(rootPoint)).normalizeLocal();\r
          return normal;\r
      }\r
  \r
-   \r
-\r
-       /**\r
-        * Keeps a count of the number of indexes, good for debugging\r
-        */\r
-       public class VerboseIntBuffer {\r
-               private IntBuffer delegate;\r
-               int count = 0;\r
-               public VerboseIntBuffer(IntBuffer d) {\r
-                       delegate = d;\r
-               }\r
-               public void put(int value) {\r
-                       try {\r
-                               delegate.put(value);\r
-                               count++;\r
-                       } catch (BufferOverflowException e) {\r
-                               //System.out.println("err buffer size: "+delegate.capacity());\r
-                       }\r
-               }\r
-               public int getCount() {\r
-                       return count;\r
-               }\r
-       }\r
+    /**\r
+     * Keeps a count of the number of indexes, good for debugging\r
+     */\r
+    public class VerboseIntBuffer {\r
+\r
+        private IntBuffer delegate;\r
+        int count = 0;\r
+\r
+        public VerboseIntBuffer(IntBuffer d) {\r
+            delegate = d;\r
+        }\r
+\r
+        public void put(int value) {\r
+            try {\r
+                delegate.put(value);\r
+                count++;\r
+            } catch (BufferOverflowException e) {\r
+                //System.out.println("err buffer size: "+delegate.capacity());\r
+            }\r
+        }\r
+\r
+        public int getCount() {\r
+            return count;\r
+        }\r
+    }\r
  \r
      /**\r
       * Get a representation of the underlying triangle at the given point,\r
@@ -807,12 +817,13 @@ public class LODGeomap extends BufferGeomap {
       * @return\r
       */\r
      protected Triangle[] getGridTrianglesAtPoint(float x, float z) {\r
-        int gridX = (int)x;\r
-        int gridY = (int)z;\r
+        int gridX = (int) x;\r
+        int gridY = (int) z;\r
  \r
-        int index = findClosestHeightIndex(gridX,gridY);\r
-        if (index < 0)\r
+        int index = findClosestHeightIndex(gridX, gridY);\r
+        if (index < 0) {\r
              return null;\r
+        }\r
  \r
          Triangle t = new Triangle(new Vector3f(), new Vector3f(), new Vector3f());\r
          Triangle t2 = new Triangle(new Vector3f(), new Vector3f(), new Vector3f());\r
@@ -823,7 +834,7 @@ public class LODGeomap extends BufferGeomap {
          float h4 = hdata.get(index + width + 1);    // bottom right\r
  \r
  \r
-        if ((gridX == 0 && gridY == 0) || (gridX == width-1 && gridY == width-1)) {\r
+        if ((gridX == 0 && gridY == 0) || (gridX == width - 1 && gridY == width - 1)) {\r
              // top left or bottom right grid point\r
              t.get(0).x = (gridX);\r
              t.get(0).y = (h1);\r
@@ -848,8 +859,7 @@ public class LODGeomap extends BufferGeomap {
              t2.get(2).x = (gridX + 1);\r
              t2.get(2).y = (h2);\r
              t2.get(2).z = (gridY);\r
-        }\r
-        else {\r
+        } else {\r
              // all other grid points\r
              t.get(0).x = (gridX);\r
              t.get(0).y = (h1);\r
@@ -876,9 +886,9 @@ public class LODGeomap extends BufferGeomap {
              t2.get(2).z = (gridY + 1);\r
          }\r
  \r
-        return new Triangle[]{t,t2};\r
+        return new Triangle[]{t, t2};\r
      }\r
-    \r
+\r
      /**\r
       * Get the triangle that the point is on.\r
       * \r
@@ -889,7 +899,7 @@ public class LODGeomap extends BufferGeomap {
      protected Triangle getTriangleAtPoint(float x, float z) {\r
          Triangle[] triangles = getGridTrianglesAtPoint(x, z);\r
          if (triangles == null) {\r
-            System.out.println("x,z: "+x+","+z);\r
+            System.out.println("x,z: " + x + "," + z);\r
              return null;\r
          }\r
          Vector2f point = new Vector2f(x, z);\r
@@ -897,20 +907,21 @@ public class LODGeomap extends BufferGeomap {
          Vector2f t2 = new Vector2f(triangles[0].get2().x, triangles[0].get2().z);\r
          Vector2f t3 = new Vector2f(triangles[0].get3().x, triangles[0].get3().z);\r
  \r
-        if (0 != FastMath.pointInsideTriangle(t1, t2, t3, point))\r
+        if (0 != FastMath.pointInsideTriangle(t1, t2, t3, point)) {\r
              return triangles[0];\r
+        }\r
  \r
          t1.set(triangles[1].get1().x, triangles[1].get1().z);\r
          t1.set(triangles[1].get2().x, triangles[1].get2().z);\r
          t1.set(triangles[1].get3().x, triangles[1].get3().z);\r
  \r
-        if (0 != FastMath.pointInsideTriangle(t1, t2, t3, point))\r
+        if (0 != FastMath.pointInsideTriangle(t1, t2, t3, point)) {\r
              return triangles[1];\r
+        }\r
  \r
          return null;\r
      }\r
  \r
-\r
      protected int findClosestHeightIndex(int x, int z) {\r
  \r
          if (x < 0 || x >= width - 1) {\r
@@ -933,4 +944,3 @@ public class LODGeomap extends BufferGeomap {
          super.read(im);\r
      }\r
  }\r
-\r
diff --git a/engine/src/terrain/com/jme3/terrain/geomipmap/TerrainGrid.java b/engine/src/terrain/com/jme3/terrain/geomipmap/TerrainGrid.java

index 1ea8cb1..2c59731 100644 (file)
--- 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;
diff --git a/engine/src/terrain/com/jme3/terrain/geomipmap/TerrainQuad.java b/engine/src/terrain/com/jme3/terrain/geomipmap/TerrainQuad.java

index fbdb408..089691a 100644 (file)
--- 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() {\r
          public Thread newThread(Runnable r) {\r
              Thread th = new Thread(r);\r
+            th.setName("jME Terrain Thread");\r
              th.setDaemon(true);\r
              return th;\r
          }\r
author	shadowislord <shadowislord@75d07b2b-3a1a-0410-a2c5-0572b91ccdca>
	Sat, 18 Jun 2011 21:05:04 +0000 (21:05 +0000)
committer	shadowislord <shadowislord@75d07b2b-3a1a-0410-a2c5-0572b91ccdca>
	Sat, 18 Jun 2011 21:05:04 +0000 (21:05 +0000)
engine/src/core/com/jme3/scene/CameraNode.java		patch \| blob \| history
engine/src/core/com/jme3/scene/control/package.html	[new file with mode: 0644]	patch \| blob
engine/src/core/com/jme3/scene/debug/Arrow.java		patch \| blob \| history
engine/src/core/com/jme3/scene/debug/Grid.java		patch \| blob \| history
engine/src/core/com/jme3/scene/mesh/IndexBuffer.java		patch \| blob \| history
engine/src/core/com/jme3/scene/mesh/IndexByteBuffer.java		patch \| blob \| history
engine/src/core/com/jme3/scene/mesh/IndexIntBuffer.java		patch \| blob \| history
engine/src/core/com/jme3/scene/mesh/IndexShortBuffer.java		patch \| blob \| history
engine/src/core/com/jme3/scene/mesh/VirtualIndexBuffer.java		patch \| blob \| history
engine/src/core/com/jme3/scene/mesh/WrappedIndexBuffer.java		patch \| blob \| history
engine/src/core/com/jme3/scene/mesh/package.html	[new file with mode: 0644]	patch \| blob
engine/src/core/com/jme3/scene/package.html	[new file with mode: 0644]	patch \| blob
engine/src/core/com/jme3/scene/shape/AbstractBox.java		patch \| blob \| history
engine/src/core/com/jme3/scene/shape/Curve.java		patch \| blob \| history
engine/src/core/com/jme3/scene/shape/Dome.java		patch \| blob \| history
engine/src/core/com/jme3/scene/shape/Line.java		patch \| blob \| history
engine/src/core/com/jme3/scene/shape/PQTorus.java		patch \| blob \| history
engine/src/core/com/jme3/scene/shape/Quad.java		patch \| blob \| history
engine/src/core/com/jme3/scene/shape/Sphere.java		patch \| blob \| history
engine/src/terrain/com/jme3/terrain/MapUtils.java		patch \| blob \| history
engine/src/terrain/com/jme3/terrain/ProgressMonitor.java		patch \| blob \| history
engine/src/terrain/com/jme3/terrain/Terrain.java		patch \| blob \| history
engine/src/terrain/com/jme3/terrain/geomipmap/LODGeomap.java		patch \| blob \| history
engine/src/terrain/com/jme3/terrain/geomipmap/TerrainGrid.java		patch \| blob \| history
engine/src/terrain/com/jme3/terrain/geomipmap/TerrainQuad.java		patch \| blob \| history