bevy 1.0.0

data/crates/bevy/src/text_renderer.rs

@@ -0,0 +1,258 @@
+//! Text renderer module for synchronizing Ruby text entities with Bevy.
+
+use std::collections::HashMap;
+
+#[cfg(feature = "rendering")]
+use bevy_color::Color;
+#[cfg(feature = "rendering")]
+use bevy_ecs::entity::Entity;
+#[cfg(feature = "rendering")]
+use bevy_ecs::world::World;
+#[cfg(feature = "rendering")]
+use bevy_render::view::{InheritedVisibility, ViewVisibility, Visibility};
+#[cfg(feature = "rendering")]
+use bevy_text::{Text2d, TextColor, TextFont};
+#[cfg(feature = "rendering")]
+use bevy_transform::components::{GlobalTransform, Transform};
+
+#[derive(Debug, Clone)]
+pub struct TextData {
+    pub content: String,
+    pub font_size: f32,
+    pub color_r: f32,
+    pub color_g: f32,
+    pub color_b: f32,
+    pub color_a: f32,
+}
+
+impl Default for TextData {
+    fn default() -> Self {
+        Self {
+            content: String::new(),
+            font_size: 24.0,
+            color_r: 1.0,
+            color_g: 1.0,
+            color_b: 1.0,
+            color_a: 1.0,
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct TextTransformData {
+    pub translation_x: f32,
+    pub translation_y: f32,
+    pub translation_z: f32,
+    pub scale_x: f32,
+    pub scale_y: f32,
+    pub scale_z: f32,
+}
+
+impl Default for TextTransformData {
+    fn default() -> Self {
+        Self {
+            translation_x: 0.0,
+            translation_y: 0.0,
+            translation_z: 0.0,
+            scale_x: 1.0,
+            scale_y: 1.0,
+            scale_z: 1.0,
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum TextOperation {
+    Sync {
+        ruby_entity_id: u64,
+        text_data: TextData,
+        transform_data: TextTransformData,
+    },
+    Remove {
+        ruby_entity_id: u64,
+    },
+    Clear,
+}
+
+pub struct TextSync {
+    entity_map: HashMap<u64, TextEntityData>,
+    pub pending_operations: Vec<TextOperation>,
+}
+
+struct TextEntityData {
+    #[cfg(feature = "rendering")]
+    bevy_entity: Entity,
+    #[cfg(not(feature = "rendering"))]
+    _phantom: (),
+}
+
+impl TextSync {
+    pub fn new() -> Self {
+        Self {
+            entity_map: HashMap::new(),
+            pending_operations: Vec::new(),
+        }
+    }
+
+    pub fn sync_text_standalone(
+        &mut self,
+        ruby_entity_id: u64,
+        text_data: &TextData,
+        transform_data: &TextTransformData,
+    ) {
+        self.pending_operations.push(TextOperation::Sync {
+            ruby_entity_id,
+            text_data: text_data.clone(),
+            transform_data: transform_data.clone(),
+        });
+    }
+
+    pub fn remove_text_standalone(&mut self, ruby_entity_id: u64) {
+        self.pending_operations
+            .push(TextOperation::Remove { ruby_entity_id });
+    }
+
+    pub fn clear_standalone(&mut self) {
+        self.pending_operations.push(TextOperation::Clear);
+    }
+
+    #[cfg(feature = "rendering")]
+    pub fn apply_pending(&mut self, world: &mut World) {
+        let ops: Vec<_> = self.pending_operations.drain(..).collect();
+        for op in ops {
+            match op {
+                TextOperation::Sync {
+                    ruby_entity_id,
+                    text_data,
+                    transform_data,
+                } => {
+                    self.sync_text(world, ruby_entity_id, &text_data, &transform_data);
+                }
+                TextOperation::Remove { ruby_entity_id } => {
+                    self.remove_text(world, ruby_entity_id);
+                }
+                TextOperation::Clear => {
+                    self.clear(world);
+                }
+            }
+        }
+    }
+
+    #[cfg(not(feature = "rendering"))]
+    pub fn apply_pending(&mut self, _world: &mut ()) {
+        self.pending_operations.clear();
+    }
+
+    #[cfg(feature = "rendering")]
+    pub fn sync_text(
+        &mut self,
+        world: &mut World,
+        ruby_entity_id: u64,
+        text_data: &TextData,
+        transform_data: &TextTransformData,
+    ) {
+        let color = Color::srgba(
+            text_data.color_r,
+            text_data.color_g,
+            text_data.color_b,
+            text_data.color_a,
+        );
+
+        let transform = Transform {
+            translation: bevy_math::Vec3::new(
+                transform_data.translation_x,
+                transform_data.translation_y,
+                transform_data.translation_z,
+            ),
+            rotation: bevy_math::Quat::IDENTITY,
+            scale: bevy_math::Vec3::new(
+                transform_data.scale_x,
+                transform_data.scale_y,
+                transform_data.scale_z,
+            ),
+        };
+
+        if let Some(entity_data) = self.entity_map.get(&ruby_entity_id) {
+            let bevy_entity = entity_data.bevy_entity;
+
+            if let Some(mut text) = world.get_mut::<Text2d>(bevy_entity) {
+                **text = text_data.content.clone();
+            }
+
+            if let Some(mut text_color) = world.get_mut::<TextColor>(bevy_entity) {
+                text_color.0 = color;
+            }
+
+            if let Some(mut font) = world.get_mut::<TextFont>(bevy_entity) {
+                font.font_size = text_data.font_size;
+            }
+
+            if let Some(mut t) = world.get_mut::<Transform>(bevy_entity) {
+                *t = transform;
+            }
+        } else {
+            let bevy_entity = world
+                .spawn((
+                    Text2d::new(text_data.content.clone()),
+                    TextFont {
+                        font_size: text_data.font_size,
+                        ..Default::default()
+                    },
+                    TextColor(color),
+                    transform,
+                    GlobalTransform::default(),
+                    Visibility::default(),
+                    InheritedVisibility::default(),
+                    ViewVisibility::default(),
+                ))
+                .id();
+
+            self.entity_map
+                .insert(ruby_entity_id, TextEntityData { bevy_entity });
+        }
+    }
+
+    #[cfg(feature = "rendering")]
+    pub fn remove_text(&mut self, world: &mut World, ruby_entity_id: u64) {
+        if let Some(entity_data) = self.entity_map.remove(&ruby_entity_id) {
+            world.despawn(entity_data.bevy_entity);
+        }
+    }
+
+    #[cfg(feature = "rendering")]
+    pub fn clear(&mut self, world: &mut World) {
+        for (_, entity_data) in self.entity_map.drain() {
+            world.despawn(entity_data.bevy_entity);
+        }
+    }
+
+    pub fn len(&self) -> usize {
+        self.entity_map.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.entity_map.is_empty()
+    }
+
+    #[cfg(not(feature = "rendering"))]
+    pub fn sync_text(
+        &mut self,
+        _world: &mut (),
+        _ruby_entity_id: u64,
+        _text_data: &TextData,
+        _transform_data: &TextTransformData,
+    ) {
+    }
+
+    #[cfg(not(feature = "rendering"))]
+    pub fn remove_text(&mut self, _world: &mut (), _ruby_entity_id: u64) {}
+
+    #[cfg(not(feature = "rendering"))]
+    pub fn clear(&mut self, _world: &mut ()) {}
+}
+
+impl Default for TextSync {
+    fn default() -> Self {
+        Self::new()
+    }
+}

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

@@ -0,0 +1,114 @@
+use bevy_color::{Alpha, Color, Srgba};
+
+#[derive(Debug, Clone, Copy)]
+pub struct RubyColor {
+    inner: Srgba,
+}
+
+impl RubyColor {
+    pub fn new(r: f32, g: f32, b: f32, a: f32) -> Self {
+        Self {
+            inner: Srgba::new(r, g, b, a),
+        }
+    }
+
+    pub fn rgb(r: f32, g: f32, b: f32) -> Self {
+        Self::new(r, g, b, 1.0)
+    }
+
+    pub fn rgba(r: f32, g: f32, b: f32, a: f32) -> Self {
+        Self::new(r, g, b, a)
+    }
+
+    pub fn from_hex(hex: &str) -> Option<Self> {
+        Srgba::hex(hex).ok().map(|c| Self { inner: c })
+    }
+
+    pub fn white() -> Self {
+        Self::new(1.0, 1.0, 1.0, 1.0)
+    }
+
+    pub fn black() -> Self {
+        Self::new(0.0, 0.0, 0.0, 1.0)
+    }
+
+    pub fn red() -> Self {
+        Self::new(1.0, 0.0, 0.0, 1.0)
+    }
+
+    pub fn green() -> Self {
+        Self::new(0.0, 1.0, 0.0, 1.0)
+    }
+
+    pub fn blue() -> Self {
+        Self::new(0.0, 0.0, 1.0, 1.0)
+    }
+
+    pub fn transparent() -> Self {
+        Self::new(0.0, 0.0, 0.0, 0.0)
+    }
+
+    pub fn r(&self) -> f32 {
+        self.inner.red
+    }
+
+    pub fn g(&self) -> f32 {
+        self.inner.green
+    }
+
+    pub fn b(&self) -> f32 {
+        self.inner.blue
+    }
+
+    pub fn a(&self) -> f32 {
+        self.inner.alpha
+    }
+
+    pub fn set_r(&mut self, r: f32) {
+        self.inner.red = r;
+    }
+
+    pub fn set_g(&mut self, g: f32) {
+        self.inner.green = g;
+    }
+
+    pub fn set_b(&mut self, b: f32) {
+        self.inner.blue = b;
+    }
+
+    pub fn set_a(&mut self, a: f32) {
+        self.inner.alpha = a;
+    }
+
+    pub fn with_alpha(&self, alpha: f32) -> Self {
+        Self {
+            inner: self.inner.with_alpha(alpha),
+        }
+    }
+
+    pub fn to_bevy(&self) -> Color {
+        Color::Srgba(self.inner)
+    }
+
+    pub fn to_srgba(&self) -> Srgba {
+        self.inner
+    }
+
+    pub fn to_array(&self) -> [f32; 4] {
+        [self.inner.red, self.inner.green, self.inner.blue, self.inner.alpha]
+    }
+}
+
+impl From<Srgba> for RubyColor {
+    fn from(color: Srgba) -> Self {
+        Self { inner: color }
+    }
+}
+
+impl From<Color> for RubyColor {
+    fn from(color: Color) -> Self {
+        Self {
+            inner: color.to_srgba(),
+        }
+    }
+}

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

@@ -0,0 +1,131 @@
+use bevy_ecs::component::Component;
+use std::collections::HashMap;
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum DynamicValue {
+    Nil,
+    Boolean(bool),
+    Integer(i64),
+    Float(f64),
+    String(String),
+    Symbol(String),
+    Array(Vec<DynamicValue>),
+    Hash(HashMap<String, DynamicValue>),
+}
+
+impl DynamicValue {
+    pub fn as_bool(&self) -> Option<bool> {
+        match self {
+            DynamicValue::Boolean(v) => Some(*v),
+            _ => None,
+        }
+    }
+
+    pub fn as_i64(&self) -> Option<i64> {
+        match self {
+            DynamicValue::Integer(v) => Some(*v),
+            _ => None,
+        }
+    }
+
+    pub fn as_f64(&self) -> Option<f64> {
+        match self {
+            DynamicValue::Float(v) => Some(*v),
+            DynamicValue::Integer(v) => Some(*v as f64),
+            _ => None,
+        }
+    }
+
+    pub fn as_str(&self) -> Option<&str> {
+        match self {
+            DynamicValue::String(v) => Some(v),
+            DynamicValue::Symbol(v) => Some(v),
+            _ => None,
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct DynamicComponent {
+    pub type_name: String,
+    pub data: HashMap<String, DynamicValue>,
+}
+
+impl DynamicComponent {
+    pub fn new(type_name: &str) -> Self {
+        Self {
+            type_name: type_name.to_string(),
+            data: HashMap::new(),
+        }
+    }
+
+    pub fn with_field(mut self, name: &str, value: DynamicValue) -> Self {
+        self.data.insert(name.to_string(), value);
+        self
+    }
+
+    pub fn set(&mut self, name: &str, value: DynamicValue) {
+        self.data.insert(name.to_string(), value);
+    }
+
+    pub fn get(&self, name: &str) -> Option<&DynamicValue> {
+        self.data.get(name)
+    }
+
+    pub fn type_name(&self) -> &str {
+        &self.type_name
+    }
+}
+
+#[derive(Debug, Clone, Component, Default)]
+pub struct DynamicComponents {
+    components: Vec<DynamicComponent>,
+}
+
+impl DynamicComponents {
+    pub fn new() -> Self {
+        Self {
+            components: Vec::new(),
+        }
+    }
+
+    pub fn add(&mut self, component: DynamicComponent) {
+        let type_name = component.type_name.clone();
+        self.components.retain(|c| c.type_name != type_name);
+        self.components.push(component);
+    }
+
+    pub fn get(&self, type_name: &str) -> Option<&DynamicComponent> {
+        self.components.iter().find(|c| c.type_name == type_name)
+    }
+
+    pub fn get_mut(&mut self, type_name: &str) -> Option<&mut DynamicComponent> {
+        self.components
+            .iter_mut()
+            .find(|c| c.type_name == type_name)
+    }
+
+    pub fn has(&self, type_name: &str) -> bool {
+        self.components.iter().any(|c| c.type_name == type_name)
+    }
+
+    pub fn has_all(&self, type_names: &[&str]) -> bool {
+        type_names.iter().all(|name| self.has(name))
+    }
+
+    pub fn remove(&mut self, type_name: &str) -> Option<DynamicComponent> {
+        let pos = self
+            .components
+            .iter()
+            .position(|c| c.type_name == type_name)?;
+        Some(self.components.remove(pos))
+    }
+
+    pub fn iter(&self) -> impl Iterator<Item = &DynamicComponent> {
+        self.components.iter()
+    }
+
+    pub fn type_names(&self) -> Vec<&str> {
+        self.components.iter().map(|c| c.type_name.as_str()).collect()
+    }
+}