3D)Point de contact entre une face et un point

Dans le moteur 3d que je dévelope présentement j'ai un problème de performance .
Voila j'aimerais savoir si vous connaissiez un algorithme qui permettrait de savoir le point de collision z entre un face et un point X Y .
On connait chaque coordonnés (X,Y,Z) de chaque vertex qui constitue la face. On connait seulement les coordonnés (x,y) du point.

Voici un schéma fait avec blender pour essayer d'expliquer mieux le problème:



J'ai trouvé la solution mais elle prend trop de ressources .
La voici: (c'est un script)
//argument0=x du point dont on cherche le z de collision
//argument1=y du point dont on cherche le z de collision
//arguemnt2=x du vertex 1
//arguemnt3=y du vertex 1
//arguemnt4=z du vertex 1
//arguemnt5=x du vertex 2
//arguemnt6=y du vertex 2
//arguemnt7=z du vertex 2
//arguemnt8=x du vertex 3
//arguemnt9=y du vertex 3
//arguemnt10=z du vertex 3
http://global.find_z retournne si le script à trouver une valeur
http://global.find_z_value retournne la valeur z trouver
{
if M3D_VertexInTriangle(argument0,argument1,argument2,argument3,argument5,argument6,argument8,argument9)//AUTRE SCRIPT QUI PERMET DE SAVOIR AVANT TOUT SI LE POINT EST DANS LA FACE (EN 2D)
{var dc1;var dc2;var dc3;var b1;var c1;var b2;var c2;var b3;var c3;
b1=find_angle(point_direction(argument5,argument6,argument2,argument3),point_direction(argument5,argument6,argument8,argument9))
c1=max(180-find_angle(point_direction(argument2,argument3,argument5,argument6),point_direction(argument2,argument3,argument0,argument1))-b1,1)
dc1=(sin(degtorad(b1))*point_distance(argument2,argument3,argument5,argument6))/sin(degtorad(c1))
b2=find_angle(point_direction(argument8,argument9,argument5,argument6),point_direction(argument8,argument9,argument2,argument3))
c2=max(180-find_angle(point_direction(argument5,argument6,argument8,argument9),point_direction(argument5,argument6,argument0,argument1))-b2,1)
dc2=(sin(degtorad(b2))*point_distance(argument5,argument6,argument8,argument9))/sin(degtorad(c2))
b3=find_angle(point_direction(argument2,argument3,argument8,argument9),point_direction(argument2,argument3,argument5,argument6))
c3=max(180-find_angle(point_direction(argument8,argument9,argument2,argument3),point_direction(argument8,argument9,argument0,argument1))-b3,1)
dc3=(sin(degtorad(b3))*point_distance(argument8,argument9,argument2,argument3))/sin(degtorad(c3))if dc1=0|| dc2=0|| dc3=0{global.find_z=false exit}
global.find_z=true
global.find_z_value=((1-(point_distance(argument2,argument3,argument0,argument1)/dc1))*argument4)+((1-(point_distance(argument5,argument6,argument0,argument1)/dc2))*argument7)+((1-(point_distance(argument8,argument9,argument0,argument1)/dc3))*argument10)exit}else{global.find_z=false}
}



Le script find_angle que le dernier script utilise permet de trouver l'angle entre deux direction donnés.
voici son script :
var maxi;var mini;
maxi=max(number_limit(argument0,0,360),number_limit(argument1,0,360));
mini=min(number_limit(argument0,0,360),number_limit(argument1,0,360));
if (maxi>180&&mini>180)|| (maxi<180&&mini<180){return abs(maxi-mini)}
if maxi-mini>180{return abs(mini+(360-maxi))}
if maxi>=180&& mini<=180{return abs(maxi-mini)}


Mais j'ai penser aussi faire l'équivalent en C++ puis en faire une DLL comme sa le côté performance serait sauvé. Mais je vais attendre vos réponses.

j'aimerais beaucoup t'aider mais je ne mis connais pas en 3d...

Je ne suis malheuresement pas expert en la matière, donc je ne peut pas t'aider...
Désolé...