Nova demora EXTREMA de atualização

Olá pessoal!
Peço desculpas a todos, e também peço um pouco de compreensão de todos a respeito da demora de atualização.
O que acontece no momento, é que devido a faculdade/trabalho, estou sem tempo de postar algo novo. Este blog surgiu como uma espécie de "backup" de arquivos. Mas como se pode perceber, as expectativas se ultrapassaram (para se ter uma idéia, o contador de acesso que eu utilizo, aquele que abre um pop-up quando se entra no site, teve um overflow, apesar de que o limite dele deve ser um pouco limitado, cerca de 3500 acessos).
Peço que todos tenham paciência e continuem acessando, que assim que eu tiver tempo, prometo que postarei algo bem mais útil a respeito de SDL e configurações de sistema aqui. O próximo passo, que pretendo postar é de como instalar um servidor WIKI dentro de uma lan.
Conto também, a cerca de uma ou duas semanas com o auxílio de um amigo, o RAZEC, que futuramente vai postar algumas coisas úteis aqui no blog também.
Peço desculpas a todos e peço encarecidamente que entendam o porém da demora.

Mas como exercício para fixação do nosso SDL que tal você tentar criar um programinha bem simples:
Crie um programa que faça um quadrado (de preferencia com uma imagem importada) que se move de acordo com as setas do teclado.

Creio que com os exemplos que passei anteriormente, todos tem capacidade de fazer um programinha funcional.
Vai aqui uma dica: As teclas de seta do teclado são mapeadas da seguinte forma
* Seta para cima = SDLK_UP
* Seta para baixo = SDLK_DOWN
* Seta para direita = SDLK_RIGHT
* Seta para esquerda = SDLK_LEFT

Pessoal, tentem fazer isso, e qualquer dúvida mandem perguntas. Terei um enorme prazer de receber um feedback de vocês e saber que este blog serviu de alguma utilidade algum dia.
Obrigado a todos, uma ótima sexta-feira e vamos lah!
Assim que eu tiver um tempo, pretendo fazer um projeto dinâmico com todos vocês, uma idéia talvez meio precária, mas que tal se todos nós nos unisse-mos e criassemos um pequeno jogo, por exemplo um Pac-man?
O que vocês acham?

Bom, é isso.
Prentendo voltar a postar novos tutoriais assim que eu terminar a instalação do maldito postgreSQL + apache + PHP5 + WikiMedia num K6.
Obrigado pelo apoio e até a próxima!

SDL - Parte 4

Olá pessoal!
Depois de um grande período sem novos posts, finalmente consegui arranjar um tempo para poder adicionar esta continuação do nosso "curso" de SDL.
Objetivos deste artigo:
1. Aprender a utilizar um pequeno evento de fechar janela
2. Aprender como importar imagens de outros formatos, diferentes de BMP.

Vamos lá, dê uma estudada neste código:

#include <stdio.h>
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>

int main(int argc, char *argv[]){
    SDL_Surface *janela, *imagem;
    SDL_Rect rect;
    SDL_Event evento;
    int x, y;
    int sair = 0;

    if(SDL_Init(SDL_INIT_EVERYTHING) == -1){
        printf("Problema na inicialização do SDL");
        exit(1);
    }
    janela = SDL_SetVideoMode(800, 600, 32, SDL_ANYFORMAT | 
                                            SDL_DOUBLEBUF);
    if(!janela){
        printf("Problema na inicialização da janela");
        exit(1);
    }

        x=100;
        y=100;
    
    while(sair == 0){
        if(evento.type == SDL_QUIT)
                sair = 1;
        else{
                SDL_PollEvent(&evento);
                rect = (SDL_Rect) {x, y, NULL, NULL};
                imagem = IMG_Load("imagens/img.jpg");
                SDL_BlitSurface(imagem, NULL, janela, &rect);
                SDL_Flip(janela);
                x = x+10;
                y = y+10;
                SDL_Delay(30);
        }
    }

    SDL_FreeSurface(imagem);
    SDL_FreeSurface(janela);
    SDL_Quit();
    return 0;
}

Para compilar este código basta utilizar: gcc -o sdl4 sdl_parte4.c -lSDL -lSDL_image
Bom, como você deve ter percebido, temos algumas coisas iguais ao código passado.
O que nos interessa neste novo código é o seguinte:
A biblioteca SDL_image.h que contém as funções para tratamento de imagem.
A linha SDL_Event evento; -> Aqui nós declaramos um evento, com ele podemos fazer algumas coisas bem divertidas, mas isso vou deixar para um próximo post;
Agora na linha if(evento.type == SDL_QUIT) -> nós estamos verificando se a janela foi fechada (com ALT + F4 ou clique mesmo).
Depois o que temos é o seguinte imagem = IMG_Load("imagens/img.jpg");. Esta função não faz nada mais do que procurar a imagem passada como parâmetro e retornar para a surface.
Depois nós somente movimentamos a imagem chamada.
Agora como "lição de casa" que tal adicionar um fundo a janela?

Bom pessoal, por hoje é isso. Fiz este artigo meio que às pressas, portanto qualquer correção ou falha, mande-me um email ou adicione um comentário.
Obrigado e até a próxima!.

SDL - Parte 3

Olá pessoal,
Resolvi postar hoje um tutorial como fazer para importar figuras Bitmap para uma interface SDL. Neste artigo estou utilizando somente arquivos bitmap mesmo, ou seja, arquivos com a extensão .BMP. No próximo artigo, pretendo ensinar-lhes como inserir outro formato de imagem.

Bom, vamos nessa:
Dê uma olhada nesse código:

#include <stdio.h>
#include <SDL/SDL.h>

int main(int argc, char *argv[]){
    SDL_Surface *janela, *imagem;
    SDL_Rect rect;
    Uint8 *tecla;
    int sair = 0;

    if(SDL_Init(SDL_INIT_EVERYTHING) == -1){
        printf("Problema na inicialização do SDL");
        exit(1);
    }
    janela = SDL_SetVideoMode(800, 600, 32, SDL_ANYFORMAT | 
                                            SDL_DOUBLEBUF);
    if(!janela){
        printf("Problema na inicialização da janela");
        exit(1);
    }

    rect = (SDL_Rect) {400, 300, NULL, NULL};
    imagem = SDL_LoadBMP("/imagens/imagem.bmp");
    SDL_BlitSurface(imagem, NULL, janela, &rect);
    SDL_Flip(janela);
    
    while(sair == 0){
        SDL_PollEvent(NULL);
        tecla = SDL_GetKeyState(NULL);
        if(tecla[SDLK_ESCAPE]) sair = 1;
    }

    SDL_FreeSurface(imagem);
    SDL_FreeSurface(janela);
    SDL_Quit();
    return 0;
}

Bom, para compilar todos vocês já devem estar careca de saber né?
gcc -o teste arquivo.c -lSDL

Bom, o que há de novo nesse código?

Temos um novo tipo de dados: SDL_Rect
Este cara, nada mais faz do que indicar a posição da imagem na surface. Você pode perceber que tivemos dois warnings quando compilamos o código, certo? É por causa dele mesmo, mas hoje não vou explicar o que é aquilo.

Ainda temos o imagem = SDL_LoadBMP("/imagens/imagem.bmp"); onde passamos como parâmetro o local da imagem. Pode ser tanto caminho absoluto, quanto sua pasta local.

Depois temos: rect = (SDL_Rect) {400, 300, NULL, NULL}; Este cara é o SDL_Rect que declaramos lá em cima, onde dizemos a posição de origem dele (400, 300), os outros parâmetros passarei depois para que servem também, caso estejam com pressa, man SDL_Rect ;-)

Agora o SDL_BlitSurface(imagem, NULL, janela, &rect); este cara, é a função que vai indicar onde que vai ser inserida a imagem que acabamos de pedir. ou seja, insira a imagemna janela com o rect, ou seja na posição indicada por rect.

Bom pessoal, por hoje é isso que eu queria postar, já sabem né: Comentem, corrijam, critiquem ....
É isso ai, obrigado e uma ótima semana a todos!
Fui!

SDL - Parte 2

Olá pessoal!
Postando hoje, a segunda parte de nosso tutorial de SDL.

Objetivos:
- Poder criar uma janela;
- Configurar esta janela como Fullscreen;
- Configurar a tecla ESC (Escape) para terminar o SDL e sair do programa.

Prontos?

Como vimos no último artigo criamos uma janela, com um determinado tamanho e utilizamos um Delay para finalizar a janela.

Lembram-se quando eu falei das Flags no último tutorial?
Então, hoje vamos utilizar um flag novo para poder deixar esta tela em fullscreen.
Vamos lá?


zimmermann@Anakin:~$ vim testeSDL2.c


Vamos incluir os headers e o que desejamos dentro deste atquivo:

#include <stdio.h> //Entrada e saida para o C
#include <SDL/SDL.h> //Header principal do SDL
#include <stdlib.h> //Para usar o exit

int main(){
 SDL_Surface *janela;  //Nossa surface que será a janela
 Uint8 *teclas;        //Nossas teclas do teclado
 int sair = 0;         //Uma variavel para segurar o software

 if(SDL_Init(SDL_INIT_EVERYTHING) == -1){          //SDL iniciando tudo
   printf("Problema na inicialização do SDL\nSaindo"); //Imprime o erro
   SDL_Quit();                //Termina o SDL
   exit(1);                  //Retorna 1 para o sistema, indicando erro
  }

 janela = SDL_SetVideoMode(540, 480, 16, SDL_ANYFORMAT | SDL_DOUBLEBUF 
                                                     | SDL_FULLSCREEN);
 if(!janela){       //Se janela for nulo é porque não iniciou a surface
  printf("Não pude inicializar a janela!\nSaindo");  //Mensagem de erro
  SDL_Quit();         //Sai do SDL
  exit(1);            //Retorna erro ao sistema
 }

  while(sair == 0){           //Laço que segura o software inteiro
   SDL_PollEvent(NULL);       //Verifica todos os eventos que ocorrem
   teclas = SDL_GetKeyState(NULL); 
                             //Armazena na pilha os eventos de teclado
    if(teclas[SDLK_ESCAPE]){  //Se a tecla ESCAPE (Esc) for apertada
      sair = 1;               //Então saia
      SDL_Quit();             //Termina o SDL
    }
 }

 return 0;                    //Retorna ao sistema
}

