blender – fazendo uma taça

On October 13, 2009, in trecos, by athanazio
1

opa achei este video muito interessante, que esta me ajudando nas minhas explorações do blender

Tagged with:
 

unity3d passo 1

On September 22, 2009, in games, programacao, unity3d, by athanazio
0

movebox1
Esta eh a primeira aventura com o Unity3D, graças a um esperto tutorial do Erick consegui dar os primeiros passos no Unity3D !! o resultado pode ser encontrado aqui : move-box1

Quero registrar alguns passos importantes que aprendi :

1. O chao vira chao quando vc chama ele de chao :) hehehehe neste exemplo adicionei um cubo usando a opcao : ‘Game Object / Create Other / Cube’, fiz ele ficar mais larguinho para dar mais estabilidade ao movimento e adicionei o component de corpo rigido atraves de : ‘Component / Physics / Rigid Body’ pronto isto bastaria para todos serem felizes e o cubo nao passar do chao quando dah o play.

2. nao entendi ainda como usar um Shader para cada elemento heheheh quando mudo a cor do plano muda a cor da rampinha que fiz

3. adicionei um codigo javascript e arrastei sobre o cubo, pronto !! o metodo update implementado fica valendo para o objeto, e uma variavel que declarei no codigo : var speed:int ficou on inspector do objeto, simplim simplim

olha o codigo usado para o controle de teclado:

var speed: int;
function Update () {
    var x = Input.GetAxis("Horizontal") * speed * Time.deltaTime;
    var y = 0;
    var z = Input.GetAxis("Vertical") * speed * Time.deltaTime;
    transform.Translate(x , y, z );
}

4. e este links salvaram o dia
documentacao sobre o gameplay
documentacao sobre a fisica
documentacao sobre o input
post sobre movimentacao com teclas

por enquanto eh soh, depois tem mais

Tagged with:
 

tutoriais opengl

On September 21, 2009, in trecos, by athanazio
0

7_lod
procurei procurei e encontrei estes otimos tutoriais de openGl
http://www.swiftless.com/tutorials/opengl/opengltuts.html

Tagged with:
 

criador de mundos

On March 11, 2009, in trecos, by athanazio
0

criador-de-mundos
Lindo filme, onde a ficção científica e a construção de fantásticas interfaces com o usuário, mostram possibilidades maravilhosas do uso da tecnologia para o bem estar. Fiquei emocionado com o filme, muito bonito mesmo … tem umas sacadas de interface que eu adorei, capturei algumas imagens, delas mas o melhor mesmo eh ver em ação no filme, veja soh:
world-builder-color-palete
world-builder-keyboard world-builder-rotate world-builder-texture world-builder-vertical-meter

veja o video

Tagged with:
 

xna scene graph tutorial

On January 7, 2009, in games, programacao, by athanazio
0
Tagged with:
 

Jmonkey começando

On December 17, 2006, in trecos, by athanazio
0

Estou começando a estudar uma nova game engine 3D  ! Jmonkey !

o primeiro desafio foi a paciência para baixar o projeto do cvs que fica no java.net, e depois dar uma configurada no projeto para usar as libraries, e por fim marcar no jar do lwjgl aonde encontrar as DLLs necessarias para o mapeamento OpenGL

tem um tutorial de como configurar no eclipse

tenho de agradecer ao Mark Powell, pela sacada das bibliotecas nativas no eclipse

por fim consegui rodar os exemplos :D e vou começar a seguir o tutorial http://www.jmonkeyengine.com/wiki/doku.php?id=learning_jme

jmonkey_primeiro_teste.jpg

Tagged with:
 

arquivos do Warcraft 3

On November 25, 2006, in games, by athanazio
1

neste meche meche de games e modelagem 3D achei uma ferramenta para abrir os arquivos com os dados do jogo Warcraft3 …

veja mais : http://www.riogdug.org/viewtopic.php?t=38

Tagged with:
 

modelagem 3D

On November 25, 2006, in trecos, by athanazio
0

achei uma ferramenta otima, barata e simples para modelar objetos 3d

veja mais : http://www.riogdug.org/viewtopic.php?t=37&highlight=

Tagged with:
 

Movendo um cubo na paisagem

On November 23, 2006, in trecos, by athanazio
3

E continuo me divertindo com o jpct ! agora estou quase entendendo alguns trechos do código hehehe, mas para minha satisfação consegui isolar o código para um possível jogo em um JComponent e fiz alguns ajustes para permitir rodar tanto num Applet quanto num JFrame.

