Uma função nada mais é, em sua essência, do que apenas um conjunto de instruções binárias em alguma posição de memória. Sendo assim, então, o C/C++ permite você criar um ponteiro para uma função, que irá guardar o endereço de memória que poderá ser executada. Esse tipo de funcionalidade permite técnicas, como por exemplo, um sistema de eventos.

Antes de começar a demonstrar como usar ponteiros para funções, entendam que a sintaxe para trabalhar com eles é estranha, mas depois que se entende a técnica, fica simples entender.

Como C (e C++) é uma linguagem fortemente tipada, nenhum dado pode ser de tipo desconhecido para ser utilizado, e funções não são exceção. Alem disso, funções tem o agravante de não apenas terem um tipo de dado de retorno, mas também a possibilidade de receber n parametros. Então, ao declarar um ponteiro para função, é necessário declarar  seu tipo de retorno e os tipos de todos os parametros. Voce consegue o endereço de uma função usando o nome da função, sem o operador (). O uso do operador & antes do nome da função é, neste caso, opcional. Porém, mais além iremos ver um caso onde o seu uso é obrigatório. Vamos ver alguns exemplos:

// exemplo de função 01
void vazia() {}
// seu ponteiro e atribuiçao
void (*fpVazia)(void) = vazia;
 
// exemplo de função 02
int numero() { return 2; }
// seu ponteiro e atribuição
int (*fpNumero)(void) = numero;
 
// exemplo de função 03
int soma(int a, int b) { return a+b; }
// seu ponteiro e atribuição
int (*fpSoma)(int,int) = soma;

Como disse anteriormente, a sintaxe é ligeiramente estranha, mas funciona. Temos aqui três ponteiros para funções. Agora para executar cada uma dessas, usamos a seguinte sintaxe:

// executa cada uma das funções anteriores
fpVazia();
int num = fpNumero(); // num recebe 2
int res = fpSoma(2,2); // res recebe 4
 
// outras formas de executar:
(fpVazia)();
(*fpVazia)();

Repare que eu coloquei algumas outras formas de executar no final do código. Embora todas elas funcionem na maioria dos compiladores, alguns compiladores mais antigos podem dar problema com um ou outro formato. Além disso, para executar ponteiros para métodos (funções membros de classe), a sintaxe para chamadas de função vai ficar menos flexivel.

Para facilitar um pouco a sintaxe de uso de ponteiros para função, podemos utilizar o operador typedef, como exemplifico a seguir:

// exemplo de declaração sem typedef
void (*funcExemplo)(int,int) fpExemplo;
 
// agora usando typedef para criar
// um tipo de dado novo que é um
// ponteiro para função
typedef void (*funcExemplo)(int,int);
// declarando o ponteiro
funcExemplo fpExemplo;

Muito mais simples, não? se você pensar na questão de passar ponteiros para função como parametro de outra função, esta facilidade de criar um tipos de dados deixa o código muito mais limpo e facil de entender.

Ponteiros para funções são muito úteis, mas você deve estar pensando “posso usar isso para criar ponteiros de métodos de classes?”. A resposta carrega junto uma explicação:

Um método estático de uma classe é exatamente igual a uma função comum – apenas que o compilador mantém controle sobre as permissões de acesso. Um método não-estático, porém, tem uma diferença. O formato de chamada (_thiscall), envia internamente um parametro extra – um ponteiro para o objeto no qual o método está sendo chamado. Disso podemos tirar que, além de sabermos o endereço dessa função, é necessário um ponteiro (ou referência) para o objeto do qual queremos chamar o método. Aqui está o exemplo de um ponteiro para um método:

// vamos ver uma classe
class A
{
private:
   int _a;
 
public:
   A(int a) : _a(a) {}
   ~A() {}
 
   // método a ser executado
   int soma(int b) { return _a + b; }
};
 
// criação do tipo ponteiro 'funcSoma'
typedef int (A::*funcSoma)(int);
 
// criando ponteiro
funcSoma fpSoma = &A::soma;
// nao podemos chamar a função sem um
// objeto do tipo A
A a(2);
A p = new A(3);
 
// chamando função pelo ponteiro
int res;
res = (a.*fpSoma)(2); // res recebe 4
res = (p->*fpSoma)(2); // res recebe 5

Repare em algumas peculariedades. Primeiro, inicializamos o ponteiro passando o caminho do método (&A::soma – diz q soma pertence à classe A. Neste caso, o uso do operador & passa a ser obrigatório). Como disse anteriormente, chamar o método sem uma referência a um objeto da classe é impossível, então criamos os objetos ‘a’ e ‘p’ do tipo A. Finalmente, vemos os métodos sendo executados. Repare bem na sintaxe: voce usa o próprio objeto para chamar o método. No caso, dependendo do tipo (se é uma referência ou um ponteiro), usamos um operador diferente. .* ou ->*.