Para compilar este código:

zimmermann@Anakin:~$ gcc -o testeSDL2 testeSDL2.c -lSDL


Depois de compilado, execute o programa:

zimmermann@Anakin:~$ ./testeSDL2


O que ocorrerá é que aparecerá uma "belíssima" tela preta dominando todo o seu ambiente gráfico!
Bom, você pode perceber que uma das linha eu não comentei.
Deixei isso para fazer agora:

 janela = SDL_SetVideoMode(540, 480, 16, SDL_ANYFORMAT | SDL_DOUBLEBUF 
                                                     | SDL_FULLSCREEN);

O que eu fiz nessa linha?
Iniciei uma janela, com 540 pixels de largura, 480 de altura, 16 bits por pixel, e com as flags:
SDL_ANYFORMAT -> Previne para que o SDL crie uma surface, e não a sua placa de vídeo
SDL_DUBLEBUFF -> Permite um SDL_Flip (veremos mais para frente quando importarmos figuras
SDL_FULLSCREEN -> Deixa a apicação como FullScreen

Bom pessoal, por hoje é isso que eu quero passar. Comentem, critiquem, ... Mas quando o fizer, mande seu email junto, para podermos manter um melhor contato.
Obrigado pelo apoio e até mais!

SDL - Parte 1

Olá Pessoal!
É com grande satisfação que eu anuncio hoje (05/05/2007) que meu blog estará com um novo rumo, porém mantendo os objetivos iniciais, que eram configuração de sistema, tutorias, etc...
Bom, como vocês devem ter notado na chamada do post, este irá se tratar de SDL.

O que é SDL?
SDL é uma API gráfica que cuida de gerenciamentos de janelas e/ou controle de entrada de dados.
O SDL é um conjunto de funções onde se pode fazer quase tudo, digo quase porque eu ainda não utilizei a biblioteca inteira, mas pretendo hehehe.
Então chega de bla bla bla e vamos começar.
Vou partir do princípio que todos vocês já sabem ao menos um básico de C ou C++ e que já tem a biblioteca do SDL instalada no diretório padrão (/usr/include). Pelo que eu sei, e o Ubuntu e os Debian's Like não vem com a SDL instalada por padrão, mas nada que um APT não resolva.

Bom vamos lá.
Crie um arquivo com extensão .c

zimmermann@Anakin:~$ vi testeSDL.c


Dica: Se você deseja utilizar o VI, pode usar o meu arquivo .vimrc e seja felize heheheh. Ou caso você tenha uma máquina parruda, você pode utilizar o Eclipse para desenvolver em C/C++ perfeitamente.

Agora, vamos ao que interessa:

#include <stdio.h> //Biblioteca padrão
#include <SDL/SDL.h> //Biblioteca do SDL

int main(int argc, char **argv){ //Main normal

    SDL_Surface *janela;   //Surface SDL

    if(SDL_Init(SDL_INIT_VIDEO) == -1){ //Inicializando o vídeo e checando erros
        printf("Problema na inicializacao do SDL, saindo!"); // Mensagem de DEBUG
        exit(0); //Saia do programa
    }
    janela = SDL_SetVideoMode(540, 480, 16, SDL_ANYFORMAT | SDL_DOUBLEBUF); //Iniciando a janela

    SDL_Delay(2000); //Tempo até fechar a janela
    SDL_Quit(); //Fechando todo o SDL
    return 0; //Retornando ao sistema
}

Para compilar este código, basta usar o seguinte comando:

zimmermann@Anakin:~$ gcc -o testeSDL testeSDL.c -lSDL


Bom, como se pode perceber, inicializar uma janela em SDL não é muito complicado não né?
Então deixa eu explicar o que ocorre lá em cima:
na linha #include //Biblioteca do SDL estamos importando a biblioteca que precisamos.
Já na linha SDL_Surface *janela; //Surface SDL estamos inicializando uma surface chamada janela. Quase tudo que iremos utilizar, tanto para imagens e quanto a janelas, será uma surface.
Agora na linha if(SDL_Init(SDL_INIT_VIDEO) == -1) estamos inicializando o video para podermos utilizar a interface.
E na linha janela = SDL_SetVideoMode(540, 480, 16, SDL_ANYFORMAT | SDL_DOUBLEBUF); estamos inicializando uma janela de 540x480 com 16 bits por pixel e com algumas flags. Não vou entrar em detalhes sobre flags ainda, mas este é um assunto muito interessante.
E na linha SDL_Delay(2000); é o tempo até a janela se fechar automaticamente.
E por fim, na linha SDL_Quit(); estamos fechando toda a SDL que está em memória.

Bom por hoje é só pessoal. Qualquer dúvida, por favor mail-me

diego.c.zimmermann at gmail dot com

Até mais e obrigado, logo logo mais artigos de SDL frente.