Leitura de arquivo de configuração

E ai galera!
Blz? Bom, desculpem pela demora de atualização, mas estou corrido mesmo no trabalho, e na faculdade também. Mas esta é a última semana de aula, e depois é só alegria! Bom, quanto as postagens, pretendo me policiar melhor, e começar o ano com uma meta de pelo menos uma postagem por semana. Digo começar o ano, porque estarei em Floripa para o natal e o ano novo, e pretendo me manter saudável o suficiente e não utilizar o computador durante essa semana hehehe.
Bom, o que irei passar hoje, é uma função que criei, onde faz uma leitura de um arquivo de configuração, e retorna para a string passada como argumento, e retorna 0 em sucesso ou 1 em erro, como padrão no Linux.

O código vem logo abaixo:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int readConf(FILE *pfile, int delim, const char *key, char *buf){

        char tmp[256];
        char tmp2[256];

        char tmp3[256];
        int i, j;

        while(fgets(tmp, 256, pfile)){

                if(strchr(tmp, '#')){
                        strcpy(tmp3, strchr(tmp, '#'));

                        if(strlen(tmp3) == strlen(tmp)){

                                continue;
                        }
                }
                memset(tmp3, 0, 256);

                if(strcpy(tmp3, strstr(tmp, key))){

                        memset(tmp2, 0, 256);
                        if(strchr(tmp3, '#')){

                                memset(tmp, 0, 256);
                                strcpy(tmp, strchr(tmp3, '#'));

                                strncpy(tmp2, tmp3, strlen(tmp3) - strlen(tmp)+1);

                                memset(tmp3, 0, 256);
                                strcpy(tmp3, strchr(tmp2, delim));

                        }
                        else
                                strcpy(tmp3,strchr(tmp, delim));

                        memset(tmp2, 0, 256);
                        for(i=1, j=0; i<strlen(tmp3)-1; i++){

                                if(tmp3[i] == ' ') { 
                                        continue;

                                }
                                tmp2[j]=tmp3[i];
                                j++;

                        }
                        strcpy(buf, tmp2);
                        
                        return 0;

                }
        }
        return 1;
}

Para compilar este código, basta inclui-lo como um reader, ou fazer um .so (shared object) mas isso não é um assunto para hoje.
Esta função deve ser utilizada dessa forma:

if(readConf(file, ':', "path_arquivos", buf)){
printf("Erro no leitura do path_arquivos!")
}


onde:
readConf -> Nome da função;
file -> Arquivo aberto onde será localizada a string;
: -> Caracter delimitador de configuração (pode ser alterado com '=' por exemplo);
path_arquivos -> string a ser localizada dentro do arquivo 'file'
buf -> String onde será retornado o valor da configuração

Para o arquivo ser lido, eu optei por passar o parametro do 'file' como um arquivo aberto lá fora mesmo, na main por exemplo, onde ele deve ser de um tipo FILE *
Outra coisa, o arquivo pode ser comentado também, na minha implementação, ele aceita o valor '#' para isso, mas caso queira alterar, fique a vontade, não é nem um pouco difícil!

Obrigado a todos e até a próxima!

.:Converter Imagem No Terminal:.

I ai amigos não sumi não estou passando aqui para deixar uma dica =)
Eu precisei converter um formato de imagem para outro e pensei bom vou mandar essa dica afinal todos nós já
fomos iniciantes e não sabiamos fazer isso.
É uma dica Simples e muito necessária precisa ter o pacote ImageMagick instalada em seu sistema:

http://www.imagemagick.org/script/index.php

Nós que usamos Slack já somos agraciados com o pacote do ImageMagick isso no Slack(FULL).

Para Converter. (Abra seu Bash seu Terminal preferido)

# convert imagem_do_Boot.png nova_imagemBoot.jpg

Pronto Converteu !!
Sim pode acreditar converteu mesmo =)

Abraço Amigos, aos Users bom todo mundo e ao meu Amigo Diego.=)

[]'s
Razec
mrazec@gmail.com
razec@linuxmail.org
Linux User: 443515

OpenGL Parte II

Dae pessoal!
Perdão pela demora na atualização, mas meu trabalho está realmente exigindo muito de mim.
E a faculdade então, nem tenho o que falar.
Mas chega de choro, e vamos ao que interessa.

Vamos fazer uma pequena animação, onde desenharemos um retângulo e colocaremos cores em cada vértices.
A cada delay passado, será atualizada a cor de cada vértice, então teremos um efeito bem legal no nosso tutorial.
Bom, como normalmente, abra um editor de textos e mande ver.


#include <GL/glut.h>
#include <stdio.h>
#include <stdlib.h>
#define DELAY 200

