Map: Prep for TerrainQuad enhancements.

src/roadtrip/view/FineTerrainGrid.java

@@ -0,0 +1,574 @@
+/*
+ * Copyright (c) 2009-2012 jMonkeyEngine
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * * Neither the name of 'jMonkeyEngine' nor the names of its contributors
+ *   may be used to endorse or promote products derived from this software
+ *   without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package roadtrip.view;
+
+import com.jme3.bounding.BoundingBox;
+import com.jme3.export.InputCapsule;
+import com.jme3.export.JmeExporter;
+import com.jme3.export.JmeImporter;
+import com.jme3.export.OutputCapsule;
+import com.jme3.material.Material;
+import com.jme3.math.FastMath;
+import com.jme3.math.Vector2f;
+import com.jme3.math.Vector3f;
+import com.jme3.scene.Spatial;
+import com.jme3.scene.control.UpdateControl;
+import com.jme3.terrain.Terrain;
+import com.jme3.terrain.geomipmap.LRUCache;
+import com.jme3.terrain.geomipmap.NormalRecalcControl;
+import com.jme3.terrain.geomipmap.TerrainGridListener;
+import com.jme3.terrain.geomipmap.TerrainGridTileLoader;
+import com.jme3.terrain.geomipmap.TerrainQuad;
+import com.jme3.terrain.heightmap.HeightMap;
+import com.jme3.terrain.heightmap.HeightMapGrid;
+import java.io.IOException;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.Callable;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * <p>
+ * TerrainGrid itself is an actual TerrainQuad. Its four children are the visible four tiles.</p>
+ * </p><p>
+ * The grid is indexed by cells. Each cell has an integer XZ coordinate originating at 0,0.
+ * TerrainGrid will piggyback on the TerrainLodControl so it can use the camera for its
+ * updates as well. It does this in the overwritten update() method.
+ * </p><p>
+ * It uses an LRU (Least Recently Used) cache of 16 terrain tiles (full TerrainQuadTrees). The
+ * center 4 are the ones that are visible. As the camera moves, it checks what camera cell it is in
+ * and will attach the now visible tiles.
+ * </p><p>
+ * The 'quadIndex' variable is a 4x4 array that represents the tiles. The center
+ * four (index numbers: 5, 6, 9, 10) are what is visible. Each quadIndex value is an
+ * offset vector. The vector contains whole numbers and represents how many tiles in offset
+ * this location is from the center of the map. So for example the index 11 [Vector3f(2, 0, 1)]
+ * is located 2*terrainSize in X axis and 1*terrainSize in Z axis.
+ * </p><p>
+ * As the camera moves, it tests what cameraCell it is in. Each camera cell covers four quad tiles
+ * and is half way inside each one.
+ * </p><pre>
+ * +-------+-------+
+ * | 1     |     3 |    Four terrainQuads that make up the grid
+ * |    *..|..*    |    with the cameraCell in the middle, covering
+ * |----|--|--|----|    all four quads.
+ * |    *..|..*    |
+ * | 2     |     4 |
+ * +-------+-------+
+ * </pre><p>
+ * This results in the effect of when the camera gets half way across one of the sides of a quad to
+ * an empty (non-loaded) area, it will trigger the system to load in the next tiles.
+ * </p><p>
+ * The tile loading is done on a background thread, and once the tile is loaded, then it is
+ * attached to the qrid quad tree, back on the OGL thread. It will grab the terrain quad from
+ * the LRU cache if it exists. If it does not exist, it will load in the new TerrainQuad tile.
+ * </p><p>
+ * The loading of new tiles triggers events for any TerrainGridListeners. The events are:
+ * <ul>
+ *  <li>tile Attached
+ *  <li>tile Detached
+ *  <li>grid moved.
+ * </ul>
+ * <p>
+ * These allow physics to update, and other operation (often needed for loading the terrain) to occur
+ * at the right time.
+ * </p>
+ * @author Anthyon
+ */
+public class FineTerrainGrid extends TerrainQuad {
+    protected static final Logger log = Logger.getLogger(FineTerrainGrid.class.getCanonicalName());
+    protected Vector3f currentCamCell = Vector3f.ZERO;
+    protected int quarterSize; // half of quadSize
+    protected int quadSize;
+    protected HeightMapGrid heightMapGrid;
+    private TerrainGridTileLoader gridTileLoader;
+    protected Vector3f[] quadIndex;
+    protected Set<TerrainGridListener> listeners = new HashSet<TerrainGridListener>();
+    protected Material material;
+    //cache  needs to be 1 row (4 cells) larger than what we care is cached
+    protected LRUCache<Vector3f, TerrainQuad> cache = new LRUCache<Vector3f, TerrainQuad>(20);
+    protected int cellsLoaded = 0;
+    protected int[] gridOffset;
+    protected boolean runOnce = false;
+    protected ExecutorService cacheExecutor;
+
+    public int getSize() {
+        return size;
+    }
+
+    protected class UpdateQuadCache implements Runnable {
+
+        protected final Vector3f location;
+
+        public UpdateQuadCache(Vector3f location) {
+            this.location = location;
+        }
+
+        /**
+         * This is executed if the camera has moved into a new CameraCell and will load in
+         * the new TerrainQuad tiles to be children of this TerrainGrid parent.
+         * It will first check the LRU cache to see if the terrain tile is already there,
+         * if it is not there, it will load it in and then cache that tile.
+         * The terrain tiles get added to the quad tree back on the OGL thread using the
+         * attachQuadAt() method. It also resets any cached values in TerrainQuad (such as
+         * neighbours).
+         */
+        public void run() {
+            for (int i = 0; i < 4; i++) {
+                for (int j = 0; j < 4; j++) {
+                    int quadIdx = i * 4 + j;
+                    final Vector3f quadCell = location.add(quadIndex[quadIdx]);
+                    TerrainQuad q = cache.get(quadCell);
+                    if (q == null) {
+                        if (heightMapGrid != null) {
+                            // create the new Quad since it doesn't exist
+                            HeightMap heightMapAt = heightMapGrid.getHeightMapAt(quadCell);
+                            q = new TerrainQuad(getName() + "Quad" + quadCell, patchSize, quadSize, heightMapAt == null ? null : heightMapAt.getHeightMap());
+                            q.setMaterial(material.clone());
+                            log.log(Level.FINE, "Loaded TerrainQuad {0} from HeightMapGrid", q.getName());
+                        } else if (gridTileLoader != null) {
+                            q = gridTileLoader.getTerrainQuadAt(quadCell);
+                            // only clone the material to the quad if it doesn't have a material of its own
+                            if(q.getMaterial()==null) q.setMaterial(material.clone());
+                            log.log(Level.FINE, "Loaded TerrainQuad {0} from TerrainQuadGrid", q.getName());
+                        }
+                    }
+                    cache.put(quadCell, q);
+
+                    
+                    final int quadrant = getQuadrant(quadIdx);
+                    final TerrainQuad newQuad = q;
+                    
+                    if (isCenter(quadIdx)) {
+                        // if it should be attached as a child right now, attach it
+                        getControl(UpdateControl.class).enqueue(new Callable() {
+                            // back on the OpenGL thread:
+                            public Object call() throws Exception {
+                                if (newQuad.getParent() != null) {
+                                    attachQuadAt(newQuad, quadrant, quadCell, true);
+                                }
+                                else {
+                                    attachQuadAt(newQuad, quadrant, quadCell, false);
+                                }
+                                return null;
+                            }
+                        });
+                    } else {
+                        getControl(UpdateControl.class).enqueue(new Callable() {
+                            public Object call() throws Exception {
+                                removeQuad(newQuad);
+                                return null;
+                            }
+                        });
+                    }
+                }
+            }
+
+            getControl(UpdateControl.class).enqueue(new Callable() {
+                    // back on the OpenGL thread:
+                    public Object call() throws Exception {
+                        for (Spatial s : getChildren()) {
+                            if (s instanceof TerrainQuad) {
+                                TerrainQuad tq = (TerrainQuad)s;
+                                tq.resetCachedNeighbours();
+                            }
+                        }
+                        System.out.println("fixed normals "+location.clone().mult(size));
+                        setNeedToRecalculateNormals();
+                        return null;
+                    }
+            });
+        }
+    }
+
+    protected boolean isCenter(int quadIndex) {
+        return quadIndex == 9 || quadIndex == 5 || quadIndex == 10 || quadIndex == 6;
+    }
+
+    protected int getQuadrant(int quadIndex) {
+        if (quadIndex == 5) {
+            return 1;
+        } else if (quadIndex == 9) {
+            return 2;
+        } else if (quadIndex == 6) {
+            return 3;
+        } else if (quadIndex == 10) {
+            return 4;
+        }
+        return 0; // error
+    }
+
+    public FineTerrainGrid(String name, int patchSize, int maxVisibleSize, Vector3f scale, TerrainGridTileLoader terrainQuadGrid,
+            Vector2f offset, float offsetAmount) {
+        this.name = name;
+        this.patchSize = patchSize;
+        this.size = maxVisibleSize;
+        this.stepScale = scale;
+        this.offset = offset;
+        this.offsetAmount = offsetAmount;
+        initData();
+        this.gridTileLoader = terrainQuadGrid;
+        terrainQuadGrid.setPatchSize(this.patchSize);
+        terrainQuadGrid.setQuadSize(this.quadSize);
+        addControl(new UpdateControl());
+        
+        fixNormalEdges(new BoundingBox(new Vector3f(0,0,0), size*2, Float.MAX_VALUE, size*2));
+        addControl(new NormalRecalcControl(this));
+    }
+
+    public FineTerrainGrid(String name, int patchSize, int maxVisibleSize, Vector3f scale, TerrainGridTileLoader terrainQuadGrid) {
+        this(name, patchSize, maxVisibleSize, scale, terrainQuadGrid, new Vector2f(), 0);
+    }
+
+    public FineTerrainGrid(String name, int patchSize, int maxVisibleSize, TerrainGridTileLoader terrainQuadGrid) {
+        this(name, patchSize, maxVisibleSize, Vector3f.UNIT_XYZ, terrainQuadGrid);
+    }
+
+    public FineTerrainGrid() {
+    }
+
+    private void initData() {
+        int maxVisibleSize = size;
+        this.quarterSize = maxVisibleSize >> 2;
+        this.quadSize = (maxVisibleSize + 1) >> 1;
+        this.totalSize = maxVisibleSize;
+        this.gridOffset = new int[]{0, 0};
+
+        /*
+         *        -z
+         *         | 
+         *        1|3 
+         *  -x ----+---- x
+         *        2|4
+         *         |
+         *         z
+         */
+        this.quadIndex = new Vector3f[]{
+            new Vector3f(-1, 0, -1), new Vector3f(0, 0, -1), new Vector3f(1, 0, -1), new Vector3f(2, 0, -1),
+            new Vector3f(-1, 0, 0), new Vector3f(0, 0, 0), new Vector3f(1, 0, 0), new Vector3f(2, 0, 0),
+            new Vector3f(-1, 0, 1), new Vector3f(0, 0, 1), new Vector3f(1, 0, 1), new Vector3f(2, 0, 1),
+            new Vector3f(-1, 0, 2), new Vector3f(0, 0, 2), new Vector3f(1, 0, 2), new Vector3f(2, 0, 2)};
+
+    }
+
+    /**
+     * Get the location in cell-coordinates of the specified location.
+     * Cell coordinates are integer corrdinates, usually with y=0, each 
+     * representing a cell in the world.
+     * For example, moving right in the +X direction:
+     * (0,0,0) (1,0,0) (2,0,0), (3,0,0)
+     * and then down the -Z direction:
+     * (3,0,-1) (3,0,-2) (3,0,-3)
+     */
+    public Vector3f getCamCell(Vector3f location) {
+        Vector3f tile = getTileCell(location);
+        Vector3f offsetHalf = new Vector3f(-0.5f, 0, -0.5f);
+        Vector3f shifted = tile.subtract(offsetHalf);
+        return new Vector3f(FastMath.floor(shifted.x), 0, FastMath.floor(shifted.z));
+    }
+
+    /**
+     * Centered at 0,0.
+     * Get the tile index location in integer form:
+     * @param location world coordinate
+     */
+    public Vector3f getTileCell(Vector3f location) {
+        Vector3f tileLoc = location.divide(this.getWorldScale().mult(this.quadSize));
+        return tileLoc;
+    }
+
+    public TerrainGridTileLoader getGridTileLoader() {
+        return gridTileLoader;
+    }
+    
+    /**
+     * Get the terrain tile at the specified world location, in XZ coordinates.
+     */
+    public Terrain getTerrainAt(Vector3f worldLocation) {
+        if (worldLocation == null)
+            return null;
+        Vector3f tileCell = getTileCell(worldLocation.setY(0));
+        tileCell = new Vector3f(Math.round(tileCell.x), tileCell.y, Math.round(tileCell.z));
+        return cache.get(tileCell);
+    }
+    
+    /**
+     * Get the terrain tile at the specified XZ cell coordinate (not world coordinate).
+     * @param cellCoordinate integer cell coordinates
+     * @return the terrain tile at that location
+     */
+    public Terrain getTerrainAtCell(Vector3f cellCoordinate) {
+        return cache.get(cellCoordinate);
+    }
+    
+    /**
+     * Convert the world location into a cell location (integer coordinates)
+     */
+    public Vector3f toCellSpace(Vector3f worldLocation) {
+        Vector3f tileCell = getTileCell(worldLocation);
+        tileCell = new Vector3f(Math.round(tileCell.x), tileCell.y, Math.round(tileCell.z));
+        return tileCell;
+    }
+    
+    /**
+     * Convert the cell coordinate (integer coordinates) into world coordinates.
+     */
+    public Vector3f toWorldSpace(Vector3f cellLocation) {
+        return cellLocation.mult(getLocalScale()).multLocal(quadSize - 1);
+    }
+    
+    protected void removeQuad(TerrainQuad q) {
+        if (q != null && ( (q.getQuadrant() > 0 && q.getQuadrant()<5) || q.getParent() != null) ) {
+            for (TerrainGridListener l : listeners) {
+                l.tileDetached(getTileCell(q.getWorldTranslation()), q);
+            }
+            q.setQuadrant((short)0);
+            this.detachChild(q);
+            cellsLoaded++; // For gridoffset calc., maybe the run() method is a better location for this.
+        }
+    }
+
+    /**
+     * Runs on the rendering thread
+     * @param shifted quads are still attached to the parent and don't need to re-load
+     */
+    protected void attachQuadAt(TerrainQuad q, int quadrant, Vector3f quadCell, boolean shifted) {
+        
+        q.setQuadrant((short) quadrant);
+        if (!shifted)
+            this.attachChild(q);
+
+        Vector3f loc = quadCell.mult(this.quadSize - 1).subtract(quarterSize, 0, quarterSize);// quadrant location handled TerrainQuad automatically now
+        q.setLocalTranslation(loc);
+
+        if (!shifted) {
+            for (TerrainGridListener l : listeners) {
+                l.tileAttached(quadCell, q);
+            }
+        }
+        updateModelBound();
+        
+    }
+
+    
+    /**
+     * Called when the camera has moved into a new cell. We need to
+     * update what quads are in the scene now.
+     * 
+     * Step 1: touch cache
+     * LRU cache is used, so elements that need to remain
+     * should be touched.
+     *
+     * Step 2: load new quads in background thread
+     * if the camera has moved into a new cell, we load in new quads
+     * @param camCell the cell the camera is in
+     */
+    protected void updateChildren(Vector3f camCell) {
+
+        int dx = 0;
+        int dy = 0;
+        if (currentCamCell != null) {
+            dx = (int) (camCell.x - currentCamCell.x);
+            dy = (int) (camCell.z - currentCamCell.z);
+        }
+
+        int xMin = 0;
+        int xMax = 4;
+        int yMin = 0;
+        int yMax = 4;
+        if (dx == -1) { // camera moved to -X direction
+            xMax = 3;
+        } else if (dx == 1) { // camera moved to +X direction
+            xMin = 1;
+        }
+
+        if (dy == -1) { // camera moved to -Y direction
+            yMax = 3;
+        } else if (dy == 1) { // camera moved to +Y direction
+            yMin = 1;
+        }
+
+        // Touch the items in the cache that we are and will be interested in.
+        // We activate cells in the direction we are moving. If we didn't move 
+        // either way in one of the axes (say X or Y axis) then they are all touched.
+        for (int i = yMin; i < yMax; i++) {
+            for (int j = xMin; j < xMax; j++) {
+                cache.get(camCell.add(quadIndex[i * 4 + j]));
+            }
+        }
+        
+        // ---------------------------------------------------
+        // ---------------------------------------------------
+
+        if (cacheExecutor == null) {
+            // use the same executor as the LODControl
+            cacheExecutor = createExecutorService();
+        }
+
+        cacheExecutor.submit(new UpdateQuadCache(camCell));
+
+        this.currentCamCell = camCell;
+    }
+
+    public void addListener(TerrainGridListener listener) {
+        this.listeners.add(listener);
+    }
+
+    public Vector3f getCurrentCell() {
+        return this.currentCamCell;
+    }
+
+    public void removeListener(TerrainGridListener listener) {
+        this.listeners.remove(listener);
+    }
+
+    @Override
+    public void setMaterial(Material mat) {
+        this.material = mat;
+        super.setMaterial(mat);
+    }
+
+    public void setQuadSize(int quadSize) {
+        this.quadSize = quadSize;
+    }
+
+    @Override
+    public void adjustHeight(List<Vector2f> xz, List<Float> height) {
+        Vector3f currentGridLocation = getCurrentCell().mult(getLocalScale()).multLocal(quadSize - 1);
+        for (Vector2f vect : xz) {
+            vect.x -= currentGridLocation.x;
+            vect.y -= currentGridLocation.z;
+        }
+        super.adjustHeight(xz, height);
+    }
+
+    @Override
+    protected float getHeightmapHeight(int x, int z) {
+        return super.getHeightmapHeight(x - gridOffset[0], z - gridOffset[1]);
+    }
+    
+    @Override
+    public int getNumMajorSubdivisions() {
+        return 2;
+    }
+    
+    @Override
+    public Material getMaterial(Vector3f worldLocation) {
+        if (worldLocation == null)
+            return null;
+        Vector3f tileCell = getTileCell(worldLocation);
+        Terrain terrain = cache.get(tileCell);
+        if (terrain == null)
+            return null; // terrain not loaded for that cell yet!
+        return terrain.getMaterial(worldLocation);
+    }
+
+    /**
+     * This will print out any exceptions from the thread
+     */
+    protected ExecutorService createExecutorService() {
+        final ThreadFactory threadFactory = new ThreadFactory() {
+            public Thread newThread(Runnable r) {
+                Thread th = new Thread(r);
+                th.setName("jME TerrainGrid Thread");
+                th.setDaemon(true);
+                return th;
+            }
+        };
+        ThreadPoolExecutor ex = new ThreadPoolExecutor(1, 1,
+                                    0L, TimeUnit.MILLISECONDS,
+                                    new LinkedBlockingQueue<Runnable>(), 
+                                    threadFactory) {
+            protected void afterExecute(Runnable r, Throwable t) {
+                super.afterExecute(r, t);
+                if (t == null && r instanceof Future<?>) {
+                    try {
+                        Future<?> future = (Future<?>) r;
+                        if (future.isDone())
+                            future.get();
+                    } catch (CancellationException ce) {
+                        t = ce;
+                    } catch (ExecutionException ee) {
+                        t = ee.getCause();
+                    } catch (InterruptedException ie) {
+                        Thread.currentThread().interrupt(); // ignore/reset
+                    }
+                }
+                if (t != null)
+                    t.printStackTrace();
+            }
+        };
+        return ex;
+    }
+    
+    @Override
+    public void read(JmeImporter im) throws IOException {
+        super.read(im);
+        InputCapsule c = im.getCapsule(this);
+        name = c.readString("name", null);
+        size = c.readInt("size", 0);
+        patchSize = c.readInt("patchSize", 0);
+        stepScale = (Vector3f) c.readSavable("stepScale", null);
+        offset = (Vector2f) c.readSavable("offset", null);
+        offsetAmount = c.readFloat("offsetAmount", 0);
+        gridTileLoader = (TerrainGridTileLoader) c.readSavable("terrainQuadGrid", null);
+        material = (Material) c.readSavable("material", null);
+        initData();
+        if (gridTileLoader != null) {
+            gridTileLoader.setPatchSize(this.patchSize);
+            gridTileLoader.setQuadSize(this.quadSize);
+        }
+    }
+
+    @Override
+    public void write(JmeExporter ex) throws IOException {
+        super.write(ex);
+        OutputCapsule c = ex.getCapsule(this);
+        c.write(gridTileLoader, "terrainQuadGrid", null);
+        c.write(size, "size", 0);
+        c.write(patchSize, "patchSize", 0);
+        c.write(stepScale, "stepScale", null);
+        c.write(offset, "offset", null);
+        c.write(offsetAmount, "offsetAmount", 0);
+        c.write(material, "material", null);
+    }
+}

