Blender Tutoriais

NeoTextureEdit gerador de textura Open Source

2011-02-15T18:31:00.000-08:00

NeoTextureEdit é um programa open source (GNU LGPL v. 3) fácil de usar gráfico baseado em textura perfeita editor processual. Usando funções de base contínua pode gerar imagens de resolução arbitrária, sem degradação da qualidade. Sua principal finalidade é produzir texturas de alta qualidade para aplicações de renderização em tempo real que podem ser armazenadas em alguns KB e sintetizada na inicialização do aplicativo. Mas também pode ser usado para gerar imagens-off line.

Opinião do Blogger:

Vale a pena conferir o site do desenvolvedor e baixar a ferramenta, muito útil e simples de usar.

Como se tornar um profissional da indústria de games

2011-02-15T18:18:00.000-08:00

O co-fundador da desenvolvedora brasileira Mojjo.de dá dicas sobre como entrar nesse mercado e preparar seu próprio jogo.
Uma matéria muito interessante sobre profissionais em Game, confira aqui.

Função de ScreenShot durante o jogo - ScreenMaker

2011-02-04T10:50:00.000-08:00

Imagem Ilustrativa

Muitas vezes gostaríamos de salvar imagens durante um jogo ou passeio virtual 3d no blender, mas muitos inclusive eu não tinham idéia de como fazer. Dando uma olhada na API da BGE achei uma função chamada 'makeScreenshot()' do módulo Rasterizer que trata da renderização da imagem e tem muitas funções interessantes como coordenadas do mouse, tamanho da tela em pixel e por ai vai.
A função makeScreenshot() é muito simples de ser usado é só colocar o nome do arquivo que será salvo no parâmetro da função Ex: Rasterizer.makeScreenschot('minha_imagem') e pronto. A imagem será salva na extensão jpg.

Imagem geral do template

Vamos para a lógica do template:
-Criamos um script python que irá fazer o processo de salvar a imagem de preferência ligado na câmera.
-Associamos um sensor do tipo keyboard(teclado) que irá disparar a função de salvar a imagem.
-Criar uma variável no Add Property que será o nosso contador de fotos.

Painel de Logica da BGE

Tirando várias fotos:
O script que desenvolvi tem a função de salvar um arquivo de imagem sempre que uma determinada tecla for pressionada e salva a imagem com um nome diferente em ordem crescente Ex: imagem0, imagem1 etc...

Script Python
____________________________________________________________

# Feito por Marcos Amaral (racom)
# em 27/01/2011

import Rasterizer #MODULO RESPOSAVEL PELA RENDERIZAÇÃO

import GameLogic as g #MODULO DA BGE

cont = g.getCurrentController() #PARA OBTER OS CONTROLADORES, ACTUADORES E SENSORES
obj = cont.owner #PROPRIETARIO DOS CONTROLADORES

key = cont.sensors['key'] #OBTEM O SENSOR DE TECLADO

arquivo='imagem'+str(obj['contador']) #CRIA O NOME DO ARQUIVO

# SALVA screenshot
if key.positive:
Rasterizer.makeScreenshot(arquivo) #FUNCAO QUE SALVA A IMAGEM
obj['contador'] += 1 #SOMA MAIS UM AO CONTADOR
____________________________________________________________

Download do template: screenshot.blend

É isso ai, espero que tenho gostado, em breve mais tutoriais sobre BGE.
Até mais! \o

Template Game Engine

2011-02-03T10:24:00.000-08:00

Estou disponibilizando um template criado por mim e usado na oficia do IV Conferência Nacional Blender Pro. Ele trata de funções básicas para se fazer um jogo utilizando Python Script. O código contém comentários para facilitar o entendimento do mesmo. Bons estudos e bom divertimento.

Download do arquivo: script_python.blend

Desenvolvimento de IA com BGE

2010-12-30T08:22:00.000-08:00

Esse material é parte da Palestra que ministrei na IV Conferência Nacional - Blender Pro, fala sobre lógica de programação, Pathfinder (encontrar o caminho) para jogos e um arquivo .blend demonstrativo.

link RTS.blend

Movimento de Câmera vista de cima

2010-12-16T19:05:00.000-08:00

