Roteiro. Introdução. Introdução. Introdução. Tutorial Engine Gráfico OGRE

(1)

Tutorial Tutorial Engine

EngineGrGrááfico OGREfico OGRE

Autores Thiago Souto Maior mouse@cin.ufpe.br João Paulo Lima jpsml@cin.ufpe.br Veronica Teichrieb vt@cin.ufpe.br Judith Kelner jk@cin.ufpe.br WRA 2006

Tutorial – Engine Gráfico OGRE

Introdução Introdução O que é o OGRE? Licença Instalação A Arquitetura do OGRE A Arquitetura do OGRE O Objeto Root O Objeto SceneManager O Objeto RenderSystem O Objeto Entity O Objeto SceneNode

O Objeto Camera & Viewport

O Objeto Material Overlays Overlays Tipos Suportados Tipos Suportados Malhas Texturas Scripts Scripts Inicialização Materiais Programas Partículas Overlays Facilidades do

Facilidades do EngineEngine Geração de Sombras Render-to-texture Mouse Picking Aplicação Básica Aplicação Básica Modelo de Aplicação

Tutorial – Engine Gráfico OGRE Licença

Introdução

OGREOGRE(OObject-orientedGGraphicsRRenderingEEngine)

Engine gráfico •Open-source •Multiplataforma: Windows, Linux, MacOS •Nativamente implementado em C++

Vasta gama de plugins, ferramentas e add-ons

Wrappers para Java, .NET e Python O que é o OGRE? Instalação

Introdução

Independente de configuração de hardware

Verificação dos recursos oferecidos pelo hardware

• RSC_AUTOMIPMAP

• RSC_BLENDING

• RSC_CUBEMAPPING

• RSC_HWSTENCIL

O que é o OGRE? Instalação

• RSC_VERTEX_PROGRAM

• RSC_FRAGMENT_PROGRAM

• RSC_HWRENDER_TO_TEXTURE

const RenderSystemCapabilities *caps =

Root::getSingleton().getRenderSystem()->getCapabilities();

if (!caps->hasCapability(RSC_VERTEX_PROGRAM) || !(caps->hasCapability(RSC_FRAGMENT_PROGRAM))) {

OGRE_EXCEPT(1, "Your card does not support vertex and fragment programs, so cannot " "run this demo. Sorry!", "Fresnel::createScene");

}

Licença

Introdução

OGREOGRE

•Não é um game engine •É um rendering engine genérico

Pode ser incorporado a

•Bibliotecas de tratamento de entradas •Bibliotecas de processamento de som

•Plataformas que disponibilizem algoritmos de inteligência artificial

O que é o OGRE? Instalação Licença

Introdução

Licenciado sob os termos da GNU Lesser Public

License(LGPL)

•Código fonte do OGRE pode ser adquirido

•Código fonte da aplicação não precisa ser liberado

•Divulgar as alterações feitas no engine para a comunidade

OGREOGRE

•Utilização em qualquer aplicação comercial ou não

•Sem despesa adicional com licenciamento O que é o OGRE? Instalação

(2)

Tutorial – Engine Gráfico OGRE Duas formas •SDK pré-compilado •Código fonte •Disponíveis em www.ogre3d.org

SDK

•Mais indicado para iniciantes

•Instalação através de um Wizard

•Fácil e rápida

•São instalados

•Arquivos de cabeçalho (.h)

•Bibliotecas (.lib)

•Bibliotecas dinâmicas (.dll)

•Código fonte de exemplos

•Manual

•Especificação da API

Introdução

SDK

•É criada uma variável de ambiente chamada OGRE_HOME •OGRE_HOMEcontém o caminho do diretório onde o SDK foi

instalado

•Facilita a configuração do ambiente de desenvolvimento O que é o OGRE? Instalação

Introdução

Source

•Forma mais complexa de instalação, mas possui suas vantagens

•Indicada nos casos em que se deseja •Fazer alterações no engine

•Entrar em modo debug dentro do engine

O que é o OGRE? Instalação

Licença

