Exemple #1
0
  @Override
  public void render() {
    // Update
    getInput();

    b2dWorld.step(1f / 60f, 6, 2);

    camera.update();
    cameraBak.update();
    manager.update();
    background.update();

    // Draw
    Gdx.gl.glClearColor(0, 0, 0, 1);
    Gdx.gl.glClear(GL30.GL_COLOR_BUFFER_BIT);

    // Background
    batch.setProjectionMatrix(cameraBak.combined);
    batch.begin();
    background.draw(batch);
    batch.end();

    batch.setProjectionMatrix(camera.combined);
    debugMatrix = batch.getProjectionMatrix().cpy().scale(PPM, PPM, 0);
    // debugRenderer.render(b2dWorld, debugMatrix);
    batch.begin();
    manager.draw(batch);
    batch.end();

    // GUI
    batch.setProjectionMatrix(cameraBak.combined);
    batch.begin();
    drawGUI(batch);
    batch.end();
  }
 public void resize(int width, int height) {
   camera.viewportWidth = (Constants.VIEWPORT_HEIGHT / height) * width;
   camera.update();
   cameraGUI.viewportHeight = Constants.VIEWPORT_GUI_HEIGHT;
   cameraGUI.viewportWidth = Constants.VIEWPORT_GUI_HEIGHT / (float) height * (float) width;
   cameraGUI.position.set(cameraGUI.viewportWidth / 2, cameraGUI.viewportHeight / 2, 0);
   cameraGUI.update();
 }
Exemple #3
0
 private void updateCamZoom(float newZoom) {
   OrthographicCamera c = cam.camera;
   c.unproject(zTmp1.set(cs.xy.x, cs.xy.y, 0));
   c.zoom = newZoom;
   c.update();
   c.unproject(zTmp2.set(cs.xy.x, cs.xy.y, 0));
   c.translate(zTmp1.sub(zTmp2));
   c.update();
 }
Exemple #4
0
 /** Set's the ShapeRenderer's projection matrix depending on the mode of the demo camera. */
 public void setCamera(ShapeRenderer renderer) {
   if (inCloseupMode) {
     closeupCamera.update();
     renderer.setProjectionMatrix(closeupCamera.combined);
   } else {
     overviewCamera.update();
     renderer.setProjectionMatrix(overviewCamera.combined);
   }
 }
 private void init() {
   batch = new SpriteBatch();
   camera = new OrthographicCamera(Constants.VIEWPORT_WIDTH, Constants.VIEWPORT_HEIGHT);
   camera.position.set(0, 0, 0);
   camera.update();
   cameraGUI = new OrthographicCamera(Constants.VIEWPORT_GUI_WIDTH, Constants.VIEWPORT_GUI_HEIGHT);
   cameraGUI.position.set(0, 0, 0);
   cameraGUI.setToOrtho(true); // flip y-axis
   cameraGUI.update();
 }
Exemple #6
0
  @Override
  public void render() {
    delta = Gdx.graphics.getDeltaTime() * 60;
    Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
    camera.update();
    player.update(delta);
    if (player.atLimit()) backgroundPos -= 20 * delta;
    else backgroundPos -= 10 * delta;

    if (backgroundPos <= -background.getHeight()) backgroundPos = 0;

    spriteBatch.setProjectionMatrix(camera.combined);
    spriteBatch.begin();
    spriteBatch.draw(background, -1080 / 2, +background.getHeight() / 2 + backgroundPos);
    spriteBatch.draw(background, -1080 / 2, -background.getHeight() / 2 + backgroundPos);
    player.draw(spriteBatch);
    enemies.update(spriteBatch, delta);
    tweenManager.update(delta / 60);
    spriteBatch.end();

    rayHandler.setCombinedMatrix(camera.combined);
    rayHandler.updateAndRender();

    controls.handleInput(camera);
  }
  public void draw(float deltaTime) {
    renderer.render();

    guiCam.update();
    batcher.setProjectionMatrix(guiCam.combined);
    batcher.enableBlending();
    batcher.begin();

    drawUI(deltaTime);

    switch (state) {
      case GAME_READY:
        presentReady();
        break;
        // case ROUND_START
        // case COUNT_DUCKS
        // case NEXT_ROUND
      case GAME_RUNNING:
        presentRunning();
        break;
      case GAME_OVER_1:
      case GAME_OVER_2:
        presentGameOver();
        break;
    }

    batcher.end();
  }
