LIBGDX Scene UI

De MediaWiki
Saltar a: navegación, buscar

UNIDADE 3: Scene2D UI

Introdución

Información na wiki: https://github.com/libgdx/libgdx/wiki/Scene2d.ui


Neste punto imos explicar outro recurso do framework que é o Scene2d-ui (scene 2d user interface).

Ven ser como o Scene pero aplicado os recursos gráficos que imos necesitar para construír unha interface de usuario. Este paquete incorpora moitas clases típicas dunha interface (botóns, cadros de texto, checkbox....).

O Scene é outra forma de xestionar os elementos gráficos nun xogo. Basease no uso de Actor´s. Cada Actor ven ser un elemento gráfico do xogo sobre o cal queremos ter algún control. Permite debuxar e xestionar o control do elemento dentro da propia clase Actor (mestura Modelo-Vista-Controlador). Fai que o seu control sexa moi sinxelo e como característica que a min máis me gosta, ten a posibilidade de asociar a cada Actor unha serie de accións. As accións poden afectar ó seu aspecto (deformalo, cambiarlle a cor,....) como a súa posición,... Ditas accións pódense programar para que vaian unha detrás doutra, en paralelo, que se executen despois dun tempo, que se repitan....

Centrándonos no Scene2D UI, teremos esas mesmas opcións pero aplicados a elementos gráficos propios dun deseño da interface dun usuario.


Elementos necesarios

Necesitamos:

  • Un Atlas con todos os gráficos necesarios: Os gráficos das fontes, dos botóns,....
  • Un arquivo json no que están definidos a cor, fonte, gráficos...para cada elemento gráfico. É o que se coñece como un estilo e ven ser un obxecto da clase Skin.


O estilo o podemos xerar por programación, pero o máis normal é telo nun arquivo externo coa extensión json.

Como punto de partido imos a utilizar o arquivo json xunto cos bmp, atlas e fonte necesarios que veñen nos exemplos do motor de xogos: https://github.com/libgdx/libgdx/tree/master/tests/gdx-tests-android/assets/data => Arquivo uiskin.atlas, uiskin.png,uiskin.json e default.fnt.

Podedes descargar estes arquivos dende este enlace: Media:LIBGDX_stage2dui.zip

Nota: Se descargades os arquivos do sitio web, o estilo definido para a lista variou, polo que vos dará un erro. Podedes ver a diferenza no arquivo adxunto.


Descomprimide os arquivos e copialos ó cartafol Assets do proxecto Android.


Nota:

O que imos facer con estes arquivos é crear un estilo (parecido o CSS de HTML ou os arquivos skin de ASP.NET).

Se editamos o arquivo json podemos ver entre outras cousas:

  1. com.badlogic.gdx.graphics.g2d.BitmapFont: { default-font: { file: default.fnt } },
  2. com.badlogic.gdx.graphics.Color: {
  3. green: { a: 1, b: 0, g: 1, r: 0 },
  4. white: { a: 1, b: 1, g: 1, r: 1 },
  5. red: { a: 1, b: 0, g: 0, r: 1 },
  6. black: { a: 1, b: 0, g: 0, r: 0 }
  7. },
  8. com.badlogic.gdx.scenes.scene2d.ui.Skin$TintedDrawable: {
  9. dialogDim: { name: white, color: { r: 0, g: 0, b: 0, a: 0.45 } }
  10. },
  11. com.badlogic.gdx.scenes.scene2d.ui.Button$ButtonStyle: {
  12. default: { down: default-round-down, up: default-round },
  13. toggle: { down: default-round-down, checked: default-round-down, up: default-round }
  14. },
  15. .......................

Analicemos o código:

Nesta liña:

  1. com.badlogic.gdx.graphics.g2d.BitmapFont: { default-font: { file: default.fnt } },

Indicamos o tipo de fonte de texto que imos a usar (arquivo default.fnt) nos elementos gráficos (label´s, botóns con texto,...)


Aquí definimos constantes de cores:

  1. com.badlogic.gdx.graphics.Color: {
  2. green: { a: 1, b: 0, g: 1, r: 0 },
  3. white: { a: 1, b: 1, g: 1, r: 1 },
  4. red: { a: 1, b: 0, g: 0, r: 1 },
  5. black: { a: 1, b: 0, g: 0, r: 0 }
  6. },


