Archive for fevereiro de 2008

Engine 3D – Especificação

Idéia inicial

O Ploobs está com uma empreitada audaciosa, criar uma engine de jogos 3d.
A idéia do desenvolvimento é nos fazer aprender bastante sobre o mundo do jogos e ter uma biblioteca que nos possibilite desenvolver jogos e às outras pessoas também, de forma o mais flexível possível.
Pensamos em uma plataforma de desenvolvimento que pudesse ser portável a vários SO, não apenas Windows, e de uma forma que ela funcione perfeitamente, com apenas poucas modificações.

Features (essa parte será sempre atualizada, e estou colocando aqui de forma bem grosseira)

  • Câmeras
  • Luzes
  • Texturas
  • Input (teclado, mouse e controles)
  • Som
  • Física
  • Shaders
  • Sistema de partículas
  • Modelos ( obj,3ds,md2,md3, etc…)
  • Scene Graphs
  • LOD
  • AI

Dentro de cada item desses existem obviamente diversos sub-itens que com o tempo serão especificados.

Nossa idéia é ter em dois anos uma plataforma básica que nos permita desenvolver jogos de pequeno e médio nível com grande facilidade mas também autonomia.

Não queremos inventar a roda e nem mudar o mundo só fomentar os jogos brasileiros, para que passemos a usar mais o que é nosso e assim crescer a cultura de desenvolvimento de jogos no Brasil

Nenhum comentário.

Templates

Para entender para que servem os templates, vamos analisar um caso simples: queremos criar uma biblioteca para criar e manipular stacks de inteiros. Em C++, podíamos fazer qualquer coisa do gênero:

class Stack {
public:
Stack(int size) {
stack = new int[size];
msize = size;
ptr = 0;
}

~Stack() {
delete[] stack;
}
int size() {
return ptr;
}
void push(int i) {
if (ptr < msize) stack[ptr++] = i; else // whatever } int top() { if (ptr > 0)
return stack[ptr-1];
else
// whatever
}
void pop() {
if (ptr > 0)
ptr–;
else
// hm, whatever
}
private:
int ptr;
int msize;
int *stack;
};

Há vários aspectos desta implementação que são discutíveis, mas o que importa aqui é a questão simples: e se eu precisar de um stack não de inteiros, mas de doubles?
Claro que posso copiar o código todo e alterar int para double. E se quiser os 2 ao mesmo tempo? E se depois quiser um stack de objectos de uma classe qualquer que ainda nem sei qual é? Já se vê o problema: esta implementação não é genérica, ou seja, não pode ser usada com qualquer tipo de dados. Os Templates resolvem este problema. Antes de explicar, aqui está o código do mesmo stack mas agora genérico, ou seja, um stack que pode ser de um tipo qualquer:

template
class Stack {
public:
Stack(int size) {
stack = new Type[size];
msize = size;
ptr = 0;
}

~Stack() {
delete[] stack;
}
int size() {
return ptr;
}
void push(const Type &t) {
if (ptr < msize) stack[ptr++] = t; else // whatever } Type top() { if (ptr > 0)
return stack[ptr-1];
else
// whatever
}
void pop() {
if (ptr > 0)
ptr–;
else
// hm, whatever
}
private:
int ptr;
int msize;
Type *stack;
};

Este código ajuda imenso a ver como se usam os templates: usa-se a keyword template, seguida do nome genérico que vamos usar entre <>. Neste caso, o nome é Type. A linha completa fica template. Se quisermos usar 2 tipos genéricos, fica template (podem ser quantos forem precisos). Como o nome que usámos foi Type esse é também o nome que usamos para nos referirmos a esse tipo no código que se segue. Neste caso, o código abrangido pela definição do template é a definição da classe Stack. Se o código das funções fosse definido fora da definição da classe, teria de ser assim: template

Type Stack::top()
{
if (ptr > 0)
return stack[ptr-1];
else
// whatever
}

Pronto, esta parte foi simples. Agora como se cria um stack por exemplo, de inteiros? E de doubles?

int main()
{
Stack pilha(10);
Stack pilhaReal(10); // ai

pilha.push(2);
pilhaReal.push(3.14);
cout << pilha.top() << “\n”;
pilhaReal.pop();
return 0;
}

Portanto, se quiserem usar um stack de objectos de uma classe chamada MuitaClasse, o código é Stack o_meu_stack(100).

Nenhum comentário.