# Struct bevy::math::prelude::CircularSegment

``````pub struct CircularSegment {
pub arc: Arc2d,
}``````
Expand description

A primitive representing a circular segment: the area enclosed by the arc of a circle and its chord (the line between its endpoints).

The segment is drawn starting from `Vec2::Y`, extending equally on either side. To orient the segment differently, apply a rotation. The segment is drawn with the center of its circle at the origin `Vec2::ZERO`. When positioning a segment, the `apothem` function may be particularly useful.

Warning: Circular segments with negative angle or radius, or with angle greater than an entire circle, are not officially supported. We recommend normalizing circular segments to have an angle in [0, 2π].

## Fields§

§`arc: Arc2d`

The arc defining the segment

## Implementations§

§

### impl CircularSegment

#### pub fn new(radius: f32, angle: f32) -> CircularSegment

Create a new `CircularSegment` from a `radius`, and an `angle`

##### Examples found in repository?
examples/2d/2d_shapes.rs (line 28)
```18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
```
``````fn setup(
mut commands: Commands,
mut meshes: ResMut<Assets<Mesh>>,
mut materials: ResMut<Assets<ColorMaterial>>,
) {
commands.spawn(Camera2dBundle::default());

let shapes = [
Vec2::Y * 50.0,
Vec2::new(-50.0, -50.0),
Vec2::new(50.0, -50.0),
))),
];
let num_shapes = shapes.len();

for (i, shape) in shapes.into_iter().enumerate() {
// Distribute colors evenly across the rainbow.
let color = Color::hsl(360. * i as f32 / num_shapes as f32, 0.95, 0.7);

commands.spawn(MaterialMesh2dBundle {
mesh: shape,
transform: Transform::from_xyz(
// Distribute shapes from -X_EXTENT/2 to +X_EXTENT/2.
-X_EXTENT / 2. + i as f32 / (num_shapes - 1) as f32 * X_EXTENT,
0.0,
0.0,
),
..default()
});
}

commands.spawn(
TextBundle::from_section("Press space to toggle wireframes", TextStyle::default())
.with_style(Style {
position_type: PositionType::Absolute,
top: Val::Px(12.0),
left: Val::Px(12.0),
..default()
}),
);
}``````

Create a new `CircularSegment` from a `radius` and an `angle` in radians.

#### pub fn from_degrees(radius: f32, angle: f32) -> CircularSegment

Create a new `CircularSegment` from a `radius` and an `angle` in degrees.

#### pub fn from_turns(radius: f32, fraction: f32) -> CircularSegment

Create a new `CircularSegment` from a `radius` and a number of `turns` of a circle.

For instance, `0.5` turns is a semicircle.

##### Examples found in repository?
examples/2d/mesh2d_arcs.rs (line 80)
```31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
```
``````fn setup(
mut commands: Commands,
asset_server: Res<AssetServer>,
mut meshes: ResMut<Assets<Mesh>>,
mut materials: ResMut<Assets<ColorMaterial>>,
) {

commands.spawn(Camera2dBundle {
camera: Camera {
clear_color: ClearColorConfig::Custom(DARK_SLATE_GREY.into()),
..default()
},
..default()
});

const UPPER_Y: f32 = 50.0;
const LOWER_Y: f32 = -50.0;
const FIRST_X: f32 = -450.0;
const OFFSET: f32 = 100.0;
const NUM_SLICES: i32 = 8;

// This draws NUM_SLICES copies of the Bevy logo as circular sectors and segments,
// with successively larger angles up to a complete circle.
for i in 0..NUM_SLICES {
let fraction = (i + 1) as f32 / NUM_SLICES as f32;

let sector = CircularSector::from_turns(40.0, fraction);
// We want to rotate the circular sector so that the sectors appear clockwise from north.
// We must rotate it both in the Transform and in the mesh's UV mappings.
let sector_angle = -sector.half_angle();
let sector_mesh =
angle: sector_angle,
});
commands.spawn((
MaterialMesh2dBundle {
material: material.clone(),
transform: Transform {
translation: Vec3::new(FIRST_X + OFFSET * i as f32, 2.0 * UPPER_Y, 0.0),
rotation: Quat::from_rotation_z(sector_angle),
..default()
},
..default()
},
DrawBounds(sector),
));

