Calculer les équations des plans du Frustum et clipping

**kiroukou** · 10/01/2007, 00h08

Bonjour à vous,
Voilà je rencontre un problème en tentant d'implémenter le frustum clipping.
J'ai taché de déterminer les points définissant le frustum et ensuite de calculer l'équation de chacun des plans.

J'obtiens pour le moment les équations suivantes :

Plan gauche : 0.99990604980155,0,0.0137073546047075,-2.77555756156289e-17

Plan droit :-0.99990604980155,0,0.0137073546047075,-2.77555756156289e-17

Plan sommet : 0,-0.99990604980155,0.0137073546047075,-2.77555756156289e-17

Plan sol : 0,0.99990604980155,0.0137073546047075,-2.77555756156289e-17

Plan proche : 0,0,1,10

Plan lointain : 0,0,-1,-1000

Est ce que ces valeurs vous semblent correctes? (si vous avez la possibilité de comparer avec des valeurs obtenues sur d'autres moteurs par ex).

Déja est-t'il necessaire de normaliser ces plans? En vue du clipping toujours.
Lors du clipping dans quel repère doivent etre les vertices? Dans celui de la camera "normalisé" par la 4eme coordonnée ?

Merci de m'aider à éclaircir ces points assez sombres pour moi

)

**Laurent Gomila** · 10/01/2007, 09h52

Est ce que ces valeurs vous semblent correctes?

Presque : les normales ont l'air bien orientées (2 sur X, 2 sur Y, 2 sur Z), mais tes 4 premiers plans passent tous par l'origine. Et à mon avis tu n'es pas dans le bon espace, car à moins d'avoir une caméra parfaitement alignée et une projection ortho, tu ne devrais pas avoir des valeurs aussi parfaites.

Déja est-t'il necessaire de normaliser ces plans? En vue du clipping toujours.

Ils le sont déjà, donc j'imagine que la méthode que tu emploies resort toujours des plans normalisés.

Lors du clipping dans quel repère doivent etre les vertices? Dans celui de la camera "normalisé" par la 4eme coordonnée ?

Dans le même que ton frustum. En général, on utilise l'espace monde.

Je ne sais pas quelle méthode tu emploies pour calculer tout ça, mais je pense que le point de départ serait de nous la donner pour qu'on puisse t'aider

**kiroukou** · 10/01/2007, 21h09

Salut Laurent et merci de ta réponse.

Voilà mon code, en espérant qu'il puisse te permettre de m'aider un peu plus encore.

MAtrice de projection :

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
	public function setPerspectiveProjection(fovY:Number, aspectRatio:Number, zNear:Number, zFar:Number):Void
	{
		var cotan:Number, Q:Number;
		// --
		if( undefined == fovY ) fovY = 45;
		if( undefined == aspectRatio ) aspectRatio = _is.getRatio();
		if( undefined == zNear ) zNear = 10;
		if( undefined == zFar ) zFar = 1000;
		// --
		fovY = NumberUtil.toRadian( fovY );
		cotan = 1 / Math.tan(fovY / 2);
		Q = zFar/(zFar - zNear);
 
		delete _mp;
		_mp = Matrix4.createZero();
		_mp.n11 = cotan / aspectRatio;
		_mp.n22 = cotan;
		_mp.n33 = Q;
		_mp.n34 = -Q*zNear;
		_mp.n43 = 1;
 
		_mpInv = Matrix4Math.getInverse( _mp );
 
		frustrum.computePlanes(aspectRatio, zNear, zFar, 2*fovY );
 
		_compiled = false;
 
	}

Extraction des points du frustum et des plans :

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
 
	public function computePlanes( nAspect:Number, fNear:Number, fFar:Number, nFov:Number ):Void
	{
		var yNear:Number = (Math.tan (nFov / 2 * 0.017453292519943295769236907684886)) * fNear;
		var xNear:Number = yNear * nAspect;
		var yFar:Number = yNear * fFar / fNear;
		var xFar:Number = xNear * fFar / fNear;
		//fNear = -fNear;
		//fFar = -fFar;
		var p:Array = aVertex;
		p[0] = new Vector(xNear, yNear, fNear); // Near, right, top
		p[1] = new Vector(xNear, -yNear, fNear); // Near, right, bottom
		p[2] = new Vector(-xNear, -yNear, fNear); // Near, left, bottom
		p[3] = new Vector(-xNear, yNear, fNear); // Near, left, top
		p[4] = new Vector(xFar, yFar, fFar);  // Far, right, top
		p[5] = new Vector(xFar, -yFar, fFar);  // Far, right, bottom
		p[6] = new Vector(-xFar, -yFar, fFar);  // Far, left, bottom
		p[7] = new Vector( -xFar, yFar, fFar);  // Far, left, top
 
		aPlanes[0] = PlaneMath.computePlaneFromPoints( p[2], p[3], p[6] ); // Left
		trace("Plan gauche : "+aPlanes[0]);
		aPlanes[1] = PlaneMath.computePlaneFromPoints( p[0], p[1], p[4] ); // right
		trace("Plan droit : "+aPlanes[1]);
		aPlanes[2] = PlaneMath.computePlaneFromPoints( p[0], p[7], p[3] ); // Top
		trace("Plan sommet : "+aPlanes[2]);
		aPlanes[3] = PlaneMath.computePlaneFromPoints( p[1], p[2], p[5] ); // Bottom
		trace("Plan sol : "+aPlanes[3]);
		aPlanes[4] = PlaneMath.computePlaneFromPoints( p[0], p[2], p[1] ); // Near
		trace("Plan proche : "+aPlanes[4]);
		aPlanes[5] = PlaneMath.computePlaneFromPoints( p[4], p[5], p[6] ); // Far
		trace("Plan lointain : "+aPlanes[5]);
 
		for( var i:Number = 0; i < 6; i++ )
			PlaneMath.normalizePlane( aPlanes[i] );	
 
 
	}

