gb

GAME ENGINE DO BLENDER

http://ddj.orgfree.com

1. INTRODUÇÃO:

1.3 - Por que utilizar a engine Blender? Qual o seu potencial?

- Ambiente integrado, com modelador, animação e “game player”.

- Construção de objetos com Física aplicada (dinâmica de corpo rígido) e simulação de colisão. - De fácil interatividade com sensores predefinidos e outros blocos lógicos.

- Multiplataforma: Windows, Linux, FreeBSD, BeOS, Irix e mais...

1.4 - LÓGICA DE UM JOGO:

A figura abaixo mostra um objeto (o jogador) num cenário simples.

Esta seção corresponde a um pequeno tutorial que irá ensiná-lo a: - Ajustar os atributos dos objetos;

- adicionar blocos lógicos - conectar os blocos lógicos

- o uso básico de teclado, “Always” e “Touch Sensor” (sensor de toque)

Este documento não ensina como usar o Blender, a modelar ou fazer qualquer animação. Para estas informações, procure o manual ou os inúmeros tutoriais dispostos na internet.

Preparando:

Inicie o Blender e carregue o arquivo “B-Man1.blend”. Você pode usar a tecla F1 ou o menu “FILE” para carregar a cena. Com a cena já carregada, provavelmente você verá algo parecido com o screenshot abaixo:

A janela 3D a esquerda é uma “view” texturizada para a câmera. A janela direita é um frame do arame da observação do caracter “jogador” (player). Ele está selecionado, devido a sua coloração rosa.

A parte inferior é onde se encontra os botões com as funções (RealTimeButtons), você pode chamá-las com F8. É aqui que a maioria do trabalho de interatividade dos gráficos 3D no blender serão feitos.

Agora podemos iniciar a “gameEngine” movendo o cursor do mouse para a janela 3D e pressionando a tecla “P”. Com nós não definimos qualquer tipo de interatividade você vai ver as linhas de controle desaparecerem e o céu azul em vez de cinza. Pressione ESC para parar a “gameEngine” novamente.

Fazendo um ator “que cai”:

Agora clique com o botão esquerdo do mouse sobre o “ator” no “RealtimeButtons”.

Simplesmente ative o botão escrito “DYNAMIC”. Isto define par o objeto selecionado como um ator que ele será construído com atribuições de “Física” da “gameEngine” (ou seja, será um corpo que é afetado por uma gravidade). Se você acidentalmente tirar a seleção do jogador torne a selecioná-lo com o botão direito do mouse e recarregue a cena.

Atributos a serem ajustados para o objeto

Agora rode a “gameEngine” novamente. Pressione a tecla “P” com o mouse sobre o a janela com a opção “texturizada” e você verá o “jogador” cair sobre o terreno e saltar algumas vezes. Pressione ESC pra parar a engine.

Movendo o ator:

O “RealtimeButtons” estão logicamente divididos em quarto colunas. A coluna mais a esquerda é usada para ajustar os parâmetros que fazem o objeto “cair”. As outras três colunas são usadas para a construção das interatividades que acontecem em seu jogo.

Agora vamos mover o jogador pelo ambiente.

Existem três partes chamadas “Sensors” (Sensores), “Controllers” (controladores) e “Actuators” (atuadores). Você pode pensar os “Sensors” como uma forma de vida (que dá vida ao jogador), os controladores como o cérebro e os atuadores como a musculatura.

Agora pressione o botão “Add” para cada coluna uma vez com o botão esquerdo do mouse para fazer um “LodigBrick” (bloco lógico) para os sensores, controladores e atuadores.

Selecionando o tipo de “LogikBrick”.

O screenshot acima mostra os tipos de “LogicBricks” existentes. Clique no botão escrito “Always” e escolha “Kayboard”. Na versão 2.41 o screen é um pouco diferente do de cima, mas no geral é bem semelhante.

Agora clique com o botão esquerdo no interior da caixa fazia correspondente ao campo “key”. O texto “Press any key” aparece. Pressione a tecla que você deseja para mover seu personagem para frente (eu sugiro a seta para cima).

Agora nós temos como controlar o movimento. Nós vamos definiar como o jogador vai se mover. A primeira linha de números é chamada “FORCE” e define com que força será aplicada quando o controle de movimento estiver ativo. Os três numeros são as respectivas forças no eixo X, Y e Z.

Se olhar na malha do jogador você verá para onde o eixo X está apontando. Para mover para frente é necessário aplicar uma força “positiva” ao longo do eixo X. Para fazer isto basta clicar sobre o número com o botão esquerdo do mouse. Coloque o valor 10.00 para X.

Nos temos que fazer as ligações como foram exibidas no screenshot mais acima. Nos precisamos conectar através de linhas os blocos lógicos.

Clique e arraste com o botão esquerdo do mouse pressionado sobre a bola amarela do “Keyboard Sensor” e você observará uma linha preta, ligue esta linha preta no anel no controlador AND. Solte o mouse e agora os “LogicBricks” estão conectados. Agora conecte a bola amarela do controlador AND com o anel do controle de movimento (Motion Controller).

Para deletar uma conexão mova o mouse sobre a conexão. A linha irá ficar evidente e você poderá apagá-la pressionando a tecla X ou DELETE.

Agora pressione a tecla “P” para iniciar a “gameEngine” e então pressione a SETA PARA CIMA e você verá o jogador indo para frente ao longo do eixo X.

Mais controles:

Agora adicione mais “LogicBricks” como mostrado no screenshot abaixo. Estes “LogicBricks” vai permitir você mudar a orientação do personagem utilizando as teclas de setas. Note que a linha “Torque” do “Motion Actuator” produz um movimento de giro no jogador em torno do eixo especificado. No caso, o eixo Y.

Pulo:

Para adicionar mais graus de liberdade e também para mostrar mas um sensor como controle de entrada, iremos fazer o jogador pular.

Adicione o “LogicBricks” como exibido na figura acima para o jogador. O é ativado através do teclado. Mas existe também um outro sensor conectado ao controlador AND, é o sensor “Touch”. O controlador “Touch” somente dá um impulso no jogador quando o objeto está tocando algo. Esta correlação é lida da seguinte forma “Se a tecla A for pressionada E o jogador estiver tocando o terreno (ou piso), ENTÃO dê um impulso produzido pelo atuador de movimento”. Este caminho assegura que o jogador não vai dar um novo salto enquanto estiver no ar. Tente deletar a ligação do sensor “Touch” para o controlador AND e vejo o que acontece...

O controle para o pulo está conectado a dois “Motion Controllers”, ambos tem uma força de 100.00 para o eixo Z. Porque o valor 100.0 é o máximo para cada atuador de movimento, assim nós usamos dois atuadores para obter um impulso maior e produzir um pulo mais alto.

2 - A ENGINE:

Tecnicamente a “GameEngine” é uma central de trabalho com uma coleção de módulos para propósitos interativos como Física, gráficos, lógica, som e network. O funcionamento se processa num ambiente de realidade virtual, consistindo da construção de ambientes e comportamentos (como Física, animação e lógica). Os elementos deste ambiente – também chamado objetos do jogo (GameObjects) – comportam-se autônomamente após ajustes de uma ferramenta chamada “LogicBricks” e propriedades. Para refrescar a nossa memória, os “Sensors” são os sensores, os “Controllers” é o cérebro e os “Actuators” permitem que a ação aconteça, ou seja, são os “músculos” do objeto.

Até o momento “Controllers” podem ser scriptados usandos a linguagem python ou também expressões simples. A idéia é que a criação de blocos lógicos possam ser editados utilizando caminhos alternativos no futuro. “Controllers” podem ser mudado para determinados centros de controle, como o centro audio visual, centro de movimentação, etc..

2.2 - Opções da GameEngine:

Com este menu você pode mudar as opções durante a edição da cena. Correntemente somente a opção “Autostart” é salva com o arquivo.

Start Game (tecla P) :: Inicia a GameEngine.

Use vertex arrays :: Habilita (verifica) ou desabilita o uso de “vertex arrays”. VertexArrays

normalmente aumenta a velocidade de calculos complexos na cena. Se seu systema não suporta OpenGL vertexarrays você pode desabilitar a função.

