godotengine/godot-docs-l10n
1
0
Fork 0
mirror of https://github.com/godotengine/godot-docs-l10n.git synced 2026-01-05 14:10:19 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
4.x
godot-docs-l10n/classes/fr/class_gridmap.rst
Rémi Verschelde 369fd84a4f Sync classref with 4.5 branch
2025-12-19 14:34:07 +01:00

694 lines
38 KiB
ReStructuredText
Raw Permalink Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

:github_url: hide
.. meta::
:keywords: tilemap
.. _class_GridMap:
GridMap
=======
**Hérite de :** :ref:`Node3D<class_Node3D>` **<** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
Nœud pour les cartes à base de tuiles 3D.
.. rst-class:: classref-introduction-group
Description
-----------
GridMap vous permet de placer de manière interactive des maillages sur une grille. Elle fonctionne à la fois à partir de l'éditeur et des scripts, ce qui peut vous aider à créer des éditeurs de niveau en jeu.
Les GridMaps utilisent une :ref:`MeshLibrary<class_MeshLibrary>` qui contient une liste de tuiles. Chaque tuile est un maillage avec des matériaux, en plus de formes de collision et de navigation en option.
Une GridMap contient une collection de cellules. Chaque cellule de la grille se réfère à une tuile dans la :ref:`MeshLibrary<class_MeshLibrary>`. Toutes les cellules de la grille ont les mêmes dimensions.
En interne, une GridMap est divisée en une collection d'octants séparés pour traitement du rendu et de la physique efficace. Chaque octant a les mêmes dimensions et peut contenir plusieurs cellules.
\ **Note :** GridMap n'étend pas :ref:`VisualInstance3D<class_VisualInstance3D>` et donc de ne pas être cull ou masqué selon :ref:`VisualInstance3D.layers<class_VisualInstance3D_property_layers>`. Si vous ajoutez une lumière qui n'affecte pas la première couche, la GridMap entière ne sera éclairée la lumière en question.
.. rst-class:: classref-introduction-group
Tutoriels
------------------
- :doc:`Utiliser les gridmaps <../tutorials/3d/using_gridmaps>`
- `Démo de jeu de plateforme en 3D <https://godotengine.org/asset-library/asset/2748>`__
- `Démo de personnage cinématique en 3D <https://godotengine.org/asset-library/asset/2739>`__
.. rst-class:: classref-reftable-group
Propriétés
--------------------
.. table::
:widths: auto
+-----------------------------------------------+----------------------------------------------------------------------+----------------------+
| :ref:`bool<class_bool>` | :ref:`bake_navigation<class_GridMap_property_bake_navigation>` | ``false`` |
+-----------------------------------------------+----------------------------------------------------------------------+----------------------+
| :ref:`bool<class_bool>` | :ref:`cell_center_x<class_GridMap_property_cell_center_x>` | ``true`` |
+-----------------------------------------------+----------------------------------------------------------------------+----------------------+
| :ref:`bool<class_bool>` | :ref:`cell_center_y<class_GridMap_property_cell_center_y>` | ``true`` |
+-----------------------------------------------+----------------------------------------------------------------------+----------------------+
| :ref:`bool<class_bool>` | :ref:`cell_center_z<class_GridMap_property_cell_center_z>` | ``true`` |
+-----------------------------------------------+----------------------------------------------------------------------+----------------------+
| :ref:`int<class_int>` | :ref:`cell_octant_size<class_GridMap_property_cell_octant_size>` | ``8`` |
+-----------------------------------------------+----------------------------------------------------------------------+----------------------+
| :ref:`float<class_float>` | :ref:`cell_scale<class_GridMap_property_cell_scale>` | ``1.0`` |
+-----------------------------------------------+----------------------------------------------------------------------+----------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`cell_size<class_GridMap_property_cell_size>` | ``Vector3(2, 2, 2)`` |
+-----------------------------------------------+----------------------------------------------------------------------+----------------------+
| :ref:`int<class_int>` | :ref:`collision_layer<class_GridMap_property_collision_layer>` | ``1`` |
+-----------------------------------------------+----------------------------------------------------------------------+----------------------+
| :ref:`int<class_int>` | :ref:`collision_mask<class_GridMap_property_collision_mask>` | ``1`` |
+-----------------------------------------------+----------------------------------------------------------------------+----------------------+
| :ref:`float<class_float>` | :ref:`collision_priority<class_GridMap_property_collision_priority>` | ``1.0`` |
+-----------------------------------------------+----------------------------------------------------------------------+----------------------+
| :ref:`MeshLibrary<class_MeshLibrary>` | :ref:`mesh_library<class_GridMap_property_mesh_library>` | |
+-----------------------------------------------+----------------------------------------------------------------------+----------------------+
| :ref:`PhysicsMaterial<class_PhysicsMaterial>` | :ref:`physics_material<class_GridMap_property_physics_material>` | |
+-----------------------------------------------+----------------------------------------------------------------------+----------------------+
.. rst-class:: classref-reftable-group
Méthodes
----------------
.. table::
:widths: auto
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`clear<class_GridMap_method_clear>`\ (\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`clear_baked_meshes<class_GridMap_method_clear_baked_meshes>`\ (\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`get_bake_mesh_instance<class_GridMap_method_get_bake_mesh_instance>`\ (\ idx\: :ref:`int<class_int>`\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Array<class_Array>` | :ref:`get_bake_meshes<class_GridMap_method_get_bake_meshes>`\ (\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Basis<class_Basis>` | :ref:`get_basis_with_orthogonal_index<class_GridMap_method_get_basis_with_orthogonal_index>`\ (\ index\: :ref:`int<class_int>`\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_cell_item<class_GridMap_method_get_cell_item>`\ (\ position\: :ref:`Vector3i<class_Vector3i>`\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Basis<class_Basis>` | :ref:`get_cell_item_basis<class_GridMap_method_get_cell_item_basis>`\ (\ position\: :ref:`Vector3i<class_Vector3i>`\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_cell_item_orientation<class_GridMap_method_get_cell_item_orientation>`\ (\ position\: :ref:`Vector3i<class_Vector3i>`\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`get_collision_layer_value<class_GridMap_method_get_collision_layer_value>`\ (\ layer_number\: :ref:`int<class_int>`\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`get_collision_mask_value<class_GridMap_method_get_collision_mask_value>`\ (\ layer_number\: :ref:`int<class_int>`\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Array<class_Array>` | :ref:`get_meshes<class_GridMap_method_get_meshes>`\ (\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`get_navigation_map<class_GridMap_method_get_navigation_map>`\ (\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_orthogonal_index_from_basis<class_GridMap_method_get_orthogonal_index_from_basis>`\ (\ basis\: :ref:`Basis<class_Basis>`\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Array<class_Array>`\[:ref:`Vector3i<class_Vector3i>`\] | :ref:`get_used_cells<class_GridMap_method_get_used_cells>`\ (\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Array<class_Array>`\[:ref:`Vector3i<class_Vector3i>`\] | :ref:`get_used_cells_by_item<class_GridMap_method_get_used_cells_by_item>`\ (\ item\: :ref:`int<class_int>`\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3i<class_Vector3i>` | :ref:`local_to_map<class_GridMap_method_local_to_map>`\ (\ local_position\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`make_baked_meshes<class_GridMap_method_make_baked_meshes>`\ (\ gen_lightmap_uv\: :ref:`bool<class_bool>` = false, lightmap_uv_texel_size\: :ref:`float<class_float>` = 0.1\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`map_to_local<class_GridMap_method_map_to_local>`\ (\ map_position\: :ref:`Vector3i<class_Vector3i>`\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`resource_changed<class_GridMap_method_resource_changed>`\ (\ resource\: :ref:`Resource<class_Resource>`\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_cell_item<class_GridMap_method_set_cell_item>`\ (\ position\: :ref:`Vector3i<class_Vector3i>`, item\: :ref:`int<class_int>`, orientation\: :ref:`int<class_int>` = 0\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_collision_layer_value<class_GridMap_method_set_collision_layer_value>`\ (\ layer_number\: :ref:`int<class_int>`, value\: :ref:`bool<class_bool>`\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_collision_mask_value<class_GridMap_method_set_collision_mask_value>`\ (\ layer_number\: :ref:`int<class_int>`, value\: :ref:`bool<class_bool>`\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_navigation_map<class_GridMap_method_set_navigation_map>`\ (\ navigation_map\: :ref:`RID<class_RID>`\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Signaux
--------------
.. _class_GridMap_signal_cell_size_changed:
.. rst-class:: classref-signal
**cell_size_changed**\ (\ cell_size\: :ref:`Vector3<class_Vector3>`\ ) :ref:`🔗<class_GridMap_signal_cell_size_changed>`
Émis lorsque :ref:`cell_size<class_GridMap_property_cell_size>` change.
.. rst-class:: classref-item-separator
----
.. _class_GridMap_signal_changed:
.. rst-class:: classref-signal
**changed**\ (\ ) :ref:`🔗<class_GridMap_signal_changed>`
Émis lorsque la :ref:`MeshLibrary<class_MeshLibrary>` de cette GridMap change.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Constantes
--------------------
.. _class_GridMap_constant_INVALID_CELL_ITEM:
.. rst-class:: classref-constant
**INVALID_CELL_ITEM** = ``-1`` :ref:`🔗<class_GridMap_constant_INVALID_CELL_ITEM>`
Élément de cellule invalide qui peut être utilisé dans :ref:`set_cell_item()<class_GridMap_method_set_cell_item>` pour effacer des cellules (ou représenter une cellule vide dans :ref:`get_cell_item()<class_GridMap_method_get_cell_item>`).
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descriptions des propriétés
------------------------------------------------------
.. _class_GridMap_property_bake_navigation:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **bake_navigation** = ``false`` :ref:`🔗<class_GridMap_property_bake_navigation>`
.. rst-class:: classref-property-setget
- |void| **set_bake_navigation**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_baking_navigation**\ (\ )
If ``true``, this GridMap creates a navigation region for each cell that uses a :ref:`mesh_library<class_GridMap_property_mesh_library>` item with a navigation mesh. The created navigation region will use the navigation layers bitmask assigned to the :ref:`MeshLibrary<class_MeshLibrary>`'s item.
.. rst-class:: classref-item-separator
----
.. _class_GridMap_property_cell_center_x:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **cell_center_x** = ``true`` :ref:`🔗<class_GridMap_property_cell_center_x>`
.. rst-class:: classref-property-setget
- |void| **set_center_x**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **get_center_x**\ (\ )
Si ``true``, les éléments de la grille sont centrés sur l'axe X.
.. rst-class:: classref-item-separator
----
.. _class_GridMap_property_cell_center_y:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **cell_center_y** = ``true`` :ref:`🔗<class_GridMap_property_cell_center_y>`
.. rst-class:: classref-property-setget
- |void| **set_center_y**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **get_center_y**\ (\ )
Si ``true``, les éléments de la grille sont centrés sur l'axe Y.
.. rst-class:: classref-item-separator
----
.. _class_GridMap_property_cell_center_z:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **cell_center_z** = ``true`` :ref:`🔗<class_GridMap_property_cell_center_z>`
.. rst-class:: classref-property-setget
- |void| **set_center_z**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **get_center_z**\ (\ )
Si ``true``, les éléments de la grille sont centrés sur l'axe Z.
.. rst-class:: classref-item-separator
----
.. _class_GridMap_property_cell_octant_size:
.. rst-class:: classref-property
:ref:`int<class_int>` **cell_octant_size** = ``8`` :ref:`🔗<class_GridMap_property_cell_octant_size>`
.. rst-class:: classref-property-setget
- |void| **set_octant_size**\ (\ value\: :ref:`int<class_int>`\ )
- :ref:`int<class_int>` **get_octant_size**\ (\ )
La taille de chaque octant mesurée en nombre de cellules. Ceci s'applique aux trois axes.
.. rst-class:: classref-item-separator
----
.. _class_GridMap_property_cell_scale:
.. rst-class:: classref-property
:ref:`float<class_float>` **cell_scale** = ``1.0`` :ref:`🔗<class_GridMap_property_cell_scale>`
.. rst-class:: classref-property-setget
- |void| **set_cell_scale**\ (\ value\: :ref:`float<class_float>`\ )
- :ref:`float<class_float>` **get_cell_scale**\ (\ )
L'échelle des éléments des cellules.
Cela n'affecte pas la taille des cellules du réseau elles-mêmes, seulement les éléments dans celles-ci. Cela peut être utilisé pour faire que des éléments de cellule chevauchent leurs voisins.
.. rst-class:: classref-item-separator
----
.. _class_GridMap_property_cell_size:
.. rst-class:: classref-property
:ref:`Vector3<class_Vector3>` **cell_size** = ``Vector3(2, 2, 2)`` :ref:`🔗<class_GridMap_property_cell_size>`
.. rst-class:: classref-property-setget
- |void| **set_cell_size**\ (\ value\: :ref:`Vector3<class_Vector3>`\ )
- :ref:`Vector3<class_Vector3>` **get_cell_size**\ (\ )
Les dimensions des cellules de la grille.
Cela n'affecte pas la taille des maillages. Voir :ref:`cell_scale<class_GridMap_property_cell_scale>`.
.. rst-class:: classref-item-separator
----
.. _class_GridMap_property_collision_layer:
.. rst-class:: classref-property
:ref:`int<class_int>` **collision_layer** = ``1`` :ref:`🔗<class_GridMap_property_collision_layer>`
.. rst-class:: classref-property-setget
- |void| **set_collision_layer**\ (\ value\: :ref:`int<class_int>`\ )
- :ref:`int<class_int>` **get_collision_layer**\ (\ )
La couche physique dans laquelle est cette GridMap.
Les GridMaps agissent comme des corps statiques, ce qui signifie qu'ils ne sont pas affectés par la gravité ou les autres forces. Ils n'affectent que les autres corps physique qui entrent en collision avec eux.
.. rst-class:: classref-item-separator
----
.. _class_GridMap_property_collision_mask:
.. rst-class:: classref-property
:ref:`int<class_int>` **collision_mask** = ``1`` :ref:`🔗<class_GridMap_property_collision_mask>`
.. rst-class:: classref-property-setget
- |void| **set_collision_mask**\ (\ value\: :ref:`int<class_int>`\ )
- :ref:`int<class_int>` **get_collision_mask**\ (\ )
Les couches physiques sur lesquelles ce GridMap détecte les collisions. Voir `Couches et masques de collisions <../tutorials/physics/physics_introduction.html#collision-layers-and-masks>`__ dans la documentation pour plus d'informations.
.. rst-class:: classref-item-separator
----
.. _class_GridMap_property_collision_priority:
.. rst-class:: classref-property
:ref:`float<class_float>` **collision_priority** = ``1.0`` :ref:`🔗<class_GridMap_property_collision_priority>`
.. rst-class:: classref-property-setget
- |void| **set_collision_priority**\ (\ value\: :ref:`float<class_float>`\ )
- :ref:`float<class_float>` **get_collision_priority**\ (\ )
La priorité utilisée pour résoudre la collision lors de la pénétration. Plus la priorité est élevée, plus la pénétration dans l'objet sera faible. Cela peut par exemple être utilisé pour empêcher le joueur de franchir les limites d'un niveau.
.. rst-class:: classref-item-separator
----
.. _class_GridMap_property_mesh_library:
.. rst-class:: classref-property
:ref:`MeshLibrary<class_MeshLibrary>` **mesh_library** :ref:`🔗<class_GridMap_property_mesh_library>`
.. rst-class:: classref-property-setget
- |void| **set_mesh_library**\ (\ value\: :ref:`MeshLibrary<class_MeshLibrary>`\ )
- :ref:`MeshLibrary<class_MeshLibrary>` **get_mesh_library**\ (\ )
La :ref:`MeshLibrary<class_MeshLibrary>` assignée.
.. rst-class:: classref-item-separator
----
.. _class_GridMap_property_physics_material:
.. rst-class:: classref-property
:ref:`PhysicsMaterial<class_PhysicsMaterial>` **physics_material** :ref:`🔗<class_GridMap_property_physics_material>`
.. rst-class:: classref-property-setget
- |void| **set_physics_material**\ (\ value\: :ref:`PhysicsMaterial<class_PhysicsMaterial>`\ )
- :ref:`PhysicsMaterial<class_PhysicsMaterial>` **get_physics_material**\ (\ )
Redéfinit les propriétés physiques par défaut de la friction et du rebondissement pour la **GridMap** entière.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descriptions des méthodes
--------------------------------------------------
.. _class_GridMap_method_clear:
.. rst-class:: classref-method
|void| **clear**\ (\ ) :ref:`🔗<class_GridMap_method_clear>`
Effacer toutes les cellules.
.. rst-class:: classref-item-separator
----
.. _class_GridMap_method_clear_baked_meshes:
.. rst-class:: classref-method
|void| **clear_baked_meshes**\ (\ ) :ref:`🔗<class_GridMap_method_clear_baked_meshes>`
Retire tous les maillages pré-calculés. Voir :ref:`make_baked_meshes()<class_GridMap_method_make_baked_meshes>`.
.. rst-class:: classref-item-separator
----
.. _class_GridMap_method_get_bake_mesh_instance:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **get_bake_mesh_instance**\ (\ idx\: :ref:`int<class_int>`\ ) :ref:`🔗<class_GridMap_method_get_bake_mesh_instance>`
Renvoie le :ref:`RID<class_RID>` d'un maillage pré-calculé avec l'index ``idx`` donné.
.. rst-class:: classref-item-separator
----
.. _class_GridMap_method_get_bake_meshes:
.. rst-class:: classref-method
:ref:`Array<class_Array>` **get_bake_meshes**\ (\ ) :ref:`🔗<class_GridMap_method_get_bake_meshes>`
Renvoie un tableau de références d':ref:`ArrayMesh<class_ArrayMesh>`\ s et de :ref:`Transform3D<class_Transform3D>`\ s de tous les maillages pré-calculés qui existent dans la GridMap actuelle. Les indices pairs contiennent des :ref:`ArrayMesh<class_ArrayMesh>`\ s, tandis que les indices impairs contiennent des :ref:`Transform3D<class_Transform3D>` qui sont toujours égaux à :ref:`Transform3D.IDENTITY<class_Transform3D_constant_IDENTITY>`.
Cette méthode repose sur la sortie de :ref:`make_baked_meshes()<class_GridMap_method_make_baked_meshes>`, qui sera appelée avec ``gen_lightmap_uv`` défini à ``true`` et ``lightmap_uv_texel_size`` défini à ``0.1`` si elle n'a pas encore été appelée.
.. rst-class:: classref-item-separator
----
.. _class_GridMap_method_get_basis_with_orthogonal_index:
.. rst-class:: classref-method
:ref:`Basis<class_Basis>` **get_basis_with_orthogonal_index**\ (\ index\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_GridMap_method_get_basis_with_orthogonal_index>`
Renvoie une des 24 rotations possibles qui se situent le long des vecteurs (x,y,z) avec chaque composante valant -1, 0, ou 1. Pour plus de détails, consultez le code source de Godot.
.. rst-class:: classref-item-separator
----
.. _class_GridMap_method_get_cell_item:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_cell_item**\ (\ position\: :ref:`Vector3i<class_Vector3i>`\ ) |const| :ref:`🔗<class_GridMap_method_get_cell_item>`
L'indice de l'élément de la :ref:`MeshLibrary<class_MeshLibrary>` situé aux coordonnées de grille données. Si la cellule est vide, :ref:`INVALID_CELL_ITEM<class_GridMap_constant_INVALID_CELL_ITEM>` sera renvoyé.
.. rst-class:: classref-item-separator
----
.. _class_GridMap_method_get_cell_item_basis:
.. rst-class:: classref-method
:ref:`Basis<class_Basis>` **get_cell_item_basis**\ (\ position\: :ref:`Vector3i<class_Vector3i>`\ ) |const| :ref:`🔗<class_GridMap_method_get_cell_item_basis>`
Renvoie la base qui donne à la cellule spécifiée son orientation.
.. rst-class:: classref-item-separator
----
.. _class_GridMap_method_get_cell_item_orientation:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_cell_item_orientation**\ (\ position\: :ref:`Vector3i<class_Vector3i>`\ ) |const| :ref:`🔗<class_GridMap_method_get_cell_item_orientation>`
L'orientation de la cellule aux coordonnées de grille données. ``-1`` est renvoyé si la cellule est vide.
.. rst-class:: classref-item-separator
----
.. _class_GridMap_method_get_collision_layer_value:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **get_collision_layer_value**\ (\ layer_number\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_GridMap_method_get_collision_layer_value>`
Renvoie si la couche spécifiée du :ref:`collision_layer<class_GridMap_property_collision_layer>` est activée, étant donné un numéro de couche ``layer_number`` entre 1 et 32.
.. rst-class:: classref-item-separator
----
.. _class_GridMap_method_get_collision_mask_value:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **get_collision_mask_value**\ (\ layer_number\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_GridMap_method_get_collision_mask_value>`
Renvoie si la couche spécifiée du :ref:`collision_mask<class_GridMap_property_collision_mask>` est activée, étant donné un numéro de couche ``layer_number`` entre 1 et 32.
.. rst-class:: classref-item-separator
----
.. _class_GridMap_method_get_meshes:
.. rst-class:: classref-method
:ref:`Array<class_Array>` **get_meshes**\ (\ ) |const| :ref:`🔗<class_GridMap_method_get_meshes>`
Renvoie un tableau de références :ref:`Transform3D<class_Transform3D>` et :ref:`Mesh<class_Mesh>` correspondant aux cellules non vides de la grille. Les transformations sont spécifiées dans l'espace local. Les indices pairs contiennent des :ref:`Transform3D<class_Transform3D>`\ s, et les indices impairs contiennent les :ref:`Mesh<class_Mesh>`\ s liés au :ref:`Transform3D<class_Transform3D>` de l'index précédent.
.. rst-class:: classref-item-separator
----
.. _class_GridMap_method_get_navigation_map:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **get_navigation_map**\ (\ ) |const| :ref:`🔗<class_GridMap_method_get_navigation_map>`
Renvoie le :ref:`RID<class_RID>` de la carte de navigation que ce nœud GridMap utilise pour ses maillages de navigation à base de cellules pré-calculés.
Cette fonction renvoie toujours la carte définie sur le nœud GridMap et non la carte sur le NavigationServer. Si la carte est changée directement avec l'API NavigationServer, le nœud GridMap ne sera pas au courant du changement de carte.
.. rst-class:: classref-item-separator
----
.. _class_GridMap_method_get_orthogonal_index_from_basis:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_orthogonal_index_from_basis**\ (\ basis\: :ref:`Basis<class_Basis>`\ ) |const| :ref:`🔗<class_GridMap_method_get_orthogonal_index_from_basis>`
Cette fonction considère une discrétisation des rotations en 24 points sur la sphère unité, le long des vecteurs (x,y,z), chaque composante valant soit -1, 0, ou 1, et renvoie l'index (dans un intervalle de 0 à 23) du point représentant le mieux l'orientation de l'objet. Pour plus de détails, consultez le code source de Godot.
.. rst-class:: classref-item-separator
----
.. _class_GridMap_method_get_used_cells:
.. rst-class:: classref-method
:ref:`Array<class_Array>`\[:ref:`Vector3i<class_Vector3i>`\] **get_used_cells**\ (\ ) |const| :ref:`🔗<class_GridMap_method_get_used_cells>`
Renvoie un tableau de :ref:`Vector3<class_Vector3>` avec les coordonnées des cellules non vides dans la grille.
.. rst-class:: classref-item-separator
----
.. _class_GridMap_method_get_used_cells_by_item:
.. rst-class:: classref-method
:ref:`Array<class_Array>`\[:ref:`Vector3i<class_Vector3i>`\] **get_used_cells_by_item**\ (\ item\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_GridMap_method_get_used_cells_by_item>`
Renvoie un tableau de toutes les cellules avec l'indice d'élément donné spécifié dans ``item``.
.. rst-class:: classref-item-separator
----
.. _class_GridMap_method_local_to_map:
.. rst-class:: classref-method
:ref:`Vector3i<class_Vector3i>` **local_to_map**\ (\ local_position\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_GridMap_method_local_to_map>`
Renvoie les coordonnées de la cellule contenant la position locale ``local_position`` donnée. Si ``local_position`` est dans les coordonnées globales, envisagez d'utiliser :ref:`Node3D.to_local()<class_Node3D_method_to_local>` avant de la transmettre à cette méthode. Voir aussi :ref:`map_to_local()<class_GridMap_method_map_to_local>`.
.. rst-class:: classref-item-separator
----
.. _class_GridMap_method_make_baked_meshes:
.. rst-class:: classref-method
|void| **make_baked_meshes**\ (\ gen_lightmap_uv\: :ref:`bool<class_bool>` = false, lightmap_uv_texel_size\: :ref:`float<class_float>` = 0.1\ ) :ref:`🔗<class_GridMap_method_make_baked_meshes>`
Génère une maillage pré-calculé qui représente tous les maillages dans la :ref:`MeshLibrary<class_MeshLibrary>` attribuée à utiliser avec :ref:`LightmapGI<class_LightmapGI>`. Si ``gen_lightmap_uv`` vaut ``true``, les données UV2 seront générées pour chaque maillage actuellement utilisé dans la **GridMap**. Sinon, seuls les maillages qui ont déjà des données UV2 présentes seront en mesure d'utiliser des lightmaps pré-calculées. Lors de la génération des UV2, ``lightmap_uv_texel_size`` contrôle la densité de texel pour les lightmaps, avec les valeurs inférieures résultant en des lightmaps plus détaillées. ``lightmap_uv_texel_size`` est ignoré si ``gen_lightmap_uv`` vaut ``false``. Voir aussi :ref:`get_bake_meshes()<class_GridMap_method_get_bake_meshes>`, qui dépend de la sortie de cette méthode.
\ **Note :** Appeler cette méthode ne pré-calcule pas les lightmaps, car le pré-calcul des lightmaps est effectué en utilisant le nœud :ref:`LightmapGI<class_LightmapGI>`.
.. rst-class:: classref-item-separator
----
.. _class_GridMap_method_map_to_local:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **map_to_local**\ (\ map_position\: :ref:`Vector3i<class_Vector3i>`\ ) |const| :ref:`🔗<class_GridMap_method_map_to_local>`
Renvoie la position d'une cellule de la grille dans l'espace de coordonnées local de la GridMap. Pour convertir la valeur renvoyée en coordonnées globales, utilisez :ref:`Node3D.to_global()<class_Node3D_method_to_global>`. Voir aussi :ref:`local_to_map()<class_GridMap_method_local_to_map>`.
.. rst-class:: classref-item-separator
----
.. _class_GridMap_method_resource_changed:
.. rst-class:: classref-method
|void| **resource_changed**\ (\ resource\: :ref:`Resource<class_Resource>`\ ) :ref:`🔗<class_GridMap_method_resource_changed>`
**Obsolète :** Use :ref:`Resource.changed<class_Resource_signal_changed>` instead.
Cette méthode ne fait rien.
.. rst-class:: classref-item-separator
----
.. _class_GridMap_method_set_cell_item:
.. rst-class:: classref-method
|void| **set_cell_item**\ (\ position\: :ref:`Vector3i<class_Vector3i>`, item\: :ref:`int<class_int>`, orientation\: :ref:`int<class_int>` = 0\ ) :ref:`🔗<class_GridMap_method_set_cell_item>`
Définit l'indice de maillage pour la cellule référencée par ses coordonnées de grille.
Un index négatif comme :ref:`INVALID_CELL_ITEM<class_GridMap_constant_INVALID_CELL_ITEM>` effacera la cellule.
En option, l'orientation de l'objet peut être spécifiée. Pour les valeurs d'orientation valides, voir :ref:`get_orthogonal_index_from_basis()<class_GridMap_method_get_orthogonal_index_from_basis>`.
.. rst-class:: classref-item-separator
----
.. _class_GridMap_method_set_collision_layer_value:
.. rst-class:: classref-method
|void| **set_collision_layer_value**\ (\ layer_number\: :ref:`int<class_int>`, value\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_GridMap_method_set_collision_layer_value>`
Selon ``value``, active ou désactive la couche spécifiée dans le :ref:`collision_layer<class_GridMap_property_collision_layer>`, étant donné un numéro de couche ``layer_number`` entre 1 et 32.
.. rst-class:: classref-item-separator
----
.. _class_GridMap_method_set_collision_mask_value:
.. rst-class:: classref-method
|void| **set_collision_mask_value**\ (\ layer_number\: :ref:`int<class_int>`, value\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_GridMap_method_set_collision_mask_value>`
Selon ``value``, active ou désactive la couche spécifiée dans le :ref:`collision_mask<class_GridMap_property_collision_mask>`, étant donné un numéro de couche ``layer_number`` entre 1 et 32.
.. rst-class:: classref-item-separator
----
.. _class_GridMap_method_set_navigation_map:
.. rst-class:: classref-method
|void| **set_navigation_map**\ (\ navigation_map\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_GridMap_method_set_navigation_map>`
Sets the :ref:`RID<class_RID>` of the navigation map this GridMap node should use for its cell baked navigation meshes.
.. |virtual| replace:: :abbr:`virtual (Cette méthode doit typiquement être redéfinie par l'utilisateur pour avoir un effet.)`
.. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)`
.. |const| replace:: :abbr:`const (Cette méthode n'a pas d'effets de bord. Elle ne modifie aucune des variables membres de l'instance.)`
.. |vararg| replace:: :abbr:`vararg (Cette méthode accepte n'importe quel nombre d'arguments après ceux décris ici.)`
.. |constructor| replace:: :abbr:`constructor (Cette méthode est utilisée pour construire un type.)`
.. |static| replace:: :abbr:`static (Cette méthode n'a pas besoin d'instance pour être appelée, elle peut donc être directement appelée en utilisant le nom de la classe.)`
.. |operator| replace:: :abbr:`operator (Cette méthode décrit un opérateur valide à utiliser avec ce type en tant qu'opérande gauche.)`
.. |bitfield| replace:: :abbr:`BitField (Cette valeur est un nombre entier composé d'un masque de bits des options suivantes.)`
.. |void| replace:: :abbr:`void (Aucune valeur de retour.)`
Reference in New Issue View Git Blame Copy Permalink