Num próximo post, irei descrever a implementação de uma classe genérica (usanto templates) que facilita a manipulação de ponteiros para métodos.

Decidi utilizar XNA como base para estes artigos pela sua facilidade de utilização, além de permitir uma fácil adaptação para C++ com DirectX.

Neste artigo, estarei explicando o básico de renderização 3D, gerando triângulos por programação e renderizando-os com cores básicas e com texturas.

A pedidos de alguns leitores, estou editando o artigo para colocar aqui uma pequena explicação sobre o que é XNA, e onde pode baixar.

O XNA é uma framework dotNET da Microsoft. É uma biblioteca de classes e ferramentas para desenvolver facilmente jogos para Windows e XBox 360 utilizando a linguagem C#, mas mantendo uma estrutura semelhante ao DirectX (tanto que sempre aconselho começar com XNA para quem está querendo começar a estudar DirectX). Você pode fazer download do Visual C# 2008 Express Edition e do XNA Game Studio 3.1 AQUI. Ambas as ferramentas são grátis.

Antes de começar o artigo, é importante salientar que o XNA necessita de shaders para renderizar qualquer coisa na tela. Como iremos aprender sobre shaders em outros artigos mais adiante, cada artigo anterior a esse estudo irei preparar um arquivo de shader específico para podermos trabalhar tranquilamente cada assunto tratato. O arquivo de shader para este artigo pode ser BAIXADO AQUI.

Comece por criar um projeto XNA Windows Game 3.1.

Para utilizar o arquivo de shader, é preciso fazer o seguinte. Primeiro, copie o arquivo de shader .fx para a pasta Content, dentro da pasta do seu projeto XNA. Em seguida, importe-o para o projeto dentro do Visual C#, clicando com o butão direito na pasta Content, e escolhendo Import Existing Item. Agora, temos algumas linhas de código necessárias para utilizar esse shader. No arquivo de código Game1.cs, logo em cima ao código criando o GraphicsDeviceManager e o SpriteBatch, coloque o seguinte código:

Effect effect;

Dentro do método LoadContent(), coloque:



effect = Content.Load<Effect>("article01");

E finalmente, precisamos criar a base de renderização com esse shader, com o seguinte código dentro do método Draw():

// limpar a tela com a cor preta
GraphicsDevice.Clear(Color.Black);
 
// setando o efeito padrão - explicarei melhor esta parte mais tarde
effect.CurrentTechnique = effect.Techniques[0];
// aqui começa a renderização utilizando este shader
effect.Begin();
foreach (EffectPass pass in effect.CurrentTechnique.Passes)
{
   // cada shader pode ter vários passos - explicarei mais tarde também
   pass.Begin();
 
   // AQUI IREMOS COLOCAR NOSSO CÓDIGO DE RENDERIZAÇÃO DE MALHA
 
   // termina o passo
   pass.End();
}
// termina renderização com este shader
effect.End();

Pronto, temos agora a base necessária para renderizar o nosso exercício de hoje.

Qualquer objeto renderizado em 3D é representado por um conjunto de triângulos. Cada triângulo é (logicamente) definido por 3 pontos, que chamaremos de vértices. Cada vértice, por sua vez, tem um conjunto de características definidas, como por exemplo posição espacial ou cor.

No XNA, existem algumas estruturas prontas com definições de vértice, então iremos utilizar essa facilidade para começar. A estrutura VertexPositionColor define um vértice com posição e cor. Para definir um triângulo, necessitamos de 3 vértices, então vamos criar um array e um método para inicializar nosso array:

VertexPositionColor[] vertices;
private void CriaVertices()
{
   vertices = new VertexPositionColor[3];
 
   vertices[0].Position = new Vector3(-0.5f, -0.5f, 0);
   vertices[0].Color = Color.Green;
   vertices[1].Position = new Vector3(0, 0.5f, 0);
   vertices[1].Color = Color.Yellow;
   vertices[2].Position = new Vector3(0.5f, -0.5f, 0);
   vertices[2].Color = Color.Red;
}

Repare que eu estou colocando as coordenadas diretamente no espaço 2D da tela, assim não existe necessidade de transformar de 3D para 2D (iremos ver isso mais tarde). Agora que temos nosso triângulo definido, precisamos ainda definir o formato dos nossos vértices, para que a placa de vídeo saiba utilizar os dados do nosso array. Para isso, utilizamos a estrutura VertexDeclaration, da seguinte forma:

VertexDeclaration vertexDecl;
private void CriaDecl()
{
   vertexDecl = new VertexDeclaration(GraphicsDevice, VertexPositionColor.VertexElements);
}

Agora, basta chamar estes dois métodos para inicializar nossos dados e estamos prontos para renderizar. Coloque a chamada para ambos os métodos criados dentro do método LoadContent(), logo após a leitura do Effect. Basta colocarmos o código que vai enviar os dados para a a placa de vídeo e renderizá-los, dentro do loop Begin()..End() dos passos do nosso shader, no método Draw()

// aqui setamos a declaração do formato de vertices no directx
GraphicsDevice.VertexDeclaration = vertexDecl;
// aqui mandamos o directX desenhar nosso triângulo
GraphicsDevice.DrawUserPrimitives(PrimitiveType.TriangleList, vertices, 0, 1);

Rode a aplicação e você deverá ver um triângulo desenhado na tela, onde cada ponta tem uma cor diferente. Vamos entender um pouco mais sobre este último pedaço de código.

A primeira linha passa a declaração do formato dos vértices. O array de vértices, ao ser passado para a GPU, é transformado num stream de bytes, e é esta declaração que vai definir o tamanho nesse stream de cada vértice, assim o que cada dado significa, e sem isto a GPU não saberia o que fazer com os dados.
A segunda linha manda desenhar nosso triângulo, e recebe 4 parametros:

• O primeiro parâmetro, PrimitiveType.TriangleList, define o processo seguido para renderizar os triângulos. Neste caso, TriangleList, significa que a GPU irá utilizar o stream como uma lista de vértices, desenhando triângulos utilizando 3 vértices por vez. Outras opções utilizam a stream de jeitos diferentes, e iremos estudar essas técnicas mais tarde;
• O segundo parâmetro é o nosso array de vértices, que passamos aqui para o DirectX mandar para a placa de vídeo;
• O terceiro parâmetro é o vertexOffset. Basicamente, qual o índice do array que a GPU deve usar como primeiro vértice. No nosso caso, começamos no início do buffer, ou seja, índice 0;
• Finalmente, o ultimo parâmetro define o número de triângulos a serem desenhados. Se quisermos aumentar este número, é necessário a criação de mais vértices no nosso array.

Ok. Chegamos ao fim do nosso primeiro artigo sobre renderização 3D. No próximo artigo, iremos estudar como utilizar coordenadas 3D de mundo (para não ter que definir coordenadas 2D de tela diretamente nos vértices), e como transformar essas coordenadas 3D em 2D na tela.

O curso é 100% online, com videoaulas e suporte através de um fórum com uma comunidade ativa, onde os professores estarão presentes para tirar duvidas e receber sugestões.

O GamesTotal visa ensinar todos os conceitos necessários para um profissional da área de desenvolvimento de jogos. Embora cada profissional do mercado tenha sua especialidade (programação, animação, modelagem, texturização, game design, level design, etc), é importante saber os conceitos essenciais de todas as áreas, e portanto o curso GamesTotal é generalista nesse ponto. A Artic Studios está trabalhando em outros cursos mais especificos, que irão se aprofundar em todas as áreas, partindo dos conceitos básicos passados neste curso.

O preço será de R$ 650,00 após o lançamento oficial dia 15 de Dezembro, mas até o dia de lançamento estamos fazendo pré-venda com 40% de desconto. É possivel pagar à vista ou parcelado em até 18x. Mais informações no HotSite do curso.

Então, serão abordadas todas as áreas importantes do desenvolvimento de um jogo digital:

• Game Design
  • Aqui o aluno irá aprender como desenvolver um Game Design Document, assim como desenvolver mecânicas de jogo, criação de personagem, enredo e roteiro;
• Game Art
  • Depois do desenvolvimento de todo o game design do jogo, é necessário o desenvolvimento do visual baseado nesse design document. Aqui iremos aprender como transformar os conceitos definidos no GDD, e criar todo o conteúdo gráfico do jogo, desde concept até modelagem 3D, texturização e animação;
• Programação
  • Ter todo o game design e arte do jogo definidos e criados não é o bastante. É com programação que irão aprender como dar vida ao jogo.

Mais informações no site oficial

Posso responder dúvidas deixadas nos comentários, msn, skype ou gtalk.

Em 2008, no meu antigo blog VertexBuffer, coloquei algumas informações sobre a GDC de San Francisco, Califórnia. Neste post, estarei explicando de novo todos os detalhes sobre este evento importante do mercado de jogos internacional.