Et mes fonctions "utilitaires" sur les plans :

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
 
 
	/**
         * Normalize the plane. Often before making some calculations with a plane you have to normalize it.
         * @param plane Plane The plane that we want to normalize.
         */
	public static function normalizePlane( plane:Plane ):Void
	{
		var mag:Number;
		mag = Math.sqrt( plane.a * plane.a + plane.b * plane.b + plane.c * plane.c );
		plane.a = plane.a / mag;
		plane.b = plane.b / mag;
		plane.c = plane.c / mag;
		plane.d = plane.d / mag;
	}
 
	/**
         * Computes the distance between a plane and a 3D point (a vector here).
         * @param plane Plane The plane we want to compute the distance from
         * @param pt Vector The vector in the 3D space
         * @return Number The distance between the point and the plane.
         */
	public static function distanceToPoint( plane:Plane, pt:Vector ):Number
	{
		return plane.a * pt.x + plane.b * pt.y + plane.c * pt.z + plane.d ;
	}
 
	/**
         * Returns a constant PlaneMath.NEGATIVE PlaneMath.POSITIVE PlaneMath.ON_PLANE depending of the position
         * of the point compared to the plane
         * @param plane Plane The reference plane
         * @param pt Vector The point we want to classify
         * @return Number The classification of the point PlaneMath.NEGATIVE or PlaneMath.POSITIVE or PlaneMath.ON_PLANE 
         */
	public static function classifyPoint( plane:Plane, pt:Vector ):Number
	{
		var d:Number;
		d = PlaneMath.distanceToPoint( plane, pt );
		if (d < 0) return PlaneMath.NEGATIVE;
		if (d > 0) return PlaneMath.POSITIVE;
		return PlaneMath.ON_PLANE;
	}
 
	public static function computePlaneFromPoints( pA:Vector, pB:Vector, pC:Vector ):Plane
	{
		var p:Plane = new Plane();
		var n:Vector = VectorMath.cross( VectorMath.sub( pA, pB), VectorMath.sub( pA, pC) );
		VectorMath.normalize( n );
		var d:Number = VectorMath.dot( pA, n);
		// --
		p.a = n.x;
		p.b = n.y;
		p.c = n.z;
		p.d = d;
		// --
		return p;
	}

Vois tu qq chose de non cohérent?

Merci bcp

**kiroukou** · 11/01/2007, 09h49

Bonjour,
personne ne vois comment faire cela OU si mon code présente des erreurs (dans la partie algorithmique bien sur)?

Comment faites vous cela sans utiliser OpenGL ou autre?

Merci

**Laurent Gomila** · 11/01/2007, 10h09

Difficile à dire, je ne vois en tout cas pas d'erreur qui saute aux yeux.

Personnellement j'utilise la méthode décrite ici :
http://www2.ravensoft.com/users/ggri...extraction.pdf

Tu peux l'essayer, ça te permettra de voir si c'est ton algo d'extraction des plans qui est foireux ou non.

**kiroukou** · 11/01/2007, 10h21

Salut laurent,
Oui je connais ce document.
Mais le soucis c'est que cela utilise la model view aussi pour extraire ces plans. Je veux dire qu'a chaque cycle tu es obligé de faire cette extraction.

Moi pour des raisons de perfs je ne veux faire cela qu'une seule fois, et cela doit etre possible vu que je ramène mes objets dans le repère de la caméra initial.

Voilà pourquoi je me suis concentré sur cette solution.
Peut etre est-je mal compris un principe..?

Autrement tu obtiens quel type d'équations avec ta méthode?

Merci