clique aqui para ver o resultado final

clique em veja mais para ver o código fonte (more…)

Tagged with:
 

rodando o cubo v2

On November 20, 2006, in trecos, by athanazio
0

a primeira versão precisava ficar teclando a rotação, neste fazendo uso do tratamento de teclado que o engine oferece, dah para ficar com a tecla pressionada direto e a rotação vai rolando … isto vai ser util depois acreditem hehehehe :D

as mudanças foram a criação das variáveis para controlar que tecla esta sendo pressionada e colocar um chamada ao método rotateCube() no mainloop da classe

RotateTheCube.java
01   private static final float ROTATE_ANGLE = 
02     (floatMath.toRadians(20.0);
03 
04   private static boolean left = false;
05 
06   private static boolean right = false;
07 
08   private static boolean up = false;
09 
10   private static boolean down = false;
11 
12   private void keyAffected(KeyState state) {
13     int code = state.getKeyCode();
14     boolean event = state.getState();
15 
16     switch (code) {
17     case (KeyEvent.VK_ESCAPE){
18       exit = event;
19       break;
20     }
21     case (KeyEvent.VK_UP){
22       up = event;
23       break;
24     }
25     case (KeyEvent.VK_DOWN){
26       down = event;
27       break;
28     }
29     case (KeyEvent.VK_LEFT){
30       left = event;
31       break;
32     }
33     case (KeyEvent.VK_RIGHT){
34       right = event;
35       break;
36     }
37     }
38   }
39 
40   private void rotateCube() {
41     if (up)
42       box.rotateX(ROTATE_ANGLE);
43     if (down)
44       box.rotateX(-ROTATE_ANGLE);
45     if (left)
46       box.rotateY(ROTATE_ANGLE);
47     if (right)
48       box.rotateY(-ROTATE_ANGLE);
49   }
Tagged with:
 

rodando o cubo …

On November 20, 2006, in trecos, by athanazio
0

mais aventuras na arena 3D, no episódio de hoje o cubo roda com controle do teclado … grandes coisa … :D

Este é um trecho de código feito em cima do HelloWorld, adicionei alguns tratamentos de tecla e chamei alguns métodos de rotação de objeto, vale lembrar que o método recebe os graus da rotação em radianos, por isto a conversão da linha 01, e usei os negativos para rodar no sentido anti-horário.

RotateTheCube.java
01   private static final float ROTATE_ANGLE = (floatMath.toRadians(20.0);
02   
03   private void keyAffected(KeyState state) {
04     int code = state.getKeyCode();
05     boolean event = state.getState();
06 
07     switch (code) {
08     case (KeyEvent.VK_ESCAPE){
09       exit = event;
10       break;
11     }
12     case (KeyEvent.VK_UP){
13       rotateUp();
14       break;
15     }
16     case (KeyEvent.VK_DOWN){
17       rotateDown();
18       break;
19     }
20     case (KeyEvent.VK_LEFT){
21       rotateLeft();
22       break;
23     }
24     case (KeyEvent.VK_RIGHT){
25       rotateRight();
26       break;
27     }
28     }
29   }
30 
31   private void rotateRight() {
32     box.rotateZ(-ROTATE_ANGLE);
33   }
34 
35   private void rotateLeft() {
36     box.rotateZ(ROTATE_ANGLE);
37   }
38 
39   private void rotateUp() {
40     box.rotateX(ROTATE_ANGLE);
41   }
42 
43   private void rotateDown() {
44     box.rotateX(-ROTATE_ANGLE);
45   }
Tagged with:
 

HelloWorld 3D :)

On November 20, 2006, in games, by athanazio
2

Aee este é o começo de uma nova aventura pelo mundo 3D, este é meu HelloWorld usando a biblioteca JPCT (thanks for the help EgonOlsen !), segue o código :

HelloWorld.java
001 import java.awt.Graphics;
002 import java.awt.Insets;
003 import java.awt.event.KeyEvent;
004 
005 import javax.swing.JFrame;
006 
007 import com.threed.jpct.Camera;
008 import com.threed.jpct.Config;
009 import com.threed.jpct.FrameBuffer;
010 import com.threed.jpct.IRenderer;
011 import com.threed.jpct.Lights;
012 import com.threed.jpct.Object3D;
013 import com.threed.jpct.Primitives;
014 import com.threed.jpct.SimpleVector;
015 import com.threed.jpct.TextureManager;
016 import com.threed.jpct.World;
017 import com.threed.jpct.util.KeyMapper;
018 import com.threed.jpct.util.KeyState;
019 
020 public class HelloWorld extends JFrame {
021 
022   private FrameBuffer buffer = null;
023 
024   private World world = null;
025 
026   private TextureManager textureManager = null;
027 
028   private Camera camera = null;
029 
030   private int width = 640;
031 
032   private int height = 480;
033 
034   private Graphics g = null;
035 
036   /**
037    * main method
038    */
039   private static final long serialVersionUID = 1L;
040 
041   public static void main(String[] args) {
042     HelloWorld h = new HelloWorld();
043   }
044 
045   private boolean exit = false;
046 
047   private int titleBarHeight;
048 
049   private int leftBorderWidth;
050 
051   private KeyMapper keyMapper;
052 
053   private void gameLoop() {
054     World.setDefaultThread(Thread.currentThread());
055 
056     buffer = new FrameBuffer(width, height, FrameBuffer.SAMPLINGMODE_NORMAL);
057     buffer.enableRenderer(IRenderer.RENDERER_SOFTWARE);
058 
059     while (!exit) {
060       buffer.clear();
061       world.renderScene(buffer);
062       world.draw(buffer);
063       buffer.update();
064       poll();
065       buffer.display(g, leftBorderWidth, titleBarHeight);
066       Thread.yield();
067 
068       try {
069         Thread.sleep(200);
070       catch (InterruptedException e) {
071       }
072     }
073 
074     System.exit(0);
075   }
076 
077   /**
078    */
079   public HelloWorld() {
080     setFrameStuff();
081     add3DStuff();
082     gameLoop();
083   }
084 
085   private void setFrameStuff() {
086     setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
087     setTitle("jPCT Hello World (" + Config.getVersion() ")");
088     pack();
089     Insets insets = getInsets();
090     titleBarHeight = insets.top;
091     leftBorderWidth = insets.left;
092     setSize(width + leftBorderWidth + insets.right, height + titleBarHeight
093         + insets.bottom);
094     setResizable(false);
095     setLocationRelativeTo(null);
096     setVisible(true);
097     g = getGraphics();
098     keyMapper = new KeyMapper(this);
099   }
100 
101   private void add3DStuff() {
102     world = new World();
103     textureManager = TextureManager.getInstance();
104     Object3D box = Primitives.getBox(501);
105     box.setOrigin(new SimpleVector(000));
106     world.addObject(box);
107     world.buildAllObjects();
108     /**
109      * Place the camera at the starting position.
110      */
111     setCamera(box);
112     setLight();
113   }
114 
115   private void setCamera(Object3D box) {
116     camera = world.getCamera();
117     camera.setPosition(0, -100200);
118     camera.lookAt(box.getTransformedCenter());
119   }
120 
121   private void setLight() {
122     // Config.fadeoutLight = false;
123     world.getLights().setOverbrightLighting(
124         Lights.OVERBRIGHT_LIGHTING_DISABLED);
125     world.getLights().setRGBScale(Lights.RGB_SCALE_2X);
126     world.setAmbientLight(253030);
127 
128     /**
129      * Place the lightsources...
130      */
131     world.addLight(new SimpleVector(0, -1500)252219);
132     world.addLight(new SimpleVector(-100, -150100)2254);
133     world.addLight(new SimpleVector(100, -150, -100)4222);
134 
135   }
136 
137   /**
138    * Use the KeyMapper to poll the keyboard
139    */
140   private void poll() {
141     KeyState state = null;
142     do {
143       state = keyMapper.poll();
144       if (state != KeyState.NONE) {
145         keyAffected(state);
146       }
147     while (state != KeyState.NONE);
148   }
149 
150   private void keyAffected(KeyState state) {
151     int code = state.getKeyCode();
152     boolean event = state.getState();
153 
154     switch (code) {
155     case (KeyEvent.VK_ESCAPE){
156       exit = event;
157       break;
158     }
159     }
160   }
161 }
Observe que na verdade é um Jframe que serve de container para o desenho, na linha 97 fica a ligação onde guardo o objeto Graphics que será usado no gameloop() para desenhar a interface … é claro que este HelloWorld não faz muita coisa (na verdade quase nada hehehe) mas cria um objeto 3D na tela e permite que com Esc vc saia do programa, para funcionar precisa da biblioteca JPCT que pode ser baixada em : http://www.jpct.net/download.html
Veja o resultado visual
helloworld_3d.jpg
Tagged with: