Discussion :

[romainprogdebutant]

Bonjour,
J'aimerai avoir des précisions sur le pasage par référence constante, je vais montrer les exemple directement ce sera plus parlant

mon.h de ma classe comporte

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

bool intersect(const Ray &r, float t0, float t1) const;

monn/cpp de ma classe comporte

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

bool Box::intersect(const Ray &r, float t0, float t1) const {...

appel depuis le main :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

b.intersect(r,0,4)

erreur :

Error: il n'existe aucune conversion définie par l'utilisateur appropriée de Ray en const Ray

ok maintenant

mon.h de ma classe comporte

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

bool intersect(Ray &r, float t0, float t1) const;

monn/cpp de ma classe comporte

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

bool Box::intersect(Ray &r, float t0, float t1) const {...

appel depuis le main :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

b.intersect(r,0,4)

erreur :

Error: impossible d'initialiser une référence de type "Ray &"(non qualifié const) avec une valeur de type "Ray"

bon j'ai testé ça aussi :

mon.h de ma classe comporte

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

bool intersect(Ray const &r, float t0, float t1) const;

monn/cpp de ma classe comporte

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

bool Box::intersect(Ray const &r, float t0, float t1) const {...

appel depuis le main :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

b.intersect(r,0,4)

erreur :

Error: il n'existe aucune conversion définie par l'utilisateur appropriée de "Ray" en "const Ray"

[Iradrille]

Hello,

Il va falloir donner plus de détails car on peut pas deviner d'où vient le problème.

[romainprogdebutant]

Hello,

Il va falloir donner plus de détails car on peut pas deviner d'où vient le problème.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include "box.h"
 
Box::Box(const Vec3f &mini, const Vec3f &maxi) {
		bounds[0] = mini;
		bounds[1] = maxi;
	}
 
void Box::expand(Box box){
	bounds[0] = Vec3f(std::min(box.bounds[0].x,bounds[0].x),std::min(box.bounds[0].x,bounds[0].x),std::min(box.bounds[0].x,bounds[0].x));	
	bounds[1] = Vec3f(std::max(box.bounds[0].x,bounds[0].x),std::max(box.bounds[0].x,bounds[0].x),std::max(box.bounds[0].x,bounds[0].x));
}
 
bool Box::intersect( Ray const &r, float t0, float t1) const {
	float tmin, tmax, tymin, tymax, tzmin, tzmax;
	tmin = (bounds[r.sign[0]].x - r.origin.x) * r.inv_direction.x;
	tmax = (bounds[1-r.sign[0]].x - r.origin.x) * r.inv_direction.x;
	tymin = (bounds[r.sign[1]].y - r.origin.y) * r.inv_direction.y;
	tymax = (bounds[1-r.sign[1]].y - r.origin.y) * r.inv_direction.y;
	if ( (tmin > tymax) || (tymin > tmax) )
		return false;
	if (tymin > tmin)
		tmin = tymin;
	if (tymax < tmax)
		tmax = tymax;
	tzmin = (bounds[r.sign[2]].z - r.origin.z) * r.inv_direction.z;
	tzmax = (bounds[1-r.sign[2]].z - r.origin.z) * r.inv_direction.z;
	if ( (tmin > tzmax) || (tzmin > tmax) )
		return false;
	if (tzmin > tmin)
		tmin = tzmin;
	if (tzmax < tmax)
		tmax = tzmax;
	return ( (tmin < t1) && (tmax > t0) );
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
class Box {
public:
	Box();
	Box(const Vec3f &mini, const Vec3f &maxi);
	bool intersect(Ray const &r, float t0, float t1) const;
	void expand(Box box);
 
protected :
	Vec3f bounds[2];
};

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
int main(int argc, char **argv)
{
	Vec3f mini(1,1,1);
	Vec3f maxi(2,2,2);
	Box b(mini,maxi);
	Vec3f o(1.5,1.5,0);
	Vec3f d(0,0,1);
	Ray r(o,d);
	if(b.intersect(r,0,4))
		cout << "interstion ok"<< endl;
	else
		cout << "nok" <<endl;

	system("pause");
	return 0;
}

l'erreur se trouve au niveau du "r" souligné

[ternel]

Pour la deuxième erreur, c'est qu'on ne peut pas fournir une valeur temporaire à une référence modifiante (Ray&).

Pour la première, c'est probablement lié à une interférence entre plusieurs noms "Ray".
Vérifie les namespace et autre.
Vérifie aussi que ce ne soit pas un include manquant (si c'est ca, ton compilateur n'est pas poli)

[Iradrille]

Hum...

En ajoutant les classes Vec3f et Ray ça compile sans problème. A quoi elles ressemblent ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
struct Vec3f {
	float x, y, z;
 
	Vec3f() { }
	Vec3f(float, float, float) { }
};
 
struct Ray {
	Ray(Vec3f const&, Vec3f const&) { }
 
	int sign[42];
	Vec3f origin;
	Vec3f inv_direction;
};

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
#include <iostream>
#include <algorithm>
 
using std::cout;
using std::endl;
 
struct Vec3f {
	float x, y, z;
 
	Vec3f() { }
	Vec3f(float, float, float) { }
};
 
struct Ray {
	Ray(Vec3f const&, Vec3f const&) { }
 
	int sign[42];
	Vec3f origin;
	Vec3f inv_direction;
};
 
class Box {
public:
	Box();
	Box(const Vec3f &mini, const Vec3f &maxi);
	bool intersect(Ray const &r, float t0, float t1) const;
	void expand(Box box);
 
protected:
	Vec3f bounds[2];
};
 
Box::Box(const Vec3f &mini, const Vec3f &maxi) {
	bounds[0] = mini;
	bounds[1] = maxi;
}
 
void Box::expand(Box box) {
	bounds[0] = Vec3f(std::min(box.bounds[0].x, bounds[0].x), std::min(box.bounds[0].x, bounds[0].x), std::min(box.bounds[0].x, bounds[0].x));
	bounds[1] = Vec3f(std::max(box.bounds[0].x, bounds[0].x), std::max(box.bounds[0].x, bounds[0].x), std::max(box.bounds[0].x, bounds[0].x));
}
 
bool Box::intersect(Ray const &r, float t0, float t1) const {
	float tmin, tmax, tymin, tymax, tzmin, tzmax;
	tmin = (bounds[r.sign[0]].x - r.origin.x) * r.inv_direction.x;
	tmax = (bounds[1 - r.sign[0]].x - r.origin.x) * r.inv_direction.x;
	tymin = (bounds[r.sign[1]].y - r.origin.y) * r.inv_direction.y;
	tymax = (bounds[1 - r.sign[1]].y - r.origin.y) * r.inv_direction.y;
	if ((tmin > tymax) || (tymin > tmax))
		return false;
	if (tymin > tmin)
		tmin = tymin;
	if (tymax < tmax)
		tmax = tymax;
	tzmin = (bounds[r.sign[2]].z - r.origin.z) * r.inv_direction.z;
	tzmax = (bounds[1 - r.sign[2]].z - r.origin.z) * r.inv_direction.z;
	if ((tmin > tzmax) || (tzmin > tmax))
		return false;
	if (tzmin > tmin)
		tmin = tzmin;
	if (tzmax < tmax)
		tmax = tzmax;
	return ((tmin < t1) && (tmax > t0));
	return false;
}
 
int main(int argc, char **argv)
{
	Vec3f mini(1, 1, 1);
	Vec3f maxi(2, 2, 2);
	Box b(mini, maxi);
	Vec3f o(1.5, 1.5, 0);
	Vec3f d(0, 0, 1);
	Ray r(o, d);
	if (b.intersect(r, 0, 4))
		cout << "interstion ok" << endl;
	else
		cout << "nok" << endl;
 
	system("pause");
	return 0;
}

[romainprogdebutant]

Pour la première, c'est probablement lié à une interférence entre plusieurs noms "Ray".
Vérifie les namespace et autre.

Je pense que c'est la cause en effet, le problème c'est que j'ai plusieurs classe qui s'incluent les unes les autres parfois oui parfois non du coup j'ai mis des
#ifndef EX
#define EX
#include "exemple.h"
#endif

à chaque fois mais ça ne fonctionne, toujours pas c'est quoi la bonne méthode du coup svp ?

[ternel]

mettre le define dans le .h

utiliser des namespace et ne pas (trop) utiliser using namespace

[romainprogdebutant]

C'est ce que j'ai fait je vous met mes fichiers parceque là je m'en sors pas, le compilo me met des erreurs à cotés de la plaque
geometry.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
#include <cstdlib>
#include <cstdio>
#include <iostream>
#include <iomanip>
#include <cmath>
#include <stdint.h>
 
template<typename T>
class Vec3
{
public:
    Vec3() : x(T(0)), y(T(0)), z(T(0)) {}
    Vec3(T xx) : x(xx), y(xx), z(xx) {}
    Vec3(T xx, T yy, T zz) : x(xx), y(yy), z(zz) {}
    Vec3 operator + (const Vec3 &v) const
    { return Vec3(x + v.x, y + v.y, z + v.z); }
    Vec3 operator - (const Vec3 &v) const
    { return Vec3(x - v.x, y - v.y, z - v.z); }
    Vec3 operator - () const
    { return Vec3(-x, -y, -z); }
    Vec3 operator * (const T &r) const
    { return Vec3(x * r, y * r, z * r); }
    Vec3 operator * (const Vec3 &v) const
    { return Vec3(x * v.x, y * v.y, z * v.z); }
    T dotProduct(const Vec3<T> &v) const
    { return x * v.x + y * v.y + z * v.z; }
    Vec3& operator /= (const T &r)
    { x /= r, y /= r, z /= r; return *this; }
    Vec3& operator *= (const T &r)
    { x *= r, y *= r, z *= r; return *this; }
    Vec3 crossProduct(const Vec3<T> &v) const
    { return Vec3<T>(y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x); }
    T norm() const
    { return x * x + y * y + z * z; }
    T length() const
    { return sqrt(norm()); }
	bool operator < (const Vec3<T> &v)
	{ return x<v.x && y<v.y && z<v.z ;}
    const T& operator [] (uint8_t i) const { return (&x)[i]; }
    T& operator [] (uint8_t i) { return (&x)[i]; }
    Vec3& normalize()
    {
        T n = norm();
        if (n > 0) {
            T factor = 1 / sqrt(n);
            x *= factor, y *= factor, z *= factor;
        }
 
        return *this;
    }  
    T x, y, z;
};
typedef Vec3<float> Vec3f;
typedef Vec3<int> Vec3i;

triangle.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <vector>
#ifndef BOX
#define Box
#include "box.h"
#endif
 
class Triangle{
public:
 
	Triangle(){
		p0 = 0;
		p1 = 0;
		p2 = 0;
	}
 
	Triangle(Vec3i indices, const std::vector<Vec3f> &vertexList);
	Box getBoundingBox();
 
	Vec3f *p0,*p1,*p2:
};

triangle.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include "triangle.h"
#include "box.h"
 
Box Triangle::getBoundingBox(){	
		*p0=0;
		Vec3f boxMin(std::min(p0->x,std::min(p1->x,p2->x)),std::min(p0->y,std::min(p1->y,p2->y)),std::min(p0->z,std::min(p1->z,p2->z)));
		Vec3f boxMax(std::max(p0->x,std::max(p1->x,p2->x)),std::max(p0->y,std::max(p1->y,p2->y)),std::max(p0->z,std::max(p1->z,p2->z)));
		return Box(boxMin,boxMax);
	}
Triangle::Triangle(Vec3i indices, const std::vector<Vec3f> &vertexList){
		p0 = vertexList[indices.x];
		p1 = vertexList[indices.y];
		p2 = vertexList[indices.z];
	}

ray.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#ifndef GEO
#define GEO
#include "geometry.h"
#endif
 
class Ray {
public:
	Ray(Vec3f &o, Vec3f &d) {
		origin = o;
		direction = d;
		inv_direction = Vec3f(1/d.x, 1/d.y, 1/d.z);
		sign[0] = (inv_direction.x < 0);
		sign[1] = (inv_direction.y < 0);
		sign[2] = (inv_direction.z < 0);
	}
	Vec3f origin;
	Vec3f direction;
	Vec3f inv_direction;
	int sign[3];
};

box.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#ifndef RAY
#define RAY
#include "ray.h"
#endif
 
class Box {
public:
	Box(const Vec3f &mini, const Vec3f &maxi);
	bool intersect(const Ray &r, float t0, float t1) const;
	void expand(Box box);
 
protected :
	Vec3f bounds[2];
};

box.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#ifndef RAY
#define RAY
#include "ray.h"
#endif
 
class Box {
public:
	Box(const Vec3f &mini, const Vec3f &maxi);
	bool intersect(const Ray &r, float t0, float t1) const;
	void expand(Box box);
 
protected :
	Vec3f bounds[2];
};

main

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
#include <windows.h>
 
int main(int argc, char **argv)
{
 
	system("pause");
	return 0;
}

[Arzar]

Bonjour,

Je comprends que le compilateur soit perdu, c'est un peu le chaos avec ces #ifndef sauvages.

Pour éviter les ennuis, vaut mieux respecter l'organisation définie dans la FAQ :
http://cpp.developpez.com/faq/cpp/?p...un-fichier-cpp

En gros :

Dans Truc.h, entourer le code "d'include guard" pour éviter les pb d'inclusions multiples :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
#ifndef IDENTIFIANT_TRUC
#define IDENTIFIANT_TRUC
 
// le code
...
 
#endif

Truc.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
#include "Truc.h"
 
// le code
// ...

Puis pour régler les problèmes d'inter-inclusion entre classes, il faut utiliser les déclarations anticipées (forward declaration)
Un résumé ici :

http://stackoverflow.com/questions/5...rd-declaration

Un example, dans ta classe Triangle.h, tu peux faire une déclaration anticipée de Box, pas besoin d'inclure Box.h (Par contre il faudra faire un #include "Box.h" dans Triangle.cpp)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
#include <vector>
 
class Box; // declaration anticipée
 
class Triangle{
public:
 
	Triangle(){
		p0 = 0;
		p1 = 0;
		p2 = 0;
	}
 
	Triangle(Vec3i indices, const std::vector<Vec3f> &vertexList);
	Box getBoundingBox();
 
	Vec3f *p0,*p1,*p2:
};

[ternel]

la bonne manière de faire une "include guard" c'est dans le fichier inclus, pas dans l'inclueur

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#ifndef RAY_H_INCLUDED
#define RAY_H_INCLUDED
#include "geometry.h"
 
struct Ray {
	Ray(Vec3f const& o, Vec3f const& d) :
		origin(o), direction(d),
		inv_direction(1/d.x, 1/d.y, 1/d.z)
	{
		sign[0] = (inv_direction.x < 0);
		sign[1] = (inv_direction.y < 0);
		sign[2] = (inv_direction.z < 0);
	}
	Vec3f origin;
	Vec3f direction;
	Vec3f inv_direction;
	int sign[3];
};
#endif

J'en profite opur améliorer ton constructeur: utilisation de la liste d'initialisation, et des références constantes.

Fais de même avec tous tes .h, et le problème devrait se résoudre de lui même.

[Médinoc]

Un example, dans ta classe Triangle.h, tu peux faire une déclaration anticipée de Box, pas besoin d'inclure Box.h (Par contre il faudra faire un #include "Box.h" dans Triangle.cpp)

Je ne crois pas que ça marche dans cet exemple, un objet de la classe Box étant retourné par valeur par une des fonctions membres.

[romainprogdebutant]

Merci ça marche