float r1=0.7, r2=0.2, r3=0.5, r4=0.0;
float g1=0.3, g2=0.9, g3=0.3, g4=0.5;
float b1=0.1, b2=0.0, b3=0.8, b4=0.7;

void anima(){
r1+=0.1; g1+=0.1; b1+=0.1;
r2+=0.1; g2+=0.1; b2+=0.1;
r3+=0.1; g3+=0.1; b3+=0.1;
r4+=0.1; g4+=0.1; b4+=0.1;

if(r1>=1) r1=0; if(g1>=1) g1=0;
if(b1>=1) b1=0; if(r2>=1) r2=0;
if(g2>=1) g2=0; if(b2>=1) b2=0;
if(r3>=1) r3=0; if(g3>=1) g3=0;
if(b3>=1) b3=0; if(r4>=1) r4=0;
if(g4>=1) g4=0; if(b4>=1) b4=0;

glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_QUADS);
glColor3f(r1,g1,b1); glVertex3f(-0.5,-0.5,0);
glColor3f(r2,g2,b2); glVertex3f(0.5,-0.5,0);
glColor3f(r3,g3,b3); glVertex3f(0.5,0.5,0);
glColor3f(r4,g4,b4); glVertex3f(-0.5,0.5,0);
glEnd();
glFlush();
glutTimerFunc(DELAY,anima, 0);
}

void display(){
glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_QUADS);
glVertex3f(-0.5,-0.5,0);
glColor3f(1,0,0);
glVertex3f(0.5,-0.5,0);
glColor3f(0,1,0);
glVertex3f(0.5,0.5,0);
glColor3f(0,0,1);
glVertex3f(-0.5,0.5,0);
glColor3f(0,0,0);
glEnd();
glFlush();
}

void init(){
glClearColor(0,0,0,0);
}
int main(int argc, char **argv){
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGB|GLUT_SINGLE);
glutInitWindowSize(1024,768);
glutInitWindowPosition(0,0);
glutCreateWindow("Draw Colors");

init();
glutDisplayFunc(display);
glutTimerFunc(DELAY,anima, 0);
glutMainLoop();

return 0;
}


Compile-o como fizemos anteriormente:
gcc -o teste main.c -lglut

Agora execute-o.

Agora vou explicar algumas coisas para todos nos situarmos:

Na Main, o que temos de novo é somente a função glutTimerFunc(DELAY, anima, 0);
Esta função como o próprio nome diz, cria um timer no programa, e chama uma função.
No primeiro argumento, você passa o delay em milisegundos. Coloquei um define para facilitar.
No segundo, se passa o rótulo da função. E o terceiro seria um parâmetro para a função.

Ok, dessa forma inicializamos uma animação. Mas se você reparar, dentro da função anima, esta função é chamada novamente. Isso é feito, porque a cada interação, ele perde o tempo, então, temos que reinicializa-la.

Agora que já explicamos a Main, vamos ver o que temos de novo em na função anima.
Depois de todos aqueles r's, g's e b's (que são as cores) temos o início de nosso retângulo, com o glBegin(GL_QUADS);.
Logo depois, antes de cada ponto glVertex3f(x, y, z); temos um cara chamado glColor3f(r,g,b);. Esse cara, faz com que cada vértice logo após ele, tenha a cor determinada. O legal do openGL, é que ele já faz a "mistura" das cores.
Fora isso não temos mais nenhuma novidade nessa função. Repare que temos novamente a chamada da glutTimerFunc(DELAY,anima, 0); no final da função. Isso é pelo motivo já explicado anteriormente.

Bom pessoal. O resto do software já foi explicado anteriormente, neste post.
Peço desculpas pela demora na atualização, e pretendo arranjar mais tempo para atualizar isso aqui com mais frequência.
Valeu pessoal! Qualquer dúvida/sugestão comments estão aí!
Abraços a todos!

News

Dae Galera!
Layout novo, novidades, novos assuntos e idéias para posts compridos porém interessantes!
Estou terminando de fazer algumas configurações e assim que chegar em casa é capaz de surgir algum post novo.
Espero que eu consiga tempo para poder fazer todas as coisas novas que estou pretendendo.
Mas se der tudo certo, novidades e quem sabe alguns velhos amigos, podem ressurgir das cinzas para podermos nos aprimorar heheheh.
Bom, por enquanto é isso, mais pra frente veremos o que fazer certinho heheheh
Até depois pessoal!

OpenGL - Um ínicio

E ai Pessoal!
Sei que demorei para postar algo novo neste blog, mas finalmente consegui um tempo para poder recomeçar uma nova série de tutoriais.
Como prometido a muito tempo atras, irei iniciar uma série de artigos a respeito de OpenGL. O OpenGL para quem não conhece, é uma API gráfica para criação e utilização de "objetos" gráficos 2D e 3D. Foi criada em 1992 pela Silicon Grafics e serviu de muito uso para a criação de vários jogos na atualidade. Bom, chega de historinhas e bla bla blas e vamos ao que interessa.
Neste exemplo vamos apenas criar uma janela de 1024x768 e vamos inserir nela um retangulo branco. Vamos nessa então:

#include <GL/glut.h>

void display(){
    glClear(GL_COLOR_BUFFER_BIT);
    glColor3f(1,1,1);
    glBegin(GL_POLYGON);
        glVertex3f(0.25,-0.25,0);
        glVertex3f(-0.25,-0.25,0);
        glVertex3f(-0.25,0.25,0);
        glVertex3f(0.25,0.25,0);
    glEnd();
    glFlush();
}

void init(){
   glClearColor(0,0,0,0);
}

int main(int argc, char **argv){
   glutInit(&argc, argv);
   glutInitDisplayMode(GLUT_RGB| GLUT_SINGLE);
   glutInitWindowSize(1024, 768);
   glutInitWindowPosition(100, 100);
   glutCreateWindow("Teste OpenGL");
    init();
   glutDisplayFunc(display);
   glutMainLoop();
   return 0;
}

Ok, vamos compilar com o comando: gcc -o teste main.c -lglut

Entenderam?
Fácil né?
Vamos as explicações então, começando pela main:
Temos a função glutInit, esta função vai inciar o glut para nós. Como no SDL, o glut é uma API portavel, que vai servir para nós podermos compilar o mesmo código no Linux, Windows ou no MAC independentemente de alterações.
Temos que passar os argumentos da main para que ele possa inicializar o openGL certo.
Depois nós temos a função glutInitDisplayMode, nela nos dizemos como que será a nossa aplicação. No caso estou iniciando com RGB e com um single buffer. Várias outras Flags podem ser passadas para o início do Glut, mas isso vou deixar para um próximo Post.
Depois temos um glutInitWindowSize, o nome já é explicativo, mas é para dizer o tamanho da janela.
Depois temos um glutCreateWindowPosition, que também é auto explicativo, mas diz a posição de onde deve-se iniciar a janela.
Depois temos uma função chamada glutCreateWindow, exatamente aqui é onde será instanciada a janela. No Linux será chamada uma janela nova do X e será atribuido o nome de "Teste OpenGL" para ela. No Windows creio que seja o windows forms que faça isso, me corrijam se eu estiver errado. No MAC acho que é a cocoa que se encarrega disso.
Depois há a chamada da função init. Esta função diz que a cor para a janela ser limpada é o preto.

Depois da função init temos uma chamada para a função glutDisplayFunc, passando como parametro a função display. Essa função é a função que fará todo o loop de renderização de nossa aplicação. Dentro dela deverá ficar todos os nossos desenhos de tela (pelo menos nesse início).
Vamos dar uma olhada na função display:
Iniciamos fazendo uma chamada de limpeza de tela;
Depois diz que a cor do objeto é o branco;
E dai inicia um objeto. Agora cabe uma pequena aula de desenho geométrico;
Lembram-se quando a professora de matemática da 7ª/8ª série dizia sobre plano cartesiano?
Então, o que temos aqui é justamente isso, um plano cartesiano que passa exatamente no meio de nossa tela.
                     |  ----> y = 1
                     |
                     |
x=-1 ________|_____________x = 1
                     |
                     |
                     |
                     |  ----> y = -1

Temos então uma chamada a função glBegin que indica que será incializado um polígono (GL_POLYGON) e temos logo após os pontos de cada extremidade desse polígono.
Então se temos um retangulo, temos 4 pontos.
Nós dissemos que queromos um ponto na posição (0.25, -0,25, 0) , então significa que queremos na posição 0.25 do X, -0.25 do Y e 0 do Z. O plano Z é o plano de profundidade, no momento não queremos nada longe, portanto deixamos 0.

                       +y
                       | 
(-0.25, 0.25)     |          (0.25, 0.25)
           .           |         .
-X___________|_____________+X
                       |
            .          |          .
(-0.25,-0.25)     |          (0.25, -0.25)
                       |  -y

Depois que fizemos todos os pontos, fechamos o poligonos com o glEnd;
E depois fizemos um glFlush onde chamamos um update de tela.

Depois de tudo isso, novamente na main, temos um glutMainLoop, que é a função que faz todo o tratamento da janela, como por exemplo fechar, cliques, ....
Pessoal, por hoje é isso, espero que tenham gostado do inicio de uma nova série de tutoriais, e a curiosidade por novas APIs. Obrigado pela visita, e pretendo voltar a postar daqui a alguns dias, assim que meu trabalho e essa faculdade me deixar.
Obrigado a todos e até mais!