bevy 1.0.0

data/Cargo.toml

@@ -0,0 +1,36 @@
+[workspace]
+members = ["crates/*", "ext/bevy"]
+resolver = "2"
+
+[workspace.package]
+version = "0.1.0"
+edition = "2024"
+license = "MIT OR Apache-2.0"
+repository = "https://github.com/ydah/bevy-ruby"
+
+[workspace.dependencies]
+bevy_ecs = "0.15"
+bevy_app = "0.15"
+bevy_math = "0.15"
+bevy_transform = "0.15"
+bevy_color = "0.15"
+bevy_render = { version = "0.15", default-features = false }
+bevy_sprite = { version = "0.15", default-features = false }
+bevy_window = "0.15"
+bevy_winit = "0.15"
+bevy_asset = "0.15"
+bevy_time = "0.15"
+bevy_input = "0.15"
+bevy_core_pipeline = { version = "0.15", default-features = false }
+bevy_hierarchy = "0.15"
+bevy_log = "0.15"
+bevy_core = "0.15"
+bevy_a11y = "0.15"
+bevy_image = "0.15"
+bevy_text = { version = "0.15", features = ["default_font"] }
+bevy_picking = "0.15"
+bevy_prototype_lyon = "0.13"
+magnus = "0.8"
+rb-sys = "0.9"
+parking_lot = "0.12"
+thiserror = "2"

data/README.md