Aquí definimos o estilo dos botóns:

  1. com.badlogic.gdx.scenes.scene2d.ui.Button$ButtonStyle: {
  2. default: { down: default-round-down, up: default-round },
  3. toggle: { down: default-round-down, checked: default-round-down, up: default-round }
  4. },

Por defecto cando prememos sobre un, poñerá o gráfico 'default-round-down' e o soltalo 'default-round'. Ditos gráficos os podedes atopar no atlas.

Proceso de uso

Cargar o atlas e o estilo asociado

Para cargar os estilos necesitamos utilizar a clase AssetManager:

  1.         private AssetManager assetManager;
  2.         private Skin skin;
  3.         ............
  4.  
  5.         @Override
  6.         public void create () {
  7.                 ............
  8.  
  9.                 assetManager = new AssetManager();
  10.                 assetManager.load("uiskin.atlas",TextureAtlas.class);
  11.                 assetManager.finishLoading();
  12.                 TextureAtlas atlas = assetManager.get("uiskin.atlas", TextureAtlas.class);
  13.                 skin = new Skin(Gdx.files.internal("uiskin.json"), atlas); // Cargamos os estilos
  14.         }
  15.  
  16.         @Override
  17.         public void dispose() {
  18.  
  19.                 assetManager.dispose();
  20.                 skin.dispose();
  21.         }


Elementos gráficos do scene2d UI

Máis información en: https://github.com/libgdx/libgdx/wiki/Scene2d.ui#layout-widgets

Unha vez cargados os elementos gráficos entramos no Scene2D.

Este manual é unha pequena introdución do que se pode facer, polo que explicaremos con exemplos, algunhas das posibilidades.

Ó igual que sucede en Android, imos ter diferentes formas de colocar os elementos gráficos na pantalla. O modo en como se colocan é o que se coñece como layout.

A nivel de layout dispoñemos das seguintes opcións:

Un dos máis habituais a utilizar é o Table.

Tedes neste enlace unha explicación bastante completa sobre este layout e o que se pode facer.


Unha vez decidido o layout (como se van colocar os elementos) pasaríamos a engadir os elementos gráficos (Widgets) que conformarán a nosa pantalla.

Entre eles temos:

E moitos outros.

Para poder debuxar todos estes elementos (layout e widgets) imos facer uso da clase Stage.

Dentro do Stage existen 'Actors' que son os elementos que se debuxan (widgets). Cada actor ten unha textura, posición, tamaño....


O Stage vai ter dous métodos moi importantes: act e draw.

   O método act vai 'actualizar' todos os actores que se atopen engadidos ó Stage: Neste punto actualizaríamos posicións (se ten accións asociadas, por exemplo)
   O método draw vai debuxar todos os actores que se atopen no Stage. 


Por exemplo, imos facer que o Stage estea composto por un label cun texto.

  1.         private Stage stage;
  2.         ...........
  3.         @Override
  4.         public void create () {
  5.  
  6.                 assetManager = new AssetManager();
  7.                 assetManager.load("uiskin.atlas",TextureAtlas.class);
  8.                 assetManager.finishLoading();
  9.                 TextureAtlas atlas = assetManager.get("uiskin.atlas", TextureAtlas.class);
  10.                 skin = new Skin(Gdx.files.internal("uiskin.json"), atlas); // Cargamos os estilos
  11.        
  12.                 stage = new Stage();
  13.                 cargarElementosGraficos();
  14.                
  15.         }
  16.         private void cargarElementosGraficos(){
  17.                 Label titulo = new Label("Texto de exemplo",skin);
  18.                 titulo.setColor(Color.RED);
  19.                 titulo.setFontScale(2);
  20.                 titulo.setBounds(0, 100, Gdx.graphics.getWidth(), 10);
  21.                 titulo.setAlignment(Align.center);
  22.  
  23.                 stage.addActor(titulo);
  24.         }
  25.  
  26.         @Override
  27.         public void resize(int width, int height) {
  28.         // TODO Auto-generated method stub
  29.                 stage.getViewport().update(width, height, true);
  30.         }
  31.         @Override
  32.         public void dispose() {
  33.  
  34.                 assetManager.dispose();
  35.                 skin.dispose();
  36.                
  37.                 stage.dispose();
  38.         }
  • Liñas 16-24: Creamos un elemento gráfico de tipo Label, cun texto e o estilo cargado previamente.
Indicamos:
Liña 18: Unha cor.
Liña 19: Un tamaño.
Liña 20: Unha posición e tamaño que vai ocupar o contenedor que ten o label (ven ser como un bloque que rodea ó label).
Liña 21: Aliñación do texto dentro do bloque. Neste caso centrado xa que o bloque ocupa todo o ancho da pantalla.
Liña 23: Engadimos o Actor (a etiqueta) ó Stage.

O Stage vai ter a súa propia cámara co que vai debuxar todos os actores.

Para facelo:

  1.         @Override
  2.         public void render() {
  3.                 Gdx.gl.glClearColor(0, 0, 0, 1);
  4.                 Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
  5.                
  6.                 stage.act(Gdx.graphics.getDeltaTime());
  7.                 stage.draw();
  8.         }
Liña 6: Se os actores tiveran algunha acción ou o programador modificar a súa posición, chamando o método act se actualizarían.
Liña 7: Debuxa todos os actores do Stage.

Agora amosaremos un exemplo de uso dunha táboa, engadindo un TextButton e o Label anterior a unha táboa, e engadindo a táboa o Stage:

Nota: Lembrar que tedes neste enlace unha explicación bastante completa sobre este layout e o que se pode facer.


  1.         private void cargarElementosGraficos(){
  2.                
  3.                 Table tabla = new Table(skin);
  4.                 tabla.setFillParent(true);
  5.                 tabla.defaults().space(5); // Espazo por defecto arredor dos compoñenetes
  6.                 tabla.defaults().fillX(); // o elemento (label,botón,..) ocupa todo o ancho => centrar
  7.                 tabla.align(Align.top|Align.center);
  8.                
  9.                 Label titulo = new Label("Texto de exemplo",skin);
  10.                 titulo.setColor(Color.RED);
  11.                 titulo.setFontScale(2);
  12.                 titulo.setBounds(0, 100, Gdx.graphics.getWidth(), 10);
  13.                 titulo.setAlignment(Align.center);
  14.                 titulo.setPosition(20, 50);
  15.                
  16.                 tabla.add(titulo);
  17.                 tabla.row();
  18.                 tabla.row();
  19.                
  20.                 TextButton boton = new TextButton("Premer aquí", skin);
  21.                
  22.                 tabla.add(boton).height(100).width(100);
  23.                
  24.                 stage.addActor(tabla);
  25.         }

Nota: Notaredes que cando prememos o botón no pasa nada e non cambia de aspecto.

Veremos como cando engadamos o evento todo aparece correctamente.


Eventos e Accións

Eventos

Para xestionar os eventos dos botóns (ou de calquera outro elemento gráfico) temos que utilizar a interface asociada á xestión de dito evento.

  • Pero primeiro temos que indicarlle que os eventos os vai xestionar o Stage.

Nota: Se o voso xogo xa ten unha xestión de eventos (usando o InputProcessor) necesitaredes incorporar esta outra forma e polo tanto teredes que ler este enlace: http://mediawiki.cifprodolfoucha.es/index.php?title=LIBGDX_Xestion_Eventos_GestureListener#Xestionando_m.C3.BAltiples_interfaces_de_eventos

  1.         @Override
  2.         public void create () {
  3.             ..............
  4.             Gdx.input.setInputProcessor(stage);
  5.  
  6.  
  7.         }
  8.         @Override
  9.         public void dispose() {
  10.  
  11.                 Gdx.input.setInputProcessor(null);
  12.                 ............
  13.         }
  • Despois temos que engadir a interface ó botón. No exemplo anterior:
  1.                 boton.addListener(new ClickListener(){
  2.                         public void clicked (InputEvent event, float x, float y) {
  3.                                 Gdx.app.exit();
  4.                                 }
  5.                 });

Neste exemplo sairemos da aplicación ó premer.


Diálogos

Pode ser interesante que apareza unha caixa de diálogo preguntando se estamos seguros de querer saír.

