Malhas maleáveis, Corpos Macios, Roupas, Superfícies

dinâmicas de água utilizando a funcionalidade

“Softbody” do Blender em “Tempo Real”, utilizando a
BGE (Blender Game Engine)
Por “Christian Thomas Oncken” e “Diego Rangel”

Abstração: A base principal desses sistemas (corpos macios), quando aplicados ao meio dos
games em geral, tem se tornado uma vertente importante para utilização nos Jogos de nova
geração, portanto, utilizando-se da opção de funcionalidade já existente no “Blender 3D”, nós
decidimos fazer uma ferramenta, então nós poderiamos selecionar todos os vértices que irão
ser afetados pela funcionalidade de “Softbody” do “Blender 3D”. Para conseguir isso, nós
utilizamos a funcionalidade de “Vertex Paint” com o auxilio de um Script Python auxiliar, e
todos os vértices pintados seriam ligados a “Constraints” (Funcionalidade de restrições do
“Blender 3D”, transformando estes Vértices em “Estáticos”, oferecendo a opção de utilizá-los
em um “Rig” (Arranjo) de um Objeto do tipo “Softbody” no “Blender 3D”.
A ferramenta necessita de melhorias e automatização, porém por hora foi o que conseguimos.
Tópicos :

1)Script Python

2)Aplicações Práticas

3)Aplicações Secundarias

4)Um Arranjo (Rig) de “Softbody”

5)Rendimento
 1) O Script Python funciona utilizando a funcionalidade de Pintura de Vértices (“Vertex
Paint” do “Blender 3D”) para fazer a chamada dos vértices de maneira a ligá-los com as
restrições (“Constraints” ) (estes vértices podem ou não ser ligados a um Objeto
externo), portanto fornecendo a possibilidade de enganchá-los ou atrelá-los ao Objeto
de uma maneira invisível ou transparente, de maneira a mover o Objeto Renderizado
estrategicamente.

Eis o Script Python auto–explicado (linhas comentadas):

_____________________________________________________________________________
##23 CORES UTILIZADAS
## COR OBJETO 01: 661E2D
## COR OBJETO 03: 54498C
## COR OBJETO 05: 764080
## COR OBJETO 06: 1C7380
## COR OBJETO 07: 979A2A
## COR OBJETO 08: 9A4B08
## COR OBJETO 09: 9A1812
## COR OBJETO 10: 9A565C
## COR OBJETO 11: A0CD00
## COR OBJETO 12: 35CD00

cor01 = -13820314
cor03 = -7583404
cor05 = -8372106
cor06 = -8357543
cor07 = -13985129
cor08 = -16233574
cor09 = -15591270
cor10 = -10725734
cor11 = -16724576
cor12 = -16724683

# Importando o modulo GameLogic e instancias importantes

import GameLogic as g
cont = cont = g.getCurrentController()
obj = cont.owner

### Criando uma Constraint iniciando com uma

### Coordenada indicaca pelo usuário
### Valor de entrada: [x: Float, y: Float, z: Float]
### Valor de entrada: [Nome_de_um_objeto: String]
def constraint(vetPos,objLink):
# Importando Modulo PhysicConstraints
import PhysicsConstraints as pc
# Buscando o id de física do objeto
id = obj.getPhysicsId()
idLink = g.getCurrentScene().objects[objLink].getPhysicsId()
 # Criando uma Constraint
pc.createConstraint( id, idLink, 1,vetPos[0], vetPos[1], vetPos[2])

### Cria Constraints em todos os Vértices que

### já estavam pintados com Vertex Paint
def criaConstraints(objLink, cor):
# Buscando pela malha
malha = obj.meshes[0]
# Buscando a contagem de Vértices
totalVert = malha.getVertexArrayLength(0)
# Percorrendo a lista de vertices
for lista in range( 0, totalVert):
# buscando vertice individualmente
vert = malha.getVertex(0,lista) ####### MUDE DE 0 PARA 1 ###############
if vert.getRGBA() == cor:
# Se o Vértice já estiver pintado, cria uma Constraint
constraint(vert.getXYZ(), objLink)
if objLink == "H_AnteBracoD":
print(objLink, vert.getRGBA())

