webs de fisicas

[kozka]

bueno na queria compartir unas cuantas webs buenas de fisicas si teneis mas pues añadirlas
afer si alguien sease erkosone saca algo en claro , y conseguimos tener un sistema de fisicas potente que es mi ilusion Xd ,porque yo soy un desastre


bueno este es un blog de un profesional de los videojuegos con informacion de todo tipo sobre cualquier tema
//el blog general
http://www.wildbunny.co.uk/blog/
//phisica para dummies
http://www.wildbunny.co.uk/blog/2011/04/06/physics-engines-for-dummies/
//tecnica de contactos especulativos
http://www.wildbunny.co.uk/blog/2011/03/25/speculative-contacts-an-continuous-collision-engine-approach-part-1/


Pagina de fisica muy buena sobre muchas cuestiones con ejemplos
http://www.sc.ehu.es/sbweb/fisica/dinamica/con_mlineal/choques2/choques2.htm


buena pagina con codigos y ejemplos en flash
http://krazydad.com/bestiary/bestiary_objectcell.html


Ya ire poniendo mas si eso

[erkosone]

Genial recurso, lo que pasa es que para un motor genérico hace falta dedicarle mucho tiempo, piensa que todo está documentado y hacerlo no es el problema, el tema es quien se va a pegar un par de años para hacer eso.. yo no XD..

Lo mejor es pillar una lib de física ya hecha y a correr.. aunque miedo me da.. por que cada vez que se habla por aquí de programar de la forma mas eficiente posible.. la gente empieza a decir que si eso ya no es filosofía div XD.. se nota que el que dice eso no ha salido de div.. y dificilmente será capaz de aprobechar una lib de fisicas..
Es mas.. la lib de red que prometío CicTec.. cuando salga todavía estoy por ver como alguien la critica por no tener ni idea de lo que está haciendo.. o por programar por estados que es lo que habrá que hacer cuando salga..

Ya verás ya la risa del momento XD..


La filosofía DIV es genial, pero con ese sistema no se puede hacer todo, y si nos cerramos a DIV puro y duro.. pues eso.. que nunca avanzaremos hacia juegos complejos, y no me refiero a juegos con mucho código, o código basura ilegible XD.. me refiero a que para usar una lib de red o lib de físicas hay que tener la mente muy abierta.. y tener todo mas que milimetrado..

Supongo que te has mirado el tema de constraints en física computacional, ahora dile tu a alguien que usa div.. que tiene que controlar la física desde un solo proceso con tablas y matrices.. y que si no no funciona.. XD..

No creo que nadie nunca use un motor de física así a pelo en Gemix a no ser que CicTec o GINO se encierren durante unos meses en una cueva y monten un sistema de objetos con motor de colisión interno ya hecho en el lenguaje.

Esto está mu buen Kozka, pero no te esfuerces jeje.. nadie lo va a usar.. te lo digo desde el cariño

[kozka]

no ya afer lo hago como pasatiempo xd no espero que se case nadie conmigo xd.
en otros div-likes parece que tienen bastante avanzado el tema de fisicas con chinpunk,
afer cuando se ponen ello por akina.xd


afer esque el blog del tio ese pues eso que el homnbre es una makina comparados con el somo una mierdecilla de pelusa insuslsa Xd pero bueno normal.


tu crees que seriamos capaces nosotros de pasar el box2d al lenguaje gemix.. tal cual viene en el codigo? porque se podria hacer algo asi en vez de hacer nada o esperar
o colavorar...supongo que es ponerse nose que dificultades mas puede haber "aparte de que es jodidisimo Xd"

[kozka]

el problema principal es entender lo que es cada cosa
y la sintaxis que no entiendo nada, si bien e programado en c++ pero hay muchas cosas que no entiendo nada de nada xD

Source Code (C) [ Download ] [ Hide ]

Source Code (C) [ Download ] [ Show ]

