Aventuras com Texturas

Estou me aventurando com as texturas, no caso das caixas de do terreno ficou até que bom, o SkyBox está com borda nas texturas e eu não consegui entender o por que.

pode baixar aqui:

https://sourceforge.net/projects/newbie-engine/

Classe Servo Motor

Olá pessoal, implementei uma Classe para simular um motor servo e consegui construir um triciclo com cinco servos, há também um "radar" em cima do robô que é mais um Servo, como previsto por estar utilizando a Open Dynamics Engine para física vou poder usar a engine para simulação robóticas, estou pensando em criar uma luta de robôs, implementando mais uma joint o Pistão com isso vai dar pra criar até um trator (Sempre quis um trator)

você pode ver como o robô foi montado no header R1D1.h
não preciso dizer que falta muita coisa ainda pra sair um jogo mas o trabalho continua.

você pode fazer o download no Source Forge, neste link  agora no pacote tambén tem as libs usadas é só corrigir os "path" no projedo do CodeBlocks que da pra compilar.

Link para Download 

Vertex Buffer Objects

Bom dia pessoal a grande novidade agora são os Vertex Buffer Objects, para quem não conhece os VBO é uma maneiro de enviar os arrays dos vetores, indices coordenadas de textura, normais para a memória da placa de video desta maneira não é necessário chamar o glVertex* para cada vetor diminuindo drasticamento o overred do programa desta maneira você envia os arrays para a placa de video uma única vez, e depois chama o  glDrawElements ele desenha seu mesh.

a um vasto conteudo na internet sobre VBO, abaixo segue alguns links de referência:

http://www.songho.ca/opengl/gl_vbo.html
http://nehe.gamedev.net/data/lessons/lesson.asp?lesson=45

na engine consegui colocar o terreno no VBO, tive que fazer um re-build na estrutura basicamente por causa do tipo de dados, mas como tudo aqui é experimental ainda vão haver muitas modificações, os indices funcionão corretamente, só as coordenadas de textura que me deram uma bela surra.

 Abaixo segue as respectivas classes e um exemplo de utilização:
**** VertexBufferObject.h
/**
* @brief Gera Buffer Object
**/

class VertexBufferObject
{
    public:
        unsigned int vertexBuffId; //id do buffer vertices
        unsigned int indexBuffId; //id do buffer indices
        unsigned int normalBuffId; //id do buffer de normal
        unsigned int texBuffId; //id do buffer de coordenada de textura
        unsigned int numIndices;
        float *vertices; // data dos vertices
        unsigned int *indexs; // data dos indicex
        float *normals; // data das normais
        float *texCoord; //data das coordenadas de Texturas

        VertexBufferObject();

        /**
        * @brief seta os vetices do VBO
        * @param vec3d *data ponteiro para os vertices
        * @param uint32 size tamanho do buffer
        */
        void setVertices(float *data,unsigned int size);

        /**
        * @brief seta os indices do VBO
        * @param uint32 *data ponteiro para os indices
        * @param uint32 size tamanho do buffer
        */
        void setIndexs(unsigned int *data,unsigned int size);

        /**
        * @brief seta as normais do VBO
        * @param vec3d *data ponteiro para os normais
        * @param uint32 size tamanho do buffer
        */
        void setNormals(float *data,unsigned int size);

        /**
        * @brief seta as coordenadas de textura VBO
        * @param TexCoord2 *data ponteiro para os vertices
        * @param uint32 size tamanho do buffer
        */
        void setTexCoords(float *data,unsigned int size);

        /**
        * @brief desenha o VBO
        */
        void draw();
        virtual ~VertexBufferObject();
};

***EOF***
***VertexBufferObject.cpp****

VertexBufferObject::VertexBufferObject()
{
    vertexBuffId = 0;
    indexBuffId = 0;
    normalBuffId = 0;
    texBuffId = 0;
    numIndices = 0;
    vertices = NULL;
    indexs = NULL;
    normals = NULL;
    texCoord = NULL;

}

