Você está na página 1de 91

UNSANTOS Universidade Catlica de Santos

Centro de Cincias Exatas e Tecnolgicas


Curso de Sistemas de nformao
Trabalho de Concluso de Curso
Desenvolvimento de jogos 3D com
ferramentas gratuitas
Autor: Jonathan Ohara de Araujo
Orientador: Prof. Ciro Cirne Trindade
Santos
2010
ii
Desenvolvimento de jogos 3D com
ferramentas gratuitas
Monografia apresentada ao Curso de Sistemas
de Informao do Centro de Cincias Exatas e
Tecnologia da Uniersidade Cat!lica de Santos
como re"uisito o#rigat!rio para aproao na
disciplina Tra#al$o de Concluso de Curso % II&
_______________________________
'luno( )onat$an *$ara de 'rau+o
_______________________________
*rientador( ,rof& Ciro Cirne Trindade
Agradecimentos
iii
Ao professor Ciro Cirne Trindade, pela orientao, disponibilidade, eficcia e
sinceridade em relao ao projeto, e ensinamentos de linguagem C e estruturas de
dados que foram essenciais no projeto prtico.
Ao professor Andr Vizine pelas ideias na parte de nteligncia artificial, e pelo
incentivo para com o projeto, e pelos ensinamentos na rea de algoritmos.
A todos meus colegas de classe por ter que aturar eu falando o tempo todo
sobre desenvolvimento de jogos.
Aos meus familiares, meu pai, me e irmo que sempre me apoiaram e
incentivaram, tanto na parte acadmica como profissional e pela pacincia.
A minha namorada rica Caires Silva pelo carinho, pacincia, incentivo, apoio
e compreenso pelos tempos que passei estudando e pelo projeto do jogo.
Ao meu colega de desenvolvimento de jogos Luiz Dubas, com o qual
desenvolvi e pretendo desenvolver mais projetos nessa rea.
iv
Resumo
O desenvolvimento de jogos sempre foi tratado de forma proprietria,
cabendo a grandes empresas internacionais desenvolver suas prprias bibliotecas, e
motores de desenvolvimento. Porm, nessa ltima dcada surgiram vrias
evolues nessa rea, motores de cdigo aberto foram desenvolvidos e alguns
motores pagos esto sendo disponibilizados gratuitamente.
No entanto, no Brasil essa rea de pesquisa muito pouco explorada. Um
dos objetivos desse trabalho incentivar mais pessoas nas reas de
desenvolvimento de jogos (arte, programao, msica entre outros).
Esse trabalho alm de terico acompanha o desenvolvimento real de um
projeto de jogo envolvendo os principais aspectos da rea de desenvolvimento de
jogos.
v
Abstract
The game development always was treated as proprietary, fitting the big
international companies to develop their own libraries and development engines. But
in the last decade a lot of improvements arise in this area, open sources engines and
some paid engines are available free.
Nevertheless, in Brazil this research area is less explored. One of my work
objectives is to incentive more people in game development area (art, programming,
music).
This work beyond the theory follows the real development of a game project
using the main aspects in the game development area.
vi
Lista de Figuras
Figura 1: Primeiro registro de jogos computacionais .........................................................1
Figura 2: Atari 2600 primeiro console utilizado em grande escala........................................................2
Figura 3: Quake, grande marco para o OpenGL .........................................................3
Figura 4: Lego sland, grande marco para o DirectX .........................................................3
Figura 5: Need For Speed , grande marco para o Voodoo .........................................................4
Figura 6: TorchLight jogo comercial utilizando Ogre .........................................................6
Figura 7: Grappling Hook jogo comercial utilizando JME .........................................................6
Figura 8: Keepsake jogo comercial utilizando Crystal Space .........................................................7
Figura 9: Cena renderizada com o modelador Blender 3D .........................................................7
Figura 10: Cena renderizada com o modelador Wings 3D .........................................................8
Figura 11: Modelo de Coordenada 2D .......................................................10
Figura 12: Modelo de Coordenada 3D. .......................................................11
Figura 13: Exemplificando Cenas .......................................................11
Figura 14: lustrao de uma cmera para o renderizador .......................................................12
Figura 15: Frustum .......................................................13
Figura 16: Modelos de Luzes .......................................................14
Figura 17: Objeto 3D completo .......................................................15
Figura 18: Vrtices de um Objeto .......................................................15
Figura 19: Vrtices e arestas de um Objeto .......................................................16
Figura 20: Vrtices de um poliedro .......................................................17
Figura 21: Arestas de um poliedro .......................................................18
Figura 22: Faces de um poliedro .......................................................18
Figura 23: Normais .......................................................19
Figura 24: Cor aplicada em vrtices .......................................................20
Figura 25: Texturizao de uma pirmide .......................................................21
Figura 26: Exemplo simples de UV Mapping .......................................................22
Figura 27: Uma espada sem textura .......................................................22
Figura 28: Faces mapeadas em uma imagem .......................................................23
Figura 29: faces mapeadas pintadas .......................................................23
Figura 30: Objeto texturizado com UV Mapping .......................................................24
Figura 31: Eixos e rotaes .......................................................25
Figura 32: Objeto rotacionado em X .......................................................25
Figura 33: Objeto rotacionado em Y .......................................................25
Figura 34: Objeto rotacionado em Z .......................................................26
Figura 35: Matrizes de rotaes .......................................................26
Figura 36: Objeto sem rotao .......................................................27
Figura 37: Objeto rotacionado em X, Y, Z .......................................................27
Figura 38: Objeto rotacionado em Z, Y, X .......................................................28
vii
Figura 39: Exemplo de um quartenio .......................................................29
Figura 40: Os quatros motores fsicos mais populares .......................................................30
Figura 41: teste 1 no Windows, OpenGL e Ogre .......................................................39
Figura 42: teste 2 no Windows, DirectX e Ogre .......................................................40
Figura 43: teste 3 no Windows, DirectX e rrlicht .......................................................41
Figura 44: teste 4 no Windows, OpenGL e rrlicht .......................................................42
Figura 45: teste 5 no Windows, DirectX e Unity .......................................................43
Figura 46: teste 6 no Windows, DirectX e XNA .......................................................44
Figura 47: teste 7 no Windows, OpenGL e JME .......................................................45
Figura 48: teste 8 no Linux, OpenGL e Ogre .......................................................46
Figura 49: teste 9 no Linux, OpenGL e rrlicht .......................................................47
Figura 50: teste 10 no Linux, OpenGL e Jme .......................................................48
Figura 51: Grfico de Comparao entre engines .......................................................49
Figura 52: Grfico dos resultados de Windows, DirectX e Ogre .......................................................49
Figura 53: Grfico dos resultados de Ubuntu, OpenGL e Ogre .......................................................50
Figura 54: Grfico dos resultados de Windows, Directx e XNA .......................................................50
Figura 55: Grfico de Comparao da engine Unity .......................................................51
Figura 56: Nome e logo do jogo .......................................................53
Figura 57: Rob inicialmente .......................................................54
Figura 58: Menu Principal .......................................................56
Figura 59: Modelando o primeiro rob .......................................................57
Figura 60: Modelando o segundo rob .......................................................57
Figura 61: Modelando o esqueleto do personagem para animao....................................................58
Figura 62: Rob associado a um esqueleto .......................................................58
Figura 63: Perspectiva de animao .......................................................59
Figura 64: Animao "andar .......................................................59
Figura 65: Animao "soco .......................................................60
Figura 66: Arena de batalha .......................................................60
Figura 67: Estdio da batalha .......................................................61
Figura 68: Exportador Ogre .......................................................61
Figura 69: Shapes do personagem .......................................................63
Figura 70: Foto 1 tirada durante o jogo .......................................................70
Figura 71: Foto 2 tirada durante o jogo .......................................................70
Figura 72: Foto 3 tirada durante o jogo .......................................................71
Figura 73: Foto 4 tirada durante o jogo .......................................................71
Figura 74: Foto 5 tirada durante o jogo .......................................................71
Figura 74: Foto 6 tirada durante o jogo .......................................................72
viii
Listas de Tabelas
Tabela 1: Primeiro teste ente engines .......................................................39
Tabela 2: Segundo teste ente engines .......................................................40
Tabela 3: Terceiro teste ente engines .......................................................41
Tabela 4: Quarto teste ente engines .......................................................42
Tabela 5: Quinto teste ente engines .......................................................43
Tabela 6: Sexto teste ente engines .......................................................44
Tabela 7: Stimo teste ente engines .......................................................45
Tabela 8: Oitavo teste ente engines .......................................................46
Tabela 9: Nono teste ente engines .......................................................47
Tabela 10: Dcimo teste ente engines .......................................................48
ix
Sumrio
1
1. INTRODU!O
1.1 "onte#tuali$a%&o
O desenvolvimento de um jogo requer atenes especiais e diferenciadas,
pois ele um software completo abrangendo as mais diversas reas das cincias da
computao como programao, design, redes, inteligncia artificial, sons,
integrados e de alto desempenho. Apesar de aparentar recente, a rea de
desenvolvimento de jogos antiga tendo como primeiros registros meados de 1958
com o William Higinbothan com um peculiar jogo de tnis para duas pessoas
denominado 'Tennis for two' (GETTLER, 2010) (vide a Figura 1).
Figura 1: Primeiro registro de jogos computacionais
Outra diferena notria de um jogo para um software que, diferente de um
software, um jogo no feito para solucionar um problema, e sim, para gerar
entretenimento, sendo assim ele tem de ser de fcil compreenso, atrativo e
estimulante ao jogador, ou resumidamente tem de, alguma forma, ser um bom
passatempo, gerar diverso.
Por muito tempo, os computadores pessoais disponveis no tinham
qualidade necessria para produzir imagens de qualidade (EBERLY, 2000), pois a
quantidade processamento com execuo de algoritmos, efeitos sonoros e
processamento de arte grfica principalmente, sempre foi muito grande.
2
Para suprir essa necessidade, com baixo custo, foram criados
"computadores que tinham como fim a especfica funo de fazer processamento
de tudo relacionado a jogos, chamados de consoles.
Pode-se considerar como primeiro console comercialmente utilizado, o Atari
2600 (vide a Figura 2) lanado em 1977 e que teve em sua grande gama de jogos quase mil
ttulos produzidos (ATAR !"#$% 2010&'
Figura 2: Atari 2600 primeiro console utilizado em grande escala
Enquanto isso os jogos para computadores pessoais, s comearam a ser
comercialmente produzidos no meio da dcada de 90, impulsionado principalmente
pela aderncia do mercado aos Sistemas Operacionais grficos surgindo, nessa
poca, importantes AP's (Application Programming nterfaces) para
desenvolvimento de jogos como OpenGL (Open Graphics Library) em 1992 (vide a
Figura 3), o Direct3D em 1995 (vide a Figura 4) e o Voodoo em 1996 (vide a Figura
5), entre outras.
3
Figura 3: Quake, grande marco para o OpenGL
Figura 4: Lego sland, grande marco para o DirectX
4
Figura 5: Need For Speed , grande marco para o Voodoo
Com a grande evoluo do hardware, principalmente daqueles que tm como
fim processamento, como CPU (Central Processing Unit) e GPU (Graphics
Processing Unit), o entretenimento atravs de jogos computadorizados teve seu
acesso facilitado para uma grande parcela de populao. Acompanhando a
evoluo do hardware, os jogos computacionais atuais apresentam evoluo
exponencial em quesitos como qualidade grfica e efeitos e fsica, muito disso
devido evoluo da computao grfica, as AP's dos sistemas operacionais, e da
padronizao de efeitos como o shader (conjunto de instrues para criao de
efeitos) no hardware.
1.' (roblema
Com toda essa abrangncia previamente descrita, as grandes empresas de
desenvolvimento de jogos computacionais como Atari, Eletronic Arts e Square Enix,
desenvolveram seu prprio ambiente para desenvolvimento de jogos de maneira
proprietria e apenas de uso prprio, impedindo estudantes e pequenas empresas
independentes de desenvolver um jogo sem tem que desenvolver tambm uma AP,
o que invivel em termos de custo e tempo, apesar de atualmente haver verses
bem reduzidas e grtis de AP's comerciais, muitas vezes para fins no comerciais,
como as poderosas Unreal e Unity 3D, ainda h problemas de carssimas licenas
para o desenvolvimento de jogos comercialmente.
5
Entretanto, hoje h algumas opes para renderizadores, motores, ou
simplesmente engines, totalmente gratuitos e muitas vezes de cdigo aberto como o
OGRE 3D (Object-oriented Graphics Rendering Engine) ou Ogre, porm a aderncia
a essas AP's est ocorrendo de forma lenta, e s hoje esto ganhando espao no
mercado e na rea acadmica, mas ainda preciso mostrar o poder dessas, como e
por onde comear matematicamente e conceitualmente para um desenvolvimento
de qualidade de um jogo computacional.
1.3 (roblemati$a%&o
Tendo em vista tais problemas, tentar-se- responder s seguintes questes:
Que motores livres e/ou gratuitos existem para criao de jogos
computacionais 3D em diferentes plataformas?
Quais as ferramentas livres e/ou gratuitas existentes para auxiliar esses
motores grficos?
Por que escolher C++ e Ogre?
O que o Ogre fornece?
Quais so os conceitos bsicos necessrios para comear a desenvolver
um jogo computacional 3D?
1.) Objetivos
1.4.1 Objetivo Geral
O objetivo geral da pesquisa atravs do desenvolvimento de um jogo
computacional 3D, demonstrar conceitos tericos e prticos sobre desenvolvimento
de jogos, e demonstrar o motor grfico Ogre, assim como seu potencial em jogos
comerciais, sua flexibilidade, facilidade e sua grande gama de recursos.
1.4.2 Objetivos Especficos
Este trabalho tem como objetivo, alm do desenvolvimento de um jogo
computacional 3D, mostrar as opes que existem para desenvolvimento de jogos
com ferramentas livres e/ou gratuitas, como por exemplo: Ogre, JME (Java Monkey
Engine), Crystal Space, estabelecendo comparativos em termos de desempenho,
facilidade, e aderncia em mercado. Alguns jogos comerciais desenvolvidos com
essas tecnologias so:
6
TorchLight: jogo comercial desenvolvido pela Runic Games, que tem como
motor grfico Ogre (vide a Figura 6);
Grappling Hook: jogo comercial desenvolvido pela SpeedRunGames, que
tem como motor grfico o JME (vide a Figura 7);
Keepsake: jogo comercial desenvolvido pela Wicked Studios, que tem
como motor grfico o Crystal Space (vide a Figura 8).
Figura 6: TorchLight jogo comercial utilizando Ogre
Figura 7: Grappling Hook jogo comercial utilizando JME
7
Figura 8: Keepsake jogo comercial utilizando Crystal Space
Como todas essas engines tratam de motores grficos ainda preciso auxlio
de ferramentas que ajudem no processo de modelagem de personagens, terrenos e
efeitos em geral, com um ambiente grfico mais amigvel. Entre essas sero
apresentadas nesse trabalho o Blender 3D (vide a Figura 9) e Wings 3D (vide a
Figura 10).
Figura 9: Cena renderizada com o modelador Blender 3D
8
Figura 10: Cena renderizada com o modelador Wings 3D
O Ogre uma biblioteca estvel, confivel, multiplataforma, flexvel e com
um grande leque de recursos, para desenvolvimento de aplicaes 3D em tempo
real (JUNKER, 2006). Sua SDK (Software Development Kit) oferece recursos para o
desenvolvedor como: abstrao de qual AP grfica ser usada (Direct3D ou
OpenGL), sem necessitar escrever nenhuma linha adicional de cdigo; recursos de
udio com OpenAL (Open Audio Library), AP livre de reproduo de som 3D; uma
GU (Graphical User nterface), AP de iterao usurio e software, o CEGU (Crazy
Eddie's GU System), biblioteca livre para GU especializada em jogos; e OS
(Object-oriented nput System), AP livre de comunicao para controladores de
jogos, joysticks ou gamepads, alm de outros recursos adicionais, que podem ser
acoplados no motor Ogre para complet-lo, como a integrao com diversas engines
de fsica, engines de realidade aumentada e integrao com outras linguagens como
o LUA, entre outros. Estes recursos e AP's sero abordados para justificar a
escolha do Ogre.
Tambm sero abordados conceitos bsicos para o desenvolvimento de
jogos, tais como os eixos tridimensionais, pontos, vrtices e faces, orientao,
rotaes matriciais e quartenies, colises, gravidade e animao.
1.* Relev+ncia ou ,ustificativa
9
O projeto pretende demonstrar que possvel produzir jogos de nvel
comercial, com alta qualidade grfica e sonora em diferentes plataformas usando
apenas ferramentas gratuitas e/ou livres, como o Linux, Ogre 3D, Blender, entre
outros, incentivando desenvolvedores independentes e pequenas empresas, para
expandir o mercado brasileiro, e comear a ganhar espao no mercado mundial de
desenvolvimento de jogos. Tambm se pretende estimular nos estudantes o
interesse na rea de exatas, especialmente matemtica, e disseminar uma nova
gama de atividades na rea de pesquisa tecnolgica.
'. Revis&o -ibliogr.fica
'.1 /ame 0ngines
Em suma, uma game engine responsvel pela gesto de dados e contedo
artstico do jogo, e decidir o que desenhar na tela do computador e como desenh-
la. Estas decises so tomadas tanto em alto como em baixo nvel. As decises de
alto nvel so manipuladas pela nteligncia Artificial do jogo e por um sistema de
gesto de grafo de cenas. As decises de baixo nvel preocupam-se em que e como
desenhar (EBERLY, 2000).
'.1.1 Renderi$ador
Um dos principais componentes de uma game engine seu renderizador, que
basicamente tem trs grandes responsabilidades.
A primeira responsabilidade de um renderizador 3D transformar um mundo
virtual 3D em uma pequena rea de viso. Esse modelo chamado de camera
model, ou modelo de cmera.
A segunda responsabilidade de um renderizador 3D eliminar objetos 3D no
visveis. sso envolve conceitos como culling (processo que determina se um objeto
completamente fora de viso) e clipping (processo que divide um objeto em partes
menores, algumas delas visveis; a parte invisvel descartada pelo renderizador, e
as partes visveis so devidamente processadas) (EBERLY, 2000).
A terceira responsabilidade de um renderizador 3D transformar essa rea
3D visvel, em um desenho 2D para ser mostrado, por exemplo, em uma tela de
computador.
'.1.' "oordenadas 3D
10
O sistema de coordenadas cartesiano 2D de Ren Descartes (vide figura 11)
o primeiro passo para se entender um plano 3D. O eixo horizontal (X na figura)
representa largura, positivo para direita (leste), negativo para esquerda (oeste), e um
eixo vertical (Y na figura) representa altura, positivo para cima (norte) e negativo
para baixo (sul).
Figura 11: Modelo de Coordenada 2D.
O sistema de coordenadas 3D segue basicamente o mesmo conceito, s que
adicionado um novo eixo chamado de Z, esse eixo proporcional a X e Y (vide
figura 12), onde valores negativos indicam para frente, e valores positivos param
trs.
Figura 12: Modelo de Coordenada 3D.
11
'.1.3 "enas
Segundo o Aurlio online, cena pode ser: "Lugar onde se passa uma ao,
cenrio / Paisagem, horizonte de viso". No mundo das engines grficas cenas so
pores especficas do mundo, ou seja, so pedaos que compe o mundo.
Para melhor entendimento desse conceito, e principalmente a composio de
uma cena, considere-se esse exemplo:
Em um grande terreno, existem vrias casas (vide figura 13).

Figura 13: Exemplificando Cenas
magine que exista uma mesa que est dentro da casa 1 (marcada em
vermelho na figura). Quais premissas tero de ser atendidas para que se possa ver
essa mesa nessa casa?
Primeiramente para que isso possa acontecer precisa-se ter o recurso da
viso, seja por olho humano ou por um dispositivo que fornea imagens (uma
filmadora, por exemplo).
O segundo passo que o objeto esteja no campo de viso do olho ou do
dispositivo.
O terceiro e ltimo passo que exista uma iluminao, natural ou artificial,
para esse objeto.
Traduzindo isso, o terreno e as casas so cenas, ou seja, uma cena pode ter
zero a infinitas cenas dentro dela, as casas tambm so cenas, que alm de cenas,
12
podem ter objetos dentro dela como a mesa, o olho ou dispositivo de viso uma
cmera, e uma cena tambm pode conter vrios recursos de luz.
'.1.) "+meras
So as cmeras que definem o que vai ser desenhado pelo renderizador (vide
figura 14).
Figura 14: lustrao de uma cmera para o renderizador
Na foto a mquina fotogrfica a posio da cmera, essa primeira grandeza
chamada fovy o ngulo da viso em Y (valores convincentes para os humanos
variam de 45 at 60 graus), W a largura, e H altura. necessrio definir qual a
distncia mxima que a cmera desenha, essa a chamada far distance, e tambm
necessrio definir a distncia mnima que esse objeto tem que estar da cmera
para ele se tornar visvel, esse chamado near distance. Descartando essa rea
no visvel, ou no renderizada tem-se a rea de viso ou frustum (vide Figura 15).
Figura 15: Frustum
'.1.* Lu$es
13
Grande parte da riqueza do sistema visual humano devido iluminao. Um
sistema grfico deve suportar o conceito de luzes e objetos afetados por luzes. Os
modelos de iluminao apoiados por AP's grficas por padro so uma
aproximao simples de iluminao de verdade, mas so projetados para que os
clculos de iluminao possam ser feitos rapidamente (EBERLY, 2005).
As fontes de iluminao padres de uma engine so:
Luzes direcionais (Directional Lights): A fonte de luz considerada
como infinitamente longe, de modo que as direes dos raios de luz
so paralelas. O sol o exemplo clssico de uma luz direcional.
Ponto de luz (Point Lights): A fonte de luz localizada em qualquer
lugar do espao e emite luz em todas as direes.
Regio de luz (Spot lights). A fonte de luz localizada em qualquer
lugar do espao e emite luz na forma de um cone.
Elas podem ser mais bem entendidas na ilustrao da figura 16.
Figura 16: Modelos de Luzes
'.1.1 Objetos
Pode-se dividir um objeto 3D em duas grandes partes: sua estrutura fsica,
sua malha, mesh ou meshes poligonais, e sua pintura.
Meshes poligonais so a representao da geometria mais adequada para
aplicaes interativas em 3D. Eles so flexveis o suficiente para aproximar as
formas arbitrrias de qualquer tolerncia e aproximao. Eles podem ser tratados
eficientemente com o hardware atual, que est disponvel at mesmo em
computadores de baixo custo hoje (BOTSCH, 2002).
Esse modelo de mesh foi arquitetado tendo em vista trs princpios:
flexibilidade, eficincia de tempo e espao e fcil implementao.
14
Uma malha poligonal composta de um conjunto de vrtices, arestas, faces e
relaes topolgicas entre eles. Com base nestas relaes, uma estrutura de dados
define a forma como cada elemento armazenado e que referncias seu vizinho
necessita (BOTSCH, 2002).
Para melhor mostrar essa composio de vrtices, arestas, faces, um
exemplo prtico, foi utilizada a engine Ogre e alguns de seus recursos para mostrar
essa relao. Primeiro um objeto completo (vide figura 17), com vrtices, arestas,
faces e pintura.
Figura 17: Objeto 3D completo
Desabilitando as faces e arestas, visualizam-se apenas os vrtices (vide figura
18).
15
Figura 18: Vrtices de um Objeto
Vrtices armazenam posies de trs eixos como, por exemplo, (0, 0, 0) e
tambm armazenam outras informaes como cor, vetor de normais, e coordenadas
de texturas.
Desabilitando apenas as faces, mostram-se apenas vrtices e arestas (vide
figura 19).
16
Figura 19: Vrtices e arestas de um Objeto
Arestas ou edges so ligaes entre dois vrtices.
E por ltimo tm-se as faces que so um conjunto fechado de pelo menos
trs arestas, e contm outras informaes como as normais.
Por questes de otimizao e para simplificar clculos, em nvel de hardware
(placa de vdeo) as faces so um conjunto de trs vrtices e trs arestas, ou seja,
um tringulo, por isso, que comum medir o peso de uma cena por nmero de
tringulos.
Considere-se agora um poliedro com os seguintes vrtices:
Vrtice #0: ( 1, 0, 1)
Vrtice #1: ( 1, 0,-1)
Vrtice #2: (-1, 0,-1)
Vrtice #3: (-1, 0, 1)
Vrtice #4: ( 0, 1, 0)
Com auxlio do Blender so desenhados esses cinco vrtices (vide figura 20).
17
Figura 20: Vrtices de um poliedro
Na figura 20 os vrtices so os pontos amarelos, o ponto em rosa representa a
origem, ou seja, o ponto (0, 0, 0), as trs setas representam os eixos tridimensionais,
verde para Y (altura), vermelho para X (largura), azul para Z (profundidade).
Ligando os vrtices (v) do seguinte modo:
Aresta #0: (v0, v1);
Aresta #1: (v1, v2);
Aresta #2: (v2, v3);
Aresta #3: (v3, v0);
Aresta #4: (v0, v4);
Aresta #5: (v1, v4);
Aresta #6: (v2, v4);
Aresta #7: (v3, v4);
Aresta #8: (v0, v2);
Com auxlio do Blender desenhado essas nove arestas e obtm-se a
imagem mostrada na figura 21.
18
Figura 21: Arestas de um poliedro
E por ltimo tornando-se trs arestas (a) e transformando-as em faces:
Face #0: (a0, a4, a5);
Face #1: (a1, a5, a6);
Face #2: (a2, a6, a7);
Face #3: (a3, a7, a4);
Face #4: (a8, a2, a3);
Face #5: (a8, a0, a1);
No Blender so unidas essas arestas para criar faces, como mostra a figura 22.
Figura 22: Faces de um poliedro
19
Na figura 22 as faces so os pontos laranja que esto entres trs arestas as
linhas amarelas.
Considere esse exemplo anterior em uma linguagem de programao como o
Java:
float[][] vertexList = { {1,0,1}, {1,0,-1}, {-1,0,-1}, {-1,0,1}, {0,1,0} };
float[][] edgeList = { {0,1}, {1,2}, {2,3}, {3,0}, {0,4}, {1,4}, {2,4},
{3,4}, {0,2} };
float[][] faceList = { {0,4,5}, {1,5,6}, {2,6,}, {3,,4}, {!,2,3}, {!,0,1}
};
Esse modelo de criao de meshes chamado winged-edge meshes, existem
outros modelos como o vertex-vertex meshes, que consiste em usar apenas vrtices
e vetores de ligaes de vrtices para criar meshes, e o face-vertex meshes, que
utiliza vrtices e faces para criao de meshes.
As normais anteriormente citadas geralmente so encontradas em dois nveis,
normais de face e normais de vrtices (indicados em azul na figura 23).
Primariamente, as normais servem para definir qual o lado de fora de um objeto,
importante para questes de iluminao e alguns tipos de otimizaes alm de ser a
base para entender tcnicas de shader.
Figura 23: Normais
S existe iluminao em uma face se sua reta normal iluminada pela fonte de
luz. sso reduz o nmero de faces afetadas pela iluminao pela metade.
20
Os efeitos de cores nos objetos normalmente so feitos normalmente na escala
RGB (Red Green Blue), na engine Ogre normalmente usado a escala RGBA (Red
Green Blue e Alpha), ou seja, vermelho, verde, azul e nvel de transparncia, onde
esses valores so representados em ponto flutuante e variam entre zero e um.
Considere um exemplo de cdigo fonte:
Ogre::ColourValue(0.5, 0.5, 0.5, 1);
As cores so adicionadas para cada vrtice, cada vrtice tendo sua cor. As
cores das arestas so calculadas pela interpolao das cores, fazendo um efeito
bem parecido com o efeito gradiente, a mesma coisa acontece para as faces. Segue
um exemplo.
Figura 24: Cor aplicada em vrtices
Na figura 24 v-se um exemplo bem simples, um tringulo com trs vrtices,
trs arestas e uma face. Analisando o tringulo, nota-se que ao norte aplicada a
cor magenta, ao sul a cor verde, e a leste o ciano. Feito isso j se pode verificar no
centro de suas arestas e de sua face, a interpolao de cores.
Outra importante tcnica de pintura de meshes chamada texturizao, que
basicamente consiste em aplicar uma imagem de duas dimenses em um objeto de
trs dimenses.
magens de textura, ou simplesmente texturas, fornecem mais realismo a um
modelo e pode ser usado com eficincia para esconder o aspecto poligonal de um
modelo (EBERLY, 2000).
As coordenadas de textura so atribudas a vrtices de objetos e no a textura,
isso permite o compartilhamento de vrios objetos a mesma textura (EBERLY,
2005).
21
O processo de texturizao acontece da seguinte maneira: um tringulo
atribudo a uma imagem de textura. Cada vrtice de um tringulo atribudo a uma
coordenada da textura, s assim possvel fazer uma pesquisa de cores dentro de
uma imagem. A coordenadas da textura dos vrtices so interpolados por um
processo chamado rasterizao, que transformar uma imagem em formato de
grficos vetoriais, para obter coordenadas de textura para os outros pixels no
tringulo. Cada coordenada interpolada tambm usado para fazer uma pesquisa
de cores na imagem (EBERLY, 2000).
Figura 25: Texturizao de uma pirmide
Na figura 25 v-se um exemplo de texturizao simples, onde se tem uma
imagem e um objeto simples, o que acontece nessa figura que a imagem envolve
o objeto preenchendo todo ele. Comparando com o mundo real pode-se fazer uma
associao que exemplifica muito bem essa situao. magine que voc tem uma
toalha que no caso equivale uma textura, agora imagine que se tem um objeto
esfrico como uma bola de futebol que representa o objeto, ao envolver a bola de
futebol com a toalha e tirando o excesso de toalha, tem-se uma boa representao
do que um processo simples de texturizao.
Esse um dos modos mais simples de texturizao que geralmente usado
para objetos simples, para objetos complexos so usados outros modos de
texturizao, onde o mapeamento de face ou vrtice do objeto e imagem feito
manualmente, o modo mais comum desse tipo de texturizao o UV Mapping.
22
Figura 26: Exemplo simples de UV Mapping
Na figura 26 tem-se um exemplo simples de UV Mapping, onde essa imagem
xadrez lembrando o formato de uma cruz tem exatamente todas as faces do objeto.
Com auxlio do Blender desenhado um objeto um pouco mais complexo como
uma espada (figura 27).
Figura 27: Uma espada sem textura
Ainda no Blender a espada transformada em uma imagem com todas as
faces mapeadas, e exportada como uma imagem 2D, como pode ser visto na
figura 28.
23
Figura 28: Faces mapeadas em uma imagem
Observe que e arestas so esses traos em preto. Aps isso em editor de
imagem qualquer como o GMP, essa imagem pintada (vide figura 29).
Figura 29: faces mapeadas pintadas
Voltando ao Blender a imagem pintada carregada, e finalmente aplicada a
textura no objeto (vide figura 30).
24
Figura 30: Objeto texturizado com UV Mapping
'.' "onceitos essenciais
Algumas funes e algumas premissas matemticas precisam ser
apresentadas para melhor entender, e, melhor usar uma engine.
Uma das funes geomtricas mais usadas em engines so as
transformaes, elas definem, por exemplo, para que lado o objeto esta virado e o
tamanho final do objeto.
'.'.1 0scala
Define o tamanho de um objeto em cena, um processo que simplesmente
transforma o objeto multiplicando a posio dos vrtices pela escala desejada,
reajustando as arestas e faces. Exemplo no Ogre: scale (1, 1, 1);
'.'.' Rota%&o
Define para onde objeto estar voltado, girado. Existem dois modos principais
para rotao, matriciais ou atravs de quartenies.
As rotaes em 3D so rotaes sobre um eixo (X, Y ou Z) (vide figura 31).
25
Figura 31: Eixos e rotaes
Observe como uma espada se comporta ao rotacionar no eixo X (seta
vermelha) na figura 32.
Figura 32: Objeto rotacionado em X
Observe agora como uma espada se comporta ao rotacionar no eixo Y (seta
verde) na figura 33.
Figura 33: Objeto rotacionado em Y
Por ltimo como uma espada se comporta ao rotacionar no eixo Z (seta azul)
na figura 34
26
Figura 34: Objeto rotacionado em Z
A rotao matricial de um ponto no espao tridimensional pode ser obtida pela
multiplicao dos fatores de rotao ao ponto. A aplicao da matriz de rotao
dependente do eixo sobre o qual se efetua a rotao. A matriz de rotao para cada
eixo pode ser observado na figura 35.
Figura 35: Matrizes de rotaes
A letra grega theta representa a quantidade de graus a qual se quer
rotacionar o objeto. Existem alguns problemas envolvendo rotao matricial, o mais
comum eles que acontecem muitas confuses quando, por exemplo, deseja-se
fazer rotaes de trs eixos simultaneamente. Com ajuda do Blender, veja esse
exemplo (figura 36).
27
Figura 36: Objeto sem rotao
magine agora que se deseja rotacionar simultaneamente o objeto em 90
graus nos trs eixos. Dependendo da ordem dos eixos que sero rotacionados o
resultado diferente. Na figura 37 v-se o objeto rotacionado em X, Y e Z, na figura
38 v-se o mesmo objeto rotacionado Z, Y e X.
Figura 37: Objeto rotacionado em X, Y, Z
28
Figura 38: Objeto rotacionado em Z, Y, X
O resultado totalmente diferente, por isso a confuso gerada. O modo
correto de se rotacionar o objeto o chamado yaw pitch row, um dos conceitos
herdados da aeronutica para computao grfica, que significa Y, X e Z.
Quartenio um nmero complexo que consiste em um vetor de quatro
dimenses, muito mais usado, pois ele consome muito menos memria e
processamento, apesar de mais complexo para aprendizagem. As trs primeiras
posies do vetor consistem nas coordenadas 3D (X, Y, Z) a ltima posio do vetor
representa a quantidade de graus a qual deseja rotacionar.
O processo de rotao acontece da seguinte forma: criada uma linha
imaginria do ponto de origem (0, 0, 0) at X, Y, Z do quartenio, isso cria um novo
eixo, e essa rotao acontece sobre esse eixo (vide figura 39).
29
Figura 39: Exemplo de um quartenio
'.3 /ame engines e engines gr.ficas gratuitas
Aps conhecer a composio e as funes bsicas de uma engine so
enumeradas, e descritas basicamente algumas dessas engines disponveis
gratuitamente, para posterior escolha no projeto.
So descritas tambm as possveis engines fsicas que podem ser utilizadas,
engine fsica, uma srie de algoritmos que tm como finalidade a deteco de
colises, e aproximao dos efeitos de certos sistemas fsicos com a realidade, ela
prove recursos para voc associar grandezas reais para objetos 3D como massa,
densidade, fora, gravidade entre outros.
Entre as diversas engine gratuitas cinco delas escolhidas, so:
Ogre 3D ou Simplesmente Ogre;
RRLCHT;
Java Monkey Enigne ou simplesmete JME;
Unity;
Microsoft XNA ou simplesmente XNA.
'.) Engines f2sicas
30
Os motores fsicos dentro dos jogos tm a funo de aproximar uma aplicao
ao mundo real atravs dos conceitos fsicos, ou seja, ela fornece recursos como
deteco de colises assim como simulao da fsica, ou seja, com ela permite-se a
associao de massas nos objetos tridimensionais, velocidade, gravidade, entre
outras grandezas.
Alm da aplicao em jogos, hoje os motores fsicos so muito empregados em
filmes, e outros tipos de aplicativos como modeladores 3D.
Segundo a revista norte-americana Game Developers Magazine publicada em
setembro de 2009, o motor fsico mais utilizado o Physx (hoje mantido pela
Nvidia), seguido por Havok, e em terceiro lugar o motor Bullet (conforme figura 40).
Figura 40: Os quatro motores fsicos mais populares
Hoje muito comum encontrar bibliotecas fsicas separadas de bibliotecas
grficas, para assim poder se ter mais opes de motores fsicos em seu motor
grfico, isso possvel, pois as engines fsicas oferecem uma interface fcil para
voc descrever vrtices, arestas e faces de seus objetos 3D, ficando assim s a
cargo do desenvolvedor preparar os dados para essa interface e pegando a sada
do motor para atualizar as transformaes de seu objeto.
O Nvidia PhysX motor fsico 100% grtis para jogos comerciais e no
comerciais disponibilizados para todos desenvolvedores registrados da Nvidia
(Nvidia, 2010).
Escrita em C++ foi inicialmente desenvolvido pela empresa AGEA, e, apesar
de gratuita proprietria, ou seja, seu cdigo fonte no aberto. Disponvel para
maioria das arquiteturas como: Windows, Linux, Mac, Wii, PlayStation 3 e Xbox360
tem aproximadamente 150 jogos utilizando-a (Nvidia, 2010).
31
Ficou famosa por ser gratuita e de fcil manipulao alm de que os drivers
para placas grficas Nvidia j incluem o motor fsico, alm de ter uma srie de
otimizaes para placas da Nvidia.
O motor fsico Havok o lder na deteco de coliso em tempo real e solues
de simulao fsica. Havok oferece a tecnologia mais rpida de simulao fsica,
razo pela qual se tornou muito utilizada da indstria de jogos. Havok Fsica foi
escolhida pelos desenvolvedores de jogos em mais de 200 ttulos lanados e muitos
mais em desenvolvimento (HAVOK, 2010).
Havok hoje mantido pela ntel e tambm um motor fsico proprietrio, ele
no gratuito. Desenhado inicialmente para consoles, hoje funciona em maioria das
plataformas como: Unix, Linux, PlayStation 3, PlayStation 2, PlayStation portable,
GameCube, Wii, Mac, Xbox 360, Xbox e Windows.
Bullet um motor fsico de deteco de coliso profissional de cdigo aberto,
para corpos rgidos e maleveis dinamicamente. A biblioteca gratuita para uso
comercial sob a licena Zlib (Bullet, 2010).
O motor fsico o primeiro entre as engines de cdigo aberto. Tambm
disponvel para grande nmero de arquiteturas como: PlayStation 3, Xbox 360, Wii,
Windows, Mac, Linux e phone. Foi desenvolvido por um empregado da Sony
Computer Entertaiment. Por ser de cdigo aberto, estar disponvel em um grande
nmero diferente de arquitetura, e ter sido desenvolvido por um membro de uma
grande corporao na rea de jogos digitais, um grande nmero de usurios aderiu
ao motor fsico.
'.* Ogre 3D
Ogre 3D uma engine grfica de cdigo aberto disponibilizado sobre a licena
LGPL.
'.*.1 Linguagem
C++, mas existem opo de utiliz-la na plataforma .NET, em Java e Python.
'.*.' (lataforma
Windows;
32
Linux;
Mac;
phone;
'.*.3 Renderi$ador
OpenGL;
DirectX 9;
'.*.) Documenta%&o
tima documentao (http://www.ogre3d.org/documentation), AP de
referncia (http://www.ogre3d.org/docs/api/html/), timo manual
(http://www.ogre3d.org/docs/manual/), um completo wii
(http://www.ogre3d.org/wiki), com tutoriais de instalao, de aprendizagem, de
recursos disponveis, e exemplos, dois timos frum
(http://www.ogre3d.org/forums/), um para a engine, e outro somente para os plugins,
com vrios administradores que so os prprios desenvolvedores da engine, alm
de existir um livro sobre a engine.
'.*.* 0ngines 32sica
Newton Game Dynamics;
Nvidia PhysX;
Open Dynamics Engine, ou simplesmente ODE;
Bullet;
33
'.1 IrrLic4t
RRLCHT uma game engine de cdigo aberto disponibilizado sobre licena
zlib/libpng.
'.1.1 Linguagem
C++, mas existe a opo de utiliz-la na plataforma .NET, Java, Perl, Ruby,
Phyton, FreeBasic, LUA e Delphi.
'.1.' (lataforma
Windows;
Linux;
Mac.
'.1.3 Renderi$ador
OpenGL;
DirectX 8 e 9;
'.1.) Documenta%&o
Boa documentao, AP de referncia
(http://irrlicht.sourceforge.net/docu/index.html), um bom wiki
(http://www.irrlicht3d.org/wiki), com tutoriais de instalao, de aprendizagem, e
exemplos, um bom frum com vrios administradores que so os prprios
desenvolvedores da engine (http://irrlicht.sourceforge.net/phpBB2/index.php).
'.1.* 0ngines 32sica
Physics Abstraction Layer;
Newton Game Dynamics;
Open Dynamics Engine, ou simplesmente ODE;
Tokamak;
Nvidia PhysX;
Bullet.
34
'.5 ,ava 6on7e8 0ngine
Java Monkey Engine, ou simplesmente JME, uma game engine de cdigo
aberto disponibilizado sobre a licena LGPL, tem como linguagem de programao
Java.
'.5.1 Linguagem
Java
'.5.' (lataforma
Windows;
Linux;
Mac;
Solaris.
'.5.3 Renderi$ador
OpenGL.
'.5.) Documenta%&o
Fraca documentao, um bom wiki (http://jmonkeyengine.org/wiki/doku.php),
com tutoriais de instalao, de aprendizagem, e exemplos, frum regular
(http://jmonkeyengine.org/forums/).
'.5.* 0ngine 32sica
Bullet;
'.9 Unit8
35
Unity uma game engine proprietria com verso gratuita limitada.
'.9.1 Linguagem
C#;
JavaScript;
Boo, uma variante de Python.
'.9.' (lataforma
A verso gratuita do Unity est disponvel nas seguintes plataformas:
Windows;
Mac;
Web player.
'.9.3 Renderi$ador
OpenGL;
DirectX.
'.9.) Documenta%&o
tima documentao (http://unity3d.com/support/documentation/), AP de
referncia (http://unity3d.com/support/documentation/ScriptReference/index.html),
timo manual (http://unity3d.com/support/documentation/Manual/index.html), grande
nmero de tutoriais inclusive vdeos (http://unity3d.com/support/resources/tutorials/),
grande nmero de exemplos, timo frum (http://forum.unity3d.com/), e um bom wiki
(http://www.unifycommunity.com/wiki/index.php?title=Main_Page).
'.9.* 0ngine 32sica
Nvidia PhysX;
'.: 6icrosoft ;NA
Microsoft XNA, ou simplesmente XNA, uma game engine proprietria gratuita
sobre licena EULA.
36
'.:.1 Linguagem
C#;
'.:.' (lataforma
Windows;
XBOX 360;
Zune.
'.:.3 Renderi$ador
DirectX.
'.:.) Documenta%&o
tima documentao (http://creators.xna.com/en-US/education/), AP de
referncia, timo manual, grande nmero de tutoriais, grande nmero de exemplos
(http://creators.xna.com/en-US/education/catalog/), timo frum
(http://forums.xna.com/forums/).
'.:.* 0ngine 32sica
Nvidia PhysX;
Open Dynamics Engine, ou simplesmente ODE;
Bullet;
37
'.1< Testes de engines
Aps a apresentao de cada engine, alguns de seus recursos e plataformas,
foram realizados alguns testes, para melhorar compar-las.
'.1<.1 Ambiente
Para realizar os testes foi montado o seguinte ambiente para cada engine:
OGRE: Windows 7, Microsoft Visual C++ 2008 Express; Ubuntu 10.04,
Code::Blocks e GCC;
RRLCHT: Windows 7, Microsoft Visual C++ 2008 Express; Ubuntu
10.04, Code::Blocks e GCC;
JME: Windows 7, Eclipse; Ubuntu 10.04, Eclipse.
Unity: Windows 7, Unity Studio 2.6
XNA: Windows 7, Microsoft Visual C# 2008 Express, XNA 3.1.
'.1<.' Observa%=es
Para analisar desempenho de cada engine foi adotada a medida de FPS
(Frames per Second) que nmero de quadro ou imagens por segundo. Foi
escolhida essa mtrica, pois ela a principal mtrica usada para definir, por
exemplo, requisitos mnimos para execuo de um game. Essa medio consiste
em contar quantas imagens a placa de vdeo gera em um segundo, quanto mais
imagens melhor o desempenho. Todos os testes a seguir foram realizados em
resoluo 1024x768 pixels.
Porm ao medir essa taxa de FPS algumas observaes tm que ser citadas,
pois elas afetam negativamente o desempenho de cada engine:
Ogre: Nos exemplos usados, a engine adiciona uma mdia de 200 tringulos
na cena para colocar seu logo, e as observaes (como nmero de
tringulos, e desempenho), alm disso, existe um ponto de iluminao, e
tambm por padro j existem funes de movimentao com os botes
WASD do teclado, setas do teclado, e funo de viso que executada pelo
mouse.
38
RRLCHT: Nos Exemplos usados, o RRLCHT adiciona funes de
movimentao com as setas do mouse, e funo de viso que executada
pelo mouse, alm disso, h um ponto de luz na cena.
JME: Nos exemplos usados, o JME adiciona uma mdia de 50 tringulos na
cena para colocar um grfico com a medio do FPS, alm disso, existe um
ponto de iluminao, e tambm por padro j existem funes movimentao
com os botes WASD do teclado, setas do teclado, e funo de viso que
executada pelo mouse.
Unity: Existe apenas um ponto de luz na cena.
XNA: Existem apenas as funes de movimentao atravs dos botes
WASD, e setas do mouse.
Tendo em vista isso, pode-se concluir que o XNA e o Unity so mais leves, e o
Ogre mais pesado por ter mais funes e por ter mais tringulos na cena.
'.1<.3 Testes
Para realizao dos testes foram escolhidos objetos aleatrios, disponibilizados
gratuitamente em sites que oferecem modelos gratuitos ou foram desenhados pelo
autor.
Todos os arquivos dos testes foram importados para o Blender, e exportados
para os formatos de cada engine que so:
Ogre: Ogre Meshes (.mesh) (plugin para blender);
RRLCHT: RR Scene (.irr) (plugin para blender);
JME: Ogre Meshes (.mesh) (plugin para blender);
Unity: Arquivo padro do blender (.blend);
XNA: DirectX (.x).
Os dez testes a seguir esto ordenados pelo nmero de tringulos em cena
ascendente, seguido por uma foto de um dos testes realizado.
39
Primeiro Teste (vide figura 40): Espada 523 tringulos.
Tabela 1: Primeiro teste ente engines
Sistema
Operacional
Renderizado
r Engine Mdia FPS
-indo.s / *pen 01 *gre 1234
-indo.s / 5irect 6 *gre 2073
-indo.s / 5irect 6 68' 2273
-indo.s / 5irect 6
I991IC:
T 2200
-indo.s / *pen 01
I991IC:
T 141;
-indo.s / 5irect 6 Unit< 25 ;;1
-indo.s / *pen 01 )ME 1200
U#untu 10&0= *pen 01 *gre 1422
U#untu 10&0= *pen 01
I991IC:
T 2202
U#untu 10&0= *pen 01 )ME 1=00
Figura 41: teste 1 no Windows, OpenGL e Ogre
40
Segundo Teste (vide figura 41): Escudo 745 tringulos.
Tabela 2: Segundo teste ente engines
Sistema
Operacional
Renderizado
r Engine Mdia FPS
-indo.s / *pen 01 *gre 132;
-indo.s / 5irect 6 *gre 1;;;
-indo.s / 5irect 6 68' 1/;;
-indo.s / 5irect 6
I991IC:
T 1;;/
-indo.s / *pen 01
I991IC:
T 17;0
-indo.s / 5irect 6 Unit< 25 720
-indo.s / *pen 01 )ME 1100
U#untu 10&0= *pen 01 *gre 1/7/
U#untu 10&0= *pen 01
I991IC:
T 14==
U#untu 10&0= *pen 01 )ME 1200
Figura 42: teste 2 no Windows, DirectX e Ogre
41
Terceiro Teste (vide figura 42): Tails (personagem do jogo Sonic) 5479
tringulos.
Tabela 3: Terceiro teste ente engines
Sistema
Operacional
Renderizado
r Engine Mdia FPS
-indo.s / *pen 01 *gre 1234
-indo.s / 5irect 6 *gre 1741
-indo.s / 5irect 6 68' 17;=
-indo.s / 5irect 6
I991IC:
T 1=12
-indo.s / *pen 01
I991IC:
T 1=13
-indo.s / 5irect 6 Unit< 25 7;;
-indo.s / *pen 01 )ME 420
U#untu 10&0= *pen 01 *gre 172/
U#untu 10&0= *pen 01
I991IC:
T 110;
U#untu 10&0= *pen 01 )ME 1100
Figura 43: teste 3 no Windows, DirectX e rrlicht
42
Quarto Teste (vide figura 43): Tanque 5566 tringulos.
Tabela 4: Quarto teste ente engines
Sistema
Operacional
Renderizado
r Engine Mdia FPS
-indo.s / *pen 01 *gre 1=;/
-indo.s / 5irect 6 *gre 1;/0
-indo.s / 5irect 6 68' 1==1
-indo.s / 5irect 6
I991IC:
T 122/
-indo.s / *pen 01
I991IC:
T 1274
-indo.s / 5irect 6 Unit< 25 ;10
-indo.s / *pen 01 )ME 434
U#untu 10&0= *pen 01 *gre 17//
U#untu 10&0= *pen 01
I991IC:
T 102=
U#untu 10&0= *pen 01 )ME 1100
Figura 44: teste 4 no Windows, OpenGL e rrlicht
43
Quinto Teste (vide figura 44): Link (Personagem do jogo Zelda) 7138
tringulos.
Tabela 5: Quinto teste ente engines
Sistema
Operacional
Renderizado
r Engine Mdia FPS
-indo.s / *pen 01 *gre ;3/
-indo.s / 5irect 6 *gre 1=33
-indo.s / 5irect 6 68' 1220
-indo.s / 5irect 6
I991IC:
T 114;
-indo.s / *pen 01
I991IC:
T /77
-indo.s / 5irect 6 Unit< 25 //4
-indo.s / *pen 01 )ME ;00
U#untu 10&0= *pen 01 *gre 114;
U#untu 10&0= *pen 01
I991IC:
T 774
U#untu 10&0= *pen 01 )ME 1100
Figura 45: teste 5 no Windows, DirectX e Unity
44
Sexto Teste (vide figura 45): Uma aeronave 9056 tringulos.
Tabela 6: Sexto teste ente engines
Sistema
Operacional
Renderizado
r Engine Mdia FPS
-indo.s / *pen 01 *gre 11;0
-indo.s / 5irect 6 *gre 13==
-indo.s / 5irect 6 68' 1=2/
-indo.s / 5irect 6
I991IC:
T 17/0
-indo.s / *pen 01
I991IC:
T 1372
-indo.s / 5irect 6 Unit< 25 /;0
-indo.s / *pen 01 )ME ;;2
U#untu 10&0= *pen 01 *gre 1=20
U#untu 10&0= *pen 01
I991IC:
T 122;
U#untu 10&0= *pen 01 )ME 1000
Figura 46: teste 6 no Windows, DirectX e XNA
45
Stimo Teste (vide figura 46): Um carro 34906 tringulos.
Tabela 7: Stimo teste ente engines
Sistema
Operacional
Renderizado
r Engine Mdia FPS
-indo.s / *pen 01 *gre 101=
-indo.s / 5irect 6 *gre 1122
-indo.s / 5irect 6 68' 1143
-indo.s / 5irect 6
I991IC:
T 770
-indo.s / *pen 01
I991IC:
T /0=
-indo.s / 5irect 6 Unit< 25 ==/
-indo.s / *pen 01 )ME =27
U#untu 10&0= *pen 01 *gre 10;7
U#untu 10&0= *pen 01
I991IC:
T 701
U#untu 10&0= *pen 01 )ME 300
Figura 47: teste 7 no Windows, OpenGL e JME
46
Oitavo Teste (vide figura 47): Um drago 54885 tringulos.
Tabela 8: Oitavo teste ente engines
Sistema
Operacional
Renderizado
r Engine Mdia FPS
-indo.s / *pen 01 *gre ;;7
-indo.s / 5irect 6 *gre 430
-indo.s / 5irect 6 68' ;/2
-indo.s / 5irect 6
I991IC:
T 234
-indo.s / *pen 01
I991IC:
T 232
-indo.s / 5irect 6 Unit< 25 3/3
-indo.s / *pen 01 )ME 222
U#untu 10&0= *pen 01 *gre 477
U#untu 10&0= *pen 01
I991IC:
T 27;
U#untu 10&0= *pen 01 )ME 2;4
Figura 48: teste 8 no Linux, OpenGL e Ogre
47
Nono Teste (vide figura 48): Um palcio 148436 tringulos.
Tabela 9: Nono teste ente engines
Sistema
Operacional
Renderizado
r Engine Mdia FPS
-indo.s / *pen 01 *gre 333
-indo.s / 5irect 6 *gre 3;0
-indo.s / 5irect 6 68' 2/7
-indo.s / 5irect 6
I991IC:
T 2=;
-indo.s / *pen 01
I991IC:
T 221
-indo.s / 5irect 6 Unit< 25 1//
-indo.s / *pen 01 )ME /2
U#untu 10&0= *pen 01 *gre 343
U#untu 10&0= *pen 01
I991IC:
T 1;3
U#untu 10&0= *pen 01 )ME /3
Figura 49: teste 9 no Linux, OpenGL e rrlicht
48
Dcimo Teste (vide figura 49): Um jogo de xadrez 148618 tringulos.
Tabela 10: Dcimo teste ente engines
Sistema
Operacional
Renderizado
r Engine Mdia FPS
-indo.s / *pen 01 *gre 3=2
-indo.s / 5irect 6 *gre 3//
-indo.s / 5irect 6 68' 2//
-indo.s / 5irect 6
I991IC:
T 210
-indo.s / *pen 01
I991IC:
T 22=
-indo.s / 5irect 6 Unit< 25 24;
-indo.s / *pen 01 )ME 77
U#untu 10&0= *pen 01 *gre 3;3
U#untu 10&0= *pen 01
I991IC:
T 10;
U#untu 10&0= *pen 01 )ME /2
Figura 50: teste 10 no Linux, OpenGL e Jme
49
'.1<.) "onclus&o
Tirando uma mdia desses dados (vide figura 50), os melhores desempenhos
foram encontrados em Windows / DirectX / Ogre (vide figura 51), Ubuntu / OpenGL /
Ogre (vide figura 52), Windows / DirectX / XNA (vide figura 53).
Figura 51: Grfico de Comparao entre engines
Figura 52: Grfico dos resultados de Windows, DirectX e Ogre
50
Figura 53: Grfico dos resultados de Ubuntu, OpenGL e Ogre
Figura 54: Grfico dos resultados de Windows, Directx e XNA
A engine Microsoft XNA aparece com um bom resultado entre as engines,
porm, precisa ser observado, que quase todos os objetos sofreram problemas ao
ser importados, um problema frequente que se encontrou foi com as normais.
O pior desempenho foi da engine Unity, porm se for observado os ltimos
testes ela obteve um bom desempenho, e, alm disso, essa engine mostrou a menor
queda de FPS ao maior nmero de tringulos (vide figura 54), outra grande
vantagem da engine, que ela disponibiliza uma ferramenta grfica para
desenvolvimento, e, alm disso, ela importa objetos da maioria dos modeladores 3D,
e, no foi encontrados problemas em nenhuma das importaes.
51
Figura 55: Grfico de Comparao da engine Unity
52
3. (rojeto
Aps todo esse levantamento tcnico sobre engines o projeto visa mostrar
essas ferramentas aplicadas na prtica, ou seja, a implementao de um jogo 3D. A
engine escolhida por razes de desempenho e por ser de cdigo aberto foi a engine
Ogre. Como motor de fsica foi escolhido a engine Bullet, pela facilidade de
desenvolvimento e grande nmero de recursos oferecidos, e como interface grfica
foi escolhida o CEGU por causa da sua fcil integrao com Ogre. Para tratamento
de udio foi escolhido !pen"L ( Open Audio Library ) por ser de cdigo aberto,
multi-plataforma e de fcil utilizao.
3.1 Ogre
Como j dito anteriormente Ogre um ferramenta de cdigo aberto, um
motor 3D orientado a cenas, flexvel escrito em C++ desenhado para tornar mais
fcil e intuitiva para os desenvolvedores a produzir aplicaes utilizando a
acelerao por hardware de grficos 3D. A biblioteca abstrai todos os detalhes de
utilizar as bibliotecas do sistema subjacente como Direct3D e OpenGL e fornece
uma interface baseada em objetos do mundo e de outras classes e intuitiva (OGRE,
2010).
A verso 1.0 da engine foi lanada em fevereiro de 2005 a verso utilizada
ser 1.7.1 lanada no fim do ms de abril de 2010.
3.' -ullet
Bullet uma biblioteca deteco de coliso e simulao dinmica de corpos
rgidos. A Biblioteca de cdigo aberto e gratuito para uso comercial, sob a licena
Zlib. sto significa que voc pode us-lo em jogos comerciais, mesmo na prxima
gerao de consoles como o Sony Playstation 3 (Bullet, 2010).
A verso utilizada no projeto ser a ultima verso 2.77 lanada em setembro
de 2010.
3.3 "0/UI
A interface grfica CEGU foi projetada desde o incio para ser usada em
engine de jogos. Possui ferramenta grfica multi plataforma. Possui como padro de
layout um xml muito fcil de usar, de alta performance, e escrita em C++ (CEGU,
2010) .
53
Sua primeira verso foi lanada no incio do ano de 2006, e a verso utilizada
no projeto 0.7.1 foi lanada em janeiro de 2010.
3.) O>enAL
Para a manipulao de diversos tipos de som, desde msicas a efeitos
sonoros foi escolhida o motor OpenAL utilizando-se do formato de compresso de
dados Theora (.ogg).
O motor OpenAL permite voc utilizar projeo tridimensionais de msicas e
efeitos, ou seja, com essa biblioteca permitido realizar projees de distncia de
emisso de som, ou seja, possvel distinguir se o som foi emitido de perto ou
longe, da esquerda, do meio ou da direita, aumentando assim a percepo e o
realismo do jogo.
3.* ,ogo
O jogo apresentado uma primeira verso com apenas uma batalha que
demonstrar todos os conceitos abordados. O nome do jogo Tumbu (vide figura
56).
Figura 56: Nome e logo do jogo
3.*.1 /?nero
O jogo em desenvolvimento ambientado no futuro, seguindo o estilo do
clssico RPG (Role-Playing Game), traduzindo, jogo de interpretao de
personagens.
O gnero do jogo foi bastante inspirado por importantes jogos como: #he
Legend !f $elda !carina !f #ime (Nitendo, 1998), as sries da Square Final
Fantasy, Shadow %earts, Draengard e !gre &attle, #he 'itcher (CD Projekt e Red
Studio, 2007).
54
3.*.' "onte#to
Os personagens disponveis no jogo so basicamente robs, assim como
nosso heri (vide figura 56), mais detalhes sobre o contexto do jogo, enredo
encontra-se completo no apndice A dessa monografia.
Figura 57: Rob inicialmente
3.*.3 Objetivo
O jogo tem como objetivo entreter o jogador atravs de lutas entre esses
robs, sendo que em cada luta, se ganhar pontos, que no acmulo desses, sero
transformados em habilidades para o rob, alm disso, ser adotado um sistema de
customizao do rob onde o jogador pode construir o seu rob em 5 partes:
cabea, corpo, brao direito, brao esquerdo e pernas. Essas customizaes sero
feitas atravs de novas peas que podero ser adquiridos pelo jogador no decorrer
do jogo atravs do dinheiro ganho durante sua jornada.
3.*.) 6ec+nica
A mecnica do jogo baseada em robs e na luta entre eles. Muitas so as
caractersticas que definem um rob, como HP (%ealth Points pontos de sade), que
55
em batalha quando alcanado o nvel de 0 o rob parar de funcionar caracterizando
derrota, &reath (flego) que ser o flego disponvel para execuo de golpes, alm
de outros atributos como ataque, defesa e velocidade
O sistema de luta consiste entre dois robs em um terreno, cada um tem seu
HP, o primeiro a ter seu HP esgotado ser considerado como derrotado, no final de
cada luta o jogador vencedor ganhar pontos de experincia que posteriormente se
transformaro em habilidades a serem distribudas no rob.
3.*.* @istema de "+mera
O sistema de cmera adotado em todo o jogo ser o de terceira pessoa, ou
seja, nesse sistema de cmera voc pode visualizar voc mesmo assim como o
cenrio em sua volta.
3.*.* @istema de "omandos
O jogo conta com movimentao simples encontrada em maioria dos jogos,
os comandos do rob so:
W Andar para frente;
A Andar para esquerda;
S Andar para traz;
D Andar para direita;
Q rotacionar a cmera para esquerda;
E rotacionar a cmera para direita;
P Defesa;
O Soco;
O menu de opes do jogo pode ser acionado atravs da tecla ESC a qual
ser mostrado botes como de situao de jogo, inventrio de itens, opes de
jogos, ajuda e sair (vide figura 56).
56
Figura 58: Menu Principal
Toda a parte de GU do jogo, menus, botes e etc., sero controlados atravs
de mouse.
3.1 Desenvolvimento do jogo
Aps se apresentar o jogo, ser apresentado como ele foi desenvolvido as
ferramentas e os principais algoritmos aplicados.
3.1.1 6odelagem de >ersonagens
Como dito anteriormente a ferramenta usada para fazer modelagem dos
personagens foi o Blender, alm da modelagem, toda animao de personagem foi
feita nele.
A figura 59 ilustra como foi modelado o primeiro rob.
57
Figura 59: Modelando do primeiro rob.
Como podemos ver na imagem anterior, o rob foi modelado com baixo
nmero de tringulos, e foi usada basicamente a pintura de vrtice usando a cor
cinza, na cabea foi usado UV Mapping assim como mostra a figura.
A figura 60 ilustra o modelo do segundo rob.
Figura 60: Modelando do segundo rob.
A modelagem do segundo rob seguiu o padro do primeiro com algumas
modificaes na cabea braos e peito do personagem.
58
3.1.' Anima%&o dos >ersonagens
Ainda no Blender foi feita a animao desses personagens, a tcnica usada
foi a tcnica de animao por esqueleto, onde criado um esqueleto composto por
ossos e articulaes (vide figura 61).
Figura 61: Modelando o esqueleto do personagem para animao
Aps desenhar tal esqueleto o associamos a um objeto 3D, ajustando se
necessrio os ossos aos vrtices a arestas do objeto (vide figura 62).
Figura 62: Rob associado a um esqueleto.
59
Agora se tem um objeto relacionado a um esqueleto. Para fazer a animao
basta mudar a perspectiva do Blender para a perspectiva de animao (vide figura
63).
Figura 63: Perspectiva de animao.
Nessa perspectiva cria-se uma nova animao, e a animao feita movendo
e girando as articulaes dos ossos, feito isso, a ferramenta ir automaticamente
atualizar o objeto 3D (vide figura 64).
Figura 63: Animao "andar.
Ao todo foram criadas 7 animaes: comemorao de vitria, tchau, soco
(vide figura 64), especial, sem pose, defesa e andar.
60
Figura 64: Animao "soco.
3.1.3 6odelagem de terrenos
Foram criados dois modelos bsicos para o terreno, o primeiro foi uma arena
de batalha (vide figura 65), com o logo do jogo ao centro, nesse modelo foi usado
para pintura apenas a tcnica de () Mapping.
Figura 65: Arena de batalha.
O segundo modelo criado foi uma espcie de estdio que ficar em volta da
arena, o modelo foi inspirado no Coliseu de Roma (vide figura 66), nesse modelo
tambm s foi usado () Mapping.
61
Figura 66: Estdio da batalha.
3.1.3 "arregando modelos no Ogre
O primeiro passo exportar esses modelos criados no Blender para um
formato compatvel com Ogre, para isso foi usado um plug-in para Blender chamado
!gre Meshes *xporter (vide figura 67). Nesse plug-in permitido exportar os
objetos, animaes e texturas do objeto.
Figura 67: Exportador Ogre.
Ao exportar o plug-in gerar um arquivo com extenso .mesh (exemplo
pernas.mesh) nesse arquivo tem todas informaes de vrtices, arestas e faces,
assim como animaes e aplicaes de texturas.
62
O Ogre se baseia em grafos de cenas, ou seja, as cenas so compostas por
ns, a vantagem dessa abordagem a organizao de uma cena, a manipulao
que se pode ter movendo um n filho para outro n pai. Umas das principais
vantagens do n que tudo que for feito em um n pai, afeta todos os ns filhos, por
exemplo, voc tem um personagem que est em um n, e tem um carro em outro
n, no momento em que o personagem entrar no carro, o n personagem
colocado como filho do n carro, assim ao mover o carro o personagem
automaticamente se mover junto a ele.
Foi criado para cada rob um objeto chamado +haracter que contm um n
para cada parte do corpo e um n pai para todos esses ns como podemos ver
abaixo:
Ogre::SceneNode
*charNode,
*cabecaNode,
*corpoNode,
*bracoDirNode,
*bracoEsqNode,
*pernasNode;
Nesses ns podem ser associado vrias coisas como objetos 3D (*ntity),
luzes (Light) entre outros objetos. Para carregar os objetos no Ogre foi feito o
seguinte procedimento:
mainChar = new Character();
mainChar->charNode = mSceneMgr->getRootSceneNode()->createChildSceneNode(
"mainCharNode", Ogre::Vector3(6,14,0) );
/** CRA UM N PARA CADA PARTE DO CORPO */
mainChar->cabecaNode = mainChar->charNode->createChildSceneNode("mainCharCabeca");
mainChar->corpoNode = mainChar->charNode->createChildSceneNode( "mainCharCorpo" );
mainChar->bracoDirNode = mainChar->charNode->createChildSceneNode("mainCharBracoDir");
mainChar->bracoEsqNode = mainChar->charNode->createChildSceneNode( "mainCharBracoEsq" );
mainChar->pernasNode = mainChar->charNode->createChildSceneNode(
"mainCharPernas" );
/** CARREGA OS ARQUVOS */
mainChar->cabeca = mSceneMgr->createEntity( "cabeca", "cabeca_001.mesh" );
mainChar->corpo = mSceneMgr->createEntity( "corpo", "corpo_001.mesh" );
mainChar->bracoDir = mSceneMgr->createEntity( "bracoDir", "braco_dir_001.mesh" );
mainChar->bracoEsq = mSceneMgr->createEntity( "bracoEsq", "braco_esq_001.mesh" );
mainChar->pernas = mSceneMgr->createEntity( "pernas", "pernas_001.mesh" );
/** Colocando as entidades em seus ns*/
mainChar->cabecaNode->attachObject(mainChar->cabeca);
mainChar->corpoNode->attachObject(mainChar->corpo);
mainChar->bracoDirNode->attachObject(mainChar->bracoDir);
mainChar->bracoEsqNode->attachObject(mainChar->bracoEsq);
mainChar->pernasNode->attachObject(mainChar->pernas);
63
Aps carregar esses objetos, eles so posicionados para que se paream ser
um objeto s, o cdigo fonte pode ser conferido abaixo:
/** Ajustando posies*/
mainChar->charNode->setPosition(1.0f, 0.2f, 0.0f);
mainChar->cabecaNode->setPosition( Ogre::Vector3( 0.000f, 1.642f, 0.010f) );
mainChar->corpoNode->setPosition( Ogre::Vector3( 0.000f, 1.263f, 0.000f) );
mainChar->bracoDirNode->setPosition( Ogre::Vector3( -0.238f, 1.161f, 0.002f) );
mainChar->bracoEsqNode->setPosition( Ogre::Vector3( 0.225f, 1.219f, -0.003f) );
mainChar->pernasNode->setPosition( Ogre::Vector3( 0.000f, 0.516f, 0.092f) );
Agora feita a parte fsica junto ao Bullet. A ideia simples, usado para
cada objeto 3D uma forma para coliso o que chamamos de Shapes, todos esses
Shapes depois de criados so associado ao corpo rgido do personagem
(,igid-ody). Para melhor explicar esses Shapes mostrada uma foto do jogo,
ativando o modo de mostrar Shapes (vide figura 68), note que os Shapes so as
linhas na cor verde.
Figura 68: Shapes do personagem
O cdigo para serem criados esses Shapes e corpos rgidos, sua hierarquia e
posio pode ser conferido abaixo:
mainChar->charRigidBody = new OgreBulletDynamics::RigidBody( "mainCharRigid", world );
animConverter = new OgreBulletCollisions::AnimatedMeshToShapeConverter(mainChar->cabeca);
mainChar->cabecaShape= animConverter->createConvex();
delete animConverter;
animConverter = new OgreBulletCollisions::AnimatedMeshToShapeConverter(mainChar->corpo);
mainChar->corpoShape = animConverter->createConvex();
64
delete animConverter;
animConverter = new OgreBulletCollisions::AnimatedMeshToShapeConverter(mainChar->bracoDir);
mainChar->bracoDirShape = animConverter->createConvex();
delete animConverter;
animConverter = new OgreBulletCollisions::AnimatedMeshToShapeConverter(mainChar->bracoEsq);
mainChar->bracoEsqShape = animConverter->createConvex();
delete animConverter;
animConverter = new OgreBulletCollisions::AnimatedMeshToShapeConverter(mainChar->pernas);
mainChar->pernasShape = animConverter->createConvex();
delete animConverter;
mainChar->charShape = new OgreBulletCollisions::CompoundCollisionShape();
mainChar->charShape->addChildShape(mainChar->cabecaShape,Ogre::Vector3(0.000f, 1.642f,
0.010f));
mainChar->charShape->addChildShape(mainChar->corpoShape,Ogre::Vector3( 0.000f,
1.263f, 0.000f));
mainChar->charShape->addChildShape(mainChar->bracoDirShape,Ogre::Vector3(-0.238f, 1.161f,
0.002f));
mainChar->charShape->addChildShape(mainChar->bracoEsqShape,Ogre::Vector3( 0.225f, 1.219f,
-0.003f));
mainChar->charShape->addChildShape(mainChar->pernasShape,Ogre::Vector3( 0.000f, 0.516f,
0.092f));
mainChar->charRigidBody->setShape( mainChar->charNode, mainChar->charShape, charRestitution,
charFriction, charMass );
Aps isso, criado e carregado uma matriz de animaes e partes do corpo,
ou seja, de 6 por 5:
Ogre::String animNames[] = {"andar", "soco_direito", "no_pose", "victory_dance", "tchau", "guard"};
for( int i = 0; i < 7; i++){
mainChar->animationArray[i][0] = mainChar->cabeca->getAnimationState(animNames[i]);
mainChar->animationArray[i][1] = mainChar->corpo->getAnimationState(animNames[i]);
mainChar->animationArray[i][2] = mainChar->bracoEsq->getAnimationState(animNames[i]);
mainChar->animationArray[i][3] = mainChar->bracoDir->getAnimationState(animNames[i]);
mainChar->animationArray[i][4] = mainChar->pernas->getAnimationState(animNames[i]);
}
Para carregar a arena e o estdio o procedimento parecido, porm nesses
objetos no so criadas animaes, e por serem objetos sem movimentos usado
uma srie de classes para otimizao desses objetos. Primeiro criado uma funo
para adicionar #riMesh estticos ( mesh = objeto, tri = tringulos ):
OgreBulletDynamics::RigidBody* TUMBU::addStaticTrimesh (const Ogre::String &instanceName,
const Ogre::String &meshName, const Ogre::Vector3 &pos, const Ogre::Quaternion &q, const
Ogre::Real bodyRestitution, const Ogre::Real bodyFriction, bool castShadow){
Ogre::Entity *sceneEntity = mSceneMgr->createEntity(instanceName +
Ogre::StringConverter::toString(mNumEntitiesnstanced), meshName);
sceneEntity->setCastShadows (castShadow);
65
OgreBulletCollisions::StaticMeshToShapeConverter *trimeshConverter = new
OgreBulletCollisions::StaticMeshToShapeConverter(sceneEntity);
OgreBulletCollisions::TriangleMeshCollisionShape *sceneTriMeshShape = trimeshConverter-
>createTrimesh();
delete trimeshConverter;
OgreBulletDynamics::RigidBody *sceneRigid = new OgreBulletDynamics::RigidBody(
instanceName + "Rigid" + Ogre::StringConverter::toString(mNumEntitiesnstanced),
world);
Ogre::SceneNode *node = mSceneMgr->getRootSceneNode ()->createChildSceneNode ();
node->attachObject (sceneEntity);
sceneRigid->setStaticShape(node, sceneTriMeshShape, bodyRestitution, bodyFriction, pos);
mNumEntitiesnstanced++;
return sceneRigid;
}
Aps criadas essas funes, carregamos facilmente os objetos do cenrio do
seguinte modo:
addStaticTrimesh("arena", "arena.mesh", Ogre::Vector3(0,0,0), Ogre::Quaternion::DENTTY, 0.1f,
0.8f, false);
addStaticTrimesh("coliseum", "coliseum.mesh", Ogre::Vector3(0,0,0), Ogre::Quaternion::DENTTY,
0.1f, 0.8f, false);
3.1.) "om>osi%&o das classes
Para padronizar as classes dentro do desenvolvimento foi criado uma
interface chamada Game!&.ect nessa interface so definidos todos os mtodos que
uma classe que representa algo na cena deve implementar:
class GameObject{
public:
GameObject(void);
virtual ~GameObject(void);
virtual void keyPressed(const Ogre::Real time, const OS::KeyEvent& input) = 0;
virtual void keyReleased(const Ogre::Real time, const OS::KeyEvent& input) = 0;
virtual void update(const Ogre::Real time) = 0;
private:
};
Os 3 mtodos que so obrigatoriamente implementados so:
eyPressed: mtodo que executado quando foi apertado algum boto ou
tecla pelos dispositivos de entrada;
66
ey,eleased: mtodo executado quando um desses botes ou teclas
so soltados;
update: esse mtodo executado a cada frame gerado pela placa de
vdeo.
O parmetro time representa a diferena de tempo do frame anterior at o
frame atual. O parmetro input contm todas informaes de qual foi o boto ou
tecla acionada pelo jogador.
3.1.* "lasses
Ser explicado aqui o funcionamento e os algoritmos das principais classes
que compe o jogo.
A classe +amera responsvel por todo movimento e regras de cmera, em
seu construtor so recebidos dois parmetros:
Ogre::Camera: a objeto cmera do motor Ogre;
Ogre::SceneNode* mChaseNode: o n a qual a cmera vai seguir.
No momento que a classe instanciada criado um novo n a partir do n
raiz do grafo:
mCameraNode = camera->getSceneManager()->getRootSceneNode()->createChildSceneNode();
O objeto Ogre::Camera atribudo a esse novo n criado, porm na posio x
= 0, y = 2.2, e z = 4 como mostra o cdigo a seguir:
mCamera->setPosition(Ogre::Vector3( 0, 2.2f, 4.0f ) );
mCameraNode->attachObject(mCamera);
Desse modo garante-se que a cmera esteja sempre apontando para o centro
do n, facilitando a rotao, pois, no caso de uma rotao, s preciso girar o n, e
automaticamente todos os filhos dos ns sofrero essa rotao.
No mtodo update da classe atualizamos sempre a posio da cmera de
acordo com n que ela est seguindo, e verificamos se o usurio solicitou rotao de
cmera ou zoom de cmera como mostra o cdigo a seguir:
67
mCameraNode->setPosition( chaseNode->getPosition() );
if( isRotatingRight ){
mCameraNode->yaw(Ogre::Radian(timeSinceLastrame ! -"));
#e$se if( isRotatingLeft){
mCameraNode->yaw(Ogre::Radian(timeSinceLastrame ! "));
#e$se if( isRotating%& ){
mCameraNode->&itch(Ogre::Radian(timeSinceLastrame ! -"));
#e$se if( isRotating'own ){
mCameraNode->&itch(Ogre::Radian(timeSinceLastrame ! "));
#e$se if( is(oom)n ** mCamera->getPosition()+, > -)N.C/-0R/.')S1/NC0){
mCamera->setPosition(mCamera->getPosition() 2 Ogre::3ector"(45 45 -64 !
timeSinceLastrame));
#e$se if( is(oomO7t ** mCamera->getPosition()+, 8 -/9.C/-0R/.')S1/NC0){
mCamera->setPosition(mCamera->getPosition() 2 Ogre::3ector"(45 45 64 !
timeSinceLastrame));
#
Outra classe importante a classe que controla a interface de usurio
chamado de G(/. Essa classe responsvel por toda comunicao com a biblioteca
CEGU, carregar todos os layouts de menus e mostrar e sumir menus da tela.
Esses "layouts so carregados de arquivos com a extenso .layout que so
arquivos do tipo XML com as informaes sobre elementos, tamanhos, textos, cores
entre outras informaes. Para um exemplo completo sobre esse arquivo XML ver o
apndice B, que contm os menus da conversa entre personagens.
Aps ler esses arquivos as propriedades do XML so persistidos em variveis
da classe para poder ser feita a manipulao. No cdigo abaixo mostrado como
feita a associao do arquivo chamado loading:
loadingLayout = CEGU::WindowManager::getSingleton().loadWindowLayout( "loading.layout" );
mainLoading = wmgr.getWindow("RootLoading/Loading");
loadingText = (CEGU::Window*)mainLoading->getChild("RootLoading/Loading/LoadingText");
Associado a variveis eles so facilmente manipulados. O exemplo a seguir
mostra o funcionamento da funo que ativa a mensagem de "carregando...:
void GU::startLoad(Ogre::String message){
mainLoading->setVisible(true);
loadingText->setText(message);
}
Temos tambm a classe SoundManager responsvel pela manipulao de
sons no jogo. O seu principal mtodo o createSoundNode que cria um n filho de
um n passado por parmetro com a msica desejada, como mostra o cdigo a
seguir:
68
Ogre/L::So7nd! So7nd-anager::createSo7ndNode(Ogre::SceneNode! father5
Ogre::String nodeName5 Ogre::String m7sicName5 Ogre::String m7sici$e5 :oo$
$oo&){
Ogre/L::So7nd! so7nd ; so7nd-anager->createSo7nd(m7sicName5 m7sici$e5 $oo&5
stream);
Ogre::SceneNode! so7ndNode ; father->createChi$dSceneNode(nodeName);
so7ndNode->attachO:<ect(so7nd);
ret7rn so7nd;
#
Por parmetro recebido o n pai do n da msica, o nome do novo n a ser
criado, o nome da msica, o nome do arquivo com a msica, um booleano para
saber se a msica ser tocada repetidamente.
Uma das classes mais importantes classe responsvel pela manipulao
dos robs, essa classe chamada Character. Alm das variveis responsveis pela
manipulao de objetos, fsica e animao a classe Character contm uma srie de
outros atributos que podem ser conferidos a seguir.
/** Atributos das atuais do jogador */
double hp;
double bp;
/** Atributos estticos do jogador */
double maxHp;
double maxBp;
double maxAttack;
double maxDefense;
double maxVelocity;
Um dos principais algoritmos dessa classe o algoritmo de movimento do
jogador. Primeiros vamos ver o cdigo do mtodo keyPressed:
if (input.key == OS::KC_W){
mKeyDirection.z = -1;
}else if (input.key == OS::KC_A){
mKeyDirection.x = -1;
}else if (input.key == OS::KC_S){
mKeyDirection.z = 1;
}else if (input.key == OS::KC_D){
mKeyDirection.x = 1;
}
Ainda no mtodo keyPress verificamos se esse vetor tridimensional
diferente de 0, se for diferente ativamos a animao andar para o objeto das pernas:
if (!mKeyDirection.isZeroLength()){
animationArray[0][ANM_PERNAS]->setEnabled(true);
}
69
O cdigo a seguir mostra um trecho do mtodo update e representa a parte
de movimento:
/** Movimento */
if (!mKeyDirection.isZeroLength()){
// Calcula a direo do movemento a paritr da posio da camera
mGoalDirection += mKeyDirection.z * activeCameraNode->getOrientation().zAxis();
mGoalDirection += mKeyDirection.x * activeCameraNode->getOrientation().xAxis();
mGoalDirection.y = 0;
mGoalDirection.normalise();
//Calcula quanto se deve rotacionar
Ogre::Quaternion toGoal = charNode->getOrientation().zAxis().getRotationTo(mGoalDirection);
// Calcula quanto o rob esta virado para direo de destino
Ogre::Real yawToGoal = toGoal.getYaw().valueDegrees();
// Quanto pode virar nesse frame
Ogre::Real yawAtSpeed = yawToGoal / Ogre::Math::Abs(yawToGoal) * time * TURN_SPEED;
if (yawToGoal < 0){
yawToGoal = std::min<Ogre::Real>(0, std::max<Ogre::Real>(yawToGoal, yawAtSpeed));
}else if (yawToGoal > 0){
yawToGoal = std::max<Ogre::Real>(0, std::min<Ogre::Real>(yawToGoal, yawAtSpeed));
}
//Rotacionando o n no eixo Y
charNode->yaw(Ogre::Degree(yawToGoal));
//Atualiza a parte fsica de acordo com a nova rotao e posies do rob
btTransform localTrans(OgreBulletCollisions::OgreBtConverter::to(charNode->getOrientation()),
OgreBulletCollisions::OgreBtConverter::to(charNode->getPosition()));
charRigidBody->getBulletObject()->setWorldTransform(localTrans);
//Calcula a velocidade que ser aplicada ao corpo fsica
btVector3 translation = OgreBulletCollisions::OgreBtConverter::to(charNode->_getDerivedOrientation()
* Ogre::Vector3(0,0,RUN_SPEED));
translation.setY(0);
charRigidBody->getBulletRigidBody()->setLinearVelocity( translation );
//Atualiza a animao das pernas
animationArray[0][ANM_PERNAS]->addTime(time);
}
Essas so as principais classes e principais funcionalidades que compe o
projeto, existem muitas outras, mas sem muita necessidade de explicao.
3.1 3otos do jogo
Para melhor demonstrar o projeto em funcionamento foram tiradas algumas
fotos (figura 69 a 74) durante o jogo.
70
Figura 69: Foto 1 tirada durante o jogo
Figura 70: Foto 2 tirada durante o jogo
Figura 71: Foto 3 tirada durante o jogo
71
Figura 72: Foto 4 tirada durante o jogo
Figura 73: Foto 5 tirada durante o jogo
Figura 74: Foto 6 tirada durante o jogo
72
73
). "onclus&o
Conclui-se ento que a rea de jogos tanto em questes tecnolgicas como
em questes de mercado vem crescendo.
Em questes de mercado vemos cada vez mais crescer o nmero de
jogadores, isso foi impulsionado pela grande facilidade de acesso aos jogos, e a
grande gama de tipos de jogos, hoje se tem jogos para diversos tipos de pblicos,
como: jogos casuais, jogos sociais (jogos para redes sociais), jogos para
computadores, jogos para internet, jogos para videogames, jogos para plataformas
mveis e jogos interativos.
A rea de desenvolvimento de jogos j muito grande em continentes como
Amrica do Norte, Europa e sia, porm, no Brasil a rea est comeando a evoluir.
Hoje j temos alguns cursos superiores na rea, mas a rea tem muito que crescer.
Em questo de desenvolvimento, foco principal do trabalho, podemos concluir
que o desenvolvimento no uma tarefa fcil, pois como j vimos essa rea
abrange muitas das cincias da computao alm de outros aspectos como arte e
msica.
No incio do desenvolvimento de jogos as tecnologias eram limitadas apenas
para empresas, porm isso gradativamente vem mudando e cada vez mais temos
ferramentas de qualidade disponveis gratuitamente.
Hoje em dias podemos escolher quais motores de jogos usar, quais
modeladores 3D usar e quais motores fsicos usar.
Um dos motivos pelo qual foi escolhido Ogre3D alm de ela ser de cdigo
aberto e com uma grande gama de recursos grficos, por ela ser apenas um motor
grfico, diferentemente de outros motores como Unity e Unreal que so motores de
jogos. Os motores de jogos tm como um dos componentes o motor grfico, porm
eles abrangem uma rea muito maior. Um motor de jogo nos dias atuais possui
geralmente: editor integrado, motor fsico integrado, motor de udio integrado,
sistema de GU integrado, e bibliotecas de comunicao em rede integrada. Com o
Ogre3D possvel voc definir quais motores fsicos, GU, udio usar, assim
cabendo a comunidade dos desenvolvedores Ogre3D se preocuparem apenas com
74
recursos e desempenho da parte grfica, e esse um dos motivos que fazem muitos
desenvolvedores e empresas a escolher Ogre3D.
Visto isso essa monografia tem como objetivo desmistificar o real processo do
desenvolvimento de jogos usando Ogre e ferramentas gratuitas, alm de incentivar
pessoas para essa rea de pesquisa. Foram escolhidas ferramentas gratuitas para
incentivar a rea profissional a usar ferramentas que podem ser facilmente
acessadas por estudantes, facilitando assim o processo de aprendizagem
profissional.
75
Refer?ncias -ibliogr.ficas
Atari Guide. Disponvel em: http://www.atariguide.com/. Acesso em: abril de 2010.
BOTSCH M., Steinberg S., Bischoff S., Kobbelt L. Openmesh a generic and
efficient
polygon mesh data structure. OpenSG Simpsio, 2002.
Bullet Bullet Physics. Disponvel em: http://bulletphysics.org/wordpress/ . Acesso
em novembro de 2010.
AURLO Dicionrio do Aurlio Online Dicionrio da lngua portuguesa.
Disponvel em: http://www.dicionariodoaurelio.com/ . Acesso em: julho de 2010.
CEGU Crazy Eddie's Gui System for Games. Disponvel em:
http://www.cegui.org.uk/wiki/index.php/Main_Page. Acesso em julho de 2010.
EBERLY, D. H. 3D Game Engine Design A Practical Approach to Real-Time
Computer Graphics. Boston: Morgan Kaufmann Publishers, 2000, 561 p.
GETTLER, Joe. The First Video Game? Disponvel em:
http://www.bnl.gov/bnlweb/history/higinbotham.asp . Acesso em: abril de 2010.
Havok Havok. Disponvel em: http://www.havok.com/. Acesso em novembro de
2010.
RRLicht rrLicht A free open source 3d engine, documentation, wiki e forums.
Disponvel em: http://irrlicht.sourceforge.net/. Acesso em julho de 2010.
JMonkeyEngine Java Monkey Engine wiki, manual e forums. Disponvel em:
http://www.jmonkeyengine.org/. Acesso em julho de 2010.
JUNKER, G. Pro Ogre 3D Programming. New York: Apress, 2006. 312 p.
NVidia NVidia. Disponvel em: http://www.nvidia.com. Acesso em novembro de
2010.
OGRE Open Source 3D Graphics Engine, wiki, manual and api reference.
Disponvel em: http://www.ogre3d.org/. Acesso em abril de 2010.
Unity Game development Tool, support. Disponvel em: http://unity3d.com/. Acesso
em julho de 2010.
76
XNA Creators XNA Creators Club Online, education. Disponvel em:
http://creators.xna.com/en-US/. Acesso em julho de 2010.
77
A>?ndice AA 0nredo jogo
2050 DC...
A Terra passou por um grande caos natural.
Cientistas do Reino Unido descobre uma "coisa que gerencia todos os tipos
de vidas, essa "coisa se chama GAA (Deusa da Terra na mitologia Grega), GAA
o fluxo da vida, e que controla e sincroniza diferentes dimenses.
GAA pode abrir portas para outra dimenso sempre que pensa que
necessrio, segundo os cientistas o ltimo portal foi para Avalon, no se sabe
quantos portes foram abertos, e por que esto abertos, e quando so abertas.
A maior preocupao dos cientistas que o GAA est irradiando uma
estranha energia para a Terra. A energia mstica, no causam nenhum perigo,
mas to estranho, ningum consegue explicar o que .
Apesar de nossa tecnologia avanada, os nossos robs no podem agir como
seres humanos, em outras palavras, eles no tm sentimentos. Rumores dizem que
um jovem cientista chamado Jonathan descobriu uma maneira de dar algum tipo de
"vida a esses robs. Um monte de lendas projetada sobre Jonathan e seu
MyMech Chronus.
Voc o heri, um estudante universitrio que vive em uma cidade no muito
grande no Japo, voc no tem um MyMech e no sabe como ele funciona.
Num dia chuvoso voc ficou at mais tarde na faculdade para estudar e opta
por fazer um caminho diferente para voltar para casa. Coisas estranhas acontecem
nesse caminho, s luzes comeam a piscar, e repentinamente desligam a luz de
toda a rua, curiosamente, uma luz branca comea piscar perto de uma fbrica antiga
j desativada h muito tempo. Hero caminha at l lentamente, at que encontra no
meio de alguns entulhos um MyMech meio sujo emitindo um curioso brilho branco.
Hero comea a perguntar algumas questes para o rob, mas o rob no se
lembra de nada, depois de vrias tentativas para descobrir coisas sobre o MyMech,
o heri decide levar o rob para casa.
No meio do caminho um cara parar o heri forando-o a lutar contra seu MyMech.
Apesar de o rob desconhecido estar na metade de sua energia que voc decide
lutar contra ele.
78
Aps a luta voc volta correndo para sua casa, e o heri decide cuidar do MyMech
at que seu dono aparea.
Hero ento resolve chamar o rob de Ares. A partir daqui o jogo tem incio e o
heri junto ao seu MyMech ter uma trajetrias de vrias batalhas at chegar ao
Cientista Jonathan que lhe explica o que acontece no mundo:
- Existem diversas ilhas, em espaos e tempos diferentes a qual nosso
planeta est conectado, um deles Avalon, GAA a abriu quando julgou necessrio,
e a escondeu quando a misso foi terminada, existe tambm outra ilha chamada
Tumbu (vale profundo num dialeto lfico) assim como existem muitas outras. Apesar
da gente no os ver elas enxergo todos os acontecimentos dessa galxia atravs
do fluxo de vida. Essas ligaes providas por GAA foi criada, pois essas ilhas
precisavam de ajuda, ou precisavam ajudar a Terra, hoje o portal est aberto para
Tumbu, que uma espcie de isolamento para todas as espcies que cometeram
algum tipo de infrao imposta pelas leis de GAA. O portal est aberto por que o
povo de Tumbu de alguma forma teve acesso a essa galxia e hoje eles usam a
nossa tecnologia, unida ao fluxo da vida (esses robs agora so denominados
MechFirya, Firya humano em um dialeto lfico) , para tentar se libertar de Tumbu, e
dominar outras ilhas e at essa galxia.
Ao saber disso Jonathan e Chronus, comeam a recrutar pessoas com seus
robs, dando vida a esses robs atravs de GAA, e, de tempos em tempos so
transportados para Tumbu.
Em sua primeira viagem Jonathan e Chronus constatam que Tumbu no to
diferente que a Terra, isso evidencia GAA conectar os mundos, o clima lembra
muito o clima da Terra. Mas algo curioso acontece em Tumbu, qualquer tipo de arma
de fogo no funciona, aps alguns estudos, foi descoberto, que existe uma
substncia no ar de Tumbu que elimina qualquer efeito causado por qualquer tipo de
plvora.
Sua misso salvar Tumbu, e qualquer outra ilha que venha a ser ameaado
por esses infratores..
Apndice B: Conversation.layout
<?xml version="1.0" encoding="UTF-8"?>
79
<GULayout >
<Window Type="DefaultWindow" Name="RootConversation" >
<Property Name="UnifiedAreaRect" Value="{{0,0},{0,0},{1,0},{1,0}}" />
<Window Type="DefaultWindow" Name="RootConversation/Main" >
<Property Name="UnifiedAreaRect" Value="{{0,0},{0,0},{1,0},{1,0}}" />
<Window Type="TaharezLook/FrameWindow" Name="RootConversation/Main/conversationTop" >
<Property Name="Text" Value="Character One" />
<Property Name="TitlebarFont" Value="DejaVuSans-10" />
<Property Name="TitlebarEnabled" Value="True" />
<Property Name="UnifiedAreaRect" Value="{{0.01,0},{0.01,0},{0.99,0},{0.2,0}}" />
<Window Type="TaharezLook/Staticmage" Name="RootConversation/Main/conversationTop/imag" >
<Property Name="mage" Value="set:RobotFaces image:robot001" />
<Property Name="UnifiedAreaRect" Value="{{0.01,0},{0.05,0},{0.16,0},{0.99,0}}" />
<Property Name="MousePassThroughEnabled" Value="True" />
</Window>
<Window Type="TaharezLook/Button" Name="RootConversation/Main/conversationTop/moreButto">
<Property Name="Text" Value="Continue..." />
<Property Name="AlwaysOnTop" Value="True" />
<Property Name="UnifiedAreaRect" Value="{{0.85,0},{0.8,0},{0.99,0},{0.99,0}}" />
</Window>
<Window Type="TaharezLook/StaticText" Name="RootConversation/Main/conversationTop/text" >
<Property Name="VertFormatting" Value="TopAligned" />
<Property Name="UnifiedAreaRect" Value="{{0.17,0},{0.05,0},{0.99,0},{0.99,0}}" />
</Window>
</Window>
<Window Type="TaharezLook/FrameWindow" Name="RootConversation/Main/conversationBotto" >
<Property Name="Text" Value="Character Two" />
<Property Name="TitlebarFont" Value="DejaVuSans-10" />
<Property Name="TitlebarEnabled" Value="True" />
<Property Name="UnifiedAreaRect" Value="{{0.01,0},{0.8,0},{0.99,0},{0.99,0}}" />
80
<Window Type="TaharezLook/Staticmage" Name="RootConversation/Main/conversationBottom/i">
<Property Name="mage" Value="set:RobotFaces image:robot002" />
<Property Name="UnifiedAreaRect" Value="{{0.01,0},{0.05,0},{0.16,0},{0.99,0}}" />
</Window>
<Window Type="TaharezLook/StaticText" Name="RootConversation/Main/conversationBottom/txt" >
<Property Name="VertFormatting" Value="TopAligned" />
<Property Name="UnifiedAreaRect" Value="{{0.17,0},{0.05,0},{0.99,0},{0.99,0}}" />
</Window>
<Window Type="TaharezLook/Button" Name="RootConversation/Main/conversationBottom/moreB" >
<Property Name="Text" Value="Conitnue..." />
<Property Name="AlwaysOnTop" Value="True" />
<Property Name="UnifiedAreaRect" Value="{{0.85,0},{0.8,0},{0.99,0},{0.99,0}}" />
</Window>
</Window>
</Window>
</Window>
</GULayout>
81
/loss.rio
"onsoleA Aparelho Eletrnico para execuo de jogos (videogames).
"(UA processador, parte do computador responsvel por executar as instrues dos
programas.
Direct3DA AP do DirectX responsvel pela renderizao 3D.
Direct;A Conjunto de AP's proprietria da Microsoft para programao de jogos.
0ngineA Conjunto de bibliotecas, para abstrao e simplificao de acesso a um recurso.
3(@A Nmero de imagens renderizadas em um segundo.
/ame>adA Perifrico de entrada feita para jogos.
/(UA ou VPU, processador normalmente encontradas nas placas de vdeo especializado
em processamento grfico.
/UIA nterface grfica para interao entre usurio e dispositivo digital, termo bastante
usado no desenvolvimento de jogos.
InterfaceA Mediador entre duas entidades diferentes seja AP's, hardwares, etc.
Intelig?ncia ArtificialA Cincia e engenharia dedicada a oferecer artifcios para fazer
simular a inteligncia humana.
,o8stic7sA Perifrico de entrada (formato de basto) feita para jogos.
LUAA Linguagem de programao interpretada, imperativa, de script, procedural, pequena e
reflexiva, projetada para expandir aplicaes em geral.
6al4aA Estrutura geomtrica, em jogos, conjunto de vrtices, bordas e faces.
6atri$A Tabela de smbolos com N linhas em M colunas.
6odelagemA Ato de esculpir, desenhar.
OI@A AP multiplataforma orientada a objetos para entrada de dados por diferentes
dispositivos.
(48tonA Linguagem de Programao Dinmica.
R(/A Estilo de jogo em que o jogador assume o papel de personagens.
Buarteni&oA Extenso do conjunto de nmeros complexos, em jogos, soluo para fins de
rotao.
Renderi$arA Processo de processamento digital para gerar um produto final.
Rota%&o 6atricialA Rotao Utilizando Matrizes.
82
@4aderA Conjunto de nstrues de software, implementados no hardware para gerao de
diversos efeitos.