LibGdx Tiled Map Rendering Issue

Question

Im trying to study a book to learn LibGDX game engine but i have a problem with rendering tiled maps. i think i wrote the same code with book but i couldnt get the same result.

its a simple game with a character and a map. When i rendered my character and background, there was no problem.

its looking like this;

http://i66.tinypic.com/nb97nq.png

but after i add my tmx map screen shows just some part of the game and no map.. i dont know how to fix this.. im really confused.

enter link description here

those are my GameManager and ScreenManager classes, maybe you can figure out what i did wrong..

public class GameManager {

static TiledMap map;
public static TiledMapRenderer renderer;/////

//region paddle
static TextureRegion leftPaddleTexture;
static TextureRegion rightPaddleTexture;
static Sprite leftPaddleSprite;
static Sprite rightPaddleSprite;
public static final float PADDLE_RESIZE_FACTOR = 700f;
public static final float PADDLE_ALPHA = 0.25f;
public static final float PADDLE_HORIZ_POS_FACTOR = 0.02f;
public static final float PADDLE_VERT_POSITION_FACTOR = 0.01f;
//endregion

static AssetManager assetManager;
static TextureAtlas texturePack;

static Bob bob;

static TextureRegion bobSpriteSheet;

public static Sprite backgroundSprite;
public static Texture backgroundTexture;

public static final float BOB_RESIZE_FACTOR = 400f;

public static void loadAssets()
{
    assetManager.load(GameConstants.backgroundImage, Texture.class);
    assetManager.load(GameConstants.texturePack, TextureAtlas.class);


    assetManager.setLoader(TiledMap.class, new TmxMapLoader(new InternalFileHandleResolver()));


    assetManager.load(GameConstants.level1, TiledMap.class);


    assetManager.finishLoading();
}

public static void initialize(float width, float height)
{



    assetManager = new AssetManager();
    loadAssets();


    map = assetManager.get(GameConstants.level1);
    renderer = new OrthogonalTiledMapRenderer(map, GameConstants.unitScale);

    GameScreen.camera.setToOrtho(false, 35,20);
    GameScreen.camera.update();


    renderer.setView(GameScreen.camera);

    texturePack = assetManager.get(GameConstants.texturePack);

    initializeLeftPaddle(width,height);
    initializeRightPaddle(width, height);

    bob = new Bob();
    bobSpriteSheet = texturePack.findRegion(GameConstants.bobSpriteSheet);
    bob.initialize(width,height,bobSpriteSheet);


    bob.bobSprite = new Sprite(bobSpriteSheet);

    //set the size of the bob
    bob.bobSprite.setSize((walkSheet.getRegionWidth()/ANIMATION_FRAME_SIZE) * (width/BOB_RESIZE_FACTOR),
            walkSheet.getRegionHeight()*(width/BOB_RESIZE_FACTOR));

    bob.bobSprite.setPosition(width / 2f, 0);

    backgroundTexture =assetManager.get(GameConstants.backgroundImage);
    backgroundSprite = new Sprite(backgroundTexture);

    backgroundSprite.setSize(width, height);

}

public static void renderGame(SpriteBatch batch)
{
   backgroundSprite.draw(batch);
    bob.update();
    bob.render(batch);
    leftPaddleSprite.draw(batch);
    rightPaddleSprite.draw(batch);

}

public static void dispose()
{
    assetManager.unload(GameConstants.backgroundImage);
  assetManager.clear();
}

public static void initializeLeftPaddle(float width, float height)
{
    leftPaddleTexture = texturePack.findRegion(GameConstants.leftPaddleImage);
    leftPaddleSprite = new Sprite(leftPaddleTexture);

    leftPaddleSprite.setSize(leftPaddleSprite.getWidth()*width/PADDLE_RESIZE_FACTOR,
            leftPaddleSprite.getHeight()*width/PADDLE_RESIZE_FACTOR);

    leftPaddleSprite.setPosition(width * PADDLE_HORIZ_POS_FACTOR, height * PADDLE_VERT_POSITION_FACTOR);

    leftPaddleSprite.setAlpha(PADDLE_ALPHA);
}

public static void initializeRightPaddle(float width, float height)
{
    rightPaddleTexture = texturePack.findRegion(GameConstants.rightPaddleImage);
    rightPaddleSprite = new Sprite(rightPaddleTexture);

    rightPaddleSprite.setSize(rightPaddleSprite.getWidth()*width/PADDLE_RESIZE_FACTOR,
            rightPaddleSprite.getHeight()*width/PADDLE_RESIZE_FACTOR);

    rightPaddleSprite.setPosition(leftPaddleSprite.getX() + leftPaddleSprite.getWidth() + width * PADDLE_HORIZ_POS_FACTOR,
            height * PADDLE_VERT_POSITION_FACTOR);

    rightPaddleSprite.setAlpha(PADDLE_ALPHA);
}

}

public class GameScreen implements Screen {

MainGame game;
SpriteBatch batch;
public static OrthographicCamera camera;

public GameScreen(MainGame game)
{
    this.game = game;
    float height = Gdx.graphics.getHeight();
    float width = Gdx.graphics.getWidth();

    camera = new OrthographicCamera(width, height);
    camera.setToOrtho(false);

    batch = new SpriteBatch();

    GameManager.initialize(width, height);

    Gdx.input.setInputProcessor(new InputManager(camera));

}

@Override
public void show() {

}

@Override
public void render(float delta) {
    Gdx.gl.glClearColor(1,1,1,1);
    Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);


    batch.setProjectionMatrix(camera.combined);


    GameManager.renderer.render();


     batch.begin();
     GameManager.renderGame(batch);
     batch.end();





}

@Override
public void resize(int width, int height) {

}

@Override
public void pause() {

}

@Override
public void resume() {

}

@Override
public void hide() {

}

@Override
public void dispose() {
    batch.dispose();
    GameManager.dispose();

}

}

I hope you can help, i searched on site to find same problem but i couldnt..

If you don't get a useful answer to your question here, note that the Stack Exchange Network has a community dedicated to game-dev-related questions, Game Development, where you may find more help. See: gamedev.stackexchange.com — mech
One thing I see different to what I do, is I set the view of the tiled map renderer inside my render call so it happens every render cycle. There is another sample github.com/libgdx/libgdx/blob/master/tests/gdx-tests/src/com/… — Lionel Port
I pretty sure it has to be inside the render call because it uses the current projection matrix of the camera. So if the camera position changes you need to make sure it's set again on the tiled map renderer. — Lionel Port

Bajo Mendez Bajo Mendez · Accepted Answer · 2016-06-04T18:28:12

static TiledMap map;

Let's define the path for the map file in the GameConstants class:

public static final String level1 = "data/maps/level1.tmx";

To queue the map for loading, add these lines of code to the loadAssets() method of GameManager before the finishedLoading() method's call:

// set the tiled map loader for the assetmanager
assetManager.setLoader(TiledMap.class, new TmxMapLoader(new
InternalFileHandleResolver()));
//load the tiled map
assetManager.load(GameConstants.level1, TiledMap.class);
//blocking method to load all assets
assetManager.finishLoading();

Now, you can get the map instance loaded into the initialize() method: loadAssets();

// get the map instance loaded
map = assetManager.get(GameConstants.level1);

To render the map, we need a map renderer. As we are using an orthogonal map, the OrthogonalTiledMapRenderer from the Tiled package is suitable for this purpose. Declare its instance in the GameManager class:

public static OrthogonalTiledMapRenderer renderer;
// map renderer

LibGdx Tiled Map Rendering Issue

1 Answers