Olá a todos! Ontem conheci um blogueiro, Max Teslenko, ele possui em seu blog, muitas dicas semelhantes às que eu gosto de publicar. Uma delas é esta que irei expor aqui.

Para os que usam Ogre3D e acham chato sempre ter que definir os parâmetros de projeto, ou mesmo para aqueles que não sabem [...]]]>

Olá a todos! Ontem conheci um blogueiro, Max Teslenko, ele possui em seu blog, muitas dicas semelhantes às que eu gosto de publicar. Uma delas é esta que irei expor aqui.

Para os que usam Ogre3D e acham chato sempre ter que definir os parâmetros de projeto, ou mesmo para aqueles que não sabem como fazê-lo, aqui vai uma dica bem legal: Max Tyslenko fez um template bem simples para Ogre3D.

O arquivo pode ser baixado aqui: OgreTemplate.rar.

Para reduzir o tamanho do arquivo, os arquivos de mídia foram removidos do projeto, para tornar o projeto funcional, faz-se necessário copiar essa pasta do diretorio do Ogre para OgreTemplate/OgreTemplate.

Essa informação deve estar no site oficial, contudo não consegui encontrar versoes funcionais. Por isso estou a escrever esse artigo e divulgar esse arquivo.

Para que esta solução funcione, a variabel de ambiende “OGRE_HOME” tem de estar corretamente configurada, caso tenha alguma dúvida sobre este assunto, tente aqui: http://tinyurl.com/ylxcfzz

Vou expilcar o processo utilizado para gerar o template acima:

Para começar, crie um novo projeto, clicamos no Solution Explorer, botão direito do mouse e escolha Propriedades:

Na imagem que aparecer:

Na aba à esquerda, clique em Linker/Input e coloque campo Additional Dependencies OgreMain_d.lib OIS_d.lib assim como o mostrado na figura abaixo.

Na aba à esquerda, clique em Linker, e no campo Additional Library Directories, escreva $(OGRE_HOME)\lib , o mesmo que o que a imagem abaixo mostra.

Na aba à esquerda, clique em C/C++ e no campo Additional Include Directories, digite “$(OGRE_HOME)\include”;..\include;”$(OGRE_HOME)\samples\include” , o mesmo conteudo mostrado na imagem abaixo:

O código de exemplo que posso dar é o abaixo, pode colocá-lo como o main.cpp do seu projeto.

#include "ExampleApplication.h"

// Declare a subclass of the ExampleFrameListener class
class MyListener : public ExampleFrameListener
{
public:
    MyListener(RenderWindow* win, Camera* cam) : ExampleFrameListener(win, cam)
    {
    }

    bool frameStarted(const FrameEvent& evt)
    {
        return ExampleFrameListener::frameStarted(evt);
    }

    bool frameEnded(const FrameEvent& evt)
    {
        return ExampleFrameListener::frameEnded(evt);
    }
};

// Declare a subclass of the ExampleApplication class
class SampleApp : public ExampleApplication
{
public:
   SampleApp()
   {
   }

protected:
   // Define what is in the scene
   void createScene(void)
   {
       // put your scene creation in here
   }

   // Create new frame listener
   void createFrameListener(void)
   {
       mFrameListener = new MyListener(mWindow, mCamera);
       mRoot->addFrameListener(mFrameListener);
   }
};

#ifdef __cplusplus
extern "C" {
#endif

#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
#define WIN32_LEAN_AND_MEAN
#include "windows.h"
INT WINAPI WinMain(HINSTANCE hInst, HINSTANCE, LPSTR strCmdLine, INT)
#else
int main(int argc, char **argv)
#endif
{
    // Instantiate our subclass
    SampleApp myApp;

    try {
        // ExampleApplication provides a go method, which starts the rendering.
        myApp.go();
    }
    catch (Ogre::Exception& e) {
#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
        MessageBoxA(NULL, e.getFullDescription().c_str(), "An exception has occured!", MB_OK | MB_ICONERROR | MB_TASKMODAL);
#else
        std::cerr << "Exception:\n";
        std::cerr << e.getFullDescription().c_str() << "\n";
#endif
        return 1;
    }

return 0;
}

#ifdef __cplusplus
}
#endif