Introdução

Source

•Arquivos necessários para instalação

•Source para a plataforma desejada

(Windows)

•Dependências

•SDK do DirectX •As dependências devem ser

adicionadas ao fonte

O que é o OGRE? Instalação Licença

Introdução

Source

•Abrir e compilar solução Ogre.sln •Todos os projetos

•Suas dependências

•As aplicações exemplo também serão compiladas O que é o OGRE? Instalação

(3)

Utiliza vários padrões de projeto

•Factory

•Singleton

•Listener

Todas as classes estão em um namespace chamado Ogre

#include"Ogre.h"

usingnamespace Ogre;

Arquitetura

É o ponto de entrada do OGREOGRE

Deve ser inicializado antes de qualquer outro objeto

Dá origem a todo o resto do sistema

Deve ser o último objeto a ser destruído

Root SceneManager RenderSystem Entity SceneNode Camera & ViewPort Material

Arquitetura

Método Root::showConfigDialog

•Detecção das opções disponibilizadas pelos sistemas de renderização Caixa de diálogo •Resolução •Tela cheia •Anti-aliasing •Outros

Arquitetura

Apenas uma instância deve ser criada (Singleton)

Pode ser acessado através do método

Root::getSingleton

Mantém referência para objetos importantes

•SceneManager

•RenderSystem

•ResourceManager

Habilita o modo de renderização

•Contínua (indicado para jogos)

(4)

Tutorial – Engine Gráfico OGRE // Cria o Root

Root *root = new Root();

// Mostra caixa de dialogo e chama Root::setRenderSystem, // RenderSystem::setConfigOption and Root::saveConfig

if(!root->showConfigDialog())

{

return0;

}

// Inicializa o root

RenderWindow *window = root->initialise(true);

// ...

// Cria a cena, camera, objetos, etc // ...

// Inicia renderizacao

root->startRendering();

É responsável por organizar todos os objetos da cena

Existem diversas especializações, cada uma sendo otimizada para tipo de cena

Criação e acesso dos nós e objetos da cena

•Entity: createEntity/getEntity

•Camera: createCamera/getCamera

•Light: createLight/getLight

•SceneNode: createSceneNode/getSceneNode

•Outros

Arquitetura

Funciona como uma Factory

Responsável pelo ajuste da luz ambiente

•SceneManager::setAmbientLight(const ColourValue &colour);

Arquitetura

// ... // Criar Root // ... // Cria a cena

SceneManager *sceneMgr = root->getSceneManager(Ogre::ST_GENERIC); // Cria objetos da cena

Camera *mainCam = sceneMgr->createCamera( "MainCam" );

SceneNode *nodeAthena = sceneMgr->createSceneNode( "AntheneNode" ); Entity *entAthene = mSceneMgr->createEntity( "Athene", "athene.mesh" ); Light *sunLight = mSceneMgr->createLight("SunLight");

// Acessa objetos da cena

Entity *entAthene2 = mSceneMgr->getEntity( "Athene" ); Light *sunLight2 = mSceneMgr->getLight( "SunLight" ); // ...

Arquitetura

Interação desenvolvedor x SceneManager

•Montagem da cena

A cena é enviada automaticamente para o RenderSystem no momento da renderização

Método RenderSystem::_renderScene •Chamado pelo engine a cada quadro

Arquitetura

Diferentes tipos de cenas (outdoor, indoor) requerem diferentes algoritmos para estruturação

Otimizar tempo de renderização selecionando apenas os objetos visíveis

Especializações do SceneManager

•BspSceneManager

•TerrainSceneManager

•OctreeSceneManager

(5)

Método Root::getSceneManager •Obter os SceneManagers

Não são obtidos diretamente através do nome das classes, mas sim das constantes

•ST_GENERIC

•ST_EXTERIOR_CLOSE

•ST_EXTERIOR_FAR

•ST_EXTERIOR_REAL_FAR

•ST_INTERIOR

Tutorial – Engine Gráfico OGRE //...

// Criar Root //...

