[NDS][Programación con Palib] 9. Sistemas de entrada/salida avanzados

Bien, este es un tutorial largo, asi que espero que lo repaseis bien, es bastante importante los dos primero apartados.

Empezemos.


1. Bg en 8 y 16 bits con uso de texto(a fondo) y eliminacion de bg y sprite.

Bien, con bg en 8 y 16 bits, conseguiremos una mayor calidad de imagen, con 8 bits sacaremos bastantes colores, y con 16 bits TODOS los colores.
Todo tiene sus pros y sus contras.

8bit:
A favor:
- Mejor calidad (si usas photoshop para editar y guardas tu imagen indexada, podras guardarla en 8bits casi sin perder calidad)
- Mas opciones a la ora de texto y bg.
- Los sprites son los "de siempre".

En contra:
- Varia un poquito la forma de acer aparecer un bg, o texto
- Hay que cargar un "pre-bg" en 8bits para despues cargar tu bg
- Hay que cargar una paleta para el bg.

16bit:
A favor:
- Mucha mejor calidad
- Mas opciones a la ora de sprites

En contra:
- Varia un poquito la forma de acer aparecer un sprite o bg
- Hay que cargar bg en 16bits para despues cargar tu bg
- NO SE PUEDE CARGAR TEXTO, algo que lo hace inutil



Despues de aclararlo, espezamos.

Vamos a crear una aplicacion, que crea lo siguiente:

- Un bg en 16 bit en la pantalla de arriva y de 8 bits en la tactil.
- Poner un sprite en 16bit.
- Pondremos un texto en la pantalla de abajo, un texto en 8bits.
- Cuando pulsemos A, se borraran los dos bg.
- Cuando pulsamos B, se borra el sprite de arriba.
- Aprenderemos a usar tamaños, rotaciones y colores (es muy facil)



Bien, primero empezamos configurando el Pagfx.ini, pues la configuración es distinta.
Para que veais que no miento, he puesto como bg de 16bits una captura de la ventana del msn 8, que tiene muchos colores.
Lo que pone 81 mensajes sin leer no esta retocado, es verdad, y lo de las 40 solicitudes también...xD

#TranspColor Magenta

#Sprites :
sprite16.bmp 16bit

#Backgrounds :
bg0.bmp 8bit bg8
bg1.bmp 16bit

Os he resaltado lo mas significativo del cambio.

Delante de el bg de 8 bits pongo el nombre de la paleta, lo recuerdo para los despistadillos.

Bien, ahora vamos a acer todo eso que antes hemos mencionado.

AVISO: Los sprites en 16bits no se ven bien en el emulador

Código:

// Includes
#include // Incluimos las PA_Lib
#include "gfx/all_gfx.c"
#include "gfx/all_gfx.h"

// Funcion main
int main(int argc, char ** argv)
{
PA_Init(); // Iniciamos las PALib
PA_InitVBL(); // Iniciamos VBL


//Iniciamos un "pre-background" en la pantalla tactil en 8 bits. Seria algo parecido a iniciar un modo 8bits.
PA_Init8bitBg
(0, // pantalla
3); //capa


// Lo mismo, pero en la pantalla de arriba y con un bg de 16 bits.
PA_Init16bitBg(1, //pantalla
3); //capa




// cargamos la paleta de 8 bits, en 16 bits no hace falta
PA_Load8bitBgPal(0, (void*)bg8_Pal);



//Cargamos los bg

PA_Load16bitBitmap // modo: 16 bits
(1, //pantalla
bg1_Bitmap); //imagen(nombre)



PA_Load8bitBitmap //modo: 8 bits
(0, // pantalla
bg0_Bitmap); // imagen(nombre)

// cargamos el sprite
PA_Create16bitSprite(1, // Screen
0, // Sprite number
(void*)sprite16_Sprite, // image to load, 128 pixels wide !
OBJ_SIZE_32X32, // sprite size
50, // x
50); //y


// escribimos en la pantalla de abajo. el texto se pone en la misma capa que cargas el bg
PA_SmartText(0, // Pantalla

// la posición es como definiendo una zona del stylus
0, // Posición X1
1, // Posición Y1
255, // Posición X2
20, // Posición Y2


"Visitad http://www.zonahomebrew.com, mi web de programación", // Texto

70, // Color (De 0 a 255)

2, // Tamaño del texto (De 0 a 4)

1, // Modo de texto (0 - normal (fondo opaco), 1 - transparente(normal), 2 - sin texto, 3 - rotado 90°, 4 - rotado 90° acia el otro lado)

100); // Numero maximo de caracteres


//Bucle
while (1)
{

// si pulsamos A, se borran dos dos bg.
if (Pad.Newpress.A){
PA_DeleteBg //borramos el bg
(1, // de la pantalla 1
3); //que está en la capa 3 (si hay mas cosas en la capa 3 tambien se borran, como el texto)


PA_DeleteBg // borramos el bg
(0, // de la pantalla 0
3); // que está en la capa 3
}


// si pulsamos b, se borra el sprite
if (Pad.Newpress.B){
PA_DeleteSprite // borramos el sprite
(1, //que esta en la pantalla de arriba
0); // y que es el numero 0
}



PA_WaitForVBL();
}

return 0;
} //Fin de main

