Vistas de página en total

Mostrando entradas con la etiqueta multiplataforma. Mostrar todas las entradas
Mostrando entradas con la etiqueta multiplataforma. Mostrar todas las entradas

viernes, 16 de septiembre de 2016

Modos de escalado en Corona SDK

Para resumir las últimas entradas, vimos que si pintamos objetos en pantalla utilizando los pixels del dispositivo (pixels reales), tenemos un problema por los diversos tamaños de pantalla y resoluciones que tienen los distintos dispositivos. También vimos que Corona permite definir una pantalla virtual con un tamaño determinado y definiendo un modo de escalado. Vimos el modo "letterbox" que lo que hace es centrar la pantalla virtual en la pantalla física aprovechando al máximo el espacio y escalando los objetos proporcionalmente y sin deformarlos. Cuando ponemos los objetos en la pantalla virtual nos olvidamos del tamaño real de la pantalla del móvil, para nosotros sólo existe esa pantalla virtual que tiene un tamaño determinado en pixels virtuales. Obviamente, dependiendo de las proporciones del dispositivo destino, en algunos casos, la pantalla virtual no se adapta 100% a la pantalla física, y pueden quedar zonas (arriba y abajo, o bien, a izquierda y derecha) que no estén cubiertas por la pantalla virtual.
Las constantes:

    display.contentWidth
    display.contentHeight

nos dan el tamaño de la pantalla virtual (en pixels virtuales).

Todo esto en cuanto al modo "letterbox", pero éste no es el único modo de escalado que tiene Corona. En esta entrada vamos a tratar este tema para conocerlos todos y ver cuál se adapta mejor a las necesidades de nuestra aplicación o juego.

Escalado

En Corona, como ya he dicho varias veces, trabajamos con una pantalla virtual de un determinado tamaño fijo, y nuestro programa siempre va a trabajar con pixels en las coordenadas de esa pantalla virtual.
Cuando la aplicación se ejecuta en un dispositivo, los pixels virtuales se expanden (o se contraen) para rellenar la pantalla del dispositivo. A esto se le llama escalado.
Nuestro programa no tiene porqué conocer el tamaño real del dispositivo, simplemente trabaja sobre la pantalla virtual, y Corona se encargará de escalar el contenido a la pantalla física. Corona escalará todos los objetos gráficos, el texto, las imágenes, etc.
Es muy habitual definir una pantalla virtual de 320x480. Se suele utilizar este tamaño porque casi todos los dispositivos iOS y muchos Android tienen la misma relación de aspecto.
Los modos de escalado que ofrece Corona son:
  • letterbox
  • zoomEven
  • zoomStretch
  • none

Modo letterbox

Este es el modo más utilizado y el que se suele utilizar en caso de duda.
El modo letterbox nunca deforma ni corta los objetos. Por tanto, es el modo más fácil de utilizar.
Todo lo que se sitúe dentro de la pantalla virtual se mostrará en la pantalla del dispositivo sin deformaciones y sin que los objetos se salgan de la pantalla.
En modo letterbox hay tres casos a considerar:



En el primer caso, la relación de aspecto de la pantalla virtual coincide con la del dispositivo, con lo cual no tenemos que hacer nada y el escalado será perfecto.
En el segundo caso, el dispositivo es algo alargado, y por tanto, como la pantalla virtual no se puede deformar, quedará un espacio arriba y abajo de la pantalla real que no se pueda rellenar con la pantalla virtual.
En el tercer caso, el dispositivo es más ancho y por tanto, al encajar la pantalla virtual en el dispositivo (sin deformar), quedará espacio a izquierda y derecha sin deformar.

En la práctica, rellenaremos estas zonas fuera de la pantalla virtual con contenido que no sea relevante, por ejemplo con un fondo. No podemos poner objetos que sean importantes porque en algunos dispositivos no se va a visualizar.

Podemos saber el espacio que tenemos fuera de la pantalla virtual con las constantes:

    display.actualContentWidth
    display.actualContentHeight

que nos indican el tamaño total que disponemos, en coordenadas virtuales.
Así por ejemplo, si queremos poner un fondo que ocupe la pantalla entera:

    local bg = display.newRect( 
            display.contentCenterX, display.contentCenterY,
            display.actualContentWidth, display.actualContentHeight)
    bg:setFillColor(0.5, 0.4, 0,7)