if "obj_01" in obj:
criaConstraints(obj["obj_01"], cor01)

if "obj_02" in obj:
criaConstraints(obj["obj_02"], cor02)

if "obj_03" in obj:
criaConstraints(obj["obj_03"], cor03)

if "obj_04" in obj:
criaConstraints(obj["obj_04"], cor04)

if "obj_05" in obj:
criaConstraints(obj["obj_05"], cor05)

if "obj_06" in obj:
criaConstraints(obj["obj_06"], cor06)

if "obj_07" in obj:
criaConstraints(obj["obj_07"], cor07)

if "obj_08" in obj:
criaConstraints(obj["obj_08"], cor08)

if "obj_09" in obj:
criaConstraints(obj["obj_09"], cor09)

if "obj_10" in obj:
criaConstraints(obj["obj_10"], cor10)
if "obj_11" in obj:
criaConstraints(obj["obj_11"], cor11)

if "obj_12" in obj:
criaConstraints(obj["obj_12"], cor12)
_____________________________________________________________________________
Você pode criar mais links conforme necessitar, tudo o que você precisa fazer é adicionar mais
cores e mais Objetos ligados a essas cores .

2) Existem muitas aplicações para o Script Python fornecido, você pode tornar partes de
um Objeto endurecidas enquanto outras não, e isso facilita por exemplo operações
como fixar objetos enquanto outras partes continuam macias/esticáveis. Utilizando a
funcionalidade de Pintura de Vértices (“Vertex Paint”) do ”Blender 3D” você pode
selecionar estrategicamente o que quer evitando a maneira tradicional (chata), aonde
você tem de adicionar e configurar as “Constraints” uma a uma. Isso também fornece
a possibilidade de configurar cores de uma maneira personalizada, e você pode utilizar
“GLSL” (Glide Shading Language), ou o modo “Texture Mode” sem preocupações com
a Pintura de Vértices.

3) As aplicações secundarias têm seu lugar no Arranjo de Objetos, nós podemos criar
personagens com partes de seu corpo estrategicamente amolecidas (barriga, seios,
coxas), de fato, utilizando uma aproximação da mesma tecnologia utilizada em outros
simuladores físicos de máquina/motor de jogos (Game Engines) como “Havok” e “Phys
X”, agora possível também utilizando a “Biblioteca Bullet de Simulação Física” mesmo
utilizando uma abordagem não padrão, e nós podemos simular superfícies de água
dinâmicas, além de plantas e árvores, estipulando áreas aonde os movimentos devem
aparecer.

4) O arranjo (“Rig”) de um Objeto “Softbody” dentro do “Blender 3D” tem de geralmente

seguir algumas configurações hierárquicas, sendo elas:
Armature
Bone
Hook
Script Python
Área com “Softbody”
Objeto

Fizemos um simples rascunho da esquemática (“Imagem Ilustrativa 1”):

Rascunho da Esquemática (“Imagem Ilustrativa 1”)

Seguindo essas instruções, você pode criar animações e colocá-las em um Objeto “SoftBody”
com a mesma confiança e qualidade de um “Arranjo de Ossos” (“Bone Rig”) dentro do
“Blender 3D”.

5) Rendimento : Essa palavra assusta a maioria dos usuários quando falam sobre
simulações físicas de Corpos Maleáveis/Macios em jogos, mas com uma boa
configuração, eles podem ser utilizados de maneira imperceptível pelo Jogador (do
ponto de vista de performance/rendimento), caso você preste atenção as seguintes
observações:
a) A opção “Bending Constraints” merece extremo cuidado, pois que é muito faminta
de CPU, e calcula em todos os Vértices, isto é dispendioso para computadores
antigos.
b) As Opções ”Cluster collision”, para colisões entre Objetos “SoftBody” e
“RigidBody”, têm de ser utilizadas com atenção porque é dispendiosa de uma
maneira que, dependendo do número de Iterações (muitos Objetos interagindo),
pode ser fatal para o rendimento em “FPS” (Frames per Second), caso você utilize
ambos, em máquinas mais antigas, recomendamos que você evite uma grande
quantidade de Iterações por que estas serão suavizadas (o algoritmo irá se auto
ajustar), ao mesmo tempo, com dispêndio de CPU.
c) O deslizador para o fator de margem de contato “Margin” também deve ser
ajustado para um valor aceitável, quanto mais você adicionar ao valor, mais poder
de processamento será requerido, conforme esse valor controla a área de contato
entre os Objetos .
d) A opção “Shape Match” pode influir em computadores menos potentes, mas pode
fornecer uma solução eficiente para situações quando você não quiser utilizar a
opção de “Bending Constraints”.
e) Você deve estudar um pouco mais para esses outros atributos na aba, mas eles
possuem menos influência na performance em geral do sistema como um todo.
(Veja “Imagem Ilustrativa 2”)