Exemple #8
0
 @Override
 public void render(float delta) {
   camera.update();
   maps.setView(camera);
   maps.render();
   entities.update(delta);
 }
  @Override
  public void render(float dt) {

    Gdx.gl.glClearColor(0, 0, 0, 1);
    Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);

    // compara si la aplicacion se ejecuta en escritorio o en android
    if (Gdx.app.getType() == ApplicationType.Desktop) {
      this.entradaEscritorio(dt);
    } else if (Gdx.app.getType() == ApplicationType.Android) {
      this.entradaAndroid(dt);
    }
    // actualizamos
    camara.update();
    this.juegoGanado();
    batch.setProjectionMatrix(camara.combined);
    manejadorDeSprite.update(dt, arcanoid, jugador);

    // renderiza el manejadorDeSprite, fondo de pantalla y fuente de jugador
    batch.begin();
    batch.draw(fondoPantalla, 0, 0, Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
    jugador.draw(batch);
    batch.end();
    manejadorDeSprite.render();
  }
Exemple #10
0
  /**
   * Splash Screen Constructor.
   *
   * @param tappy
   */
  public SplashScreen(Tappy tappy) {
    // Core Variable.
    this.tappy = tappy;

    // Get sprites.
    splashHeadphone = Assets.getSprite("splashHeadphone");
    splashBackground = Assets.getSprite("splashBackground");

    // Set normal camera.
    orthographicCamera = new OrthographicCamera(Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
    orthographicCamera.position.set(
        orthographicCamera.viewportWidth / 2f, orthographicCamera.viewportHeight / 2f, 0);
    orthographicCamera.update();

    // Initialize TweenManager.
    tweenManager = new TweenManager();
    Tween.registerAccessor(Sprite.class, new SpriteAccessor());

    // Initialize splashScreen variable.
    splashNormalStage = new Stage();

    // Trace player!
    HashMap<String, String> parameters = new HashMap<String, String>();
    try {
      parameters.put(
          "signature",
          Helper.md5(
              (int) (Math.floor(((int) (System.currentTimeMillis() / 1000L) / 1000.0)))
                  + "tHeJ3110pylnWzA-007!-+ei"));
    } catch (Exception e) {
      parameters.put("signature", "Error");
    }
    parameters.put("function", "launch");
    try {
      parameters.put("computerName", InetAddress.getLocalHost().getHostName());
    } catch (Exception e) {
      parameters.put("computerName", "Unknown");
    }
    try {
      parameters.put("javaVersion", System.getProperty("java.version"));
    } catch (Exception e) {
      parameters.put("javaVersion", "Unknown");
    }
    parameters.put("isFirst", tappy.getPreferences().getBoolean("firstTime", true) ? "1" : "0");
    HttpRequest httpPost = new HttpRequest(HttpMethods.POST);
    httpPost.setUrl("http://jellopy.in.th/tappy1eaTrace.php");
    httpPost.setContent(HttpParametersUtils.convertHttpParameters(parameters));
    Gdx.net.sendHttpRequest(
        httpPost,
        new HttpResponseListener() {
          @Override
          public void handleHttpResponse(HttpResponse httpResponse) {}

          @Override
          public void failed(Throwable error) {}

          @Override
          public void cancelled() {}
        });
  }
  public GameScreen(final IkeGame game) {
    this.game = game;

    // Creates the world manager with the specified map
    worldManager = new WorldManager("test_map.tmx");
    // Creates the player at the specified coordinates
    worldManager.createPlayer(1.5f, 5.5f);
    // Sets this class's ike body instance to the world manager's for convenience
    ikeBody = worldManager.player;
    // Gets the ike instance from ike's body
    ike = (Ike) ikeBody.getUserData();

    // Creates the camera
    camera = new OrthographicCamera();
    // Makes the camera render 32 tiles wide and 18 tiles high
    camera.setToOrtho(false, 32, 18);
    // Updates the camera
    camera.update();

    // Creates the shape renderer
    shapeRenderer = new ShapeRenderer();

    // Sets the input listener
    Gdx.input.setInputProcessor(new ControlListener());
  }
Exemple #12
0
  @Override
  public void render(float delta) {
    Gdx.gl.glClearColor(0.39f, 0.58f, 0.92f, 1.0f);
    Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);

    // Update deltaTime & animationTime
    deltaTime = Gdx.graphics.getDeltaTime();
    animationTime += Gdx.graphics.getDeltaTime();

    // Store Spritesheet to sprite
    sprite = new Sprite(animation.getKeyFrame(animationTime, true));
    sprite.setPosition(xPosition, 0);
    sprite.setScale(1.8f);

    // Set camera to batch and undate camera
    batch.setProjectionMatrix(camera.combined);
    camera.update();

    tiledMapRenderer.setView(camera);
    tiledMapRenderer.render(background);
    tiledMapRenderer.render(foreground);

    // Display on Screen
    batch.begin();
    sprite.draw(batch);
    batch.end();

    // update xPosition
    xPosition = xPosition + (speed * deltaTime);

    HUDBatch.begin();
    font1.draw(HUDBatch, "SCORE:100", 100, 450);
    HUDBatch.end();
  }
  @Override
  public void render(float delta) {
    // TODO Auto-generated method stub

    if (Gdx.input.justTouched()) {
      guiCam.unproject(touch.set(Gdx.input.getX(), Gdx.input.getY(), 0));
      if (startbutton.contains(touch)) {
        maingame.setScreen(maingame.mainscene);
        return;
      }
    }

    GL10 gl = Gdx.graphics.getGL10();
    gl.glClearColor(0, 0, 0, 1);
    gl.glClear(GL10.GL_COLOR_BUFFER_BIT);
    /*
     * Actualiza los parametros de la camara
     * y los enlaza al objeto de renderizado batcher
     * */
    guiCam.update();
    this.batcher.setProjectionMatrix(this.guiCam.combined);
    /*
     * Desactiva las trasnparencias
     * */
    batcher.disableBlending();
    batcher.begin();
    batcher.draw(Assets.background, 0, 0, 10, 15);
    batcher.end();
    batcher.enableBlending();
    batcher.begin();
    batcher.draw(Assets.title, 1, 6, 8, 8);
    batcher.draw(Assets.start, x, 3, 6, 3);
    x += c;
    batcher.end();
  }
