Java DistanceLodCalculator类代码示例

import com.jme3.terrain.geomipmap.lodcalc.DistanceLodCalculator; //导入依赖的package包/类
@Override
public void read(JmeImporter im) throws IOException {
    super.read(im);
    InputCapsule ic = im.getCapsule(this);
    size = ic.readInt("size", 16);
    totalSize = ic.readInt("totalSize", 16);
    quadrant = ic.readShort("quadrant", (short)0);
    stepScale = (Vector3f) ic.readSavable("stepScale", Vector3f.UNIT_XYZ);
    offset = (Vector2f) ic.readSavable("offset", Vector3f.UNIT_XYZ);
    offsetAmount = ic.readFloat("offsetAmount", 0);
    lodCalculator = (LodCalculator) ic.readSavable("lodCalculator", new DistanceLodCalculator());
    lodCalculator.setTerrainPatch(this);
    lodCalculatorFactory = (LodCalculatorFactory) ic.readSavable("lodCalculatorFactory", null);
    lodEntropy = ic.readFloatArray("lodEntropy", null);
    geomap = (LODGeomap) ic.readSavable("geomap", null);
}
 

import com.jme3.terrain.geomipmap.lodcalc.DistanceLodCalculator; //导入依赖的package包/类
@Override
protected Sheet createSheet() {
    //TODO: multithreading..
    Sheet sheet = Sheet.createDefault();
    Sheet.Set set = Sheet.createPropertiesSet();
    set.setDisplayName("DistanceLodControl");
    DistanceLodCalculator obj = lodCalculator;
    if (obj == null) {
        return sheet;
    }

    set.put(makeProperty(obj, float.class, "getLodMultiplier", "setLodMultiplier", "Multiplier"));
    
    sheet.put(set);
    return sheet;

}
 

import com.jme3.terrain.geomipmap.lodcalc.DistanceLodCalculator; //导入依赖的package包/类
@Override
protected Node[] createNodes(Object key) {
    if (key instanceof DistanceLodCalculator) {
        DistanceLodCalculator assetKey = (DistanceLodCalculator) key;
        return new Node[]{new JmeDistanceLodCalculator(control, assetKey, getDataObject())};
    } else if (key instanceof PerspectiveLodCalculator) {
        //PerspectiveLodCalculator assetKey = (PerspectiveLodCalculator) key;
        //return new Node[]{new JmePerspectiveLodCalculator(control, assetKey)};
    }
    return null;
}
 

import com.jme3.terrain.geomipmap.lodcalc.DistanceLodCalculator; //导入依赖的package包/类
public JmeDistanceLodCalculator(TerrainLodControl lodControl, DistanceLodCalculator lodCalculator, DataObject dataObject) {
    super(Children.LEAF);
    this.lodControl=lodControl;
    this.lodCalculator = lodCalculator;
    this.dataObject = dataObject;
    getLookupContents().add(lodCalculator);
    getLookupContents().add(this);
    setName("DistanceLodCalculator");
}
 

import com.jme3.terrain.geomipmap.lodcalc.DistanceLodCalculator; //导入依赖的package包/类
public TerrainLodControl(Terrain terrain, Camera camera) {
    List<Camera> cams = new ArrayList<Camera>();
    cams.add(camera);
    this.terrain = terrain;
    this.cameras = cams;
    lodCalculator = new DistanceLodCalculator(65, 2.7f); // a default calculator
}
 

import com.jme3.terrain.geomipmap.lodcalc.DistanceLodCalculator; //导入依赖的package包/类
@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());
}
 

import com.jme3.terrain.geomipmap.lodcalc.DistanceLodCalculator; //导入依赖的package包/类
public Class getExplorerObjectClass() {
    return DistanceLodCalculator.class;
}
 

import com.jme3.terrain.geomipmap.lodcalc.DistanceLodCalculator; //导入依赖的package包/类
TiledTerrain() {
    // TERRAIN TEXTURE material
    matTerrain = new Material(assetManager, "Common/MatDefs/Terrain/TerrainLighting.j3md");
    matTerrain.setBoolean("useTriPlanarMapping", false);
    matTerrain.setBoolean("WardIso", true);
    matTerrain.setFloat("Shininess", 0);

    // GRASS texture
    Texture grass = assetManager.loadTexture("Textures/Terrain/splat/grass.jpg");
    grass.setWrap(WrapMode.Repeat);
    matTerrain.setTexture("DiffuseMap", grass);
    matTerrain.setFloat("DiffuseMap_0_scale", grassScale);

    // CREATE THE TERRAIN
    terrain1 = new TerrainQuad("terrain 1", 65, 513, null);
    terrain1.setMaterial(matTerrain);
    terrain1.setLocalTranslation(-256, -100, -256);
    terrain1.setLocalScale(1f, 1f, 1f);
    this.attachChild(terrain1);

    terrain2 = new TerrainQuad("terrain 2", 65, 513, null);
    terrain2.setMaterial(matTerrain);
    terrain2.setLocalTranslation(-256, -100, 256);
    terrain2.setLocalScale(1f, 1f, 1f);
    this.attachChild(terrain2);

    terrain3 = new TerrainQuad("terrain 3", 65, 513, null);
    terrain3.setMaterial(matTerrain);
    terrain3.setLocalTranslation(256, -100, -256);
    terrain3.setLocalScale(1f, 1f, 1f);
    this.attachChild(terrain3);

    terrain4 = new TerrainQuad("terrain 4", 65, 513, null);
    terrain4.setMaterial(matTerrain);
    terrain4.setLocalTranslation(256, -100, 256);
    terrain4.setLocalScale(1f, 1f, 1f);
    this.attachChild(terrain4);
    
    terrain1.setNeighbourFinder(this);
    terrain2.setNeighbourFinder(this);
    terrain3.setNeighbourFinder(this);
    terrain4.setNeighbourFinder(this);
    
    MultiTerrainLodControl lodControl = new MultiTerrainLodControl(getCamera());
    lodControl.setLodCalculator( new DistanceLodCalculator(65, 2.7f) ); // patch size, and a multiplier
    lodControl.addTerrain(terrain1);
    lodControl.addTerrain(terrain2);
    lodControl.addTerrain(terrain3);// order of these seems to matter
    lodControl.addTerrain(terrain4);
    this.addControl(lodControl);
    
}
 

