Struct HexLayout 

pub struct HexLayout {
    pub orientation: HexOrientation,
    pub origin: Vec2,
    pub scale: Vec2,
}

Hexagonal layout. This type is the bridge between your world/pixel coordinate system and the hexagonal coordinate system.

Axis

By default, the Hex y axis is pointing up and the x axis is pointing right but you have the option to invert them using invert_x and invert_y This may be useful depending on the coordinate system of your display.

Example

let layout = HexLayout {
    // We want flat topped hexagons
    orientation: HexOrientation::Flat,
    // We define the world space origin equivalent of `Hex::ZERO` in hex space
    origin: Vec2::new(1.0, 2.0),
    // We define the world space scale of the hexagons
    scale: Vec2::new(1.0, 1.0),
};
// You can now find the world positon (center) of any given hexagon
let world_pos = layout.hex_to_world_pos(Hex::ZERO);
// You can also find which hexagon is at a given world/screen position
let hex_pos = layout.world_pos_to_hex(Vec2::new(1.23, 45.678));

Builder

HexLayout provides a builder pattern:

let mut layout = HexLayout::flat()
    .with_scale(Vec2::new(2.0, 3.0)) // Individual Hexagon size
    .with_origin(Vec2::new(-1.0, 0.0)); // World origin
// Invert the x axis, which will now go left. Will change `scale.x` to `-2.0`
layout.invert_x();
// Invert the y axis, which will now go down. Will change `scale.y` to `-3.0`
layout.invert_y();

Working with Sprites

If you intend to use the hexagonal grid to place images/sprites you may use HexLayout::with_rect_size to make the hexagon scale fit the your sprite dimensions.

You can also retrieve the matching rect size from any layout using HexLayout::rect_size()

Fields

orientation: HexOrientation

The hexagonal orientation of the layout (usually “flat” or “pointy”)

origin: Vec2

The origin of the hexagonal representation in world/pixel space, usually Vec2::ZERO

scale: Vec2

The size of individual hexagons in world/pixel space. The scale can be irregular or negative

Implementations

impl HexLayout

pub fn invert_x(&mut self)

Inverts the layout X axis

pub fn invert_y(&mut self)

Inverts the layout Y axis

pub fn transform_vector(&self, vector: Vec2) -> Vec2

Transforms a local hex space vector to world space by applying the layout scale but NOT the origin

pub fn transform_point(&self, point: Vec2) -> Vec2

Transforms a local hex point to world space by applying the layout scale and origin

pub fn inverse_transform_vector(&self, vector: Vec2) -> Vec2

Transforms a world space vector to local hex space by applying the layout scale but NOT the origin

pub fn inverse_transform_point(&self, point: Vec2) -> Vec2

Transforms a world pace point to local hex space by applying the layout scale and origin

impl HexLayout

pub fn hex_to_world_pos(&self, hex: Hex) -> Vec2

Computes hexagonal coordinates hex into world/pixel coordinates

pub fn fract_hex_to_world_pos(&self, hex: Vec2) -> Vec2

Computes fractional hexagonal coordinates hex into world/pixel coordinates

pub fn world_pos_to_hex(&self, pos: Vec2) -> Hex

Computes world/pixel coordinates pos into hexagonal coordinates

pub fn world_pos_to_fract_hex(&self, pos: Vec2) -> Vec2

Computes world/pixel coordinates pos into fractional hexagonal coordinates

pub fn hex_corners(&self, hex: Hex) -> [Vec2; 6]

Retrieves all 6 corner coordinates of the given hexagonal coordinates hex

pub fn hex_edge_corners(&self, hex: Hex) -> [[Vec2; 2]; 6]

Retrieves all 6 edge corner pair coordinates of the given hexagonal coordinates hex

pub fn center_aligned_hex_corners(&self) -> [Vec2; 6]

Retrieves all 6 edge corner pair coordinates of the given hexagonal coordinates hex without offsetting at the origin

pub fn rect_size(&self) -> Vec2