Exemple #14
0
  @Override
  public void present(float deltaTime) {
    GLCommon gl = Gdx.gl;
    gl.glClear(GL10.GL_COLOR_BUFFER_BIT);

    camera.update();

    worldRender.render(deltaTime);
    if (isTreasure) {
      batcher.begin();
      renderTreasure(treasureType);
      if (isTreasureSound) {
        Assets.playSound(Assets.treasureSound, game.soundState);
        isTreasureSound = false;
      }
      batcher.end();
    } else if (isFinal) {
      batcher.begin();
      renderFinal();
      batcher.end();
    } else {
      if (isPause && !isDialog) {
        batcher.begin();
        renderGamePause();
        batcher.end();
      }
    }
    if ((isPause || !game.soundState) && bgMusic.isPlaying()) {
      bgMusic.pause();
    } else if (!isPause && !bgMusic.isPlaying() && game.soundState) {
      Assets.playMusic(bgMusic, game.soundState);
    }
  }
  @Override
  public void render(float delta) {
    Gdx.gl.glClearColor(Color.BLUE.r, Color.BLUE.g, Color.BLUE.b, Color.BLUE.a);
    Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);

    camera.update();
    game.batch.setProjectionMatrix(camera.combined);

    batch.begin();
    font.draw(batch, "Loading Game", 32, 32);
    background.draw(batch);
    batch.end();

    if (licenseVerified) {
      if (Gdx.input.isTouched()) {
        Logger.logMsg("transitioning to main menu screen");
        game.setGameScreen(this, game.mainMenuScreen);
        dispose();
      }
    } else {
      Dialog dialog =
          new Dialog("license key invalid", game.uiSkin) {
            protected void result(Object object) {
              Logger.logMsg("exiting");
              Gdx.app.exit();
            }
          };
      dialog.text("Your license key is invalid, exiting...");
      dialog.button("OK", true);
      dialog.show(stage);
    }
  }
  private void drawWorld() {
    camera.update();
    batch.setProjectionMatrix(camera.combined);
    batch.begin();
    batch.draw(background, camera.position.x - background.getWidth() / 2, 0);
    for (Rock rock : rocks) {
      batch.draw(rock.image, rock.position.x, rock.position.y);
    }
    batch.draw(ground, groundOffsetX, 0);
    batch.draw(ground, groundOffsetX + ground.getRegionWidth(), 0);
    batch.draw(ceiling, groundOffsetX, 480 - ceiling.getRegionHeight());
    batch.draw(ceiling, groundOffsetX + ceiling.getRegionWidth(), 480 - ceiling.getRegionHeight());
    batch.draw(plane.getKeyFrame(planeStateTime), planePosition.x, planePosition.y);
    batch.end();

    batch.setProjectionMatrix(uiCamera.combined);
    batch.begin();
    if (gameState == GameState.Start) {
      batch.draw(
          ready,
          Gdx.graphics.getWidth() / 2 - ready.getRegionWidth() / 2,
          Gdx.graphics.getHeight() / 2 - ready.getRegionHeight() / 2);
    }
    if (gameState == GameState.GameOver) {
      batch.draw(
          gameOver,
          Gdx.graphics.getWidth() / 2 - gameOver.getRegionWidth() / 2,
          Gdx.graphics.getHeight() / 2 - gameOver.getRegionHeight() / 2);
    }
    if (gameState == GameState.GameOver || gameState == GameState.Running) {
      font.draw(batch, "" + score, Gdx.graphics.getWidth() / 2, Gdx.graphics.getHeight() - 60);
    }
    batch.end();
  }
  @Override
  public void render(float delta) {
    Gdx.gl.glClearColor(0, 0, 0, 1);
    Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);

    camera.update();
    mainGame.spriteBatch.setProjectionMatrix(camera.combined);

    world.step(1 / 45f, 6, 2);

    // Renderable.update
    for (Renderable r : renderables) {
      r.update();
    }

    if (Gdx.input.isTouched()) {
      Gdx.app.debug(TAG, "Fire");
    }

    mainGame.spriteBatch.begin();

    // Renderable.render
    for (Renderable r : renderables) {
      r.render(mainGame.spriteBatch);
    }

    mainGame.spriteBatch.end();
  }
  @Override
  public void draw(Player p) {
    cam.setToOrtho(true, HawkthorneGame.WIDTH, HawkthorneGame.HEIGHT);
    cam.zoom = 1f;
    cam.update(true);
    batch.setProjectionMatrix(cam.combined);
    batch.begin();
    Gdx.gl.glClearColor(0, 0, 0, 1);
    Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT | GL20.GL_DEPTH_BUFFER_BIT);
    batch.draw(
        this.background,
        cam.viewportWidth / 2 - this.background.getRegionWidth() / 2,
        cam.viewportHeight / 2 - this.background.getRegionHeight() / 2);

    batch.setColor(0, 0, 0, 1);
    BitmapFont font = Assets.getFont();
    font.setScale(0.8f, -0.8f);
    font.draw(batch, "SERVER", 278, 151);
    font.draw(batch, "CLIENT", 278, 181);
    batch.setColor(1, 1, 1, 1);
    batch.draw(this.arrow, 236, 139 + 30 * this.option);
    String back = Keys.toString(KeyMapping.gameKeyToInt(GameKeys.START)) + ": EXIT GAME";
    String howto =
        "<JUMP> OR " + Keys.toString(KeyMapping.gameKeyToInt(GameKeys.JUMP)) + ": SELECT ITEM";
    font.draw(batch, back, 25, 25);
    font.draw(batch, howto, 25, 55);

    font.setColor(Color.RED);
    font.draw(batch, warning, 60, 305);

    font.setColor(Color.WHITE);
    batch.end();
  }