@@ -0,0 +1,226 @@
+# Bevy Ruby
+
+Bevy bindings for Ruby, providing ECS-driven game/app architecture, 2D rendering sync, input bridging, and runtime interaction events.
+
+<img width="400" alt="Image" src="https://github.com/user-attachments/assets/440971a6-bf10-4cc2-abe6-e5cf28949b95" />
+
+## Status
+
+This project provides a practical, Bevy-compatible API surface in Ruby, with a mix of:
+
+- native-backed features through Rust + Bevy integration
+- Ruby convenience/DSL layers for ergonomic usage
+
+### Native-backed (current)
+
+- App/game loop integration (`App`, schedules, startup/update flow)
+- ECS bridge (`World`, `Entity`, dynamic component/resource/event plumbing)
+- Render bridge (window + camera + sync to Bevy scene)
+  - `Sprite`
+  - `Text2d`
+  - `Mesh` 2D primitives (rectangle/circle/regular polygon/line/ellipse)
+- Input bridge
+  - keyboard and mouse state
+  - gamepad state
+  - gamepad rumble forwarding (`RumbleRequest`)
+- Picking event bridge (`bevy_picking`)
+  - `over`, `out`, `down`, `up`, `click`
+
+### Ruby layer (current)
+
+- DSL and registries
+  - `ComponentDSL`
+  - `ResourceDSL`
+  - `EventDSL`
+  - `EventRegistry`, readers/writers
+- Runtime helpers
+  - `SystemContext` query/spawn/resource/event APIs
+  - input helper methods for keyboard/mouse/gamepad
+  - picking helper methods (`picking_events`, `picked?`)
+- Value and utility types
+  - `Vec2`, `Vec3`, `Quat`, `Transform`, `Color`
+  - `KeyboardInput`, `MouseInput`, `GamepadInput`, `Gamepads`, `DeadZone`
+
+### Native build note
+
+- The Rust backend currently targets Bevy `0.15`.
+- A number of high-level Ruby modules exist in `lib/bevy/*`, but not all are fully wired end-to-end in native Bevy systems yet (for example, parts of audio/scene/gltf/ui/shader/material-related areas).
+
+## Requirements
+
+- Ruby 3.2+
+- Rust toolchain (`rustc`, `cargo`) for native extension build
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'bevy'
+```
+
+Then run:
+
+```bash
+bundle install
+```
+
+## Installing Native Library
+
+This gem does not require installing a separate external runtime shared library.
+
+The native extension is built from this repository's Rust crates.
+
+### macOS
+
+```bash
+xcode-select --install
+bundle install
+bundle exec rake compile
+```
+
+### Linux
+
+```bash
+bundle install
+bundle exec rake compile
+```
+
+### Windows
+
+```powershell
+bundle install
+bundle exec rake compile
+```
+
+## Quick Start
+
+```ruby
+require 'bevy'
+
+class Velocity < Bevy::ComponentDSL
+  attribute :x, Float, default: 120.0
+end
+
+app = Bevy::App.new(
+  render: true,
+  window: { title: 'Bevy Ruby', width: 800.0, height: 600.0 }
+)
+
+app.add_startup_system do |ctx|
+  ctx.spawn(
+    Velocity.new,
+    Bevy::Transform.from_xyz(0.0, 0.0, 0.0),
+    Bevy::Sprite.new(
+      color: Bevy::Color.from_hex('#4ECDC4'),
+      custom_size: Bevy::Vec2.new(80.0, 80.0)
+    )
+  )
+end
+
+app.add_update_system do |ctx|
+  ctx.query(Velocity, Bevy::Transform) do |entity, vel, transform|
+    next_x = transform.translation.x + vel.x * ctx.delta
+    vel.x *= -1.0 if next_x > 360.0 || next_x < -360.0
+
+    ctx.world.insert_component(
+      entity,
+      transform.with_translation(Bevy::Vec3.new(transform.translation.x + vel.x * ctx.delta, 0.0, 0.0))
+    )
+  end
+
+  ctx.app.stop if ctx.key_pressed?('ESCAPE')
+end
+
+app.run
+```
+
+## Gamepad Rumble Example
+
+```ruby
+require 'bevy'
+
+app = Bevy::App.new(render: true)
+
+app.add_update_system do |ctx|
+  next unless ctx.any_gamepad_connected?
+
+  if ctx.gamepad_just_pressed?(Bevy::GamepadButton::SOUTH)
+    ctx.gamepad&.rumble(
+      Bevy::RumbleRequest.new(strong: 0.8, weak: 0.3, duration: 0.4)
+    )
+  end
+end
+
+app.run
+```
+
+## Picking Event Example
+
+```ruby
+require 'bevy'
+
+app = Bevy::App.new(render: true)
+
+app.add_update_system do |ctx|
+  ctx.picking_events(:click).each do |event|
+    puts "clicked target=#{event.target_id} button=#{event.button}"
+  end
+end
+
+app.run
+```
+
+## API Coverage (Bevy docs parity)
+
+| Area | Status | Notes |
+| --- | --- | --- |
+| ECS basics (`App`/`World`/entities/components/resources/events) | Implemented | Core loop and dynamic ECS bindings are available |
+| 2D render sync (`Sprite`/`Text2d`/`Mesh` shapes) | Implemented | Ruby-side component data is synchronized to Bevy |
+| Keyboard and mouse input | Implemented | Render loop input state is exposed through `SystemContext` |
+| Gamepad input + rumble | Implemented | State bridge plus `RumbleRequest` forwarding |
+| Picking events (`over`/`out`/`down`/`up`/`click`) | Implemented | Exposed as `Bevy::PickingEvent` |
+| Camera transform controls (2D) | Implemented | Position/scale helpers are available |
+| 3D/PBR-native workflows | Partial | Current bridge is primarily focused on 2D sync |
+| Asset/scene/gltf/audio/ui/full parity with upstream Bevy | Partial | Some APIs exist in Ruby, but native end-to-end wiring is incomplete in several domains |
+| Upstream Bevy version parity (`0.18+`/`main`) | Not implemented | Current backend target is Bevy `0.15` |
+
+## Development
+
+After checking out the repo, install dependencies:
+
+```bash
+bundle install
+```
+
+Build native extension:
+
+```bash
+bundle exec rake compile
+```
+
+Run tests:
+
+```bash
+bundle exec rake spec
+```
+
+Run examples:
+
+```bash
+bundle exec ruby examples/hello_world.rb
+bundle exec ruby examples/input_handling.rb
+bundle exec ruby examples/gamepad.rb
+bundle exec ruby examples/shapes_2d.rb
+bundle exec ruby examples/space_shooter.rb
+```
+
+## License
+
+This project is available under the [MIT License](LICENSE).
+
+## Contributing
+
+Bug reports and pull requests are welcome at:
+
+- https://github.com/ydah/bevy-ruby

data/crates/bevy/Cargo.toml

@@ -0,0 +1,52 @@
+[package]
+name = "bevy-ruby"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+
+[features]
+default = ["rendering"]
+rendering = [
+    "bevy_window",
+    "bevy_winit",
+    "bevy_render",
+    "bevy_sprite",
+    "bevy_core_pipeline",
+    "bevy_asset",
+    "bevy_hierarchy",
+    "bevy_log",
+    "bevy_core",
+    "bevy_a11y",
+    "bevy_image",
+    "bevy_text",
+    "bevy_picking",
+    "bevy_prototype_lyon",
+]
+
+[dependencies]
+bevy_ecs.workspace = true
+bevy_app.workspace = true
+bevy_math.workspace = true
+bevy_transform.workspace = true
+bevy_color.workspace = true
+bevy_time.workspace = true
+bevy_input.workspace = true
+parking_lot.workspace = true
+thiserror.workspace = true
+
+# Optional rendering dependencies
+bevy_window = { workspace = true, optional = true }
+bevy_winit = { workspace = true, optional = true, features = ["x11", "wayland"] }
+bevy_render = { workspace = true, optional = true }
+bevy_sprite = { workspace = true, optional = true }
+bevy_core_pipeline = { workspace = true, optional = true }
+bevy_asset = { workspace = true, optional = true }
+bevy_hierarchy = { workspace = true, optional = true }
+bevy_log = { workspace = true, optional = true }
+bevy_core = { workspace = true, optional = true }
+bevy_a11y = { workspace = true, optional = true }
+bevy_image = { workspace = true, optional = true }
+bevy_text = { workspace = true, optional = true, features = ["default_font"] }
+bevy_picking = { workspace = true, optional = true }
+bevy_prototype_lyon = { workspace = true, optional = true }

data/crates/bevy/src/app.rs

@@ -0,0 +1,43 @@
+use crate::component::ComponentRegistry;
+use crate::system::{ScheduleLabel, SystemDescriptor};
+use crate::world::WorldWrapper;
+use std::sync::Arc;
+
+pub struct AppBuilder {
+    registry: Arc<ComponentRegistry>,
+    systems: Vec<SystemDescriptor>,
+}
+
+impl AppBuilder {
+    pub fn new() -> Self {
+        Self {
+            registry: ComponentRegistry::new(),
+            systems: Vec::new(),
+        }
+    }
+
+    pub fn registry(&self) -> &Arc<ComponentRegistry> {
+        &self.registry
+    }
+
+    pub fn add_system(&mut self, descriptor: SystemDescriptor) {
+        self.systems.push(descriptor);
+    }
+
+    pub fn systems_for_schedule(&self, schedule: ScheduleLabel) -> Vec<&SystemDescriptor> {
+        self.systems
+            .iter()
+            .filter(|s| s.schedule == schedule)
+            .collect()
+    }
+
+    pub fn create_world(&self) -> WorldWrapper {
+        WorldWrapper::with_registry(Arc::clone(&self.registry))
+    }
+}
+
+impl Default for AppBuilder {
+    fn default() -> Self {
+        Self::new()
+    }
+}

data/crates/bevy/src/component.rs

@@ -0,0 +1,111 @@
+use bevy_ecs::component::ComponentId;
+use parking_lot::RwLock;
+use std::any::TypeId;
+use std::collections::HashMap;
+use std::sync::Arc;
+
+#[derive(Debug, Clone)]
+pub struct AttributeDescriptor {
+    pub name: String,
+    pub attr_type: AttributeType,
+    pub default_value: Option<Vec<u8>>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum AttributeType {
+    Integer,
+    Float,
+    Boolean,
+    String,
+    Vec2,
+    Vec3,
+    Quat,
+    Entity,
+}
+
+#[derive(Debug, Clone)]
+pub struct ComponentMetadata {
+    pub name: String,
+    pub attributes: Vec<AttributeDescriptor>,
+}
+
+#[derive(Debug, Clone)]
+pub struct ComponentData {
+    pub metadata: ComponentMetadata,
+    pub data: HashMap<String, Vec<u8>>,
+}
+
+impl ComponentData {
+    pub fn new(name: &str) -> Self {
+        Self {
+            metadata: ComponentMetadata {
+                name: name.to_string(),
+                attributes: Vec::new(),
+            },
+            data: HashMap::new(),
+        }
+    }
+
+    pub fn with_attribute(mut self, name: &str, attr_type: AttributeType) -> Self {
+        self.metadata.attributes.push(AttributeDescriptor {
+            name: name.to_string(),
+            attr_type,
+            default_value: None,
+        });
+        self
+    }
+
+    pub fn set_data(&mut self, name: &str, data: Vec<u8>) {
+        self.data.insert(name.to_string(), data);
+    }
+
+    pub fn get_data(&self, name: &str) -> Option<&Vec<u8>> {
+        self.data.get(name)
+    }
+}
+
+pub struct ComponentRegistry {
+    name_to_id: RwLock<HashMap<String, ComponentId>>,
+    id_to_metadata: RwLock<HashMap<ComponentId, ComponentMetadata>>,
+    #[allow(dead_code)]
+    type_to_id: RwLock<HashMap<TypeId, ComponentId>>,
+}
+
+impl ComponentRegistry {
+    pub fn new() -> Arc<Self> {
+        Arc::new(Self {
+            name_to_id: RwLock::new(HashMap::new()),
+            id_to_metadata: RwLock::new(HashMap::new()),
+            type_to_id: RwLock::new(HashMap::new()),
+        })
+    }
+
+    pub fn register(&self, name: &str, component_id: ComponentId, metadata: ComponentMetadata) {
+        self.name_to_id
+            .write()
+            .insert(name.to_string(), component_id);
+        self.id_to_metadata.write().insert(component_id, metadata);
+    }
+
+    pub fn get_id(&self, name: &str) -> Option<ComponentId> {
+        self.name_to_id.read().get(name).copied()
+    }
+
+    pub fn get_metadata(&self, id: ComponentId) -> Option<ComponentMetadata> {
+        self.id_to_metadata.read().get(&id).cloned()
+    }
+
+    pub fn is_registered(&self, name: &str) -> bool {
+        self.name_to_id.read().contains_key(name)
+    }
+}
+
+impl Default for ComponentRegistry {
+    fn default() -> Self {
+        Self {
+            name_to_id: RwLock::new(HashMap::new()),
+            id_to_metadata: RwLock::new(HashMap::new()),
+            type_to_id: RwLock::new(HashMap::new()),
+        }
+    }
+}

data/crates/bevy/src/entity.rs

@@ -0,0 +1,30 @@
+use bevy_ecs::entity::Entity;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct EntityWrapper(pub Entity);
+
+impl EntityWrapper {
+    pub fn new(entity: Entity) -> Self {
+        Self(entity)
+    }
+
+    pub fn id(&self) -> u64 {
+        self.0.to_bits()
+    }
+
+    pub fn inner(&self) -> Entity {
+        self.0
+    }
+}
+
+impl From<Entity> for EntityWrapper {
+    fn from(entity: Entity) -> Self {
+        Self(entity)
+    }
+}
+
+impl From<EntityWrapper> for Entity {
+    fn from(wrapper: EntityWrapper) -> Self {
+        wrapper.0
+    }
+}

data/crates/bevy/src/error.rs

@@ -0,0 +1,32 @@
+use bevy_ecs::entity::Entity;
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum BevyRubyError {
+    #[error("Entity {0:?} not found")]
+    EntityNotFound(Entity),
+
+    #[error("Component '{component}' not found on entity {entity:?}")]
+    ComponentNotFound { entity: Entity, component: String },
+
+    #[error("Component '{0}' already exists")]
+    ComponentAlreadyExists(String),
+
+    #[error("Resource '{0}' not found")]
+    ResourceNotFound(String),
+
+    #[error("Resource '{0}' already exists")]
+    ResourceAlreadyExists(String),
+
+    #[error("Component '{0}' is not registered")]
+    ComponentNotRegistered(String),
+
+    #[error("Invalid type conversion: expected {expected}, got {actual}")]
+    InvalidType { expected: String, actual: String },
+
+    #[error("System error: {0}")]
+    SystemError(String),
+
+    #[error("World is not available")]
+    WorldNotAvailable,
+}