// Cria a cena ( ST_GENERIC | ST_EXTERIOR_CLOSE | ST_EXTERIOR_FAR | // ST_EXTERIOR_REAL_FAR | ST_INTERIOR )

SceneManager *sceneMgr = root->getSceneManager(Ogre::ST_GENERIC);

// ...

// Criar camera, objetos, etc // ...

Arquitetura

Classe abstrata

•Interface entre o OGREOGREe uma API gráfica

É necessária pois as APIs gráficas diferem nos comandos e no paradigma de programação

Três implementações

•D3D9RenderSystem (Direct3D9)

•D3DRenderSystem (Direct3D7)

•GLRenderSystem (OpenGL)

Arquitetura

Sistema de renderização

•Abstraído durante o desenvolvimento

•Escolher qual usar no momento da inicialização (caixa de diálogo de configuração)

Método Root::initialise •Inicializa o sistema de renderização

•Acessado por Root::getRenderSystem

Arquitetura

Não precisa ser acessado diretamente pelo desenvolvedor

Operação relativa à renderização de objetos

•SceneManager

•Material

•Outros

Precisa ser acessado quando criar mais de uma janela

Arquitetura

// ...

// Criar Root, SceneManager e objetos // ...

// Pega o RenderSystem ativo

RenderSystem *renderSys = this->root->getRenderSystem(); // Cria a janela da aplicação (nome, largura, altura, tela cheia) RenderWindow *renderWin = renderSys->

createRenderWindow("MainWin", 640, 480, false); renderWin->addViewport(camera1);

// Cria um RenderTexture

RenderTexture *renderTex = renderSys->

createRenderTexture( "RenderTex1", 320, 240 ); renderTex->addViewport(camera2);

// ...

(6)

É uma instância de um objeto móvel da cena

Ideal para objetos

•Carro

•Personagem

•Avião

•Qualquer objeto relativamente pequeno comparado com a cena

Método SceneManager::createEntity •Criação da entidade

•Nome e caminho do arquivo .mesh

Toda entidade possui uma malha (Mesh) associada

Um Mesh •Conjunto de vértices •Outras informações •Vetores normais •Cor •Mapeamento de coordenadas de textura

•Índice de posicionamento das

faces

•Outras

Arquitetura

Mais de uma cópia de um objeto na cena

•Entidades referenciarão o mesmo Mesh

MeshManager

•Evita que uma mesma malha seja carregada inúmeras vezes

Evita desperdício de memória e de tempo na replicação dos objetos Mesh

Arquitetura

Uma entidade só será visível na cena se estiver associada a um SceneNode

Método SceneNode::attachObject •Associa uma entidade a um SceneNode

SceneNode armazena

•Posição

•Orientação

•Escala

Arquitetura

Quando um Mesh é inicializado, automaticamente o material que foi definido no arquivo .mesh é carregado

Material

•Mais de um material associado a uma entidade

•Cada um associado a uma SubEntity

A quantidade de materiais associada a uma Entity define a quantidade de SubEntity

Arquitetura

Entity SubEntity Mesh SubMesh SubMesh SubMesh SubMesh SubEntity SubEntity SubEntity

(7)

Tutorial – Engine Gráfico OGRE // ...

// Criar Root e SceneManager // ...

// Cria as entidades

Entity *entOgreHead1 = mSceneMgr->createEntity("OgreHead1","ogrehead.mesh"); Entity *entOgreHead2 = mSceneMgr->createEntity("OgreHead2","ogrehead.mesh"); // Altera apenas o material do olho da segunda cabeca

entOgreHead2->getSubEntity(0)->setMaterialName("Ogre/Eye2");

// Cria nos da cena

SceneNode *nodeOgreHead1 = sceneMgr->createSceneNode( "OgreHeadNode1" ); SceneNode *nodeOgreHead2 = sceneMgr->createSceneNode( "OgreHeadNode2" ); // Associa entidades aos nos da cena

nodeOgreHead1->attachObject( entOgreHead1 ); nodeOgreHead2->attachObject( entOgreHead2 ); // ...