Y podemos poner encima otro rectángulo que ocupe la pantalla virtual completamente, que es donde deberíamos situar el contenido importante de nuestra aplicación:

    local content = display.newRect( 
            display.contentCenterX, display.contentCenterY,
            display.contentWidth, display.contentHeight)
    content:setFillColor(0.6, 0.5, 0,8)


Ahora, dependiendo del dispositivo, veremos un caso u otro de los mencionados anteriormente para letterbox.
El fichero config.lau contiene lo siguiente:

application = {
    content = {
        width = 320,
        height = 480,
        scale = "letterbox",
    },
}

Modo zoomEven

Este modo es el más utilizado, después de letterbox. En este modo, la pantalla virtual se expande lo máximo posible, y si es necesario habrá partes de la pantalla virtual que quedarán fuera del dispositivo y no se verán. El escalado es proporcional, sin deformación (escala igual en un eje que en el otro, igual que letterbox). Lo bueno que tiene este modo es que no hay barras laterales sin rellenar. Pero tiene el inconveniente de que pueden quedar zonas de la pantalla que no se muestran.


Para ver el modo zoomEven en acción, escribamos el siguiente fichero de config.lua:

application = {
    content = {
        width = 320,
        height = 480,
        scale = "zoomEven",
    },
}

Y el siguiente main.lua:

local bg = display.newRect( display.contentCenterX, display.contentCenterY, display.contentWidth, display.contentHeight )
bg:setFillColor( 1, 1, 1 )

local circle = display.newCircle( display.contentCenterX, display.contentCenterY, display.contentWidth/2 )
circle:setFillColor( 0.3, 0.6, 0.3 )

En blanco vemos la pantalla virtual y en el centro de ésta un círculo verde, que no se deforma en ningún dispositivo, pero que se puede salir fuera de la pantalla y no dibujarse completamente según el tamaño del dispositivo final.
Si el dispositivo es iPhone 4, entonces veremos el círculo completo, porque la relación de aspecto del iPhone 4 es la misma que la de nuestra pantalla virtual (tamaños distintos pero misma relación de aspecto). Sin embargo en otros dispositivos como el iPhone 5, más alargado, el círculo se cortará.

zoomStretch

Este modo escala, deformando si es necesario, la pantalla virtual a la pantalla física. Es decir, puede escalar de forma distinta en el eje X y en el eje Y.
No se utiliza mucho este modo porque la deformación que produce no suele ser aceptable. No se me ocurre ninguna aplicación en la que pudiera ser útil este modo. Pero es bueno saber que existe, por si acaso es necesario.

none

Este modo es equivalente a no tener ningún modo de escalado en config.lua

Resumen

  • letterbox: no deforma, puede haber barras laterales, no recorta
  • zoomEven: no deforma, no puede haber barras laterales, puede recortar
  • zoomStretch: puede deformar, no puede haber barras laterales, no recorta
¿Cuál es la mejor opción? En mi opinión, yo uso casi siempre letterbox, con una opción de alineamiento que explicaré en la próxima entrada. Pero eso no quita para que en algunos casos sean interesantes los otros modos.

lunes, 18 de julio de 2016

Qué es Corona

Frank Zammetti, un experto desarrollador de videojuegos, dice al comienzo de uno de sus libros:

"Writing mobile apps is hard. Writing mobile games is even more so"
"Escribir applicaciones para móviles es duro. Escribir juegos para móviles es incluso más duro"

¿Por qué es tan difícil el desarrollo para móviles? El principal problema es lo que comenté en la entrada anterior: la diversidad de plataformas. Pero además, se añade otro problema adicional, al menos tan importante como éste: la diversidad de tamaños de pantalla, proporciones (ancho x alto), resoluciones, puntos por pulgada, etc de los distintos dispositivos y tablets que existen actualmente en el mercado.

Corona SDK es un framework para desarrollar aplicaciones para móviles multiplataforma. Está orientado al desarrollo de juegos 2D y de aplicaciones para móviles (aunque las últimas versiones también permiten el desarrollo para TV y para desktop). Está diseñado para que el desarrollo sea muy rápido (el número de líneas de código en Corona comparado con un desarrollo nativo con Swift o Java, está o suele estar, en un orden de magnitud por debajo, y el tiempo correspondiente para escribirlo suele ser equiparable).

