Blog

Projeto Flow

O projeto fez parte de uma série de atividades no SESC Carmo – SP – sobre educação e sensibilização sobre música clássica. A demanda era alguma peça/instalação multimídia que percorresse alguns compositores característicos de certos momentos da história da música clássica européia.

O projeto então foi baseado em uma releitura do game Auditoruim, e transportado para dimesões de uma instalação ambiente.

Então consolidou-se como um jogo tipo puzzle, utilizando de computer vision, e projeção. Desenvolvido com Processing/ReactVision.

Anim-and-play

Anim-and-play é um jogo lúdico com o intuito de apresentar os conceitos de animação para crianças.

Este vídeo mostra o funcionamento do software Anim-and-play. O jogo foi desenvolvido especificamente para as atividades de férias do SESC Carmo (Julho/2010). Este programa encontra-se disponível para download e contribuição de desenvolvimento no Google Code, sob licença GPL, neste endereço:
http://code.google.com/p/anim-and-play/
Não deixe de ler as instruções na página wiki.

G.R.E.S. Unidos da Escandinávia (2006-2008)

O projeto envolveu a criação de jogos para compor melodias de samba enredo, usados na ocasião do carnaval, para público infantojuvenil.

2006:
Software feito com interatividade com mouse para se tocar os instrumentos. Loops de samba enredo coletados no The Free Sound Project.
Ambiente: Flash.

2007:
Software com interatividade via teclado, para a escolha de bases de samba, e pequenos solos de instrumentos. Os sons utilizados no jogo, foram produzidos por alunos do projeto, sob coordenação de um músico percussionista profissional.
Ambiente: Blender/Python.


2008:
Software com interatividade baseada em Computer Vision (captura de vídeo), ou seja, imagens de webcam eram capturadas e analisadas, e de acordo com a movimentação corporal do jogador, os sons de samba enredo eram tocados em tempo real.
Ambiente: Python.

Curso Visão Computacional: reacTIVision + Processing

Olá!

Nesse post eu quero anunciar o curso que vou ministrar no SESC Carmo – SP (rua do Carmo, 147, Sé, São Paulo-SP) tratando de visão computacional. Mais especificamente, sobre o uso do engine reacTIVision trabalhando junto com o Processing.

A dinâmica proposta será a reprodução de um jogo bem simples… veja o vídeo abaixo.

O CURSO É GRATUITO! As datas? Começa na próxima segunda-feira, dia(s) 12/03, 13/03, 14/03, 15/03, 16/03, das 10h às 12h.
Veja no link no SESC: http://www.sescsp.org.br/sesc/programa_new/mostra_detalhe.cfm?programacao_id=214983

Colisões :: GameDev receitas Unity3D

Detetar colisões entre objetos é uma prática fundamental para (quase) todo jogo eletrônico.
Além de detetar as colisões, é importante saber o que fazer, depois que elas ocorrem.
As game engines, sempre possuem recursos para a deteção de colisões, e esse é um tópico muito importante de ser observado, antes de escolher qual game engine utilizar para seu projeto.

Em linhas gerais, os pontos básicos a serem observados são:
– como se configura a deteção de colisão;
– quais geometrias de colisão (esferas, cubos, planos …) são disponibilizados pela engine;
– Se a game engine, permite deteção de colisão com geometria 3D (mesh).

Quando as colisões são detetadas, em geral, eventos são disparados pelo sistema. E esses eventos, podem ser capturados por objetos de jogo; que iniciam funções, para gerar a dinâmica do jogo.

Para esses exercícios no Unity3D, monte uma cena como descrita na imagem abaixo:
CenaCollisions
Obs.: Durante o tutorial, vou utilizar os nomes dos elementos como estão marcados na imagem acima.

No Unity3D, as deteção de colisões são realizadas pela engine de física, portanto, os elementos necessários para a deteção estão localizados no menu Componet >> Physics, são eles os Colliders e o Rigidbody.

Para começarmos o demo, vamos adicionar e configurar os elementos básicos necessários.
Observe no objeto SphereTrigger, se há o component SphereCollider, e se esse component está marcado como um Trigger. Caso não haja o componente collider, para adicioná-lo, selecione o objeto SphereTrigger, vá ao menu Component >> Physics >> Sphere Collider. E para marcá-lo como trigger, vá ao componente no painel Inspector, e selecione a opção “Is Trigger”.

