¿Detecta si un sprite ha dejado la cámara en libgdx?

¿Hay algún método para saber si un sprite ha salido de la cámara del escenario? o tengo que hacer mis operaciones? :PAGS

La clase Camera contiene un objeto Frustum con el método público pointInFrustum (punto Vector3) que devuelve verdadero si su sprite está dentro del tronco de la cámara. También puede echar un vistazo a la wiki del usuario para otras técnicas de eliminación. http://code.google.com/p/libgdx-users/wiki/Culling

Si está creando un juego 2D con mosaicos, puede implementar fácilmente su propio sacrificio, que es mucho más barato, ya que solo tiene que calcular exactamente lo que necesita dentro de su matriz de mosaicos.

Cosas que debes saber:

• Ubicación de la cámara
• Ancho de ventana / altura
• Ancho / altura del azulejo

Ahora podemos calcular cuántos mosaicos se deben dibujar.

• Total de mosaicos horizontales en pantalla = viewport.width / tileWidth
• Total de mosaicos verticales en pantalla = viewport.height / tileHeight

Las matemáticas dependen de cómo se configura todo, pero es muy simple. Por ejemplo, hace una diferencia si el centro de la pantalla es la ubicación de la cámara, la parte superior izquierda o la inferior izquierda.

Deberías terminar con algo como esto:

int startX = cameraWorldPosX / tileWidth;
int startY = cameraWorldPosY / tileHeight;

//When you have the position of the camera in the center of the screen you do something like this:

int startX = (cameraWorldPosX - viewport.width / 2) / tileWidth;
int startY = (cameraWorldPosY - viewport.height / 2) / tileHeight;

for (int y = startY; y < startY + viewportWidth / tileWidth; y++)
{
    for (int x = startX; x < startX + viewportHeight / tileHeight; x++)
    {
        //Draw logic
    }
}

El beneficio de esto sobre la comprobación de si un punto está dentro de su tronco es que con este último necesita iterar sobre cada punto en lugar de usar una matriz simple donde siempre itera sobre una cantidad establecida de mosaicos que es igual a la cantidad de mosaicos horizontales * fichas verticales que realmente necesitan dibujar. De esta manera, puede tener mapas enormes y aún así tener una buena velocidad de fotogramas. Desafortunadamente, esto se vuelve más difícil y complicado cuando se usa 3D, pero se vuelve exponencialmente más difícil con la libertad que el usuario obtiene con la cámara. Puede imaginar que una cámara de perspectiva fija que se mueve con el personaje solo necesita un par de variables codificadas para hacer los mismos trucos en una matriz de mallas que representan su mapa.

Simplemente use la verificación de la esfera delimitadora (puede calcular el radio usando pitagógoras) Es rápido como el infierno y también funciona con rotación. No es perfecto, pero nunca causa un sacrificio falso.

Para la versión optimizada ad hoc Intersector, algunos rectángulos contienen métodos rectanle que también pueden funcionar. Pero debe calcular el rectángulo para el frustum de la cámara.

Esta función verifica si un actor es visible (funciona solo para 2D). Funciona en todas las situaciones, por ejemplo cuando el actor está dentro de un grupo.

    /**
     * Returns if the actor is visible or not. Useful to implement 2D culling.
     **/
    public static boolean actorIsVisible(Actor actor) {
        Vector2 actorStagePos = actor.localToStageCoordinates(new Vector2(0,0));
        Vector2 actorStagePosTl = actor.localToStageCoordinates(new Vector2(
            actor.getWidth(), 
            actor.getHeight()));

        Vector3 actorPixelPos = new Vector3(actorStagePos.x, actorStagePos.y, 0);
        Vector3 actorPixelPosTl = new Vector3(actorStagePosTl.x, actorStagePosTl.y, 0);

        actorPixelPos = actor.getStage().getCamera().project(actorPixelPos);
        actorPixelPosTl = actor.getStage().getCamera().project(actorPixelPosTl);

        return !(actorPixelPosTl.x < 0 ||
                 actorPixelPos.x > Gdx.graphics.getWidth() ||
                 actorPixelPosTl.y < 0 ||
                 actorPixelPos.y > Gdx.graphics.getHeight()
                );
    }