Captura:




Descarga:
http://www.zonahomebrew.com/modules.php?name=Downloads&d_op=getit&lid=18


Es larguillo, pero a poco te lo aprendes.
No es que sea algo prioritario, pero es una cosa que no esta mas de saber.
Lo pongo para que lo sepais por si lo usais en vuestros futuros proyectos, ya que suele venir vien.

Ahora, a por otra cosa.




2. Teclado y teclado customizado.

Vereis que usar un teclado no es muy "dificil", y se puede hacer facilmente.
Ahora crearemos un teclado normal, y despues una variante del ejercicio que sirve para skinear el teclado.

Creamos un nuevo ejercicio, y empezamos con el codigo del teclado:

// Includes
#include // Include de las PA_Lib


char text[200]; // Esto seria una cadena de caracteres. es como una especie de varieble para texto y numero maximo de caracteres

s32 nletra = 0; // Numero de letras. 0 indica que no hay
char letra = 0; // Nueva letra a escribir

// Funcion main
int main(int argc, char ** argv)
{
PA_Init(); // Iniciamos PA_Lib
PA_InitVBL(); // Iniciamos VBL

PA_InitText(1, 0); // Iniciamos el texto

PA_InitKeyboard(2); // Cargamos el teclado en la capa 2...

PA_KeyboardIn(20, 95); // Hace aparecer el teclado y sus coordenadas

// escribimos
PA_OutputSimpleText(1, 7, 10, "Texto : ");



// Bucle
while (1)
{

letra = PA_CheckKeyboard(); // chekea si se pulsa una nueva letra

// este if sirve para que las letras no se salgan de la pantalla y baje una linea cuando llege al tope
if (letra > 31) { // si el numero de letras es mayor de 31
text[nletra] = letra; // los caracteres del texto por el numero de letras = el valor de letra
nletra++; // como se escribe una letra mas, el numero de letras sube
}



else if ((letra == PA_BACKSPACE)&&nletra) { // si pulsamos el boton de borrar (backspace, ese que va encima del enter) xD
nletra--; // el numero de letras escritas se le resta 1 que hemos borrado
text[nletra] = ' '; // borramos la ultima letra con un texto en blanco
}

PA_OutputSimpleText(1, 8, 11, text); // hacermos que aparezca el texto
PA_WaitForVBL();
}

return 0;
} // fin de main

Captura:


Descarga:
http://www.zonahomebrew.com/modules.php?name=Downloads&d_op=getit&lid=19


Es un codigo un poco complicado, y dificil de entender si no sabeis mucho de c, pero ya os dare un minituto de c para que aprendais un poco.


Ahora, os enseño un poco como seria el teclado customizado.

Seria exactamente lo mismo que el anterior, solo que, seria incluir los gráficos, y cambiar lo siguiente:

Cambiamos esta función:

PA_InitKeyboard(2);

Por esta:

PA_InitCustomKeyboard(2, // capa
keyboardcustom // imagen del teclado
);

En cuanto a la configuracion del pagfx, es poner la imagen del teclado como si fuera un bg normal y corriente.

La "plantilla" y la configuracion del pagfx la podeis verlo si vais a esta ruta:

C:\devkitPro\PAlibExamples\Input\Keyboard\KeyboardCustom\source\gfx

Bien, y con esto, vamos ya a aprender a usar la tactil para dibujar, asi que id preparando buestros stylus (o vuestro lapiz que sustituye al palo perdido xD)


3. Dibujo con nds.

El ultimo ejercicio, pense en algo chulo y se me ocurrio... ¡dibujar en la tactil!

Vamos (mejor dicho vais) a aprender a dibujar normal, y por pixels, y os dale algunos trucos pa borrar la pantalla, cambiar el color, etc...

Al dibujar en la tactil podemos usar 8 o 16 bits, ya sabeis sus ventajas y inconvenientes, que estan explicados arriva.

Voy a usar el modo 16 bits, para poder usar colores rgb, pero en 8 bits, es cambiar todo lo que pone 16 por 8, no es que sea muy dificil... xD