import com.jme3.terrain.geomipmap.lodcalc.DistanceLodCalculator; //导入依赖的package包/类
public MultiTerrainLodControl(List<Camera> cameras) {
    this.cameras = cameras;
    lodCalculator = new DistanceLodCalculator(65, 2.7f);
}
 

import com.jme3.terrain.geomipmap.lodcalc.DistanceLodCalculator; //导入依赖的package包/类
protected Spatial doCreateTerrain(Node parent,
                                   int totalSize,
                                   int patchSize,
                                   int alphaTextureSize,
                                   float[] heightmapData,
                                   String sceneName,
                                   org.openide.nodes.Node selectedNode) throws IOException
   {
       final ProjectAssetManager manager = selectedNode.getLookup().lookup(ProjectAssetManager.class);
       
       Terrain terrain = new TerrainQuad("terrain-"+sceneName, patchSize, totalSize, heightmapData); //TODO make this pluggable for different Terrain implementations
       com.jme3.material.Material mat = new com.jme3.material.Material(manager, "Common/MatDefs/Terrain/TerrainLighting.j3md");

       String assetFolder = "";
       if (manager != null && manager instanceof ProjectAssetManager)
           assetFolder = ((ProjectAssetManager)manager).getAssetFolderName();

       // write out 3 alpha blend images
       for (int i=0; i<TerrainEditorController.NUM_ALPHA_TEXTURES; i++) {
           BufferedImage alphaBlend = new BufferedImage(alphaTextureSize, alphaTextureSize, BufferedImage.TYPE_INT_ARGB);
           if (i == 0) {
               // the first alpha level should be opaque so we see the first texture over the whole terrain
               for (int h=0; h<alphaTextureSize; h++)
                   for (int w=0; w<alphaTextureSize; w++)
                       alphaBlend.setRGB(w, h, 0x00FF0000);//argb
           }
           File alphaFolder = new File(assetFolder+"/Textures/terrain-alpha/");
           if (!alphaFolder.exists())
               alphaFolder.mkdir();
           String alphaBlendFileName = "/Textures/terrain-alpha/"+sceneName+"-"+((Node)terrain).getName()+"-alphablend"+i+".png";
           File alphaImageFile = new File(assetFolder+alphaBlendFileName);
           ImageIO.write(alphaBlend, "png", alphaImageFile);
           Texture tex = manager.loadAsset(new TextureKey(alphaBlendFileName, false));
           if (i == 0)
               mat.setTexture("AlphaMap", tex);
           else if (i == 1)
               mat.setTexture("AlphaMap_1", tex);
           else if (i == 2)
               mat.setTexture("AlphaMap_2", tex);
       }
       
       Texture defaultTexture = manager.loadTexture(TerrainEditorController.DEFAULT_TERRAIN_TEXTURE);
       
       // copy the default texture to the assets folder if it doesn't exist there yet
       String dirtTextureName = "/Textures/dirt.jpg";
       File dirtTextureFile = new File(assetFolder+dirtTextureName);
       if (!dirtTextureFile.exists()) {
           BufferedImage bi = ImageToAwt.convert(defaultTexture.getImage(), false, true, 0);
           ImageIO.write(bi, "jpg", dirtTextureFile);
       }
       // give the first layer default texture
       Texture dirtTexture = manager.loadTexture(dirtTextureName);
       dirtTexture.setWrap(WrapMode.Repeat);
       mat.setTexture("DiffuseMap", dirtTexture);
       mat.setFloat("DiffuseMap_0_scale", TerrainEditorController.DEFAULT_TEXTURE_SCALE);
       mat.setBoolean("WardIso", true);

       ((Node)terrain).setMaterial(mat);
       ((Node)terrain).setModelBound(new BoundingBox());
       ((Node)terrain).updateModelBound();
       ((Node)terrain).setLocalTranslation(0, 0, 0);
       ((Node)terrain).setLocalScale(1f, 1f, 1f);

       // add the lod control
       TerrainLodControl control = new TerrainLodControl(terrain, SceneApplication.getApplication().getCamera());
       control.setLodCalculator(new DistanceLodCalculator(patchSize, 2.7f));
((Node)terrain).addControl(control);

       parent.attachChild((Node)terrain);

       //setNeedsSave(true);
       //addSpatialUndo(parent, (Node)terrain, jmeNodeParent);
       
       return (Spatial)terrain;
   }