O último passo é copiar as bibliotecas necessárias e os arquivos de mídia na pasta do projeto. No nosso caso, tudo isso deve ser copiado para uma subpasta do projeto com o mesmo nome.

Qualquér dúvida, basta perguntar aqui, que terei prazer em responder.

Existe um grande problema na área de games que é o carregamento de mapas. Uma das soluções mais utilizadas  é utilizar estruturas quadtrees para games 2D e octatrees para games 3D.

Quadtree é um tipo de estrutura na qual tem-se um nó raiz(quadrado maior) que se abre em 4 filhos, aonde cada filho será responsável por [...]]]> Existe um grande problema na área de games que é o carregamento de mapas. Uma das soluções mais utilizadas  é utilizar estruturas quadtrees para games 2D e octatrees para games 3D.

Quadtree é um tipo de estrutura na qual tem-se um nó raiz(quadrado maior) que se abre em 4 filhos, aonde cada filho será responsável por um quadrante do quadrado repesentado pelo nó pai.

De maneira análoga, o octatree é uma estrutura na qual se tem um nó raiz(cubo maior) que se abre em 8 filhos, aonde cada filho será responsável por um octante do cubo representado pelo nó pai.

Agora vamos aos exemplos práticos:

Para exemplificar o Quadtree, encontrei neste site um applet exemplificando o quadtree, o mesmo segue logo abaixo. Para adicionar pontos na estrutura, clique no quadrado, para visualizar a estrutura da árvore clique em show tree.

Your browser does not support Java, so nothing is displayed.

Para exemplificar uma octree, não encontrei nenhum applet, mas encontrei uma outra estrutura de dados para mapas 3D: BSP. Para usar o exemplo abaixo, basta utilizar o primeiro quadrado. Dentro dele, para desenhar uma parede no mapa, clique e arraste com o botão direito. Para mover a camera clique com o botão esquerdo no ponto vermelho e arraste. Os demais campos são representações do mapa.

Your browser does not support Java, so nothing is displayed.

Nesta sexta-feira(20/11/2009) tentamos implementar árvores quadtree.

• Eu fiz um exemplo em C# e com XNA:
  • Codigo-Fonte (necessita do XNA framework 3.1 e Visual Studio C# 2008)
  • Executavel (necessita do XNA 3.1 Redistributable e .NET 3.5)
• Ian Liu juntamente com o Fenando Lucchesi implementaram em Python com Pygame
  • Código-Fonte (necessita do Pyhon e do Pygame)

Espero que tenham gostado, qualquer dúvida, entre em contato.

Como alguns sabem, OpenCL é um padrão de programação de GPU computing (GPGPU) desenvolvido inicialmente pela apple e agora é open source.

A ATI tinha seu projeto chamado Close to Metal (CTM) para programar os shaders de suas placas, mas que não caiu no agrado dos programadores por ser um tanto mais complexo que o seu [...]]]> Como alguns sabem, OpenCL é um padrão de programação de GPU computing (GPGPU) desenvolvido inicialmente pela apple e agora é open source.

A ATI tinha seu projeto chamado Close to Metal (CTM) para programar os shaders de suas placas, mas que não caiu no agrado dos programadores por ser um tanto mais complexo que o seu concorrente CUDA da Nvidia.

O problema principal era que as maiores fabricantes de placas gráficas estavam produzindo linguagens diferentes para o mesmo propósito.
Acredito eu que a ATI deu o braço a torcer e adotou o OpenCL como seu padrão para esse tipo de programação de alto desempenho e com isso deu deu um grande passo para a unificação do OpenCL uma vez que agora a Nvidia também está usando OpenCL junto com o CUDA.

Esses dias, acabei descobrindo que o novo driver beta da Nvidia consegue rodar coisas programadas com OpenCL , contudo a Nvidia ainda não lançou nenhuma IDE, ou SDK para OpenCL, eles possuem uma idéia promissora com o Nexus, que vale a pena conferir, mas ainda não possuem algo palpável ainda com OpenCL.