let segment = CircularSegment::from_turns(40.0, fraction);
// For the circular segment, we will draw Bevy charging forward, which requires rotating the
// shape and texture by 90 degrees.
//
// Note that this may be unintuitive; it may feel like we should rotate the texture by the
// opposite angle to preserve the orientation of Bevy. But the angle is not the angle of the
// texture itself, rather it is the angle at which the vertices are mapped onto the texture.
// so it is the negative of what you might otherwise expect.
let segment_angle = -FRAC_PI_2;
let segment_mesh =
angle: -segment_angle,
});
commands.spawn((
MaterialMesh2dBundle {
material: material.clone(),
transform: Transform {
translation: Vec3::new(FIRST_X + OFFSET * i as f32, LOWER_Y, 0.0),
rotation: Quat::from_rotation_z(segment_angle),
..default()
},
..default()
},
DrawBounds(segment),
));
}
}``````

#### pub fn half_angle(&self) -> f32

Get the half-angle of the segment

#### pub fn angle(&self) -> f32

Get the angle of the segment

#### pub fn radius(&self) -> f32

Get the radius of the segment

#### pub fn arc_length(&self) -> f32

Get the length of the arc defining the segment

#### pub fn half_chord_length(&self) -> f32

Get half the length of the segment’s base, also known as its chord

#### pub fn chord_length(&self) -> f32

Get the length of the segment’s base, also known as its chord

#### pub fn chord_midpoint(&self) -> Vec2

Get the midpoint of the segment’s base, also known as its chord

#### pub fn apothem(&self) -> f32

Get the length of the apothem of this segment, which is the signed distance between the segment and the center of its circle

#### pub fn sagitta(&self) -> f32

Get the length of the sagitta of this segment, also known as its height

#### pub fn area(&self) -> f32

Returns the area of this segment

## Trait Implementations§

§

### impl Bounded2d for CircularSegment

§

#### fn aabb_2d(&self, translation: Vec2, rotation: impl Into<Rot2>) -> Aabb2d

Get an axis-aligned bounding box for the shape with the given translation and rotation. The rotation is in radians, counterclockwise, with 0 meaning no rotation.
§

#### fn bounding_circle( &self, translation: Vec2, rotation: impl Into<Rot2>, ) -> BoundingCircle

Get a bounding circle for the shape The rotation is in radians, counterclockwise, with 0 meaning no rotation.
§

### impl Clone for CircularSegment

§

#### fn clone(&self) -> CircularSegment

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from `source`. Read more
§

### impl Debug for CircularSegment

§

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

Formats the value using the given formatter. Read more
§

### impl Default for CircularSegment

§

#### fn default() -> CircularSegment

Returns the default `CircularSegment` with radius `0.5` and covering a third of a circle

§

### impl<'de> Deserialize<'de> for CircularSegment

§

#### fn deserialize<__D>( __deserializer: __D, ) -> Result<CircularSegment, <__D as Deserializer<'de>>::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
§

### impl From<Arc2d> for CircularSegment

§

#### fn from(arc: Arc2d) -> CircularSegment

Converts to this type from the input type.
§

### impl From<CircularSegment> for Mesh

§

#### fn from(segment: CircularSegment) -> Mesh

Converts this sector into a `Mesh` using a default `CircularSegmentMeshBuilder`.

See the documentation of `CircularSegmentMeshBuilder` for more details.

§

### impl FromReflect for CircularSegmentwhere CircularSegment: Any + Send + Sync, Arc2d: FromReflect + TypePath + RegisterForReflection,

§

#### fn from_reflect(reflect: &(dyn Reflect + 'static)) -> Option<CircularSegment>

Constructs a concrete instance of `Self` from a reflected value.
§

#### fn take_from_reflect( reflect: Box<dyn Reflect>, ) -> Result<Self, Box<dyn Reflect>>

Attempts to downcast the given value to `Self` using, constructing the value using `from_reflect` if that fails. Read more
§