(imagem ilustrativa)
(Cópia de tela das Opções de Física do “Blender 3D”) “Imagem Ilustrativa 2”
Os testes de performance, com uma base mínima de “FPS” de 30 (Frames per Second), foram
feitos utilizando uma Máquina com capacidades menos poderosas, uma máquina de
performance mediana, e uma estação de trabalho/máquina de jogos. Nós descrevemos estas
abaixo:

1. Fraca capacidade:
• Netbook Acer, Windows XP, Atom CPU, 2,13 Ghz, 3 GB Ram DDR2 , Onboard Graphics (Intel 945 GM)
• Results: 25 flags , 13 -FPS

2. Máquina de performance mediana:

• Notebook Acer, Windows vista , AMD Semprom CPU, 2,40 GHz, 3 GB Ram DDR2, Onboard Graphics
(with GLSL support)
• Results: 60~45 -FPS (monster) , 8~15 (water surface simulation)

3. Estação de trabalho, máquina de Jogos:

• Sony Vaio,Windows XP ,Intel Centrino dual core 2,0 Ghz, Nvidia Ge Force 7500 Go (with GLSL
support) , 1 GB Ram DDR2
• Results: 60~52 FPS (monster) , 15~22 FPS (water surface simulation)

Abaixo, nós explicamos a sequência que utilizamos para fazer um arranjo “Rig” completo de
um personagem:

1. Modelagem
2. Texturização
3. Posicionamento e configuração dos Ossos e Armadura
4. Animar a partir da “Posição de descanso”
5. Gravar poses iniciais
6. Adicionar ganchos “Hooks“ (Parentear Objetos aos Ossos )
7. Nomear corretamente Ossos e ganchos “Hooks” para o sistema.
8. Configurar o Script Python (Dando aos Objetos as cores do Script)
9. Pintar a Malha (dentro do modo de “Vertex Paint” do “Blender 3D”)
10. Configurar o “SoftBody”
11. Adicionar “Logic Bricks” (Always – Script Python)
12. Adicionar todas as “Properties” (Tipo “String”)
13. Adicionar “Logic Bricks” (Animações – Armadura)
14. Dar ao “Soft Body” os ajustes corretos (ajustes finos)
Juntamente com este documento, são enviados algumas demonstrações de sistemas
funcionais dentro do “Blender 3D” utilizando a “BGE” (Blender Game Engine) utilizando esta
técnica/abordagem, exemplificando algumas aplicações práticas utilizando o Script Python
embutido.

Este projeto foi idealizado e executado por:

Christian Thomas Oncken - Mentor do projeto, inspetor do sistema/auxiliar, programador

secundário .

Diego Rangel - Programador principal, modelagem, texturas.

Agradecimentos as seguintes pessoas:

“A todos os que apoiaram esse projeto, incluindo minha família, Allan , Karen, Gislene , Gastão,
Jessica (minha namorada), e a toda comunidade Blender Brasil, incluindo Ivan (Greylica),
Leandro (cerberus),junior silva , jhonny, Vitor Balbio e Letícia. Este projeto é para ser
compartilhado e amplamente difundido, isto é tudo sobre amor, inspiração, carinho e
dedicação. Um real “GRANDE AGRADECIMENTO” ao meu amigo e cooperador neste trabalho
Diego Rangel”

Christian Thomas Oncken

Adaptado, Traduzido e Revisado por “Ivan Paulos Tomé” (Greylica).