Enable All Frames :: Esta opção verifica se a GameEngine roda em 50 Hertz sem “quebra” de

frames. Isto é útil enquanto “executa” para a “Targa-Sequence” ou quando necessita ter certeza que todas as colisões são calculadas sem perdas sobre computadores mais lentos.

Disable Sound :: Habilita e desabilita o som.

Disable Mipmaps :: Não use mipmap, isto pode aumentar a velocidade de processamento

(obviamente vai depender da máquina)

Autostart :: Habilita a iniciação automática ao ler o arquivo.

2.3 Opções em linha de comando para a GameEngine:

Quando o Blender é carregado com a opção –h na linha de comando (shell do Windows ou janela DOS) ele irá imprimir os parâmetros da linha de comando. Veja abaixo:

bash-2.00$ blender -h Blender V 2.12

Usage: blender [options ...] [file] Render options:

-b <file> Render <file> in background -S <name> Set scene <name>

-f <frame> Render frame <frame> and save it

-s <frame> Set start to frame <frame> (use with -a) -e <frame> Set end to frame (use with -a)<frame> -a Render animation

Animation options:

-a <file(s)> Playback <file(s)>

-m Read from disk (Don't buffer) Window options:

-w Force opening with borders

-p <sx> <sy> <w> <h> Open with lower left corner at <sx>, <sy> and width and height <w>, <h>

Game Engine specific options:

-g fixedtime Run on 50 hertz without dropping frames

-g vertexarrays Use Vertex Arrays for rendering (usually faster) -g noaudio No audio in Game Engine

-g nomipmap No Texture Mipmapping

-g linearmipmap Linear Texture Mipmapping instead of Nearest (default) Misc options:

-d Turn debugging on

-noaudio Disable audio on systems that support audio -h Print this help text

-y Disable OnLoad scene scripts, use -Y to find out why its -y bash-2.00$

-g fixedtime

Esta opção roda a engine em 50 hertz sem baixar os frames. Isto é útil enquanto “executa” para a “Targa-Sequence” ou quando necessita ter certeza que todas as colisões são calculadas sem perdas sobre computadores mais lentos.

-g vertexarrays

Desabilita o uso de vertexarrays. VertexArrays normalmente aumenta a velocidade de calculos complexos na cena. Se seu systema não suporta OpenGL vertexarrays você pode desabilitar a função.

-g noaudio

Desabilita o som.

-g nomipmap

Não usa mipmap. Isto pode aumentar a velocidade do jogo.

-g linermipmap

Ajusta o mipmapping de textura para Nearest (default).

2.4 - O “RealTimeButtons”:

O “RealtimeButtons” é o conjunto de botões que permite produzir interatividade entre os objetos 3D presente no ambiente no Blender. O Blender é uma ferramenta completa de desenvolvimento para interatividade no mundo virtual incluindo uma “gameEngine” para a criação de jogos. Tudo isso pode ser feito sem precisar compilar o jogo ou o cenário. Simplesmente pressione a tecla P e execute tudo em tempo real. Na janela principal de trabalho encontra-se o botão que dá acesso ao “RealtimeButtons” ( ). Aqui você definirá seus blocos lógicos (LogicBricks) e com isso o comportamento de seus objetos.

Informação: A palavra “games” (jogos) aqui é usa para todos os tipos de interatividade 3D. O Blender

não existe limitação quanto ao tipo de jogo que se deseja criar.

Os “RealtimeButtons” podem ser logicamente ser separados em duas partes. A parte à esquerda contém os ajustes globais para os objetos do jogo (gameObjects).

É nesta parte que inclui os ajustes geral para a física, como amortecimento (damping) ou massa do objeto. Aqui você pode definir se um objeto precisa ser calculado na cena com física, como um ator, ou se vai apenas fazer parte do cenário, formando o nível.

Ajuste para os objetos:

Actor

Ativando “Actor” para um objeto permite a gameEngine a avaliar este objeto. O botão “Actor” vai habilitar mais botões descritos mais abaixo. Um objeto sem “Actor” pode formar, fazer parte do cenário (como os suportes de um estágio) e são “vistos” por outros atores também.

Ghost

Um objeto “Ghost” não possui colisões, mais ainda possui “chave” de sensor de colisão. Ideal para criar algum tipo de evento.

Esta opção ativada faz com que o objeto esteja sujeito as leis da física. Esta opção habilita novos botões que permite definir os atribulos do objeto mais detalhadamente.

Rigid Body

O “Rigid Body” (corpo rígido) habilita a física avançada da gameEngine. Com isto é possível fazer esferas rolar automaticamente quando elas entram em contado com outros objetos e a fricção entre os materiais é diferente de zero. A dinâmica de corpo rígido deve ser aprimorada em versões futuras da gameEngine.

Do Fh

Este botão ativa o mecanismo “Fh”. Com esta opção você pode criar comportamente de vôo ou nado para atores. Um ator “voando” ou “nadando”.

Rot Fh

Com esta opção ajustada o objeto irá rodar em torno do ponto z semelhante (da mesma maneira) sobre o terreno quando usado o mecanismo Fh. (?)

Mass

A massa de um ator dinâmico como um “efeito” é a propriedade que permite especificar como a força será aplicada sobre ele. Note que não adianta aumentar a massa de um objeto para ele cair mais rápido que outro. É a resistência do ar que produz diferentes velocidades de queda (sem ar, todos os objetos irão cair da mesma maneira!). Use o valor “Damp” para simular a resistência do ar.

Size

É o tamanho da esfera limite. A esfera limite determina a área na qual a colisão irá ocorrer. Em versões futuras isto não será limitado a apenas esferas. Provavelmente isto já ocorre com a versão 2.41

Damp

Amortecimento geral para o movimento de um objeto. Use este valor para simular amortecimentos em objetos que estão no ar (como em queda) ou na água. No espaço, para simular ar, é preciso colocar valores baixos para o amortecimento. Para simular água, use valores mais altos.

RotDamp

Faz o mesmo que “Damp” mas para rotação do objeto.

Anisotropic

Quando atores movem-se sobre superfícies você pode definir o atrito entre os objetos. O atrito irá tornar os objetos mais lentos, porque sempre haverá uma força contrária a existente sobre o objeto e que o impulsiona para frente devido ao contato com a superfície. Ele é controlado no ajuste de material dinâmico (dynamic material settings). Este atrito trabalha igualmente em todas as direções do movimento.

Com o “Anisotropic” ativado você pode controlar o atrito independentemente para cada eixo. Isto é muito usual em jogos de corrida, onde por exemplo o carro recebe diferentes atritos dependendo do tipo de curva ou situação em que apresenta.

Segue abaixo os ajustes que definirão as propriedade do objeto (gameObject). Estas propriedades podem conter valores que descrevem atributos do objeto como variáveis numa linguagem de programação. Use o botão ADD para adicionar propriedades.

A verdade é que o “RealtimeButtons” é o centro de comendo para adicionar a lógica para seus objetos e ambiente. A lógica consiste de sensores (Sensors), Controllers e Actuators.

“Sensors” são como sensores de uma forma de vida. Eles reagem a tecla pressionadas, colisões, contatos com materiais (touch), eventos com o tempo (timer events) ou valores de propriedades.

Os controladores estão coletando eventos dos sensores e são capazes de calcular então o resultado. Os controladores são o “cerebro” das operações. Controladores simplesmente fazem um “E” (AND). Um exemplo é o teste se uma tecla foi pressionada “E” (AND) um certo tempo passou. Há também o controlador “OR” e você pode usar script em python e expressões para criar comportamentos mais complexos.

Os atuadores produzem as ações nos objetos. Um atuador de movimento (Motion Actuator) é como um músculo. Um “músculo” pode aplicar força nos objetos para movê-los ou girá-los. Existem atuadores para executar animações pré-definidas (via IPOs), que podem ser comparadas como um reflexo.

A lógica é conectada por linhas usando o mouse, “Sensors” para “Controllers” e “Controllers” para “Actuators”. Feito tudo isso corretamente você será capaz de rodar o jogo imediatamente! Se descobrir algo no jogo que não está do seu agrado, basta parar a gameEngine, editar o ambiente 3D e reiniciar e assim por diante. Este caminho pode reduzir drasticamente o tempo de desenvolvimento além de ser mais confortável!!!

2.5 - Propriedades:

Propriedades carregam informações limites para o objeto, similar a variáveis locais em linguagens de programação. Nenhum outro objeto pode normalmente acessar estas propriedades, mas é possível copiar propriedades com “Property Copy Actuator”.

O botão “ADD property” adiciona uma nova propriedade. Por default, uma propriedade adicionada é do tipo “float”. Detele um a propriedade com o botão “Del”. O “MenuButton” difine o tipo de propriedade. Clique e com o botão esquerdo do mouse escolha no menu o tipo que deseja. O “Name:” o texto pode ser editado clicando com o botão esquerdo do mouse sobre ele. SHIFT-BACKSPACE apaga o nome.

Informação: O nome da propriedade é “case sensitive”, desta forma, “casa” é diferente de “Casa”.

O próximo campo é diferente para cada tipo de propriedade. Para o tipo booleano são dois botões a escolher: “True” e “False”. O tipo string aceita cadeia de caracteres. Entre com uma string clicando no campo com o botão esquerdo do mouse. Os outros tipos usam números para definir um certo valor. É possível editar com teclado ou arrastando o mouse.

Tipos:

Boolean (Bool)

Esta propriedade armazena um valor binário, ele pode ser “True” ou “False”.

Integer (Int)

Armazena números como 1, 2, 3, 4, ... na faixa de -2147483647 a 2147483647.

Float

Armazena um número de ponto flutuante.

String

Armazena uma cadeia de caracteres.

Timer

Este tipo de propriedade faz um “update” (atualização) com o atual tempo do jogo em segundos, iniciando do zero.

2.6 - Ajuste no MaterialButtons:

Alguns atributos físicos podem ser definidos com o ajuste de material no Blender. O “MaterialButtons” pode ser acessado via o ícone . Crie um novo material ou escolha um existente com o botão no menu. No “MaterialButtons” você precisa ativar o botão “DYN” para ver os ajustes dinâmicos (de dinâmica).

Restitut

Este parâmetro controla a elasticidade das colisões. Um valor igual a 1.0 irá converter toda energia cinética em energia elástica, ou seja, será restituído em força igual e oposta. Este objeto tem então uma elasticidade ideal. Um “Restitut” igual a um fará o objeto quicar indefinidamente sobre o terreno.

Friction

Este valor controla o atrito do objeto. Se o atrito é baixo, seu objeto vai deslizar como no gelo, se é alto terá um efeito tipo “cimento”.

Fh Force

Em conjunção com “Do Fh” e/ou “Rot Fh” faz o objeto flutuar sobre uma superfície. “Fh Force” controla a força que sustenta o objeto sobre o terreno (superfície).

Fh Dist

“Fh Dist” controla o tamanho da área “Fh”. Quando o objeto entra nesta área o mecanismo “Fh” começa a trabalhar.

Fh Damp

Controla o “arrasto” dentro da área “Fh”. Valores acima de 0.0 vai causar um “arrasto” no movimento do objeto dentro da área “Fh”.

Fh Norm

Com este botão ativado o objeto simplesmente sentirá uma força na direção da normal da face do terreno. Isto irá causar um efeito no objeto que o fará descer uma rampa ou ladeira. (Veja FhDemo.blend)

2.6.1 - Ajuste de especularidade da gameEngine:

Spec

Ajusta o controle de intensidade de especularidade.

Hard

Ajusta o controle do tamanho da especularidade.

Spec color

Ativando este botão, você habilita os ajustes RGB ou HSV para definir a cor da especularidade.

Luzes podem ser criadas pressionando ESPAÇO -> ADD Lamp. Para uma lâmpada selecionada é possível abrir as suas propriedades. Estas propriedades são a cor, a energia, etc... A GameEngine é totalmente integrada no Blender, existem alguns botões que são somente usuais para animações lineares.

Um ajuste comum a todos os tipos de lampadas é a energia e a cor (ajustável com RGB).

Para permitir uma face a receber luz em tempo real na GameEngine do Blender a face precisa estar ajustada para “Light” no Paint/FaceButtons. Com a camada (Layer) ajustada para a luz e objetos é possível controlar a luz precisamente. Luzes somente afetam faces sobre a mesma camada. Por camada é possível usar 8 luzes (limitação do OpenGL) para luzes em tempo real.

Tipos de luzes da GameEngine:

Lamp

“Lamp” é uma fonte de luz puntiforme.

Spot

É uma lâmpada restrica a um espaço cônico. Na janela 3D é possível ver as linhas do cone. Use “SpotSi” para ajustar o ângulo de “visão” da luz.

Sun

É um tipo de luz direcional. A distância não afeta sua intensidade. A luz direcional é exibida com uma linha que mostra a sua direção.

Hemi

A luz “Hemi” não é suportada pela game engine. (Este manual é antigo, de 2001! Provavelmente a nova versão da engine 2.41 de 2006 já deve dar suporte a este tipo de luz. É bom conferir).

As luzes “Lamp” e “Spot” são sensíveis com a distância. Use “Dist:”, “Quad1:” e “Quad2:” para ajustar isto.

2.8 - O Blender e as Leis da Física:

Todos os objetos no Blender com a opção “Dynamic” são avaliados com as Leis da Física e definidos pela engine para usá-las.

As propriedade chave para um objeto dinâmico é a sua massa. Gravidade, força e impulsos (limite de colisão) somente trabalham com objetos que possuem massa. Desta forma, somente objetos dinâmicos podem experimentar algum tipo de arrasto, ou velocidade de amortecimento (como o que ocorre com o ar ou resistência da água).

Observação: Note que objetos dinâmicos usando “dLoc” e “dRot” não apresenta resultados desejados.

Uma vez que um objeto dinâmico é controlado por forças e impulsos, qualquer mudança explícida de posição ou orientação de um objeto pode não corresponder com a velocidade. Para objetos dinâmicos é melhor utilizar “linV” e “angV” para explicitar definições de movimento.

Como definimos uma massa para seu objeto dinâmico ele será afetado pela gravidade, causando sua queda no ambiente até encontrar outro objeto com limite para colisão já que o objeto dinâmico possui um limite esférico para colisão. O tamanho da esfera-limite pode ser modificado no parâmetro “Size:”. O valor da gravidade por default está ajustado para 9.81. Você pode modificá-la no “WorldButtons” com o deslizante “Grav”. Uma gravidade zero é muito útil para jogos espaciais ou simulações!

Informação: Use os ajustes “Damp:” e “RotDamp:” para a resistência do ar ou simular outros

ambientes. Não use estes ajustes para simular atrito! O Atrito (Friction) pode ser simulado usando os ajustes de material dinâmico (dynamic material).

Objetos dinâmicos possuem limite por duas razões. Ambos tem “Do Fh” habilitado e tem pequeno arrasto (damping), ou você está usando um valor “Restitut” no material dinâmico (dynamic material) que é bem alto.

Se você não definir um material, por default a restituição será 1.0. Este é o valor máximo para a restituição e ele irá produzir um efeito bastante interessante pois o objeto ficará quicando indefinidamente no piso (elasticidade perfeita!)

No primeiro caso, incrementando um “arrasto” (damping) pode-se reduzir os quiques! No último caso define-se um material para o objeto e ajusta-se o seu valor de restituição para um número menor que 1.0. O valor de restituição determina a elasticidade do material. Um valor igual a zero determina que a velocidade de afastamento depois da colisão será nulo, ou seja, será um choque inelástico. Um valor igual a 1.0 faz com que o momento seja conservado mesmo depois da colisão.

O Damping (arrasto) irá decrementar a velocidade em % por segundo. Damping é usual para estabelecer uma velocidade máxima. Um valor alto diminui a velocidade do objeto drasticamente. A velocidade máxima é alcançada quando a força que tende a acelerar o objeto é igual a sua desaceleração provocada pela força de arrasto. Damping é usual para produzir também oscilações amortecidas.

Friction (atrito) é uma força tangente ao contato entre as superfícies dos objetos. A força de

atrito possui um valor máximo que é proporcional a normal, isto é, a força que pressiona os objetos uns contra os outros. Esta proporcionalidade é denota o coeficiente de atrito. Um valor alto para a força de atrito irá permitir um valor alto para o atrito máximo. A “regra” para o movimento obedece as leis da resultante de forças, ou seja, se a força aplicada for menor que o atrito máximo, o objeto não se move. Se for igual, ele fica na eminência do movimento, se for maior o objeto se move. Se no movimento a força for igual a força de atrito cinético, o objeto se move com velocidade constante.

Para alguns objetos é necessário ter diferentes atritos em direções diferentes. Por exemplo, um skate possui pouco atrito quando se move para frente ou para trás, mas um atrito relativamente alto quando se move para os lados. Isto é chamado “anisotropic friction” (atrito anisotrópico). Selecionando o botão “Anisotropic” no “RealTimeButtons” irá habilitar o atrito anisotrópico. Depois de selecionar este botão, três barras deslizantes vão aparecer com o coeficiente relativo para cada eixo local a ser ajustado. Um coeficiente de atrito ao longo de um eixo igual a zero significa que ao longo desse eixo o atrito é zero. Um coeficiente de atrito igual a 1 significa que o atrito máximo é aplicado no dado eixo.

2.9 - EXPRESSÕES:

Expressões válidas

Expression type Example

Integer numbers 15 Float number 12.23224

Booleans TRUE, FALSE

Strings "Eu sou uma string!"

Properties propname

Expressões aritméticas

Expression Example

EXPR1 + EXPR2 Addition, 12+3, propname+21 EXPR1 - EXPR2 Subtraction, 12-3, propname-21 EXPR1 * EXPR2 Multiplication, 12*3, propname*21 EXPR1 / EXPR2 Division, 12/3, propname/21 EXPR1 > EXPR2 EXPR1 greater EXPR2

EXPR1 >= EXPR2 EXPR1 greater or equal EXPR2 EXPR1 < EXPR2 EXPR1 less EXPR2

Operações booleanas

Operation Example

NOT EXPR Not EXPR

EXPR1 OR EXPR2 logical OR EXPR1 AND EXPR2 logical AND

EXPR1 == EXPR2 EXPR1 equals EXPR2

Declarações condicional: IF( Test, ValueTrue, ValueFalse )

Exemplos de expressões:

Expressão Resultado Explicação

12+12 24 Adição

property=="Carsten" TRUE or

FALSE String comparação entre uma propriedade e uma string "Erwin">"Carsten" TRUE Comparação entre Strings

2.10 - Botões de som:

Os “SoundButtons” ( ) são usandos para carregar e gerenciar sons na gameEngine.

No “SoundButton” é possível chamar sons como é visto no screenshot acima (o som, no caso, tem nome: MiniGunFire.wav). Este nome é ajustado para o nome do som sample por default. Com o

“MenuButtons” você pode abrir um som existente e criar um novo “SoundObjects”. A cor azul indica que mais de um usuário está utilizando o som, o número indica o número de usuários.

O “NumberButton” indica quantos “SoundObjets” partilham o exemplo. Quando o botão “pack/unpack” é pressionado, o “sample” é empacotado dentro do arquivo *.blend. Isto é muito importante quando for distribuir arquivos, já que não é necessário ter os arquivos de sons em separado. Tudo fica embutido dentro do próprio arquivo do blender.

O botão “Play” obviamente toca o som e o botão “Loop” ajusta se o som irá tocar uma única vez ou se vai executar repetidamente. Dependendo do “play-mode” no “Sound Actuator” este ajuste pode estar “não disponível”.

A barra de ferramenta “Vol:” ajusta o volume global do som.

Pitch: com o “pitch” você pode mudar a frequência do som. Atualmente ele suporta valores

entre -12 semitons a +12 semitons. Em Hertz: se seu “sample” possui frequência de 1000Hz, o “baixo” possui 500Hz e o “alto” 2000Hz.

A próxima linha de botões vai definir o som 3D. Com o botão “3D vol” ativado (se desativar “Fixed”) você habilida o som 3D. Esta medida de volume do som depende da distância entre a fonte sonora e o observador. O observador é a câmera ativa!!!

O botão deslizange “Attn:” ajusta a atenuação do som. No mundo 3D você pode escalar a relação entre avanço e distância. Por exemplo, se um som passar pela câmera você deseja ajustar o fator que determina como o som vai se comportar quando passa por você (observador – câmera).

A próxima linha de botões define a posição estéreo do som. Com “3D pan” ativado o volume do canal direito e esquerdo do som vai depender da posição relativa do ouvinte. Quando “Fixed” está ativado você pode manualmente ajustar o som com o botão deslizante “Pann:”

A janela de som é usada para visualizarmos o som, ou seja, sua forma de onda. A barra verde indica a posição do som que está sendo executada. Isto pode ser usado para sincronizar o som com uma animação IPO. A parte inferior da janela mostra a duração do som em segundos.

2.12 - Performance e design visando a otimização para o melhor resultado:

Os computadores tem se tornado cada vez mais velozes. Mas ainda sim algumas performances devem ser buscadas na hora de se criar o design do game para que o framerate mantenha constante e o jogo não fique lento e desagradável ao jogar. Isto não é somente um bom estilo em design e programação mas simplesmente essencial para a plataforma que o programa irá rodar e que o Blender é capaz de fornecer. Assim, ao criar um jogo, tendo em vista as diversas plataformas, tenha em mente algumas regras importantes de otimização:

1] Originalmente para um “AddObject Actuator” precisa estar em uma camada invisível (muito importante, talvez você vai usar isto regularmente no futuro).