A GDC acontece no Moscone Center em São Francisco, Califórnia. Em termos de valores, não fica uma viagem barata para brasileiros (mesmo com a estabilização do dólar). No entando, se existe a possibilidade de ir, não perca esta oportunidade de aprender com grandes profissionais e aumentar sua rede de contatos. Andei fazendo algumas sondagens de preços de passagens, e vi preços que variam de R$ 2800 a R$ 4000 (de São Paulo a San Francisco, com variadas escalas e tempo de vôo). É bom lembrar que quanto mais próximo ao dia do embarque, mais caras ficam as passagens. Em relação a hospedagem, os hoteis pertos do Moscone Center são ligeiramente caros, e vão de US$ 120 a US$ 250 pernoite, sendo que alguns tem quartos com duas camas, podendo assim ser divididos. Existem também alguns albergues na região, onde você pode conseguir quartos por valores perto de US$ 500 por semana.

Além de viagem e hospedagem, existe também o gasto com a entrada para o evento. A compra antecipada (este ano até 4 de Fevereiro 2010) garante um desconto de 35%. Existem vários passes, de diferentes acessos a certas partes do evento e, consequentemente, de diferentes preços. Ainda não foi divulgado no site oficial os preços dos passes do próximo ano, mas vou falar os preços que eu paguei na minha última participação. O passe mais completo é o “All Access Pass”. Com ele é permitido participar de todos os tutoriais, eventos, palestras, keynotes, etc. Este passe costuma ficar por volta de US$2000. Alguns outros passes que costumam ter:

Main Conference Pass – US$1400. Permite acesso às palestras, pavilhões de exposição, keynotes e eventos dos 3 últimos dias do evento (os tutoriais e workshops, além de alguns outros eventos, acontecem nos 2 primeiros dias);

GDC Mobile Pass  - US$1050. Passe especial para participantes focados em desenvolvimento para mobile;

Expo Pass – US$200. Passe apenas para os 3 dias de exposição. Sem acesso às palestras, keynotes, etc.

Todo ano aparecem e somem tipos de passes, então é importante ficar ligado no site oficial, e ao abrir as informações de passes, ler atentamente todas as possibilidades para encontrar a mais apropriada. Os preços do evento incluem café da manhã e almoço nos dias correspondentes.

Falando um pouco da conferência agora. A GDC é na verdade o conjunto de vários eventos simultâneos. Segunda e terça são voltados para negócios e profissionais. Envolvem vários ’summits’ (pequenos eventos), com palestras e atividades específicas a certas áreas do desenvolvimento de games. Por exemplo, a GDC Mobile, voltada para desenvolvimento de jogos para portáteis, Independent Game Summit, voltado para a comunidade de desenvolvedores independentes, etc. Acontecem também sessões de tutoriais e workshops de durações que vão de 1 hora até os 2 dias.

De quarta até sexta, a chamada “main conference” acontece. Nesses dias, a feira com os stands das empresas e universidades é aberta aos participantes. É muito interessante tirar um tempo para passear calmamente pela exposição. Em outro bloco, existe outra “expo” com stands – o Pavilhão de Carreira. Ali, é possivel conversar com representantes de RH, e em alguns casos até representantes das diferentes áreas das empresas.Ao mesmo tempo que existem os dois pavilhões de exposição e carreira (acredite, acontece tanta coisa ao mesmo tempo que é facil se sentir perdido), acontecem as palestras. São um volume monstruoso de palestras , geralmente com várias da mesma área (programação, audio, design gráfico, game design, etc) acontecendo simultaneamente. E acredite, vocÊ terá que escolher e não será facil.

Acontecem também keynotes (alguém importante dando sua visão), que eu recomendo (dependendo do palestrante). Eu tive a honra de participar da keynote do Ray Kurzweil sobre os proximos 50 anos da indústria de jogos. Além disso, todo ano tem o evento/festa de premiação da IGF (Independent Game Awards), que reconhece os melhores jogos independentes do ano e as premiações para os melhores jogos “mainstream” do ano – a Game Developer’s Choice Awards.

Além de tudo isso, existem diversas festas e eventos acontecento. Desde a tradicional festa da IGDA (International Game Developers Association), até diversas festas patrocinadas pelas grandes empresas como Microsoft, Sony, etc, e incluindo também um campeonato beneficiente de Pocker. Muito importante estar atendo à programação do evento para saber escolher o que quer fazer. A cidade de San Francisco oferece também entretenimento e lugares interessantes para visitar.

