Struct Map

pub struct Map {
    pub pos: Vec2,
    pub tiles: Vec<TileData>,
    pub lower_buffer: Vec<MapVertex>,
    pub upper_buffer: Vec<MapVertex>,
    pub stores: [Index; 2],
    pub orders: [DrawOrder; 2],
    pub filled_tiles: [u16; 9],
    pub tilesize: u32,
    pub can_render: bool,
    pub camera_type: CameraType,
    pub changed: bool,
}

Handler for rendering Map to GPU.

Fields

pos: Vec2

X, Y, GroupID for loaded map. Add this to the higher up Map struct. pub world_pos: Vec3, its render position. within the screen.

tiles: Vec<TileData>

lower_buffer: Vec<MapVertex>

upper_buffer: Vec<MapVertex>

stores: [Index; 2]

Store index per each layer.

orders: [DrawOrder; 2]

the draw order of the maps. created when update is called.

filled_tiles: [u16; 9]

count if any Filled Tiles Exist. this is to optimize out empty maps in rendering.

tilesize: u32

The size of the Tile to render. for spacing tiles out upon vertex creation. Default will be 20.

can_render: bool

Used to deturmine if the map can be rendered or if its just a preload.

camera_type: CameraType

changed: bool

If the position or a tile gets changed.

Implementations

impl Map

pub fn create_quad(&mut self, renderer: &mut GpuRenderer, atlas: &mut AtlasSet)

Updates the Map’s Buffers to prepare them for rendering.

pub fn new(renderer: &mut GpuRenderer, tilesize: u32) -> Self

Creates a new Map with tilesize.

pub fn unload(&self, renderer: &mut GpuRenderer)

Unloades the Map’s buffer from the buffer store.

pub fn get_tile(&self, pos: (u32, u32, u32)) -> TileData

gets the TileData based upon the tiles x, y, and MapLayers. MapLayers::Ground is Layer 0.

pub fn set_camera_type(&mut self, camera_type: CameraType)

Sets the CameraType this object will use to Render with.

pub fn set_tile(&mut self, pos: (u32, u32, u32), tile: TileData)

This sets the tile’s Id within the texture, layer within the texture array and Alpha for its transparency. This allows us to loop through the tiles Shader side efficiently.

pub fn update( &mut self, renderer: &mut GpuRenderer, atlas: &mut AtlasSet, ) -> Option<Vec<OrderedIndex>>

Used to check and update the Map’s Buffer for Rendering. Returns an Optional vec![Lower, Upper] OrderedIndex to use in Rendering.