Table of Contents

Class GBGeometryUtils

Namespace
GridPlacement.GDScript
Assembly
MoonBark.GridPlacement.GDScript.dll

Utility functions for geometry calculations and shape operations.\n\nProvides static methods for working with collision shapes, bounding boxes, and coordinate transformations in grid building contexts.

class GBGeometryUtils
GBGeometryUtils

Properties

left_bound 

var left_bound = p_vector_array[0].x

right_bound 

var right_bound = p_vector_array[0].x

top_bound 

var top_bound = p_vector_array[0].y

bottom_bound 

var bottom_bound = p_vector_array[0].y

size 

var size = Vector2(

generated_rect 

var generated_rect = Rect2(p_rect_position, size)

shapes_dict 

var shapes_dict = {}

shape_owners 

var shape_owners = p_owner.get_shape_owners()

shape_count 

var shape_count = p_owner.shape_owner_get_shape_count(owner)

shape 

var shape = p_owner.shape_owner_get_shape(owner, shape_index)

shapes 

var shapes: Array[Shape2D] = []

result 

var result: Dictionary[Node2D, Array] = {}

shapes 

var shapes: Array[Shape2D] = []

shapes 

var shapes: Array[Shape2D] = []

shape_owners 

var shape_owners = p_owner.get_shape_owners()

shape_count 

var shape_count = p_owner.shape_owner_get_shape_count(owner)

shape 

var shape = p_owner.shape_owner_get_shape(owner, shape_index)

collision_shape 

var collision_shape = child as CollisionShape2D

convex_parts 

var convex_parts = Geometry2D.decompose_polygon_in_convex(p_owner.polygon)

poly_shape 

var poly_shape: ConvexPolygonShape2D = ConvexPolygonShape2D.new()

adjusted_rect 

var adjusted_rect = p_rect

new_size_x 

var new_size_x = p_rect.size.x + p_increment.x * sign(p_rect.size.x) if p_rect.size.x != 0 else p_increment.x

new_size_y 

var new_size_y = p_rect.size.y + p_increment.y * sign(p_rect.size.y) if p_rect.size.y != 0 else p_increment.y

abs_rect_size 

var abs_rect_size = abs(p_rect.size)

abs_larger_dimension 

var abs_larger_dimension = max(abs_rect_size.x, abs_rect_size.y)

larger_dimension_size 

var larger_dimension_size = Vector2(

tile_size 

var tile_size: Vector2 = tile_map.tile_set.tile_size

half_size 

var half_size = rect_size / 2.0

left 

var left = rect_center.x - half_size.x + epsilon

right 

var right = rect_center.x + half_size.x - epsilon

top 

var top = rect_center.y - half_size.y + epsilon

bottom 

var bottom = rect_center.y + half_size.y - epsilon

left_tile 

var left_tile = tile_map.local_to_map(tile_map.to_local(Vector2(left, rect_center.y)))

right_tile 

var right_tile = tile_map.local_to_map(tile_map.to_local(Vector2(right, rect_center.y)))

top_tile 

var top_tile = tile_map.local_to_map(tile_map.to_local(Vector2(rect_center.x, top)))

bottom_tile 

var bottom_tile = tile_map.local_to_map(tile_map.to_local(Vector2(rect_center.x, bottom)))

tile_positions 

var tile_positions: Array[Vector2i] = []

overlapped 

var overlapped: Array[Vector2i] = []

tile_shape 

var tile_shape: TileSet.TileShape = tile_type

tile_size 

var tile_size: Vector2 = tile_map.tile_set.tile_size

aabb 

var aabb = Rect2(polygon[0], Vector2.ZERO)

aabb_corners 

var aabb_corners: Array[Vector2] = [

mapped 

var mapped: Array[Vector2i] = []

min_x 

var min_x = mapped[0].x

max_x 

var max_x = mapped[0].x

min_y 

var min_y = mapped[0].y

max_y 

var max_y = mapped[0].y

cell 

var cell = Vector2i(x, y)

cell_center 

var cell_center = tile_map.map_to_local(cell)

cell_pos 

var cell_pos: Vector2

shape_poly 

var shape_poly: PackedVector2Array

rect 

var rect: RectangleShape2D = collision_shape.shape

ext 

var ext: Vector2 = rect.extents

shape_pos 

var shape_pos: Vector2 = collision_shape.global_position - ext

Methods

points_array_to_rect_2d 

static func points_array_to_rect_2d(p_vector_array: PackedVector2Array, p_rect_position: Vector2) -> Rect2:

Parameters

p_vector_array
p_rect_position

Returns

get_collision_object_shapes 

static func get_collision_object_shapes(p_collision_object: CollisionObject2D) -> Array[Shape2D]:

Parameters

p_collision_object

Returns

get_all_collision_shapes_by_owner 

static func get_all_collision_shapes_by_owner(root_node: Node2D) -> Dictionary[Node2D, Array]:

Parameters

root_node

Returns

get_shapes_from_owner 

static func get_shapes_from_owner(p_owner: Node2D) -> Array[Shape2D]:

Parameters

p_owner

Returns

grow_rect2_to_increment 

static func grow_rect2_to_increment(p_rect: Rect2, p_increment: Vector2) -> Rect2:

Parameters

p_rect
p_increment

Returns

grow_rect2_to_square 

static func grow_rect2_to_square(p_rect: Rect2) -> Rect2:

Parameters

p_rect

Returns

get_rect2_position_offset 

static func get_rect2_position_offset(p_rect: Rect2) -> Vector2:

Parameters

p_rect

Returns

get_overlapped_tiles_for_rect 

static func get_overlapped_tiles_for_rect(rect_center: Vector2, rect_size: Vector2, tile_map: TileMapLayer, epsilon: float = 0.1) -> Array[Vector2i]:

Parameters

rect_center
rect_size
tile_map
epsilon

Returns

get_overlapped_tiles_for_polygon 

static func get_overlapped_tiles_for_polygon( polygon: PackedVector2Array,

is_tile_covered_by_collision_shape 

static func is_tile_covered_by_collision_shape(tile_pos: Vector2, tile_size: Vector2, collision_shape: CollisionShape2D, tile_type: TileSet.TileShape, epsilon: float = 0.01) -> bool:

Parameters

tile_pos
tile_size
collision_shape
tile_type
epsilon

Returns

is_tile_covered_by_collision_polygon 

static func is_tile_covered_by_collision_polygon(tile_pos: Vector2, tile_size: Vector2, collision_polygon: CollisionPolygon2D, tile_type: TileSet.TileShape, epsilon: float = 0.01) -> bool:

Parameters

tile_pos
tile_size
collision_polygon
tile_type
epsilon

Returns