Utilizado para agrupar entidades e armazenar informações de posição, orientação e escala das mesmas

Uma entidade não será visível ao menos que ela esteja associada a um SceneNode que faz parte da hierarquia da cena

Toda cena possui por padrão um SceneNode raiz (RootSceneNode)

Método SceneManager::getRootSceneNode •Acessar o RootSceneNode da cena

Arquitetura

Cada SceneNode pode ter inúmeros SceneNodes filhos

•Criação de hierarquias complexas

Podem ser associados a SceneNodes objetos como

•Entities

•BillboardSets

•Cameras

•Lights

Arquitetura

Todos os outros SceneNodes devem estar ligados diretamente ou indiretamente ao RootSceneNode

Criação de SceneNodes

•SceneManager::createSceneNode

•SceneNode retornado ainda precisa ser adicionado como filho

•SceneNode::createChildSceneNode

•SceneNode retornado já está associado a um nó pai

SceneNodes podem ser identificados por um nome

Arquitetura

Transformações aplicadas hierarquicamente aos nós descendentes

Pneu3 Pneu2 Pneu1 Carroceria Pneu4 RootSceneNode

Arquitetura

Método SceneNode::setVisible •Define a visibilidade das

entidades através dos SceneNodes

Método

SceneNode::showBoundingBox •Habilita o volume que delimita

os objetos

(8)

// Pega RootSceneNode

SceneNode *rootNode = sceneManager->getRootSceneNode();

// Cria hierarquia de SceneNodes

SceneNode *carroceriaNode = rootNode->createChildSceneNode("CarroceriaNode"); SceneNode *pneuNode1 = carroceriaNode->createChildSceneNode("PneuNode1"); SceneNode *pneuNode2 = carroceriaNode->createChildSceneNode("PneuNode2"); SceneNode *pneuNode3 = carroceriaNode->createChildSceneNode("PneuNode3"); SceneNode *pneuNode4 = carroceriaNode->createChildSceneNode("PneuNode4");

// Cria as entidades

Entity *entCarroceria = sceneManager->createEntity("Carroceria", "Carroceria.mesh"); Entity *entPneu1 = sceneManager->createEntity("Pneu1", "Pneu.mesh");

Entity *entPneu2 = sceneManager->createEntity("Pneu2", "Pneu.mesh"); Entity *entPneu3 = sceneManager->createEntity("Pneu3", "Pneu.mesh"); Entity *entPneu4 = sceneManager->createEntity("Pneu4", "Pneu.mesh");

// Associa entidades aos SceneNodes

carroceriaNode->attachObject(entCarroceria); pneuNode1->attachObject(entPneu1); pneuNode2->attachObject(entPneu2); pneuNode3->attachObject(entPneu3); pneuNode4->attachObject(entPneu4); //...

// Posiciona pneus relativamente //..

Câmera

•Uma câmera representa um ponto de vista da cena

•Possui propriedade de Frustum

Near plane

Far plane

FOV (field of view)

Aspect (proporção entre a largura e a altura)

Arquitetura

Atributos

Arquitetura

Outros Atributos

•Posição (Vector3D)

setPosition(const Vector3D &position); •Orientação (Quaternion)

setOrientation(const Quaternion &orientation);

Arquitetura

Associada a um alvo de renderização (RenderTarget)

•RenderWindow

•RenderTexture

Viewport

•Associação de uma câmera a uma janela

•Cada janela pode ter vários viewports

Arquitetura

Características do viewport •Posicionamento na janela •Tamanho Largura Altura •Cor do fundo

(9)

SceneManager *sceneMgr = root->getSceneManager(ST_GENERIC);

// Cria a câmera

Camera *camera = sceneMgr->createCamera("SimpleCamera");

// cria um viewport que preenche a janela toda

Viewport *viewport = root->getAutoCreatedWindow()->addViewport(camera);

// Ajusta a cor de fundo para “preto”

viewport->setBackgroundColour(ColourValue::Black)

Identificados unicamente por um nome