Returns the size of the bounding box/rect of an hexagon This uses both the hex_size and orientation of the layout.

impl HexLayout

pub fn edge_coordinates(&self, edge: GridEdge) -> [Vec2; 2]

Returns the world coordinate of the two edge vertices in clockwise order

pub fn all_edge_coordinates(&self, coord: Hex) -> [[Vec2; 2]; 6]

Returns the world coordinate of all edge vertex pairs in clockwise order

pub fn vertex_coordinates(&self, vertex: GridVertex) -> Vec2

Returns the world coordinate of the vertex

impl HexLayout

pub const fn new(orientation: HexOrientation) -> Self

Constructs a new layout with the given orientation and default values

pub const fn flat() -> Self

Constructs a new flat layout with default values

pub const fn pointy() -> Self

Constructs a new pointylayout with default values

pub const fn with_origin(self, origin: Vec2) -> Self

Specifies the world/pixel origin of the layout

pub const fn with_hex_size(self, size: f32) -> Self

Specifies the world/pixel regular size of individual hexagons

pub fn with_rect_size(self, rect_size: Vec2) -> Self

Specifies the world/pixel size of individual hexagons to match the given rect_size. This is useful if you want hexagons to match a sprite size

pub const fn with_scale(self, scale: Vec2) -> Self

Specifies the world/pixel scale of individual hexagons.

Note

For most use cases prefer Self::with_hex_size instead.

Trait Implementations

impl Clone for HexLayout

fn clone(&self) -> HexLayout

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Component for HexLayout

where Self: Send + Sync + 'static,

const STORAGE_TYPE: StorageType = bevy_ecs::component::StorageType::Table

A constant indicating the storage type used for this component.

type Mutability = Mutable

A marker type to assist Bevy with determining if this component is mutable, or immutable. Mutable components will have Component<Mutability = Mutable>, while immutable components will instead have Component<Mutability = Immutable>.

fn register_required_components( _requiree: ComponentId, required_components: &mut RequiredComponentsRegistrator<'_, '_>, )

Registers required components.

fn clone_behavior() -> ComponentCloneBehavior

Called when registering this component, allowing to override clone function (or disable cloning altogether) for this component.

fn on_add() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_add ComponentHook for this Component if one is defined.

fn on_insert() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_insert ComponentHook for this Component if one is defined.

fn on_replace() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_replace ComponentHook for this Component if one is defined.

fn on_remove() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_remove ComponentHook for this Component if one is defined.

fn on_despawn() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_despawn ComponentHook for this Component if one is defined.

fn map_entities<E>(_this: &mut Self, _mapper: &mut E)

where E: EntityMapper,

Maps the entities on this component using the given EntityMapper. This is used to remap entities in contexts like scenes and entity cloning. When deriving Component, this is populated by annotating fields containing entities with #[entities]

impl Debug for HexLayout

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for HexLayout

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for HexLayout

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl FromReflect for HexLayout

fn from_reflect(reflect: &dyn PartialReflect) -> Option<Self>

Constructs a concrete instance of Self from a reflected value.

fn take_from_reflect( reflect: Box<dyn PartialReflect>, ) -> Result<Self, Box<dyn PartialReflect>>

Attempts to downcast the given value to Self using, constructing the value using from_reflect if that fails.

impl GetTypeRegistration for HexLayout

fn get_type_registration() -> TypeRegistration

Returns the default TypeRegistration for this type.

fn register_type_dependencies(registry: &mut TypeRegistry)

Registers other types needed by this type.

impl PartialReflect for HexLayout

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

Returns the TypeInfo of the type represented by this value.

fn try_apply(&mut self, value: &dyn PartialReflect) -> Result<(), ApplyError>

Tries to apply a reflected value to this value.

fn reflect_kind(&self) -> ReflectKind

Returns a zero-sized enumeration of “kinds” of type.

fn reflect_ref(&self) -> ReflectRef<'_>

Returns an immutable enumeration of “kinds” of type.

fn reflect_mut(&mut self) -> ReflectMut<'_>

Returns a mutable enumeration of “kinds” of type.