### impl GetTypeRegistration for CircularSegmentwhere CircularSegment: Any + Send + Sync, Arc2d: FromReflect + TypePath + RegisterForReflection,

§

#### fn get_type_registration() -> TypeRegistration

Returns the default `TypeRegistration` for this type.
§

#### fn register_type_dependencies(registry: &mut TypeRegistry)

Registers other types needed by this type. Read more
§

### impl<'w, 's, Config, Clear> GizmoPrimitive2d<CircularSegment> for Gizmos<'w, 's, Config, Clear>where Config: GizmoConfigGroup, Clear: 'static + Send + Sync,

§

#### type Output<'a> = ()where Gizmos<'w, 's, Config, Clear>: 'a

The output of `primitive_2d`. This is a builder to set non-default values.
§

#### fn primitive_2d( &mut self, primitive: &CircularSegment, position: Vec2, angle: f32, color: impl Into<Color>, ) -> <Gizmos<'w, 's, Config, Clear> as GizmoPrimitive2d<CircularSegment>>::Output<'_>

Renders a 2D primitive with its associated details.
§

### impl Meshable for CircularSegment

§

#### type Output = CircularSegmentMeshBuilder

The output of `Self::mesh`. This will be a `MeshBuilder` used for creating a `Mesh`.
§

#### fn mesh(&self) -> <CircularSegment as Meshable>::Output

Creates a `Mesh` for a shape.
§

### impl PartialEq for CircularSegment

§

