docs/physics__world_8gd_source.html

extends RefCounted


const SpatialState = preload("res://scripts/systems/physicsEngine/spatial_state.gd")

const MotionIntegrator = preload("res://scripts/systems/physicsEngine/motion_integrator.gd")

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

const ConstraintSolver = preload("res://scripts/systems/physicsEngine/constraint_solver.gd")

const PhysicsQueries = preload("res://scripts/systems/physicsEngine/physics_queries.gd")


var spatial_state = SpatialState.new()

var motion_integrator = MotionIntegrator.new()

var collision_pipeline = CollisionPipeline.new()

var constraint_solver = ConstraintSolver.new()

var queries = PhysicsQueries.new()


var gravity := Vector2.ZERO

var damping := 0.0

var constraints := []

var last_contacts := []


func configure(options:Dictionary = {}) -> void:

    gravity = options.get("gravity", gravity)

    damping = max(0.0, float(options.get("damping", damping)))


func create_body(id:String, position:Vector2, options:Dictionary = {}) -> Dictionary:

    return spatial_state.create_body(id, position, options)


func add_force(id:String, force:Vector2) -> void:

    var body = spatial_state.get_body(id)

    if body.is_empty():

        return

    spatial_state.set_body(motion_integrator.add_force(body, force))


func apply_impulse(id:String, impulse:Vector2) -> void:

    var body = spatial_state.get_body(id)

    if body.is_empty():

        return

    spatial_state.set_body(motion_integrator.apply_impulse(body, impulse))


func add_constraint(constraint:Dictionary) -> void:

    constraints.append(constraint.duplicate(true))


func step(delta:float, solver_iterations:int = 1) -> Array:

    for body in spatial_state.get_bodies():

        spatial_state.set_body(motion_integrator.integrate(body, delta, gravity, damping))

    var pairs = collision_pipeline.broad_phase(spatial_state.get_bodies(), spatial_state)

    last_contacts = collision_pipeline.narrow_phase(pairs)

    var resolved = constraint_solver.resolve_collisions(spatial_state.bodies, last_contacts)

    resolved = constraint_solver.solve_constraints(resolved, constraints, solver_iterations)

    spatial_state.bodies = resolved

    return last_contacts.duplicate(true)


func get_broad_phase_pairs() -> Array:

    return collision_pipeline.broad_phase(spatial_state.get_bodies(), spatial_state)


func get_contacts() -> Array:

    return collision_pipeline.narrow_phase(get_broad_phase_pairs())


func point_query(point:Vector2) -> Array:

    return queries.point_query(spatial_state.get_bodies(), point)


func aabb_query(area:Rect2) -> Array:

    return queries.aabb_query(spatial_state.get_bodies(), area)


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

    return queries.raycast(spatial_state.get_bodies(), from, to)


func get_body(id:String) -> Dictionary:

    return spatial_state.get_body(id)


func get_state() -> Dictionary:

    return {

        "spatial_state": spatial_state.get_state(),

        "gravity": gravity,

        "damping": damping,

        "constraints": constraints.duplicate(true)

    }


func apply_state(state:Dictionary) -> void:

    spatial_state.apply_state(state.get("spatial_state", {}))

    gravity = state.get("gravity", Vector2.ZERO)

    damping = float(state.get("damping", 0.0))

    constraints = state.get("constraints", []).duplicate(true)


func clear() -> void:

    spatial_state.clear()

    constraints.clear()

    last_contacts.clear()