fn reflect_owned(self: Box<Self>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn try_into_reflect( self: Box<Self>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

Attempts to cast this type to a boxed, fully-reflected value.

fn try_as_reflect(&self) -> Option<&dyn Reflect>

Attempts to cast this type to a fully-reflected value.

fn try_as_reflect_mut(&mut self) -> Option<&mut dyn Reflect>

Attempts to cast this type to a mutable, fully-reflected value.

fn into_partial_reflect(self: Box<Self>) -> Box<dyn PartialReflect>

Casts this type to a boxed, reflected value.

fn as_partial_reflect(&self) -> &dyn PartialReflect

Casts this type to a reflected value.

fn as_partial_reflect_mut(&mut self) -> &mut dyn PartialReflect

Casts this type to a mutable, reflected value.

fn reflect_partial_eq(&self, value: &dyn PartialReflect) -> Option<bool>

Returns a “partial equality” comparison result.

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

Attempts to clone Self using reflection.

fn apply(&mut self, value: &(dyn PartialReflect + 'static))

Applies a reflected value to this value.

fn to_dynamic(&self) -> Box<dyn PartialReflect>

Converts this reflected value into its dynamic representation based on its kind.

fn reflect_clone_and_take<T>(&self) -> Result<T, ReflectCloneError>

where T: 'static, Self: Sized + TypePath,

For a type implementing PartialReflect, combines reflect_clone and take in a useful fashion, automatically constructing an appropriate ReflectCloneError if the downcast fails.

fn reflect_hash(&self) -> Option<u64>

Returns a hash of the value (which includes the type).

fn debug(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Debug formatter for the value.

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

impl Reflect for HexLayout

fn into_any(self: Box<Self>) -> Box<dyn Any>

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &dyn Any

Returns the value as a &dyn Any.

fn as_any_mut(&mut self) -> &mut dyn Any

Returns the value as a &mut dyn Any.

fn into_reflect(self: Box<Self>) -> Box<dyn Reflect>

Casts this type to a boxed, fully-reflected value.

fn as_reflect(&self) -> &dyn Reflect

Casts this type to a fully-reflected value.

fn as_reflect_mut(&mut self) -> &mut dyn Reflect

Casts this type to a mutable, fully-reflected value.

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

Performs a type-checked assignment of a reflected value to this value.

impl Serialize for HexLayout

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Struct for HexLayout

fn field(&self, name: &str) -> Option<&dyn PartialReflect>

Returns a reference to the value of the field named name as a &dyn PartialReflect.

fn field_mut(&mut self, name: &str) -> Option<&mut dyn PartialReflect>

Returns a mutable reference to the value of the field named name as a &mut dyn PartialReflect.

fn field_at(&self, index: usize) -> Option<&dyn PartialReflect>

Returns a reference to the value of the field with index index as a &dyn PartialReflect.

fn field_at_mut(&mut self, index: usize) -> Option<&mut dyn PartialReflect>

Returns a mutable reference to the value of the field with index index as a &mut dyn PartialReflect.

fn name_at(&self, index: usize) -> Option<&str>

Returns the name of the field with index index.

fn field_len(&self) -> usize

Returns the number of fields in the struct.

fn iter_fields(&self) -> FieldIter<'_>

Returns an iterator over the values of the reflectable fields for this struct.

fn to_dynamic_struct(&self) -> DynamicStruct

Creates a new DynamicStruct from this struct.

fn get_represented_struct_info(&self) -> Option<&'static StructInfo>

Will return None if TypeInfo is not available.

impl TypePath for HexLayout

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type.

fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type.

fn type_ident() -> Option<&'static str>

Returns the name of the type, or None if it is anonymous.

fn crate_name() -> Option<&'static str>

Returns the name of the crate the type is in, or None if it is anonymous.

fn module_path() -> Option<&'static str>

Returns the path to the module the type is in, or None if it is anonymous.

impl Typed for HexLayout

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.

impl Resource for HexLayout

where Self: Send + Sync + 'static,