•Atribuir um determinado material a um Entity ou SubEntity

Altera a aparência dos objetos

Define como os objetos serão renderizados

Agrupam características da cor do material, reflexão, espalhamento da luz

•diffuse

•specular

•ambient

Arquitetura

Permite multi-texture-layers

•Camadas de texturas

•Composição das camadas (blending)

Efeitos de mapeamento de textura

•Environment Mapping

•Animações (rotação, translação)

Culling

Arquitetura

Definição

•Código

Necessita recompilação

•Scripts

Facilita edição dos materiais e testes

Aumenta o reuso tornando os materiais acessíveis a partir de qualquer aplicação

Overlays

Representam HUDs 2D e 3D

•Painéis de status e menus

•Cockpits fixos no viewport

Criação •Código •Scripts “.overlay” Facilidade de edição Independência do código fonte

Overlays

Método Overlay::show() •Exibe Overlays •Começam desabilitados

Método Overlay::serZOrder(int order) •Atributo “Z-Order” controla sobreposição

(10)

OverlayElement representa os elementos 2D associados a um Overlay

Atributos

•Tamanho

•Posição

•Material

Base para elementos que podem ser adicionados em Overlays

OverlayContainer

•Classe derivada importante

•Permite agrupamento de outros elementos

OverlayElement *guiAvg =

OverlayManager::getSingleton().getOverlayElement("Core/AverageFps");

const RenderTarget::FrameStats& stats = mWindow->getStatistics(); guiAvg->setCaption("Average FPS: " + StringConverter::toString(stats.avgFPS));

Overlay *overlay = OverlayManager::getSingleton().getByName("Core/DebugOverlay"); overlay->show();

Tipos Suportados

Arquivos .mesh

Binários

Exportados por programas de modelagem 3D:

•3DS Max

•Maya

•Blender Malhas Texturas

Tipos Suportados

Arquivos .xml.mesh

Podem ser editados facilmente (arquivos no formato de texto)

Não podem ser diretamente carregados pelo engine

Devem ser convertidos para arquivos .mesh

•OgreXMLConverter

•OgreMeshViewer Malhas Texturas

Exportando modelos no 3DS:

•Modelar

•Aplicar material (mapear coordenadas de textura) •Criar animações •Exportar .mesh.xml .mesh

Tipos Suportados

Malhas Texturas

Tipos Suportados

DevIL Multiplataforma Tipos suportados:

.bmp, .cut, .dcx, .dds, .ico, .gif, .jpg, .lbm, .lif, .mdl, .pcd, .pcx, .pic, .png, .pnm, .psd, .psp, .raw, .sgi, .tga, .tif, .wal, .act e .pal

(11)

Texturas podem ser carregadas manualmente caso o DevIL não suporte

#ifndef RAW_VOLUME_LOADER_H

#define RAW_VOLUME_LOADER_H

#include<OgreResource.h>

#include<OgreTexture.h> using namespace Ogre;

class RawVolumeLoader : public ManualResourceLoader { private:

String fileName;

unsigned short ***loadImageRaw(const Texture &tex, unsigned &max); ColourValue getPsuedoColor(float t);

public:

RawVolumeLoader(const String &fileName); ~RawVolumeLoader() {}

void loadResource(Resource* resource); };

#endif

São simples arquivos de texto

Podem ser criados e alterados em qualquer editor de texto

Agilizam processo de desenvolvimento

Caminho alternativo ao código fonte

Código fonte mais enxuto

Evita recompilações no código

Processo de experimentação mais rápido

Podem ser reutilizados em outras aplicação

Scripts

Scripts de inicialização

Plugins.cfg

•Carregamento dos plugins

•PluginFolder

Pasta onde ficam os plugins •Plugin

Nome do plugin a ser carregado (sem a extensão) Ogre.cfg

•Auto-preenchimento da janela de configuração Materiais

Inicialização Programas Partículas Overlays

Scripts

Resources.cfg

•Guarda os caminhos dos recursos utilizados pela aplicação

