Malhas de árvore 3d geradas

Ainda não encontrei uma pergunta nessas linhas, corrija-me se estiver errado.

Árvores (e fauna em geral) são comuns em jogos. Devido à sua natureza, eles são um bom candidato à geração de procedimentos.

Existe o SpeedTree , é claro, se você puder pagar; Até onde eu sei, ele não oferece a possibilidade de gerar suas malhas de árvores em tempo de execução. Depois, há o SnappyTree , um gerador de árvore baseado na webgl baseado no proctree.js, que é cerca de 500 linhas de javascript.

Pode-se usar qualquer um dos métodos acima (ou algum outro gerador de árvore que eu não tenha encontrado) para criar algumas dúzias de malhas de árvores de antemão - ou modelá-las do zero em um modelador 3d - e depois espelhá-las / dimensioná-las aleatoriamente para obter mais algumas variantes ..

Mas eu prefiro ter um gerador de malha de árvore vinculável e gratuito.

Soluções possíveis:

• Port proctree.js para c ++ e lida com a licença de código-fonte aberto (não parece ser gpl, portanto, pode ser possível; o autor também pode estar disposto a cooperar para tornar a licença ainda mais gratuita).
• Role os meus com base em sistemas L.
• Não se preocupe, basta usar árvores geradas offline.
• Use outro método que ainda não encontrei.

Atualização 2015 : acabou portando proctree.js para c ++ https://github.com/jarikomppa/proctree

Eu fiz um bom trabalho nessa área, embora a maioria das minhas demos seja mais antiga:

(flash 2010)
http://genesisbbs.com/appstem.html (clique e arraste o mouse)
http://genesisbbs.com/appstem2.html
(directX 2006)
http://vimeo.com/5206795

É altamente recomendável que você faça o seu próprio, se estiver fazendo isso por diversão. Você quase certamente precisará trabalhar com Quaternions . Compreendê-los é muito difícil, mas você não precisa ir muito fundo para usá-los. Pense em um quaternion como um vetor com um componente extra: rotação. Se você quiser que suas plantas torçam e girem à medida que crescem, elas precisarão de quaternions.

Outras coisas a aprender:
Figuras de Lichtenberg Diagramas de Voronoi do
crescimento da
Lapônia
Algoritmos de algoritmos de vizinhos mais próximos (google)

Eu (pessoalmente) desencorajaria o uso de L-Systems, além de talvez ditar uma gramática para o que cresce onde, ou seja, [semente -> [raiz] / [tronco -> galho -> [flor / folha]]. Os sistemas L não são bons para responder a estímulos ambientais, como direção da luz solar, gravidade, obstáculos, etc.

Quanto à velocidade, uma única árvore pode ser gerada em tempo real. Porém, para fins de memória e desempenho, é provável que você queira apenas gerar um pequeno conjunto de árvores e instalá-las um pouco se estiver lidando com florestas.

A maioria dos geradores de árvores existentes não é tão boa (IMHO), além dos de ponta usados ​​para o Maya e outros.

Eu também recomendo o uso de voxels para gerar a árvore (depois descasque com uma malha, se necessário). A vantagem dos voxels é que você pode simular facilmente algoritmos de crescimento usando coisas como o crescimento da Lapônia e vários autômatos (não o jogo da vida de Conway, mas outras regras produzem resultados interessantes).

Pessoalmente, eu provavelmente começaria com árvores pré-geradas e apenas uma vez que eu tivesse um mecanismo de renderização florestal incrível - completo com arbustos, grama, cogumelos e outras coisas - começaria a procurar se precisar de mais malhas de árvores variáveis.

Dito isto, você pode dar uma olhada no ngPlant . Ele inclui um aplicativo modelador de árvore processual da GPL, mas as bibliotecas que fazem todo o trabalho pesado são licenciadas por BSD. Está escrito em C ++.

Para a renderização florestal, existe o mecanismo de renderização Geometry Paged for Ogre (licenciado pelo MIT) .

O principal problema com as árvores procedurais não é gerá-las, mas renderizá-las todas as estruturas em tempo de execução. Esta é a razão pela qual você verá muitas árvores idênticas nos jogos AAA, não é que eles não pudessem implementar ou escrever tecnologia que criou árvores únicas, é que isso significaria que você precisaria cortar uma série de outros recursos para o jogo para correr.

Se você tiver muitas árvores idênticas, poderá girá-las e possivelmente escalá-las uniformemente para torná-las diferentes de todos os ângulos e, como são idênticas, é possível instalá-las para economizar milissegundos preciosos em cada quadro.

Pensando nesse problema por um segundo, pode haver um meio feliz - que tal gerar algumas partes diferentes de árvores, troncos, galhos, folhas etc. mas aquelas que se encaixam de maneira modular, como o lego da árvore. Então você pode ter muitas combinações e, portanto, algumas árvores bastante únicas, mas também pode ter todas as partes para um jogo de corrida mais rápido.

Eu tropecei na árvore [d] há algum tempo atrás ... usei-a apenas por uma pequena quantidade de tempo para testar um projeto, mas foi apenas porque parei o desenvolvimento - a ferramenta oferece uma ampla variedade de opções de gerador para você brincar e , pelo que me lembro, é bastante rápido. Um link está abaixo.

A desvantagem é que não é um gerador de árvores que você pode incorporar. Você precisaria pré-gerar algumas árvores e modificar os dados ao colocá-los em tempo de execução para ajustar sua singularidade.

O melhor de tudo é que o TreeD é gratuito, e você pode incluir as árvores que você cria em seus próprios projetos, comerciais ou gratuitas, desde que não sejam pacotes de modelos, pacotes de textura, geradores de modelos 3D ou geradores de textura.

Essa é uma pequena solução interessante, e eu a usei em um projeto e posso dizer que é rápido o suficiente para gerar árvores rapidamente porque o jogo está em execução. Certamente não é detalhado, mas se você se livrar dos outdoors, pode ser bem legal.

http://ltrees.codeplex.com/