Exemple #19
0
  private void initScreenMode() {
    switch (project.getScreenMode()) {
      case STRETCH:
        stage.setViewport(virtualWidth, virtualHeight, false);
        screenshotWidth = ScreenValues.SCREEN_WIDTH;
        screenshotHeight = ScreenValues.SCREEN_HEIGHT;
        screenshotX = 0;
        screenshotY = 0;
        break;

      case MAXIMIZE:
        stage.setViewport(virtualWidth, virtualHeight, true);
        screenshotWidth = maximizeViewPortWidth;
        screenshotHeight = maximizeViewPortHeight;
        screenshotX = maximizeViewPortX;
        screenshotY = maximizeViewPortY;
        break;

      default:
        break;
    }
    camera = (OrthographicCamera) stage.getCamera();
    camera.position.set(0, 0, 0);
    camera.update();
  }
Exemple #20
0
  @Override
  public void render(float delta) {

    Gdx.gl.glClearColor(0, 0.3f, 0.6f, 1);
    Gdx.gl.glClear(GL10.GL_COLOR_BUFFER_BIT);

    camara.update();
    juego.spriteBatch.setProjectionMatrix(camara.combined);

    // Muestra un menú de inicio
    juego.spriteBatch.begin();
    juego.fuente.draw(juego.spriteBatch, "Fin del juego!!!!", 100, 150);
    juego.fuente.draw(
        juego.spriteBatch, "Si quieres jugar otra partida pulsa la tecla 'N'", 100, 110);
    juego.fuente.draw(juego.spriteBatch, "Pulsa 'ESCAPE' para SALIR", 100, 90);
    juego.spriteBatch.end();

    /*
     * Si el usuario toca la pantalla se inicia la partida
     */
    if (Gdx.input.isKeyPressed(Keys.N)) {
      /*
       * Aquí habrá que reiniciar algunos aspectos del
       * juego de cara a empezar una nueva partida
       */
      juego.setScreen(new GameScreen(juego));
    }
    /*
     * El usuario pulsa la tecla ESCAPE, se sale del juego
     */
    else if (Gdx.input.isKeyPressed(Keys.ESCAPE)) {
      dispose();
      System.exit(0);
    }
  }
