refactored collider shape editing plugin

editor/src/plugins/collider/ball.rs

@@ -0,0 +1,103 @@
+use crate::{
+    fyrox::{
+        core::{algebra::Vector3, pool::Handle},
+        scene::{
+            collider::{BallShape, ColliderShape},
+            node::Node,
+            Scene,
+        },
+    },
+    plugins::collider::{
+        make_handle, set_node_position, try_get_collider_shape, try_get_collider_shape_mut,
+        ShapeGizmoTrait, ShapeHandleValue,
+    },
+};
+
+pub struct BallShapeGizmo {
+    radius_handle: Handle<Node>,
+}
+
+impl BallShapeGizmo {
+    pub fn new(
+        ball: &BallShape,
+        center: Vector3<f32>,
+        side: Vector3<f32>,
+        root: Handle<Node>,
+        visible: bool,
+        scene: &mut Scene,
+    ) -> Self {
+        Self {
+            radius_handle: make_handle(scene, center + side.scale(ball.radius), root, visible),
+        }
+    }
+}
+
+impl ShapeGizmoTrait for BallShapeGizmo {
+    fn for_each_handle(&self, func: &mut dyn FnMut(Handle<Node>)) {
+        func(self.radius_handle)
+    }
+
+    fn handle_major_axis(&self, handle: Handle<Node>) -> Option<Vector3<f32>> {
+        if handle == self.radius_handle {
+            Some(Vector3::x())
+        } else {
+            None
+        }
+    }
+
+    fn try_sync_to_collider(
+        &self,
+        collider: Handle<Node>,
+        center: Vector3<f32>,
+        side: Vector3<f32>,
+        _up: Vector3<f32>,
+        _look: Vector3<f32>,
+        scene: &mut Scene,
+    ) -> bool {
+        let Some(ColliderShape::Ball(ball)) = try_get_collider_shape(collider, scene) else {
+            return false;
+        };
+
+        set_node_position(self.radius_handle, center + side.scale(ball.radius), scene);
+
+        true
+    }
+
+    fn value_by_handle(
+        &self,
+        handle: Handle<Node>,
+        collider: Handle<Node>,
+        scene: &Scene,
+    ) -> Option<ShapeHandleValue> {
+        let Some(ColliderShape::Ball(ball)) = try_get_collider_shape(collider, scene) else {
+            return None;
+        };
+
+        if handle == self.radius_handle {
+            Some(ShapeHandleValue::Scalar(ball.radius))
+        } else {
+            None
+        }
+    }
+
+    fn set_value_by_handle(
+        &self,
+        handle: Handle<Node>,
+        value: ShapeHandleValue,
+        collider: Handle<Node>,
+        scene: &mut Scene,
+        _initial_collider_local_position: Vector3<f32>,
+    ) {
+        let Some(ColliderShape::Ball(ball)) = try_get_collider_shape_mut(collider, scene) else {
+            return;
+        };
+
+        if handle == self.radius_handle {
+            ball.radius = value.into_scalar();
+        }
+    }
+
+    fn is_vector_handle(&self, _handle: Handle<Node>) -> bool {
+        false
+    }
+}

editor/src/plugins/collider/capsule.rs

@@ -0,0 +1,124 @@
+use crate::{
+    fyrox::{
+        core::{algebra::Vector3, pool::Handle},
+        scene::{
+            collider::{CapsuleShape, ColliderShape},
+            node::Node,
+            Scene,
+        },
+    },
+    plugins::collider::{
+        make_handle, set_node_position, try_get_collider_shape, try_get_collider_shape_mut,
+        ShapeGizmoTrait, ShapeHandleValue,
+    },
+};
+
+pub struct CapsuleShapeGizmo {
+    radius_handle: Handle<Node>,
+    begin_handle: Handle<Node>,
+    end_handle: Handle<Node>,
+}
+
+impl CapsuleShapeGizmo {
+    pub fn new(
+        capsule: &CapsuleShape,
+        center: Vector3<f32>,
+        side: Vector3<f32>,
+        visible: bool,
+        root: Handle<Node>,
+        scene: &mut Scene,
+    ) -> Self {
+        Self {
+            radius_handle: make_handle(scene, center + side.scale(capsule.radius), root, visible),
+            begin_handle: make_handle(scene, center + capsule.begin, root, visible),
+            end_handle: make_handle(scene, center + capsule.end, root, visible),
+        }
+    }
+}
+
+impl ShapeGizmoTrait for CapsuleShapeGizmo {
+    fn for_each_handle(&self, func: &mut dyn FnMut(Handle<Node>)) {
+        for handle in [self.radius_handle, self.begin_handle, self.end_handle] {
+            func(handle)
+        }
+    }
+
+    fn handle_major_axis(&self, handle: Handle<Node>) -> Option<Vector3<f32>> {
+        if handle == self.radius_handle {
+            Some(Vector3::x())
+        } else {
+            None
+        }
+    }
+
+    fn try_sync_to_collider(
+        &self,
+        collider: Handle<Node>,
+        center: Vector3<f32>,
+        side: Vector3<f32>,
+        _up: Vector3<f32>,
+        _look: Vector3<f32>,
+        scene: &mut Scene,
+    ) -> bool {
+        let Some(ColliderShape::Capsule(capsule)) = try_get_collider_shape(collider, scene) else {
+            return false;
+        };
+
+        set_node_position(
+            self.radius_handle,
+            center + side.scale(capsule.radius),
+            scene,
+        );
+        set_node_position(self.begin_handle, center + capsule.begin, scene);
+        set_node_position(self.end_handle, center + capsule.end, scene);
+
+        true
+    }
+
+    fn value_by_handle(
+        &self,
+        handle: Handle<Node>,
+        collider: Handle<Node>,
+        scene: &Scene,
+    ) -> Option<ShapeHandleValue> {
+        let Some(ColliderShape::Capsule(capsule)) = try_get_collider_shape(collider, scene) else {
+            return None;
+        };
+
+        if handle == self.radius_handle {
+            Some(ShapeHandleValue::Scalar(capsule.radius))
+        } else if handle == self.begin_handle {
+            Some(ShapeHandleValue::Vector(capsule.begin))
+        } else if handle == self.end_handle {
+            Some(ShapeHandleValue::Vector(capsule.end))
+        } else {
+            None
+        }
+    }
+
+    fn set_value_by_handle(
+        &self,
+        handle: Handle<Node>,
+        value: ShapeHandleValue,
+        collider: Handle<Node>,
+        scene: &mut Scene,
+        _initial_collider_local_position: Vector3<f32>,
+    ) {
+        let Some(ColliderShape::Capsule(capsule)) = try_get_collider_shape_mut(collider, scene)
+        else {
+            return;
+        };
+
+        if handle == self.radius_handle {
+            capsule.radius = value.into_scalar().max(0.0);
+        } else if handle == self.begin_handle {
+            capsule.begin = value.into_vector();
+        } else if handle == self.end_handle {
+            capsule.end = value.into_vector();
+        }
+    }
+
+    fn is_vector_handle(&self, handle: Handle<Node>) -> bool {
+        handle == self.begin_handle || handle == self.end_handle
+    }
+}