void VertexBufferObject::setVertices(float *data,unsigned int size)
{


    glGenBuffersARB( 1, &vertexBuffId);
    glBindBufferARB( GL_ARRAY_BUFFER_ARB, vertexBuffId );

    vertices = data;

    glBufferDataARB( GL_ARRAY_BUFFER_ARB, size, data, GL_STATIC_DRAW_ARB );

}
void VertexBufferObject::setIndexs(unsigned int *data,unsigned int size)
{
    glGenBuffersARB( 1, &indexBuffId );
    glBindBufferARB( GL_ELEMENT_ARRAY_BUFFER, indexBuffId );

    indexs = data;

    numIndices = (size/sizeof(unsigned int));
    glBufferDataARB( GL_ELEMENT_ARRAY_BUFFER, size, data, GL_STATIC_DRAW_ARB );
}

void VertexBufferObject::setNormals(float *data,unsigned int size)
{
    glGenBuffersARB( 1, &normalBuffId );
    glBindBufferARB( GL_ARRAY_BUFFER_ARB, normalBuffId );

    normals = data;

    glBufferDataARB( GL_ARRAY_BUFFER_ARB, size, data, GL_STATIC_DRAW_ARB );
}

void VertexBufferObject::setTexCoords(float *data,unsigned int size)
{
    glGenBuffersARB( 1, &texBuffId );
    glBindBufferARB( GL_ARRAY_BUFFER_ARB, texBuffId );

    texCoord = data;
    glBufferDataARB( GL_ARRAY_BUFFER_ARB, size, data, GL_STATIC_DRAW_ARB );
}

void VertexBufferObject::draw()
{

    if (vertexBuffId != 0 )
    {
        glBindBufferARB(GL_ARRAY_BUFFER_ARB, vertexBuffId);
        glEnableClientState(GL_VERTEX_ARRAY);

        glVertexPointer(3,GL_FLOAT,0,0);
    }

    if (indexBuffId != 0 )
    {
        glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER, indexBuffId);
        glEnableClientState(GL_INDEX_ARRAY);
        glIndexPointer(GL_UNSIGNED_INT,0,0);
    }

    if (normalBuffId != 0)
    {
        glEnableClientState(GL_NORMAL_ARRAY);
        glNormalPointer(GL_FLOAT,0,normals);
    }

    if (texBuffId != 0)
    {
        glBindBufferARB(GL_ARRAY_BUFFER_ARB, texBuffId);
        glEnableClientState(GL_TEXTURE_COORD_ARRAY);
        glTexCoordPointer(2,GL_FLOAT,0,0);
    }

    //glDrawArrays(GL_TRIANGLES,0,3);
    glDrawElements(GL_TRIANGLES,numIndices,GL_UNSIGNED_INT,0);


    glDisableClientState(GL_VERTEX_ARRAY);
    glDisableClientState(GL_INDEX_ARRAY);
    glDisableClientState(GL_NORMAL_ARRAY);
    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}

VertexBufferObject::~VertexBufferObject()
{

}
***EOF***

Um exemplo da maneira que se possa utilizar segue abaixo isso vai desenhar um quadrado na tela.

// vertex coords array
GLfloat vertices[] =
{1,-1,1, 1,1,1, -1,1,1,
-1,-1,1
 };


unsigned int indices[] = {0,1,2,2,3,0};

float texCord[] = {0,1, 1,1, 1,0, 0,0, 0,1};

VertexBufferObject *vbo = NULL;
TexturePCX *tex = NULL;
...
...
...

int main(int argc,char **argv)
{
 ...
 ...
 ...

 vbo = new VertexBufferObject();
 vbo->setVertices(vertices,sizeof(vertices));
 vbo->setIndexs(indices,sizeof(indices));
tex = new TexturePCX("storage//textures//ground.bmp"); //Não era pra carregar um bmp?
}

void draw()
{
 ...
 glMatrixMode(GL_MODELVIEW);
    glPushMatrix();
    glLoadIdentity();
    glTranslatef(0.0f,0.0f,-5.0f);
    tex->begin();
    vbo->draw();
    tex->end();
    glPopMatrix();
}

o resultado é o quadrado na tela você pode perceber que as texturas não estão aparecendo corretamente, você pode perceber tb o terreno sendo desenhado em um vbo, com o terreno coloquei um mapa de 512*512 sem sentir queda no FPS:

 

no gDEBugger você pode ver na placa de video como estão os dados:

Vertices:

Indices:

se você quiser ver os códigos completos da um pulo lá no svn:
https://newbie-engine.svn.sourceforge.net/svnroot/newbie-engine

Newbie Engine Updates

Nova versão saindo.
Os próximos passos são estudar a Fisica Aplicada a Veiculos, achei uma referencia muito boa na hexGear Engine
Vou esmiuçar esse motor

Newbie Game Engine Updates

Olá pessoal temos uma nova versão, creio que a simulação fisica esta totalmente estável e o mesh do terreno esta colidindo corretamente com os objetos, há uma demonstração com sen x cos, ainda não re-escrevi a parte relativa ao carregamento de um HeightMap através de uma imagem pretendo usar png, pois este tem 4 camadas e da pra colocar informações por escala nas 4 camadas, uma para Grandes Morros a nivel geral, e ir dimunuindo o nivel de detalhe gradativamente, mas antes de fazer isso tenho que dividir o mapa em setores e fazer um colling para assim trabalhar com a ordem de 1024x1024.

https://sourceforge.net/projects/newbie-engine/

vou demorar um pouco pra   ataulizar o SVN mas o arquivo sf já foi atualizado

Newbie Game Engine Updates

Olá pessoal não ainda estou vivo, e fiz uma atualização no SVN com a nova estrutura do projeto creio que agora só precise do SDL para compilar (./configure && make) talvez tenha que usar o autotools também mas não fiz os tetes em outras plataformas.

uma ataualização pendente que estou pra enviar é a correção do Mesh de Terreno agora colide com o Mapa normalmente, agora tenho que dividir os mapas em partes 32x32 para fazer um cooling e texturizar.

bom pessoal por enquanto é isso, se puderem tentar compilar é uma boa.

agora vou atualizar o arquivo do sf.

o path do repositório é

svn co https://newbie-engine.svn.sourceforge.net/svnroot/newbie-engine newbie-engin

https://sourceforge.net/projects/newbie-engine/


até mais pessoal.

Newbie Game Engine Updates

Olá pessoal, um final de semana chuvoso no litoral acaba sendo bem produtivo, tenho já um roteiro para um game.

Playground Lunático

Playground Lunático é um jogo 3D, onde você pode utilizar de vários veiculos como Tanques de guerra, tratores, jipes, entre diversos outros e interagir com um cenário gigante com diversos objetos interativos. o único objetivo é provocar a destruição e semear o caos.

 andei dando uma brisada no blender e modelei um veiculo:

LN 1 Carnicinha:

A Lateral (Iluminação ruim):

Como vemos temos um canhão, que terá elevação de 60º.

Topo:

A base do canhão terá angulo de 180º.

Me arriscando no blender:

Ainda vai demorar umas semanas para fazer o LN 1 Carnicinha funcionar, mais valeu o exercicio criativo.

Algum Game Design de plantã HELP-ME PLEASE.

A ultima screen-shot da engine (ainda não atualizei o sf.net)

um chão com uma textura (Grama ou Concreto)? e um Sky box vão dar um aspecto legal, a rampa vermelha é um modelo (.obj), creio que ja de para fazer cenários pequenos já que ainda não há nenhuma técnica de particionamento de espaço.

gostei deste estilo de render vou dar uma explorada nele.

Até mais pessoal

Newbie Game Engine Veiculos.

Bom pessoal, consegui deixar a simulação fisica estável, e fiz até um cena maneirinha ora demonstrar.




Você pode fazer o download do código no SF.
só não atualizei o svn

Até mais pessoal

Newbie Game Engine Updates

Fiz algumas melhorias na Classe de Terreno e Mesh (Terreno herda de Mesh) e o Mesh que carregava wavefront virou Wavefront.h, mas o mapa ainda ta com problema precisa de diversas melhorias,
outra novidade é o build pra vs2005 (buid/vs2005).

na imagem acima a esfera não colide com o terreno, vai ser um problema desagradavél de se resolver.

atualizei o código no sf, mas ainda não fiz o commit no svn. Agora vou ouvir The Gladiators e jogar, tb tenho que terminar de instalar as dependecias do GNU Octave.

Terreno Parte 2