•Utilizado por aplicações derivadas de ExampleApplication

•FileSystem

Diretiva que indica um diretório onde podem ser colocados recursos da aplicação

•Zip

Indica que recursos podem ser colocados em arquivos “.zip” Materiais

Scripts

Facilitam o processo de criação de materiais

Podem ser posteriormente reutilizados

Arquivos contendo scripts de material são identificados pela extensão .material

São analisados (parsed) no momento da inicialização da aplicação

Materiais

Scripts

Inúmeros materiais em um único arquivo .material

Agrupar material relativo a uma entidade em um único arquivo .material

Ogre.material material Ogre/Eyes {… } material Ogre/Skin {… } material Ogre/Earring {… } material Ogre/Tusks {… } Materiais

(12)

Estrutura de um script de material

•Estrutura hierárquica de seções: material

technique

pass

texture_unit

•Cada seção possui um conjunto de atributos próprios

•Caso os atributos não sejam explicitados, a eles serão atribuídos os valores padrões

Tutorial – Engine Gráfico OGRE // isto é um comentário material <identificador> { // atributos do material technique { // atributos da técnica pass { // atributos do passo diffuse 1001 texture_unit { // atributos da textura } } } }

Scripts

material

•Raiz da hierquia

•Deve ser identificado por uma string

•Identificador deve ser globalmente único

Caso haja conflito entre identificadores a aplicação será encerrada

Materiais

Scripts

technique

•Uma forma de se chegar a um dado efeito

•Um material pode ser composto por inúmeras techniques Fallback (as que forem primeiramente declaradas terão

prioridade)

LOD (Level of Detail)

Materiais

Scripts

pass

•Representa um passo da renderização (uma chamada a API)

•Uma techinque pode ser composta por até 16 passos

•O custo (computacional) de uma technique é diretamente proporcional a quantidade de passos

Materiais

Scripts

Reflexão Refração

Materiais

(13)

texture_unit

•Definição dos atributos relativos as textura:

•Um passo pode ser composto por mais de uma texture_unit

Textura Mapa de Iluminação Resultado da Composição

Vertex Shaders

• Animações

• Iluminação Gouraud

Interpolação de cores por vértice

• Cálculo de informações a cada vértice

Scripts

Pixel Shaders

•Efeitos de distorção, refração, reflexão, iluminação

•Cálculo de informações a cada pixel

•Demanda processamento maior na GPU Materiais

Scripts

Podem ser implementados através de linguagens específicas de Shading

•HLSL (High Level Shading Language)

•GLSL (GL Shading Language)

•CG (C for Graphics)

•Direto no Assembly do perfil escolhido Materiais

Scripts

Podem ser declarados em arquivos .material

•Devem ser declarados antes de serem usados

Podem ser declarados em arquivos .program

•Garante que serão carregados antes de serem referenciados e pode ser reusado em outros materiais depois

Declaração consiste do tipo do programa, nome e linguagem utilizada

•Tipos: fragment program, vertex_program

•Linguagens: hlsl, glsl, cg, asm

•Ex: fragment_program myCgFragmentProgram cg { source myCgFragmentProgram.cg entry_point main profiles ps_2_0 arbfp1 } fragment_program myCgFragmentProgram cg { source myCgFragmentProgram.cg entry_point main profiles ps_2_0 arbfp1 } Materiais

Scripts

Referência ao programa deve ser feita dentro de um “pass”

O programa será executado no passo de renderização onde ele foi referenciado

Ex: pass { vertex_program_ref myVertexProgram { param_indexed_auto 0 worldviewproj_matrix param_indexed 4 float4 10.0 0 0 0 } } pass { vertex_program_ref myVertexProgram { param_indexed_auto 0 worldviewproj_matrix param_indexed 4 float4 10.0 0 0 0 } } Materiais

(14)

Simular efeitos como:

•Fumaça

•Fogo

•Chuva

São definidos em arquivos .particle

A sessão inicial é identificada apenas pelo identificador do script

•EX: Exemplos/Chuva