O objeto Cube, irá desempenhar um papel importante nesse demo, ele andará pela tela com os comandos do usuário, e irá demonstrar o funcionamento das colisões. Para configurá-lo, verifique se o mesmo possui o componente Box Collider, porém esse não pode ser marcado como um trigger. Adicione também ao Cube, o componente Rigidbody. Para adicionar tal componente, selecione o Cube, vá ao menu Component >> Physics >> Rigidbody. E nesse caso é importante marcar a opção “Is Kinematic”, isso nos permitirá mover o Cube, sem a necessidade de simulações de física.
Para finalizar, basta adicionar dois scripts ao cubo; Primeiro o script BasicInputHandlerCube, que você encontra no tutorial sobre Inputs de Usuário; O segundo script a ser adicionado é o script abaixo:

BasicCollisionHandlerCube:
[code lang=”java”]
private var colisionInfo:String = “Collision info”;
function Update () {
}

function OnCollisionEnter(col : Collision){
colisionInfo = “Collision Enter (Rigidbody) : “;
}

function OnCollisionExit(col : Collision){
colisionInfo = “Collision Exit (Rigidbody) : “;
}

function OnTriggerEnter(col : Collider){
colisionInfo = “Collision Enter (Trigger) : “;
}

function OnTriggerExit(col : Collider){
colisionInfo = “Collision Exit (Trigger) : “;
}

function OnTriggerStay(col : Collider){
colisionInfo = “Collision Stay (Trigger) : “;
}

function OnGUI(){
GUI.Label(Rect(200,75,300,100),colisionInfo);
}
[/code]

Após esse trabalho, quando você executar o jogo, verá na parte central da tela, um texto exibindo algumas informações sobre a colisão, quando ela existir.
O que acontece é o seguinte. Como dito anteriormente, o Unity3D, realiza as colisões usando a engine de física, logo, os Colliders são os “sensores” que são usados para calcular quando um “toca” ou “permeia” a àrea de outro collider. Quando esse toque é detetado, o componente Rigidbody dos objetos é informado, e envia uma mensagem para o gameObject que pode ser: OnCollisionEnter, OnCollisionStay, OnCollisionExit, OnTriggerEnter, OnTriggerStay, ou OnTriggerExit.
No caso de uma colisão com um trigger, que é o caso do objeto SphereTrigger, serão enviadas as mensagens OnTriggerEnter, quando a colisão se iniciar; OnTriggerStay, enquanto a colisão estiver em curso; OnTriggerExit, quando os objetos param de colidir.
No caso de uma colisão com um rigidbody, serão enviadas as mensagens OnCollisionEnter, OnCollisionStay, e OnCollisionExit, seguindo os mesmos princípios das colisões com Triggers.

Portanto, o que script faz é o seguinte, quando uma mensagem de colisão é enviada, o script BasicCollisionHandlerCube acionará a função apropriada à colisão, e irá mudar o texto da mensagem que aparece na tela, informando se a colisão foi com um Trigger, ou com um Rigidbody.

Para fazer a colisão com um rigidbody, vamos cofigurar o objeto SphereObject. Verifique se se a SphereObject, possui um SphereCollider (não trigger), e um Rigidbody (não kinematic).
Então use o Cube, para colidir sobre esse objeto e veja o resultado. Você verá que a esfera, não irá se interpolar com o Cube, e ainda irá reagir como uma bolinha sobre o plano.

Veja o exemplo final aqui.

As outras esferas que temos nas cenas, podem ser configuradas como lhe interessar. Use-as para experimentar.

Mensagens :: Gamedev receitas Unity3D

Para enviar mensagens de eventos entre objetos de jogo no Unity3D, há duas possibilidades: 1 – Enviar a mensagem para os objetos com parentesco; 2 – Fazer uma busca pela cena para encontrar objetos de jogo, e executar um componente.

Mensagens
Inicialmente, vejamos o primeiro modo, com objetos agrupados usando dos método, SendMessage, BroadcastMessage, e SendMessageUpwards.
Para começar, criamos uma cena com elementos básicos como descrito na imagem abaixo:
imagemCenaMessages
Obs.: Monte sua cena com elementos semelhantes a esses, e dê os mesmos nomes. Os objetos fountain, e cannon, devem possuir um EllipsoidParticleEmitter, um ParticleRender e um ParticleAnimator, configure-os como quiser.
Obs 2.: No objeto Cube2, utilize o script BasicInputHandler, visto no tutorial sobre Inputs de usuário.