Corona SDK utiliza el lenguaje de programación Lua. Un lenguaje similar a Javascript, aunque, en mi opinión, mas potente que éste y más seguro desde el punto de vista del programador. En cualquier caso, los programadores que conozcan Javascript, o incluso algún otro lenguaje de programación moderno (como Java, C#, etc) aprenderán Lua muy rápidamente.

Corona incluye un simulador muy potente que permite comprobar instantáneamente los cambios que se hacen en el código. Creo que este aspecto es fundamental y a mí me hizo decidirme por este framework. Si comparamos con el desarrollo nativo, XCode tiene que compilar la aplicación, cargarla en el simulador y entonces podremos verla. El caso de Android es mucho peor, ya que además de la compilación previa y carga en el emulador, la velocidad de los emuladores Android es realmente desesperante (a pesar de las mejoras que se han ido haciendo, tanto por parte de Google, como por parte del software de virtualización). Con Corona, cambiamos una línea de código, salvamos el fichero y automáticamente el simulador recarga en menos de un segundo la aplicación modificada. La única pega es que al tratarse de un simulador (distinto de un emulador), hay algunas funciones que no se pueden probar en el simulador, por ejemplo, el GPS, la publicidad, y algunas otras características que sólo podremos ver en el dispositivo. Corona genera un fichero .APK para Android y un fichero .IPA para iOS. Estos ficheros son perfectamente instalables en cualquier dispositivo, y también están preparados para subirse a una de las tiendas de aplicaciones.

El 99% del código escrito en Lua/Corona es común para Android e iOS. Aunque hay algunos temas que son muy específicos de cada plataforma, por ejemplo, el formato de los ficheros de audio. En estos casos, disponemos de métodos para comprobar cuál es la plataforma destino, e incluso, podemos saber si estamos ejecutando en el simulador.

Otras características de Corona SDK:


  • Corona es 100% gratuito. Podemos desarrollar una aplicación o juego desde el principio hasta su despliegue en las tiendas de aplicaciones sin pagar absolutamente nada. Existe una  versión comercial de corona, llamada Corona Enterprise, que permite llamar a código nativo. También es necesario contratar Corona Enterprise si nuestra aplicación obtiene unos ingresos superiores a 500,000 dólares (aunque en este caso yo no tendría ningún problema en pagar la suscripción).
  • Lua y Corona son muy sencillos de aprender. Los inicios con Lua son muy sencillos. El lenguaje en sí es muy sencillo, y además podemos ver inmediatamente nuestra aplicación en el simulador, e incluso en un dispositivo. Por otra parte, Corona trae un montón de ejemplos con su código fuente que tratan un montón de situaciones típicas que podemos copiar o que nos pueden servir de inspiración.
  • Corona soporta las siguientes plataformas: iOS, Android, Kindle, Windows Phone, Apple TV, Android TV, OSX y Windows Desktop.
  • El simulador de Corona se puede ejecutar tanto en Windows como en MacOS.
  • En Windows podemos generar aplicaciones para Android. En MacOS podemos generar aplicaciones tanto para Android como para iOS (esto es debido a que Apple obliga que se genere código para iOS únicamente desde un ordenador con MacOS). En cualquier caso, el código Lua desarrollado en Windows se puede llevar a un Mac y generar la versión con iOS, sin ningún cambio.
  • Corona tiene una amplia documentación y una comunidad muy activa, fundamentalmente porque los propios desarrolladores de Corona participan en los foros y blog:
Y ahora, algo que nos gusta mucho a los desarrolladores, vamos a ver qué es Corona en la práctica desde el punto de vista de desarrollo. Muy brevemente, para hacer un programa con Corona, simplemente abrimos un editor de texto, escribimos nuestro programa en uno o más ficheros Lua (uno de estos ficheros será main.lua), abrimos el fichero main.lua con el simulador de Corona y se ejecutará casi instantáneamente. Si queremos generar la versión para Android, o sea, un fichero APK, simplemente entramos en la opción Build del simulador y generamos el APK. Para iOS el proceso es similar, pero en este caso necesitamos tener algunos certificados de Apple, como ya veremos. En resumen, para hacer un programa con Corona, simplemente tenemos que tener instalado el simulador de Corona y un editor de texto.

En próximas entradas de este blog iremos profundizando en los diversos aspectos de Corona SDK: el lenguaje Lua, los APIs de Corona, despliegue tanto en Android como en iOS, etc. Pero antes de nada, empezaremos haciendo una sencilla aplicación en muy pocos minutos.