Sitemas de partículas são criados pelo ParticleSystemManager::createSystem

ParticleSystem devem ser associados a SceneNodes (translate, rotate, scale)

Scripts

Seções:

•“Raiz” (apenas o nome do script)

•emmiter <tipo> Point Box Cylinder Ellipsoid ... •affector <tipo> LinearForce ColourFader Materiais

Scripts

// Uma fonte de particulas

Exemplos/Fonte { material Examples/Flare2 particle_width 20 particle_height 20 quota 10000 // ... // Emissor de particulas emitter Point { emission_rate 75 time_to_live 3 direction 0 1 0 velocity_min 250 velocity_max 300 // ... } // Gravidade affector LinearForce { force_vector 0 -1000 0 // ... } } Materiais

Scripts

// Cria sistema de particulas

ParticleSystem* pSys =

ParticleSystemManager::getSingleton().createSystem("Fonte1", "Examples/Fonte");

// Aponta a fonte para um angulo

SceneNode* fNode = rootSceneNode()->createChildSceneNode(); fNode->translate(200,-100,0);

fNode->rotate(Vector3::UNIT_Z, Degree(20));

fNode->attachObject(pSys);

Materiais

Scripts

Facilita a criação de GUIs

Overlays podem ser reutilizados em outras aplicações ("Core/DebugOverlay")

Materiais

(15)

Podem conter qualquer quantidade de elementos

Elementos podem ser 2D ou 3D

•2D –Panel, BorderPanel, TextArea, TextBox

•3D - Meshes

Elementos 2D podem ser agrupados em containers

Seções:

•Element

Elemento 2D que não agrupa outros elementos (TextArea,

TextBox) •Container

Elemento capaz de agrupar outros elementos 2D (Panel,

BorderPanel) •Entity

Objetos 3D

Scripts

// O nome do overlay MyOverlays/ANewOverlay { zorder 200 container Panel(MyOverlayElements/TestPanel) {

// Posiciona janela no meio da tela horizontalmente left 0.25 top 0 width 0.5 height 0.1 material MyMaterials/APanelMaterial } } TestPanel Materiais

Scripts

// O nome do overlay MyOverlays/Cockpit { zorder 100 entity cockpit.mesh(Carro/Cockpit) {

// Posicao e orientacao do objeto

position 000

rotation 0001

} }

Materiais

Scripts

// Mostrando um Overlay

Overlay *overlay = OverlayManager::getSingleton().getByName("MyOverlays/Cockpit"); overlay->show();

// Pega o elemento FPS (TextArea) OverlayElement* guiAvg =

OverlayManager::getSingleton().getOverlayElement("Core/AverageFps");

const RenderTarget::FrameStats& stats = mWindow->getStatistics();

// Atualiza com o novo valor do fps

guiAvg->setCaption("Fps = "+ StringConverter::toString(stats.avgFPS)); Materiais

Inicialização Programas Partículas Overlays Render-to-texture

Facilidades do Engine

Sombras

•Realismo na cena

•Percepção de distância

•Composição de ambientes Geração de Sombras Mouse Picking

(16)

Tipos de sombra disponíveis no OGRE

•Texture Modulative Usa texturas

Sombra com pouca resolução na imagem (pixelate)

•Stencil Modulative

Renderiza a partir dos volumes das sombras •Stencil Additive

Mais custosa

Renderiza cada luz num passo diferente

a b c d a. Stencil Additive b. Stencil Modulative c. Texture Modulative d. Nenhuma

Facilidades do Engine

Tipo de Sombras escolhido com

•SceneManager::setShadowTechnique

SHADOWTYPE_NONE

SHADOWTYPE_STENCIL_MODULATIVE

SHADOWTYPE_STENCIL_ADDITIVE

SHADOWTYPE_TEXTURE_MODULATIVE

O tipo das sombras deve ser escolhido no início da criação da cena

Malhas recebem um tratamento diferente ao serem carregadas

Pode-se desabilitar a geração de sombras em cada Entidade

•Entity::setCastShadows