Para facelo temos que utilizar a clase Dialog

Un exemplo de uso, sobre o botón anterior:

  1. new Dialog("Sair do xogo", skin, "dialog") { // Os acentos non aparecen xa que non están no png das letras
  2.        protected void result (Object object) {
  3.                     if ((Boolean) object)
  4.                          Gdx.app.exit();
  5.        }
  6. }.text("Estás seguro de querer sair ?")
  7. .button("Yes", true)
  8. .button("No",false)
  9. .key(Keys.ENTER, true)
  10. .key(Keys.ESCAPE, false)
  11. .show(stage);

Analicemos o código:

  • Liña 1: Creamos un obxecto da clase Dialog, indicando o título, o estilo e o tipo de diálogo.

O tipo de diálogo está definido no arquivo uiskin.json:

com.badlogic.gdx.scenes.scene2d.ui.Window$WindowStyle: {
        default: { titleFont: default-font, background: default-window, titleFontColor: white },
        dialog: { titleFont: default-font, background: default-window, titleFontColor: white, stageBackground: dialogDim }
},
  • Liña 2-5: A este método se chamará automaticamente cando escollamos unha das opcións do Dialog. O parámetro vai servir para saber que se escolleu (true / false = aceptar/cancelar).
  • Liña 5: Texto que aparece no diálogo.
  • Liña 6-7: Texto e valores asociados ás opción de Aceptar-Cancelar. Neste caso valores true/false que son os usados como valores recibidos no método result analizado na liña anterior.
  • Liñas 8-9: Que teclas teñen os mesmos efectos que premer sobre as opcións do diálogo. No exemplo, premer a tecla ENTER ten o mesmo efecto que premer o botón Yes.
  • Liña 10: Amosar o diálogo no Stage.

Este código tería que ser chamado dende o click do botón.


Botón BACK de Android

Como sabedes, cando prememos o botón BACK dun dispositivo Android estamos a pechar a aplicación.

Libgdx permite capturar dito evento e preguntar (como fixemos antes) se realmente queremos saír do xogo.