Vamos a empezar con dibujo normal usando RGB, tambien os enseñare en el mismo ejercicio como borrar y como cambiar los colores para no alargar esto más:

// Includes
#include // Include for PA_Lib



// vamos a hacer tres variables, una para cada color rgb (RedGreenBlue/RojoVerdeAzul)
s32 r = 30; // el color rojo lo ponemos a 30
s32 g = 0; // ponemos a cero el verde, para no usarlo
s32 b = 0; // lo mismo con el azul, lo ponemos a 0 para no usarlo


// Function: main()
int main(int argc, char ** argv)
{
PA_Init(); // Initializes PA_Lib
PA_InitVBL(); // Initializes a standard VBL


// iniciamos el modo 16 bits en las dos pantallas
PA_Init16bitBg(0, 3);
PA_Init16bitBg(1, 3);



// ponemos el color de fondo blanco
PA_SetBgColor(0, PA_RGB(31, 31, 31)); // usamos tambien colores rgb




// Infinite loop to keep the program running
while (1)
{




// la funcion de dibujar, asi de simple xD
PA_16bitDraw(0, // pantalla
PA_RGB(r, g, b)); //aqui le endiñamos una funcion para usar colores RGB y dentro las variables



// si pulsamos "A" dejamos de pintar rojo y pintamos verde
if (Pad.Newpress.A){
r = 0; // ponemos el color rojo a 0 para no usarlo
g = 30; // ponemos el verde a 30
b = 0; // el azul no lo usamos y lo dejamos en 0
}





// si pulsamos "B" borramos la pantalla
if (Pad.Newpress.B){
PA_Clear16bitBg(0 //pantalla
);
}





PA_WaitForVBL();
}

return 0;
} // Fin de main

Captura:



Descarga:
http://www.zonahomebrew.com/modules.php?name=Downloads&d_op=getit&lid=20


Bien, ahora, vamos a aprender a dibujar por pixeles.
Lo bueno de esto esque puedes hacer la brocha mas gorda o mas fina.

// Includes
#include // Include for PA_Lib

// Function: main()
int main(int argc, char ** argv)
{
PA_Init(); // Initializes PA_Lib
PA_InitVBL(); // Initializes a standard VBL


// iniciamos el modo 16 bits en las dos pantallas
PA_Init16bitBg(0, 3);
PA_Init16bitBg(1, 3);



// ponemos el color de fondo blanco
PA_SetBgColor(0, PA_RGB(31, 31, 31)); // usamos colores rgb



// Infinite loop to keep the program running
while (1)
{

// con esto, hacemos que se ponga un pixel en la posicion que esta el stylus, como esta en un bucle
PA_Put16bitPixel(0, // pantalla
Stylus.X, // esto seria donde ponemos el pixel, para que parezca que dibujamos, ponemos las cordenadas que tocamos en el eje x
Stylus.Y, // lo mismo pero en el eje y
PA_RGB(0, 31, 0)); // color de lo que dibujamos (rgb)



PA_WaitForVBL();
}

return 0;
} // End of main()

Captura:



Descarga:
http://www.zonahomebrew.com/modules.php?name=Downloads&d_op=getit&lid=21

Eso dibujaria un pixel en la posicion que esta el stylus en el momento. Ya veis, que si dibujais rapido, no se queda la trayectoria perfecta.

Para corregir eso, y conseguir un pincel mas grande, seria hacer lo siguiente:

Donde tenemos la funcion de poner los pixeles, añadimos lo siguiente:

PA_Put16bitPixel(0, Stylus.X, Stylus.Y, PA_RGB(0, 31, 0));

// ahora ponemos lo mismo pero le sumamos un pixel a la cordenada del stylus
PA_Put16bitPixel(0, Stylus.X+1, Stylus.Y+1, PA_RGB(0, 31, 0));

// ahora ponemos lo mismo pero le restamos un pixel a la cordenada del stylus
PA_Put16bitPixel(0, Stylus.X+1, Stylus.Y+1, PA_RGB(0, 31, 0));

Asi obtendríamos un pincel mas grande, solo es ir haciendo eso hasta tener el tamaño que queramos.
Para no aburrirnos tanto y ahorrar mucho codigo, podemos hacer el mismo metodo que usabamos para mover varios sprites a la vez.


Bien, ya con esto, terminaremos sabiendo hacer casi de todo, solo nos falta saber ponerlo en practica.
En el siguiente tutorial, aprenderemos a aplicar todo lo que hemos visto hasta ahora, creando un mini-GUI.
Tambien os voy a enseñar dos cosas muy simples, basicas, y utiles (bueno, bonito, y barato) xD

Como usar varios archivos en un proyecto, y aprender a crear nuestras propias funciones.


Salu2