bevy 1.0.0

data/crates/bevy/src/types/math.rs

@@ -0,0 +1,260 @@
+use bevy_math::{Quat, Vec2, Vec3};
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct RubyVec2(pub Vec2);
+
+impl RubyVec2 {
+    pub fn new(x: f32, y: f32) -> Self {
+        Self(Vec2::new(x, y))
+    }
+
+    pub fn zero() -> Self {
+        Self(Vec2::ZERO)
+    }
+
+    pub fn one() -> Self {
+        Self(Vec2::ONE)
+    }
+
+    pub fn x(&self) -> f32 {
+        self.0.x
+    }
+
+    pub fn y(&self) -> f32 {
+        self.0.y
+    }
+
+    pub fn set_x(&mut self, x: f32) {
+        self.0.x = x;
+    }
+
+    pub fn set_y(&mut self, y: f32) {
+        self.0.y = y;
+    }
+
+    pub fn length(&self) -> f32 {
+        self.0.length()
+    }
+
+    pub fn length_squared(&self) -> f32 {
+        self.0.length_squared()
+    }
+
+    pub fn normalize(&self) -> Self {
+        Self(self.0.normalize())
+    }
+
+    pub fn dot(&self, other: &RubyVec2) -> f32 {
+        self.0.dot(other.0)
+    }
+
+    pub fn add(&self, other: &RubyVec2) -> Self {
+        Self(self.0 + other.0)
+    }
+
+    pub fn sub(&self, other: &RubyVec2) -> Self {
+        Self(self.0 - other.0)
+    }
+
+    pub fn mul(&self, scalar: f32) -> Self {
+        Self(self.0 * scalar)
+    }
+
+    pub fn div(&self, scalar: f32) -> Self {
+        Self(self.0 / scalar)
+    }
+
+    pub fn distance(&self, other: &RubyVec2) -> f32 {
+        self.0.distance(other.0)
+    }
+
+    pub fn inner(&self) -> Vec2 {
+        self.0
+    }
+}
+
+impl From<Vec2> for RubyVec2 {
+    fn from(v: Vec2) -> Self {
+        Self(v)
+    }
+}
+
+impl From<RubyVec2> for Vec2 {
+    fn from(v: RubyVec2) -> Self {
+        v.0
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct RubyVec3(pub Vec3);
+
+impl RubyVec3 {
+    pub fn new(x: f32, y: f32, z: f32) -> Self {
+        Self(Vec3::new(x, y, z))
+    }
+
+    pub fn zero() -> Self {
+        Self(Vec3::ZERO)
+    }
+
+    pub fn one() -> Self {
+        Self(Vec3::ONE)
+    }
+
+    pub fn x(&self) -> f32 {
+        self.0.x
+    }
+
+    pub fn y(&self) -> f32 {
+        self.0.y
+    }
+
+    pub fn z(&self) -> f32 {
+        self.0.z
+    }
+
+    pub fn set_x(&mut self, x: f32) {
+        self.0.x = x;
+    }
+
+    pub fn set_y(&mut self, y: f32) {
+        self.0.y = y;
+    }
+
+    pub fn set_z(&mut self, z: f32) {
+        self.0.z = z;
+    }
+
+    pub fn length(&self) -> f32 {
+        self.0.length()
+    }
+
+    pub fn length_squared(&self) -> f32 {
+        self.0.length_squared()
+    }
+
+    pub fn normalize(&self) -> Self {
+        Self(self.0.normalize())
+    }
+
+    pub fn dot(&self, other: &RubyVec3) -> f32 {
+        self.0.dot(other.0)
+    }
+
+    pub fn cross(&self, other: &RubyVec3) -> Self {
+        Self(self.0.cross(other.0))
+    }
+
+    pub fn add(&self, other: &RubyVec3) -> Self {
+        Self(self.0 + other.0)
+    }
+
+    pub fn sub(&self, other: &RubyVec3) -> Self {
+        Self(self.0 - other.0)
+    }
+
+    pub fn mul(&self, scalar: f32) -> Self {
+        Self(self.0 * scalar)
+    }
+
+    pub fn div(&self, scalar: f32) -> Self {
+        Self(self.0 / scalar)
+    }
+
+    pub fn distance(&self, other: &RubyVec3) -> f32 {
+        self.0.distance(other.0)
+    }
+
+    pub fn inner(&self) -> Vec3 {
+        self.0
+    }
+}
+
+impl From<Vec3> for RubyVec3 {
+    fn from(v: Vec3) -> Self {
+        Self(v)
+    }
+}
+
+impl From<RubyVec3> for Vec3 {
+    fn from(v: RubyVec3) -> Self {
+        v.0
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct RubyQuat(pub Quat);
+
+impl RubyQuat {
+    pub fn identity() -> Self {
+        Self(Quat::IDENTITY)
+    }
+
+    pub fn from_axis_angle(axis: &RubyVec3, angle: f32) -> Self {
+        Self(Quat::from_axis_angle(axis.0, angle))
+    }
+
+    pub fn from_euler(x: f32, y: f32, z: f32) -> Self {
+        Self(Quat::from_euler(bevy_math::EulerRot::XYZ, x, y, z))
+    }
+
+    pub fn from_rotation_x(angle: f32) -> Self {
+        Self(Quat::from_rotation_x(angle))
+    }
+
+    pub fn from_rotation_y(angle: f32) -> Self {
+        Self(Quat::from_rotation_y(angle))
+    }
+
+    pub fn from_rotation_z(angle: f32) -> Self {
+        Self(Quat::from_rotation_z(angle))
+    }
+
+    pub fn x(&self) -> f32 {
+        self.0.x
+    }
+
+    pub fn y(&self) -> f32 {
+        self.0.y
+    }
+
+    pub fn z(&self) -> f32 {
+        self.0.z
+    }
+
+    pub fn w(&self) -> f32 {
+        self.0.w
+    }
+
+    pub fn normalize(&self) -> Self {
+        Self(self.0.normalize())
+    }
+
+    pub fn inverse(&self) -> Self {
+        Self(self.0.inverse())
+    }
+
+    pub fn mul(&self, other: &RubyQuat) -> Self {
+        Self(self.0 * other.0)
+    }
+
+    pub fn mul_vec3(&self, v: &RubyVec3) -> RubyVec3 {
+        RubyVec3(self.0 * v.0)
+    }
+
+    pub fn inner(&self) -> Quat {
+        self.0
+    }
+}
+
+impl From<Quat> for RubyQuat {
+    fn from(q: Quat) -> Self {
+        Self(q)
+    }
+}
+
+impl From<RubyQuat> for Quat {
+    fn from(q: RubyQuat) -> Self {
+        q.0
+    }
+}

data/crates/bevy/src/types/mod.rs

@@ -0,0 +1,9 @@
+pub mod color;
+pub mod dynamic;
+pub mod math;
+pub mod transform;
+
+pub use color::RubyColor;
+pub use dynamic::{DynamicComponent, DynamicComponents, DynamicValue};
+pub use math::{RubyQuat, RubyVec2, RubyVec3};
+pub use transform::RubyTransform;

data/crates/bevy/src/types/transform.rs

@@ -0,0 +1,166 @@
+use bevy_math::{Quat, Vec3};
+use bevy_transform::components::Transform;
+use crate::types::math::{RubyQuat, RubyVec3};
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct RubyTransform(pub Transform);
+
+impl RubyTransform {
+    pub fn new() -> Self {
+        Self(Transform::IDENTITY)
+    }
+
+    pub fn from_translation(translation: RubyVec3) -> Self {
+        Self(Transform::from_translation(translation.inner()))
+    }
+
+    pub fn from_xyz(x: f32, y: f32, z: f32) -> Self {
+        Self(Transform::from_xyz(x, y, z))
+    }
+
+    pub fn from_rotation(rotation: RubyQuat) -> Self {
+        Self(Transform::from_rotation(rotation.inner()))
+    }
+
+    pub fn from_scale(scale: RubyVec3) -> Self {
+        Self(Transform::from_scale(scale.inner()))
+    }
+
+    pub fn from_translation_rotation(translation: RubyVec3, rotation: RubyQuat) -> Self {
+        Self(Transform {
+            translation: translation.inner(),
+            rotation: rotation.inner(),
+            scale: Vec3::ONE,
+        })
+    }
+
+    pub fn from_translation_rotation_scale(
+        translation: RubyVec3,
+        rotation: RubyQuat,
+        scale: RubyVec3,
+    ) -> Self {
+        Self(Transform {
+            translation: translation.inner(),
+            rotation: rotation.inner(),
+            scale: scale.inner(),
+        })
+    }
+
+    pub fn identity() -> Self {
+        Self(Transform::IDENTITY)
+    }
+
+    pub fn translation(&self) -> RubyVec3 {
+        RubyVec3::from(self.0.translation)
+    }
+
+    pub fn rotation(&self) -> RubyQuat {
+        RubyQuat::from(self.0.rotation)
+    }
+
+    pub fn scale(&self) -> RubyVec3 {
+        RubyVec3::from(self.0.scale)
+    }
+
+    pub fn set_translation(&mut self, translation: RubyVec3) {
+        self.0.translation = translation.inner();
+    }
+
+    pub fn set_rotation(&mut self, rotation: RubyQuat) {
+        self.0.rotation = rotation.inner();
+    }
+
+    pub fn set_scale(&mut self, scale: RubyVec3) {
+        self.0.scale = scale.inner();
+    }
+
+    pub fn translate(&mut self, delta: RubyVec3) {
+        self.0.translation += delta.inner();
+    }
+
+    pub fn rotate(&mut self, rotation: RubyQuat) {
+        self.0.rotation = rotation.inner() * self.0.rotation;
+    }
+
+    pub fn rotate_x(&mut self, angle: f32) {
+        self.0.rotate_x(angle);
+    }
+
+    pub fn rotate_y(&mut self, angle: f32) {
+        self.0.rotate_y(angle);
+    }
+
+    pub fn rotate_z(&mut self, angle: f32) {
+        self.0.rotate_z(angle);
+    }
+
+    pub fn rotate_local_x(&mut self, angle: f32) {
+        self.0.rotate_local_x(angle);
+    }
+
+    pub fn rotate_local_y(&mut self, angle: f32) {
+        self.0.rotate_local_y(angle);
+    }
+
+    pub fn rotate_local_z(&mut self, angle: f32) {
+        self.0.rotate_local_z(angle);
+    }
+
+    pub fn look_at(&mut self, target: RubyVec3, up: RubyVec3) {
+        self.0.look_at(target.inner(), up.inner());
+    }
+
+    pub fn forward(&self) -> RubyVec3 {
+        RubyVec3::from(*self.0.forward())
+    }
+
+    pub fn back(&self) -> RubyVec3 {
+        RubyVec3::from(*self.0.back())
+    }
+
+    pub fn left(&self) -> RubyVec3 {
+        RubyVec3::from(*self.0.left())
+    }
+
+    pub fn right(&self) -> RubyVec3 {
+        RubyVec3::from(*self.0.right())
+    }
+
+    pub fn up(&self) -> RubyVec3 {
+        RubyVec3::from(*self.0.up())
+    }
+
+    pub fn down(&self) -> RubyVec3 {
+        RubyVec3::from(*self.0.down())
+    }
+
+    pub fn mul(&self, other: &RubyTransform) -> Self {
+        Self(self.0 * other.0)
+    }
+
+    pub fn transform_point(&self, point: RubyVec3) -> RubyVec3 {
+        RubyVec3::from(self.0.transform_point(point.inner()))
+    }
+
+    pub fn inner(&self) -> Transform {
+        self.0
+    }
+}
+
+impl Default for RubyTransform {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl From<Transform> for RubyTransform {
+    fn from(t: Transform) -> Self {
+        Self(t)
+    }
+}
+
+impl From<RubyTransform> for Transform {
+    fn from(t: RubyTransform) -> Self {
+        t.0
+    }
+}

data/crates/bevy/src/world.rs

@@ -0,0 +1,163 @@
+use crate::component::ComponentRegistry;
+use crate::entity::EntityWrapper;
+use crate::error::BevyRubyError;
+use crate::types::{DynamicComponent, DynamicComponents};
+use bevy_ecs::world::World;
+use std::cell::RefCell;
+use std::sync::Arc;
+
+pub struct WorldWrapper {
+    world: RefCell<World>,
+    registry: Arc<ComponentRegistry>,
+}
+
+impl WorldWrapper {
+    pub fn new() -> Self {
+        Self {
+            world: RefCell::new(World::new()),
+            registry: ComponentRegistry::new(),
+        }
+    }
+
+    pub fn with_registry(registry: Arc<ComponentRegistry>) -> Self {
+        Self {
+            world: RefCell::new(World::new()),
+            registry,
+        }
+    }
+
+    pub fn spawn(&self) -> EntityWrapper {
+        let entity = self.world.borrow_mut().spawn_empty().id();
+        EntityWrapper::new(entity)
+    }
+
+    pub fn spawn_with_component(&self, component: DynamicComponent) -> EntityWrapper {
+        let mut components = DynamicComponents::new();
+        components.add(component);
+        let entity = self.world.borrow_mut().spawn(components).id();
+        EntityWrapper::new(entity)
+    }
+
+    pub fn spawn_with_components(&self, component_list: Vec<DynamicComponent>) -> EntityWrapper {
+        let mut components = DynamicComponents::new();
+        for component in component_list {
+            components.add(component);
+        }
+        let entity = self.world.borrow_mut().spawn(components).id();
+        EntityWrapper::new(entity)
+    }
+
+    pub fn despawn(&self, entity: EntityWrapper) -> Result<(), BevyRubyError> {
+        let mut world = self.world.borrow_mut();
+        if world.get_entity(entity.inner()).is_ok() {
+            world.despawn(entity.inner());
+            Ok(())
+        } else {
+            Err(BevyRubyError::EntityNotFound(entity.inner()))
+        }
+    }
+
+    pub fn entity_exists(&self, entity: EntityWrapper) -> bool {
+        self.world.borrow().get_entity(entity.inner()).is_ok()
+    }
+
+    pub fn insert_component(
+        &self,
+        entity: EntityWrapper,
+        component: DynamicComponent,
+    ) -> Result<(), BevyRubyError> {
+        let mut world = self.world.borrow_mut();
+        match world.get_entity_mut(entity.inner()) {
+            Ok(mut entity_mut) => {
+                if let Some(mut components) = entity_mut.get_mut::<DynamicComponents>() {
+                    components.add(component);
+                } else {
+                    let mut components = DynamicComponents::new();
+                    components.add(component);
+                    entity_mut.insert(components);
+                }
+                Ok(())
+            }
+            Err(_) => Err(BevyRubyError::EntityNotFound(entity.inner())),
+        }
+    }
+
+    pub fn get_component(
+        &self,
+        entity: EntityWrapper,
+        type_name: &str,
+    ) -> Result<DynamicComponent, BevyRubyError> {
+        let world = self.world.borrow();
+        match world.get_entity(entity.inner()) {
+            Ok(entity_ref) => {
+                if let Some(components) = entity_ref.get::<DynamicComponents>() {
+                    components.get(type_name).cloned().ok_or_else(|| {
+                        BevyRubyError::ComponentNotFound {
+                            entity: entity.inner(),
+                            component: type_name.to_string(),
+                        }
+                    })
+                } else {
+                    Err(BevyRubyError::ComponentNotFound {
+                        entity: entity.inner(),
+                        component: type_name.to_string(),
+                    })
+                }
+            }
+            Err(_) => Err(BevyRubyError::EntityNotFound(entity.inner())),
+        }
+    }
+
+    pub fn has_component(&self, entity: EntityWrapper, type_name: &str) -> bool {
+        let world = self.world.borrow();
+        match world.get_entity(entity.inner()) {
+            Ok(entity_ref) => {
+                if let Some(components) = entity_ref.get::<DynamicComponents>() {
+                    components.has(type_name)
+                } else {
+                    false
+                }
+            }
+            Err(_) => false,
+        }
+    }
+
+    pub fn query_entities_with(&self, type_names: &[&str]) -> Vec<EntityWrapper> {
+        let world = self.world.borrow();
+        let mut result = Vec::new();
+
+        for entity in world.iter_entities() {
+            if let Some(components) = entity.get::<DynamicComponents>() {
+                if components.has_all(type_names) {
+                    result.push(EntityWrapper::new(entity.id()));
+                }
+            }
+        }
+
+        result
+    }
+
+    pub fn registry(&self) -> &Arc<ComponentRegistry> {
+        &self.registry
+    }
+
+    pub fn with_world<F, R>(&self, f: F) -> R
+    where
+        F: FnOnce(&World) -> R,
+    {
+        f(&self.world.borrow())
+    }
+
+    pub fn with_world_mut<F, R>(&self, f: F) -> R
+    where
+        F: FnOnce(&mut World) -> R,
+    {
+        f(&mut self.world.borrow_mut())
+    }
+}
+
+impl Default for WorldWrapper {
+    fn default() -> Self {
+        Self::new()
+    }
+}

data/crates/bevy_ruby_render/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "bevy-ruby-render"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+
+[dependencies]
+bevy_ecs.workspace = true
+bevy_app.workspace = true
+bevy_math.workspace = true
+bevy_transform.workspace = true
+bevy_color.workspace = true
+bevy_render = { workspace = true }
+bevy_sprite = { workspace = true }
+bevy_window.workspace = true
+bevy_core_pipeline = { workspace = true }
+bevy_asset.workspace = true
+bevy_hierarchy.workspace = true
+bevy_image.workspace = true
+bevy_text = { workspace = true }
+bevy_prototype_lyon.workspace = true