Para facelo:

  • Temos que chamar ó método setCatchBackKey do paquete Gdx.input, indicando true como parámetro.
  • Sobreescribimos ó método keyDown do Stage.
  1.         @Override
  2.         public void create () {
  3.             ...........
  4.             Gdx.input.setCatchBackKey(true);
  5.             stage = new Stage(){
  6.                         @Override
  7.                         public boolean keyDown(int keyCode) {
  8.                            if (keyCode == Keys.BACK) {
  9.                                 // CHAMAMOS O DIALOGO PARA PECHAR OU NON
  10.                            }
  11.                            return super.keyDown(keyCode);
  12.                         }
  13.                 };
Accións

Información na wiki: https://github.com/libgdx/libgdx/wiki/Scene2d#actions

É un dos elementos máis espectaculares que ten este tipo de programación.

O uso da clase Stage vainos permitir facer diferentes accións sobre os actors que o compoñen.

Dispoñemos de 3 tipos de accións:

1. Accións animadas.
2. Accións compostas.
3. Outras accións.


As accións animadas modifican varias propiedades dos actor´s, coma a posición, rotación, escala e factor alfa. Son as seguintes.

  • FadeIn – modifica o factor alfa do actor do valor que teña ó valor 1.
  • FadeOut - modifica o factor alfa do actor do valor que teña ó valor 0.
  • FadeTo - modifica o factor alfa do actor do valor que teña ó valor especificado.
  • MoveBy – move o actor unha distancia especificada.
  • MoveTo – move o actor a unha posición específica.
  • RotateBy – rota o actor engadindo ó ángulo especificado.
  • RotateTo – rota o actor ata un ángulo especificado.
  • ScaleTo – escala o actor ó valor indicado.


Accións compostas combinan múltiple accións en unha:

  • Parallel – executa todas as accións en paralelo. Todas á vez.
  • Sequence – executa todas as accións en secuencia. Unha detrás de outra.


Outras accións:

  • Repeat – repite a acción n-veces.
  • Forever – repite a acción indefinidamente.
  • Delay – retrasa a execución dunha acción o tempo especificado.
  • Remove – elimina o Actor especificado do Stage.


As accións poden aplicarse sobre cada Actor ou sobre o Stage completo.

Por exemplo, imos facer que a pantalla apareza toda negra e vaian aparecendo os compoñentes do Stage.

Para iso temos que utilizar as Accións: Actions.fadeOut e Actions.fadeIn.

  1.   stage.addAction(Actions.fadeOut(0));
  2.   stage.addAction(Actions.fadeIn(4));

Pero podemos facelo doutra forma máis elegante, xa que a acción pode estar composta por moitas accións as cales se poden executar en paralelo, secuencial, .... como vimos antes.

  1. stage.addAction(Actions.sequence(Actions.fadeOut(0),Actions.fadeIn(4)));


Nota: Ós propios actores poden ter accións asociadas, chamando o método addAction de cada un deles.


Nota: Para non ter que estar escribindo continuamente Actions.acción podemos facer este import:

import static com.badlogic.gdx.scenes.scene2d.actions.Actions.*;

Outro exemplo de accións, no que movemos continuamente e de forma indefinida un botón de esquerda a dereita:

  1.     boton.addAction(Actions.forever(Actions.sequence(Actions.moveTo(0, 0, 5),Actions.moveTo(Gdx.graphics.getWidth(), Gdx.graphics.getHeight(), 5))));

Como vemos temos:

  • Actions.forever: Repite de forma indefinida a acción que ven a continuación.
  • Actions.sequence: Executa na orde indicada o conxunto de accións que veñen a continuación.
  • Actions.moveTo(0, 0, 5),Actions.moveTo(Gdx.graphics.getWidth(), Gdx.graphics.getHeight(), 5): Move cara a coordenada (0,0) o botón cunha duración de 5 segundos e move cara a esquina superior dereita o botón cunha duración de 5 segundos.

Exemplo de código

Preparación:

  • Descargade o seguinte arquivo e descomprimídeo no cartafol assets da versión Android.Media:LIBGDX_stage2dui.zip.
  • Crear unha nova clase e cambiar os diferentes proxectos para que carguen dita clase.


C¢digo da clase Stage2DUI
Obxectivo: Exemplo de uso do Stage2D ui, eventos e accións.

  1. import com.badlogic.gdx.ApplicationAdapter;
  2. import com.badlogic.gdx.Gdx;
  3. import com.badlogic.gdx.Input.Keys;
  4. import com.badlogic.gdx.assets.AssetManager;
  5. import com.badlogic.gdx.graphics.Color;
  6. import com.badlogic.gdx.graphics.GL20;
  7. import com.badlogic.gdx.graphics.g2d.TextureAtlas;
  8. import com.badlogic.gdx.scenes.scene2d.InputEvent;
  9. import com.badlogic.gdx.scenes.scene2d.Stage;
  10. import com.badlogic.gdx.scenes.scene2d.actions.Actions;
  11. import com.badlogic.gdx.scenes.scene2d.ui.Dialog;
  12. import com.badlogic.gdx.scenes.scene2d.ui.Label;
  13. import com.badlogic.gdx.scenes.scene2d.ui.Skin;
  14. import com.badlogic.gdx.scenes.scene2d.ui.Table;
  15. import com.badlogic.gdx.scenes.scene2d.ui.TextButton;
  16. import com.badlogic.gdx.scenes.scene2d.ui.TextField;
  17. import com.badlogic.gdx.scenes.scene2d.utils.Align;
  18. import com.badlogic.gdx.scenes.scene2d.utils.ClickListener;
  19.  
  20. public class Stage2DUI extends ApplicationAdapter {
  21.    
  22.         private AssetManager assetManager;
  23.         private Skin skin;
  24.         private Stage stage;
  25.        
  26.        
  27.         @Override
  28.         public void create () {
  29.  
  30.                 assetManager = new AssetManager();
  31.                 assetManager.load("uiskin.atlas",TextureAtlas.class);
  32.                 assetManager.finishLoading();
  33.                 TextureAtlas atlas = assetManager.get("uiskin.atlas", TextureAtlas.class);
  34.                 skin = new Skin(Gdx.files.internal("uiskin.json"), atlas); // Cargamos os estilos
  35.        
  36.             Gdx.input.setCatchBackKey(true);
  37.                 stage = new Stage(){
  38.                         @Override
  39.                         public boolean keyDown(int keyCode) {
  40.                         if (keyCode == Keys.BACK) {
  41.                                 avisarSair();
  42.                         }
  43.                         return super.keyDown(keyCode);
  44.                         }
  45.                 };
  46.                 Gdx.input.setInputProcessor(stage);
  47.                
  48.                 cargarElementosGraficos();
  49.                
  50.         }
  51.        
  52.         private void cargarElementosGraficos(){
  53.                
  54.                 Table tabla = new Table(skin);
  55.                 tabla.setFillParent(true);
  56.                 tabla.defaults().space(5); // Espazo por defecto arredor dos compoñenetes
  57.                 tabla.defaults().fillX(); // o elemento (label,botón,..) ocupa todo o ancho => centrar
  58.                 tabla.align(Align.top|Align.center);
  59.                
  60.                 Label titulo = new Label("Texto de exemplo",skin);
  61.                 titulo.setColor(Color.RED);
  62.                 titulo.setFontScale(2);
  63.                 titulo.setBounds(0, 100, Gdx.graphics.getWidth(), 10);
  64.                 titulo.setAlignment(Align.center);
  65.                 titulo.setPosition(20, 50);
  66.                
  67.                 tabla.add(titulo);
  68.                 tabla.row();
  69.                 tabla.row();
  70.                
  71.                 TextField texto = new TextField("", skin);
  72.                 texto.setBounds(0, 50, Gdx.graphics.getWidth(), 10);
  73.        
  74.                 tabla.add(texto);
  75.                
  76.                
  77.                 TextButton boton = new TextButton("Premer aquí", skin);
  78.                 boton.addListener(new ClickListener(){
  79.                         public void clicked (InputEvent event, float x, float y) {
  80.                                 avisarSair();
  81.                         }
  82.                 });
  83.                 boton.setPosition(0, 0);
  84.                 boton.addAction(Actions.forever(Actions.sequence(Actions.moveTo(0, 0, 5),Actions.moveTo(Gdx.graphics.getWidth(), Gdx.graphics.getHeight(), 5))));
  85.                 stage.addActor(tabla);
  86.                 stage.addActor(boton);
  87.                
  88.                 stage.setKeyboardFocus(texto);  // Poñemos o foco na caixa de texto
  89.         }
  90.        
  91.         private void avisarSair(){
  92.                 new Dialog("Sair do xogo", skin, "dialog") { // Os acentos non aparecen xa que non están no png das letras
  93.                        protected void result (Object object) {
  94.                                     if ((Boolean) object)
  95.                                          Gdx.app.exit();
  96.                        }
  97.                 }.text("Estás seguro de querer sair ?")
  98.                 .button("Yes", true)
  99.                 .button("No",false)
  100.                 .key(Keys.ENTER, true)
  101.                 .key(Keys.ESCAPE, false)
  102.                 .show(stage);
  103.  
  104.         }
  105.  
  106.         @Override
  107.         public void render() {
  108.                 Gdx.gl.glClearColor(0, 0, 0, 1);
  109.                 Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
  110.                
  111.                 stage.act(Gdx.graphics.getDeltaTime());
  112.                 stage.draw();
  113.         }
  114.         @Override
  115.         public void resize(int width, int height) {
  116.         // TODO Auto-generated method stub
  117.                 stage.getViewport().update(width, height, true);
  118.         }
  119.        
  120.         @Override
  121.         public void dispose() {
  122.  
  123.                 Gdx.input.setInputProcessor(null);
  124.                 assetManager.dispose();
  125.                 skin.dispose();
  126.                
  127.                 stage.dispose();
  128.         }
  129.  
  130.  
  131. }


Ó executar dará como resultado un botón movéndose de forma indefinida e unha caixa de texto para introducir un texto co foco nel.

LIBGDX UD3 StageUI 1.jpg


TAREFA OPTATIVA A FACER



Modifica a pantalla principal do xogo:

LIBGDX itin1 pantallapresentacion.png

E utiliza o Stage2d UI para desenvolvela.

Podes engadir efectos de fadein / fadeout ou calquera outro efecto que queiras.



-- Ángel D. Fernández González -- (2015).