<--  | 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