Em jogos de RPG ou de RTS se utiliza muito a visão de cima, a navegação pelo cenario com a câmera pode ser uma dificuldade há mais. A proposta aqui é a movimentação da câmera pelas bordas da área de visão, como no video abaixo:

Você pode reparar que ao movimentar o cursor do mouse para perto das bordas da janela, "o cenário se desloca", isto é a câmera se desloca em relação ao cenário.

Como funciona o template?
Precisamos criar um script python que saiba da localização do cursor mouse e as dimensões da janela, em seguida comparar a posição atual do cursor em relação aos limites da tela, então criamos aréas de ação do cursor.

Assim que o cursor atingir umas das área de ação a câmera se desloca na direção da área ativa e quando sai da área para o deslocamento.

Os elementos do template:
Ativos - Câmera ligada(parenteada) ao Empty, no qual vai no Painel de Lógica um sensor do tipo Always e outro de Mouse/Moviment, ligados ao Controlador Python.

O Script Python:

import Rasterizer
Rasterizer.showMouse(1)
w = Rasterizer.getWindowWidth()
h = Rasterizer.getWindowHeight()
import GameLogic as g
from GameLogic import *

cont = getCurrentController()
ow = cont.owner

mousesensor = cont.sensors['move']
campos = ow.position

x = mousesensor.position[0]
y = mousesensor.position[1]

screenposx = 1.0*(x - w/2) / w
screenposy = 1.0*( ( h - y ) - h/2 ) / h

#deltax = campos[2]/1
#deltay = campos[2]/1
deltax = campos[2]/1.265
deltay = campos[2]/1.84

newposx = campos[0] + screenposx * deltax
newposy = campos[1] + screenposy * deltay
newposz = 0

newpos = [newposx,newposy,newposz]

print y
#print L,l
#print screenposx, screenposy
#print newposx,newposy

#DETECTA OS LIMITES DE AÇAO DA TELA
if y < 50:
up="on"
else:
up="off"
if y > h-50:
down="on"
else:
down="off"
if x < 50:
left="on"
else:
left="off"
if x > w-50:
right="on"
else:
right="off"

vel = 0.1

if up=="on":
ow.applyMovement([0,vel,0],1)
print "up"
# down

elif down=="on":
ow.applyMovement([0,-vel,0],1)
#print "down"

# left
elif left=="on":
ow.applyMovement([-vel,0,0],1)
print "left"

# right
elif right=="on":
ow.applyMovement([vel,0,0],1)
print "right"

Conclusão:
Esse template demonstra os princípios do funcionamento de Movimento de câmera, com ele você pode usar de base para seus projetos e incrementar mais funções.

Download do template: aqui

Drag and Drop - Arrastar e Largar

2010-12-09T07:19:00.000-08:00

Drag and Drop 3D - Arrastar e Largar

Conceito
Nas interfaces gráficas de computadores, drag-and-drop (arrastar e largar) é a ação de clicar em um objeto virtual e "arrastá-lo" a uma posição diferente ou sobre um outro objeto virtual. De maneira geral, ele pode ser usado para invocar diversos tipos de ações, ou criar vários tipos de associações entre dois objetos abstratos.

A seqüência básica de ações relacionadas ao drag-and-drop é:

Clicar, e manter o botão do mouse ou outro dispositivo semelhante apertado, para "agarrar" o objeto,
"Arrastar" (drag) o objeto/cursor à posição ou localização desejada,
"Largar" (drop) o objeto, soltando o botão pressionado.

Neste Tutorial iremos abordar um Drag and Drop um pouco diferente, por se tratar de um Drag and Drop 3D, isso quer dizer que diferentemente de um porcedimento 2D onde só um angulo de visão é permitido podemos posicionar nossa camera em qualquer ângulo para deslocar o objeto.

Vamos para a lógica do template.
Consiste basicamente em o ponteiro do mouse estar sobre o objeto que se deseja deslocar.
Ao clicar com o botão esquerdo do mouse, uma função pega as propriedades do objeto e verifica se este possui tal propriedade para permitir o deslocamento.
Se este apresentar esta propriedade sua posição será a aposição do mouse, enquanto o botão do mouse permanecer precionado, assim que solto o botão do mouse o objeto fica na posição atual.

Construindo o Template.

1º Passo - Adicionar o objeto ou objetos, adicione uma propriedade no objeto no painel Game Logic (F4) em Add Property com o nome de ativo.

2º Passo - Criar um script Python como descrito abaixo e liga-lo a câmera.

import Rasterizer
Rasterizer.showMouse(1)

import GameLogic as g
from GameLogic import *

cont = getCurrentController()
own = cont.owner
mouseover = cont.sensors['MOverAny']
lmb = cont.sensors['LMB']

hitLoc = mouseover.hitPosition #COORDENADAS DA POS DO MOUSE
hitObj = mouseover.hitObject #OBJ Q ESTA SOB O MOUSE

hitLoc=hitLoc
posx=hitLoc[0]
posy=hitLoc[1]
posz=hitLoc[2]

cena=g.getCurrentScene().objects

if hitObj.has_key('ativo') and lmb.positive:
    #print hitObj #Use o print para visualizar o obj na linha de comando
    obj=hitObj
    obj.position = [posx,posy,1]

3º Passo - Adcionando sensores a câmera:
Adicione um sensor Mouse do tipo Mouse over any.
Um sensor Mouse do tipo Movement.
Um sensor Mouse do tipo Left button.
Ligue-os ao controlador Python como descrito na figura abaixo.

Agora é só testar teclando P e clicar e manter precionado sobre o objeto, mova o mouse e solte o clique, se tudo estiver certo vocề terá deslocado o objeto de lugar.
Esse template poderá ser a base para algum jogo ou parte dele em seus projetos.
Bom proveito!

Download template: aqui

Editando Materiais e Texturas para BGE

2010-09-07T21:45:00.000-07:00

MATERIAS E TEXTURAS

Por Marcos Amaral

1-Materiais:

O que são materiais?

Para responder essa pergunta temos de refletir sobre o mundo real. Um objeto real é composto por algum tipo de material, como vidro, plástico, pedra e por ai vai.

Todos eles tem suas características, físicas e visuais. Vamos ficar a princípio com as características visuais.

O Blender trata da mesma forma e tenta imitar os materiais reais, não é uma tarefa das mais fáceis, já que precisamos ter uma boa noção da realidade e saber passar essas característica para o virtual.

Vamos criar o nosso material.

-Primeiro apague o cubo que já é criado quando inicializamos um novo arquivo.

-Agora adicione um objeto qualquer, como um cubo ou uma esfera.

-Tecle F5, esse é o atalho para Material Buttons.

Na janela Link and Pipeline clique em ADD new para adicionar um novo material.

Painel Shading Material Buttons, com uma prévia do lado esquerdo.

Todas as modificações são geradas na janela Preview.

Na janela Material há 3 características básicas de cor a serem aplicadas no objeto.

Nas caixas de cor você seleciona a cor do seu objeto.

Col – Cor principal do material.
Spe – Cor das reflexões.
Mir – Cor dos espelhamentos.

Resultado obtido com a mudança de cor.

2-Múltiplos materiais em um objeto:

Você pode precisar colocar mais de um material em um objeto, para isto usaremos um cubo como exemplo.
Este processo é um pouco chato, mas vamos la!
Vá no painel Editing(tecla F9), na janela Link and Materials.

Os materiais para múltiplos objetos são selecionados aqui.

Entre no modo edit(TAB), selecione somente uma face, clique em New, note que o seletor de cores incrementou um númeno, por exemplo, 2 Mat 2, significa que ele criou outro material.

Na caixa de cor, troque a cor por outra e depois clique em Assign.

3-Espelhamento e Sombreamento (Shaders):

Na janela Shading em Material Buttons-Shaders, encontramos mais opções relativas a materiais, são os algoritmos de materiais, como Reflexão (Ref) e Specula(Spec), teste todos e veja os resultados.Espelhamento e Sombreamento (Shaders):

Na janela Shading em Material Buttons-Shaders, encontramos mais opções relativas a materiais, são os algoritmos de materiais, como Reflexão (Ref) e Specula(Spec), teste todos e veja os resultados.

A parte de cima é para reflexo e a de baixa para especular.