Render-to-texture

Geração de Sombras Mouse Picking

Facilidades do Engine

Renderização de cenas em texturas

Simulação de reflexo do ambiente em um material

•Ex: carroceria de um carro Render-to-texture

Facilidades do Engine

Método baseado em RenderTargets

•RenderWindow

•RenderTexture

Um RenderTarget é associado a uma câmera

•O viewport determina que porção do RenderTarget será renderizada

Uma RenderTexture pode ser referenciada a partir do script de materiais

Render-to-texture

Facilidades do Engine

Passos para utilizar o RTT

1. Criação do material material RenderTextureMaterial { technique { pass { texture_unit { texture RTName tex_addr_mode clamp } texture_unit { texture fundoMaterial.jpg } } Render-to-texture

(17)

2. criação (no código) de um RenderTexture com o mesmo nome utilizado no script de material

3. adição de um viewport através de uma câmera que vai definir que parte da cena será renderizada no RenderTexture

4. aplicação do material criado em alguma entidade

RenderTexture* rttTex =

mRoot->getRenderSystem()->createRenderTexture( "RTName", 512, 512 );

Viewport *v = rttTex->addViewport( mCamera );

this->entity->setMaterialName("RenderTextureMaterial");

Seleção dos objetos da cena

Utilizada principalmente em editores 3D

Facilidades do Engine

O Picking é realizado pelo Objeto RaySceneQuery

Método SceneManager::createRaySceneQuery que recebe um Ray

RaySceneQuery deverá ser executado

Retorna lista do objetos interceptados pelo Ray

Render-to-texture

Facilidades do Engine

Como obter um Ray?

•Camera::getCameraToViewportRay Recebe a posição relativa onde o click ocorreu

Retorna um Ray resultante

(0.5,0.7)

Janela Render-to-texture

Facilidades do Engine

É realizado utilizando como base o AxisAlignedBox dos objetos

Forma bastante rápida, porém pouco precisa

Render-to-texture

Facilidades do Engine

// Cria o objeto RaySceneQuery

this->raySceneQuery = this->sceneManager->createRayQuery( Ray() ); ...

// Computa o raio originado da posição onde ocorreu o click do mouse Ray mouseRay=this->camera->getCameraToViewportRay(e->getX(),e->getY()); // Atualiza o RaySceneQuery com o novo raio

this->raySceneQuery->setRay( mouseRay ); // Executa o query

RaySceneQueryResult &result = raySceneQuery->execute(); RaySceneQueryResult::iterator itr;

// Percorrre a lista dos resultados

for ( itr = result.begin( ); itr != result.end(); itr++ ) {

// Faz com que objetos interceptados pelo raio fiquem invisiveis itr->movable->setVisible(false);

}

Render-to-texture

(18)

Modelo de Aplicação fornecido pelo OGRE

• Aplicação Básica

• Formas de interação padrão

Mouse

Teclado

Classes fornecidas

• ExampleApplication

• ExampleFrameListener

Tutorial – Engine Gráfico OGRE ExampleApplication

• Configura a inicialização, cria a janela, o viewport e outros componentes básicos para uma aplicação

• Permite que o usuário interfira apenas no que for necessário através da sobrecarga de algum método

Aplicação Básica

Métodos que podem ser sobrecarregados

• createScene (único obrigatório)

• createFrameListener • createCamera • chooseSceneManager • configure • createViewports • destroy • go

Aplicação Básica

ExampleFrameListener

• Implementação padrão da

interface FrameListener

• Possui recursos de

interação com a câmera e exibição de estatísticas

• A interação com a câmera

é feita através do teclado e mouse segundo a tabela ao lado

Pr Práática:tica: Exerc Exercííciocio

Tutorial Tutorial Engine

EngineGrGrááfico OGREfico OGRE

Autores Thiago Souto Maior mouse@cin.ufpe.br João Paulo Lima jpsml@cin.ufpe.br Veronica Teichrieb vt@cin.ufpe.br Judith Kelner jk@cin.ufpe.br