TODO gl_overlay pour écrire le texte de ce qui est sous le curseur
[3/4] display info, FPS
déplacer un curseur => Input ds Chuchu
curseur avec épaisseur => ligne line width
pointer avec souris => Position de la souris
implement dynamical update src/matrix2020/gl_fovhamming.hpp
- test-020-window : cube en rotation
- test-021-cells : geom pour tracer cell => NON, FAIL
<<affichage fps>> est un lien/ancre préféré à ‘affichage fps’
- tactiship/gl_3dvect.hpp : line3d.v.glsl, line.f.glsl
- tactiship/gl_3dship.hpp : line_tri_xyz_rgb_fade.v.glsl, line_tri_xyz_rgb_fade.f.glsl
- tactiship/trajectory.hpp : line_tri_xyz_rgb_fade.v.glsl, line_tri_xyz_rgb_fade.f.glsl
- gl_engine.
- gl_texture : sprite
- gl_texture_fade : sprite_fade
nouvelle direction avec rotation horaire tant que mur existe
En continuant ce qui est fait pour -l_walls
Quand on ajoute un flèche, certains Chuchu déjà engagés dans la sortie ne prennent plus le trajet qui va de centre de case en centre de case.
Enlevé DEPT_TEST je crois
le compteur d’animation doit être avec la Rocket. Mais, normalement, c’est pas dans le modèle… Quoique
- ajouter un update à chaque Rocket qui gère le compteur d’animation
++++2) GLRocket maintient un compteur d’animation par Rocket => essayer de lui passer en paramètre un GLSprite::render( projection, Vec2, unsigned int spriteIndex ou (row,col)) où projection peut être mutiplié par scale fonction de l’anim. En static ou en Ptr. Modèle déclence le moment d’entrée, donc de début d’animation.
On parle ici d’une sorte de GLSprite
- on lui ajoute des Textures (nb_row, nb_col)
- pre_render => choisi program; _vbo_carre_vtx
- set_texture
- render avec (proj, pos, row,col) ; glm::matrix, glDraw…
test lorsqu’on essaie de faire le binding
Dernier tracé => en haut, Z compte pas
Les chuchu grossisent et “sautent” hors des sources, qui, comme les fusées, sont extrudées du sol et donc vue en perspectives.
Cross qui devient pâle sur fusée ou flèches autre ??
Maintenant qu’on a un GL_Controler, la pose de flèche alors que le cursor est hors zone => SegFault
http://en.wikibooks.org/wiki/OpenGL_Programming/Object_selection
// Parsing command line options #include <boost/program_options.hpp> namespace po = boost::program_options; // ******************************************************************* options void setup_options(int argc, char **argv) { po::options_description desc(“Options”); desc.add_options() (“help,h”, “produce help message”) (“nb_player,n”, po::value<unsigned int>(), “nb de joueur par défaut”) ;
// Options en ligne de commande po::options_description cmdline_options; cmdline_options.add(desc);
// Options qui sont ‘après’ po::positional_options_description pod; //pod.add( “data_file”, 1);
// Parse po::variables_map vm; po::store(po::command_line_parser(argc, argv). options(desc).positional(pod).run(), vm); po::notify(vm);
if (vm.count(“help”)) { std::cout << “Usage: ” << argv[0] << ” [options]” << std::endl; std::cout << desc << std::endl; exit(1); }
if (vm.count(“nb_player”)) { _nb_player = vm[“nb_player”].as<unsigned int>(); } }
>>>>>> Dans MAIN setup_options( argc, argv ); std::cout << “__SET_CONTROLER” << std::endl; app.set_controler( _nb_player );
== TactiShip == ===============
Reprendre un peu tout à partir de SpaceZombie et faire un afficheur de traces de vaisseaux (genre Tie SW et Navette :o) )
https://en.wikibooks.org/wiki/GLSL_Programming/GLUT/Two-Sided_Surfaces
http://www.opengl-tutorial.org/intermediate-tutorials/tutorial-17-quaternions/
Quaternion QuatAroundX = Quaternion( Vector3(1.0,0.0,0.0), EulerAngle.x ); Quaternion QuatAroundY = Quaternion( Vector3(0.0,1.0,0.0), EulerAngle.y ); Quaternion QuatAroundZ = Quaternion( Vector3(0.0,0.0,1.0), EulerAngle.z ); Quaternion finalOrientation = QuatAroundX * QuatAroundY * QuatAroundZ;
The concept of quaternion multiplication is similar to matrix multiplication, it is neither dot nor cross product. If you want to understand the usage of quaternions, then get used to matrices and understand axis-angles, their basic concept is pretty similar to quaternions, the math is a bit more advanced, but once you understood axis-angles, then quaternions are not far away anymore.
Hamilton product => implémenté par operator*
For two elements a1 + b1i + c1j + d1k and a2 + b2i + c2j + d2k, their product, called the Hamilton product (a1 + b1i + c1j + d1k) (a2 + b2i + c2j + d2k), is determined by the products of the basis elements and the distributive law. The distributive law makes it possible to expand the product so that it is a sum of products of basis elements. This gives the following expression:
a1a2+a1b2i+a1c2j+a1d2k {}+b1a2i+b1b2i2+b1c2ij+b1d2ik {}+c1a2j+c1b2ji+c1c2j2+c1d2jk {}+d1a2k+d1b2ki+d1c2kj+d1d2k2.
Now the basis elements can be multiplied using the rules given above to get:[6]
a1a2-b1b2-c1c2-d1d2 {}+(a1b2+b1a2+c1d2-d1c2)i {}+(a1c2-b1d2+c1a2+d1b2)j {}+(a1d2+b1c2-c1b2+d1a2)k.
The product of two rotation quaternions will be equivalent to the rotation a1 + b1i + c1j + d1k followed by the rotation a2 + b2i + c2j + d2k.