GridMap

public bool BakeNavigation { get; set; }

If true, this GridMap creates a navigation region for each cell that uses a GridMap.MeshLibrary item with a navigation mesh. The created navigation region will use the navigation layers bitmask assigned to the MeshLibrary's item.

public bool CellCenterX { get; set; }

If true, grid items are centered on the X axis.

public bool CellCenterY { get; set; }

If true, grid items are centered on the Y axis.

public bool CellCenterZ { get; set; }

If true, grid items are centered on the Z axis.

public int CellOctantSize { get; set; }

The size of each octant measured in number of cells. This applies to all three axis.

public float CellScale { get; set; }

Placed-item basis scale, affecting both meshes and physics shapes. Does not change CellSize or MapToLocal. A value of 0.5 shrinks blocks while retaining the original cell spacing.

public Vector3 CellSize { get; set; }

Grid spacing on three axes. Changes cell spacing/placement, not source MeshLibrary mesh dimensions. Match module dimensions separately; CellScale controls placed mesh and shape scale.

public uint CollisionLayer { get; set; }

The physics layers this GridMap is in. GridMaps act as static bodies, meaning they aren't affected by gravity or other forces. They only affect other physics bodies that collide with them.

public uint CollisionMask { get; set; }

The physics layers this GridMap detects collisions in. See Collision layers and masks in the documentation for more information.

public float CollisionPriority { get; set; }

The priority used to solve colliding when occurring penetration. The higher the priority is, the lower the penetration into the object will be. This can for example be used to prevent the player from breaking through the boundaries of a level.

public GridMap.DebugVisibilityMode CollisionVisibilityMode { get; set; }

Show or hide the GridMap's collision shapes. If set to GridMap.DebugVisibilityMode.Default, this depends on the show collision debug settings.

public Color DebugOctantColor { get; set; }

The Color used for rendering octant debug visuals when GridMap.DebugShowOctants is enabled.

public bool DebugShowOctants { get; set; }

If true, shows debug visuals for octants.

public MeshLibrary MeshLibrary { get; set; }

Shared grid-item resource: IDs, meshes, transforms and separate physics shapes. Meshes do not automatically create collision. Current persistence is verified with contiguous IDs 0 and 1; sparse 0/7 loses item 7 data through a .rdata roundtrip despite Error.Ok.

public PhysicsMaterial PhysicsMaterial { get; set; }

Overrides the default friction and bounce physics properties for the whole GridMap.

public void Clear();

Clear all cells.

public void ClearBakedMeshes();

Clears all baked meshes. See GridMap.MakeBakedMeshes.

public Rid GetBakeMeshInstance(int idx);

Returns Rid of a baked mesh with the given idx.

public Reckfell.Collections.Array GetBakeMeshes();

Returns an array of ArrayMeshes and Transform3D references of all bake meshes that exist within the current GridMap. Even indices contain ArrayMeshes, while odd indices contain Transform3Ds that are always equal to Transform3D.Identity. This method relies on the output of GridMap.MakeBakedMeshes, which will be called with gen_lightmap_uv set to true and lightmap_uv_texel_size set to 0.1 if it hasn't been called yet.

public Basis GetBasisWithOrthogonalIndex(int index);

Returns one of 24 possible rotations that lie along the vectors (x,y,z) with each component being either -1, 0, or 1. For further details, refer to the Reckfell source code.

public int GetCellItem(Vector3I position);

Reads the stored cell ID. An ID does not prove a matching MeshLibrary item, ready physics or visible geometry.

public Basis GetCellItemBasis(Vector3I position);

Returns the basis that gives the specified cell its orientation.

public int GetCellItemOrientation(Vector3I position);

Reads a cell orientation index, not Euler angles. Use GetCellItemBasis or GetBasisWithOrthogonalIndex for its Basis.

public bool GetCollisionLayerValue(int layerNumber);

Returns whether or not the specified layer of the GridMap.CollisionLayer is enabled, given a layer_number between 1 and 32.

public bool GetCollisionMaskValue(int layerNumber);

Returns whether or not the specified layer of the GridMap.CollisionMask is enabled, given a layer_number between 1 and 32.

public Reckfell.Collections.Array GetMeshes();

Returns transform/mesh pairs for existing items. Not a list of entities or colliders; a stored unknown item ID can be absent from this result.

public Rid GetNavigationMap();

Returns the Rid of the navigation map this GridMap node uses for its cell baked navigation meshes. This function returns always the map set on the GridMap node and not the map on the NavigationServer. If the map is changed directly with the NavigationServer API the GridMap node will not be aware of the map change.

