Jeux Libres

Envie de créer un jeu vidéo ?   Le site qui vous accompagne de A à Z.


» Les Forums » A propos de la création de jeux vidéo » Algorithme final


Aller à la page : 1.

Algorithme final
Lo



Grade : Expert
Inscrit le: 26 Dec 2007, 17:33
Ecrit le: 08 Juin 2009, 22:39             Message non corrigé

Voilà, chez moi cet algorithme marche pour la gestion du sol.


public static float calculerPointCollisionAvecTriangle  (Vec3t positionsPerso, Vec3t pointA, Vec3t pointB, Vec3t pointC) {
                //Je vais prendre comme repère le point A.           
               
                float valeur;
                       
                float largeur1 = Math.abs(pointC.getVec3t()[2] - pointA.getVec3t()[2]);
                float largeur2 = Math.abs(positionsPerso.getVec3t()[2] - pointA.getVec3t()[2]);
                float hauteur = Math.abs(pointC.getVec3t()[1] - pointA.getVec3t()[1]);
                if (largeur1 != 0)
                        valeur = hauteur * largeur2 / largeur1;
                else
                        valeur = 0;
               
                if (pointC.getVec3t()[1] > pointA.getVec3t()[1]) {                 
                        //Translation vers le haut.                    
                        positionsPerso.translation(valeur, false, true, false);   
                } else {                       
                        //Transaltion vers le bas.                             
                        positionsPerso.translation(-valeur, false, true, false);                       
                }
               
                largeur1 = Math.abs(pointB.getVec3t()[2]) - Math.abs(pointA.getVec3t()[2]);
                largeur2 = Math.abs(positionsPerso.getVec3t()[2]) - Math.abs(pointA.getVec3t()[2]);
                hauteur = Math.abs(pointB.getVec3t()[1] - pointA.getVec3t()[1]);
                if (largeur1 != 0)
                        valeur = hauteur * largeur2 / largeur1;
                else
                        valeur = 0;
               
                if (pointB.getVec3t()[1] > pointA.getVec3t()[1]) {
                        positionsPerso.translation(valeur, false, true, false);
                       
                } else {               
                        positionsPerso.translation(-valeur, false, true, false);                       
                }              
               
                return positionsPerso.getVec3t()[1];       
        }       
 
Et pour les box j'ai trouver pas mal de trucs sur le net, plus qu'à les implémenter et j'ai mon moteur de collisions presque finis, il me reste en gros les box et les spheres.

Là je vais attaquer l'éditeur de map, pas pratique de devoir tracer avec des nombres dans le programme.

David avait raison, il faut faire des maps de type blocs, moi j'ai dans chaque blocs deux triangles, avec les heightfield de mémoriser.

________
Parce qu'on ne peut s'exprimer que par nos créations. ^^
  Profil Mail
David



Grade : Expert
Inscrit le: 11 Mai 2005, 20:30
Ecrit le: 09 Juin 2009, 00:16             Message non corrigé

Ta méthode vient de m'inspirer.
Si on part du principe que tout les models sont constitués de triangles, il faudrait donc se pencher sur la détection de collision entre 2 triangles.
Cette vidéo illustre bien ce que je veux dire : http://xna-uk.net/blogs/randomchaos/archive/2009/05/05/collision-detection-per-triangle.aspx .

A mon avi, il y a collision si l'un des segments d'un des deux triangles travers l'autre triangle.

Maintenant, reste à savoir comment savoir si un segment travers un triangle. J'ai le sentiment que c'est bien expliqué ici : http://texel3d.free.fr/opengl/collisions.htm . Je me pencherais sur la question à tête reposée.

Si ça peut t'aider pour ton moteur de collision.

________
Apprenez à créer votre propre FPS en C++ avec OpenGL. C'est pas dur ! :-)
  Profil Mail
Lo



Grade : Expert
Inscrit le: 26 Dec 2007, 17:33
Ecrit le: 09 Juin 2009, 22:53             Message non corrigé

Salut, j'ai réussis une autre collision pour l'éditeur de map, pas encore toute à fait finis, elle a pour principe de sélectionner des blocs sur une map comme sauerbraten, le début marche, il me reste plus qu'à rechercher la bonne face du bloc, j'ai fait une intersection entre une droite et le plan de mon bloc, et pour rechercher la face, j'ai rechercher les sommets dont l'angle entre le rayon de la caméra et le sommet est compris entre 90°

Le site texel m'a bien aidé aussi je doit avoué.

Voici donc mon aglo pour gérer l'édition de map, et aussi une méthode de pré rendus qui permet de n'afficher que les blocs visible :