src/roadtrip/view/FineTerrainGridLodControl.java

@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2009-2012 jMonkeyEngine
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * * Neither the name of 'jMonkeyEngine' nor the names of its contributors
+ *   may be used to endorse or promote products derived from this software
+ *   without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package roadtrip.view;
+
+import com.jme3.math.Vector3f;
+import com.jme3.renderer.Camera;
+import com.jme3.terrain.Terrain;
+import com.jme3.terrain.geomipmap.TerrainGridListener;
+import com.jme3.terrain.geomipmap.TerrainLodControl;
+import com.jme3.terrain.geomipmap.lodcalc.LodCalculator;
+import java.util.List;
+
+/**
+ * Updates grid offsets and cell positions.
+ * As well as updating LOD.
+ * 
+ * @author sploreg
+ */
+public class FineTerrainGridLodControl extends TerrainLodControl {
+    
+    public FineTerrainGridLodControl(Terrain terrain, Camera camera) {
+        super(terrain, camera);
+    }
+    
+    @Override
+    protected void updateLOD(List<Vector3f> locations, LodCalculator lodCalculator) {
+        FineTerrainGrid terrainGrid = (FineTerrainGrid)getSpatial();
+        
+        // for now, only the first camera is handled.
+        // to accept more, there are two ways:
+        // 1: every camera has an associated grid, then the location is not enough to identify which camera location has changed
+        // 2: grids are associated with locations, and no incremental update is done, we load new grids for new locations, and unload those that are not needed anymore
+        Vector3f cam = locations.isEmpty() ? Vector3f.ZERO.clone() : locations.get(0);
+        Vector3f camCell = terrainGrid.getCamCell(cam); // get the grid index value of where the camera is (ie. 2,1)
+        if (terrainGrid.cellsLoaded > 1) {                  // Check if cells are updated before updating gridoffset.
+            terrainGrid.gridOffset[0] = Math.round(camCell.x * (terrainGrid.getSize() / 2));
+            terrainGrid.gridOffset[1] = Math.round(camCell.z * (terrainGrid.getSize() / 2));
+            terrainGrid.cellsLoaded = 0;
+        }
+        if (camCell.x != terrainGrid.currentCamCell.x || camCell.z != terrainGrid.currentCamCell.z || !terrainGrid.runOnce) {
+            // if the camera has moved into a new cell, load new terrain into the visible 4 center quads
+            terrainGrid.updateChildren(camCell);
+            for (TerrainGridListener l : terrainGrid.listeners) {
+                l.gridMoved(camCell);
+            }
+        }
+        terrainGrid.runOnce = true;
+        super.updateLOD(locations, lodCalculator);
+    }
+}

src/roadtrip/view/GameWorldView.java

@@ -35,6 +35,8 @@ import roadtrip.view.model.GameWorldState;
  */
 public class GameWorldView {
 
+    public static boolean DEBUG = false;//true;
+    
     private final GameWorldState state;
 
     private final AssetManager assetManager;
@@ -71,6 +73,9 @@ public class GameWorldView {
         
         // TERRAIN TEXTURE material
         terrain.mat_terrain = new Material(assetManager, "Common/MatDefs/Terrain/HeightBasedTerrain.j3md");
+        if (DEBUG) {
+            terrain.mat_terrain.getAdditionalRenderState().setWireframe(true);
+        }
 
         // Parameters to material:
         // regionXColorMap: X = 1..4 the texture that should be appliad to state X
@@ -143,18 +148,20 @@ public class GameWorldView {
 
         ground.addPreFilter(terrain.terrainDataProvider.iterate);
 
-        terrain.terrainGrid = new TerrainGrid("terrain", 16 + 1, 512 + 1, new FractalTileLoader(ground, 300f));
+        int patchSize = 32;
+        //terrain.terrainGrid = new TerrainGrid("terrain", 16 + 1, 512 + 1, new FractalTileLoader(ground, 300f));
+        terrain.terrainGrid = new FineTerrainGrid("terrain", patchSize + 1, 512 + 1, new FractalTileLoader(ground, 300f));
 
         terrain.terrainGrid.setMaterial(terrain.mat_terrain);
         //terrain.terrainGrid.setLocalTranslation(0, -200, 0);
         //terrain.terrainGrid.setLocalScale(2f, 1f, 2f);
         this.rootNode.attachChild(terrain.terrainGrid);
 
-        TerrainLodControl control = new TerrainGridLodControl(terrain.terrainGrid, camera);
+        TerrainLodControl control = new FineTerrainGridLodControl(terrain.terrainGrid, camera);
-        control.setLodCalculator(new DistanceLodCalculator(32 + 1, 2.7f)); // patch size, and a multiplier
+        control.setLodCalculator(new DistanceLodCalculator(patchSize + 1, 3.7f)); // patch size, and a multiplier
         terrain.terrainGrid.addControl(control);
 
-        final TerrainGrid terrainGrid = terrain.terrainGrid;
+        final FineTerrainGrid terrainGrid = terrain.terrainGrid;
         terrainGrid.addListener(new TerrainGridListener() {
 
             @Override
@@ -226,6 +233,7 @@ public class GameWorldView {
             }
 
         });
+        /**/
 
     }
 

src/roadtrip/view/TerrainView.java

@@ -9,7 +9,7 @@ import roadtrip.model.TerrainDataProvider;
  */
 public class TerrainView {
     public Material mat_terrain;
-    public TerrainGrid terrainGrid;
+    public FineTerrainGrid terrainGrid;
     public float grassScale = 64;
     public float dirtScale = 64;
     public float rockScale = 64;