2] Não utilize propriedades em combinação com controladores AND/OR/Expr com a linguagem de script. Existe um controlador python.

3] não “divida” (reparta) variáveis (pyhon) entre scrips.

4] Use poucas interligações entre conecções “LogicBrick”, se possível.

5] Use ALT-D (instância de malha para novos objetos) quando for fazer uma réplica, isto é melhor do que SHIFT-D (copia da malha).

6] polígonos com mapeamento “alpha” são expansivos, assim use com moderação.

7] A “bandeira” (flag) para colisão estando desligada melhora bastante a performance. O uso de “ghost” é econômico quando comparado com um objeto “físico” regular.

8] Use o menor número de polígonos possível. É muito fácil adicionar polígonos a um modelo, no entanto, remover polígonos sem distorcer o modelo é difícil. Procure enriquecer os detalhes cobrindo a malha com uma boa textura.

9] Mantenha a resolução das texturas o mais baixo possível. Você pode trabalhar com versões em alta-resolução e então reduzi-las quando for publicar o jogo (veja UV Texturing).

10] Polígonos ajustados para “Light” são expansivos. Um acelerador de hardware irá trabalhar bastante com calculos de transformações e luzes. Use somente se for necessário e verifique sempre a

performance.

11] No lugar de luz em tempo real use “VertexPaint” para iluminar, escurecer ou pintar faces como sugestão de situações de luzes. Bastante útil e criativo!

3 - GAME LogikBricks:

A lógica do jogo no GameBlender está situada no “RealtimeButtons”. Aqui é possível ligar diferentes “LogicBricks” (bloco lógicos) juntos. A seguir serão descritos todos os blocos lógicos usados pela engine.

3.1 - SENSORS:

Sensors atuam como sensores realmente. Eles pode detectar colisões, tato (toque), olfato (perto, proximidade), visão (raio, radar).

Tipos de sensores (Sensors):

3.1.1 - Always

Este é o sensor mais básico da engine. Ele executa uma tarefa continuamente. Por exemplo, uma peça que fica girando no cenário pode ser criada usando este recurso (como as moedas que giram e devem ser coletadas)

O botão [x] deleta o sensor da lógica do jogo (gameLogic). Isto acontece sem confirmação, portanto, tome cuidado! O botão a direita do botão de deletar permite a escolha do tipo de sensor (no screenshot acima o sensor é “Always”). Clique sobre ele e irá aparecer uma lista de sensores. O próximo botão é o botão do nome do sensor. O Blender assume um nome automaticamente no momento da criação do sensor, mas você pode renomeá-lo a vontade.

Informação: Nomeie seus “LogicBlicks” e os objetos no Blender para facilitar a manutenção de suas

cenas. Um esquema gráfico pode se tornar complexo demais.