Exemple #21
0
  @Override
  public void render(float arg0) {
    Gdx.gl.glClear(GL10.GL_COLOR_BUFFER_BIT);
    camera.update();
    if (Gdx.input.isKeyPressed(Input.Keys.ESCAPE)) {
      if (focused) {
        focused = false;
      } else {
        goBack();
      }
    }

    if (focused) {
      shapeRenderer.begin(ShapeType.FilledRectangle);
      Color c = new Color(0.15f, 0.4f, 0.15f, 1f);
      shapeRenderer.setColor(c);
      shapeRenderer.filledRect(focusedBox.x, focusedBox.y, focusedBox.width, focusedBox.height);
      shapeRenderer.end();
    }

    batch.begin();
    ObjectMap.Entries<String, Rectangle> it = bindingButtons.entries();
    // draw back button text
    font.draw(batch, "Back", backButton.x, backButton.y + backButton.height);
    // draw option texts
    while (it.hasNext()) {
      ObjectMap.Entry<String, Rectangle> entry = it.next();
      Rectangle bounds = entry.value;
      font.draw(batch, entry.key, bounds.x, bounds.y + bounds.height);
      Binding binding = game.getBindings().get(entry.key);
      font.draw(batch, binding.character, bounds.x + 200.0f, bounds.y + bounds.height);
    }
    batch.end();
  }
Exemple #22
0
 /** used because actors usually need to run the full constructor before adding things to them */
 public GameRoot init() {
   /**
    * gameroot is 16 units wide and whatever units high, keeping aspect ratio. not too important..
    */
   this.setSize(16, (screenH / screenW) * 16);
   cam.setToOrtho(false, getWidth(), getHeight());
   cam.update();
   this.addListener(
       new EventListener() {
         @Override
         public boolean handle(Event event) {
           if (event instanceof MobRemoveEvent) {
             ((MobRemoveEvent) event).removeMob();
             if (event instanceof MobTouchedEvent) {
               stats.pointUp();
               screen.pointsChanged(stats.getPoints());
             } else if (event instanceof MobExplodeEvent) {
               screen.mobExploded(stats.mobExploded());
               if (stats.getStrikes() >= 5 && !gameOver) gameOver();
             }
           }
           return false;
         }
       });
   stats.reset();
   gameOver = false;
   return this;
 }