Dentro do Moscone Center costuma ser montada uma pequena loja oficial do evento, vendendo desde camisetas até livros, DVDs, camisas, bolsas, canetas, esqueiros e o que mais você possa imaginar. As coisas não são muito caras, vale a pena comprar algumas lembrancinhas pra fazer inveja aos seus colegas e amigos. Tem também todo ano uma espécie de jogo interno ao evento que qualquer um pode participar. É um jogo focado em networking e me falaram que é bem interessante, porém nunca participei.

Agora deixo aqui algumas dicas e informações:

Informações:

• site oficial: www.gdconf.com (o site costuma ser atualizado mais perto do final do ano, é bom ficar ligado)
• Data: 9 a 13 Março 2009

• Local: Moscone Center, San Francisco – CA

Algumas dicas:

• Tente chegar um ou dois dias antes do evento. É bom poder descansar, se habituar ao clima/horário, e encontrar seus contatos pré-estabelecidos antes do evento (caso combine algo) ou mesmo passear um pouco pela cidade;
• O mesmo para o retorno. Tente passar pelo menos um dia inteiro na cidade pós-evento. Viajar para tão longe e não conhecer a cidade decentemente é triste. De preferência e se tiver condições, pegue uma semana a mais porque realmente vale muito a pena;
• Participe do máximo de festas e eventos noturnos da conferência. Se possível, vá com alguém (ou sozinho mesmo, acredite você consegue puxar papo fácil com pessoal de games) a algum dos bares da região. Um bar bastante badalado pelo pessoal da GDC é no W Hotel (é do lado do Moscone Center). É uma ótima hora para socializar e fazer networking. Além do mais, é bom dar aquela relaxada tomando uma boa cerveja. Não precisa gastar muito para beber e comer bem;
• Não perca nenhum horário de palestra. Se realmente não tem nenhuma palestra interessante em algum horário (o que vai ser raro), aproveite esse tempo para fazer algo como visitar o pavilhão de exposição;
• Seja simpático e comunicativo. Todo mundo ali está com espírito de festa e diversão, quase certeza que, se você puxar papo com o pessoal na sua mesa de almoço ou na descida da escada rolante, a pessoa vai conversar com você tranquilamente, e talvez até trocar cartões de visita;
• Leve cartões de visita. Se você trabalha em uma empresa, peça para seu chefe. Se recusarem ou simplesmente você ainda não trabalha/não quer levar cartão da empresa – faça um pessoal. Um cartão apresentável com nome, profissão, email e telefone é obrigatório num evento deste porte;
• Se pretende procurar oportunidades, leve um currículo padrão internacional. Não precisa levar impresso, existem alguns locais baratos para impressão por lá. Se não pretende procurar oportunidade, leve seu currículo mesmo assim – nunca se sabe o que pode acontecer;
• Tire o pó do seu inglês. É sério, se está na area de desenvolvimento de jogos, inglês é obrigatório. Se você enrola no inglês, dê um jeito de desenferrujar. Se não sabe, tá em boa hora de aprender;
• Leve dinheiro extra ou cartão de crédito com um bom limite. Você vai querer sair, comprar bugiganga, etc – se você for de grana contada vai perder oportunidade de se divertir melhor, e quem sabe de passar na BestBuy comprar aquela placa de vídeo ou então na Apple Store comprar seu iPod Touch ou MacBook (tem uma AppleStore a duas quadras do Moscone Center);
• Ao se registrar no evento, você ganha uma entrada para o site de relacionamento do evento (MyGDC). Entre nele, use bastante, tente descubrir pessoas com interesses parecidos e puxe papo. O networking pode começar mesmo antes de ir!!
• Se você tiver conhecidos pelo evento, tente saber que palestras eles vão participar. Não é muito interessante você ir em uma mesma palestra que um conhecido seu – muito melhor vocês combinarem de cada um ir em uma palestra diferente, e depois trocar figurinha;
• Leve (ou compre por lá) uma camera digital. Documentar sua viagem é muito importante;
• No evento você ganha uma sacola com presentinhos, folhetos e outras coisas interessantes e úteis para o evento e depois. Não se acanhe de pegar o bloco e caneta que vem dentro e de anotar bastante durante as palestras. Sua memória pode ser infalível mas depois de dois dias durmindo 3~4 horas com palestras durante o dia e cerveja de noite, ela pode começar a lhe faltar.

Se tiver dúvidas, quiser conversar sobre a GDC por msn/gtalk/email, ou quiser mais informações também é benvindo a colocar comentários ou me procurar.

Abraços pessoal!

Então estou desativando o velho VertexBuffer e criando este novo blog, que terá bastantes informações, dicas, tutoriais e artigos sobre o mundo de desenvolvimento de jogos digitais. Espero que todos fiquem bastante satisfeitos com o resultado!

Um abraço para todos vocês!