Com a pequena seta laranja é possível “minimizar” a janela do bloco lógico. É muito útil quando o esquema lógico se torna mais complexo.

A próxima linha de botões é usada para determinar com que frequência o sensor está “atirando”. Este é um tópico mais complexo, daremos exemplos mais adiante nesta documentação. Informações gerais sobre pulsos:

Pulsos são formas de sensor chave em ambos “Controllers” e “Actuators”. Um pulso pode ter dois valores, TRUE e FALSE.

Cada controlador é sempre avalisado quando ele recebe um pulso, se o pulso for TRUE ou FALSE isto não vem ao caso. A entrada “gate” de um controlador lembra o valor do último pulso. Isto é necessário para que os controladores iniciem a ligação de múltiplos sensores, então ele pode ainda fazer uma operação lógica AND ou OR sobre todas as entradas. Quando um controlador está chaveado, e depois da avaliação de todas as entradas, ele pode decidir entre executar um script interno ou enviar um pulso para os atuadores.

Um atuador reage a um pulso de maneira diferente, com pulso TRUE ele é chaveado em ON (torna-se ativo), com FALSE ele é chaveado em OFF.

botão de modo de pulso.

O primeiro botão ativa o modo de pulso positivo. A todo momento o sentor “atira” um pulso e ele é um pulso positivo. Isto pode ser usual, por exemplo, mas iniciar um movimento com um “Motion Actuator”. O próximo botão ativa o modo de pulso negativo, isto pode ser usado para parar o movimento.

Informação: se nenhum modo de pulso estiver ativado o sensor “Always” irá “atirar” somente uma

O botão de nome “f:” (no caso do screenshot acima, está ajustado para 41), determina o delay (retardo) entre dois pulsos pelo sensor. O valor de “f:” é dada em frames.

O botão “Inv” inverte o pulso, se é positivo (TRUE) vai se tornar negativo (FALSE) e vice-versa. Veja o exemplo “pulses.blend”.

3.1.2 - Keyboard:

O sensor “Keyboard” é, talvez, um dos sensores mais usados porque ele provê uma interface entre o Blender e o usuário (mais adiante falaremos da entrada através do mouse).

Os botões de modo de pulso são comuns para todos os sensores e possuem a mesma funcionalidade descrita no sensor “Always”.

Ativando o botão “All keys” o sensor vai reagir com qualquer tecla. No campo “Hold” você pode por chaves de modificação.

Metodos python:

setKey(int key);

Ajusta a tecla que o sensor vai reagir.

Int key getkey();

Captura a tecla que o sensor reagiu.

setHold1(int key);

Ajusta o modificador chave um.

Int key getHold1();

Captura o modificador key one.

setHold2 (int key);

Ajusta o modificador tecla dois.

setUseAllKeys(bool all);

Ajusta a opção “All keys” para todas=TRUE

Bool all getUseAllKeys();

Captura o estado da opção “All Keys”

List keys getPressedkeys();

Captura uma lista das teclas pressionadas;

List events getkeyEvents();

Captura uma lista dos eventos das teclas.

3.1.3 - Mouse:

O sensor mouse inclui os botões usuais presentes nos mouses. O propósito principal desse sensor é obviamente criar uma interface entre o usuário e o aplicativo através do mouse. Atualmente o sensor é capaz de “vigiar” os cliques ou movimento do mouse. Para capiturar a posição atual do ponteiro do mouse será preciso usar um scripth Python. Isto será tratado mais adiante neste documento.

Metodos python:

Int xposgetXPosition();

Captura a posição x do mouse.

Int yposgetYPosition();

Captura a posição y do mouse.

3.1.4 - Touch:

O sensor “Touch” “atira” um pulso quando o objeto está designado para tocar um material. Se você entrar com um nome no campo “MA:” então ele somente reage para o material correspondente ao nome caso contrário irá reagir a todos os materiais. Isto é muito útil para ativar efeitos para materiais específicos. Por exemplo, o personagem deve morrer ou ter o “life” abaixado de um dado valor se tocar no material lava.

Metodos python:

setTouchMaterial( (char* matname));

Ajusta o material na qual o sensor “Touch” vai reagir.

Char* matname getTouchMaterial();

Captura o material que o sensor ‘Toch’ reagiu.

gameObject obj getHitObject();

Retorna o objeto que foi tocado.

List objs getHitObjectList();

Retorna uma lista dos objetos que foram tocados. Veja o exemplo ‘touch.blend’.

3.1.5 - Collision:

O sensor “Collision” é um sensor geral usado para detector o contato entre dois objetos. Além disso reage sobre materiais e é simplesmente capaz de detectar propriedades de um objeto. Entretando você pode escolher (comutar) o campo de entrada do material para propriedade clicando sobre o botão “M/P”.

Metodos python:

setTouchMaterial( (char* matname) );

Ajusta o material de colisão na qual o sensor irá reagir.

Char* matname getTouchMaterial();

Captura o material de colisão que o sensor reagiu.

setProperty( (char* propname) );

Ajusta as propriedades do sensor colisão.

Char* propname getProperty();

Captura a propriedade de colisão da reação do sensor.

gameObject obj getHitObject();

Retorna o objeto que está colidindo.

List objs getHitObjectList();

Retorna a lista de objetos que colidiram. Veja o exemplo ‘collision.blend’.

3.1.6 - Near:

O sensor “near” reage a aproximação dos atores ao objeto com o sensor.

Informação: O sensor de proximidade (near) somente “sente” objetos do tipo “Actor” (um objeto

dinâmico é um “actor”).

Se o campo “Property:” estiver vazio, o sensor de proximidade irá reagir a todos os atores na faixa. Se o campo tiver um nome para a propriedade, o sensor irá reagir somente sobre atores que possuem a propriedade do nome.

A faixa (esférica) do sensor de proximidade é ajustada com o botão “Dist”. O valor “Reset” define que o valor da distância do sensor de proximidade é resetado novamente. Isto é muito útil para impedir multiplos pulsos quando um ator está justamente na distância “Dist”, ou para abrir uma porta a uma certa distância mas fechar em outra distância diferente. Veja o esquema de pulsos do sensor:

Métodos python:

setProperty( (char* propname) );

Ajusta a propriedade do sensor de proximidade para reagir.

Char* propname getProperty();

Captura a propriedade que o sensor de proximidade reagiu.

Exemplos de use de sensor de proximidade podem ser aplicados a inimigos quando o jogador se aproxima, uma porta abrir, etc...

3.1.7 - Radar:

O sensor “Radar” funciona como um radar real. Ele observa um objeto em terno dos eixos indicados com os botões “X, Y, Z”. Se uma propriedade for digitada no campo “Prop:”, ele somente reage a objetos que possuem esta propriedade.

No campo “Ang:” você pode entrar com o ângulo de abertura do radar. Este ângulo é equivalente ao ângulo de visão de uma câmera. O ajuste “Dist:” determina a distância em que o sensor radar é capar de “ver”.

Objetos não bloqueiam a linha do sinal do sensor radar. Isto é diferente do sensor “Ray” (veja mais adiante). Você pode combinar ambos para fazer um radar que não é capaz de “ver” atraves de objetos, um muro, por exemplo.

3.1.8 - Property:

O sensor “Property” logicamente verifica uma propriedade “ligada” (atada) a um mesmo objeto.

O sensor ‘property’ do tipo “Equal” verifica a igualdade da propriedade dada no campo “Prop:” e o valor dado no campo “Value:”. Se a condição for verdadeira, ele “atira” um pulso de acordo com o ajuste do modo de pulsos.

O “Not Equal” verifica a “inegualdade” e então atira os pulsos.

A propriedade tipo “Interval” atira seus pulsus se o valor da propriedade estiver dentro do intervalo definido por “Min:” e “Max:”. Este tipo de sensor é especialmente usual para verificar valores flutuantes (que mudam). Isto é mais comum com a propriedade “Timer”.

A propriedade “Changed” emite pulsos toda vez que a propriedade é chamada. Isto, por exemplo, acontece, apesar de que, uma propriedade “Actuator”, um script python ou uma expressão (? – a traduzão está confusa aqui)