A ATI desenvolveu um SDK que compila em OpenCL, o Stream SDK e exitem alguns usuários Nvidia utilizando-o para programar em OpenCL. Espero tambem ser um desses usuários…

Agora me pergunto: OpenCL, CUDA ou CTM? Algumas pessoas na ultima “Nvidia’s GPU Developer’s Conference” afirmaram que o desempenho do mesmo algoritmo rodado em OpenCL era muito mais lento do que o rodado com CUDA, mas convenhamos, o driver para OpenCL na Nvidia teve sua primeira implementação agora e foi em um driver beta… Imagino que o desempenho sempre fique menor no OpenCL, por não utilizar instruções próprias e especificas do processador da Nvidia, mas acredito que esse hiato venha a diminuir com a melhoria do driver.

Na minha humilde opinião, acredito que o mais promissor seria aprender OpenCL ao invés de CUDA.

Busquem e testem por si mesmos:

Primeiro driver beta da Nvidia que suporta OpenCL, Versão 195.39: http://www.nvidia.com/Download/Find.aspx?lang=en-us

Nexus da Nvidia: http://developer.nvidia.com/object/nexus.html:

Clique aqui para assistir o vídeo inserido.

Stream SDK da ATI: http://developer.amd.com/GPU/ATISTREAMSDKBETAPROGRAM/Pages/default.aspx

Espero que tenham gostado e eu tenha atiçado a curisidade.

Comentem!

]]> http://tolstenko.net/2009/11/14/opencl/feed/ 0 http://tolstenko.net/2009/11/14/physaxe-engine-fisica-para-flash/ http://tolstenko.net/2009/11/14/physaxe-engine-fisica-para-flash/#comments Sat, 14 Nov 2009 12:14:10 +0000 Alexandre http://tolstenko.net/?p=348

Um colega meu, “Ian Liu” do grupo de jogos me apresentou uma engine fisica 2D em flash para haXe: Physaxe. A proposta dele é que o grupo destinado a pesquisar desenvolvimento de jogos em 2D busque soluções que incorporem coisas assim.

Parafraseando o próprio autor: “Um demo vale mais que 1000 palavras”.

Aqui em baixo, você pode [...]]]> Um colega meu, “Ian Liu” do grupo de jogos me apresentou uma engine fisica 2D em flash para haXe: Physaxe. A proposta dele é que o grupo destinado a pesquisar desenvolvimento de jogos em 2D busque soluções que incorporem coisas assim.

Parafraseando o próprio autor: “Um demo vale mais que 1000 palavras”.

Aqui em baixo, você pode testar um demo usando a tal engine: Use as teclas 1-8 para alterar o demo e clique em algum lugar do objeto abaixo para atirar blocos.

(Para saber mais sobre o sistema, clique no link “Continue lendo…”)

O interessante é q o binário gerado aqui é de apenas 28KB. Minúsculo e bem otimizado.

Para quese possa ver o consumo da CPU, aperte a tecla D para parar de desenhar e verifique no gerenciador de recursos do seu sistema operacional, o consumo do game funcionando e sem funcionar.

Outro exemplo interessante que vem com o código fonte é esse de gravidade:

Para rodar esse demo, faça isso:

• Instale haXe
• Execute o comando haxelib install physaxe para instalar a biblioteca do Physaxe.
• Copie e cole o código Test.hx
• Excecute: haxe -swf9 test.swf -main Test -lib physaxe para compilar
• Boa diversão!

Codigo:

class Test {
 
    var root : flash.display.MovieClip;
    var world : phx.World;
 