4-Aplicando Texturas por mapeamento UV nos objetos:

Essa é uma parte muito importante para o desenvolvimento de um game, pois consiste em dar uma roupagem para os objetos, isto é: Temos um gramado, mas para que possamos identificar melhor, não basta a cor e sim uma imagem de grama, o que dará mais realismo ao jogo.
*Observação: Mas dependendo da proposta do game não há necessidade de texturas, elas apenas torna o ambiente mais próximo do real.

Primeiramente separe uma imagem do tipo grama ou outra qualquer em seu computador para o exercício.

Agora vamos preparar o as janelas do blender para trabalharmos com Texturas.
No blender temos a possibilidade de criar subdivisões de janelas para facilitar a visualização simultânea de vários itens.

Escolha Split Area, ajusta o local da divisão e clique com o botão esquerdo do mouse pra confirmar.

Agora clique em Display Current Window e escolha a opção UV/Image Editor, pronto já temos nossa janela para texturas.
Para colar uma imagem no objeto precisamos preparar o mesma para tal, nas versões 2.45 e anteriores é necessário usar um modo chamado UV/Face pela tecla F, que já não é mais utilizado, nas versões posteriores é usado o modo edit(edição-TAB) para a seleção de das faces, que irão receber a texturas.
O procedimento a seguir é o mesmo para os dois modos.
No modo edit selecione as faces que irão receber a texturas e tecle U e no menu escolha a opção Unwrap. Isso fara com que as faces fiquem disponíveis para o mapeamento UV/texture, que é visualizado na janela UV/image Edit.

Após o Unwrap, vamos buscas nossa imagem que sera usada. Clique me Image->Open e navegue no browser para selecionar sua imagem.
Uma coisa que é um pouco ruim é a interface do navegador de arquivos, para aqueles que não estão acostumados pode ser um pouco difícil no inicio, mas é só ter um pouco de curiosidade que você consegue.

Após a seleção da imagem tecle TAB para sair do modo edição e mude o modo Solid para Textured em Draw Type.

Sair do modo Edição Ir para o modo Textura

Bibliografias:

Guia do usuário para uso do Blender 3d
de Bruno Maia de Andrade

Classes em PYTHON

2010-09-07T20:43:00.000-07:00

Este é um pequeno artigo que fiz para mostrar a linguagem PYTHON e uso de classes para os colegas do curso de Tecnólogo em Sistemas para Internet - (Faculdade Atlântico Sul - Rio Grande-RS - Anhaguera).

Como falei no início este é uma breve apresentação sobre PYTHON, mas pode servir de motivação para aqueles que não conhecem a linguagem ainda.

Tutorial Animação Bones(ossos) para BGE

2010-07-12T14:55:00.000-07:00

Este tutorial tem a finalidade de desenvolver técnicas de animação para a Game Engine do Blender, mas pode ser utilizado também para produção de animações em vídeo, necessita conhecimento básico do Blender 3d. Vamos ao tutorial e bons estudos!
Esse tipo de animação é muito utilizado em personagens, pois se assemelha muito ao mundo real, por usar um corpo movimentado por ossos.
Vamos criar um corpo para se animado, tanto para renderização quanto para utilização na BGE. Mude a visualização para a visão lateral, tecle num3.

Vá para o modo de edição e crie duas extrusões uma para a direita e outra para a esquerda como na imagem acima. Saia do modo de edição, vá para o modo objeto e adicione um objeto do tipo Armature.

Coloque em modo edição e selecione os nós para movê-los na na posição conforme a figura abaixo:

Esse objeto se comporta como um osso, com isso podemos montar um esqueleto, suas pontas são as articulações, assim como utilizamos a ferramenta de extrusão para criar novas faces e vértices, podemos criar novas articulações e ossos. Selecione um nó e tecle E de extrusão. Veja a figura abaixo:

Agora vamos lincar o corpo com os ossos, saia do modo edição e selecione o cubo, logo após selecione o objeto armature, pressione ctrl+p e escolha a opção Make Parente To → Armature e Create From Bone Heat.

Mude agora para o modo pose, conforme a figura acima. Nesse modo podemos testar e manipular os ossos e influenciando a malha, será aqui que também faremos a animação. Selecione um nó e tecle G para mover, veja o resultado, a malha acompanha o osso.

Crie outros objetos e experimente para ver os resultados, estenda os objetos e os ossos, lembrando que o nó do osso deve influenciar diretamente a malha. Agora vamos criar nossa animação.
Divida a tela do 3d view e selecione o modo da janela para Action Editor.

Vamos utilizar o método de chaves para criar nossa animação, através da time line,
coloque o osso na posição inicial desejada, no frame 1 e tecle I e escolha a opção
LOCROT, com isso criamos nossa primeira chave da animação.

Próximo passo, mude o frame para 50 por exemplo, desloque um dos nós e repita o

processo de criar chave descrito anteriormente.

Volte para o frame 1 e tecle alt+a para rodar a animação.

Pronto nossa animação já esta funcionando e pronta para ser usada. Agora podemos

escolher se queremos usá-la para renderização ou para a game-engine do blender.

Para utilizar na renderização ou seja criar um vídeo, tecle F10 para mudar a janela

Buttons para o modo Scene, onde primeiramente escolheremos qual o formato de saído

queremos, logo após o tempo de duração e por fim a renderização.

-No formato de saída podemos escolher imagens do tipo jpeg ou formato vídeo em mpeg

dentre várias outras opções a gosto.

-Na duração de frames vamos colocar o início como 1 e o final como 50, já que nossa

animação possui este número como último frame.

-Para renderizar clique no botão ANIM e aguarde o termino do processo e tecle PLAY

para ver o resultado.

Agora iremos controlar nossa animação para Game-Engine do Blender.

Para isso usaremos o bloco de lógica, no qual não vamos entrar em detalhes de

funcionamento e sim maior atenção ao Actuators Action que é o diferencial para que possa

funcionar nossa animação em um jogo. Siga os passo de montagem de acordo com a

imagen abaixo, tecle F4, selecione o objeto Armature e adicione um sensor, um

controlador e um actuators ligue-os entre si.

No sensor ligue o botão de repetição e no Actuators mode de Motion para Action:

Mude no Action de Play para Loop End e digite em AC: Action que é nossa ação criada
na time line Editor Action, mude End: 1 para 50.

Feito esse processo, vamos testar nossa animação na game-engine do blender. Tecle P

com o mouse na janela 3d View, assim estaremos em modo jogo e a animação deverá

estar rodando.

Um possibilidade interessante de se testar é a ação controlada da animação, experimente

trocar no sensor Always por Keybords, que é um sensor do tipo teclado, no campo Key

clique com o botao direito do mouse e tecla barra de espaço ou outra tecla que você

quiser, essa tecla será o acionador da animação durante o jogo, esse recurso é muito

usado para animação de personagens em jogos.

Espero que tenha conseguido ajudar nos princípios básicos de animação de ossos, claro

que existem muito mais recursos no blender para animação de ossos, mas com esse

tutorial você pode começar a se aventurar nessa área.

Desenvolvendo Jogos - Game Design

2010-04-01T06:38:00.000-07:00

Começando seu projeto de Game!

Antes que se inicie os trabalhos de desenvolvimento de um jogo, deve-se passar por etapas de elaboração, as quais irão determinar o como serão os trabalhos e prazos para a criação do game.

Um bom exemplo desse processo é a criação de um filme, como os de hollywood, onde é impossível para uma só pessoa fazer esse trabalho, mas divide-se em equipes especializadas nas diversas áreas.Durante muito tempo desenvolvi meus projetos sozinho, mas como o passar do tempo e com o aprimoramento das técnicas ficou praticamente impossível faze-lo sozinho assim criei um grupo para que possamos juntos poder desenvolver nossos projetos com o máximo de qualidade possível, para isso dividi o grupo em áreas de produção as quais vou tentar descrever logo abaixo.

Aqui vão algumas idéias básicas de como vamos fazer esse trabalho:

PRODUÇÃO

- Pré-produção:

Consiste em um processo chamado BRAINSTORMINGS, como o nome sugere, é onde a equipe se reuni para debates sobre o projeto, onde surge ideias e conceitos para o projeto.

- Produção:

É a parte em que o se coloca a ''mão na massa'', onde a equipe trabalha e desenvolve o projeto.