Exemple #23
0
 public void draw(float deltaTime) {
   GLCommon gl = Gdx.gl;
   gl.glClear(GL10.GL_COLOR_BUFFER_BIT);
   renderer.render();
   guiCam.update();
   batcher.setProjectionMatrix(guiCam.combined);
   batcher.enableBlending();
   batcher.begin();
   switch (state) {
     case GAME_READY:
       presentReady();
       break;
     case GAME_RUNNING:
       presentRunning();
       break;
     case GAME_PAUSED:
       presentPaused();
       break;
     case GAME_LEVEL_END:
       presentLevelEnd();
       break;
     case GAME_OVER:
       presentGameOver();
       break;
   }
   batcher.end();
 }
Exemple #24
0
  @Override
  public void render() {
    // clear the screen with a dark blue color. The
    // arguments to glClearColor are the red, green
    // blue and alpha component in the range [0,1]
    // of the color to be used to clear the screen.
    Gdx.gl.glClearColor(0, 0, 0.2f, 1);
    Gdx.gl.glClear(GL10.GL_COLOR_BUFFER_BIT);

    // tell the camera to update its matrices.
    camera.update();

    // tell the SpriteBatch to render in the
    // coordinate system specified by the camera.
    batch.setProjectionMatrix(camera.combined);

    // begin a new batch and draw the bucket and
    // all drops
    batch.begin();
    batch.draw(bucketImage, bucket.x, bucket.y);
    for (Rectangle raindrop : raindrops) {
      batch.draw(dropImage, raindrop.x, raindrop.y);
    }
    batch.end();
    //

    // process user input
    if (Gdx.input.isTouched()) {
      Vector3 touchPos = new Vector3();
      touchPos.set(Gdx.input.getX(), Gdx.input.getY(), 0);
      camera.unproject(touchPos);
      bucket.x = touchPos.x - 48 / 2;
    }
    if (Gdx.input.isKeyPressed(Keys.LEFT)) bucket.x -= 200 * Gdx.graphics.getDeltaTime();
    if (Gdx.input.isKeyPressed(Keys.RIGHT)) bucket.x += 200 * Gdx.graphics.getDeltaTime();

    // make sure the bucket stays within the screen bounds
    if (bucket.x < 0) bucket.x = 0;
    if (bucket.x > 800 - 48) bucket.x = 800 - 48;

    // commit

    // check if we need to create a new raindrop
    if (TimeUtils.nanoTime() - lastDropTime > 1000000000) spawnRaindrop();

    // move the raindrops, remove any that are beneath the bottom edge of
    // the screen or that hit the bucket. In the later case we play back
    // a sound effect as well.
    Iterator<Rectangle> iter = raindrops.iterator();
    while (iter.hasNext()) {
      Rectangle raindrop = iter.next();
      raindrop.y -= 200 * Gdx.graphics.getDeltaTime();
      if (raindrop.y + 48 < 0) iter.remove();
      if (raindrop.overlaps(bucket)) {
        dropSound.play();
        iter.remove();
      }
    }
  }
 @Override
 public boolean touchDragged(int screenX, int screenY, int pointer) {
   mCurrentPos.set(screenX, screenY, 0);
   camera.unproject(mCurrentPos);
   camera.position.sub(mCurrentPos.sub(mCamPos));
   camera.update();
   return true;
 }
 // Constructor
 public PlayScreen(KingsValley game) {
   this.game = game;
   camera = new OrthographicCamera();
   this.ratio = (float) Gdx.graphics.getWidth() / (float) Gdx.graphics.getHeight();
   camera.setToOrtho(true, this.ratio * this.zoom, this.zoom);
   camera.position.set(544f / 2f, 480f / 2f, 0f);
   camera.update();
 }
Exemple #27
0
  private void cameraUpdate(float delta) {
    Vector3 position = camera.position;
    position.x = player.getPosition().x * PPM;
    position.y = player.getPosition().y * PPM;
    camera.position.set(position);

    camera.update();
  }
  @Override
  public void render(float delta) {
    Gdx.gl.glClearColor(0, 0, 0.2f, 1);
    Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);

    camera.update();
    ui.draw();
  }
 public void resize(int width, int height) {
   game.WIDTH = width;
   game.HEIGHT = height;
   game.scaleWidth = (float) width / game.SCALE;
   camera.viewportWidth = width;
   camera.viewportHeight = height;
   camera.update();
 }
 @Override
 public void update() {
   orthoCam.update();
   synchronized (world) {
     if (world == null) System.out.println("null");
     world.step(dt, 6, 2);
   }
 }