sigonasr2/jmonkeyengine
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

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

Browse Source 
* Javadocs for com.jme3.scene.mesh
 * Formatting for com.jme3.terrain classes
 * Terrain updating thread now called "jME3 Terrain Thread"

git-svn-id: https://jmonkeyengine.googlecode.com/svn/trunk@7667 75d07b2b-3a1a-0410-a2c5-0572b91ccdca
This commit is contained in:
sha..rd 2011-06-18 21:05:04 +00:00
parent d62952a16e
commit a6300ba55b
25 changed files with 811 additions and 596 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
engine/src/core/com/jme3/scene/CameraNode.java
View File

@ -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() {
}

17
engine/src/core/com/jme3/scene/control/package.html Normal file
View File

@ -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>

32
engine/src/core/com/jme3/scene/debug/Arrow.java
View File

@ -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();

12
engine/src/core/com/jme3/scene/debug/Grid.java
View File

@ -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();
}
}

27
engine/src/core/com/jme3/scene/mesh/IndexBuffer.java
View File

@ -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();
}

1
engine/src/core/com/jme3/scene/mesh/IndexByteBuffer.java
View File

@ -36,6 +36,7 @@ import java.nio.Buffer;
import java.nio.ByteBuffer;
/**
* IndexBuffer implementation for {@link ByteBuffer}s.
*
* @author lex
*/

1
engine/src/core/com/jme3/scene/mesh/IndexIntBuffer.java
View File

@ -36,6 +36,7 @@ import java.nio.Buffer;
import java.nio.IntBuffer;
/**
* IndexBuffer implementation for {@link IntBuffer}s.
*
* @author lex
*/

1
engine/src/core/com/jme3/scene/mesh/IndexShortBuffer.java
View File

@ -36,6 +36,7 @@ import java.nio.Buffer;
import java.nio.ShortBuffer;
/**
* IndexBuffer implementation for {@link ShortBuffer}s.
*
* @author lex
*/

16
engine/src/core/com/jme3/scene/mesh/VirtualIndexBuffer.java
View File

@ -3,6 +3,22 @@ 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;

9
engine/src/core/com/jme3/scene/mesh/WrappedIndexBuffer.java
View File

@ -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
*/

25
engine/src/core/com/jme3/scene/mesh/package.html Normal file
View File

@ -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>

26
engine/src/core/com/jme3/scene/package.html Normal file
View File

@ -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>

22
engine/src/core/com/jme3/scene/shape/AbstractBox.java
View File

@ -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);

14
engine/src/core/com/jme3/scene/shape/Curve.java
View File

@ -39,6 +39,10 @@ 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
*/
@ -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
*/

23
engine/src/core/com/jme3/scene/shape/Dome.java
View File

@ -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);

1
engine/src/core/com/jme3/scene/shape/Line.java
View File

@ -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;

1
engine/src/core/com/jme3/scene/shape/PQTorus.java
View File

