Как использовать 2 батча на одном экране?

Я в своём проекте использую TiledMap, которые для отрисовки используют SpriteBatch, Texture и камеру, и когда я двигаю камеру TiledMap движется за камерой, но Texure(персонаж (класс Hero)) вместе с камерой не двигается.

https://github.com/Nannik/Game это ссылка на мой проект в гитхабе

Должно происходить: когда перс доходит до центра, камера начинает двигатся за ним, и должно получится что перс как-бы двигается, но стоит на месте.

Управление: Это игра для телефонов и управление осуществляется при помощи джойстика

Я его положение и размеры ещё не настраивал, но когда вы нажмёте мышкой с правой стороны джойстика перс будет двигатся влево, и наоборот.

Вот класс сцены:

package com.mygdx.game.Screens;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.Screen;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.g2d.SpriteBatch;
import com.badlogic.gdx.maps.tiled.TiledMap;
import com.badlogic.gdx.maps.tiled.TiledMapTileLayer;
import com.badlogic.gdx.maps.tiled.TmxMapLoader;
import com.badlogic.gdx.maps.tiled.renderers.OrthogonalTiledMapRenderer;
import com.mygdx.game.GG.Hero;
import com.mygdx.game.Camera;
import com.mygdx.game.UI.Button;
import com.mygdx.game.UI.Joystick;

public class Street implements Screen {
    private SpriteBatch batch;
    private Hero hero;
    private Joystick joystick;
    private Camera camera;
    private TiledMapTileLayer[] collisionLoader = new TiledMapTileLayer[5], groundLoader = new TiledMapTileLayer[2];
    private OrthogonalTiledMapRenderer backgroundRenderer, groundRenderer;
    private TiledMap background, ground;
public Street() {
    batch = new SpriteBatch();
    hero = new Hero(500, 500);
    joystick = new Joystick(hero);
    Gdx.input.setInputProcessor(joystick);
    attackSkill = new Attack();
    jerkSkill   = new Jerk();
    throwSkill  = new Throw();
    extraSkill  = new Extra();
    background = new TmxMapLoader().load("Street/background.tmx");
    backgroundRenderer = new OrthogonalTiledMapRenderer(background);
    ground = new TmxMapLoader().load("Street/Ground.tmx");
    groundRenderer = new OrthogonalTiledMapRenderer(ground);
    camera = new Camera(1024, 288, backgroundRenderer, collisionLoader, groundRenderer, groundLoader);
    Gdx.gl.glClearColor(0, 0, 0, 1);
}
@Override
public void show() {
}
public void update(){
    hero.update();
    joystick.update();
}
@Override
public void render(float delta) {
    update();
    Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
    camera.translate(hero);
    batch.begin();
        joystick.render(batch);
        hero.render(batch);
    batch.end();
}
//scrap
@Override
public void resize(int width, int height) {
}
@Override
public void pause() {
}
@Override
public void resume() {
}
@Override
public void hide() {
}
@Override
public void dispose() {
}

}

класс камеры:

package com.mygdx.game;
import ...;
public class Camera {
    private final int mapWidth, mapHeight;
    private int x, y;
    private OrthographicCamera camera;
    private OrthogonalTiledMapRenderer backgroundRenderer, groundRenderer;
    private TiledMapTileLayer[] collisionLoader, groundLoader;
    public Camera(int mapWidth, int mapHeight, OrthogonalTiledMapRenderer backgroundRenderer, TiledMapTileLayer[] collisionLoader, OrthogonalTiledMapRenderer groundRenderer, TiledMapTileLayer[] groundLoader) {
        camera = new OrthographicCamera(512, 288);
        this.backgroundRenderer = backgroundRenderer;
        this.groundRenderer = groundRenderer;
        this.mapWidth =  mapWidth;
        this.mapHeight = mapHeight;
        this.collisionLoader = collisionLoader;
        for (int i = 0; i < collisionLoader.length; i++){
            this.collisionLoader[i] = (TiledMapTileLayer) backgroundRenderer.getMap().getLayers().get(i);
        }
        this.groundLoader = groundLoader;
        for (int i = 0; i < groundLoader.length; i++){
            this.groundLoader[i] = (TiledMapTileLayer) groundRenderer.getMap().getLayers().get(i);
            this.groundLoader[i].setOffsetX(groundLoader[i].getTileWidth() * 8);
        }
    }
    public void translate(Hero hero){
        float heroX = hero.getVector().x / (Gdx.graphics.getWidth() / camera.viewportWidth);
        float heroY = hero.getVector().y / (Gdx.graphics.getHeight() / camera.viewportHeight);
        System.out.println(heroX);
        // x translate
        if (heroX - camera.viewportWidth / 2 < 0) {
            x = 0;
        } else if (heroX + camera.viewportWidth / 2 > mapWidth) {
            x = mapWidth - (int)camera.viewportWidth;
        } else {
            x = (int)heroX - (int)camera.viewportWidth / 2;
//            Тут создаётся параллакс, но он сейчас не нужен
//            for (int i = 0; i < collisionLoader.length; i++) {
//                if (hero.speed < 0){
//                    collisionLoader[i].setOffsetX(collisionLoader[i].getOffsetX() - (collisionLoader.length - i) * (Math.abs(hero.speed) / collisionLoader.length));
//                }else if (hero.speed > 0){
//                    collisionLoader[i].setOffsetX(collisionLoader[i].getOffsetX() + (collisionLoader.length - i) * (hero.speed / collisionLoader.length));
//                }
//
//            }
        }
        // y translate
        if (hero.getVector().y - (int) camera.viewportHeight / 2 < 0) {
            y = 0;
        } else if (hero.getVector().y + (int) camera.viewportHeight / 2 > mapHeight) {
            y = mapHeight - (int) camera.viewportHeight;
        } else {
            y = (int) hero.getVector().y - (int) camera.viewportHeight / 2;
        }

        // camera update
        camera.update();
        // camera position translate y
        camera.position.set(new Vector3(-x, -y, 0));
        camera.position.set(new Vector3(camera.viewportWidth - camera.position.x,
                                        camera.viewportHeight / 2 - camera.position.y,
                                        0));
        // tiled render
        backgroundRenderer.setView(camera);
        groundRenderer.setView(camera);
        backgroundRenderer.render();
        groundRenderer.render();
    }
}

Ну и на всякий пожарный для понимания класс перса:

    package com.mygdx.game.GG;
import com.badlogic.gdx.graphics.Texture;
import com.badlogic.gdx.graphics.g2d.SpriteBatch;
import com.badlogic.gdx.math.Vector3;
public class Hero {
    public int speed;
    private int jumpAcceleration;
    private boolean jump;
    private Vector3 vector;
    private Texture img;
    public Hero(int x, int y){
        img = new Texture("UI/Skills/defaultAttack.png");
        vector = new Vector3(x, y,0);
    }
    public void render(SpriteBatch batch){
        batch.draw(img , vector.x, vector.y);
    }
    public void update() {
        vector.x += speed;
        if (jumpAcceleration != -20) {
            vector.y += jumpAcceleration;
            jumpAcceleration -= 2;
        }else{
            jump = false;
        }
    }
    public void jump(){
            jumpAcceleration = 18;
            jump = true;
    }
    public boolean isJump() {
        return jump;
    }
    public Vector3 getVector() {
        return vector;
    }
    public Texture getImg() {
        return img;
    }
}

У меня есть один способ решения этой проблеммы - это в классе Hero в методе render batch.draw() передавать не vector.x а vector.x + смещение перс, но этот способ очень вялый так-как это прийдётся проделывать для, например нипов. хотелось бы сделать один раз и не парится.

И если заметите каким способом лучше написать тот или иной код, пожалуйста напишите в комментах.