Les propongo un desafio: 2d Bones...

Encuentra personas para llevar adelante tu proyecto, muestra el progreso de esos proyectos y participa en competencias grupales.

Moderador: Dokan

Les propongo un desafio: 2d Bones...

Notapor hugoruscitti » Dom Dic 27, 2009 6:43 pm

Saludos, quería proponerles un desafío a ver quien
se anima a realizarlo.

La idea es construir un ejemplo sobre una técnica que
se utiliza en algunos videojuegos llamada bones aplicada
a gráficos en 2D. Y este ejemplo, una vez creado
se podría agregar en la sección de ejemplos de la
web de losersjuegos.

Existe un minitutorial con los conceptos generales
de esta técnica en el siguiente video:

http://www.youtube.com/watch?v=ZNxO5tniTlM


Y encontré algunos videos que a mi entender son un
ejemplo de bones en juegos o dibujos 2D:

<object width="425" height="344"><param name="movie" value="http://www.youtube.com/v/w3nwkXJIOTk&hl=es_ES&fs=1&"></param><param name="allowFullScreen" value="true"></param><param name="allowscriptaccess" value="always"></param><embed src="http://www.youtube.com/v/w3nwkXJIOTk&hl=es_ES&fs=1&" type="application/x-shockwave-flash" allowscriptaccess="always" allowfullscreen="true" width="425" height="344"></embed></object>


<object width="425" height="344"><param name="movie" value="http://www.youtube.com/v/TvCwB_UlOe4&hl=es_ES&fs=1&"></param><param name="allowFullScreen" value="true"></param><param name="allowscriptaccess" value="always"></param><embed src="http://www.youtube.com/v/TvCwB_UlOe4&hl=es_ES&fs=1&" type="application/x-shockwave-flash" allowscriptaccess="always" allowfullscreen="true" width="425" height="344"></embed></object>


<object width="425" height="344"><param name="movie" value="http://www.youtube.com/v/ldcx8XeVQ5o&hl=es_ES&fs=1&"></param><param name="allowFullScreen" value="true"></param><param name="allowscriptaccess" value="always"></param><embed src="http://www.youtube.com/v/ldcx8XeVQ5o&hl=es_ES&fs=1&" type="application/x-shockwave-flash" allowscriptaccess="always" allowfullscreen="true" width="425" height="344"></embed></object>


Entonces, ¿alguien se anima?, ¿conocen tutoriales, videos
o documentos para recomendar?.
Avatar de Usuario
hugoruscitti
Site Admin
 
Mensajes: 1242
Registrado: Dom Jul 30, 2006 3:57 am
Ubicación: Buenos Aires, Argentina

Notapor Adri » Lun Dic 28, 2009 8:27 pm

Hola,
Como siempre, estoy muy liado para meterme a hacer nada, pero curioseando un poco encontré un gran tutorial acerca de esa técnica. Esta en inglés y sin acabar(es muy muy extenso). Les dejo el enlace para quien se anime a hacer el ejemplo tenga algo más de biografía.

http://gpwiki.org/index.php/OpenGL:Tuto ... nes_System

Un saludo
Adri
 
Mensajes: 4
Registrado: Jue Mar 05, 2009 2:42 pm

Notapor endaramiz » Mar Dic 29, 2009 10:33 am

Yo estoy interesado pero acabo los exámenes el 18 de enero y tampoco le podría dedicar muchas horas. Así que si queréis comenzar sin mí no pasa nada, ya iré siguiendo y comentando alguna cosa y luego intento reengancharme.

Saludos.
Avatar de Usuario
endaramiz
 
Mensajes: 283
Registrado: Vie Ago 31, 2007 9:25 am
Ubicación: Barcelona

Notapor Juan Carlos » Mié Dic 30, 2009 3:05 am

La verdad es que parece muy interesante. Voy a ver si puedo hacer algun mini ejemplo en python.

Igualmente si alguien tambien esta interesado podemos coordinar para trabajar en equipo.

Saludos
Juan Carlos
 
Mensajes: 97
Registrado: Sab Jul 07, 2007 1:05 pm

Primera prueba

Notapor endaramiz » Dom Ene 03, 2010 12:14 am

Hola, llevo varios días haciendo un documento sobre un programa y me estaba aburriendo mucho así que he decidido "programar de verdad".

He hecho un brazo de 2 grados de libertad que traza caminos rectilíneos de un punto a otro, durante un tiempo predefinido, por cinemática inversa.

He utilizado OpenGL porque me parece muy útil poder utilizar las transformaciones geométricas. Aunque aun sigo sin dominar la API.

Código: Seleccionar todo
#include <iostream>
#include <SDL/SDL.h>
#include <GL/gl.h>
#include <cmath>
using namespace std;

#define SCREEN_S_W 640
#define SCREEN_S_H 640
#define CLIP_REGION_W 100
#define CLIP_REGION_H 100

float tcos3f(float l1, float a, float l2) {
    return acos((l1*l1-a*a+l2*l2)/(2*l1*l2));
}

float hip(float c1, float c2) {
    return sqrt(c1*c1+c2*c2);
}

float deg(float a) {
    return a*360/(2*M_PI);
}

void initGL() {
    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
    glShadeModel(GL_SMOOTH);
    glClearColor( 1.0f, 1.0f, 1.0f, 0.0f );
    glEnable( GL_DEPTH_TEST );

    glPointSize(8);
    glLineWidth(4);

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();

    glOrtho(0.0f, CLIP_REGION_W, 0.0f, CLIP_REGION_H, -10.0f, 10.0f);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
}

struct Hueso {
    float dist, angulo;
};

class Brazo2GL {
    public:
        Brazo2GL();
        void mover_a(float x, float y, float tiempo);
        void update(float tiempo);
        void draw();
    private:
        Hueso m_brazo, m_antebrazo;
        float m_px, m_py;
        float m_x, m_y, m_x0, m_y0, m_xF, m_yF;
        float m_tiempo, m_tiempoF;
};

Brazo2GL::Brazo2GL() {
    m_px = m_py = 40;
    m_brazo.dist = 40;
    m_antebrazo.dist = 25;
    m_xF = 80;
    m_yF = 70;
    m_tiempo = m_tiempoF = 1;
}

void Brazo2GL::mover_a(float x, float y, float tiempo) {
    m_tiempo = 0;
    m_tiempoF = tiempo;
    m_x0 = m_x;
    m_y0 = m_y;
    m_xF = x;
    m_yF = y;
}

void Brazo2GL::update(float tiempo) {
    m_tiempo += tiempo;
    if (m_tiempo >= m_tiempoF) m_tiempo = m_tiempoF;
    m_x = m_x0 + (m_xF-m_x0)*(m_tiempo/m_tiempoF);
    m_y = m_y0 + (m_yF-m_y0)*(m_tiempo/m_tiempoF);

    float alpha = atan2(m_y-m_py, m_x-m_px);
    float lado = hip(m_x-m_px, m_y-m_py);
    if (lado < (m_brazo.dist - m_antebrazo.dist))
        lado = (m_brazo.dist - m_antebrazo.dist);
    if (lado > (m_brazo.dist + m_antebrazo.dist))
        lado = (m_brazo.dist + m_antebrazo.dist);
    m_brazo.angulo = tcos3f(
        lado,
        m_antebrazo.dist,
        m_brazo.dist
    ) + alpha;
    m_antebrazo.angulo = tcos3f(
        m_antebrazo.dist,
        lado,
        m_brazo.dist
    );
}

void Brazo2GL::draw() {
    cerr << "A brazo: " << deg(m_brazo.angulo)
         << " A antbrazo: " << deg(m_antebrazo.angulo)
         << "     \r";
    glLoadIdentity();
    glPushMatrix();
    glColor3f(0.0f, 1.0f, 0.0f);
    glBegin(GL_POINTS);
      glVertex2f(m_xF, m_yF);
    glEnd();
    glPopMatrix();

    glTranslatef(m_px, m_py, 0.0f);

    glRotatef(deg(m_brazo.angulo),0,0,1);
    glColor3f(1.0f, 0.0f, 0.0f);
    glBegin(GL_LINES);
      glVertex2f(0.0f, 0.0f);
      glVertex2f(m_brazo.dist, 0.0f);
    glEnd();

    glTranslatef(m_brazo.dist,0.0f, 0.0f);
    glRotatef(180+deg(m_antebrazo.angulo),0,0,1);
    glColor3f(0.0f, 0.0f, 1.0f);
    glBegin(GL_LINES);
      glVertex2f(0.0f, 0.0f);
      glVertex2f(m_antebrazo.dist, 0.0f);
    glEnd();
}

int main() {
    if (SDL_Init(SDL_INIT_VIDEO) == -1)
        cout << "no se ha iniciado SDL" << endl;
    SDL_Surface* screen = SDL_SetVideoMode(640, 640, 16,
       SDL_OPENGL | SDL_GL_DOUBLEBUFFER |
       SDL_HWPALETTE | SDL_HWSURFACE | SDL_HWACCEL);
    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
   
    if (screen == NULL) {
        cout << "No se ha iniciado la ventana OpeGL" << endl;
        return 0;
    }
    initGL();


    Brazo2GL brazo;

    float ftime = 0;
    int tics = SDL_GetTicks();
    bool exit = false;
    while (not exit) {
        int tnow = SDL_GetTicks();
        ftime = (tnow-tics)/1000.0f;
        tics = tnow;
   
        SDL_Event event;
        while (SDL_PollEvent(&event)) {
            switch (event.type) {
                case SDL_QUIT:
                    exit = true;
                break;
                case SDL_KEYDOWN:
                    if (event.key.keysym.sym == SDLK_ESCAPE)
                        exit = true;
                break;
                case SDL_MOUSEBUTTONDOWN:
                    int x, y;
                    SDL_GetMouseState(&x, &y);
                    x = x*CLIP_REGION_W/SCREEN_S_W;
                    y = CLIP_REGION_H - y*CLIP_REGION_H/SCREEN_S_H;
                    brazo.mover_a(x, y, 2);
                break;
            }
        }

        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        brazo.update(ftime);
        brazo.draw();

        SDL_GL_SwapBuffers();
        SDL_Delay(5);
   }
   SDL_Quit();
}


Como podéis ver, es solo un pequeña prueba, muy lejos de tener un personaje corriendo y saltando. Pero como ya dije, estoy de exámenes.

Saludos y ánimos que parece muy interesante el tema.
Avatar de Usuario
endaramiz
 
Mensajes: 283
Registrado: Vie Ago 31, 2007 9:25 am
Ubicación: Barcelona

Buen comienzo

Notapor carlostex » Dom Ene 03, 2010 12:50 am

que tal, pues tambien he estado pensando como implementarlo, solo que no he tenido tiempo de estudiar la solucion, el codigo que esta publicado lo acabo de probar y funciona muy bien, tambien me interesa hacerlo, mi idea es hacer un biblioteca de funciones para que solo haya que agregarle las imagenes, si alguien le interesa podemos hacer un equipo para desarrollarlo, me agrado que lo hicieras con SDL, tambien usaria SDL, aunque aun no se manejar OpenGL, pero creo q con SDL es suficiente, al final de cuestas cada programador de videjuegos lo implementaria donde prefiera pero se puede hacer la biblioteca independiente de la API, a fin y al cabo, son puras matematicas.
un favor endemaris sera que puedas comentar que hacen las siguientes funciones:

glTranslatef(m_px, m_py, 0.0f);
glVertex2f(0.0f, 0.0f);
glRotatef(deg(m_brazo.angulo),0,0,1);

y como hiciste para rotar las lineas con el eje en uno de sus extremos, ¿OpenGL te da una funcion para poner un eje de rotacion?
El conocimiento de unos es conocimiento de todos.
Avatar de Usuario
carlostex
 
Mensajes: 249
Registrado: Mar Jul 14, 2009 4:13 am
Ubicación: mexico

Re: Primera prueba

Notapor hugoruscitti » Dom Ene 03, 2010 2:26 am

endaramiz escribió:He hecho un brazo de 2 grados de libertad que traza caminos rectilíneos de un punto a otro, durante un tiempo predefinido, por cinemática inversa.


Epa, muy bueno... mis felicitaciones.

Para compilarlo ejecuté el siguiente comando:

Código: Seleccionar todo
g++   `sdl-config --libs` -lglut  ejemplo.cc   -o ejemplo


y el resultado que veo es buenísmo, lo comparto como un
video para quienes no lo vieron.
Muy buen trabajo endaramiz....

<object width="425" height="344"><param name="movie" value="http://www.youtube.com/v/QncLnHq-dlI&hl=es&fs=1"></param><param name="allowFullScreen" value="true"></param><param name="allowscriptaccess" value="always"></param><embed src="http://www.youtube.com/v/QncLnHq-dlI&hl=es&fs=1" type="application/x-shockwave-flash" allowscriptaccess="always" allowfullscreen="true" width="425" height="344"></embed></object>
Avatar de Usuario
hugoruscitti
Site Admin
 
Mensajes: 1242
Registrado: Dom Jul 30, 2006 3:57 am
Ubicación: Buenos Aires, Argentina

Re: Buen comienzo

Notapor endaramiz » Dom Ene 03, 2010 5:05 pm

Gracias, me alegro que os guste. Y gracias Hugo por el trabajo de subir el video y lo de como compilarlo (se me olvidó).


carlostex escribió:glTranslatef(m_px, m_py, 0.0f);
glVertex2f(0.0f, 0.0f);
glRotatef(deg(m_brazo.angulo),0,0,1);

y como hiciste para rotar las lineas con el eje en uno de sus extremos, ¿OpenGL te da una funcion para poner un eje de rotacion?

La verdad es que openGL funciona de manera bastante distinta a Pygame/SDL. Cuando se hace un glBegin("primitiva") pasa al ESTADO de dibujar primitivas (en este caso lineas y un punto) a medida que le pasas vertices (que se representan con glVertex). En el caso de las lineas hay que pasar 2 vertices y en el caso del punto solo 1. Y con glEnd() se le dice que, de momento, ya no se quiere dibujar más.
Las transformaciones se van acumulando y tienen efecto en orden de abajo hacia arriba. Por ejemplo:
girar (90º)
mover (+5, 0)
dibujar punto en (0,0)
Lo que haría es dibujar un punto en (0,0) pero luego se movería 5 unidades en el eje de las x por lo tanto pasaría a estar en (5,0) y finalmente se rotaría todo 90º desde el centro (0,0) por lo tanto el punto pasaría a estar en (0,5). Si la rotación y la translación estuviesen en orden inverso, la rotación no tendría efecto (ya que es un punto en (0,0)) y con la translación quedaría dibujado en (5,0).
Con glLoadIdentity() se le dice que quieres parar de acumular transformaciones y comenzar de nuevo. Y con glPushMatrix/glPopMatrix se puede "guardar/cargar" el estado de las transformaciones.
Si se han hecho transformaciones con matrices en álgebra, seguro que esto resulta muy familiar. Sino es difícil de explicar, yo lo hice durante semanas en clase. A ver si alguien encuentra un tutorial.

Utilizando solamente SDL se puede llegar a hacer, pero la manera con la que openGL trata las transformaciones, simplifica los cálculos (aun más si se rotan imágenes y no rectas) y le da cierta elegancia (que puede o no gustar).

Saludos.
Avatar de Usuario
endaramiz
 
Mensajes: 283
Registrado: Vie Ago 31, 2007 9:25 am
Ubicación: Barcelona

Haura entiendo

Notapor carlostex » Dom Ene 03, 2010 9:48 pm

Muchas gracias endemariz por explicarlo, haora entiendo, la forma en la que funciona GL se parece al lenguaje logo cuando dibujas con la tortuga(para quienes lo conoscan), y veo que es mas facil hacer esas transformaciones de esta manera, por lo que vale la pena aprender GL.
Solo me queda una duda, esas son lineas que se dibujan de un punto a otro, cada vez que se llama a la funcion dubujar, pero si fueran imagenes, por ejemplo la de un huezo, como le aplicarias las tranformaciones, por que ya no puedes dar puntos de donde empieza y termina, habria que girar la imagen cierto angulo con respecto a un eje de rotacion cituado en uno de sus extremos, existe algo asi en GL?
El conocimiento de unos es conocimiento de todos.
Avatar de Usuario
carlostex
 
Mensajes: 249
Registrado: Mar Jul 14, 2009 4:13 am
Ubicación: mexico

Re: Haura entiendo

Notapor endaramiz » Lun Ene 04, 2010 1:04 am

carlostex escribió:Solo me queda una duda, esas son lineas que se dibujan de un punto a otro, cada vez que se llama a la funcion dubujar, pero si fueran imagenes, por ejemplo la de un huezo, como le aplicarias las tranformaciones, por que ya no puedes dar puntos de donde empieza y termina, habria que girar la imagen cierto angulo con respecto a un eje de rotacion cituado en uno de sus extremos, existe algo asi en GL?
Si que se puede, usando el mismo método de antes. Primero hay que realizar una translación de manera que el eje quede en el punto (0,0) y a continuación aplicar la rotación. Luego se podrían seguir aplicando transformaciones.

He encontrado un articulo muy bueno donde explica la teoría. Esto sería útil conocerlo incluso si no se usa openGL.

http://www.docstoc.com/docs/282412/tran ... raficacion


Por cierto, intenta cuidar un poco más la escritura, que me he liado un poco leyendo.

Saludos.
Avatar de Usuario
endaramiz
 
Mensajes: 283
Registrado: Vie Ago 31, 2007 9:25 am
Ubicación: Barcelona

Notapor carlostex » Lun Ene 04, 2010 1:47 am

Trabajaré en ello, haré una implementación usando solo SDL, buen articulo el que citaste, algunas ideas que tengo en mente son las que explica el articulo, así que pondré en practica lo que aprendí de álgebra y calculo vectorial y en cuanto lo tenga codificado lo comparto con ustedes. saludos
El conocimiento de unos es conocimiento de todos.
Avatar de Usuario
carlostex
 
Mensajes: 249
Registrado: Mar Jul 14, 2009 4:13 am
Ubicación: mexico

Notapor hugoruscitti » Lun Ene 04, 2010 11:49 am

Hey, buenisimo....

Por mi parte trataré de hacer algo también, estuve viendo
que hay algo llamado "títeres de palo o varilla" que se podría
simular como un esqueleto en dos dimensiones.

No se si alguno de ustedes de chico vió algo así, pero es
lo mas parecido a un bones 2d en la vida real... o eso creo...

Imagen

Esta imagen la encontré en una campaña
de HP y kung fu panda:

http://h20424.www2.hp.com/campaign/kung ... uppets.asp

Mi idea sería tratar de hacer un personaje así con python
y alguna biblioteca como pygame o pySFML para que
mediante el mouse o alguna tecla se puedan rotar las
piezas de un personaje.

Les dejo un ejemplo de animacion estilo flash
donde se puede ver algo similar pero en movimiento:

<object width="425" height="344"><param name="movie" value="http://www.youtube.com/v/hUz0ZYwFGCg&hl=es_ES&fs=1&"></param><param name="allowFullScreen" value="true"></param><param name="allowscriptaccess" value="always"></param><embed src="http://www.youtube.com/v/hUz0ZYwFGCg&hl=es_ES&fs=1&" type="application/x-shockwave-flash" allowscriptaccess="always" allowfullscreen="true" width="425" height="344"></embed></object>

lo te tengo en mente es algo mucho mas simple, eso si...

¿Que les parece?
Avatar de Usuario
hugoruscitti
Site Admin
 
Mensajes: 1242
Registrado: Dom Jul 30, 2006 3:57 am
Ubicación: Buenos Aires, Argentina

Notapor endaramiz » Mar Ene 05, 2010 12:25 pm

Ok. He estado leyendo y pensando sobre animación esqueletal y creo que antes de tener un personaje corriendo y saltando, habría que pasar por este paso para editar los movimientos. Me parece bien tener como objetivo este punto ya que a lo mejor con algo más complejo se complicaba demasiado para un ejemplo. Y, además, si luego se ve que esto ha sido fácil y rápido, se puede ampliar un poco más.

Saludos.
Avatar de Usuario
endaramiz
 
Mensajes: 283
Registrado: Vie Ago 31, 2007 9:25 am
Ubicación: Barcelona

Notapor hugoruscitti » Sab Ene 09, 2010 11:07 pm

Buscando ejemplos en la pagina de pygame.org encontré
un código que me pareció bastante interesante. Sobretodo
porque es muy interactivo: no solo te permite girar
y mover piezas sino que también da la posibilidad
de cambiar el eje de rotación de cada una:

El ejemplo está en la siguiente página:

http://www.pygame.org/project-JumpingJack-412-.html

Y esta es una captura de pantalla del ejemplo funcionando:

Imagen
Avatar de Usuario
hugoruscitti
Site Admin
 
Mensajes: 1242
Registrado: Dom Jul 30, 2006 3:57 am
Ubicación: Buenos Aires, Argentina

Notapor endaramiz » Mié Ene 13, 2010 2:56 pm

Ummh está muy bien, yo diría que incluso demasiado. ¿Ahora cual es el plan? Se podría empezar desde cero sin mirar el código, mirar el código y mejorarlo...

Partiendo de ese código (creo que para publicarlo en la web tiene que ser libre) se podría trabajar un poco el tema de animaciones con posiciones clave y cinemática inversa. Que trata de ir guardando ciertas posiciones de la animación y que las otras se calculen automáticamente. Como todo el sistema de huesos está implementado, ya está la mitad del trabajo hecho. Aunque habría que mejorar algunas cosas como ángulos máximo y mínimo.

Saludos.
Avatar de Usuario
endaramiz
 
Mensajes: 283
Registrado: Vie Ago 31, 2007 9:25 am
Ubicación: Barcelona

Notapor Juanxo » Mié Ene 13, 2010 4:13 pm

buenas a todos:

@endaramiz: como veo que te va gustando este temilla, te voy a recomendar un libro, y especialmente un autor.

Core Techniques and Algorithms in Game Programming. Su autor es un "vecino" tuyo: Daniel Sánchez Crespo-Dalmau, profesor de la Pompeu y del master de juegos de la Pompeu. No se si por allí podrás conseguir una copia que este en español, pero espero que la consigas porque viene muy bien explicado esto, y todo lo demás. Además, utiliza OpenGL en sus ejemplos, o pseudocodigo.

Si no puedes o no tienes ganas de buscarlo, cuando termine los examenes te puedo hacer un mini-resumen del tema de animacion, en el que trata bastante lo de bones y cinemáticas
Avatar de Usuario
Juanxo
 
Mensajes: 437
Registrado: Sab Ene 31, 2009 2:34 am
Ubicación: Madrid(España)

Notapor lacabra25 » Mié Ene 13, 2010 4:25 pm

carlostex escribió:...haora entiendo, la forma en la que funciona GL se parece al lenguaje logo cuando dibujas con la tortuga(para quienes lo conoscan), y veo que es mas facil hacer esas transformaciones de esta manera, por lo que vale la pena aprender GL...


Nunca lo habia visto asi, pero si, se parece en cierto modo a la fora de dibujar en Logo (yo tambien lo use hace algunos años), la diferencia esta en que en Logo primero tiene uno que mover la tortuga y luego dibujar, en GL es al reves, primero dices que quieres dibujar y luego lo mueves del origen de cordenadas a donde quieras. Si, vale la pena aprender GL, para graficos 3D en software libre es, a mi criterio, la mejor opcion.

carlostex escribió:...haré una implementación usando solo SDL, buen articulo el que citaste, algunas ideas que tengo en mente son las que explica el articulo, así que pondré en practica lo que aprendí de álgebra y calculo vectorial...


Si, con algebra y calculo vectorial se pueden hacer todos los calculos matematicos necesarios y luego dibujarlos con SDL, por poder se podria incluso calcular graficos 3D proyectados sobre un plano y dibujar con SDL graficos en 3D, lo unico es que seria mas lento de lo que lo haria GL, GL realiza todos esos calculos matematicas para poder dibujar lo unico es que si la tarjeta grafica lo admite en lugar de esos calculos realizarlos la CPU los realizaria la GPU, el chip de la tarjeta grafica realiza los calculos mas rapido ya que su unica funcion es realizar esos calculos (no tiene que procesar un SO y todos los programas en ejecucion, con lo que GL es mejor opcion en la practica (aunque el ejemplo, o el juego, sea en 2D) ya que los calculos con matrices GL los aria usando la GPU.

Enderamiz, ¡buen ejemplo!, hace un tiempo que tengo apartado a un lado el aprender GL por los estudios, a ver si cuando pueda vuelvo a ponerme, por que esto la verdad es que es bastante interesante para los juegos, ya no solo para los juegos 3D, sino incluso para los 2D.
Esta cuenta ahora a pasado a la cuenta jhg
Avatar de Usuario
lacabra25
 
Mensajes: 222
Registrado: Mié Abr 02, 2008 9:45 pm
Ubicación: Tenerife (España)

Notapor endaramiz » Mié Ene 13, 2010 10:11 pm

Juanxo escribió:@endaramiz: como veo que te va gustando este temilla, te voy a recomendar un libro, y especialmente un autor.

Core Techniques and Algorithms in Game Programming. Su autor es un "vecino" tuyo: Daniel Sánchez Crespo-Dalmau, profesor de la Pompeu y del master de juegos de la Pompeu. No se si por allí podrás conseguir una copia que este en español, pero espero que la consigas porque viene muy bien explicado esto, y todo lo demás. Además, utiliza OpenGL en sus ejemplos, o pseudocodigo.

Si no puedes o no tienes ganas de buscarlo, cuando termine los examenes te puedo hacer un mini-resumen del tema de animacion, en el que trata bastante lo de bones y cinemáticas

Pues que casualidad que el otro día estuve mirando su excelente currículum. A parte de ser mi "vecino", resulta que estudió en la misma facultad que yo. Solo que después se pasó a la "competencia". Aunque es probable que yo haga lo mismo, solo que como alumno y no de profesor. Volviendo al tema: Gracias! La verdad es que lo miré mientras descansaba de estudiar y luego seguí estudiando y no le presté toda la atención que se merecía ese libro. Tiene muy buena pinta. Intentaré conseguirlo cuanto antes, aunque tengo cierto libro rojo a medias y a su compañero naranja sin comenzar. Lo "bueno" es que seguramente tenga bastante tiempo libre durante unos meses: al final me paso a grado y no me puedo coger muchas asignaturas por lo de las convalidaciones.
Veo que te acuerdas de mis dificultades con el inglés. Pero últimamente he mejorado mucho y me atreveré con la versión en inglés. Aunque en su web pone que tiene intención de traducirlo y no la descarto por si no me queda claro algún concepto.

Saludos.
Avatar de Usuario
endaramiz
 
Mensajes: 283
Registrado: Vie Ago 31, 2007 9:25 am
Ubicación: Barcelona

Notapor Juanxo » Mié Ene 13, 2010 10:48 pm

jajajaja si es que al final....

te puedes creer que yo también estoy pensando en irme a la Pompeu. Estoy en la misma que tu (Politécnica), que tiene nombre, pero la verdad es que para mi deja bastante que desear. Lo que pasa es que para mi seria un cambio bastante gordo, pero lo pensaré.

A ver si a partir del 20, que tengo tres semanas de vacaciones (el grado es lo que tiene), me pongo de nuevo con OpenGL y le damos a los Bones

Me alegro de que te pongas con el ingles. Por si surge cualquier duda, pregunta si quieres.
Avatar de Usuario
Juanxo
 
Mensajes: 437
Registrado: Sab Ene 31, 2009 2:34 am
Ubicación: Madrid(España)

Notapor Juan Carlos » Vie Ene 15, 2010 6:18 pm

He visto el demo de JumpingJack y esta muy bueno. Creo que le faltaria un boton que sacara unas fotografias para obtener los fotogramas.

Me explico, supongamos que quiero hacer una animacion de Jack corriendo, abro el programa y pongo a Jack en una posicion inicial usando los controles y luego saco una fotografia (fotograma 1).
Muevo levemente las piernas de Jack y saco otra fotografia (fotograma 2).
Nuevamento muevo a Jack y repito el proceso.
El programa deberia ser capaz de almacenar los fotogramas para luego exportarlo en forma de animacion.

Nota personal: Con respecto al libro Core Techniques and Algorithms in
Game Programming
yo lo he leido y la verdad es que no lo recomiendo.
Para mi gusto, abarca demasiados temas, que van desde historia a estructuras de datos, y luego a graficos 2/3D, y solo profundiza algunos parrafos por cada tema.

Saludos
Juan Carlos
 
Mensajes: 97
Registrado: Sab Jul 07, 2007 1:05 pm

Notapor endaramiz » Sab Ene 16, 2010 2:44 pm

Juan Carlos escribió:He visto el demo de JumpingJack y esta muy bueno. Creo que le faltaria un boton que sacara unas fotografias para obtener los fotogramas.

El código es de dominio público, así que puedes animarte y intentar hacerlo. La gracia sería calcular la bounding box. Aunque de esta manera se desaprovecharía la técnica de bones en el juego y los dibujos serían más rápidos de hacer, pero de peor calidad que a mano. Igualmente a lo mejor lo intento hacer para aprender como funciona el código.

Juan Carlos escribió:Nota personal: Con respecto al libro Core Techniques and Algorithms in
Game Programming
yo lo he leido y la verdad es que no lo recomiendo.
Para mi gusto, abarca demasiados temas, que van desde historia a estructuras de datos, y luego a graficos 2/3D, y solo profundiza algunos parrafos por cada tema.
Lo encuentro normal, la programación de videojuegos abarca muchos temas. A partir de una base, se puede profundizar en los temas que más interesen (como pasa en la universidad).

Saludos.
Avatar de Usuario
endaramiz
 
Mensajes: 283
Registrado: Vie Ago 31, 2007 9:25 am
Ubicación: Barcelona

Notapor hugoruscitti » Sab Ene 30, 2010 9:48 pm

Buenas, yo estuve avanzado un poco con mi implementacion
de bones2d:

Imagen

Aunque lamentablamente tiene un Bug que se ve cuando
conecto tres piezas (o mas) y las hago rotar.

Grabé un video donde se puede ver este bug:

<object width="425" height="344"><param name="movie" value="http://www.youtube.com/v/k__hCXv4zhQ&hl=es&fs=1"></param><param name="allowFullScreen" value="true"></param><param name="allowscriptaccess" value="always"></param><embed src="http://www.youtube.com/v/k__hCXv4zhQ&hl=es&fs=1" type="application/x-shockwave-flash" allowscriptaccess="always" allowfullscreen="true" width="425" height="344"></embed></object>


El código fuente del programa está en la siguiente
dirección:

http://www.losersjuegos.com.ar/incoming ... s2d.tar.gz

Espero solucionar este bug en cuanto tenga un poquito
mas de tiempo.
Avatar de Usuario
hugoruscitti
Site Admin
 
Mensajes: 1242
Registrado: Dom Jul 30, 2006 3:57 am
Ubicación: Buenos Aires, Argentina


Volver a Propuestas de desarrollo y concursos

¿Quién está conectado?

Usuarios navegando por este Foro: No hay usuarios registrados visitando el Foro y 3 invitados

cron