docs/physics__queries_8gd_source.html

extends RefCounted


const CollisionPipeline = preload("res://scripts/systems/physicsEngine/collision_pipeline.gd")


var collision_pipeline = CollisionPipeline.new()


func point_query(bodies:Array, point:Vector2) -> Array:

    var results = []

    for body in bodies:

        if _contains_point(body, point):

            results.append(body.duplicate(true))

    return results


func aabb_query(bodies:Array, area:Rect2) -> Array:

    var results = []

    for body in bodies:

        if collision_pipeline.get_aabb(body).intersects(area):

            results.append(body.duplicate(true))

    return results


func raycast(bodies:Array, from:Vector2, to:Vector2) -> Dictionary:

    var best := {}

    var best_distance := INF

    for body in bodies:

        var hit = _ray_body(body, from, to)

        if hit.is_empty():

            continue

        var distance = from.distance_to(hit.get("point", from))

        if distance < best_distance:

            best_distance = distance

            best = hit

    return best


func _contains_point(body:Dictionary, point:Vector2) -> bool:

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

    if str(shape.get("type", "aabb")) == "circle":

        return point.distance_to(body.get("position", Vector2.ZERO)) <= float(shape.get("radius", 8.0))

    return collision_pipeline.get_aabb(body).has_point(point)


func _ray_body(body:Dictionary, from:Vector2, to:Vector2) -> Dictionary:

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

    if str(shape.get("type", "aabb")) == "circle":

        return _ray_circle(body, from, to)

    return _ray_aabb(body, from, to)


func _ray_circle(body:Dictionary, from:Vector2, to:Vector2) -> Dictionary:

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

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

    var direction = to - from

    var length = direction.length()

    if length <= 0.0001:

        return {}

    var dir = direction / length

    var to_center = center - from

    var projection = clamp(to_center.dot(dir), 0.0, length)

    var closest = from + dir * projection

    if closest.distance_to(center) <= radius:

        return {"body": body.duplicate(true), "point": closest, "distance": from.distance_to(closest)}

    return {}


func _ray_aabb(body:Dictionary, from:Vector2, to:Vector2) -> Dictionary:

    var rect = collision_pipeline.get_aabb(body)

    var direction = to - from

    var t_min := 0.0

    var t_max := 1.0

    for axis in ["x", "y"]:

        var origin = from.x if axis == "x" else from.y

        var dir = direction.x if axis == "x" else direction.y

        var min_value = rect.position.x if axis == "x" else rect.position.y

        var max_value = rect.end.x if axis == "x" else rect.end.y

        if abs(dir) < 0.0001:

            if origin < min_value or origin > max_value:

                return {}

        else:

            var inv_dir = 1.0 / dir

            var t1 = (min_value - origin) * inv_dir

            var t2 = (max_value - origin) * inv_dir

            if t1 > t2:

                var temp = t1

                t1 = t2

                t2 = temp

            t_min = max(t_min, t1)

            t_max = min(t_max, t2)

            if t_min > t_max:

                return {}

    var point = from + direction * t_min

    return {"body": body.duplicate(true), "point": point, "distance": from.distance_to(point)}