<--  | Hogar  | Mapa  | Indice  | Busqueda

por Leonardo Giordani <leo.giordani(at)libero.it> Sobre el autor: He obtenido mi diploma por parte de la Facultad de Ingeniería en Telecomunicaciones del Politécnico de Milán. Estoy interesado en la programación, principalmente en ensamblador y C/C++. Trabajo desde 1999 con Linux y Unix solamente. Traducido al español por: Edgar Hernández Zúñiga <edgar(at)linuxfocus.org> Contenidos: El desplazador o voluta Una pequeña demostración

Implementando un desplazador de texto en gráficos SDL Resumen: Esta serie de artículos tiene el propósito de introducir al lector en el mundo de las producciones multimedia, también conocidas como "demos". Toda la Internet está llena de información en la materia, pero algunas personas han conseguido grandes cosas en Linux: my meta es describir la teoría de algunos efectos gráficos y de audio y su implementación utilizando la biblioteca SDL. Podrán encontrar más información en: Simple DirectMedia Layer: leer el código de las muestras y los juegos es la mejor manera de aprender nuevas soluciones. lnxscene: un sitio nuevo, pero un gran lugar para el intercambio de conocimiento; podrás encontrarme algunas veces como "muaddib" Los requisitos para el entendimiento del artículo son: Conocimiento básico del lenguaje C, sintáxis, ciclos, bibliotecas. Conocimiento básico de la biblioteca SDL, funciones básucas e inicialización., te servirá consultar www.libsdl.org _________________ _________________ _________________

El desplazador o voluta

Un desplazador o voluta, es parte de un "demo" que permite escribir una sentencia o texto en movimiento en la panatalla o monitor: este es uno de los efectos básicos que puedes encontrar en cualquier producción multimedia al cual es posible añadirle un poco de dinámica al mostrársele al usuario. En éste artículo veremos como construir un desplazador básico que permitirá mover texto de derecha a izquierda.

La idea básica de un desplazador, es copiar una parte de la pantalla uno o más pixeles hacia la izquierda o en alguna otra dirección. Ejecutando esta operación con una buena velocidad obtendrás la ilusión de un movimiento continuo, eso es todo.

La teoría básica no es nada complicada; vamos a traducir todo esto en código: nos referiremos en adelante al concepto de superficie, dado que tenemos ya los conocimientos básicos de programación con SDL. Mientras trabajemos con la biblioteca SDL, debemos recordar siempre que podemos usar el poderío de la función

Por ejemplo, imaginemos que hemos definido e inicializado dos superficies y dos rectángulos

#define WIDTH 800
#define HEIGHT 600

SDL_Surface *Src;
SDL_Surface *Dst;

Src = SDL_CreateRGBSurface(SDL_HWSURFACE, WIDTH, HEIGHT, 8,
       r_mask, g_mask, b_mask, a_mask);
Dst = SDL_CreateRGBSurface(SDL_HWSURFACE, WIDTH, HEIGHT, 8,
       r_mask, g_mask, b_mask, a_mask);

SDL_Rect BigArea = {0, 0, (WIDTH / 2), HEIGHT};
SDL_Rect SmallArea = {(WIDTH / 2) + 1, 0, (WIDTH / 2), (HEIGHT / 2)};

SDL_BlitSurface(Src, 0, Dst, 0);

SDL_BlitSurface(Src, &BigArea, Dst, &SmallArea);

Ahora ejecutar el desplazado de una superficie no es más un misterio: es suficiente copiar una parte de la superficie en un rectángulo cambiado en la misma superficie; es obvio que esto tendremos que crearlo como un ciclo, con esto, el programa resultante será un poco más complejo, pero el concepto básico se mantiene simple. A cada instante del ciclo usaremos dos rectángulos, el segundo cambio se refiere al primero en la dirección en la que se ha determinado el desplazamiento, y copiaremos la superficie a sí misma del primero al segundo rectángulo.

SDL_Surface *temp;

SDL_Rect From = {1, 0, WIDTH, HEIGHT};
SDL_Rect First = {0, 0, 1, HEIGHT};
SDL_Rect Last = {WIDTH-1, 0, 1, HEIGHT};

temp = SDL_CreateRGBSurface(SDL_HWSURFACE, 1, HEIGHT, 8,
       r_mask, g_mask, b_mask, a_mask);

while(1){
  SDL_BlitSurface(Src, &First, temp, 0);
  SDL_BlitSurface(Src, &From, Src, 0);
  SDL_BlitSurface(temp, &First, Src, &Last);
  SDL_BlitSurface(Src, 0, Screen, 0);
}

#include "SDL/SDL.h"
#include "SDL/SDL_image.h"