public static Vec3t intersectionWithBox (Vec3t posBox, Vec3t rayon,Vec3t posCam, Vec3t[] points) {
               
                Vec3t avant, pointCollision;       
                //Position du personnage par rapport au polygone.
                               
                //On recherche le point le plus près du personnage.
                avant = getNearest (rayon, points);                    
               
                Vec3t[] face = rechercherSommetsVoisins(rayon, points);
                if (face[0] != null && face[1] != null) {
                        Vec3t a = avant.soustraire(face[0]);
                        Vec3t b = avant.soustraire(face[1]);
               
                        Vec3t normale = a.crossProduct(b);           
                        a = avant.soustraire(rayon);
                        b = posCam.soustraire(rayon);
                       
                    float denominateur = normale.produitScalaire(a);
                        float numerateur = normale.produitScalaire(b);   
                        pointCollision = avant;
                       
                        if (denominateur == 0)  {               
                                return null;
                        } else {
                                float u = numerateur / denominateur;           
                                for (int i = 0; i < 3; i++)
                                        pointCollision.getVec3t()[i] += u;                 
                                return pointCollision;
                        }
                } else
                        return null;
        }
        //Recherche les sommets voisins en fonction du point de vue.
        public static Vec3t[] rechercherSommetsVoisins (Vec3t rayon, Vec3t[] points) {
                int n = 0;     
                Vec3t[] face = new Vec3t[2];
                for (int i = 0; i < 8; i++) {
                        if (points[i].produitScalaire(rayon) >= 0 && points[i].produitScalaire(rayon) <= 1 && i != indexNearestVertex) {                               
                                face[n] = points[i];                   
                                n++;
                        }       
                        if (n >= 2)
                                break;
                }       
                return face;
        }
        public static Vec3t getNearest (Vec3t point, Vec3t[] other) {            
                //On recherche le point le plus près du personnage.
                float distMin = other[0].calculerDistance(point);
                int indexMin = 0;
                for (int i = 1; i < other.length; i++) {                       
                        float dist = other[i].calculerDistance(point);
                       
                        if (dist < distMin) {
                                indexMin = i;            
                        }                     
                }       
                indexNearestVertex = indexMin;
                return other[indexMin];
        }
 
Voilà et pour le pré rendus, ça je ne sais pas si sauerbraten l'a fait, mais c'est mieux combiné avec le brouillard ça donne un effet super :

public ArrayList<Bloc> getPrerendering (Vec3t positionsPerso, Vec3t lookAt, int ray) {   
                ArrayList<Bloc> bls = new ArrayList<Bloc> ();      
                for (Bloc b : blocs) {   
                       
                        Vec3t positionsBloc = new Vec3t (b.getX(), b.getY(), b.getZ())
                       
                        if (positionsBloc.isZeroVector() || lookAt.isZeroVector() || positionsPerso.isZeroVector()) {
                               
                                bls.add(b);
                        }
                               
                        float angle = lookAt.produitScalaire(positionsBloc);                           
                        if (positionsBloc.calculerDistance(positionsPerso) < ray && angle > 0 && angle < 1 ) {
                               
                                bls.add(b);                    
                        }                            
                }
                return bls;
        }
 

Maintenant il ne me reste plus tant à gérer, des Bounding box, peut être l'algorithme entre deux triangles, et aussi l'algoritme que j'ai vu sur texel pour les murs, enfin soit, je verrai, au pire j'ai toujours mon algo ci dessus qui marche pour tout, il permet de calculer l'intersection entre la caméra et le plus poly le  plus proche.

________
Parce qu'on ne peut s'exprimer que par nos créations. ^^
  Profil Mail
Joey



Grade : Débutant
Inscrit le: 07 Sept 2009, 22:43
Ecrit le: 09 Sept 2009, 00:08             Message non corrigé

Ouai la Bounding Box j ai carement refait un logi je les vendue a une société qui gagne du fric grace a moi . car je reçoit quedal

________
Joey Tribbiani
  Profil Mail
 


Aller à la page : 1.


Hébergeur du site : 1and1.fr



Site de création de Jeux Vidéo
Apprenez à créer vos propres Jeux Video

1198818 pages ont été consultées sur le site !
Dont 2325 pages pendant les 24 dernières heures.

Page générée en 0.311 secondes


Nos partenaires
- Otium Production : Aide aux débutants à créer leurs jeux
- Les bibliothèques de développement de jeux vidéo


  © 2005-2012 www.jeux-libres.com - Toute reproduction totale ou partielle du contenu de ce site est strictement interdite.