- Pós-produção:

São realizados melhorias e correções de Bugs, conteúdo adicional para download e patches.

Áreas de desenvolvimento

Como comentado no início do texto, aqui você terá uma ideia de qual área você se identifica e poderá escolher para trabalhar no desenvolvimento do jogo.

Gráfico

Envolve-se com todo o visual do jogo e é subdividido em algumas sub-áreas.

- Conceito Visual: é basicamente a guia para todos os trabalhos de gráficos, definindo estilos, cores, traços e criação de storeboards.

- Criação de Texturas e shaders: trabalha com a criação de imagens para o jogo, como ambiente, aparência dos objetos e personagens, inclui também iluminação do cenário.

Modelagem 3D

Cria os objetos de um jogo em 3d ou pseudo 3d, necessários para o jogo, como personagens, inimigos etc... A Modelagem 3D para jogos requer o usa de uma técnica chamada de Lowpoly, que quer dizer poucos polígonos para um objeto 3d, para que haja um desempenho maior por parte da CPU.

Animação

Tem como objetivo dar vida aos objetos e personagens do jogo, usando movimentos que imitem a realidade ou movimentos estilizados, para aqueles que acham que é brincadeira dar vida a esses objetos, não se engane existem muito material para estudo nessa área e exige muita dedicação, mas o resultado é prático e prazeroso.

Temática e Historia

Envolve criar uma história para o jogo e coloca-lo em um ambiente, uma boa história ajuda muito para que o game se torne mais emocionante. Também tem a questão da continuidade e desenvolvimento das fases.

Interface e jogabilidade

É fundamental para um bom fluxo do jogo, verifica-se onde ficam os botões do menu e de que maneira o jogador deve interagir com o personagem ou com o jogo, não tem nada pior que um jogo com combinações de botões ruins ou pressionar milhares de vezes os botões sem necessidade.

Efeitos sonoros e trilha sonora

Um jogo sem sons e música não tem a mesma emoção, então esta parte ajuda muito a trazer emoções para jogo, mas deve-se ter em mente o público alvo para não errar na receita de sons e prejudicar o game, uma música ruim ou um som muito repetitivo devem ser evitados a todo custo.

Lógica e programação

É o que traz a vida ao jogo, sem essa etapa não há interação. O programador deve ter em mente que a lógica vem em primeiro lugar, desenvolver a lógica é importante para o bom desenvolvimento dos scripts. Jogos exigem muito tempo de desenvolvimento, mesmo jogos considerados simples, ou casuais tem sempre um alto índice de complexidade, exigindo do programador vastos conhecimentos em estruturas-computacionais.

Bem pessoal, acho que consegui resumir como é o processo de criação de jogos, independente de que plataforma seja, os processos são os mesmo, claro há muito mais coisas para se ver mas esse é um ponto de partida.

2009-06-23T10:14:00.000-07:00

Tutorial de Python Script na Game Engine do Blender

Pré-Requisitos

Conhecimento em:

Game Engine do Blender, bem como o seu Bloco de Lógica

Noções basicas de Python Script

Esse tutorial se destina para aqueles que desejam ir além dos Blocos de Lógica da GE do Blender, para isso precisam entrar para o mundo da programação na linguagem Python. Para quem não sabe ainda, python é o script usado no blender para tanto para o ambinte do blender como para GE, onde podemos expandir em muito as possibilidades utilizando essa linguagem.

Em muitas vezes quando começamos a desenvolver um jogo na GE utilizando o bloco de lógica as coisas no princípio parecem fáceis, mas depois com o desenvolv

imento do projeto começa a ficar muito confuso com a grande quantidade de bloco de logica interagindo entre si, sem falar nas limitações que o próprio sistema tem. Por exemplo se criarmos um projeto utilizando scripts Python, podemos reduzir consideravelmente a quantidade de blocos de lógica e aumentando as possibilidades de desenvolvimento do projeto.

Controle de rotação

Como o título acima sugere, vamos fazer um pequeno programa

de controle de rotação que pode ser adaptado de várias maneiras, rotação, deslocamento, animação e etc... Mais adiante vou demonstrar como proceder para utilizar das maneiras já descritas. Vamos botar a mão na massa.

