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...
Camera3D
Hérite de : Node3D < Node < Object
Hérité par : XRCamera3D
Un nœud de caméra ; affichage d'un point de vue.
Description
Camera3D est un nœud spécial qui affiche ce qui est visible depuis son emplacement actuel. Les caméras s'enregistrent dans le nœud Viewport le plus proche (en remontant l'arborescence). Une seule caméra peut être active par viewport. Si aucun viewport n'est disponible dans l'arborescence, la caméra s'enregistrera dans la viewport racine. En d'autres termes, une caméra permet l'affichage en 3D dans un Viewport et, sans caméra, une scène enregistrée dans ce Viewport (où les viewports plus hauts) ne peut être affichée.
Tutoriels
Propriétés
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
Méthodes
void |
clear_current(enable_next: bool = true) |
get_camera_projection() const |
|
get_camera_rid() const |
|
get_camera_transform() const |
|
get_cull_mask_value(layer_number: int) const |
|
get_frustum() const |
|
is_position_behind(world_point: Vector3) const |
|
is_position_in_frustum(world_point: Vector3) const |
|
void |
|
project_local_ray_normal(screen_point: Vector2) const |
|
project_position(screen_point: Vector2, z_depth: float) const |
|
project_ray_normal(screen_point: Vector2) const |
|
project_ray_origin(screen_point: Vector2) const |
|
void |
set_cull_mask_value(layer_number: int, value: bool) |
void |
set_frustum(size: float, offset: Vector2, z_near: float, z_far: float) |
void |
set_orthogonal(size: float, z_near: float, z_far: float) |
void |
set_perspective(fov: float, z_near: float, z_far: float) |
unproject_position(world_point: Vector3) const |
Énumérations
enum ProjectionType: 🔗
ProjectionType PROJECTION_PERSPECTIVE = 0
Projection en perspective. Les objets sur l'écran deviennent plus petits lorsqu'ils sont éloignés.
ProjectionType PROJECTION_ORTHOGONAL = 1
La projection orthogonale, également connue sous le nom de projection orthographique. Les objets gardent la même taille à l'écran, indépendamment de leur distance.
ProjectionType PROJECTION_FRUSTUM = 2
Projection du frustum. Ce mode permet d'ajuster frustum_offset pour créer des effets « frustrum penché ».
enum KeepAspect: 🔗
KeepAspect KEEP_WIDTH = 0
Préserve le rapport d'aspect horizontal, aussi connu comme vertical scaling. C'est généralement la meilleure option pour les projets qui utilisent le mode portrait, étant donné que les rapports plus hauts bénéficient plus des champs de vision plus larges.
KeepAspect KEEP_HEIGHT = 1
Préserve le rapport d'aspect vertical ; également connu sous le nom d'échelle Hor+. C'est généralement la meilleure option pour les projets en mode paysage, car les ratios d'aspect plus larges bénéficieront automatiquement d'un champ de vision horizontal plus large.
enum DopplerTracking: 🔗
DopplerTracking DOPPLER_TRACKING_DISABLED = 0
Désactive la simulation de l'effet Doppler (par défaut).
DopplerTracking DOPPLER_TRACKING_IDLE_STEP = 1
Simule l'effet Doppler en suivant la position des objets qui ont changé lors de _process. Les changements dans la vitesse relative de cette caméra par rapport à ces objets affectent la façon dont l'audio est perçu (changement de la hauteur AudioStreamPlayer3D.pitch_scale de l'audio).
DopplerTracking DOPPLER_TRACKING_PHYSICS_STEP = 2
Simule l'effet Doppler en suivant la position des objets qui ont changé lors de _physics_process. Les changements dans la vitesse relative de cette caméra par rapport à ces objets affectent la façon dont l'audio est perçu (changement de la hauteur AudioStreamPlayer3D.pitch_scale de l'audio).
Descriptions des propriétés
CameraAttributes attributes 🔗
void set_attributes(value: CameraAttributes)
CameraAttributes get_attributes()
Le CameraAttributes à utiliser pour cette caméra.
Compositor compositor 🔗
void set_compositor(value: Compositor)
Compositor get_compositor()
Le Compositor à utiliser pour cette caméra.
Le culling mask qui décrit quelles couches VisualInstance3D.layers sont rendues par cette caméra. Par défaut, les 20 couches visibles par l'utilisateur sont rendues.
Note : Comme le cull_mask permet de stocker 32 couches au total, il y a 12 couches supplémentaires qui ne sont utilisées que par le moteur et ne sont pas exposées dans l'éditeur. Définir cull_mask en utilisant un script vous permet d'utiliser ces couches réservées, ce qui peut être utile pour les plugins d'éditeur.
Pour définir cull_mask plus facilement en utilisant un script, utilisez get_cull_mask_value() et set_cull_mask_value().
Note : VoxelGI, SDFGI et LightmapGI prendront toujours en compte toutes les couches pour déterminer ce qui contribue à l'éclairage global. Si c'est un problème, définissez GeometryInstance3D.gi_mode à GeometryInstance3D.GI_MODE_DISABLED pour les maillages et Light3D.light_bake_mode à Light3D.BAKE_DISABLED pour les lumières pour les exclure de l'illumination globale.
Si true, le Viewport ancêtre utilise actuellement cette caméra.
Si plusieurs caméras sont dans la scène, une sera toujours rendu actuelle. Par exemple, si deux nœuds Camera3D sont présents dans la scène et qu'une seule est actuelle, définir le current d'une caméra à false fera que l'autre caméra soit rendue actuelle.
DopplerTracking doppler_tracking = 0 🔗
void set_doppler_tracking(value: DopplerTracking)
DopplerTracking get_doppler_tracking()
Si non défini à DOPPLER_TRACKING_DISABLED, cette caméra simulera l'effet Doppler pour les objets modifiés dans des méthodes _process particulières.
Note : L'effet Doppler ne sera entendu sur des AudioStreamPlayer3Ds que si leur AudioStreamPlayer3D.doppler_tracking n'est pas défini sur AudioStreamPlayer3D.DOPPLER_TRACKING_DISABLED.
Environment environment 🔗
void set_environment(value: Environment)
Environment get_environment()
L'Environment à utiliser pour cette caméra.
La distance jusqu'au plan de coupe lointain pour cette caméra par rapport à son axe Z local. Des valeurs plus élevées permettent à la caméra de voir plus loin, et diminuer far peut améliorer le performances si cela résulte en des objets partiellement ou complètement coupés.
L'angle du champ de vision de la caméra (en degrés). Seulement disponible en mode perspective. Comme keep_aspect verrouille un axe, fov définit l'angle du champ de vision de l'autre axe.
Pour référence, l'angle de champ de vision par défaut (75.0) est équivalent à un champ de vision horizontal de :
~91.31 degrés pour une fenêtre avec un ratio de 4:3
~101.67 degrés pour une fenêtre avec un ratio de 6:10
~107.51 degrés pour une fenêtre avec un ratio de 16:9
~121.63 degrés pour une fenêtre avec un ratio de 21:9
Vector2 frustum_offset = Vector2(0, 0) 🔗
Le décalage du frustum de la caméra. Cela peut être modifié depuis la valeur par défaut pour créer des effets de « frustrum penché » tel que le Y-shearing.
Note : Seulement effectif si projection vaut PROJECTION_FRUSTUM.
Le décalage horizontal (X) de la fenêtre de la caméra.
KeepAspect keep_aspect = 1 🔗
void set_keep_aspect_mode(value: KeepAspect)
KeepAspect get_keep_aspect_mode()
L'axe à verrouiller pendant les réglages fov ou size. Peut être soit KEEP_WIDTH ou KEEP_HEIGHT.
La distance jusqu'au plan de coupe proche pour cette caméra par rapport à son axe Z local. Des valeurs plus faibles permettent à la caméra de voir des objets plus proche de son origine, au coût d'une précision plus faible sur sa plage entière. Des valeurs plus faibles que le défaut peut mener à une augmentation du Z-fighting.
ProjectionType projection = 0 🔗
void set_projection(value: ProjectionType)
ProjectionType get_projection()
Le mode de projection de la caméra. Dans le mode PROJECTION_PERSPECTIVE, la distance des objets dans l'espace local de la caméra détermine la taille apparante de ces objets.
La taille de la caméra en mètres mesuré comme le diamètre de la largeur ou de la hauteur, selon keep_aspect. Seulement applicable en mode orthogonal et frustum.
Le décalage vertical (Y) de la fenêtre de la caméra.
Descriptions des méthodes
void clear_current(enable_next: bool = true) 🔗
Si c'est la caméra actuelle, la retire d'être l'actuelle. Si enable_next vaut true, demande de rendre la prochaine caméra l'actuelle, s'il y en a une.
Projection get_camera_projection() const 🔗
Renvoie la matrice de projection que cette caméra utilise pour rendre dans son viewport associé. La caméra doit faire partie de l’arborescence de scène pour fonctionner.
Renvoie le RID de la caméra depuis le RenderingServer.
Transform3D get_camera_transform() const 🔗
Renvoie la transformation de la caméra plus les décalages verticaux (v_offset) et horizontaux (h_offset) et tout autre ajustement apporté à la position et à l'orientation de la caméra par des caméras sous-classées telles que XRCamera3D.
bool get_cull_mask_value(layer_number: int) const 🔗
Renvoie si la couche spécifiée du cull_mask est activée, selon un layer_number entre 1 et 20.
Array[Plane] get_frustum() const 🔗
Renvoie les plans du frustum de la caméra en unités de l'espace global en tant que tableau de Planes dans l'ordre suivant : près (near plane), lointain (far plane), gauche, haut, droite, bas. Ne pas être confondu avec frustum_offset.
Renvoie le RID d'une forme pyramidale englobant le frustum de vue de la caméra, ignorant le plan proche (near plane) de la caméra. La pointe de la pyramide représente la position de la caméra.
bool is_position_behind(world_point: Vector3) const 🔗
Renvoie true si la position donnée est derrière la caméra (la partie bleue du diagramme lié). ` Voir ce diagramme <https://raw.githubusercontent.com/godotengine/godot-docs/master/img/camera3d_position_frustum.png>`__ pour un aperçu des méthodes de requête de position.
Note : Une position qui renvoie false peut quand même être hors du champ de vision de la caméra.
bool is_position_in_frustum(world_point: Vector3) const 🔗
Renvoie true si la position donnée est à l'intérieur du frustum de la caméra (la partie verte du diagramme lié). ` Voir ce diagramme <https://raw.githubusercontent.com/godotengine/godot-docs/master/img/camera3d_position_frustum.png>`__ pour un aperçu des méthodes de requête de position.
void make_current() 🔗
Fait que cette caméra devient l'actuelle pour le Viewport (voir la description de la classe). Si le nœud de la caméra est en dehors de l'arborescence de la scène, il tentera de devenir l'actuel dès qu'il sera ajouté.
Vector3 project_local_ray_normal(screen_point: Vector2) const 🔗
Renvoie un vecteur normal à partir de l'emplacement du point d'écran, dirigé le long de la caméra. Les caméras orthogonales sont normalisées. Les caméras avec perspective prennent en compte la perspective, la largeur/hauteur d'écran, etc...
Vector3 project_position(screen_point: Vector2, z_depth: float) const 🔗
Renvoie le point 3D dans l'espace global qui est associé aux coordonnées 2D données dans le rectangle du Viewport et qui est sur un plan qui est à une distance z_depth donnée de la caméra dans la scène.
Vector3 project_ray_normal(screen_point: Vector2) const 🔗
Renvoie un vecteur normal dans le repère global, qui est le résultat de la projection d'un point sur le rectangle Viewport par la projection inverse de la caméra. Ceci est utile pour lancer des rayons sous la forme (origine, normale) pour l'intersection ou la sélection d'objets.
Vector3 project_ray_origin(screen_point: Vector2) const 🔗
Renvoie une position 3D dans le repère global, qui est le résultat de la projection d'un point sur le rectangle Viewport par la projection inverse de la caméra. Ceci est utile pour lancer des rayons sous la forme (origine, normale) pour l'intersection ou la sélection d'objets.
void set_cull_mask_value(layer_number: int, value: bool) 🔗
Selon value, active ou désactive la couche spécifiée dans le masque de cull cull_mask, selon un layer_number entre 1 et 20.
void set_frustum(size: float, offset: Vector2, z_near: float, z_far: float) 🔗
Sets the camera projection to frustum mode (see PROJECTION_FRUSTUM), by specifying a size, an offset, and the z_near and z_far clip planes in world space units. The size parameter represents the size of the near plane, either its width or height depending on the value of keep_aspect. See also frustum_offset.
void set_orthogonal(size: float, z_near: float, z_far: float) 🔗
Définit la projection de la caméra en mode orthogonal (voir PROJECTION_ORTHOGONAL), en spécifiant une taille size, et les plans de coupe proches et lointains z_near et z_far en unités de l'espace global.
Comme conseil, les jeux 3D qui ont un aspect 2D utilisent souvent cette projection, avec size spécifié en pixels.
void set_perspective(fov: float, z_near: float, z_far: float) 🔗
Définit la projection de la caméra en mode perspective (voir PROJECTION_PERSPECTIVE), en spécifiant un angle de champ de vision fov en degrés, et les plans de coupe proches et lointains z_near et z_far en unités de l'espace global.
Vector2 unproject_position(world_point: Vector3) const 🔗
Renvoie les coordonnées 2D dans le rectangle du Viewport qui correspondent à un point 3D donné dans le repère global.
Note : Lorsque vous utilisez cette méthode pour positionner des éléments graphiques sur un Viewport en 3D, pensez à utiliser is_position_behind() pour les empêcher d'apparaître tant que le point 3D se trouve derrière la caméra :
# Cet extrait de code fait partie d'un script qui hérite de Node3D.
# `control` fait référence à un nœud qui hérite de Control.
control.visible = not get_viewport().get_camera_3d().is_position_behind(global_transform.origin)
control.position = get_viewport().get_camera_3d().unproject_position(global_transform.origin)