[C++] PB, reconnaissance méthode ???

Bonsoir,

Voici mon problème.

J'ai une classe Polygone, qui est constituée de deux triangles.
Je crée un programme OpenGL en fait, et donc, je suis en train d'y insérer les collisions. J'ai donc une classe Polygone, contenant une fonction "test_collision", qui va chercher les méthodes "testcollision" des deux triangles.
S'ils renvoient faux, alors, normalement, la classe polygone renvoit faux pour sa methode "test_collision", rien de plus normal.

Hors, j'ai une erreur, et je ne comprend pas pourquoi...

Voici le fichier Polygone.h :

#ifndef __POLYGONE__
#define __POLYGONE__

#include <GL/glut.h>
#include <stdlib.h>
#include <math.h>

#include <iostream>

#include "Vecteur.h"
#include "Triangle.h"

class Polygone
{

    private :

            // Tableau contenant les 4 coordonnées du Polygone.
            GLdouble ** coords_polygone;

            // Tout quadrilatère est composé de deux triangles :
            Triangle* T1;
            Triangle* T2;

    public :

            // Constructeur par défaut
            Polygone()
            {
            coords_polygone=new GLdouble * [4];

            for(int i = 0 ; i < 4 ; i++) coords_polygone[i]= new GLdouble[3];

            for(int i = 0 ; i < 4 ; i++)
                for(int j = 0 ; j < 3 ; j++) coords_polygone[i][j]= 0;

            }

            // Constructeur avec paramètres.
            Polygone(GLdouble X1, GLdouble Y1, GLdouble Z1, GLdouble X2, GLdouble Y2, GLdouble Z2, GLdouble X3, GLdouble Y3, GLdouble Z3, GLdouble X4, GLdouble Y4, GLdouble Z4 )
            {

                coords_polygone = new GLdouble* [4];

                coords_polygone[0] = new GLdouble [3];
                coords_polygone[1] = new GLdouble [3]; // On alloue dynamiquement notre tableau
                coords_polygone[2] = new GLdouble [3];
                coords_polygone[3] = new GLdouble [3];

                coords_polygone[0][0] = X1;
                coords_polygone[0][1] = Y1;  // On instancie le premier Point du polygone
                coords_polygone[0][2] = Z1;

                coords_polygone[1][0] = X2;
                coords_polygone[1][1] = Y2; // Le deuxième
                coords_polygone[1][2] = Z2;

                coords_polygone[2][0] = X3;
                coords_polygone[2][1] = Y3; // Le Troisième
                coords_polygone[2][2] = Z3;

                coords_polygone[3][0] = X4;
                coords_polygone[3][1] = Y4; // Et enfin, le Quatrième.
                coords_polygone[3][2] = Z4;

                T1 = new Triangle( X1, Y1, Z1, X2, Y2, Z2, X3, Y3, Z3 ); // Avec les sommets 123
                T2 = new Triangle( X3, Y3, Z3, X4, Y4, Z4, X1, Y1, Z1 ); // Avec les sommets 341

                std::cout << "Creation du polygone réussie" << std::endl;
            }

            // Destructeur du polygone.
            ~Polygone()
            {
                for (int i=0; i<3; i++)
                {
                    delete[] coords_polygone[i];
                }
                delete[] coords_polygone;
                // coords_polygone=NULL;
            }

            bool test_collision(float a, float b, float c)
            {
                bool x =  T1.testcollision(a,b,c);
                bool y =  T2.testcollision(a,b,c);
                 
                return 0;
            }
};

#endif

Voici le fichier "Triangle.h" :

#ifndef __TRIANGLE__
#define __TRIANGLE__

#include <GL/glut.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <cmath>

#include <iostream>

#include "Vecteur.h"

#define PI 3.14159265

class Triangle
{

    private :

            // Tableau contenant les 3 coordonnées du Triangle.
            GLdouble ** coords_triangle;


    public :