editor/src/plugins/collider/cone.rs

@@ -0,0 +1,124 @@
+use crate::{
+    fyrox::{
+        core::{algebra::Vector3, pool::Handle},
+        scene::{
+            collider::{ColliderShape, ConeShape},
+            node::Node,
+            Scene,
+        },
+    },
+    plugins::collider::{
+        make_handle, set_node_position, try_get_collider_shape, try_get_collider_shape_mut,
+        ShapeGizmoTrait, ShapeHandleValue,
+    },
+};
+
+pub struct ConeShapeGizmo {
+    radius_handle: Handle<Node>,
+    half_height_handle: Handle<Node>,
+}
+
+impl ConeShapeGizmo {
+    pub fn new(
+        cone: &ConeShape,
+        center: Vector3<f32>,
+        side: Vector3<f32>,
+        up: Vector3<f32>,
+        visible: bool,
+        root: Handle<Node>,
+        scene: &mut Scene,
+    ) -> Self {
+        Self {
+            radius_handle: make_handle(scene, center + side.scale(cone.radius), root, visible),
+            half_height_handle: make_handle(
+                scene,
+                center + up.scale(cone.half_height),
+                root,
+                visible,
+            ),
+        }
+    }
+}
+
+impl ShapeGizmoTrait for ConeShapeGizmo {
+    fn for_each_handle(&self, func: &mut dyn FnMut(Handle<Node>)) {
+        for handle in [self.radius_handle, self.half_height_handle] {
+            func(handle)
+        }
+    }
+
+    fn handle_major_axis(&self, handle: Handle<Node>) -> Option<Vector3<f32>> {
+        if handle == self.radius_handle {
+            Some(Vector3::x())
+        } else if handle == self.half_height_handle {
+            Some(Vector3::y())
+        } else {
+            None
+        }
+    }
+
+    fn try_sync_to_collider(
+        &self,
+        collider: Handle<Node>,
+        center: Vector3<f32>,
+        side: Vector3<f32>,
+        up: Vector3<f32>,
+        _look: Vector3<f32>,
+        scene: &mut Scene,
+    ) -> bool {
+        let Some(ColliderShape::Cone(cone)) = try_get_collider_shape(collider, scene) else {
+            return false;
+        };
+
+        set_node_position(self.radius_handle, center + side.scale(cone.radius), scene);
+        set_node_position(
+            self.half_height_handle,
+            center + up.scale(cone.half_height),
+            scene,
+        );
+
+        true
+    }
+
+    fn value_by_handle(
+        &self,
+        handle: Handle<Node>,
+        collider: Handle<Node>,
+        scene: &Scene,
+    ) -> Option<ShapeHandleValue> {
+        let Some(ColliderShape::Cone(cone)) = try_get_collider_shape(collider, scene) else {
+            return None;
+        };
+
+        if handle == self.radius_handle {
+            Some(ShapeHandleValue::Scalar(cone.radius))
+        } else if handle == self.half_height_handle {
+            Some(ShapeHandleValue::Scalar(cone.half_height))
+        } else {
+            None
+        }
+    }
+
+    fn set_value_by_handle(
+        &self,
+        handle: Handle<Node>,
+        value: ShapeHandleValue,
+        collider: Handle<Node>,
+        scene: &mut Scene,
+        _initial_collider_local_position: Vector3<f32>,
+    ) {
+        let Some(ColliderShape::Cone(cone)) = try_get_collider_shape_mut(collider, scene) else {
+            return;
+        };
+
+        if handle == self.radius_handle {
+            cone.radius = value.into_scalar().max(0.0);
+        } else if handle == self.half_height_handle {
+            cone.half_height = value.into_scalar().max(0.0);
+        }
+    }
+
+    fn is_vector_handle(&self, _handle: Handle<Node>) -> bool {
+        false
+    }
+}