    function new(root) {
        this.root = root;
        var w = root.stage.stageWidth;
        var h = root.stage.stageHeight;
        world = new phx.World(new phx.col.AABB(0,0,w,h),new phx.col.SortedList());
        var p0 = phx.Const.DEFAULT_PROPERTIES;
        p0.biasCoef = 0.3;
        p0.maxDist = 2;
        world.sleepEpsilon = 0; // no sleep (gravity can change anytime)
        var floor = new phx.Body(0,0);
        floor.addShape(phx.Shape.makeBox(w,30,0,0));
        floor.addShape(phx.Shape.makeBox(w,30,0,h-30));
        floor.addShape(phx.Shape.makeBox(30,h,0,0));
        floor.addShape(phx.Shape.makeBox(30,h,w-30,0));
        floor.isStatic = true;
        world.addBody(floor);
        var mat = new phx.Material(0,0.3,1);
        for( i in 0...100 ) {
            var points = new Array();
            var size = (10 + Std.random(20)) * 0.7;
            var a = 2 * Math.PI;
            do {
                points.push(new phx.Vector(Math.cos(a) * size,Math.sin(a) * size));
                a -= (Std.random(20) + 5) * 0.1;
            } while( a > 0 );
            var shape = new phx.Body(Std.random(w - 100) + 50,Std.random(h - 100) + 50);
            shape.addShape(new phx.Polygon(points,new phx.Vector(0,0),mat));
            world.addBody(shape);
        }
    }
 
    function update() {
        var w = root.stage.stageWidth;
        var h = root.stage.stageHeight;
        var xf = (root.mouseX / w) * 2 - 1;
        var yf = (root.mouseY / h) * 2 - 1;
        world.gravity.x = xf * 0.5;
        world.gravity.y = yf * 0.5;
        world.step(1.0,20);
        root.graphics.clear();
        var d = new phx.FlashDraw(root.graphics);
        d.shape.lineSize = 0.5;
        d.staticShape.line = null;
        d.drawWorld(world);
    }
 
    public static function main() {
        var mc = flash.Lib.current;
        var t = new Test(mc);
        mc.stage.quality = flash.display.StageQuality.MEDIUM;
        mc.addEventListener(flash.events.Event.ENTER_FRAME,function(_) t.update());
    }
 
}

Para nosso desenvolvimento de games, utilizaremos a versão mais atual do Ogre, e para tal, precisaremos compilar o Ogre3D a partir do seu repositório SVN.

(Este passo-a-passo é voltado para os usuários windows)

Para tanto, utilizaremos:

Implementei uma classe simples, mas interessante, ela faz o fade de imagens. Ela permite a exibição de imagens da mesma maneira que encontramos no inicio de alguns games: o logo de uma empresa, depois outro logo e assim vai até entrar num filmezinho ou entrar no menu inicial do game. Observe que vc poderá modificar [...]]]> Implementei uma classe simples, mas interessante, ela faz o fade de imagens. Ela permite a exibição de imagens da mesma maneira que encontramos no inicio de alguns games: o logo de uma empresa, depois outro logo e assim vai até entrar num filmezinho ou entrar no menu inicial do game. Observe que vc poderá modificar essa classe para fazer outras coisas interessantes como fazer a imagem crescer, diminuir… etc.

O código segue abaixo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185

using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Content;
 
namespace MetalX.Efeitos
{
    class Fade
    {
        #region atributos
        Texture2D textura;
        SpriteFont fonte;
        estadoImg meuEstado;
        int alfaAtual;
        double tempoEsperaAcender;
        double tempoEsperaFim;
        double tempoAcesa;
        double horaInicioAcesa;
 
        int velAlfa;
 
        #endregion
 
 
        #region enums
 
        /// 
        /// enum for the image state
        /// 
        public enum estadoImg
        {
            Apagada,
            Acendendo,
            Acesa,
            Apagando,
            PreFim,
            Fim
        }
 
        #endregion
 
 
 
        #region propriedades
 
        public int Width { get { return textura.Width; } }
        public int Height { get { return textura.Height; } }
 
        /// 
        /// Atribute for MeuEstado
        /// 
        public estadoImg MeuEstado { get { return meuEstado; }
                                     set { meuEstado = value; } }
 
        /// 
        /// Valor em segundos, podendo ser fracionario que se espera para
        /// comecar a imagem
        public double TempoEsperaAcender { set { tempoEsperaAcender = value; }
                                           get { return tempoEsperaAcender; } }
 