            // Constructeur par défaut
            Triangle()
            {
            coords_triangle=new GLdouble * [3];

            for(int i = 0 ; i < 3 ; i++) coords_triangle[i]= new GLdouble[3];

            for(int i = 0 ; i < 3 ; i++)
                for(int j = 0 ; j < 3 ; j++) coords_triangle[i][j]= 0;

            }

            // Constructeur avec paramètres.
            Triangle(GLdouble X1, GLdouble Y1, GLdouble Z1, GLdouble X2, GLdouble Y2, GLdouble Z2, GLdouble X3, GLdouble Y3, GLdouble Z3 )
            {

                coords_triangle = new GLdouble* [3];

                coords_triangle[0] = new GLdouble [3];
                coords_triangle[1] = new GLdouble [3]; // On alloue dynamiquement notre tableau
                coords_triangle[2] = new GLdouble [3];


                coords_triangle[0][0] = X1;
                coords_triangle[0][1] = Y1;  // On instancie le premier Point du polygone
                coords_triangle[0][2] = Z1;

                coords_triangle[1][0] = X2;
                coords_triangle[1][1] = Y2; // Le deuxième
                coords_triangle[1][2] = Z2;

                coords_triangle[2][0] = X3;
                coords_triangle[2][1] = Y3; // Le Troisième
                coords_triangle[2][2] = Z3;

                std::cout << "Creation du Triangle reussie" << std::endl;
            }

            // Destructeur du Triangle.
            ~Triangle()
            {
                for (int i=0; i<3; i++)
                {
                    delete[] coords_triangle[i];
                }
                delete[] coords_triangle;
                // coords_triangle=NULL;
            }

            // La cam appelle cette fonction pour les 2 triangles de chaque polygone. Elle lui passe ses coordonnées en paramètres.
            bool testcollision (float a, float b, float c)
            {
                // Calcule des coordonées des vecteurs reliant le point caméra aux 3 sommets du triangle.
                double V1x = coords_triangle[0][0] - a;
                double V1y = coords_triangle[0][1] - b;
                double V1z = coords_triangle[0][2] - c;

                double V2x = coords_triangle[1][0] - a;
                double V2y = coords_triangle[1][1] - b;
                double V2z = coords_triangle[1][2] - c;

                double V3x = coords_triangle[2][0] - a;
                double V3y = coords_triangle[2][1] - b;
                double V3z = coords_triangle[2][2] - c;

                // Il faut crée les trois vecteurs, reliant le point de la cam aux sommets du triangle !
                Vecteur V1( V1x, V1y, V1z );
                Vecteur V2( V2x, V2y, V2z );
                Vecteur V3( V3x, V3y, V3z );

                // On les normalise, pour le produit scalaire.
                V1.normalisation();
                V2.normalisation();
                V3.normalisation();

                // Maintenant, on fait la somme des produits scalaires.
                double S1 = V1.scalaire(V2);
                double S2 = V1.scalaire(V3);
                double S3 = V2.scalaire(V3);
                
                // Somme des angles, avec la fonctions arccosinus
                double sda = (acos(S1) * (180.0 / PI)) + (acos(S2) * (180.0 / PI)) + (acos(S3)* (180.0 / PI));

                if(sda==360.0) 
                    return true;
                
                return false;
            }
};

#endif

Les fonctions intéressantes pour vous ici sont uniquement les fonctions de test de collision !!!

Maintenant, voici l'erreur que me génère Dev !!! :

Polygone.h In member function `bool Polygone::test_collision(float, float, float)': 
Polygone.h request for member of non-aggregate type before '(' token 
Polygone.h `testcollision' has not been declared
Polygone.h request for member of non-aggregate type before '(' token 

Je ne suis pas spécialement mauvais développeur, et en principe, j'arrive a dénicher les bugs, mais je doiq avouer que la, je ne comprends vraiment pas ce qu'il se passe... Le #include est la, la déclaration est correcte, en bref, je ne vois pas ce qu'il manque... C'est mon dernier big avant de pouvoir tester les collisions, j'espère que qqn pourra m'aider...

Cordialement

Bonne nuit

Azerty