Antes de sair digitando o script vamos a alguns conceito importantes sobre como o blender usa python.

Com o blender aberto vamos dividir a tela para podermos visualizar o modo texto onde será feito o script. Crie um novo arquivo de texto e salve-o com o nome de script por exemplo.

Primeiramente precisamos ligar o script ao objeto, para que o mesmo possa ser controlado pelo mesmo. Para isso adicione um controlador do tipo python e nomeo com o mesmo nome que foi dado ao script.

Depois ligar os sensores ao script, no nosso caso sensores de teclado.

E ligar os atuadores ao script, que irão fazer o objeto rotacionar.

Vamos ao script:

#Para obter um controlador

import GameLogic

cont = GameLogic.getCurrentController()

#Para obter o objeto associado a este controlador

own = cont.getOwner()

#Para obter um sensor associado a este controlador

up = cont.getSensor('up')

down = cont.getSensor('down')

#Para obter um atuador ligado ao controlador

act = cont.getActuator("rot")

#Definindo valores para o atuador

act.setDRot(0,0,+0.1,1)

#Ativando um atuador

if up.isPositive():

GameLogic.addActiveActuator(act,1)

elif down.isPositive():

GameLogic.addActiveActuator(act,0)

A primeira parte do script se refere a inicialização do modulo da Game Logic, import GameLogic e a linha seguinte se refere aos controles ligados ao script, cont = GameLogic.getCurrentController() a variavel cont é apenas um nome sugerido podendo ser trocado por qualquer outro nome.

*Obs: O sinal de # serve para inserir comentários no script.

#Para obter o objeto associado a este controlador

own = cont.getOwner() se refere ao objeto e suas propriedades, por exemplo suas variáveis, own também é uma variável que pode ter seu nome alterado.

*Obs: As variáveis em python são atribuidas com o sinal de =, exemplo: raiz=5, a variável raiz recebeu o valor de 5.

#Para obter um sensor associado a este controlador

up = cont.getSensor('up')

down = cont.getSensor('down')

Adicione um sensor do tipo teclado e set uma tecla por exemplo seta p/ cima.

Para ligar um sensor ao script precisamos nomealo com o mesmo nome tanto no Bloco de Logica quanto no scritp, já o nome da variável não afeta o funcionamento.

Exemplo: up = cont.getSensor('up') ou setap/cima = cont.getSensor('up')

#Para obter um atuador ligado ao controlador

act = cont.getActuator("rot")

Este é responsável por ligar o actuador motion ao script, lembre-se de colocar o mesmo nome no script e no atuador do bloco de lógica.

#Definindo valores para o atuador

act.setDRot(0,0,+0.1,1)

Aqui esta uma parte muito importante, pois é aqui que definimos o que vamos fazer com o actuador ligado ao script, neste casso escolhi o setDRot(0,0,0,0) para a variável act, mas você pode escolher setDLoc(0,0,0,0) que serve para incrementar o deslocamento do objeto. A lista de zeros indica o valor das variáveis X,Y,Z e o último se é local on = 1 ou local off = 0.

*Dica: Para que você possa utilizar todas as possibilidades que o blender lhe da é fundamental consultar a API do blender, onde se visualiza as opções em python para você desenvolver seu projeto.

#Ativando um atuador

if up.isPositive():

GameLogic.addActiveActuator(act,1)

elif down.isPositive():

GameLogic.addActiveActuator(act,0)

Aqui é a parte lógica, basicamente é o seguinte:

se a tecla up for pressionada faça:

act,1 – ou seja, ativa o act

e se a tecla down for pressionada faça:

act,0 – ou seja, desliga o act

Pronto! Agora vá para a janela do 3DView e tecle P, e teste as teclas para ver o funcionamento.

Conclusão;

Este é um ponto de partida para se compreender a forma de utilização do python na GE do blender e desenvolver seus projetos de forma mais eficiente e profissional.

Projetos feitos em python expandem em muito o poder do blender, trazendo toda uma nova game de possibilidades.

Espero que este tutorial tenha lhe sido útil.

Meu email para contato e sugestões de melhoria e tutoriais.

marcosamaralrg@hotmal.com