Depois de algumas xícaras de café, algumas horas no parque do ipirangacom um caderno uma caneta e minha calculadora HP 9s, consegui gerar um terreno no minimo decente mais ainda fanta muita coisa, corrigi os problemas de collisão,agora os objetos colliden corretamente inclusive com o terreno.nos proximos dias estarei me divertindo montando uma classe de veiculo.

Engine de Terreno

Olá pessoal comecei a codar o modulo de terreno na engine, o que fiz até agora
foi gerar uma malha de terreno e gerar os triangulos a partir dela, o próximo
passo é pegar todos esses vertices indexar gerar um Mesh para o ODE,
eu já podia e separar a Classe de Mesh assim o loader de wavefront,
e o mesh de terreno podem ser interpretados da mesma maneira para o ODE.



Vale apena fazer um observação sobre a elegancia da geração atual da imagem.

int offset = w*y+x;
index[offset] = offset;
grid[offset].x = x*scale;
grid[offset].z = y*scale;
grid[offset].y = sinf(x/2)*3;


Vai lá no sf e pega a última versão.
https://sourceforge.net/projects/newbie-engine/files/

A Quantas anda a Engine

Venho trazer noticias do que ando aprontando com a engine, primeiro tive um grande martirio tentando implementar os shaders mas bem após horas cansativas escrevendo coisas como

!!ARBvp1.0 "
PARAM mvp[4] = { state.matrix.mvp }
PARAM yellow = {1.0,1.0,0.0,0.0};
OUTPUT outPosition = result.position;
MOV result.color, vertex.color;
DP4 outPosition.x, mvp[0], vertex.position;
DP4 outPosition.y, mvp[1], vertex.position;
...

Sem debug, sem nem mesmo um analisador lexico para mostrar onde estão os erros, foram horas divertidas eu diria mas enfim estudei as equações do Dr. Phong e implementei algo deveria ser um Per Pixel Ligthing





Tambem fiz modificações no que é pra ser um Sistema de Particulas temos a representação de uma Explosão classe Explosion que é Herdeira de ParticleSystem e enfim comecei a criar a classe ParticleManager, imaginem um bombardeiro de um B-52 a cada bomba que geraria uma explosão, adicionariamos uma instancia de Explosion a ParticleManager e ela gerenciaria os sistemas.





Agora estou pensando em um terreno não tenho mais como fugir das joints do ODE e de um gameplay.

O diagrama de classe nem todas estão implementadas.






Nas próximas semanas atualizo o SVN.

Newbie Game Engine o que ta no forno

Pessoal boas novas consegui dar Suporte a ARB_vertex_program e ARB_fragment_program
e os dois funcionarão no linux (w32 sucks), agora vou fazer o tão famoso Cel Shading e deixar minha CPU livre pro ODE fazer o trabalho dele.>/p>

Vou começar também o estudo de mapas vou seguir essa técnica

só depois tenho que pensar na parte de Texturas mesmo se for toon shading ainda vai precisar, tenho que organizar o código padronizar algumas coisas e acho que ja é hora de dividir em namespaces mais isso são contos futuros. A parte de física ta meio abandonada e vai ficar por um tempo vou me concentrar na parte gráfica.

Até mais.

Newbie Engine 0.2 Now

Bom pessoal acabei de fazer o commit no svn depois de 5 meses, tem bastante código novo lá.

http://newbie-engine.svn.sourceforge.net/viewvc/newbie-engine/

só tenho que mudar o Makefile pra compilar a nova versão (Estou trabalhando com eclipse CDT agora). e tb criar um versão pro Dev-C++ mais isso fica pro próximo RC.

temos mais um membro no projeto Geison Munhoz, ele vai se aventurar na parte de
Audio, não sei se vai dar tempo mais mais ainda estamos na GPC 08 a PDJ.

newbie-engine news

-O Parse de XML (Agradeço ao time BZK) já esta funcionando

-Carregando Mesh (Wavefronr .obj) no formato trigonometrico, falta aplicar, materiais e texturas

-Projeto adicionado ao sourceforge.

-Agradecimento ao Jaca, (modelador) vlw.!!!
http://sourceforge.net/projects/newbie-engine/
http://br.geocities.com/newbie_x11/newbie_engine.zip (Não consegui fazer upload no SF)