Struct sepax2d::circle::Circle

pub struct Circle {
    pub position: (f32, f32),
    pub radius: f32,
}

A struct representing a circle via a position and radius.

Examples

use sepax2d::prelude::*;
 
let circle1 = Circle::new((0.0, 0.0), 2.0);
let circle2 = Circle::new((2.0, 2.0), 2.0);
 
let resolution = sat_collision(&circle1, &circle2);
let difference = 2.0 * (f32::sqrt(2.0) - 1.0); // 2 root 2 - 2
assert!(resolution.0 - difference < f32::EPSILON && resolution.0 - difference > -f32::EPSILON);
assert!(resolution.1 - difference < f32::EPSILON && resolution.1 - difference > -f32::EPSILON);
 
let polygon = Polygon::from_vertices((0.0, 3.0), vec![(0.0, 0.0), (1.0, 0.0), (1.0, -1.5), (0.0, -1.5)]);
assert!(sat_overlap(&polygon, &circle1));
assert!(sat_overlap(&circle1, &polygon));

Fields

position: (f32, f32)

radius: f32

Implementations

impl Circle

pub fn new(position: (f32, f32), radius: f32) -> Circle

Create a new circle with given position and radius.

Trait Implementations

impl Clone for Circle

fn clone(&self) -> Circle

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Circle

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Rotate for Circle

fn rotate(&mut self, _angle: f32)

Rotate the shape by the given angle, with the rotation counterclockwise when the Y-axis points up.

fn rotate_sincos(&mut self, _sin: f32, _cos: f32)

Rotate the shape using the given sine and cosine of an angle. Use this when you are rotating multiple shapes by the same angle and don’t want to re-calculate the trig functions.

impl Shape for Circle

fn position(&self) -> (f32, f32)

The location of the shape in 2D space.

fn set_position(&mut self, position: (f32, f32))

Set the location of the shape.

fn num_axes(&self) -> usize

The number of axes the shape provides for testing. For polygons, it is the same as the number of vertices, but for circles it is simply one.

fn get_axis(&self, _index: usize, target: (f32, f32)) -> (f32, f32)

The method used to access the axes during the SAT calculations. This is used to avoid the memory allocation of a new vector or array each time we calculate collisions.

fn project(&self, axis: (f32, f32), normalize: bool) -> (f32, f32)

Getting the minimum and maximum projection of the shape onto the given axis to look for overlap. Normalize denotes whether or not the axis passed in is a unit vector to avoid repeating calculations.

fn needs_closest(&self, _index: usize) -> bool

Determine whether or not the shape needs access to the closest vertex of another shape to check collisions.

fn get_closest(&self, _target: (f32, f32)) -> (f32, f32)

Gets the closest vertex/primary point/position to the given target, NOT the closest point on the shape.

fn point(&self, _index: usize) -> (f32, f32)

The point corresponding to the given axis, if applicable. Otherwise, position.

impl Copy for Circle