Acabei de ler este livro. Ele é escrito com bom-humor, o que deixa sua leitura mais agradável, ainda mais em um campo que é tão complexo como a programação de um engine para jogos 3D, porém em alguns lugares o autor tenta ser engraçado com desleixo, dizendo que escreveu um código em 1 hora porque estava vendo TV, o que para mim não é engraçado e ainda me deixa com uma pulga atrás da orelha.
Um ponto que considerei negativo é que em várias partes o autor diz que o livro tem como audiência programadores avançados, porém em muitas partes o autor entra em detalhes desnecessários, os quais tais programadores já dominam. Estas explicações poderiam ter sido deixadas de fora, abrindo espaço para abordar outros assuntos ou até mesmo para diminuir este monstro de mais de 800 páginas.
Um detalhe importante e que acho que muitas pessoas levam em consideração é que o livro é um pouco antigo, de 2004, porém muitas das informações ainda são relevantes, pois apesar das placas de vídeo terem evoluída bastante de lá pra cá as técnicas para se programar uma engine continuam as mesmas. Em qualquer área da computação se usa técnicas desenvolvidas a muitos anos atrás. Vários algoritmos que foram utilizados em jogos como Doom ainda são muito relevantes. Para a minha pouca experiência nesta área, a leitura foi ótima para entender vários conceitos e iniciar a programação de uma engine simples.
A introdução é bastante interessante e possui diversos pontos de vista que compartilho, alguns deles são:
- Game Engine: o livro deixa a definição aberta, mas sugere um norte, que seria os blocos que permite criar um jogo de forma "simples", sem ter que lidar com detalhes de hardware. Ela lhe provê funcionalidades para facilitar o desenvolvimento de aplicações em um ambiente 3D e nunca conterá qualquer código que envolva a lógica do jogo.
- Faz um comparativo entre o modelo de desenvolvimento antigo, quando os computadores tinham pouco memória, poder de processamento e placas gráficas rudimentares e o novo, que permite pensar em um nível mais alto, sem se preocupar tanto com algoritmos, otimizações de código assembly, etc, pois atualmente, em alguns casos, é mais fácil utilizar força bruta e deixar o HW se virar.
- Coloca o hardware como seu aliado. As coisas têm que ser assim, se você ver o hardware como seu inimigo você sempre vai estar lutando com ele, porém encarando ele como um aliado você tentará tirar o máximo que ele pode lhe oferecer, você conhecerá suas forças e suas fraquezas e saberá utilizar cada uma delas (será que a realidade é assim mesmo?).
- Nesta parte também é apresentada como o projeto e construção do jogo deve ser encarada e realizada por um time, porém não vou colocar mais detalhes, primeiro porque não li toda esta parte e segundo porque a minha intenção é realizar um desenvolvimento hobbysta e por enquanto não tem time nenhum :).
O livro tem uma tendência a utilizar conceitos do Direct3D / DirectX, pois seu autor é mais inclinado para estas tecnologias, mas o livro tenta ser independente de uma API gráfica em particular, porém o autor deixa o aviso que se alguém tentar implementar as interfaces que ele define utilizando OpenGL vai encontrar alguma dificuldade. É bom ter este tipo de aviso, pois a minha intenção é utilizar OpenGL, então tenho que manter o foco muito mais nos conceitos do que na forma de implementação em específico.
O capítulo 2 trata a respeito do projeto de uma engine e seus principais objetivos são: (1) projetar uma engine de jogo básica; (2) criar engines independente da aplicação que a usa e (3) construir uma engine a partir de partes simples. Era isso mesmo que eu estava procurando, chocolatin!!!
O capítulo começa perguntando qual será o nome da sua engine? A minha será Kodorna, por quê? É um apelido que meu irmão me deu a muito tempo, quando tinha uns 12 ou 13 anos e na época me deixava muito irritado, mas agora já me acostumei e até eu me chamo de Kodorna. Acho que é um nome bacana por ser despretensioso, porém ao mesmo tempo faz parte de uma época bacana da minha vida, onde eu estava amadurecendo ou não, talvez eu ainda continue verde :D
Neste capítulo é apresentado uma visão geral da engine e como ela irá funcionar, mencionando onde aparecerão mais detalhes a respeito de sua implementação. Ótima apresentação!
Não gostei do capítulo 3. Ele não teve uma utilidade imediata para mim, pois quero escrever um jogo em OpenGL na plataforma Linux. Apesar disso ele mostra como isolar o código dependente de API em uma interface, algo que não era novidade para mim, mas que é interessante.
Além disso achei a explicação do código ruim, é apresentada uma parte disso, outra daquilo, daí volta para apresentar um pouco mais do início. Acabou ficando confuso, sendo necessário voltar as páginas para relembrar a relação da nova informação com a antiga, sendo que seria possível explicar todas as coisas a respeito de uma parte uma vez só.
O quarto capítulo é sobre otimização de código e matemática. Ele começa alertando para o fato de não otimizar coisas desnecessárias (
"Premature optimization is the root of all evil" - Donald Knuth) e fazer
profiles para saber quais partes do código estão com problemas, algo bastante conhecido pelos programadores. O assunto fica interessante quando o autor começa a falar sobre as extensões disponíveis nos processadores para acelerar certas computações, são elas: MMX, SSE, SSE2 e 3DNow!. Acho a discussão interessante, pois pelo que eu saiba os compiladores livres não geram código para estas extensões. Uma biblioteca que nunca utilizei, mas que acredito ser útil para fazer uso destas extensões é a
liboil.
Neste capítulo além de introduzir algumas classes básicas para qualquer engine, que são as classes para manipular vetores e matrizes (utilizando as extensões citadas acima claro), também é explicado o conceito de "rays". Este é uma classe para selecionar objetos em sua tela, como em um editor 3D ou em um jogo como "The Sims" e também é utilizado para detectar colisões. Por último o autor trata de
quaternions, uma representação matemática que facilita rotações em qualquer um dos eixos. A matemática inclusa no capítulo é ótima, porém não li com muita atenção, pois sua utilização é principalmente para detectar colisões e eu pretendo utilizar a biblioteca
Bullet para isso, mas tenho certeza que algumas destas informações ainda me serão úteis. Além disso, o autor deixa referência ao livro
Geometric Tools for Computer Graphics, o qual parecer ser uma ótima referência a matemática utilizada em jogos.
O capítulo 5 é ótimo. Trata de luzes, materiais e texturas. Possui uma discussão básica sobre a utilização de luzes, mas suficiente para fazer uso desta tecnologia. Não li muito a respeito deste assunto, pois minha placa de vídeo não suporta luzes, sendo assim não pretendo utilizá-la, sendo que efeitos de iluminação podem ser conseguidos de outras formas, tal como o uso de
pixel e vertex shaders. A discussão sobre materiais e texturas é bastante interessante e o código apresentando é bem útil. A classe que carrega as texturas em memória é um
flyweight, porém o autor não o chama assim, mas a classe impede que texturas idênticas sejam carregadas mais de uma vez para a memória.
Capítulo 6 terminado e quanta informação! Nesta parte o autor mostra como suportar visões diferentes (ortogonal, perspectiva e 2D), várias viewports, modos de renderização diferentes (wireframe, etc) e como alternar entre esta opções influenciam nos cálculos da matriz de visualização, campo de visão,
view frustrum, etc (e como se deve fazer estes cálculos, claro :). Um material muito interessante. Depois disso entra a parte de renderização de vértices e como tornar esta operação rápida. Uma pena que esta parte é inteiramente voltada ao DirectX, a qual não pretendo estudar, porém através do encapsulamento de como as renderizações são feitas não se faz mais necessário acessar a API do DirectX, então o que posso fazer é me inspirar nesta implementação para reescreve-la utilizando OpenGL. Um ótimo exercício. A partir deste ponto a engine já está pronta para ser utilizada em suas primeiras renderizações!
O capítulo 7 foi bem rápido apesar do assunto ser super interessante:
Pixel e Vertex Shader! Com estas duas tecnologias recentes é possível programar como a placa irá renderizar os pixels na tela de uma forma muito mais fina e obter diversos efeitos legais, até mesmo efeitos de iluminação. Não pretendo me dedicar muito a
shaders no momento e por isso li o capítulo bem rapidamente, só para ter uma idéia geral da coisa, mesmo porque o assunto é muito mais complexo para ser tratado em apenas um capítulo de um livro de programação de engines 3D como o próprio autor comenta. Atualmente existem muitas linguagens para programar shaders que se assemelham a linguagem C, porém o autor mostra a tecnologia em uma linguagem parecida com Assembly, pois considera importante que o leitor saiba o que está por baixo dos panos e realmente é bem interessante, com poucas linhas de código (6 linhas para ser mais preciso) já é possível criar efeitos interessantes. Sim, você não leu errado, poucas linhas em assembly podem fazer grande diferença em suas cenas!
Mais um capítulo rápido. Neste o autor expões uma classe para carregar um modelo 3D com informações de esqueleto e juntas, permitindo animar personagens como monstros, pessoas, e até coisas simples, como máquinas com peças móveis.
Outro capítulo que passei muito rápido (será que todos serão assim daqui pra frente?). O capítulo 9 trata do módulo de entrada, seja ele por teclado, mouse ou joystick. Um capítulo simples, porém totalmente voltada para como fazer as coisas com DirectX e como sei que vou utilizar SDL para esta função passei bem por cima deste capítulo.
Não só passei pelo décimo capítulo muito rapidamente, mas ele também é bem curto e cobre o básico do suporte de som em um jogo, porém introduzindo suporte a som 3D, o que é bem interessante. A API é bem simples e pode facilmente ser implementada utilizando OpenAL, sendo que nesta última já estão disponíveis diversos efeitos de som interessantes na forma de exemplos.
Quase chegando no fim! Décimo primeiro capítulo terminado. Apesar das explicações básicas de vários conceitos de redes, que deixa o capítulo mais digerível para pessoas sem
background no assunto, a implementação é bastante interessante, porém a organização do código não é muito boa, deixando o código do cliente e do servidor misturados. Em implementações mais complexas isso tornaria o código mais difícil de manter e estender. Acredito que o padrão
state neste caso cairia muito bem. Apesar disso, achei que o código encapsula bem a API WinSocket, que pode ser facilmente substituída pela implementação de Berkley, deixando a complexidade da comunicação entre cliente/servidor fora do código da aplicação que utiliza a engine. Por fim, o autor escreve duas aplicações simples para utilizar a API especificada, uma de chat e outra de transferência de arquivos. Capítulo bastante interessante.
O capítulo 12 é bastante curto, porém muito interessante. Nele é mostrado código para gerenciar a câmera de suas cenas. O auto apresenta uma classe base e a partir dela escreve uma câmera com 6 graus de liberdade e uma voltada para jogos de tiro em primeira pessoa. Além disso ele também discute aspectos relacionados a jogos que utilizam câmeras em terceira pessoa e também sobre o uso de
quaternions para evitar o problema de
gimbal lock quando se está manipulando uma câmera com 6 graus de liberdades. Capítulo simples e direto, muito bom!
Cérebro fritando! O capítulo 13 é sobre gerenciamento da cena, ou seja, o que deve e o que não deve ser renderizado na sua tela. Cobre principalmente os algoritmos para renderização de jogos indoor e implementa dois destes algoritmos (BSP e Octree). Tem ainda uma parte nostalgia, onde mostra os precursores dos jogos de tiro em 3D (Doom, Duke Nukem 3D, Castle Wolfstein) que popularizaram as técnicas de gerenciamento de cena. Para quem quer desenvolver jogos outdoor e renderizar terrenos terá que procurar fontes externas. O assunto é bastante vasto e o capítulo é ótimo como uma introdução, além de dar de bandeja os algoritmos supracitados.
O capítulo 14 é enorme e deveras, já que nele é mostrado como implementar um editor de polígonos, ou seja um editor de níveis para o seu jogo sendo capaz das seguintes tarefas:
- Criar polígonos e objetos simples;
- Editar polígonos e objetos no nível de vértices;
- Apagar e copiar objetos;
- Selecionar e esconder objetos;
- Agrupar geometria em uma malha;
- Editar coordenadas de textura;
- Carregar e salvar um nível;
- Carregar e salvar partes de uma geometria;
- Definir pontos de início para os jogadores no jogo;
- Definir e editar fontes de luz;
- Marcar objetos que devem projetar sombras;
- Definir portais para o gerenciador de cena;
Tarefas interessantíssimas! Tudo utilizando a engine desenvolvida no livro, sendo assim, o que você vê na sua tela é como vai aparecer no seu jogo. Apesar disso ainda pretendo utilizar o Blender para criar meus modelos, pois ainda não estou convencido que programar um editor seja produtivo atualmente, sendo que o Blender pode ser estendido com scripts para exportar níveis com informações adicionais que o jogo precisar. Mas só terei certeza disso depois que começar a criar meus modelos.
O último capítulo é a cereja do bolo. Um jogo de
deathmatch multiplayer utilizando a engine. O jogo aproveita algumas classes do editor, porém levando em consideração questões como a performance. Faz uso de tudo que foi escrito até o momento, carregando o nível criado no editor do capítulo anterior. O capítulo também introduz classes para calcular sombras e discute (e mostra o código) de como realizar a renderização do nível de forma eficiente.
Gostei muito do livro, possui partes de muito valor, porém não gostei de algumas pequenas coisas, tal como o estilo do código do autor. Além disso, seria interessante ter mais referências, sendo poucos os livros citados pelo autor. O autor também não utiliza padrões de projeto na criação da engine, algo que eu considero interessante, porém só depois que eu começar a criar e utilizar minha própria engine poderei afirmar se vale a pena ou não.
Apesar da engine criada abranger bastante coisa, achei que faltaram duas coisas importantíssimas e fundamental para a criação de qualquer jogo atualmente: uma biblioteca de física e um sistema de partículas. O primeiro item até entendo que tenha sido deixado de fora, afinal o autor quer criar tudo da engine, pois acha importante ter o entendimento do que está acontecendo, sendo assim, seria necessário criar todo o suporte de física, o que é assunto para um livro inteiro. Já o segundo item achei uma falha grave. Hoje em dia qualquer jogo que se preze tem explosões, chuva, neve, fumaça, etc, e todos este efeitos são criados através de um sistema de partículas, que com certeza ficou faltando neste livro.
Tentei deixar meu texto curto, porém o livro tem mais de 800 páginas, então esta tarefa é bastante complicada. Espero que este
review sirva para você ter uma noção melhor do que vai encontrar no livro e como ele é escrito. Não sou um programador de jogos, nem um programador avançado de C++. Ainda estou aprendendo muito sobre os dois mundos, principalmente o de jogos, porém escrevo para partilhar do pouco da minha jornada e também para colocar as percepções que tenho do que vou aprendendo, pois estes registros é que vão me guiar no desenvolvimento da minha engine e do meu jogo.
