Ahora vamos a ver rápidamente cómo usar una cámara, algo que no hemos usado en ninguno de los tutoriales anteriores. Usar una cámara tiene un par de ventajas. Le brinda una forma más fácil de manejar la resolución del dispositivo, ya que LibGDX escalará los resultados para que coincidan con la resolución de su dispositivo. También facilita mover la vista cuando la escena es más grande que una sola pantalla. Eso es exactamente lo que vamos a hacer en el siguiente ejemplo de código.
Estoy usando una imagen grande (2048×1024) que obtenido aquí.
Bien, ahora el código:
paquete com.gamefromscratch;
importar com.badlogic.gdx.ApplicationListener;
importar com.badlogic.gdx.Gdx;
importar com.badlogic.gdx.graphics.GL10;
importar com.badlogic.gdx.graphics.OrthographicCamera;
importar com.badlogic.gdx.graphics.Textura;
importar com.badlogic.gdx.graphics.Texture.TextureFilter;
importar com.badlogic.gdx.graphics.g2d.Sprite;
importar com.badlogic.gdx.graphics.g2d.SpriteBatch;
importar com.badlogic.gdx.input.GestureDetector;
importar com.badlogic.gdx.input.GestureDetector.GestureListener;
importar com.badlogic.gdx.math.Vector2;
público clase CámaraDemo implementos ApplicationListener, GestureListener {
privado Cámara Ortográfica cámara;
privado SpriteLote lote;
privado Textura textura;
privado Duende duende;
@Anular
público vacío crear() {
cámara = nuevo Cámara ortográfica (1280, 720);
lote = nuevo SpriteLote();
textura = nuevo Textura (Gdx.archivos.interno(“datos/Toronto2048wide.jpg”));
textura.setFilter(TextureFilter.LinealFiltro de textura.Lineal);
duende = nuevo Duende(textura);
duende.setOrigen(0,0);
duende.posición de ajuste(-duende.getAncho()/2,-duende.getHeight()/2);
Gdx.aporte.setInputProcessor(nuevo Detector de gestos(este));
}
@Anular
público vacío disponer () {
lote.disponer();
textura.disponer();
}
@Anular
público vacío prestar() {
Gdx.gl.glClearColor(1, 1, 1, 1);
Gdx.gl.glBorrar(GL10.GL_COLOR_BUFFER_BIT);
lote.setProjectionMatrix(cámara.conjunto);
lote.comenzar();
duende.dibujar(lote);
lote.fin();
}
@Anular
público vacío redimensionar(En t ancho, En t altura) {
}
@Anular
público vacío pausa() {
}
@Anular
público vacío reanudar() {
}
@Anular
público booleano aterrizaje(flotar X, flotar y, En t puntero, En t botón) {
// HACER Stub de método generado automáticamente
falso retorno;
}
@Anular
público booleano grifo(flotar X, flotar y, En t contar, En t botón) {
// HACER Stub de método generado automáticamente
falso retorno;
}
@Anular
booleano público pulsación larga(flotar X, flotar y) {
// HACER Stub de método generado automáticamente
falso retorno;
}
@Anular
público booleano arrojar(flotar velocidadX, flotar velocidadY, En t botón) {
// HACER Stub de método generado automáticamente
falso retorno;
}
@Anular
público booleano cacerola(flotar X, flotar y, flotar deltaX, flotar delta Y) {
// HACER Stub de método generado automáticamente
cámara.translate(deltaX,0);
cámara.actualizar();
falso retorno;
}
@Anular
público booleano zoom(flotar distancia inicial, flotar distancia) {
// HACER Stub de método generado automáticamente
falso retorno;
}
@Anular
público booleano pinch(Vector2 punteroinicial1, Vector2 punteroinicial2,
Vector2 puntero1, Vector2 puntero2) {
// HACER Stub de método generado automáticamente
falso retorno;
}
}
Además, en Main.java cambié la resolución a 720p así:
paquete com.gamefromscratch;
importar com.badlogic.gdx.backends.lwjgl.LwjglApplication;
importar com.badlogic.gdx.backends.lwjgl.LwjglApplicationConfiguration;
clase pública Principal {
público estático vacío principal (cadena[] argumentos) {
LwjglApplicationConfiguration cfg = nuevo LwjglApplicationConfiguration();
cfg.título = «cámara»;
cfg.usarGL20 = FALSO;
cfg.ancho = 1280;
cfg.altura = 720;
nuevo AplicaciónLwjgl(nuevo CámaraDemo(), cfg);
}
}
Cuando lo ejecutes verás:
Aparte de ser una imagen del horizonte de mi ciudad, es pan-able. Puede deslizar el dedo hacia la izquierda o hacia la derecha para desplazar la imagen.
El código es mayormente familiar en este punto, pero la nueva línea importante es:
cámara = nuevo Cámara ortográfica (1280, 720);
Aquí es donde creamos la cámara. Hay dos tipos de cámaras en LibGDX, Orthographic y Perspective. Básicamente, una cámara ortográfica muestra lo que hay en la escena exactamente del tamaño que tiene. Una cámara en perspectiva, por otro lado, emula la forma en que funciona el ojo humano, al hacer que los objetos sean un poco más pequeños a medida que se alejan. Aquí hay un ejemplo de mi Serie de tutoriales de Blender.
Perspectiva:
Ortográfico:
¿Observa cómo el ala lejana es más pequeña en el renderizado en perspectiva? Eso es lo que la renderización en perspectiva hace por ti. Sin embargo, en el renderizado 2D, 99 de cada 100 veces desea utilizar Orthographic.
Los valores pasados al constructor son la resolución de la cámara, el ancho y el alto. En este caso particular, elegí usar píxeles para mi resolución, ya que quería tener un renderizado de 1280×720 píxeles. Sin embargo, no tienes que hacerlo… si estás usando física y quieres usar unidades del mundo real, por ejemplo, podrías haber optado por metros, o lo que quieras. La clave es que su relación de aspecto sea correcta. El resto del código en create() se trata de cargar nuestra imagen y posicionarla sobre el origen en el mundo. Finalmente, conectamos nuestro controlador de gestos para que podamos movernos/deslizarnos hacia la izquierda y hacia la derecha en la imagen.
La siguiente llamada importante está en render():
lote.setProjectionMatrix(cámara.conjunto);
Esto vincula nuestro objeto de cámara LibGDX al renderizador OpenGL. El proceso de renderizado de OpenGL depende de una serie de matrices para traducir correctamente desde la escena o el mundo a las coordenadas de la pantalla durante el renderizado. cámara.conjunto devuelve las matrices de vista y proyección de la cámara multiplicadas. Si desea obtener más información sobre las matemáticas detrás de escena, puede leer aquí. Por supuesto, el objetivo de las clases de cámara es que no tenga que preocuparse por estas cosas, así que si lo encuentra confuso, no se preocupe, LibGDX se encarga de las matemáticas por usted.
Finalmente, en nuestro controlador pan (¿eh?) Tenemos el siguiente código:
cámara.translate(deltaX,0);
cámara.actualizar();
Puede usar traducir para mover la cámara. Aquí movemos la cámara a lo largo del eje X en la cantidad que el usuario deslizó. Esto hace que la vista de la imagen se mueva a medida que el usuario desliza la pantalla o desplaza el mouse. Una vez que haya terminado de modificar la cámara, debe actualizarla. Sin llamar a update(), la cámara nunca se movería.
Hay una serie de funciones ordenadas en la cámara que no usamos aquí. Hay funciones para mirar un punto en el espacio, para rotar o incluso rotar (orbitar) un vector. También hay funciones para proyectar hacia y desde la pantalla al espacio mundial, así como código para proyectar rayos en la escena. En un juego 2D directo, aunque generalmente no utilizarás mucho esta funcionalidad. Podemos echar un vistazo más de cerca a la clase de cámara más adelante cuando saltemos a 3D.