Metodos python:

SetProperty( (char* propname) );

Ajusta a propriedade para verificar.

Char* propname getProperty();

Captura a propriedade para verificar.

setType( (int type) );

Ajustes do tipo do sensor propriedade. 1] Equal

2] Not Equal 3] Interval 4] Changed

SetValue( ( char* expression) );

Ajusta o valor para verificar (uma expressão).

Char* expression getValue();

Captura o valor para verificar (uma expressão). Veja o exemplo ‘property.blend’.

3.1.9 - Random:

O sensor Random atira um pulso randomicamente de acordo com o ajuste de pulsos (50/50 pick).

Informação: Com o “seed” igual a 0 (zero) o sensor Random trabalha exatamente como o sensor

“Always”. Escolha 0 (zero) para não randômico!

Metodo python:

SetSeed( (int seed) );

Ajusta o “seed” para a geração randômica.

Int seed getSeed();

Captura o “seed” para o sensor “Random”. Int seed getLastDraw();

Captura o ultimo “draw” (desenho, configuração) do sensor “Random”. Veja o exemplo random.blend!

3.1.10 - Ray:

O sensor “Ray” lança um raio para a uma dada distância determinada pelo botão “Range”. Se o raio tocar um objeto com a propriedade correta ou o material ajustado o sensor atira um pulso.

Sem um nome para o material ou propriedade, o sensor reage a todos os objetos.

Métodos python:

List [x,y,z] getHitPosition();

Retorna a posição onde o raio tocou o objeto.

List [x,y,z] getHitNormal();

Retorna o vetor normal de como o raio interceptou o objeto.

List [x,y,z] getRayDirection();

Retorna o vetor da direção do raio.

gameObject obj getHitObject();

Retorna o objeto da interceptado. Veja o exemplo “ray.blend”!

3.2 - CONTROLADORES:

Controladores agem como o “cérebro” da lógica do seu jogo. Este reage a decisões simples como conexões de entradas, reage a expressões complexas ou a scripts python que permite a criação de eventos mais complexos como a inteligência artificial.

Tipos de controladores:

3.2.1 - AND:

O controlador AND combina uma, duas ou mais entradas de sensores. Todas as entradas precisam estar ativas (serem válidas, verdadeiras) para poder passar pelo controlador.

Veja o exemplo ‘and.blend’.

3.2.2 - OR:

O controlador OR combina uma, duas ou mais entradas de sensores. O controlador deixa o pulso passar se uma ou mais entradas forem válidas (ativas).

3.2.3 - Expression:

Com o controlador expressão (Expression Controller) você pode criar lógicas um pouco mais complexas para o jogo com uma linha simples de “código”. É possível acessar a saída dos sensores ligados para o controlador e acessar as propriedades dos objetos.

Informação: O mecanismo de expressão imprime saídas de erros na janela do console DOS caso

alguma falhe.

Veja o exemplo ‘expression.blend’.

3.2.4 - Python:

O controlador Python é o controlador mais poderoso da gameEngine. É possível ligar um script Python a ele, que permite a você criar controlar seus objetos do jogo (gameObjects) desde um simples movimento de corrida até complexos movimentos programados para simular inteligência artificial.

Digite o nome do script que você deseja ligar ao controlador python no campo “Script:”. O script precisa existir na cena, caso contrário, o Blender vai ignorar o nome que digitou.

Observação: Nomes no Blender são “case sensitive”! Assim, um script “player” é diferente de

“Player”!

Métodos python:

Actuator* getActuator( char* name , );

Retorna o atuados com “name”.

List getActuators();

Retorna uma lista python de todos os atores conectados.

Sensor* getSensor( char* name , );

Retorna o sensor com “name”.

List getSensors();

3.3 - ATUADORES:

Atuadores são blocos lógicos de execução. Eles podem ser comparados com “músculos” que dão vida aos objetos.

Tipos de atuadores:

3.3.1 - Motion:

O atuador de movimento é sem dúvida o atuador mais importante. Ele move, produz rotação ou aplica velocidade em objetos.

Um caso simples de uso do atuador de movimento é, obviamente, para mover objetos. Isto é feito com o valor “dLoc” na terceira linha. Toda vez que o atuador é ativado por um impulso ele move o objeto uma dada quantidade colocada em “dLoc”. Existem três valores correspondendo aos eixos X, Y e Z. Assim quando você entra com um valor 1.0 no primeiro campo o objeto será movido de uma unidade por vez no game (o relógio na gameEngine produzem “ticks” de 1/25 segundos).

O botão chamado “L” entre cada linha do atuador de movimento determina se o movimento aplicado precisa ser tratado como global ou local. Se o botão estiver pressionado (verde escuro) o movimento é aplicado baseando-se nos eixos locais do objeto. Se o botão não estiver pressionado o movimento é aplicado baseado na orientação global (do mundo).

Force:

Os valores desta linha aplica forças no objeto. Isto trabalha somente com objetos dinâmicos.

Torque:

Os valores desta linha agem com forças que produzem movimento de rotação (torque). Trabalha somente com objetos dinâmicos. Valores positivos gira o objeto no sentido horário.

dLoc

Move o objeto como já foi explicado anteriormente.

dRot

Gira o objeto de um dado ângulo (36 é rotação total, completa)

linV

Ajusta a velocidade do objeto para um dado valor.

angV

O atuador de movimento inicia o movimento do objeto quando recebe um pulso (TRUE) e para quando recebe um pulso (FALSE). Para “pegar” um movimento numa certa distância, é preciso enviar um pulso FALSE para o atuador sempre.

Metodos python:

setForce ( list [x,y,z] , bool local );

Ajusta o parâmetro “Force” (força) para o atuador de movimento.

List [x,y,z] getForce( );

Captura o parâmetro “Force”do atuador de movimento.

setTorque( list [x,y,z] );

Ajusta o parâmetro “Torque” do atuador de movimento.

List [x,y,z] getTorque( );

Captura o parâmetro “Torque” do atuador de movimento.

setdLoc( list [x,y,z] );

Ajusta o parâmetro dLoc do atuador de movimento.

List [x,y,z] getdLoc( );

Captura o parâmetro dLoc do atuador de movimento.

setdRot( list [x,y,z] );

Ajusta o parâmetro dRot do atuador de movimento.

List [x,y,z] getdLoc( );

Captura o parâmetro dRot do atuador de movimento.

setLinearVelocity( list [x,y,z] );

Ajusta o parâmetro linV do atuador de movimento.

List [x,y,z] getLinearVelocity( );

Captura o parâmetro linV do atuador de movimento.

setAngularVelocity( list [x,y,z] );

Ajusta o parâmetro angV do atuador de movimento.

List [x,y,z] getAngularVelocity( );

Captura o parâmetro angV do atuador de movimento.

3.3.2 - Constrait:

Com o atuador Constraint é possível limitar a liberdade de um objeto de um certo grau.

Com o “MenuButton” você especifica o canal de que liberdade deseja limitar, por exemplo, eixo X, Y ou Z (no screenshot acima, está travado o eixo Y). Com o “NumberButtons” “Min” e “Max”

é definido os valores mínimos e máximos para o valor dos limites do movimento. Para limitar um objeto em mais de um canal simplesmente use mais de um atuador Constraint.

Metodos python:

setDamp (int damp); int damp getDamp( ); setMin (int min); int min getMin( ); setMax( int max); int max getMax ( ); setMin (int min); int min getMin( ); setLimit (? Limit ); int limit getLimit( );

3.3.3 - IPO:

O atuador IPO executa uma animação de “IPO-curves” para um objeto. Se o objeto possui um filho (child) com um IPO e você ativar o “Child” no atuador, o IPO vai executar a animação do Child.

Modos IPO suportados pela engine:

Play

Executa o IPO do frame inicial determinado por “Sta” até o frame final determinado por “End” toda vez que um pulso positivo atinge o atuador. Qualquer outro pulso enviado durante a execução será desconsiderado.

Ping Pong

Executa o IPO do frame inicial “Sta” para o frame final “End” ao primeiro pulso positivo que atinge o atuador. O proximo pulso recebido irá executar o IPO de “End” até “Sta”.

Flipper

Executa o IPO enquanto o pulso for positivo. Quando o pulso for negativo (nenhum é enviado) o IPO é executado do frame corrente até o frame “Sta”.

Loop Stop

Executa o IPO em loop a enquando o pulso for positivo. Ele para na posição corrente se o pulso for negative (cessar).

Loop End

Executa o IPO repetidamente enquanto existir um pulso positivo. Quando o pulso para ele continua a executar o IPO até atingir o final do loop e então para a execução.

Property

Executa o IPO para o frame indicado na propriedade digitada no campo “Prop:”

Atualmente os seguintes IPOs são suportados pela gameEngine:

Mesh Objects

Loc, Rot, Size e Col

Lamps

Loc, Rot, RGB, Energy

Cameras

Loc, Rot, Lens, ClipSta, ClipEnd

Metodos python:

setType (??? , );

int type GetType ( ??? , ); SetStart ( int frame , ); SetEnd ( int frame , ); Int frameGetStart ( ); Int frameGetEnd ( );

3.3.4 - Camera:

O atuador Camera tenta similar um cameraman. Ele focaliza um ator no campo de visão e tenta permanecer a uma certa distância do mesmo. Os movimentos são suaves e há alguns “retardos” na reação do movimento em relação ao objeto.

Você seleciona o objeto que deseja que a câmera vai acompanhar no campo “OB:”, digitando o nome do objeto. O campo “Height:” determina a altura que a câmera irá permanecer sobre o objeto.

“Min:” e “Max:” corresponde a menor e maior distância da câmera ao objeto. Os botões “X” e “Y” especificam os eixos que a câmera vai permanecer na visualização do objeto.

Dê uma olhada no exemplo “camera.blend”.

3.3.5 - Sound:

O atuador “Sound” executa um “SoundObject” que foi previamente carregado com os “SoundButtons” (isto já foi explicado mais acima).

Modos de execução do som:

Play Stop

Executa o som enquanto ouver um pulso positivo.

Play End

Executa um som até o final quando um pulso positive é recebido.

Loop Stop

Executa e repete o som quando um pulso positivo é fornecido.

Loop End

Toca o som repetidamente, quando um pulso positivo é fornecido. Quando o pulso para o som é executado até o final.

Veja o exemplo “sound property.blend”.

3.3.6 - Property:

Modos de propriedades:

Assign

Assume um valor ou expressão (dado no campo “Value”) para uma propriedade. Por exemplo, uma expressão como “Proppy + 1” o “Assign” trabalha como um “Add” (adicionador). Para strings é preciso usar quotas para adicionas as strings (“...”).

Add

Adicione o valor ou resultado de uma expresão para uma propriedade. Para subtrair simplesmente dê um valor negativo para o número no campo “Value:”.

Copy

Isto copia uma propriedade (neste screen “Prop: Sprop”) do objeto com o nome dado em “OB: Sphere” dentro da propriedade “Prop: Proppy”. Isto é uma maneira fácil de trocar informações entre objetos.

Metodos python:

SetProperty ( char* name); *char name GetProperty ( ); SetValue (char* value); Char* value GetValue( );

3.3.7 - Edit Object:

Este atuador permite a ação sobre objetos, como adicionar novos objetos, deletar objetos, etc... Tipos de Edit Object:

Add Object:

O atuador “Add Object” adiciona um objeto na cena. O novo objeto vai estar orientado ao longo do eixo X do objeto criado.

Informação: Mantenha o objeto a ser adicionado sobre uma camada separada e invisível ou ele não vai

trabalhar como esperado.

Entre com o nome do objeto a ser adicionado no campo “OB:”. O campo “Time:” determina quando tempo (em frames) o objeto deve existir. O valor “0” denota que ele vai existir para sempre na cena. Tome muito cuidado para não tornar a engine muito lenta pela adição de muitos objetos na cena. É possível usar outros eventos para adicionar ou eliminar objetos na cena (colisões, properties, etc) usando o “LogicBricks”.

Com os botões “linV” é possível dar uma velocidade inicial ao objeto no momento que ele é criado. Esta velocidade é dada em relação as componentes X, Y e Z. O botão “L” considera a orientação local. Quando ele estiver pressionado a velocidade é interpretada sobre o eixo local do objeto adicionado.

setObject ( char* name);

Ajusta o objeto a ser adicionado.

Char* name getObject( char* name);

Captura o nome do objeto.

setTime (int time);

Tempo em frames em que o objeto vai existir depois de adicionado a cena. Um valor zero o objeto estará na cena eternamente, a não ser que seja eliminado por outra propriedade.

Int time getTime ( );

Captura o tempo de vida do objeto adicionado.

setLinearVelocity ( list {vx, vy, vz} );

Ajusta a velocidade linear do objeto (em unidades da gameEngine) adicionado.

List [vx, vy, vz] getLinearVelocity ( );

Ajusta a velocidade linear do objeto (em unidades da gameEngine) do atuador.

gameObject* getLastCreateObject ( );

Captura o ponteiro do ultimo objeto criado. Isto permite a manipulação dinâmica do objeto adicionado.

End Object:

O tipo “End Object” simplesmente finaliza a vida do objeto na cena quando o atuador recebe um pulso. Isto é muito usual para finalizar a existência de balas depois de colisões ou algo similar. Quando o personagem pega uma peça e esta deixa de existir na cena, etc...

Replace Mesh:

O tipo “Replace Mesh” substitui a malha de um objeto por uma nova dada pelo campo “ME:”. Lembre-se que o nome da malha não é implicitamente igual ao nome do objeto.

Metodos python:

setMesh( char* name);

ajusta a malha para ser substituida pelo atuador para “name”.

Char* name getMesh( );

Track to:

O tipo “Track to” gira o objeto apontando-o sempre para um objeto alvo especificado no campo “OB:”. Normalmente isto acontece somente no plano x/y do objeto, caso o botão “3D” não esteja pressionado). Com “3D” pressionado o objeto irá orientar-se em três graus de liberdade. O parâmetro “Time:” ajusta a rapidez com que o objeto é capaz de acompanhar o alvo. Um valor zero faz com que o objeto acompanhe o alvo imediatamente, valores acima de zero produz um retardo dando um efeito mais suave.

Metodos python:

setObject (char* name); char* name getObject( ); setTime( int time); int time getTime( ); setUse3D( );

bool 3d setUse3D( );

3.3.8 - Scene:

O atuador “Scene” (Cena) é utilizado para “ligar” cenas e câmeras na gameEngine.

Escolha a ação com o “MenuButton” e entre com uma câmera existente ou o nome de “cena” no campo de texto. Se o nome não existe, o botão ficará escuro.

Reset:

Simplesmente reinicia e “reseta” a cena. É o mesmo efeito de para o game com ESC e reiniciar com P.

Vai para a cena indicada no campo texto. Durante o “swith” todas as propriedades são resetadas.

Metodos python:

setScene( char* scene);

Ajusta a cena que deseja exibir.

Char* scene getScene( );

Captura o nome da cena do atuador.

Set Camera:

Muda para a camera indicada no campo texto. Metodos python:

setCamera( char* camera );

Ajusta para a câmera que deseja mudar.

Char* camera getCamera( );

Captura o nome da câmera do atuador. Veja o exemplo “SetCamera.blend”.

3.3.9 - Random:

Uma função indispensável para jogos são as que geram números randômicos de modo a gerar variações em movimentos ou comportamentos de inimigos.

O parâmetro “Seed” é um valor que alimenta o gerador randômico com um valor inicial para a geração de números. O computador gera números “pseudo-randômicos” que irão se repetir a cada execução. Você irá pegar a mesma sequência de números se escolher o mesmo valor de “Seed”. Obviamente valores diferentes irão gerar uma sequência randômica diferente.

Preencha o nome da propriedade que deseja ser colocada como números randômicos no campo “Property:”.

Tipos de atuadores randômicos:

Este não é uma função totalmente randômica, use este tipo para testar a lógica do jogo com valores TRUE ou FALSE.

Boolean Uniform:

Este é o típico randômico classico dos 50-50 por cento, ou meio-a-meio. As chances dos resultados TRUE e FALSE são iguais. Isto é equivalente a jogar uma moeda.