        /// 
        /// warning!! the alfa value must be between 0 and 255
        /// 
        public int AlfaAtual { set { alfaAtual = value; }
                               get { return alfaAtual; } }
 
        /// 
        /// value in seconds, the value may be fractional. is the time waited 
        /// waited to draw another image
        public double TempoEsperaFim { set { tempoEsperaFim = value; }
                                       get { return tempoEsperaFim; } }
 
        /// 
        /// The velocity that alfa changes
        /// 
        public int VelAlfa { get { return velAlfa; } set { velAlfa = value; } }
 
        /// 
        /// time to wait in seconds of the duration of the fully painted image
        /// 
        public double TempoAcesa { get { return tempoAcesa; }
                                   set { tempoAcesa = value; } }
 
        /// 
        /// the exact time of the end of the last image state
        /// 
        public double HoraInicioAcesa { set { horaInicioAcesa = value; }
                                        get { return horaInicioAcesa; } }
 
        #endregion
 
        /// 
        /// Class construtor
        /// 
        /// 

Com essa idéia, pude fazer com que se desenhasse uma imagem apos a outra, instanciando um objeto de cada vez e transitando de uma imagem para outra quando a anterior chegar no estado fim.

Começo com esse post, uma série de artigos desenvolvidos por mim com o intúito de aprender ensinar como programar jogos em XNA. O mote desse projeto é o fato consumado de que muitos brasileiros são apaixonados por jogos, inclusive eu, mas não possuem, à sua disposição, um material tal qual eu busco construir seguindo essas [...]]]>

Começo com esse post, uma série de artigos desenvolvidos por mim com o intúito de aprender ensinar como programar jogos em XNA. O mote desse projeto é o fato consumado de que muitos brasileiros são apaixonados por jogos, inclusive eu, mas não possuem, à sua disposição, um material tal qual eu busco construir seguindo essas diretivas:

• Claro (fácil de entender);
• Conciso (o material todo mastigadinho e resumido);
• Dinâmico (enérgico, se bate de um lado e ja está do outro);
• Referenciável (como um caderno de consulta por assuntos estudados);
• Em português (nossa! é um horror ter que ler tudo em inglês);
• E o mais importante de tudo: um material DIVERTIDO.

Irei fazer o processo inverso de uma produção de artigos, ou séries de artigos: falarei primeiro das referências usadas para o estudo. Pois assim fica mais fácil para os curiosos que, come eu, gostam de pular algumas etapas no aprendizado. E de qualquer forma, poderei livremente falar usando citações, sem que me importunem chamem à atenção sobre direitos autorais.

1. – Professional XNA Game Programming – Meu primeiro livro sobre XNA. Focado no XNA 1.0, que sofreu algumas mudanças, mas com ele aprendí as idéias e a logica desse tipo de programação. Possui muito código de exemplo e também explica muitissimo bem.
2. – Begining XNA 2.0 Game programming – From Novice to Professional. Busquei esse livre mais pelo fato dos escritores serem brasileiros e para me atualizar para as mudanças para XNA 2.0.
3. – Learning XNA 3.0. Estou comprando esse hoje, espero que chegue inteiro e não se perca pelo meio do caminho. Nem sei como vai ser. Pelo que eu li… parece que promete.
4. Gamux – Grupo de jogos da UNICAMP. Foi lá aonde tudo começou.
5. SharpGames – Excelente lugar para se encontrar material em português.
6. XNA Creators Club- O lugar onde as pessoas podem encontrar exemplos de codigos para baixar, e, tambem starterkits.
7. Xna Developer Center e XNA Library – Material mais hardcore e guia de referencia de funções.

Agora é “só” falta seguir essas coisas que daqui à pouco alguem da MS Games te liga te chamando para trabalhar lá… (huahehaui) Ai ai… mas não tem nada não, sonhar faz bem né?

Só para não estimular tanto vocês, os programadores de games de verdade programam em algo semelhante ao Assembly. E aí negão, tú se lascou! (heahuheuhi) Mas não desestimulem não, porque se aprendermos um framework do nível do XNA, passar para qualquer outra coisa fica muito mais fácil.

Aquele abraço!