public Vector3I GetOctantCoordsFromCellCoords(Vector3I cellCoords);

Returns the Vector3I octant coordinates of the octant that the cell at cell_coords belongs to.

public Reckfell.Collections.Array<Vector3I> GetOctantsInBounds(Aabb bounds);

Returns an array of Vector3I octant coordinates that are inside the given bounds, including octants that have no cells in use.

public int GetOrthogonalIndexFromBasis(Basis basis);

This function considers a discretization of rotations into 24 points on unit sphere, lying along the vectors (x,y,z) with each component being either -1, 0, or 1, and returns the index (in the range from 0 to 23) of the point best representing the orientation of the object. For further details, refer to the Reckfell source code.

public Reckfell.Collections.Array<Vector3I> GetUsedCells();

Returns an array of Vector3 with the non-empty cell coordinates in the grid map.

public Reckfell.Collections.Array<Vector3I> GetUsedCellsByItem(int item);

Returns an array of all cells with the given item index specified in item.

public Reckfell.Collections.Array<Vector3I> GetUsedCellsInOctant(Vector3I octantCoords);

Returns an array of Vector3Is with the cell coordinates of non-empty cells inside the octant at octant_coords.

public Reckfell.Collections.Array<Vector3I> GetUsedCellsInOctantByItem(Vector3I octantCoords, int item);

Returns an array of Vector3Is with the cell coordinates of cells inside the octant at octant_coords that use the specified cell item.

public Reckfell.Collections.Array<Vector3I> GetUsedOctants();

Returns an array of Vector3Is with the octant coordinates of the non-empty octants in the grid map.

public Reckfell.Collections.Array<Vector3I> GetUsedOctantsByItem(int item);

Returns an array of Vector3Is with the octant coordinates of the octants that use the specified item in the grid map.

public Reckfell.Collections.Array<Vector3I> GetUsedOctantsInBounds(Aabb bounds);

Returns an array of Vector3Is with the octant coordinates of non-empty octants that are inside the local bounds.

public Vector3I LocalToMap(Vector3 localPosition);

Divides a local position by CellSize and floors each axis. Convert world positions through ToLocal first; integer-casting division is incorrect for negative coordinates.

public void MakeBakedMeshes(bool genLightmapUV = false, float lightmapUVTexelSize = 0.1f);

Generates a baked mesh that represents all meshes in the assigned MeshLibrary for use with LightmapGI. If gen_lightmap_uv is true, UV2 data will be generated for each mesh currently used in the GridMap. Otherwise, only meshes that already have UV2 data present will be able to use baked lightmaps. When generating UV2, lightmap_uv_texel_size controls the texel density for lightmaps, with lower values resulting in more detailed lightmaps. lightmap_uv_texel_size is ignored if gen_lightmap_uv is false. See also GridMap.GetBakeMeshes, which relies on the output of this method. Note: Calling this method will not actually bake lightmaps, as lightmap baking is performed using the LightmapGI node.

public Vector3 MapToLocal(Vector3I mapPosition);

Converts a cell coordinate to local position using CellSize and per-axis CellCenterX/Y/Z. Not necessarily the mesh center: MeshLibrary has separate item transforms.

public void ResourceChanged(Resource resource);

This method does nothing.

public void SetCellItem(Vector3I position, int item, int orientation = 0);

Sets the single item in a cell, replacing the previous item. Logical state changes immediately; render and physics octants update later. Validate IDs against GetItemList: an unknown ID can be stored without visible geometry. The verified item field is 16-bit: 65536 becomes 0.

public void SetCollisionLayerValue(int layerNumber, bool value);

Based on value, enables or disables the specified layer in the GridMap.CollisionLayer, given a layer_number between 1 and 32.

public void SetCollisionMaskValue(int layerNumber, bool value);

Based on value, enables or disables the specified layer in the GridMap.CollisionMask, given a layer_number between 1 and 32.

public void SetNavigationMap(Rid navigationMap);

Sets the Rid of the navigation map this GridMap node should use for its cell baked navigation meshes.

public event GridMap.CellSizeChangedEventHandler CellSizeChanged;

Emitted when GridMap.CellSize changes.

public event Action Changed;

Emitted when the MeshLibrary of this GridMap changes.

public const long InvalidCellItem = -1;

Invalid cell item that can be used in GridMap.SetCellItem to clear cells (or represent an empty cell in GridMap.GetCellItem).