#define SCREEN_WIDTH 480
#define SCREEN_HEIGHT 200

#if SDL_BYTEORDER == SDL_BIG_ENDIAN
static const Uint32 r_mask = 0xFF000000;
static const Uint32 g_mask = 0x00FF0000;
static const Uint32 b_mask = 0x0000FF00;
static const Uint32 a_mask = 0x000000FF;
#else
static const Uint32 r_mask = 0x000000FF;
static const Uint32 g_mask = 0x0000FF00;
static const Uint32 b_mask = 0x00FF0000;
static const Uint32 a_mask = 0xFF000000;
#endif

static SDL_Surface* img_surface;
static SDL_Surface* scroll_surface;
static SDL_Surface* temp_surface;

static const SDL_VideoInfo* info = 0;
SDL_Surface* screen;

int init_video()
{
  if( SDL_Init( SDL_INIT_VIDEO) < 0 )
    {
      fprintf( stderr, "Video initialization failed: %s\n",
               SDL_GetError( ) );
      return 0;
    }

  info = SDL_GetVideoInfo( );

  if( !info ) {
    fprintf( stderr, "Video query failed: %s\n",
             SDL_GetError( ) );
    return 0;
  }

  return 1;
}

int set_video( Uint16 width, Uint16 height, int bpp, int flags)
{
  if (init_video())
    {
      if((screen = SDL_SetVideoMode(width,height,bpp,flags))==0)
        {
          fprintf( stderr, "Video mode set failed: %s\n",
                   SDL_GetError( ) );
          return 0;
        }
    }
  return 1;
}

void quit( int code )
{
  SDL_FreeSurface(scroll_surface);
  SDL_FreeSurface(img_surface);

  SDL_Quit( );

  exit( code );
}

void handle_key_down( SDL_keysym* keysym )
{
    switch( keysym->sym )
      {
      case SDLK_ESCAPE:
        quit( 0 );
        break;
      default:
        break;
      }
}

void process_events( void )
{
    SDL_Event event;

    while( SDL_PollEvent( &event ) ) {

        switch( event.type ) {
        case SDL_KEYDOWN:
            handle_key_down( &event.key.keysym );
            break;
        case SDL_QUIT:
            quit( 0 );
            break;
        }
    }
}

void init()
{
  SDL_Surface* tmp;
  Uint16 i;

  tmp = SDL_CreateRGBSurface(SDL_HWSURFACE, SCREEN_WIDTH,
       SCREEN_HEIGHT, 8, r_mask, g_mask, b_mask, a_mask);

  scroll_surface = SDL_DisplayFormat(tmp);


  SDL_FreeSurface(tmp);

  img_surface = IMG_Load("img.pcx");

  for (i = 0; i < SDL_NUMEVENTS; ++i)
    {
      if (i != SDL_KEYDOWN && i != SDL_QUIT)
        {
          SDL_EventState(i, SDL_IGNORE);
        }
    }

  SDL_ShowCursor(SDL_DISABLE);
}

int main( int argc, char* argv[] )
{
  SDL_Rect ScrollFrom = {1, 0, SCREEN_WIDTH, SCREEN_HEIGHT};
  SDL_Rect First = {0, 0, 1, SCREEN_HEIGHT};
  SDL_Rect Last = {SCREEN_WIDTH - 1, 0, 1, SCREEN_HEIGHT};

  if (!set_video(SCREEN_WIDTH, SCREEN_HEIGHT, 8,
      SDL_HWSURFACE | SDL_HWACCEL | SDL_HWPALETTE /*|
SDL_FULLSCREEN*/))
   quit(1);

  SDL_WM_SetCaption("Demo", "");

  init();

  SDL_BlitSurface(img_surface, 0, scroll_surface, 0);

  while( 1 )
    {
      process_events();

      SDL_BlitSurface(scroll_surface, &First, temp_surface, 0);

      SDL_BlitSurface(scroll_surface, &ScrollFrom,
scroll_surface, 0);

      SDL_BlitSurface(temp_surface, &First, scroll_surface,
&Last);

      SDL_BlitSurface(scroll_surface, 0, screen, 0);

      SDL_Flip(screen);
    }

  return 0;
}

Como puedes ver, el trabajo de inicialización de la biblioteca no es pequeño, pero la ventaja es que es común para todo el "demo", así, cuando el código incrementa, la inicialización continua siendo una pequeña parte de todo el programa, esto lo hace portable y reutilizable.

Una pequeña demostración

PD: Puedes hacerme llegar cualquier comentario, corrección o pregunta a mi dirección de correo o a través de la página de Retroalimentación, Talback. Escríbeme en inglés, alemán o italiano.

2003-07-02, generated by lfparser version 2.40