docs/grid__viewport__manager_8gd_source.html

extends RefCounted


func world_draw_rect(panel_size:Vector2, options:Dictionary = {}) -> Rect2:

    var min_side := float(options.get("min_side", 1.0))

    var side = max(min_side, min(panel_size.x, panel_size.y))

    var position = Vector2(

        (panel_size.x - side) * 0.5,

        (panel_size.y - side) * 0.5

    )

    return Rect2(position, Vector2(side, side))


func camera_rect(player_position:Vector2, tile_size:float, camera_config:Dictionary = {}) -> Rect2:

    var visible_radius = camera_visible_radius(camera_config)

    var render_tiles = float(visible_radius) * 2.0 + 2.0

    var player_center_tiles = player_position / max(1.0, tile_size)

    var start = Vector2(

        player_center_tiles.x - (render_tiles * 0.5),

        player_center_tiles.y - (render_tiles * 0.5)

    )

    return Rect2(start * tile_size, Vector2(render_tiles, render_tiles) * tile_size)


func camera_visible_radius(camera_config:Dictionary = {}) -> int:

    return max(2, int(camera_config.get("visible_radius", 6)))


func camera_visible_tiles(camera_config:Dictionary = {}) -> Vector2i:

    var visible_radius = camera_visible_radius(camera_config)

    var fixed_tiles = max(5, visible_radius * 2 + 1)

    return Vector2i(fixed_tiles, fixed_tiles)


func visible_world_rect(camera_rect:Rect2, world_bounds:Rect2) -> Rect2:

    var left = max(camera_rect.position.x, world_bounds.position.x)

    var top = max(camera_rect.position.y, world_bounds.position.y)

    var right = min(camera_rect.position.x + camera_rect.size.x, world_bounds.position.x + world_bounds.size.x)

    var bottom = min(camera_rect.position.y + camera_rect.size.y, world_bounds.position.y + world_bounds.size.y)

    if right <= left or bottom <= top:

        return Rect2()

    return Rect2(Vector2(left, top), Vector2(right - left, bottom - top))


func cell_origin(cell:Vector2i, tile_size:float) -> Vector2:

    return Vector2(float(cell.x) * tile_size, float(cell.y) * tile_size)


func cell_center(cell:Vector2i, tile_size:float) -> Vector2:

    return cell_origin(cell, tile_size) + Vector2(tile_size * 0.5, tile_size * 0.5)


func world_point_to_panel(point:Vector2, camera_rect:Rect2, draw_rect:Rect2) -> Vector2:

    if camera_rect.size == Vector2.ZERO:

        return point

    return draw_rect.position + Vector2(

        (point.x - camera_rect.position.x) / camera_rect.size.x * draw_rect.size.x,

        (point.y - camera_rect.position.y) / camera_rect.size.y * draw_rect.size.y

    )


func world_rect_to_panel(rect:Rect2, camera_rect:Rect2, draw_rect:Rect2) -> Rect2:

    var top_left = world_point_to_panel(rect.position, camera_rect, draw_rect)

    var bottom_right = world_point_to_panel(rect.position + rect.size, camera_rect, draw_rect)

    return Rect2(top_left, bottom_right - top_left)


func cell_rect_to_panel(cell:Vector2i, tile_size:float, camera_rect:Rect2, draw_rect:Rect2) -> Rect2:

    return world_rect_to_panel(Rect2(cell_origin(cell, tile_size), Vector2(tile_size, tile_size)), camera_rect, draw_rect)


func cell_in_visible_world(cell:Vector2i, tile_size:float, visible_world_rect:Rect2) -> bool:

    return visible_world_rect.has_point(cell_center(cell, tile_size))


func cell_in_visible_object_range(cell:Vector2i, player_cell:Vector2i, tile_size:float, visible_world_rect:Rect2, radius:int) -> bool:

    if not cell_in_visible_world(cell, tile_size, visible_world_rect):

        return false

    return max(abs(cell.x - player_cell.x), abs(cell.y - player_cell.y)) <= radius


func world_point_in_visible_world(point:Vector2, visible_world_rect:Rect2) -> bool:

    return visible_world_rect.has_point(point)


func grid_line_ranges(visible_world_rect:Rect2, tile_size:float, grid_size:Vector2i) -> Dictionary:

    if visible_world_rect.size.x <= 0.0 or visible_world_rect.size.y <= 0.0:

        return {"start_x": 0, "end_x": 0, "start_y": 0, "end_y": 0}

    return {

        "start_x": clamp(int(floor(visible_world_rect.position.x / tile_size)), 0, grid_size.x),

        "end_x": clamp(int(ceil((visible_world_rect.position.x + visible_world_rect.size.x) / tile_size)), 0, grid_size.x),

        "start_y": clamp(int(floor(visible_world_rect.position.y / tile_size)), 0, grid_size.y),

        "end_y": clamp(int(ceil((visible_world_rect.position.y + visible_world_rect.size.y) / tile_size)), 0, grid_size.y)

    }