Boolean Bernoulli:

Esta função randômica resulta num valor booleano de TRUE ou FALSE. No entanto, é possível controlar as chances de haver entre um TRUE e FALSE com o parâmetro “Chance”. Uma chance de 0.5 vai trabalhar da mesma forma que o “Bool Uniform”. Uma chance de 0.1 vai resultar em 1 em cada 10 casos de sair TRUE.

Integer Constant:

Para testar a lógica com um valor dado no campo “Value:”.

Integer Uniform:

Este tipo de propriedade randômica produz um valor inteiro entre (e incluindo) um dado “Min:” e “Max:”. No exemplo ilustrado no screenshot acima o atuador vai escolher um valor entre o mínimo (no caso 1) e máximo (no caso 6).

Integer Poisson:

Os números randômicos são distribuídos “a partir de uma média” dado por “Mean:” (?)

Float Constant:

Para depurar a lógico do jogo com um dado valor.

Float Uniform:

Vai gerar um número de ponto flutuante entre um valor “Min:” e “Max:”.

Float Normal:

Retorna um número randômico em torno do número dado em “Mean:” e com um desvio padrão dado por “SD:”.

Float Negative Exponential:

Retorna um número randômico que é descrito por algum processo natural como o decaimento radioativo ou vidas de bactérias. O ajuste “Half-life time:” ajusta a média desta distribuição.

Metodos python:

setSeed (int seed);

Ajusta o seed (o valor inicial do gerador dos números randômicos)

Int seed getSeed( );

Captura o seed do atuador.

Float para1 getPara1( );

Captura o primeiro parâmetro da distribuição randômica selecionada.

Float para2 getPara2( );

Captura o segundo parâmetro da distribuição randômica selecionada.

setProperty( char* propname );

???

Char* propname getProperty( );

Captura o nome da propriedade do atuador.

setDistribution ( int dist );

??

Int dist getDistribution ( );

Captura o método de distribuição randômica do atuador.

4 - UV Texturing:

Textura produzem um grande impacto visual sobre jogos ou ambientes interativos. Com texturas é possível criar detalhes em malhas com poucos polígonos. Com texturas que possuem canal alfa é possível criar coisas como janelas, fendas ou grades sem a necessidade de modelar diretamente. 4.1 - Formatos de arquivos disponíveis:

O Blender usa o OpenGL para desenhar toda a sua interface a também para a gameEngine. Este caminho permite utilizar seus aplicativos numa série de plataforma diferente. No que se refere ao uso de texturas deve-se prestar a atenção em várias coisas antes de rodar o jogo do blender em outras plataformas. Um game multiplataforma deve funcionar em todas as plataformas e o uso correto das texturas depende disto.

- a altura e largura da textura devem ser múltiplos de 64, por exemplo, 64x64, 64x128, 128x64, etc. - não é recomendável utilizar texturas com resoluções acima de 256x256 pois nem todas as placas de vídeo suporta imagens de alta resolução.

4.2 - O Blender pode usar os seguintes formatos de texturas em tempo real:

Targa

O arquivo Targa ou TGA (formato .tga) é um tipo de arquivo de imagem comprimido. Inclui canal alfa.

Iris

Iris (.rgb) é um arquivo nativo do formato IRIX. É um arquivo de imagem comprimido. Inclui canal alfa.

Jpeg

É um tipo de arquivo de imagem comprimido muito utilizado em fotos. Devido ao tamanho reduzido é muito usado para exibição em webs. Ele não possui canal alfa e devido a sua qualidade baixa não é recomendável como formato para trabalho de design de fases para um jogo.

Manuseando as mídias:

Para a publicação e fácil manuseio dos arquivos Blender é possível incluir todas as fontes dentro da cena. Normalmente texturas, sons e fontes não são incluídas no arquivo quando o mesmo é salvo. Desta forma quando você carrega o arquivo .blend todas as fontes são carregadas dos seus respectivos diretórios de origem. Mas se deseja distribuir o game é possível comprimir todas as mídias para serem salvas juntos com o arquivo do Blender, desta forma poderá distribuir o jogo num arquivo único que contém todas as mídias. Isto permite também a proteção das mídias usadas no jogo.

No menu FILE tem uma opção PACK FILE, clicando nesta opção irá aparecer uma caixa de presente na faixa do menu superior. Isto indica que todos os arquivos usados na mídia serão salvos automaticamente junto com o arquivo .blend, criando, desta forma, um arquivo único com toda mídia empacotada.

Observação:

No texto original existe a função “Advanced Unpack” mas no Blender 2.41 não encontrei esta função, pelo que não traduzi esta parte!

4.3 - O editor UV:

O editor UV é totalmente integrado ao Blender e permite mapear textura sobre as faces dos modelos. Cada face pode ter suas coordenadas individualmente texturizadas. Isto pode ser combinada com vértices coloridos que permitem escurecer ou clarear a textura ou também pintá-las.

Para iniciar o editor UV entre em modo de seleção de faces pressionando a tecla F ou no menu de MODO selecione a opção “UV face select”. A malha é agora desenhada “z-buferizada”. Pressionando ALT-Z é possível alternar entre o modo texturizado e sólido, isto ajuda na visualização da textura.

Para selecionar um objeto basta clicar sobre ele com o botão direito do mouse, o mesmo acontecendo para seleção de faces. Você pode selecionar (ou deselecionar) todas as faces pressionando a tecla A no modo de edição ou usando a tecla B para alternar entre a seleção “circulo” (o raio pode ser alterado com o botão de rolar central) e retangular. Lembre-se que para entrar no modo de edição basta pressionar a tecla TAB.

4.3.1 - A janela de manipulação de imagens (Image Window):

Para acessar a janela de manipulação de imagens basta ir no ícone de mudança do tipo de janelas disponíveis e escolher a opção “UV/Image editor”.

Na parte inferior da janela segue o menu correspondente ao “UV/Image editor”.

O “View” exibe os modos de exibição da janela e a visualização das ferramentas de pintura e propriedades. Na ferramenta de pintura é possível escolher vários tipos de pincéis e as cores correspondentes na paleta de cores que deseja usar. E o “View Properties” permite o ajuste dos vértices no “UV vertex” e o botão “Anim” permite o uso de animações de texturas.

O “Select” exibe um menu com as seleções possíveis para vértices ou faces da malha para edição.

Em “Image” é possível carregar uma imagem, salvar, pintar a textura, desempacotar uma imagem para um diretório (não é possível pintar uma imagem que esteja “empacotada”).

5 - Python:

Python é um interpretador, interativo, linguagem orientada a objetos.

Python combina poder com uma sintaxe extremamente fácil. Ele possui módulos, classes, “exceptions”, tipos de dados com alto nível de dinamismo e tipos dinâmicos. Python é multiplataforma e não é necessário IDEs elaboradas para programar nele.

Python é gratuíto e pode ser usado para fins comerciais.

5.1 - O janela de texto (TextWindow):

O “TextWindow” é uma janela de texto simples mas bastante usual, totalmente integrada ao Blender. O propósito principal desta janela é escrever scripts em Python, mas ela também é muito usual para escrever comentários sobre o arquivo Blender ou para explicar o propósito da cena para outros usuários.

A janela de texto pode ser exibida pressionando-se SHIFT-F11 ou através do ícone no meno inferior da janela.

Em “File” é possível abrir um arquivo de texto ou python e criar um novo. No primeiro ícone a direito de “File” é possível colocar o editor no modo “fullscreen”. O icone do meio permite exibir as linhas para controle e o ícone “AB” habilita / desabilita o exibição de palavras chaves em cores, como comandos ou comentários.

O botão “Screen” altera o tamanho da fonte e o “Tab” determina a distância da tabulação. Segurando o botão esquerdo do mouse é possível selecionar textos para edição. Alguns comandos via teclado são possíveis também para edição. Segue abaixo uma lista das teclas usadas:

Teclas de comando da janela de texto:

ALT – C

Copia para o buffer o conteúdo do texto selecionado.

ALT – X

Corta o conteúdo do texto selecionado (elimina).

ALT – V

Cola o texto que está armazenado no buffer no local onde está o cursos na janela de texto.

ALT – O