SendMessage
O método SendMessage irá executar uma determinada função em qualquer componente do gameObject que enviou a mensagem.
No objeto fountain, coloque o seu BoxCollider Component como um trigger. Crie esses dois scripts, e os arraste para o gameObject.

FountainScript:
[code lang=”java”]
function Update () {
}

function TurnFountainOn( v: boolean){
particleEmitter.emit = v;
}
[/code]

SendSimpleMessageScript:
[code lang=”java”]
function Update () {
}

function OnTriggerEnter(col: Collider){
this.SendMessage(“TurnFountainOn”, true);
}

function OnTriggerExit(col: Collider){
this.SendMessage(“TurnFountainOn”, false);
}
[/code]

Ao arrastar esses scripts para o gameObject fountain, eles se tornam Components. O SendSimpleMessageScript irá detectar colisões com o seu BoxCollider (setado como um trigger), e na entrada e saída das colisões irá executar o envio de mensagem “TurnFountainOn”, junto com um valor boleano true ou false.
O FountainScript, possui a função TurnFountainOn, que irá ligar, ou desligar a emição de partículas, de acordo com o recebimento do parámetro true ou false.
Veja mais detalhes nesse link.

BroadcastMessage
O método BroadcastMessage fará o mesmo que o método SendMessage, porém com a possibilidade de enviar as mensagens para outros gameObjects, desde que esses gameObjects sejam filhos do objeto que enviar as mensagens.

Para essa etapa, arraste o gameObject cannon sobre o objeto cannonPlat (faça isso no painel, não na cena de jogo), para que ele seja um “filho” do cannonPlat.
Arraste o script FountainScript para o objeto cannon.
No objeto cannonPlat, configure seu BoxCollider como um trigger.

Crie um novo script, BroadcastMessageScript:
[code lang=”java”]
function Update () {
}

function OnTriggerEnter(col: Collider){
this.BroadcastMessage(“TurnFountainOn”, true);
}

function OnTriggerExit(col: Collider){
this.BroadcastMessage(“TurnFountainOn”, false);
}
[/code]

Esse script funciona basicamente como o SendSimpleMessageScript, detecta colisões com seu trigger, e chama a função TurnFountainOn, em qualquer objeto que seja “filho” do objeto cannonPlat.

Find Component
Todo gameObject no Unity3D pode executar a função Find, que irá procurar por gameObjects pela cena. Dessa busca, os Components dos objetos são acessíveis, e podemos executar funções pertencentes à eles.

Para essa etapa, configure o BoxCollider do objeto plat, como um trigger. Adicione o FountainScript ao objeto cannon.

Crie o seguinte script, FindBehaviorScript:
[code lang=”java”]
function Update () {
}

function OnTriggerEnter(col: Collider){
GameObject.Find(“cannon”).GetComponent(“FountainScript”).TurnFountainOn(true);
GameObject.Find(“fountain”).GetComponent(“FountainScript”).TurnFountainOn(true);
}

function OnTriggerExit(col: Collider){
GameObject.Find(“cannon”).GetComponent(“FountainScript”).TurnFountainOn(false);
GameObject.Find(“fountain”).GetComponent(“FountainScript”).TurnFountainOn(false);
}
[/code]

Arraste o script para o objeto plat. Assim como os scripts anteriores, esse script irá atentar para colisões, e então, Pesquisar na cena pelos objetos cannon, e fountain. Com esses objetos localizados, o script busca pelo componente FountainScript, e então executa a função TurnFountainOn.
Veja esse link para mais informações.

Veja aqui o exemplo final.

Curso Blender Game Engine – aula 4

Nesse vídeo há uma explicação simples sobre uso de controladores Python, no Blender GE. E uma explicação introdutória sobre alguns conceitos importantes, e recorrentes, de programação em Python na GE do Blender.

Para quem não sabe nada sobre programação em python, nunca usou a linguagem, sugiro a leitura do curso escrito pela Async, “Python na prática”, encontrado nesse link: http://www.async.com.br/projects/python/pnp/

Abaixo há um vídeo de apêndice, onde alguns pontos muito, mas muito básicos mesmo, são abordados. Esse vídeo é direcionado para pessoas realmente iniciantes, que ainda não dominam conceitos de linguagens de programação. Se esse for seu caso, assista esse vídeo, e estude os tópicos abordados. O arquivo resultante do vídeo abaixo pode ser baixado aqui: video1.blend