• int main(int argc, char** argv)
• {
•         B2_NOT_USED(argc);
•         B2_NOT_USED(argv);
•  
•         // Define the gravity vector.
•         b2Vec2 gravity(0.0f, -10.0f);
•  
•         // Construct a world object, which will hold and simulate the rigid bodies.
•         b2World world(gravity);
•  
•         // Define the ground body.
•         b2BodyDef groundBodyDef;
•         groundBodyDef.position.Set(0.0f, -10.0f);
•  
•         // Call the body factory which allocates memory for the ground body
•         // from a pool and creates the ground box shape (also from a pool).
•         // The body is also added to the world.
•         b2Body* groundBody = world.CreateBody(&groundBodyDef);
•  
•         // Define the ground box shape.
•         b2PolygonShape groundBox;
•  
•         // The extents are the half-widths of the box.
•         groundBox.SetAsBox(50.0f, 10.0f);
•  
•         // Add the ground fixture to the ground body.
•         groundBody->CreateFixture(&groundBox, 0.0f);
•  
•         // Define the dynamic body. We set its position and call the body factory.
•         b2BodyDef bodyDef;
•         bodyDef.type = b2_dynamicBody;
•         bodyDef.position.Set(0.0f, 4.0f);
•         b2Body* body = world.CreateBody(&bodyDef);
•  
•         // Define another box shape for our dynamic body.
•         b2PolygonShape dynamicBox;
•         dynamicBox.SetAsBox(1.0f, 1.0f);
•  
•         // Define the dynamic body fixture.
•         b2FixtureDef fixtureDef;
•         fixtureDef.shape = &dynamicBox;
•  
•         // Set the box density to be non-zero, so it will be dynamic.
•         fixtureDef.density = 1.0f;
•  
•         // Override the default friction.
•         fixtureDef.friction = 0.3f;
•  
•         // Add the shape to the body.
•         body->CreateFixture(&fixtureDef);
•  
•         // Prepare for simulation. Typically we use a time step of 1/60 of a
•         // second (60Hz) and 10 iterations. This provides a high quality simulation
•         // in most game scenarios.
•         float32 timeStep = 1.0f / 60.0f;
•         int32 velocityIterations = 6;
•         int32 positionIterations = 2;
•  
•         // This is our little game loop.
•         for (int32 i = 0; i < 60; ++i)
•         {
•                 // Instruct the world to perform a single step of simulation.
•                 // It is generally best to keep the time step and iterations fixed.
•                 world.Step(timeStep, velocityIterations, positionIterations);
•  
•                 // Now print the position and angle of the body.
•                 b2Vec2 position = body->GetPosition();
•                 float32 angle = body->GetAngle();
•  
•                 printf("%4.2f %4.2f %4.2f\n", position.x, position.y, angle);
•         }
•  
•         // When the world destructor is called, all bodies and joints are freed. This can
•         // create orphaned pointers, so be careful about your world management.
•  
•         return 0;
• }
•  

[erkosone]

es que con eso solo no haces nada, en este código se hacen unas cuantas llamadas a métodos de objetos tipo, entonces aquí falta muuuuuucho código para ver el global del programa..

El problema que yo también lo he intentado.. es que la box2d es tan extensa que te pierdes entre toda la maraña de posibilidades.. te recomiendo que visites cualquier pague de html5 y verás que sus usuarios normalmente están bastante acostumbrados a tratar con este tipo de problemas y hay mucho código, en especial hay un lenguaje llamado Monkey bastante moderno.. compila para casi todo.. pero no tiene potencia gráfica.. es bastante pobre y hay que hacerlo todo a mano.. y por eso mismo la gente se monta sus mini librerías de casi cualquier cosa, dale un ojo, seguro que sacas algo que te sirva.

[kozka]

afer ese es el hola mundo de dox box un ejemplo que trae.
seria una forma normal de mepezar a descodificar el codigo y traducirlo por eso lo he puesto
si yo ya lo habia mirao hacetiempo pero fufu

[TYCO]

REFLOTE DE TEMA
Atentos a los dos últimos ejemplos con la ventana azul, uno son un montón de bolas que puedes golpear entre sí y ocupan su sitio cada una y el otro hace como si fuera una cuerda colgada del techo, me han parecido interesantes y os pongo la web:

http://www.wildbunny.co.uk/blog/2011/04 ... r-dummies/

[erkosone]

esos dos los tengo yo implementados en Gemix

[kozka]

el de la cuerda es mas facil ya que solo hay colision entre objetos y no hay de terreno en principio...

[erkosone]

son sencilletes, solo hay que enfocarlo como es en realidad y no como procesos que es lo que pueda parecer, para poder traducir bien los códigos de C o C++ lo mejor es crear un typedef Vector_ y luego un array de Vectores, manupulas toda la información y lo pintas con draw_graphic(), como se te ocurra hacerlo a procesos XD.. la cosa es bastante caotica y lenta, por que cuando aplicas los constraints entre vectores aveces "depende de la precisión que quieras" tienes que hacer varias pasadas al array en cada frame, y con procesos sería algo muy complejo pero con un array de vectores está chupado.