com.jme3.terrain.Terrain Java Examples

/**
 * Get a diffuse normal of the level.
 *
 * @param layer the layer.
 * @return the normal texture or null.
 */
@FromAnyThread
public @Nullable Texture getNormal(final int layer) {

    final Function<Integer, String> layerToNormalName = getLayerToNormalName();
    if (layerToNormalName == null) {
        return null;
    }

    final Terrain terrain = getTerrain();
    final Material material = terrain.getMaterial();
    final MatParam matParam = material.getParam(layerToNormalName.apply(layer));

    if (matParam == null || matParam.getValue() == null) {
        return null;
    }

    return (Texture) matParam.getValue();
}
 

/**
 * Notify about changing height by the point in the terrain.
 *
 * @param terrain the terrain.
 * @param point   the point.
 */
@JmeThread
protected void change(@NotNull final Terrain terrain, @NotNull final Vector2f point) {

    final Node terrainNode = (Node) terrain;
    final Vector3f scale = terrainNode.getWorldScale();

    final int halfSize = terrain.getTerrainSize() / 2;
    final int x = Math.round((point.x / scale.x) + halfSize);
    final int z = Math.round((point.y / scale.z) + halfSize);

    final HeightPoint heightPoint = new HeightPoint(point.getX(), point.getY(), x, z);

    final ObjectDictionary<Terrain, ObjectDictionary<HeightPoint, Float>> originalHeight = getOriginalHeight();
    final ObjectDictionary<HeightPoint, Float> terrainHeights = originalHeight.get(terrain, DICTIONARY_FACTORY);
    if (terrainHeights.containsKey(heightPoint)) {
        return;
    }

    final float height = terrain.getHeightmapHeight(point);
    terrainHeights.put(heightPoint, height);
}
 

/**
 * Start making changes.
 */
@JmeThread
protected void startChange() {

    final ObjectDictionary<Terrain, ObjectDictionary<HeightPoint, Float>> originalHeight = getOriginalHeight();
    originalHeight.forEach(Dictionary::clear);
    originalHeight.clear();

    final Array<Terrain> terrains = getTerrains();
    terrains.clear();

    NodeUtils.visitSpatial(notNull(getPaintedModel()), spatial -> {
        if (spatial instanceof Terrain) {
            terrains.add((Terrain) spatial);
            return false;
        }
        return true;
    });

    final ObjectDictionary<Terrain, Spatial> copiedTerrains = getCopiedTerrains();
    copiedTerrains.clear();

    terrains.forEach(copiedTerrains, (terrain, toStore) ->
            toStore.put(terrain, ((Spatial) terrain).clone()));
}
 

@JmeThread
private @NotNull Vector2f getPointPercentagePosition(@NotNull final Terrain terrain,
                                                     @NotNull final Vector3f localPoint,
                                                     @NotNull final Vector3f localScale,
                                                     @NotNull final Vector2f result) {
    result.set(localPoint.x, -localPoint.z);

    float scale = localScale.getX();

    // already centered on Terrain's node origin (0,0)
    float scaledSize = terrain.getTerrainSize() * scale;
    result.addLocal(scaledSize / 2, scaledSize / 2); // shift the bottom left corner up to 0,0
    result.divideLocal(scaledSize); // get the location as a percentage

    return result;
}
 

protected Terrain getTerrain(Spatial root) {

        // is this the terrain?
        if (root instanceof Terrain && root instanceof Node) {
            return (Terrain)root;
        }

        if (root instanceof Node) {
            Node n = (Node) root;
            for (Spatial c : n.getChildren()) {
                if (c instanceof Node){
                    Terrain res = getTerrain(c);
                    if (res != null)
                        return res;
                }
            }
        }

        return null;
    }
 