#### fn eq(&self, other: &CircularSegment) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`.
1.0.0 · source§

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`. The default implementation is almost always sufficient, and should not be overridden without very good reason.
§

### impl Reflect for CircularSegmentwhere CircularSegment: Any + Send + Sync, Arc2d: FromReflect + TypePath + RegisterForReflection,

§

#### fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

Returns the `TypeInfo` of the type represented by this value. Read more
§

#### fn into_any(self: Box<CircularSegment>) -> Box<dyn Any>

Returns the value as a `Box<dyn Any>`.
§

#### fn as_any(&self) -> &(dyn Any + 'static)

Returns the value as a `&dyn Any`.
§

#### fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Returns the value as a `&mut dyn Any`.
§

#### fn into_reflect(self: Box<CircularSegment>) -> Box<dyn Reflect>

Casts this type to a boxed reflected value.
§

#### fn as_reflect(&self) -> &(dyn Reflect + 'static)

Casts this type to a reflected value.
§

#### fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)

Casts this type to a mutable reflected value.
§

#### fn clone_value(&self) -> Box<dyn Reflect>

Clones the value as a `Reflect` trait object. Read more
§

#### fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

Performs a type-checked assignment of a reflected value to this value. Read more
§

#### fn try_apply( &mut self, value: &(dyn Reflect + 'static), ) -> Result<(), ApplyError>

Tries to `apply` a reflected value to this value. Read more
§

#### fn reflect_kind(&self) -> ReflectKind

Returns a zero-sized enumeration of “kinds” of type. Read more
§

#### fn reflect_ref(&self) -> ReflectRef<'_>

Returns an immutable enumeration of “kinds” of type. Read more
§

#### fn reflect_mut(&mut self) -> ReflectMut<'_>

Returns a mutable enumeration of “kinds” of type. Read more
§

#### fn reflect_owned(self: Box<CircularSegment>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type. Read more
§

#### fn reflect_partial_eq(&self, value: &(dyn Reflect + 'static)) -> Option<bool>

Returns a “partial equality” comparison result. Read more
§

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

Debug formatter for the value. Read more
§

#### fn apply(&mut self, value: &(dyn Reflect + 'static))

Applies a reflected value to this value. Read more
§

#### fn reflect_hash(&self) -> Option<u64>

Returns a hash of the value (which includes the type). Read more
§

#### fn serializable(&self) -> Option<Serializable<'_>>

Returns a serializable version of the value. Read more
§

#### fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type. Read more
§

### impl Serialize for CircularSegment

§

#### fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where __S: Serializer,

Serialize this value into the given Serde serializer. Read more
§

### impl Struct for CircularSegmentwhere CircularSegment: Any + Send + Sync, Arc2d: FromReflect + TypePath + RegisterForReflection,

§

#### fn field(&self, name: &str) -> Option<&(dyn Reflect + 'static)>

Returns a reference to the value of the field named `name` as a `&dyn Reflect`.
§

#### fn field_mut(&mut self, name: &str) -> Option<&mut (dyn Reflect + 'static)>

Returns a mutable reference to the value of the field named `name` as a `&mut dyn Reflect`.
§

#### fn field_at(&self, index: usize) -> Option<&(dyn Reflect + 'static)>

Returns a reference to the value of the field with index `index` as a `&dyn Reflect`.
§

#### fn field_at_mut(&mut self, index: usize) -> Option<&mut (dyn Reflect + 'static)>

Returns a mutable reference to the value of the field with index `index` as a `&mut dyn Reflect`.
§

#### fn name_at(&self, index: usize) -> Option<&str>

Returns the name of the field with index `index`.
§

#### fn field_len(&self) -> usize

Returns the number of fields in the struct.
§

#### fn iter_fields(&self) -> FieldIter<'_> ⓘ

Returns an iterator over the values of the reflectable fields for this struct.
§

#### fn clone_dynamic(&self) -> DynamicStruct

Clones the struct into a `DynamicStruct`.
§

### impl TypePath for CircularSegmentwhere CircularSegment: Any + Send + Sync,

§

#### fn type_path() -> &'static str

Returns the fully qualified path of the underlying type. Read more
§

#### fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type. Read more
§

#### fn type_ident() -> Option<&'static str>

Returns the name of the type, or `None` if it is anonymous. Read more
§

#### fn crate_name() -> Option<&'static str>

Returns the name of the crate the type is in, or `None` if it is anonymous. Read more
§

#### fn module_path() -> Option<&'static str>

Returns the path to the module the type is in, or `None` if it is anonymous. Read more
§

### impl Typed for CircularSegmentwhere CircularSegment: Any + Send + Sync, Arc2d: FromReflect + TypePath + RegisterForReflection,

§

#### fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.
§

§

§

§

§

§

§

§

§

## Blanket Implementations§

source§

### impl<T> Any for Twhere T: 'static + ?Sized,

source§

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more
§

### impl<T, U> AsBindGroupShaderType<U> for Twhere U: ShaderType, &'a T: for<'a> Into<U>,

§

#### fn as_bind_group_shader_type(&self, _images: &RenderAssets<GpuImage>) -> U

Return the `T` `ShaderType` for `self`. When used in `AsBindGroup` derives, it is safe to assume that all images in `self` exist.
source§

### impl<T> Borrow<T> for Twhere T: ?Sized,

source§

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

### impl<T> BorrowMut<T> for Twhere T: ?Sized,

source§

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

§

§

### impl<T> Downcast for Twhere T: Any,

§

#### fn into_any(self: Box<T>) -> Box<dyn Any>

Convert `Box<dyn Trait>` (where `Trait: Downcast`) to `Box<dyn Any>`. `Box<dyn Any>` can then be further `downcast` into `Box<ConcreteType>` where `ConcreteType` implements `Trait`.
§

#### fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert `Rc<Trait>` (where `Trait: Downcast`) to `Rc<Any>`. `Rc<Any>` can then be further `downcast` into `Rc<ConcreteType>` where `ConcreteType` implements `Trait`.
§

#### fn as_any(&self) -> &(dyn Any + 'static)

Convert `&Trait` (where `Trait: Downcast`) to `&Any`. This is needed since Rust cannot generate `&Any`’s vtable from `&Trait`’s.
§

#### fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert `&mut Trait` (where `Trait: Downcast`) to `&Any`. This is needed since Rust cannot generate `&mut Any`’s vtable from `&mut Trait`’s.
§

### impl<T> DowncastSync for Twhere T: Any + Send + Sync,

§

#### fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Convert `Arc<Trait>` (where `Trait: Downcast`) to `Arc<Any>`. `Arc<Any>` can then be further `downcast` into `Arc<ConcreteType>` where `ConcreteType` implements `Trait`.
§

§

§

§

§

§

source§

### impl<T> From<T> for T

source§

#### fn from(t: T) -> T

Returns the argument unchanged.

§

§

§

### impl<T> FromWorld for Twhere T: Default,

§

#### fn from_world(_world: &mut World) -> T

Creates `Self` using data from the given `World`.
§

### impl<S> GetField for Swhere S: Struct,

§

#### fn get_field<T>(&self, name: &str) -> Option<&T>where T: Reflect,

Returns a reference to the value of the field named `name`, downcast to `T`.
§

#### fn get_field_mut<T>(&mut self, name: &str) -> Option<&mut T>where T: Reflect,

Returns a mutable reference to the value of the field named `name`, downcast to `T`.
§

### impl<T> GetPath for Twhere T: Reflect + ?Sized,

§

#### fn reflect_path<'p>( &self, path: impl ReflectPath<'p>, ) -> Result<&(dyn Reflect + 'static), ReflectPathError<'p>>

Returns a reference to the value specified by `path`. Read more
§

#### fn reflect_path_mut<'p>( &mut self, path: impl ReflectPath<'p>, ) -> Result<&mut (dyn Reflect + 'static), ReflectPathError<'p>>

Returns a mutable reference to the value specified by `path`. Read more
§

#### fn path<'p, T>( &self, path: impl ReflectPath<'p>, ) -> Result<&T, ReflectPathError<'p>>where T: Reflect,

Returns a statically typed reference to the value specified by `path`. Read more
§

#### fn path_mut<'p, T>( &mut self, path: impl ReflectPath<'p>, ) -> Result<&mut T, ReflectPathError<'p>>where T: Reflect,

Returns a statically typed mutable reference to the value specified by `path`. Read more
§

### impl<T> Instrument for T

§

#### fn instrument(self, span: Span) -> Instrumented<Self> ⓘ

Instruments this type with the provided `Span`, returning an `Instrumented` wrapper. Read more
§

#### fn in_current_span(self) -> Instrumented<Self> ⓘ

Instruments this type with the current `Span`, returning an `Instrumented` wrapper. Read more
source§

### impl<T, U> Into<U> for Twhere U: From<T>,

source§

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

source§

### impl<T> IntoEither for T

source§

#### fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ

Converts `self` into a `Left` variant of `Either<Self, Self>` if `into_left` is `true`. Converts `self` into a `Right` variant of `Either<Self, Self>` otherwise. Read more
source§

#### fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘwhere F: FnOnce(&Self) -> bool,

Converts `self` into a `Left` variant of `Either<Self, Self>` if `into_left(&self)` returns `true`. Converts `self` into a `Right` variant of `Either<Self, Self>` otherwise. Read more
§

§

§

### impl<T> NoneValue for Twhere T: Default,

§

§

#### fn null_value() -> T

The none-equivalent value.
§

### impl<T> Pointable for T

§

#### const ALIGN: usize = _

The alignment of pointer.
§

#### type Init = T

The type for initializers.
§

#### unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

#### unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

#### unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

#### unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

source§

Read this value from the supplied reader. Same as `ReadEndian::read_from_little_endian()`.
source§

Read this value from the supplied reader. Same as `ReadEndian::read_from_big_endian()`.
source§

Read this value from the supplied reader. Same as `ReadEndian::read_from_native_endian()`.
source§

### impl<T> Same for T

§

#### type Output = T

Should always be `Self`
source§

source§

source§

source§

### impl<T> ToOwned for Twhere T: Clone,

§

#### type Owned = T

The resulting type after obtaining ownership.
source§

#### fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

#### fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
§

§

source§

### impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

#### type Error = Infallible

The type returned in the event of a conversion error.
source§

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

### impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

§

§

§

§

§

§

### impl<T> WithSubscriber for T

§

#### fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> ⓘwhere S: Into<Dispatch>,

Attaches the provided `Subscriber` to this type, returning a `WithDispatch` wrapper. Read more
§

#### fn with_current_subscriber(self) -> WithDispatch<Self> ⓘ

Attaches the current default `Subscriber` to this type, returning a `WithDispatch` wrapper. Read more
§

source§

§

§

§

§

§