Les propongo un desafio: 2d Bones...

[hugoruscitti]

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?.

[Adri]

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

[endaramiz]

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.

[Juan Carlos]

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

[endaramiz]

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.

[carlostex]

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?

[hugoruscitti]

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>

[endaramiz]

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

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.

[carlostex]

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?

[endaramiz]

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.

[carlostex]

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

[hugoruscitti]

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...



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?

[endaramiz]

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.

[hugoruscitti]

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:

[endaramiz]

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.

[Juanxo]

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

[lacabra25]

...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.

...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.

[endaramiz]

@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.

[Juanxo]

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.

[Juan Carlos]

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

[endaramiz]

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.

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.

[hugoruscitti]

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



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.