public void paintTexture(Terrain terrain, Vector3f markerLocation, float toolRadius, float toolWeight, int selectedTextureIndex) {
    if (selectedTextureIndex < 0 || markerLocation == null)
        return;
    
    int alphaIdx = selectedTextureIndex/4; // 4 = rgba = 4 textures
    Texture tex = getAlphaTexture(terrain, alphaIdx);
    Image image = tex.getImage();

    Vector2f UV = getPointPercentagePosition(terrain, markerLocation);

    // get the radius of the brush in pixel-percent
    float brushSize = toolRadius/(terrain.getTerrainSize()*((Node)terrain).getLocalScale().x);
    int texIndex = selectedTextureIndex - ((selectedTextureIndex/4)*4); // selectedTextureIndex/4 is an int floor, do not simplify the equation
    boolean erase = toolWeight<0;
    if (erase)
        toolWeight *= -1;

    doPaintAction(texIndex, image, UV, true, brushSize, erase, toolWeight);

    tex.getImage().setUpdateNeeded();
}
 

private Texture getAlphaTexture(Terrain terrain, int alphaLayer) {
    if (terrain == null)
        return null;
    MatParam matParam = null;
    if (alphaLayer == 0)
        matParam = terrain.getMaterial().getParam("AlphaMap");
    else if(alphaLayer == 1)
        matParam = terrain.getMaterial().getParam("AlphaMap_1");
    else if(alphaLayer == 2)
        matParam = terrain.getMaterial().getParam("AlphaMap_2");
    
    if (matParam == null || matParam.getValue() == null) {
        return null;
    }
    Texture tex = (Texture) matParam.getValue();
    return tex;
}
 

/**
 * Get a diffuse texture of the level.
 *
 * @param layer the layer.
 * @return the diffuse texture or null.
 */
@FromAnyThread
public @Nullable Texture getDiffuse(final int layer) {

    final Function<Integer, String> layerToDiffuseName = getLayerToDiffuseName();
    if (layerToDiffuseName == null) {
        return null;
    }

    final Terrain terrain = getTerrain();
    final Material material = terrain.getMaterial();
    final MatParam matParam = material.getParam(layerToDiffuseName.apply(layer));

    if (matParam == null || matParam.getValue() == null) {
        return null;
    }

    return (Texture) matParam.getValue();
}
 

protected static Node findTerrain(Spatial root) {
   
    // is this the terrain?
    if (root instanceof Terrain && root instanceof Node) {
        return (Node)root;
    }

    if (root instanceof Node) {
        Node n = (Node) root;
        for (Spatial c : n.getChildren()) {
            if (c instanceof Node){
                Node res = findTerrain(c);
                if (res != null)
                    return res;
            }
        }
    }

    return null;
}
 

private int doGetNumUsedTextures() {
    Terrain terrain = (Terrain) getTerrain(null);
    if (terrain == null)
        return 0;

    int count = 0;

    for (int i=0; i<MAX_TEXTURES; i++) {
        Texture tex = doGetDiffuseTexture(i);
        if (tex != null)
            count++;
        tex = doGetNormalMap(i);
        if (tex != null)
            count++;
    }
    return count;
}
 

/**
 * Get a alpha texture of the level.
 *
 * @param layer the layer.
 * @return the alpha texture or null.
 */
@FromAnyThread
public @Nullable Texture getAlpha(final int layer) {

    final Function<Integer, String> layerToAlphaName = getLayerToAlphaName();
    if (layerToAlphaName == null) {
        return null;
    }

    final Terrain terrain = getTerrain();
    final Material material = terrain.getMaterial();
    final MatParam matParam = material.getParam(layerToAlphaName.apply(layer));

    if (matParam == null || matParam.getValue() == null) {
        return null;
    }

    return (Texture) matParam.getValue();
}
 

private void doSetNormalMap(int layer, Texture tex) {
    Terrain terrain = (Terrain) getTerrain(null);
    if (terrain == null)
        return;
    if (tex == null) {
        // remove the texture if it is null
        if (layer == 0)
            terrain.getMaterial().clearParam("NormalMap");
        else
            terrain.getMaterial().clearParam("NormalMap_"+layer);
        return;
    }

    tex.setWrap(WrapMode.Repeat);
    
    if (layer == 0)
        terrain.getMaterial().setTexture("NormalMap", tex);
    else
        terrain.getMaterial().setTexture("NormalMap_"+layer, tex);

    setNeedsSave(true);
}
 

private void doSetNormalMap(int layer, String texturePath) {
    Terrain terrain = (Terrain) getTerrain(null);
    if (terrain == null)
        return;

    if (texturePath == null) {
        // remove the texture if it is null
        if (layer == 0)
            terrain.getMaterial().clearParam("NormalMap");
        else
            terrain.getMaterial().clearParam("NormalMap_"+layer);
    } else {
        Texture tex = SceneApplication.getApplication().getAssetManager().loadTexture(texturePath);
        tex.setWrap(WrapMode.Repeat);

        if (layer == 0)
            terrain.getMaterial().setTexture("NormalMap", tex);
        else
            terrain.getMaterial().setTexture("NormalMap_"+layer, tex);
    }
    enableTextureButtons();
    setNeedsSave(true);
}
 

/**
 * Get the normal map texture at the specified layer.
 * Run this on the GL thread!
 */
private Texture doGetNormalMap(int layer) {
    Terrain terrain = (Terrain) getTerrain(null);
    if (terrain == null)
        return null;
    MatParam matParam = null;
    if (layer == 0)
        matParam = terrain.getMaterial().getParam("NormalMap");
    else
        matParam = terrain.getMaterial().getParam("NormalMap_"+layer);

    if (matParam == null || matParam.getValue() == null) {
        return null;
    }
    Texture tex = (Texture) matParam.getValue();
    return tex;
}
 

private Texture doGetAlphaTexture(Terrain terrain, int alphaLayer) {
    if (terrain == null)
        return null;
    MatParam matParam = null;
    if (alphaLayer == 0)
        matParam = terrain.getMaterial().getParam("AlphaMap");
    else if(alphaLayer == 1)
        matParam = terrain.getMaterial().getParam("AlphaMap_1");
    else if(alphaLayer == 2)
        matParam = terrain.getMaterial().getParam("AlphaMap_2");
    
    if (matParam == null || matParam.getValue() == null) {
        return null;
    }
    Texture tex = (Texture) matParam.getValue();
    return tex;
}
 

/**
 * Get the diffuse texture at the specified layer.
 * Run this on the GL thread!
 */
private Texture doGetDiffuseTexture(int layer) {
    Terrain terrain = (Terrain) getTerrain(null);
    if (terrain == null)
        return null;
    MatParam matParam = null;
    if (layer == 0)
        matParam = terrain.getMaterial().getParam("DiffuseMap");
    else
        matParam = terrain.getMaterial().getParam("DiffuseMap_"+layer);

    if (matParam == null || matParam.getValue() == null) {
        return null;
    }
    Texture tex = (Texture) matParam.getValue();

    return tex;
}
 

public JmeNode findJmeTerrain(JmeNode root) {
    if (root == null)
        root = (JmeNode) jmeRootNode;
    
    Node node = root.getLookup().lookup(Node.class);
    if (node != null && node instanceof Terrain && node instanceof Node) {
        return root;
    }
    
    if (node != null) {
        if (root.getChildren() != null) {
            for (org.openide.nodes.Node child : root.getChildren().getNodes() ) {
                if (child instanceof JmeNode) {
                    JmeNode res = findJmeTerrain((JmeNode)child);
                    if (res != null)
                        return res;
                }
            }
        }
    }
    
    return null;
}
 

private void resetHeight(Terrain terrain, List<Vector2f> undoLocs, List<Float> undoHeights) {
    List<Float> neg = new ArrayList<Float>();
    for (Float f : undoHeights)
        neg.add( f * -1f );
    
    terrain.adjustHeight(undoLocs, neg);
    ((Node)terrain).updateModelBound();
}
 

@Override
protected void doUndoTool(AbstractSceneExplorerNode rootNode, Object undoObject) {
    if (undoObject == null)
        return;
    if (undoLocs == null || undoHeights == null)
        return;
    resetHeight((Terrain)undoObject, undoLocs, undoHeights);
}
 

public Vector2f getPointPercentagePosition(Terrain terrain, Vector3f worldLoc) {
    Vector2f uv = new Vector2f(worldLoc.x,-worldLoc.z);
    float scale = ((Node)terrain).getLocalScale().x;
    
    uv.subtractLocal(((Node)terrain).getWorldTranslation().x*scale, ((Node)terrain).getWorldTranslation().z*scale); // center it on 0,0
    float scaledSize = terrain.getTerrainSize()*scale;
    uv.addLocal(scaledSize/2, scaledSize/2); // shift the bottom left corner up to 0,0
    uv.divideLocal(scaledSize); // get the location as a percentage
    
    return uv;
}
 

private void doSetTextureScale(int layer, float scale) {
    Terrain terrain = (Terrain) getTerrain(null);
    if (terrain == null)
        return;
    terrain.getMaterial().setFloat("DiffuseMap_"+layer+"_scale", scale);
    setNeedsSave(true);
}
 

private Float doGetTextureScale(int layer) {
    Terrain terrain = (Terrain) getTerrain(null);
    if (terrain == null)
        return 1f;
    MatParam matParam = null;
    matParam = terrain.getMaterial().getParam("DiffuseMap_"+layer+"_scale");
    return (Float) matParam.getValue();
}
 

private void doGenerateEntropies(ProgressMonitor progressMonitor) {
    Terrain terrain = (Terrain) getTerrain(null);
    if (terrain == null)
        return;

    terrain.generateEntropy(progressMonitor);
}
 

@Override
protected Object doApplyTool(AbstractSceneExplorerNode rootNode) {
    Terrain terrain = getTerrain(rootNode.getLookup().lookup(Node.class));
    if (terrain == null)
        return null;
    modifyHeight(terrain, radius, height);
    return terrain;
}
 

public void save() throws IOException {
    SceneApplication.getApplication().enqueue(new Callable() {

        public Object call() throws Exception {
            currentFileObject.saveAsset();
            //TerrainSaveCookie sc = currentFileObject.getCookie(TerrainSaveCookie.class);
            //if (sc != null) {
                Node root = rootNode.getLookup().lookup(Node.class);
                doSaveAlphaImages((Terrain)getTerrain(root));
            //}
            return null;
        }
    });
}
 

@Override
public void onAction(final String name, final boolean keyPressed, final float tpf) {
    if (name.equals("Lefts")) {
        if (keyPressed) {
            TerrainGridTileLoaderTest.this.left = true;
        } else {
            TerrainGridTileLoaderTest.this.left = false;
        }
    } else if (name.equals("Rights")) {
        if (keyPressed) {
            TerrainGridTileLoaderTest.this.right = true;
        } else {
            TerrainGridTileLoaderTest.this.right = false;
        }
    } else if (name.equals("Ups")) {
        if (keyPressed) {
            TerrainGridTileLoaderTest.this.up = true;
        } else {
            TerrainGridTileLoaderTest.this.up = false;
        }
    } else if (name.equals("Downs")) {
        if (keyPressed) {
            TerrainGridTileLoaderTest.this.down = true;
        } else {
            TerrainGridTileLoaderTest.this.down = false;
        }
    } else if (name.equals("Jumps")) {
        TerrainGridTileLoaderTest.this.player3.jump();
    } else if (name.equals("pick") && keyPressed) {
        //Terrain picked = terrain.getTerrainAt(player3.getPhysicsLocation());
        Terrain picked = terrain.getTerrainAtCell(terrain.getCurrentCell());
        System.out.println("** cell "+player3.getPhysicsLocation()+" picked terrain: "+picked);
    }
}
 

public void onAction(String name, boolean pressed, float tpf) {
    if (name.equals("clone") && !pressed) {

        Terrain clone = (Terrain) ((Node)terrain).clone();
        ((Node)terrain).removeFromParent();
        terrain = clone;
        getRootNode().attachChild((Node)terrain);
    }
}
 

@Override
public void read(JmeImporter im) throws IOException {
    super.read(im);
    InputCapsule ic = im.getCapsule(this);
    terrain = (Terrain) ic.readSavable("terrain", null);
    lodCalculator = (LodCalculator) ic.readSavable("lodCalculator", new DistanceLodCalculator());
}
 

@Override
public void setSpatial(Spatial spatial) {
    super.setSpatial(spatial);
    if (spatial instanceof Terrain) {
        this.terrain = (Terrain) spatial;
    }
}
 

private void doRemoveNormalMap(int layer) {
    Terrain terrain = (Terrain) getTerrain(null);
    if (terrain == null)
        return;
    if (layer == 0)
        terrain.getMaterial().clearParam("NormalMap");
    else
        terrain.getMaterial().clearParam("NormalMap_"+layer);

    setNeedsSave(true);
}