1º -- Câmera parenteada com o objeto:
Posicione a câmera na posição que você deseja que ela siga o objeto. Selecione a câmera e com o SHIFT pressionado, selecione o objeto. Agora aperte CTRL+P.

2º -- Objeto como câmera:

O seu objeto pode ser configurado para interagir como uma câmera. Para isso, temos que considerar que a frente deste objeto será o eixo Z negativoхотелско обзавеждане.
Selecione o objeto e aperte CTRL+0.

3º -- Câmera parenteada com os vértices de um objeto:

A câmera irá seguir de um a três vértices, e não o objeto como um todo.
Selecione o objeto e entre em modo de edição(TAB). Selecione de um a três vértices. Com o botão CTRL pressionado, e sem sair do modo de edição, selecione a câmera. Feito isso, aperte CTRL+P para criar o parentesco.

4º -- Atuador Camera

Selecione a câmera e adicione um sensor Always, um controlador And, e um atuador camera. Ligue esses tijolos lógicos.
No campo OB do atuador do tipo camera, coloque o nome do objeto que você deseja que ela siga. No campo Height, coloque a altura da câmera. Min é a distância mínima do objeto e Max é a distância máxima.

Até a próxima!!

Definição:
A caixa de textos consiste em um campo que captura os caracteres digitado no teclado, armazenando a sequência e mostrando-a na tela.

Como Fazer:
A primeira coisa a se fazer é criar um texto do game engine. Caso haja alguma dúvida sobre como fazer, visite esse meu outro artigo sobre Textos no Game Engine
.

Nosso objeto texto já tem uma variável com o nome de Text. Vamos criar outra variável do tipo lógico(boolean) com um nome qualquer.
Adicione um sensor do tipo Keyboard e deixe o botão "All Keys" ativado
. No campo "LogToggle", coloque o nome da nossa variável lógica que criamos. No campo "Target", coloque a variável Text.

Prontinho faça o teste. Aperte (P) e digite alguma coisa. Como você pode ver, o que for digitado irá para variável Text enquanto a variável lógica define se a caixa de texto esta ativa ou não: Se o valor for True ela funciona, se for False não.

Veja na figura abaixo como ficaria nossa configuração:

Agora é só dar uma implementada ao seu gosto!

Decidi não ficar esperando uma boa alma entre os desenvolvedores do blender incorporar a suporte no game engine do nosso idioma e procurei uma solução mais rápida, que se resume basicamente em editar a imagem da fonte, substituindo as letras que não vão ser usadas pelas que eu preciso usar.
Neste tutorial simples, irei substituir o caractere #(ao qual não me interessa, pelo menos para mim), pelo ç (que quase sempre preciso usar) utilizando o programa de edição de imagens Gimp. Então quando quiser escrever por exemplo a palavra “esperança” no game engine, a nova grafia usada será “esperan#a”.

Então vamos lá:
1º Passo: Crie uma fonte bitmap para o game engine do blender, mas é necessário que seja uma fonte no formato português. Caso haja alguma dúvida, dê uma olhada neste artigo sobre como criar textos para o Game Engine do BlenderTexto no Game Engine

2º Passo: Abra o arquivo da fonte bitmap no Gimp e com a ferramenta para seleção de regiões retangulares (atalho:R), selecione o caractere especial, no meu caso, eu selecionei o ç:

3º Passo: Copie e cole a seleção. Vai ser criada uma “Seleção Flutuante”, aperte o ícone da folha, como indica a figura, para transformar em uma camada.

4º Passo: Agora com a ferramenta de “Mover camadas e seleções” (atalho: M), mova a caractere até sobrepor (#) o outro caractere que será substituído, certifique-se que esteja bem alinhado com as outras letras.

5º Passo: Agora, na janela de camadas, selecione a camada onde se encontra a letra ç com o botão direito e clique na opção “Merge Down”.

Faça as mesmas operações para as outras letras que você deseja substituir. Agora é só salvar o arquivo (Atalho: Ctrl+S)!

Até a próxima!!!!

Uma das maiores dificuldades na hora de se criar texturas para jogos é conseguir um efeito de sombreamento convincente. No game engine, para conseguir esse efeito sem usar lâmpadas, pode-se usar radiosity, mas, seu uso em excesso pode causa queda de desempenho. Neste artigo iremos aprender a criar uma textura UV-Mapeada a partir da Radiosity.

Vamos usar como exemplo a personagem low poly da figura abaixo, mas essa técnica pode ser usada também para cenários:

Faça o mapeamento UV do objeto normalmente:

Após terminar o mapeamento, Adicione uma nova cena com uma cópia completa do objeto (Full Copy). Nesta cena iremos realizar a Radiosity. Se for em um cenário, coloque a emissão de luz normalmente como você faria. Se for em personagem, você deverá colocar a emissão de luz com o “emit” no máximo em todos os lados do objeto, e não esqueça de aplicar materiais os conforme o seu gosto, como na figura:

Aplique a Radiosity e apague as fontes de luz. Nosso macaco de teste ficou assim:

Entre no modo de seleção de faces (F), selecione todas as faces(A). Abra uma janela de “UV/Image Editor”. Como você pode ver, o mapeamento UV que você fez continua nesse novo modelo.
Agora na janela “UV/Image Editor”, nos menus, vá em “UVs” -> “Scripts” -> “UV Painter”. A mágica da conversão de Radiosity para Mapeamento UV está neste script.
O único problema neste script é que ele costuma fazer algumas barberagens na hora de salvar a imagem no HD. Eu recomendo que em vez de salvar por ele, faça um Screenshot(print screen) da imagem e depois edite em seu programa de edição de imagens preferido.
Abaixo a imagem do script em ação:

Após ter editado a imagem num programa de edição qualquer, vá à nossa primeira cena, onde está o personagem inicial, e mapeie-o com a imagem criada. Agora vamos acertar os vértices no UV/Image Editor, que deve estar um pouco fora do lugar, mais ou menos como a imagem abaixo:

Se isso acontecer (e provavelmente vai acontecer), trabalhe em cima dos vértices de forma que acerte o mapeamento em cima da imagem:

Prontinho! Agora para ficar mais legal, é só colocar os detalhes na sua imagem. Até a próxima!

Criando sua fonte bitmap
Já existe uma ferramenta chamada ftBlender, que cria essa imagem a partir de uma fonte True Type. Esse programa é executado em linha de texto, através de parâmetros, e a fonte que você deseja converter tem que estar no mesmo diretório do programa.
Para algumas pessoas, que não estão acostumadas a trabalhar em linha de comando, o ftBlender se torna um pouco complicado. Pensando nessas pessoas, desenvolvi uma interface gráfica para esse programa: “Ftblender Interface”. Ele, em conjunto com o ftBlender, consegue criar as texturas sem ter que digitar uma linha de comando. Lembrando que o FtBlender Interface, como o próprio nome já disse, é apenas uma interface, sendo que o mérito da conversão fica todo para o FtBlender.
Abaixo uma imagem do programa em ação:

Ele é totalmente alto explicativo, bastando apenas seguir as instruções para criar sua fonte com sucesso!
O link para download do programa:
Download FtBlender Interface

Inserindo Textos no Game Engine

1 -- Adicione um plano (Plane);

2 – Agora você vai fazer um mapeamento UV deste plano usando a textura que você criou com o Programa “FtBlender”. O mapeamento deverá ficar em cima do primeiro caractere arroba, conforme as imagens abaixo:

O plano deverá ficar assim:

3- Nos botões “Texture Face” (F9), abilite as opções “Tex”, “Text” e “Alpha”:

4 – Agora adicione uma propriedade com o nome de “Text” (com a primeira letra em Maiúscula). Essa propriedade pode ser de qualquer tipo (float, integer, string etc…), ela é que vai definir o texto que será escrito. No nosso caso, criamos a propriedade do tipo String e colocamos o se valor como “Testando”:

Faça o teste (P). Pode acontecer de sua imagem ficar com as letras viradas, como na figura:

Se isso acontecer, você deve selecionar o plano e em “Modo de Edição”, rotacionar a malha de forma que fique na posição correta.

Criamos nosso texto no game engine. Para você modificar esse texto em tempo real, é só criar um logicbrick de forma que modifique o valor da propriedade.

Primeiros Passos – A Partícula Solitária

-- Para criarmos as partículas no Game Engine, vamos precisar de uma imagem semelhante a essa (não é necessário ter o canal alpha);

- Adicione um plano (Add -> Mesh -> Plane);
- Em modo de Edição (TAB), rotacione o plano de forma que a face com a normal visível fique virada para o eixo –X (eixo x negativo). Esta operação é muito importante para o funcionamento da partícula;
- Mapeie o plano com nossa imagem;
- Na aba “Texture Face”, habilite os botões “Tex”, “Halo” e “Add”;

- Nomeie o plano como “Particula”.
- Agora adicione os seguintes logicBricks na particula:

As configurações iniciais da nossa partícula já estão prontas, você já tem uma partícula solitária. Faça um teste (P). Se a partícula ficar virada sempre na direção da câmera, independente de onde ele esteja significa que você realizou todos os passos da forma correta.

Emissão de Partículas
Já criamos nossa partícula, agora vamos aprender a fazer com que um objeto(Empty) passe a emitir várias partículas.
- Mova a partícula para um layer diferente (M) e oculte este layer;
- No layer visível, adicione um Empty;
- Configure os seguintes logicbricks no Empty:

Observação: No atuador “Edit Object” do tipo “Add Object”, “OB” é o nome do objeto que vai ser adicionado na cena e “Time” é o tempo de vida deste objeto. Então em nosso exemplo, o novo objeto criado vai ficar em cena um pouco mais de dois segundos (levando em conta que está configurado por padrão que cada vinte e cinco frames corresponde a um segundo).

Nossa partícula já está funcionando, faça um teste (P). Essas são as configurações básicas para que ela se torne funcional. Os próximos passos agora são incrementar para transformá-la em efeitos mais vistosos, de acordo com a imaginação do “desenvolvedor”. Mas para facilitar a sua vida, ai vão algumas dicas muito úteis:

Dica 01: Cintilância.
O Efeito de Cintilância dá a impressão de que as partículas estão piscando. Esse efeito pode se atingido de duas maneiras, ou se preferir a união das duas.
A primeira maneira é adicionar uma curva IPO na partícula que vai aumentar e diminuir seu tamanho em um determinado espaço de tempo. Depois adicionar um atuador “IPO” do tipo “Play” que vai executar essa animação constantemente. Como já temos um sensor “Always”, é só ligar em seu respectivo Controller.
A segunda maneira é idêntica à primeira, a diferença é que em vez da fazê-la no objeto “Particula”, vamos aplicá-la no objeto “Empty”.
Nos dois casos, a curva IPO ficaria mais ou menos assim:

E nosso atuador assim:

Resultado animando o “Empty":

Dica 2: Velocidade de Emissão de Partículas.
Até agora, em nossos exemplos, a quantidade de emissão partículas está no máximo, mas se você quiser dar uma diminuída, para causar um efeito melhor ou até mesmo para melhorar o desempenho, faça o seguinte: No sensor “Always” do “Empty” existe uma opção representada pela letra “f” com o valor padrão de 0. Esta opção representa o delay que o Sensor vai sofrer para executar sua ação. Se o valor fosse 5, então irá imitir a partícula a cada 5 frames.
No meu caso, coloquei o valor 15, o resultado foi esse:

Dica 3: Colorindo as Partículas
As partículas podem assumir várias cores, inclusive mudar de cor gradativamente (isso é muito útil se queremos fazer um efeito simulando fogo, já que sua base é vermelha e o topo é amarelado). Para conseguirmos trabalhar com as cores, vamos ter que usar curvas IPO. Selecione o objeto “Particula”, e em suas curvas IPO, localize os canais ColR, ColG, ColB(que representam respectivamente os canais Vermelho, Verde e Azul). Selecione os canais e, na janela, segure CTRL e clique aonde você quer criar uma Chave IPO correspondente a aquela cor.
Observer a figura:

Em nosso exemplo, colocamos todos os canais com o valor de 1.00. Esse é o valor máximo. Como nos sabemos, a união de todas as cores formam o branco, então se colocar todos os canais com o valor 1.00, a partícula vai ficar branca. Se quisermos que a partícula fique com o valor máximo vermelho, então teremos que configurar da seguinte maneira: ColR:1.00, ColG:0.00, ColB:0.00.

Animando esses canais de cores, podemos conseguir efeitos bem legais:

Coloquei aqui apenas algumas dicas de como melhorar nossa partícula, mas existem muitas outras coisas que podem ser feitas, vai da criatividade de cada um. Grande parte do que foi posto neste artigo não é regra, pode e deve ser modificado, dependendo de sua necessidade.

Bom divertimento!

Uma dúvida que deixa de cabelos brancos a todos os iniciantes no python para o Game Engine, é como acessar objetos via programação. Neste artigo, vou ensinar o conceito básico sobre a hierarquia usada nos jogos do Blender.

Observe a figura abaixo:

Na verdade este diagrama está bem simplificado, pois existem outros itens que podemos incluir na hierarquia, mas vamos tomá-lo como um padrão.

Para que se consiga atingir o destino desejado, será necessário percorrer a hierarquia. Você pode fazer esse percurso tanto do nível mais alto para o mais baixo como também o inverso. Então podemos dividir a programação python em dois tipos: Crescente e Decrescente.

Programação Crescente

Esta é o tipo de programação mais usado. Ele vai subindo o diagrama até chegar no ponto mais alto possível.
A primeira coisa que precisa saber e que todo script python do game engine está ligado a um Controlador. O script python é a parte mais baixa da hierarquia.

Vejamos este LogicBrick:

Neste exemplo existe um controlador do tipo python, dois sensores(CaixaEntrada e Teclado) e dois atuadores(AdicionarJogador e Mensageiro). Todos estão nomeados devidamente. Lembrando que é muito importante nomear os seus logicbricks para que fique mais fácil de localizar via programação.

Vamos imaginar que queremos buscar o Atuador AdicionarJogador para trabalhar com ele. Pelo nosso diagrama, o caminho seria este: Script Python -> Controlador -- > Atuador.

Vamos implantar isso em Python Script:

Prontinho, já temos nosso atuador armazenado em uma variável de igual nome (atuador). Agora você já pode trabalhar ela usando suas funções e procedimentos (temas para um próximo artigo).

Mas agora, se desse mesmo logicbricks, quisermos buscar o sensor teclado? Como ficaria nosso código? Pelo nosso diagrama, o caminho seria este: Python -> Controlador -- > Sensor.

Então o código ficaria assim:

Já vimos com acessar os sensores e atuadores, agora vamos acessar o objeto que executou o script: Script Python -> Controlador -- > Objeto.

Prontinho, temos o objeto armazenado na variável proprietário. No game engine, costumamos chamar o objeto que executou o script de proprietário, porque ele é dono de todos os controladores, sensores e atuadores que estão ligados a ele.

Como podemos ver, conseguimos alcançar todas as instancias “possíveis” usando o método de programação Crescente.

Programação Decrescente

A programação decrescente, embora menos comum, é usada em projetos em que objetos têm que interagir entre eles. Ela permite que script que esteja sendo executado em um objeto A possa acessar um objeto B.
Como exemplo, vamos imaginar que se tenha três objetos em cena, nos quais você devidamente os re-nomeou como: bola, quadrado e triangulo. Existe um script no objeto bola que você deseja que acesse o objeto quadrado. Para isso teremos que começar de cima para baixo, de acordo com o nosso diagrama: Cena -- > Objeto.
O script Python para acessar o objeto quadrado ficaria assim:

Observações:
A função getObjectList() retorna uma lista de todos os objetos que estão em cena. Quando você a usa definindo o nome ( getObjectList()["OBquadrado"]), ela busca somente o objeto em questão.
No Game Engine, mesmo que você re-nomeie seu objeto, o blender sempre vai acrescentar o prefixo “OB” no inicio.

Considerações finais:

Como se pode perceber, em ambos os métodos, nenhum alcança os extremos. Os dois só chega até o nível objeto, mas é bom saber que a união deles pode se tornar uma arma poderosa no game engine.

In 1988, Ton Roosendaal co-founded the Dutch animation studio NeoGeo. NeoGeo quickly became the largest 3D animation house in the Netherlands. NeoGeo did award winning productions (European Corporate Video Awards 1993 & 1995) for electronics company Philips. Within NeoGeo, Ton was responsible for both art direction and internal software development. After careful deliberation it was decided that the current in-house 3D toolset for NeoGeo needed to be rewritten from scratch. In 1995 this rewrite began and was destined to become the 3D software tool we all now know as Blender.
In the next week, we will speak of the characteristics of the Game Engine and its functioning with the Blender.
CYA!

Cada semana colocaremos notícias e tutorias sobre o mundo da GE.

Vamos falar um pouco da história do Blender, só um pouco porque o objetivo desse blog é ser sua fonte para a Game Engine.

Em 1988, Ton Roosendaal co-fundou o estúdio holandês NeoGeo Animation. NeoGeo transformou-se rapidamente a maior casa de animação 3D dos Países Baixos. NeoGeo concedeu produções ganhando (European Corporate Video Awards 1993 & 1995) para a companhia de eletrônica Philips. Dentro da NeoGeo, a Ton era responsável pela direção de arte e o desenvolvimento interno de software. Depois que cuidadoso estudo foi decidido que o sotware 3D atual deveria ser reescrito do zero. Em 1995 esta reescrita começou e foi assim que ela começõu a transformar-se na ferramenta de software 3D que todos nós conhecemos agora como o Blender.
Bem pesosal, NeoGeo não aquele vídeo-game e sim o nome da empresa mesmo, e para finalizar a história a NeoGeo estava falindo e Ton solicitou a comunidade doações para que assim pode-se liberar o fonte do Blender sobre a licensa GNU, e assim começou a era Blender…

Na próxima semana, falaremos sobre um pouco das características da Game Engine e de seu funcionamento com o Blender.

Até lá.