@ -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;
/**

28
engine/src/core/com/jme3/scene/shape/Quad.java
View File

@ -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);
}

13
engine/src/core/com/jme3/scene/shape/Sphere.java
View File

@ -58,11 +58,16 @@ import java.nio.ShortBuffer;
public class Sphere extends Mesh {
public enum TextureMode {
/** Wrap texture radially and along z-axis */
/**
* Wrap texture radially and along z-axis
*/
Original,
/** Wrap texure radially, but spherically project along z-axis */
/**
* Wrap texure radially, but spherically project along z-axis
*/
Projected,
/** Apply texture to each pole. Eliminates polar distortion,
/**
* Apply texture to each pole. Eliminates polar distortion,
* but mirrors the texture across the equator
*/
Polar
@ -86,7 +91,7 @@ public class Sphere extends Mesh {
protected TextureMode textureMode = TextureMode.Original;
/**
* Empty constructor for serialization only, do not use.
* Serialization only. Do not use.
*/
public Sphere(){
}

5
engine/src/terrain/com/jme3/terrain/MapUtils.java
View File

@ -4,6 +4,7 @@ import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.nio.FloatBuffer;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.imageio.ImageIO;
@ -29,7 +30,7 @@ public class MapUtils {
for (int y = 0; y < size; y++) {
for (int x = 0; x < size; x++) {
short c = (short) (ShaderUtils.clamp(buff.get(), 0, 1) * 65532);
retval.getRaster().setDataElements(x, y, new short[] { c });
retval.getRaster().setDataElements(x, y, new short[]{c});
}
}
return retval;
@ -54,7 +55,7 @@ public class MapUtils {
public static void saveImage(BufferedImage im, File file) {
try {
ImageIO.write(im, "PNG", file);
Logger.getLogger(MapUtils.class.getCanonicalName()).info("Saved image as : " + file.getAbsolutePath());
Logger.getLogger(MapUtils.class.getCanonicalName()).log(Level.INFO, "Saved image as : {0}", file.getAbsolutePath());
} catch (IOException e) {
e.printStackTrace();
}

1
engine/src/terrain/com/jme3/terrain/ProgressMonitor.java
View File

@ -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;
/**

3
engine/src/terrain/com/jme3/terrain/Terrain.java
View File

@ -29,7 +29,6 @@
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.jme3.terrain;
import com.jme3.material.Material;
@ -162,7 +161,6 @@ public interface Terrain {
*/
public void generateEntropy(ProgressMonitor monitor);
/**
* Returns the material that this terrain uses.
* This does not necessarily have to guarantee the material
@ -195,5 +193,4 @@ public interface Terrain {
* texture scales.
*/
public float getTextureCoordinateScale();
}

476
engine/src/terrain/com/jme3/terrain/geomipmap/LODGeomap.java
View File

@ -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.geomipmap;
import com.jme3.export.InputCapsule;
@ -67,17 +66,18 @@ import java.io.IOException;
*/
public class LODGeomap extends BufferGeomap {
public LODGeomap() {}
public LODGeomap() {
}
public LODGeomap(int size, FloatBuffer heightMap) {
super(heightMap, null, size, size, 1);
}
public Mesh createMesh(Vector3f scale, Vector2f tcScale, Vector2f tcOffset, float offsetAmount, int totalSize, boolean center) {
return this.createMesh(scale, tcScale, tcOffset, offsetAmount, totalSize, center, 1, false,false,false,false);
return this.createMesh(scale, tcScale, tcOffset, offsetAmount, totalSize, center, 1, false, false, false, false);
}
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){
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) {
FloatBuffer pb = writeVertexArray(null, scale, center);
FloatBuffer tb = writeTexCoordArray(null, tcOffset, tcScale, offsetAmount, totalSize);
FloatBuffer nb = writeNormalArray(null, scale);
@ -93,44 +93,45 @@ public class LODGeomap extends BufferGeomap {
return m;
}
protected void removeNormalBuffer() {
ndata = null;
}
public FloatBuffer writeTexCoordArray(FloatBuffer store, Vector2f offset, Vector2f scale, float offsetAmount, int totalSize){
if (store!=null){
if (store.remaining() < getWidth()*getHeight()*2)
public FloatBuffer writeTexCoordArray(FloatBuffer store, Vector2f offset, Vector2f scale, float offsetAmount, int totalSize) {
if (store != null) {
if (store.remaining() < getWidth() * getHeight() * 2) {
throw new BufferUnderflowException();
}else{
store = BufferUtils.createFloatBuffer(getWidth()*getHeight()*2);
}
} else {
store = BufferUtils.createFloatBuffer(getWidth() * getHeight() * 2);
}
if (offset == null)
if (offset == null) {
offset = new Vector2f();
}
Vector2f tcStore = new Vector2f();
for (int y = 0; y < getHeight(); y++){
for (int y = 0; y < getHeight(); y++) {
for (int x = 0; x < getWidth(); x++){
getUV(x,y,tcStore, offset, offsetAmount, totalSize);
for (int x = 0; x < getWidth(); x++) {
getUV(x, y, tcStore, offset, offsetAmount, totalSize);
float tx = tcStore.x * scale.x;
float ty = tcStore.y * scale.y;
store.put( tx );
store.put( ty );
store.put(tx);
store.put(ty);
}
}
return store;
}
public Vector2f getUV(int x, int y, Vector2f store, Vector2f offset, float offsetAmount, int totalSize){
public Vector2f getUV(int x, int y, Vector2f store, Vector2f offset, float offsetAmount, int totalSize) {
float offsetX = offset.x + (offsetAmount * 1.0f);//stepScale.x);
float offsetY = offset.y + (offsetAmount * 1.0f);//stepScale.z);
store.set( ( ((float)x)+offsetX) / (float)totalSize, // calculates percentage of texture here
( ((float)y)+offsetY) / (float)totalSize );
store.set((((float) x) + offsetX) / (float) totalSize, // calculates percentage of texture here
(((float) y) + offsetY) / (float) totalSize);
return store;
}
@ -146,33 +147,34 @@ public class LODGeomap extends BufferGeomap {
* @param bottomLod LOD of the bottom neighbour
* @return the LOD-ified index buffer
*/
public IntBuffer writeIndexArrayLodDiff(IntBuffer store, int lod, boolean rightLod, boolean topLod, boolean leftLod, boolean bottomLod){
public IntBuffer writeIndexArrayLodDiff(IntBuffer store, int lod, boolean rightLod, boolean topLod, boolean leftLod, boolean bottomLod) {
IntBuffer buffer2 = store;
int numIndexes = calculateNumIndexesLodDiff(lod);
if (store == null)
if (store == null) {
buffer2 = BufferUtils.createIntBuffer(numIndexes);
}
VerboseIntBuffer buffer = new VerboseIntBuffer(buffer2);
// generate center squares minus the edges
//System.out.println("for (x="+lod+"; x<"+(getWidth()-(2*lod))+"; x+="+lod+")");
//System.out.println(" for (z="+lod+"; z<"+(getWidth()-(1*lod))+"; z+="+lod+")");
for (int r=lod; r<getWidth()-(2*lod); r+=lod) { // row
int rowIdx = r*getWidth();
int nextRowIdx = (r+1*lod)*getWidth();
for (int c=lod; c<getWidth()-(1*lod); c+=lod) { // column
int idx = rowIdx+c;
for (int r = lod; r < getWidth() - (2 * lod); r += lod) { // row
int rowIdx = r * getWidth();
int nextRowIdx = (r + 1 * lod) * getWidth();
for (int c = lod; c < getWidth() - (1 * lod); c += lod) { // column
int idx = rowIdx + c;
buffer.put(idx);
idx = nextRowIdx+c;
idx = nextRowIdx + c;
buffer.put(idx);
}
// add degenerate triangles
if (r < getWidth()-(3*lod)) {
int idx = nextRowIdx+getWidth()-(1*lod)-1;
if (r < getWidth() - (3 * lod)) {
int idx = nextRowIdx + getWidth() - (1 * lod) - 1;
buffer.put(idx);
idx = nextRowIdx+(1*lod); // inset by 1
idx = nextRowIdx + (1 * lod); // inset by 1
buffer.put(idx);
//System.out.println("");
}
@ -184,36 +186,35 @@ public class LODGeomap extends BufferGeomap {
// right
int br = getWidth()*(getWidth()-lod)-1-lod;
int br = getWidth() * (getWidth() - lod) - 1 - lod;
buffer.put(br); // bottom right -1
int corner = getWidth()*getWidth()-1;
int corner = getWidth() * getWidth() - 1;
buffer.put(corner); // bottom right corner
if (rightLod) { // if lower LOD
for (int row=getWidth()-lod; row>=1+lod; row-=2*lod) {
int idx = (row)*getWidth()-1-lod;
for (int row = getWidth() - lod; row >= 1 + lod; row -= 2 * lod) {
int idx = (row) * getWidth() - 1 - lod;
buffer.put(idx);
idx = (row-lod)*getWidth()-1;
idx = (row - lod) * getWidth() - 1;
buffer.put(idx);
if (row > lod+1) { //if not the last one
idx = (row-lod)*getWidth()-1-lod;
if (row > lod + 1) { //if not the last one
idx = (row - lod) * getWidth() - 1 - lod;
buffer.put(idx);
idx = (row-lod)*getWidth()-1;
idx = (row - lod) * getWidth() - 1;
buffer.put(idx);
} else {
}
}
} else {
buffer.put(corner);//br+1);//degenerate to flip winding order
for (int row=getWidth()-lod; row>lod; row-=lod) {
int idx = row*getWidth()-1; // mult to get row
for (int row = getWidth() - lod; row > lod; row -= lod) {
int idx = row * getWidth() - 1; // mult to get row
buffer.put(idx);
buffer.put(idx-lod);
buffer.put(idx - lod);
}
}
buffer.put(getWidth()-1);
buffer.put(getWidth() - 1);
//System.out.println("\nbuffer right: "+(buffer.getCount()-runningBufferCount));
@ -224,27 +225,28 @@ public class LODGeomap extends BufferGeomap {
// top (the order gets reversed here so the diagonals line up)
if (topLod) { // if lower LOD
if (rightLod)
buffer.put(getWidth()-1);
for (int col=getWidth()-1; col>=lod; col-=2*lod) {
int idx = (lod*getWidth())+col-lod; // next row
if (rightLod) {
buffer.put(getWidth() - 1);
}
for (int col = getWidth() - 1; col >= lod; col -= 2 * lod) {
int idx = (lod * getWidth()) + col - lod; // next row
buffer.put(idx);
idx = col-2*lod;
idx = col - 2 * lod;
buffer.put(idx);
if (col > lod*2) { //if not the last one
idx = (lod*getWidth())+col-2*lod;
if (col > lod * 2) { //if not the last one
idx = (lod * getWidth()) + col - 2 * lod;
buffer.put(idx);
idx = col-2*lod;
idx = col - 2 * lod;
buffer.put(idx);
} else {
}
}
} else {
if (rightLod)
buffer.put(getWidth()-1);
for (int col=getWidth()-1-lod; col>0; col-=lod) {
int idx = col + (lod*getWidth());
if (rightLod) {
buffer.put(getWidth() - 1);
}
for (int col = getWidth() - 1 - lod; col > 0; col -= lod) {
int idx = col + (lod * getWidth());
buffer.put(idx);
idx = col;
buffer.put(idx);
@ -260,36 +262,37 @@ public class LODGeomap extends BufferGeomap {
// left
if (leftLod) { // if lower LOD
if (topLod)
if (topLod) {
buffer.put(0);
for (int row=0; row<getWidth()-lod; row+=2*lod) {
int idx = (row+lod)*getWidth()+lod;
}
for (int row = 0; row < getWidth() - lod; row += 2 * lod) {
int idx = (row + lod) * getWidth() + lod;
buffer.put(idx);
idx = (row+2*lod)*getWidth();
idx = (row + 2 * lod) * getWidth();
buffer.put(idx);
if (row < getWidth()-lod-2-1) { //if not the last one
idx = (row+2*lod)*getWidth()+lod;
if (row < getWidth() - lod - 2 - 1) { //if not the last one
idx = (row + 2 * lod) * getWidth() + lod;
buffer.put(idx);
idx = (row+2*lod)*getWidth();
idx = (row + 2 * lod) * getWidth();
buffer.put(idx);
} else {
}
}
} else {
if (!topLod)
if (!topLod) {
buffer.put(0);
}
//buffer.put(getWidth()+1); // degenerate
//buffer.put(0); // degenerate winding-flip
for (int row=lod; row<getWidth()-lod; row+=lod) {
int idx = row*getWidth();
for (int row = lod; row < getWidth() - lod; row += lod) {
int idx = row * getWidth();
buffer.put(idx);
idx = row*getWidth()+lod;
idx = row * getWidth() + lod;
buffer.put(idx);
}
}
buffer.put(getWidth()*(getWidth()-1));
buffer.put(getWidth() * (getWidth() - 1));
//System.out.println("\nbuffer left: "+(buffer.getCount()-runningBufferCount));
@ -300,39 +303,39 @@ public class LODGeomap extends BufferGeomap {
// bottom
if (bottomLod) { // if lower LOD
if (leftLod)
buffer.put(getWidth()*(getWidth()-1));
if (leftLod) {
buffer.put(getWidth() * (getWidth() - 1));
}
// there was a slight bug here when really high LOD near maxLod
// far right has extra index one row up and all the way to the right, need to skip last index entered
// seemed to be fixed by making "getWidth()-1-2-lod" this: "getWidth()-1-2*lod", which seems more correct
for (int col=0; col<getWidth()-lod; col+=2*lod) {
int idx = getWidth()*(getWidth()-1-lod)+col+lod;
for (int col = 0; col < getWidth() - lod; col += 2 * lod) {
int idx = getWidth() * (getWidth() - 1 - lod) + col + lod;
buffer.put(idx);
idx = getWidth()*(getWidth()-1)+col+2*lod;
idx = getWidth() * (getWidth() - 1) + col + 2 * lod;
buffer.put(idx);
if (col < getWidth()-1-2*lod) { //if not the last one
idx = getWidth()*(getWidth()-1-lod)+col+2*lod;
if (col < getWidth() - 1 - 2 * lod) { //if not the last one
idx = getWidth() * (getWidth() - 1 - lod) + col + 2 * lod;
buffer.put(idx);
idx = getWidth()*(getWidth()-1)+col+2*lod;
idx = getWidth() * (getWidth() - 1) + col + 2 * lod;
buffer.put(idx);
} else {
}
}
} else {
if (leftLod) {
buffer.put(getWidth()*(getWidth()-1));
buffer.put(getWidth() * (getWidth() - 1));
}
for (int col=lod; col<getWidth()-lod; col+=lod) {
int idx = getWidth()*(getWidth()-1-lod) + col; // up
for (int col = lod; col < getWidth() - lod; col += lod) {
int idx = getWidth() * (getWidth() - 1 - lod) + col; // up
buffer.put(idx);
idx = getWidth()*(getWidth()-1) + col; // down
idx = getWidth() * (getWidth() - 1) + col; // down
buffer.put(idx);
}
//buffer.put(getWidth()*getWidth()-1-lod); // <-- THIS caused holes at the end!
}
buffer.put(getWidth()*getWidth()-1);
buffer.put(getWidth() * getWidth() - 1);
//System.out.println("\nbuffer bottom: "+(buffer.getCount()-runningBufferCount));
//runningBufferCount = buffer.getCount();
@ -340,39 +343,41 @@ public class LODGeomap extends BufferGeomap {
//System.out.println("\nBuffer size: "+buffer.getCount());
// fill in the rest of the buffer with degenerates, there should only be a couple
for (int i=buffer.getCount(); i<numIndexes; i++)
buffer.put(getWidth()*getWidth()-1);
for (int i = buffer.getCount(); i < numIndexes; i++) {
buffer.put(getWidth() * getWidth() - 1);
}
return buffer.delegate;
}
public IntBuffer writeIndexArrayLodVariable(IntBuffer store, int lod, int rightLod, int topLod, int leftLod, int bottomLod){
public IntBuffer writeIndexArrayLodVariable(IntBuffer store, int lod, int rightLod, int topLod, int leftLod, int bottomLod) {
IntBuffer buffer2 = store;
int numIndexes = calculateNumIndexesLodDiff(lod);
if (store == null)
if (store == null) {
buffer2 = BufferUtils.createIntBuffer(numIndexes);
}
VerboseIntBuffer buffer = new VerboseIntBuffer(buffer2);
// generate center squares minus the edges
//System.out.println("for (x="+lod+"; x<"+(getWidth()-(2*lod))+"; x+="+lod+")");
//System.out.println(" for (z="+lod+"; z<"+(getWidth()-(1*lod))+"; z+="+lod+")");
for (int r=lod; r<getWidth()-(2*lod); r+=lod) { // row
int rowIdx = r*getWidth();
int nextRowIdx = (r+1*lod)*getWidth();
for (int c=lod; c<getWidth()-(1*lod); c+=lod) { // column
int idx = rowIdx+c;
for (int r = lod; r < getWidth() - (2 * lod); r += lod) { // row
int rowIdx = r * getWidth();
int nextRowIdx = (r + 1 * lod) * getWidth();
for (int c = lod; c < getWidth() - (1 * lod); c += lod) { // column
int idx = rowIdx + c;
buffer.put(idx);
idx = nextRowIdx+c;
idx = nextRowIdx + c;
buffer.put(idx);
}
// add degenerate triangles
if (r < getWidth()-(3*lod)) {
int idx = nextRowIdx+getWidth()-(1*lod)-1;
if (r < getWidth() - (3 * lod)) {
int idx = nextRowIdx + getWidth() - (1 * lod) - 1;
buffer.put(idx);
idx = nextRowIdx+(1*lod); // inset by 1
idx = nextRowIdx + (1 * lod); // inset by 1
buffer.put(idx);
//System.out.println("");
}
@ -384,24 +389,24 @@ public class LODGeomap extends BufferGeomap {
// right
int br = getWidth()*(getWidth()-lod)-1-lod;
int br = getWidth() * (getWidth() - lod) - 1 - lod;
buffer.put(br); // bottom right -1
int corner = getWidth()*getWidth()-1;
int corner = getWidth() * getWidth() - 1;
buffer.put(corner); // bottom right corner
if (rightLod>lod) { // if lower LOD
if (rightLod > lod) { // if lower LOD
int idx = corner;
int it = (getWidth()-1)/rightLod; // iterations
int lodDiff = rightLod/lod;
for (int i=it; i>0; i--) { // for each lod level of the neighbour
idx = getWidth()*(i*rightLod+1)-1;
for (int j=1; j<=lodDiff; j++) { // for each section in that lod level
int idxB = idx - (getWidth()*(j*lod)) - lod;
int it = (getWidth() - 1) / rightLod; // iterations
int lodDiff = rightLod / lod;
for (int i = it; i > 0; i--) { // for each lod level of the neighbour
idx = getWidth() * (i * rightLod + 1) - 1;
for (int j = 1; j <= lodDiff; j++) { // for each section in that lod level
int idxB = idx - (getWidth() * (j * lod)) - lod;
if (j == lodDiff && i == 1) {// the last one
buffer.put(getWidth()-1);
buffer.put(getWidth() - 1);
} else if (j == lodDiff) {
buffer.put(idxB);
buffer.put(idxB+lod);
buffer.put(idxB + lod);
} else {
buffer.put(idxB);
buffer.put(idx);
@ -409,17 +414,17 @@ public class LODGeomap extends BufferGeomap {
}
}
// reset winding order
buffer.put(getWidth()*(lod+1)-lod-1); // top-right +1row
buffer.put(getWidth()-1);// top-right
buffer.put(getWidth() * (lod + 1) - lod - 1); // top-right +1row
buffer.put(getWidth() - 1);// top-right
} else {
buffer.put(corner);//br+1);//degenerate to flip winding order
for (int row=getWidth()-lod; row>lod; row-=lod) {
int idx = row*getWidth()-1; // mult to get row
for (int row = getWidth() - lod; row > lod; row -= lod) {
int idx = row * getWidth() - 1; // mult to get row
buffer.put(idx);
buffer.put(idx-lod);
buffer.put(idx - lod);
}
buffer.put(getWidth()-1);
buffer.put(getWidth() - 1);
}
@ -430,26 +435,26 @@ public class LODGeomap extends BufferGeomap {
//System.out.println("\ntop:");
// top (the order gets reversed here so the diagonals line up)
if (topLod>lod) { // if lower LOD
if (rightLod>lod) {
if (topLod > lod) { // if lower LOD
if (rightLod > lod) {
// need to flip winding order
buffer.put(getWidth()-1);
buffer.put(getWidth()*lod -1);
buffer.put(getWidth()-1);
buffer.put(getWidth() - 1);
buffer.put(getWidth() * lod - 1);
buffer.put(getWidth() - 1);
}
int idx = getWidth()-1;
int it = (getWidth()-1)/topLod; // iterations
int lodDiff = topLod/lod;
for (int i=it; i>0; i--) { // for each lod level of the neighbour
idx = (i*topLod);
for (int j=1; j<=lodDiff; j++) { // for each section in that lod level
int idxB = lod*getWidth() +(i*topLod) - (j*lod);
int idx = getWidth() - 1;
int it = (getWidth() - 1) / topLod; // iterations
int lodDiff = topLod / lod;
for (int i = it; i > 0; i--) { // for each lod level of the neighbour
idx = (i * topLod);
for (int j = 1; j <= lodDiff; j++) { // for each section in that lod level
int idxB = lod * getWidth() + (i * topLod) - (j * lod);
if (j == lodDiff && i == 1) {// the last one
buffer.put(0);
} else if (j == lodDiff) {
buffer.put(idxB);
buffer.put(idx-topLod);
buffer.put(idx - topLod);
} else {
buffer.put(idxB);
buffer.put(idx);
@ -457,10 +462,11 @@ public class LODGeomap extends BufferGeomap {
}
}
} else {
if (rightLod>lod)
buffer.put(getWidth()-1);
for (int col=getWidth()-1-lod; col>0; col-=lod) {
int idx = col + (lod*getWidth());
if (rightLod > lod) {
buffer.put(getWidth() - 1);
}
for (int col = getWidth() - 1 - lod; col > 0; col -= lod) {
int idx = col + (lod * getWidth());
buffer.put(idx);
idx = col;
buffer.put(idx);
@ -475,21 +481,21 @@ public class LODGeomap extends BufferGeomap {
//System.out.println("\nleft:");
// left
if (leftLod>lod) { // if lower LOD
if (leftLod > lod) { // if lower LOD
int idx = 0;
int it = (getWidth()-1)/leftLod; // iterations
int lodDiff = leftLod/lod;
for (int i=0; i<it; i++) { // for each lod level of the neighbour
idx = getWidth()*(i*leftLod);
for (int j=1; j<=lodDiff; j++) { // for each section in that lod level
int idxB = idx +(getWidth()*(j*lod)) +lod;
int it = (getWidth() - 1) / leftLod; // iterations
int lodDiff = leftLod / lod;
for (int i = 0; i < it; i++) { // for each lod level of the neighbour
idx = getWidth() * (i * leftLod);
for (int j = 1; j <= lodDiff; j++) { // for each section in that lod level
int idxB = idx + (getWidth() * (j * lod)) + lod;
if (j == lodDiff && i == it-1) {// the last one
buffer.put(getWidth()*getWidth() - getWidth());
if (j == lodDiff && i == it - 1) {// the last one
buffer.put(getWidth() * getWidth() - getWidth());
} else if (j == lodDiff) {
buffer.put(idxB);
buffer.put(idxB-lod);
buffer.put(idxB - lod);
} else {
buffer.put(idxB);
buffer.put(idx);
@ -499,15 +505,15 @@ public class LODGeomap extends BufferGeomap {
} else {
buffer.put(0);
buffer.put(getWidth()*lod + lod);
buffer.put(getWidth() * lod + lod);
buffer.put(0);
for (int row=lod; row<getWidth()-lod; row+=lod) {
int idx = row*getWidth();
for (int row = lod; row < getWidth() - lod; row += lod) {
int idx = row * getWidth();
buffer.put(idx);
idx = row*getWidth()+lod;
idx = row * getWidth() + lod;
buffer.put(idx);
}
buffer.put(getWidth()*(getWidth()-1));
buffer.put(getWidth() * (getWidth() - 1));
}
//buffer.put(getWidth()*(getWidth()-1));
@ -519,26 +525,26 @@ public class LODGeomap extends BufferGeomap {
//System.out.println("\nbottom");
// bottom
if (bottomLod>lod) { // if lower LOD
if (leftLod>lod) {
buffer.put(getWidth()*(getWidth()-1));
buffer.put(getWidth()*(getWidth()-lod));
buffer.put(getWidth()*(getWidth()-1));
if (bottomLod > lod) { // if lower LOD
if (leftLod > lod) {
buffer.put(getWidth() * (getWidth() - 1));
buffer.put(getWidth() * (getWidth() - lod));
buffer.put(getWidth() * (getWidth() - 1));
}
int idx = getWidth()*getWidth() - getWidth();
int it = (getWidth()-1)/bottomLod; // iterations
int lodDiff = bottomLod/lod;
for (int i=0; i<it; i++) { // for each lod level of the neighbour
idx = getWidth()*getWidth() - getWidth() + (i*bottomLod);
for (int j=1; j<=lodDiff; j++) { // for each section in that lod level
int idxB = idx - (getWidth()*lod) +j*lod;
int idx = getWidth() * getWidth() - getWidth();
int it = (getWidth() - 1) / bottomLod; // iterations
int lodDiff = bottomLod / lod;
for (int i = 0; i < it; i++) { // for each lod level of the neighbour
idx = getWidth() * getWidth() - getWidth() + (i * bottomLod);
for (int j = 1; j <= lodDiff; j++) { // for each section in that lod level
int idxB = idx - (getWidth() * lod) + j * lod;
if (j == lodDiff && i == it-1) {// the last one
buffer.put(getWidth()*getWidth()-1);
if (j == lodDiff && i == it - 1) {// the last one
buffer.put(getWidth() * getWidth() - 1);
} else if (j == lodDiff) {
buffer.put(idxB);
buffer.put(idx+bottomLod);
buffer.put(idx + bottomLod);
} else {
buffer.put(idxB);
buffer.put(idx);
@ -546,21 +552,21 @@ public class LODGeomap extends BufferGeomap {
}
}
} else {
if (leftLod>lod) {
buffer.put(getWidth()*(getWidth()-1));
buffer.put(getWidth()*getWidth() - (getWidth()*lod)+lod);
buffer.put(getWidth()*(getWidth()-1));
if (leftLod > lod) {
buffer.put(getWidth() * (getWidth() - 1));
buffer.put(getWidth() * getWidth() - (getWidth() * lod) + lod);
buffer.put(getWidth() * (getWidth() - 1));
}
for (int col=lod; col<getWidth()-lod; col+=lod) {
int idx = getWidth()*(getWidth()-1-lod) + col; // up
for (int col = lod; col < getWidth() - lod; col += lod) {
int idx = getWidth() * (getWidth() - 1 - lod) + col; // up
buffer.put(idx);
idx = getWidth()*(getWidth()-1) + col; // down
idx = getWidth() * (getWidth() - 1) + col; // down
buffer.put(idx);
}
//buffer.put(getWidth()*getWidth()-1-lod); // <-- THIS caused holes at the end!
}
buffer.put(getWidth()*getWidth()-1);
buffer.put(getWidth() * getWidth() - 1);
//System.out.println("\nbuffer bottom: "+(buffer.getCount()-runningBufferCount));
//runningBufferCount = buffer.getCount();
@ -568,8 +574,9 @@ public class LODGeomap extends BufferGeomap {
//System.out.println("\nBuffer size: "+buffer.getCount());
// fill in the rest of the buffer with degenerates, there should only be a couple
for (int i=buffer.getCount(); i<numIndexes; i++)
buffer.put(getWidth()*getWidth()-1);
for (int i = buffer.getCount(); i < numIndexes; i++) {
buffer.put(getWidth() * getWidth() - 1);
}
return buffer.delegate;
}
@ -586,46 +593,48 @@ public class LODGeomap extends BufferGeomap {
System.out.println("Index buffer size: "+num);
return num;
}*/
/**
* calculate how many indexes there will be.
* This isn't that precise and there might be a couple extra.
*/
private int calculateNumIndexesLodDiff(int lod) {
if (lod == 0)
if (lod == 0) {
lod = 1;
int length = getWidth()-1; // make it even for lod calc
int side = (length/lod)+1 -(2);
}
int length = getWidth() - 1; // make it even for lod calc
int side = (length / lod) + 1 - (2);
//System.out.println("side: "+side);
int num = side*side*2;
int num = side * side * 2;
//System.out.println("num: "+num);
num -= 2*side; // remove one first row and one last row (they are only hit once each)
num -= 2 * side; // remove one first row and one last row (they are only hit once each)
//System.out.println("num2: "+num);
// now get the degenerate indexes that exist between strip rows
int degenerates = 2*(side-(2)); // every row except the first and last
int degenerates = 2 * (side - (2)); // every row except the first and last
num += degenerates;
//System.out.println("degenerates: "+degenerates);
//System.out.println("center, before edges: "+num);
num += (getWidth()/lod)*2 *4;
num += (getWidth() / lod) * 2 * 4;
num++;
num+=10;// TODO remove me: extra
num += 10;// TODO remove me: extra
//System.out.println("Index buffer size: "+num);
return num;
}
@Override
public FloatBuffer writeNormalArray(FloatBuffer store, Vector3f scale) {
if (!isLoaded())
if (!isLoaded()) {
throw new NullPointerException();
}
if (store!=null){
if (store.remaining() < getWidth()*getHeight()*3)
if (store != null) {
if (store.remaining() < getWidth() * getHeight() * 3) {
throw new BufferUnderflowException();
}else{
store = BufferUtils.createFloatBuffer(getWidth()*getHeight()*3);
}
} else {
store = BufferUtils.createFloatBuffer(getWidth() * getHeight() * 3);
}
store.rewind();
@ -636,66 +645,66 @@ public class LODGeomap extends BufferGeomap {
Vector3f bottomPoint = new Vector3f();
// calculate normals for each polygon
for (int r=0; r<getHeight(); r++) {
for (int c=0; c<getWidth(); c++) {
for (int r = 0; r < getHeight(); r++) {
for (int c = 0; c < getWidth(); c++) {
rootPoint.set(c, getValue(c,r), r);
rootPoint.set(c, getValue(c, r), r);
Vector3f normal = new Vector3f();
if (r == 0) { // first row
if (c == 0) { // first column
rightPoint.set(c+1, getValue(c+1,r), r);
bottomPoint.set(c, getValue(c,r+1), r+1);
rightPoint.set(c + 1, getValue(c + 1, r), r);
bottomPoint.set(c, getValue(c, r + 1), r + 1);
normal.set(getNormal(bottomPoint, rootPoint, rightPoint));
} else if (c == getWidth()-1) { // last column
leftPoint.set(c-1, getValue(c-1,r), r);
bottomPoint.set(c, getValue(c,r+1), r+1);
} else if (c == getWidth() - 1) { // last column
leftPoint.set(c - 1, getValue(c - 1, r), r);
bottomPoint.set(c, getValue(c, r + 1), r + 1);
normal.set(getNormal(leftPoint, rootPoint, bottomPoint));
} else { // all middle columns
leftPoint.set(c-1, getValue(c-1,r), r);
rightPoint.set(c+1, getValue(c+1,r), r);
bottomPoint.set(c, getValue(c,r+1), r+1);
leftPoint.set(c - 1, getValue(c - 1, r), r);
rightPoint.set(c + 1, getValue(c + 1, r), r);
bottomPoint.set(c, getValue(c, r + 1), r + 1);
Vector3f n1 = getNormal(leftPoint, rootPoint, bottomPoint);
Vector3f n2 = getNormal(bottomPoint, rootPoint, rightPoint);
normal.set(n1.add(n2).normalizeLocal());
}
} else if (r == getHeight()-1) { // last row
} else if (r == getHeight() - 1) { // last row
if (c == 0) { // first column
topPoint.set(c, getValue(c,r-1), r-1);
rightPoint.set(c+1, getValue(c+1, r), r);
topPoint.set(c, getValue(c, r - 1), r - 1);
rightPoint.set(c + 1, getValue(c + 1, r), r);
normal.set(getNormal(rightPoint, rootPoint, topPoint));
} else if (c == getWidth()-1) { // last column
topPoint.set(c, getValue(c,r-1), r-1);
leftPoint.set(c-1, getValue(c-1,r), r);
} else if (c == getWidth() - 1) { // last column
topPoint.set(c, getValue(c, r - 1), r - 1);
leftPoint.set(c - 1, getValue(c - 1, r), r);
normal.set(getNormal(topPoint, rootPoint, leftPoint));
} else { // all middle columns
topPoint.set(c, getValue(c,r-1), r-1);
leftPoint.set(c-1, getValue(c-1,r), r);
rightPoint.set(c+1, getValue(c+1,r), r);
topPoint.set(c, getValue(c, r - 1), r - 1);
leftPoint.set(c - 1, getValue(c - 1, r), r);
rightPoint.set(c + 1, getValue(c + 1, r), r);
Vector3f n1 = getNormal(topPoint, rootPoint, leftPoint);
Vector3f n2 = getNormal(rightPoint, rootPoint, topPoint);
normal.set(n1.add(n2).normalizeLocal());
}
} else { // all middle rows
if (c == 0) { // first column
topPoint.set(c, getValue(c,r-1), r-1);
rightPoint.set(c+1, getValue(c+1,r), r);
bottomPoint.set(c, getValue(c,r+1), r+1);
topPoint.set(c, getValue(c, r - 1), r - 1);
rightPoint.set(c + 1, getValue(c + 1, r), r);
bottomPoint.set(c, getValue(c, r + 1), r + 1);
Vector3f n1 = getNormal(rightPoint, rootPoint, topPoint);
Vector3f n2 = getNormal(bottomPoint, rootPoint, rightPoint);
normal.set(n1.add(n2).normalizeLocal());
} else if (c == getWidth()-1) { // last column
topPoint.set(c, getValue(c,r-1), r-1);
leftPoint.set(c-1, getValue(c-1,r), r);
bottomPoint.set(c, getValue(c,r+1), r+1);
} else if (c == getWidth() - 1) { // last column
topPoint.set(c, getValue(c, r - 1), r - 1);
leftPoint.set(c - 1, getValue(c - 1, r), r);
bottomPoint.set(c, getValue(c, r + 1), r + 1);
Vector3f n1 = getNormal(topPoint, rootPoint, leftPoint);
Vector3f n2 = getNormal(leftPoint, rootPoint, bottomPoint);
normal.set(n1.add(n2).normalizeLocal());
} else { // all middle columns
topPoint.set(c, getValue(c,r-1), r-1);
leftPoint.set(c-1, getValue(c-1,r), r);
rightPoint.set(c+1, getValue(c+1,r), r);
bottomPoint.set(c, getValue(c,r+1), r+1);
topPoint.set(c, getValue(c, r - 1), r - 1);
leftPoint.set(c - 1, getValue(c - 1, r), r);
rightPoint.set(c + 1, getValue(c + 1, r), r);
bottomPoint.set(c, getValue(c, r + 1), r + 1);
Vector3f n1 = getNormal(topPoint, rootPoint, leftPoint);
Vector3f n2 = getNormal(leftPoint, rootPoint, bottomPoint);
Vector3f n3 = getNormal(bottomPoint, rootPoint, rightPoint);
@ -704,7 +713,7 @@ public class LODGeomap extends BufferGeomap {
}
}
BufferUtils.setInBuffer(normal, store, (r*getWidth()+c)); // save the normal
BufferUtils.setInBuffer(normal, store, (r * getWidth() + c)); // save the normal
}
}
@ -714,22 +723,22 @@ public class LODGeomap extends BufferGeomap {
private Vector3f getNormal(Vector3f firstPoint, Vector3f rootPoint, Vector3f secondPoint) {
Vector3f normal = new Vector3f();
normal.set(firstPoint).subtractLocal(rootPoint)
.crossLocal(secondPoint.subtract(rootPoint)).normalizeLocal();
normal.set(firstPoint).subtractLocal(rootPoint).crossLocal(secondPoint.subtract(rootPoint)).normalizeLocal();
return normal;
}
/**
* Keeps a count of the number of indexes, good for debugging
*/
public class VerboseIntBuffer {
private IntBuffer delegate;
int count = 0;
public VerboseIntBuffer(IntBuffer d) {
delegate = d;
}
public void put(int value) {
try {
delegate.put(value);
@ -738,6 +747,7 @@ public class LODGeomap extends BufferGeomap {
//System.out.println("err buffer size: "+delegate.capacity());
}
}
public int getCount() {
return count;
}
@ -807,12 +817,13 @@ public class LODGeomap extends BufferGeomap {
* @return
*/
protected Triangle[] getGridTrianglesAtPoint(float x, float z) {
int gridX = (int)x;
int gridY = (int)z;
int gridX = (int) x;
int gridY = (int) z;
int index = findClosestHeightIndex(gridX,gridY);
if (index < 0)
int index = findClosestHeightIndex(gridX, gridY);
if (index < 0) {
return null;
}
Triangle t = new Triangle(new Vector3f(), new Vector3f(), new Vector3f());
Triangle t2 = new Triangle(new Vector3f(), new Vector3f(), new Vector3f());
@ -823,7 +834,7 @@ public class LODGeomap extends BufferGeomap {
float h4 = hdata.get(index + width + 1); // bottom right
if ((gridX == 0 && gridY == 0) || (gridX == width-1 && gridY == width-1)) {
if ((gridX == 0 && gridY == 0) || (gridX == width - 1 && gridY == width - 1)) {
// top left or bottom right grid point
t.get(0).x = (gridX);
t.get(0).y = (h1);
@ -848,8 +859,7 @@ public class LODGeomap extends BufferGeomap {
t2.get(2).x = (gridX + 1);
t2.get(2).y = (h2);
t2.get(2).z = (gridY);
}
else {
} else {
// all other grid points
t.get(0).x = (gridX);
t.get(0).y = (h1);
@ -876,7 +886,7 @@ public class LODGeomap extends BufferGeomap {
t2.get(2).z = (gridY + 1);
}
return new Triangle[]{t,t2};
return new Triangle[]{t, t2};
}
/**
@ -889,7 +899,7 @@ public class LODGeomap extends BufferGeomap {
protected Triangle getTriangleAtPoint(float x, float z) {
Triangle[] triangles = getGridTrianglesAtPoint(x, z);
if (triangles == null) {
System.out.println("x,z: "+x+","+z);
System.out.println("x,z: " + x + "," + z);
return null;
}
Vector2f point = new Vector2f(x, z);
@ -897,20 +907,21 @@ public class LODGeomap extends BufferGeomap {
Vector2f t2 = new Vector2f(triangles[0].get2().x, triangles[0].get2().z);
Vector2f t3 = new Vector2f(triangles[0].get3().x, triangles[0].get3().z);
if (0 != FastMath.pointInsideTriangle(t1, t2, t3, point))
if (0 != FastMath.pointInsideTriangle(t1, t2, t3, point)) {
return triangles[0];
}
t1.set(triangles[1].get1().x, triangles[1].get1().z);
t1.set(triangles[1].get2().x, triangles[1].get2().z);
t1.set(triangles[1].get3().x, triangles[1].get3().z);
if (0 != FastMath.pointInsideTriangle(t1, t2, t3, point))
if (0 != FastMath.pointInsideTriangle(t1, t2, t3, point)) {
return triangles[1];
}
return null;
}
protected int findClosestHeightIndex(int x, int z) {
if (x < 0 || x >= width - 1) {
@ -933,4 +944,3 @@ public class LODGeomap extends BufferGeomap {
super.read(im);
}
}

3
engine/src/terrain/com/jme3/terrain/geomipmap/TerrainGrid.java
View File

@ -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;

1
engine/src/terrain/com/jme3/terrain/geomipmap/TerrainQuad.java
View File

@ -111,6 +111,7 @@ public class TerrainQuad extends Node implements Terrain {
protected ExecutorService executor = Executors.newSingleThreadExecutor(new ThreadFactory() {
public Thread newThread(Runnable r) {
Thread th = new Thread(r);
th.setName("jME Terrain Thread");
th.setDaemon(true);
return th;
}