docs/collision__pipeline_8gd_source.html

extends RefCounted


func get_aabb(body:Dictionary) -> Rect2:

    var shape = body.get("shape", {})

    var position = body.get("position", Vector2.ZERO)

    var type = str(shape.get("type", "aabb"))

    if type == "circle":

        var radius = float(shape.get("radius", 8.0))

        return Rect2(position - Vector2(radius, radius), Vector2(radius * 2.0, radius * 2.0))

    var size = shape.get("size", Vector2(16, 16))

    if size is Array and size.size() >= 2:

        size = Vector2(float(size[0]), float(size[1]))

    return Rect2(position - size * 0.5, size)


func broad_phase(bodies:Array, spatial_state = null) -> Array:

    var pairs = []

    for i in range(bodies.size()):

        for j in range(i + 1, bodies.size()):

            var a = bodies[i]

            var b = bodies[j]

            if spatial_state != null and not spatial_state.can_collide(a, b):

                continue

            if get_aabb(a).intersects(get_aabb(b)):

                pairs.append({"a": a, "b": b})

    return pairs


func narrow_phase(pairs:Array) -> Array:

    var contacts = []

    for pair in pairs:

        var contact = test_collision(pair.get("a", {}), pair.get("b", {}))

        if not contact.is_empty():

            contacts.append(contact)

    return contacts


func test_collision(a:Dictionary, b:Dictionary) -> Dictionary:

    var a_shape = a.get("shape", {})

    var b_shape = b.get("shape", {})

    var a_type = str(a_shape.get("type", "aabb"))

    var b_type = str(b_shape.get("type", "aabb"))

    if a_type == "circle" and b_type == "circle":

        return _circle_circle(a, b)

    if a_type == "aabb" and b_type == "aabb":

        return _aabb_aabb(a, b)

    if a_type == "circle" and b_type == "aabb":

        return _circle_aabb(a, b)

    if a_type == "aabb" and b_type == "circle":

        var contact = _circle_aabb(b, a)

        if not contact.is_empty():

            contact["normal"] = -contact.get("normal", Vector2.RIGHT)

            contact["a"] = a

            contact["b"] = b

        return contact

    return {}


func _circle_circle(a:Dictionary, b:Dictionary) -> Dictionary:

    var delta = b.get("position", Vector2.ZERO) - a.get("position", Vector2.ZERO)

    var distance = delta.length()

    var radius_sum = float(a.get("shape", {}).get("radius", 8.0)) + float(b.get("shape", {}).get("radius", 8.0))

    if distance >= radius_sum:

        return {}

    var normal = Vector2.RIGHT if distance <= 0.0001 else delta / distance

    return {"a": a, "b": b, "normal": normal, "penetration": radius_sum - distance, "point": a.get("position", Vector2.ZERO) + normal * float(a.get("shape", {}).get("radius", 8.0))}


func _aabb_aabb(a:Dictionary, b:Dictionary) -> Dictionary:

    var a_rect = get_aabb(a)

    var b_rect = get_aabb(b)

    if not a_rect.intersects(b_rect):

        return {}

    var a_center = a_rect.get_center()

    var b_center = b_rect.get_center()

    var overlap_x = min(a_rect.end.x, b_rect.end.x) - max(a_rect.position.x, b_rect.position.x)

    var overlap_y = min(a_rect.end.y, b_rect.end.y) - max(a_rect.position.y, b_rect.position.y)

    if overlap_x < overlap_y:

        var normal_x = 1.0 if b_center.x >= a_center.x else -1.0

        return {"a": a, "b": b, "normal": Vector2(normal_x, 0), "penetration": overlap_x, "point": Vector2((a_center.x + b_center.x) * 0.5, (a_center.y + b_center.y) * 0.5)}

    var normal_y = 1.0 if b_center.y >= a_center.y else -1.0

    return {"a": a, "b": b, "normal": Vector2(0, normal_y), "penetration": overlap_y, "point": Vector2((a_center.x + b_center.x) * 0.5, (a_center.y + b_center.y) * 0.5)}


func _circle_aabb(circle:Dictionary, box:Dictionary) -> Dictionary:

    var circle_position = circle.get("position", Vector2.ZERO)

    var radius = float(circle.get("shape", {}).get("radius", 8.0))

    var rect = get_aabb(box)

    var closest = Vector2(

        clamp(circle_position.x, rect.position.x, rect.end.x),

        clamp(circle_position.y, rect.position.y, rect.end.y)

    )

    var delta = closest - circle_position

    var distance = delta.length()

    if distance >= radius:

        return {}

    var normal = Vector2.RIGHT if distance <= 0.0001 else delta / distance

    return {"a": circle, "b": box, "normal": normal, "penetration": radius - distance, "point": closest}