Comment afficher une partie de la carte et afficher une partie de celle-ci?

Question

J'ai la taille de carte 40000X20000, Je veux rendre seulement 2048X2048 et montrer sur l'écran seulement 1200X600 pixle, comment je fais cela?

En d'autres termes, penser que je Grande carte, je ne veux pas rendre tout le 40000X20000 je veux rendre seule la plus petite carte 2048x2048

Mon écran me permet de montrer 1200X600 Pixle.

Exemple.

Mon code:

public class LibgdxGame extends ApplicationAdapter { 
    static final float WORLD_WIDTH = 40000.0f; 
    static final float WORLD_HEIGHT = 20000.0f; 

// Define viewoport 
    private static final float VIRTUAL_WIDTH = 1200.0f; 
    private static final float VIRTUAL_HEIGHT = 600.0f; 
    // Move camera around 
    private static final float CAMERA_SPEED = 60.0f; 

    private OrthographicCamera camera; 
    private Viewport viewport; 

    private TiledMap map; 
    private TmxMapLoader loader; 
    private OrthogonalTiledMapRenderer renderer; 
    private Vector2 direction; 


    @Override 
    public void create() { 



     camera = new OrthographicCamera(15000, 15000); 

     viewport = new FitViewport(VIRTUAL_WIDTH, VIRTUAL_HEIGHT, camera); 
     camera.position.set(10900, 10800, 0); 
     loader = new TmxMapLoader();// 
     map = loader.load("40000X20000.tmx"); 
     renderer = new OrthogonalTiledMapRenderer(map); 

     direction = new Vector2(); 
    } 

    @Override 
    public void dispose() { 
     map.dispose(); 
     renderer.dispose(); 
    } 

    @Override 
    public void render() { 
     System.out.println("Render........."); 
     Gdx.gl.glClearColor(0.8f, 0.8f, 0.8f, 1.0f); 
     Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT); 

     updateCamera(); 

     renderer.setView(camera); 
     renderer.render(); 
    } 

    @Override 
    public void resize(int width, int height) { 
     viewport.update(width, height); 
     System.out.println(width); 
     System.out.println(height); 
    } 

    private void updateCamera() { 
     direction.set(0.0f, 0.0f); 

     int mouseX = Gdx.input.getX(); 
     int mouseY = Gdx.input.getY(); 
     int width = Gdx.graphics.getWidth(); 
     int height = Gdx.graphics.getHeight(); 

     if (Gdx.input.isKeyPressed(Keys.LEFT) || (Gdx.input.isTouched() && mouseX < width * 0.25f)) { 
      direction.x = -1; 
     } 
     else if (Gdx.input.isKeyPressed(Keys.RIGHT) || (Gdx.input.isTouched() && mouseX > width * 0.25f)) { 
      direction.x = 1; 
     } 

     if (Gdx.input.isKeyPressed(Keys.UP) || (Gdx.input.isTouched() && mouseY < height * 0.25f)) { 
      direction.y = 1; 
     } 
     else if (Gdx.input.isKeyPressed(Keys.DOWN) || (Gdx.input.isTouched() && mouseY > height * 0.25f)) { 
      direction.y = -1; 
     } 

     direction.nor().scl(CAMERA_SPEED * Gdx.graphics.getDeltaTime());; 

     camera.position.x += direction.x; 
     camera.position.y += direction.y; 

     TiledMapTileLayer layer = (TiledMapTileLayer)map.getLayers().get(0); 

     float cameraMinX = viewport.getWorldWidth() * 0.5f; 
     float cameraMinY = viewport.getWorldHeight() * 0.5f; 
     float cameraMaxX = layer.getWidth() * layer.getTileWidth() - cameraMinX; 
     float cameraMaxY = layer.getHeight() * layer.getTileHeight() - cameraMinY; 

     camera.position.x = MathUtils.clamp(camera.position.x, cameraMinX, cameraMaxX); 
     camera.position.y= MathUtils.clamp(camera.position.y, cameraMinY, cameraMaxY); 

     camera.update(); 
    } 
} 

Answer 1

Il y a différentes façons de le faire, bien que personne ne soit parfaitement optimisé. J'ai essayé de le faire il y a quelques jours. J'ai essayé d'utiliser:

1. Spritecache; ce qui est la meilleure option si vous avez une carte statique, pas de changement de tuiles. Bien que vous ayez une limite à tampon qui est 5640 tuiles/texture je suppose. Utilisez l'approche Scessior Stack, ce qui me semble compliqué, vous pouvez simplement recadrer la région de texture nécessaire et l'afficher sous forme de carte. Mais ce n'est pas une bonne solution.

2. Je ferais mieux d'aller avec cette approche. J'ai pris deux tmx le fichier est le grand_map.tmx avec toutes les tuiles détaillées et la couche; et puis a pris un autre petit small_map.tmx qui contient seulement 1/2 couches sans carreaux. Ensuite, a pris deux ensembles de chargeur, renderer et simplement simplement copié les cellules de besoins dans la petite zone (2048X2048) de la large_map à small_map et de rendre uniquement la petite carte. Vous pouvez maintenant utiliser cette carte pour modifier dynamiquement vos mosaïques et afficher l'animation car elle ne charge que le petit fichier tmx.