Struct Gizmo

Source

pub struct Gizmo {
    pub handle: Handle<GizmoAsset>,
    pub line_config: GizmoLineConfig,
    pub depth_bias: f32,
}

Expand description

A component that draws the gizmos of a GizmoAsset.

When drawing a greater number of static lines a Gizmo component can have far better performance than the Gizmos system parameter, but the system parameter will perform better for smaller lines that update often.

§Example

fn system(
    mut commands: Commands,
    mut gizmo_assets: ResMut<Assets<GizmoAsset>>,
) {
    let mut gizmo = GizmoAsset::default();

    gizmo.sphere(Vec3::ZERO, 1., RED);

    commands.spawn(Gizmo {
        handle: gizmo_assets.add(gizmo),
        line_config: GizmoLineConfig {
            width: 4.,
            ..default()
        },
        ..default()
    });
}

Fields§

§handle: Handle<GizmoAsset>

The handle to the gizmo to draw.

§line_config: GizmoLineConfig

The line specific configuration for this gizmo.

§depth_bias: f32

How closer to the camera than real geometry the gizmo should be.

In 2D this setting has no effect and is effectively always -1.

Value between -1 and 1 (inclusive).

0 means that there is no change to the gizmo position when rendering
1 means it is furthest away from camera as possible
-1 means that it will always render in front of other things.

This is typically useful if you are drawing wireframes on top of polygons and your wireframe is z-fighting (flickering on/off) with your main model. You would set this value to a negative number close to 0.

Struct Gizmo Copy item path

§Example

Fields§

Trait Implementations§

impl Clone for Gizmo

fn clone(&self) -> Gizmo

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

impl Component for Gizmowhere Gizmo: Send + Sync + 'static,

const STORAGE_TYPE: StorageType = bevy_ecs::component::StorageType::Table

type Mutability = Mutable

fn register_required_components( _requiree: ComponentId, required_components: &mut RequiredComponentsRegistrator<'_, '_>, )

fn clone_behavior() -> ComponentCloneBehavior

fn on_add() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

fn on_insert() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

fn on_replace() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

fn on_remove() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

fn on_despawn() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

fn map_entities<E>(_this: &mut Self, _mapper: &mut E)where E: EntityMapper,

impl Debug for Gizmo

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

impl Default for Gizmo

fn default() -> Gizmo

impl FromArg for Gizmo

type This<'from_arg> = Gizmo

fn from_arg(arg: Arg<'_>) -> Result<<Gizmo as FromArg>::This<'_>, ArgError>

impl FromReflect for Gizmo

fn from_reflect(reflect: &(dyn PartialReflect + 'static)) -> Option<Gizmo>

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

impl GetOwnership for Gizmo

fn ownership() -> Ownership

impl GetTypeRegistration for Gizmo

fn get_type_registration() -> TypeRegistration

fn register_type_dependencies(registry: &mut TypeRegistry)

impl IntoReturn for Gizmo

fn into_return<'into_return>(self) -> Return<'into_return>where Gizmo: 'into_return,

impl PartialReflect for Gizmo

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<Gizmo>) -> ReflectOwned

fn try_into_reflect( self: Box<Gizmo>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<Gizmo>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

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

fn to_dynamic(&self) -> Box<dyn PartialReflect>

fn reflect_clone_and_take<T>(&self) -> Result<T, ReflectCloneError>where T: 'static, Self: Sized + TypePath,

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

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

fn is_dynamic(&self) -> bool

impl Reflect for Gizmo

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

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

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

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

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

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

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

impl Struct for Gizmo

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

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

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

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

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

fn field_len(&self) -> usize

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

fn to_dynamic_struct(&self) -> DynamicStruct

fn get_represented_struct_info(&self) -> Option<&'static StructInfo>

impl TypePath for Gizmo

fn type_path() -> &'static str

fn short_type_path() -> &'static str

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

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

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

Struct Gizmo

impl Component for Gizmo
where Gizmo: Send + Sync + 'static,

fn map_entities<E>(_this: &mut Self, _mapper: &mut E)
where E: EntityMapper,

fn into_return<'into_return>(self) -> Return<'into_return>
where Gizmo: 'into_return,

fn reflect_clone_and_take<T>(&self) -> Result<T, ReflectCloneError>
where T: 'static, Self: Sized + TypePath,

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

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

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

impl<C> Bundle for C
where C: Component,

impl<C> BundleFromComponents for C
where C: Component,

unsafe fn from_components<T, F>(ctx: &mut T, func: &mut F) -> C
where F: for<'a> FnMut(&'a mut T) -> OwningPtr<'a>,

impl<T> CloneToUninit for T
where T: Clone,

fn conv<T>(self) -> T
where Self: Into<T>,

impl<T> Downcast for T
where T: Any,

impl<T> Downcast for T
where T: Any,

impl<T> DowncastSend for T
where T: Any + Send,

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

impl<C> DynamicBundle for C
where C: Component,

impl<T> DynamicTypePath for T
where T: TypePath,

impl<T> DynamicTyped for T
where T: Typed,

fn fmt_binary(self) -> FmtBinary<Self>
where Self: Binary,

fn fmt_display(self) -> FmtDisplay<Self>
where Self: Display,

fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where Self: LowerExp,

fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where Self: LowerHex,

fn fmt_octal(self) -> FmtOctal<Self>
where Self: Octal,

fn fmt_pointer(self) -> FmtPointer<Self>
where Self: Pointer,

fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where Self: UpperExp,