Attention: Here be dragons
This is the latest
(unstable) version of this documentation, which may document features
not available in or compatible with released stable versions of Godot.
Checking the stable version of the documentation...
Plane
Un plan en form normale de Hesse.
Description
Represents a normalized plane equation. normal is the normal of the plane (a, b, c normalized), and d is the distance from the origin to the plane (in the direction of "normal"). "Over" or "Above" the plane is considered the side of the plane towards where the normal is pointing.
Note: In a boolean context, a plane will evaluate to false if all its components equal 0. Otherwise, a plane will always evaluate to true.
Tutoriels
Propriétés
|
||
|
||
|
||
|
||
|
Constructeurs
Plane() |
|
Méthodes
distance_to(point: Vector3) const |
|
get_center() const |
|
intersect_3(b: Plane, c: Plane) const |
|
intersects_ray(from: Vector3, dir: Vector3) const |
|
intersects_segment(from: Vector3, to: Vector3) const |
|
is_equal_approx(to_plane: Plane) const |
|
is_finite() const |
|
is_point_over(point: Vector3) const |
|
normalized() const |
|
Opérateurs
operator !=(right: Plane) |
|
operator *(right: Transform3D) |
|
operator ==(right: Plane) |
|
Constantes
PLANE_YZ = Plane(1, 0, 0, 0) 🔗
Un plan qui s'étend aux axes Y et Z (le vecteur normal pointe vers +X).
PLANE_XZ = Plane(0, 1, 0, 0) 🔗
Un plan qui s'étend aux axes X et Z (le vecteur normal pointe vers +Y).
PLANE_XY = Plane(0, 0, 1, 0) 🔗
Un plan qui s'étend aux axes X et Y (le vecteur normal pointe vers +Z).
Descriptions des propriétés
La distance entre l'origine et le plan, exprimée en termes de normal (selon sa direction et son longueur). La distance absolue réelle entre l'origine et le plan peut être calculée avec abs(d) / normal.length() (si normal a une longueur de zéro alors ce Plane ne représente pas un plan valide).
Dans l'équation scalaire du plan ax + by + cz = d, il s’agit de d, tandis que les coordonnées (a, b, c) sont représentées par la propriété normal.
Vector3 normal = Vector3(0, 0, 0) 🔗
La normale au plan, généralement un vecteur unitaire. Ne devrait pas être un vecteur zéro car un Plane avec un tel vecteur normal ne représente pas un plan valide.
Dans l'équation scalaire du plan ax + by + cz = d, c'est le vecteur (a, b, c), où d est la propriété d.
Le composant X du vecteur de la normal du plan.
Le composant Y du vecteur de la normal du plan.
Le composant Z du vecteur de la normal du plan.
Descriptions des constructeurs
Construit un Plane initialisé par défaut, avec toutes ses composantes définies à 0.
Construit un Plane comme une copie du Plane donné.
Plane Plane(a: float, b: float, c: float, d: float)
Crée un plan à partir des quatre paramètres. Les trois composantes du vecteur normal du plan résultant sont a, b et c, et le plan est à une distance d de l'origine.
Crée un plan depuis le vecteur normal. Le plan intersectera l'origine.
Le vecteur normal du plan doit être un vecteur unitaire.
Plane Plane(normal: Vector3, d: float)
Crée un plan depuis le vecteur normal et la distance du plan à l'origine.
Le vecteur normal du plan doit être un vecteur unitaire.
Plane Plane(normal: Vector3, point: Vector3)
Crée un plan depuis le vecteur normal et un point du plan.
Le vecteur normal du plan doit être un vecteur unitaire.
Plane Plane(point1: Vector3, point2: Vector3, point3: Vector3)
Crée un plan à partir de trois points, spécifiés dans le sens horaire.
Descriptions des méthodes
float distance_to(point: Vector3) const 🔗
Renvoie la plus courte distance entre le plan et la position point. Si le point est au-dessus du plan, la distance sera positive. S'il est ci-dessous, la distance sera négative.
Renvoie le centre du plan.
bool has_point(point: Vector3, tolerance: float = 1e-05) const 🔗
Renvoie true si le point est à l'intérieur du plan. La comparaison utilise un seuil minimal de tolerance personnalisé.
Variant intersect_3(b: Plane, c: Plane) const 🔗
Renvoie le point d'intersection des trois plans b, c et ce plan. Si aucune intersection n'est trouvée, null est renvoyé.
Variant intersects_ray(from: Vector3, dir: Vector3) const 🔗
Renvoie le point d'intersection d'un rayon composé de la position from et de la direction normale dir avec ce plan. Si aucune intersection n'est trouvée, null est renvoyé.
Variant intersects_segment(from: Vector3, to: Vector3) const 🔗
Renvoie le point d'intersection d'un segment de la position from à la position to avec ce plan. Si aucune intersection n'est trouvée, null est renvoyé.
bool is_equal_approx(to_plane: Plane) const 🔗
Renvoie true si ce plan et to_plane sont approximativement égaux, en exécutant @GlobalScope.is_equal_approx() sur chaque composante.
Renvoie true si ce plan est fini, en appelant @GlobalScope.is_finite() sur chaque composante.
bool is_point_over(point: Vector3) const 🔗
Renvoie true si point est situé au-dessus du plan.
Renvoie une copie du plan, avec le vecteur normal normalisé (c'est donc un vecteur unitaire). Renvoie Plane(0, 0, 0, 0) si normal ne peut être normalisé (il a une longueur de zéro).
Vector3 project(point: Vector3) const 🔗
Renvoie la projection orthogonale de point sur un point du plan.
Descriptions des opérateurs
bool operator !=(right: Plane) 🔗
Renvoie true si les plans ne sont pas égaux.
Note : En raison d'erreurs de précision des flottants, envisagez d'utiliser is_equal_approx() qui est plus fiable.
Plane operator *(right: Transform3D) 🔗
Transforme (multiplie) de manière inverse le Plane par la matrice de transformation Transform3D donnée.
plane * transform est équivalent à transform.affine_inverse() * plane. Voir Transform3D.affine_inverse().
bool operator ==(right: Plane) 🔗
Renvoie true si les plans sont exactement égaux.
Note: En raison d'erreurs de précision des flottants, envisagez d'utiliser is_equal_approx() qui est plus fiable.
Renvoie la même valeur comme si + n'était pas là. Le + unaire ne fait rien, mais peut parfois rendre votre code plus lisible.
Renvoie la valeur négative du Plane. Cela revient à écrire Plane(-p.normal, -p.d). Cette opération retourne la direction du vecteur normal et retourne également la valeur de distance, résultant en un plan qui est au même endroit, mais fait face à la direction opposée.