bevy 1.0.0

data/crates/bevy_ruby_render/src/sprite.rs

@@ -0,0 +1,289 @@
+use bevy_color::Color;
+use bevy_ecs::entity::Entity;
+use bevy_ecs::world::World;
+use bevy_math::Vec2;
+use bevy_sprite::Sprite;
+use bevy_transform::components::Transform;
+use std::collections::HashMap;
+
+#[derive(Debug, Clone)]
+pub struct SpriteData {
+    pub color_r: f32,
+    pub color_g: f32,
+    pub color_b: f32,
+    pub color_a: f32,
+    pub flip_x: bool,
+    pub flip_y: bool,
+    pub anchor_x: f32,
+    pub anchor_y: f32,
+    pub has_custom_size: bool,
+    pub custom_size_x: f32,
+    pub custom_size_y: f32,
+}
+
+impl Default for SpriteData {
+    fn default() -> Self {
+        Self {
+            color_r: 1.0,
+            color_g: 1.0,
+            color_b: 1.0,
+            color_a: 1.0,
+            flip_x: false,
+            flip_y: false,
+            anchor_x: 0.5,
+            anchor_y: 0.5,
+            has_custom_size: false,
+            custom_size_x: 0.0,
+            custom_size_y: 0.0,
+        }
+    }
+}
+
+impl SpriteData {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn with_color(mut self, r: f32, g: f32, b: f32, a: f32) -> Self {
+        self.color_r = r;
+        self.color_g = g;
+        self.color_b = b;
+        self.color_a = a;
+        self
+    }
+
+    pub fn with_size(mut self, width: f32, height: f32) -> Self {
+        self.has_custom_size = true;
+        self.custom_size_x = width;
+        self.custom_size_y = height;
+        self
+    }
+
+    pub fn with_flip(mut self, flip_x: bool, flip_y: bool) -> Self {
+        self.flip_x = flip_x;
+        self.flip_y = flip_y;
+        self
+    }
+
+    pub fn to_bevy_color(&self) -> Color {
+        Color::srgba(self.color_r, self.color_g, self.color_b, self.color_a)
+    }
+
+    pub fn custom_size(&self) -> Option<Vec2> {
+        if self.has_custom_size {
+            Some(Vec2::new(self.custom_size_x, self.custom_size_y))
+        } else {
+            None
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct TransformData {
+    pub translation_x: f32,
+    pub translation_y: f32,
+    pub translation_z: f32,
+    pub rotation_x: f32,
+    pub rotation_y: f32,
+    pub rotation_z: f32,
+    pub rotation_w: f32,
+    pub scale_x: f32,
+    pub scale_y: f32,
+    pub scale_z: f32,
+}
+
+impl Default for TransformData {
+    fn default() -> Self {
+        Self {
+            translation_x: 0.0,
+            translation_y: 0.0,
+            translation_z: 0.0,
+            rotation_x: 0.0,
+            rotation_y: 0.0,
+            rotation_z: 0.0,
+            rotation_w: 1.0,
+            scale_x: 1.0,
+            scale_y: 1.0,
+            scale_z: 1.0,
+        }
+    }
+}
+
+impl TransformData {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn from_xyz(x: f32, y: f32, z: f32) -> Self {
+        Self {
+            translation_x: x,
+            translation_y: y,
+            translation_z: z,
+            ..Default::default()
+        }
+    }
+
+    pub fn to_bevy_transform(&self) -> Transform {
+        Transform {
+            translation: bevy_math::Vec3::new(
+                self.translation_x,
+                self.translation_y,
+                self.translation_z,
+            ),
+            rotation: bevy_math::Quat::from_xyzw(
+                self.rotation_x,
+                self.rotation_y,
+                self.rotation_z,
+                self.rotation_w,
+            ),
+            scale: bevy_math::Vec3::new(self.scale_x, self.scale_y, self.scale_z),
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum SpriteOperation {
+    Sync {
+        ruby_entity_id: u64,
+        sprite_data: SpriteData,
+        transform_data: TransformData,
+    },
+    Remove {
+        ruby_entity_id: u64,
+    },
+    Clear,
+}
+
+struct EntityData {
+    bevy_entity: Entity,
+}
+
+pub struct SpriteSync {
+    entity_map: HashMap<u64, EntityData>,
+    pub pending_operations: Vec<SpriteOperation>,
+}
+
+impl SpriteSync {
+    pub fn new() -> Self {
+        Self {
+            entity_map: HashMap::new(),
+            pending_operations: Vec::new(),
+        }
+    }
+
+    pub fn sync_sprite_standalone(
+        &mut self,
+        ruby_entity_id: u64,
+        sprite_data: &SpriteData,
+        transform_data: &TransformData,
+    ) {
+        self.pending_operations.push(SpriteOperation::Sync {
+            ruby_entity_id,
+            sprite_data: sprite_data.clone(),
+            transform_data: transform_data.clone(),
+        });
+    }
+
+    pub fn remove_sprite_standalone(&mut self, ruby_entity_id: u64) {
+        self.pending_operations
+            .push(SpriteOperation::Remove { ruby_entity_id });
+    }
+
+    pub fn clear_standalone(&mut self) {
+        self.pending_operations.push(SpriteOperation::Clear);
+    }
+
+    pub fn apply_pending(&mut self, world: &mut World) {
+        let ops: Vec<_> = self.pending_operations.drain(..).collect();
+        for op in ops {
+            match op {
+                SpriteOperation::Sync {
+                    ruby_entity_id,
+                    sprite_data,
+                    transform_data,
+                } => {
+                    self.sync_sprite(world, ruby_entity_id, &sprite_data, &transform_data);
+                }
+                SpriteOperation::Remove { ruby_entity_id } => {
+                    self.remove_sprite(world, ruby_entity_id);
+                }
+                SpriteOperation::Clear => {
+                    self.clear(world);
+                }
+            }
+        }
+    }
+
+    pub fn sync_sprite(
+        &mut self,
+        world: &mut World,
+        ruby_entity_id: u64,
+        sprite_data: &SpriteData,
+        transform_data: &TransformData,
+    ) {
+        let color = sprite_data.to_bevy_color();
+        let custom_size = sprite_data.custom_size();
+        let transform = transform_data.to_bevy_transform();
+
+        if let Some(entity_data) = self.entity_map.get(&ruby_entity_id) {
+            let bevy_entity = entity_data.bevy_entity;
+
+            if let Some(mut sprite) = world.get_mut::<Sprite>(bevy_entity) {
+                sprite.color = color;
+                sprite.custom_size = custom_size;
+                sprite.flip_x = sprite_data.flip_x;
+                sprite.flip_y = sprite_data.flip_y;
+            }
+
+            if let Some(mut t) = world.get_mut::<Transform>(bevy_entity) {
+                *t = transform;
+            }
+        } else {
+            let bevy_entity = world
+                .spawn((
+                    Sprite {
+                        color,
+                        custom_size,
+                        flip_x: sprite_data.flip_x,
+                        flip_y: sprite_data.flip_y,
+                        ..Default::default()
+                    },
+                    transform,
+                ))
+                .id();
+
+            self.entity_map
+                .insert(ruby_entity_id, EntityData { bevy_entity });
+        }
+    }
+
+    pub fn remove_sprite(&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);
+        }
+    }
+
+    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()
+    }
+
+    pub fn synced_entities(&self) -> Vec<u64> {
+        self.entity_map.keys().copied().collect()
+    }
+}
+
+impl Default for SpriteSync {
+    fn default() -> Self {
+        Self::new()
+    }
+}

data/ext/bevy/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "bevy"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+publish = false
+
+[lib]
+crate-type = ["cdylib"]
+
+[features]
+default = ["rendering"]
+rendering = ["bevy-ruby/rendering"]
+
+[dependencies]
+bevy-ruby = { path = "../../crates/bevy", default-features = false }
+magnus.workspace = true
+rb-sys = { workspace = true, features = ["stable-api-compiled-fallback"] }
+parking_lot.workspace = true

data/ext/bevy/extconf.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'mkmf'
+require 'rb_sys/mkmf'
+
+create_rust_makefile('bevy/bevy')

data/ext/bevy/src/conversions.rs

@@ -0,0 +1,137 @@
+use bevy_ruby::types::{DynamicValue, RubyColor, RubyQuat, RubyTransform, RubyVec2, RubyVec3};
+use magnus::{prelude::*, Error, RHash, Ruby, TryConvert, Value};
+
+pub fn ruby_hash_to_dynamic_value(ruby: &Ruby, hash: &RHash) -> Result<std::collections::HashMap<String, DynamicValue>, Error> {
+    let mut result = std::collections::HashMap::new();
+
+    hash.foreach(|key: Value, value: Value| {
+        let key_str = String::try_convert(key)?;
+        let dynamic_value = value_to_dynamic(ruby, value)?;
+        result.insert(key_str, dynamic_value);
+        Ok(magnus::r_hash::ForEach::Continue)
+    })?;
+
+    Ok(result)
+}
+
+pub fn value_to_dynamic(_ruby: &Ruby, value: Value) -> Result<DynamicValue, Error> {
+    if value.is_nil() {
+        return Ok(DynamicValue::Nil);
+    }
+
+    if let Ok(b) = bool::try_convert(value) {
+        return Ok(DynamicValue::Boolean(b));
+    }
+
+    if let Ok(i) = i64::try_convert(value) {
+        return Ok(DynamicValue::Integer(i));
+    }
+
+    if let Ok(f) = f64::try_convert(value) {
+        return Ok(DynamicValue::Float(f));
+    }
+
+    if let Ok(s) = String::try_convert(value) {
+        return Ok(DynamicValue::String(s));
+    }
+
+    Ok(DynamicValue::Nil)
+}
+
+pub fn dynamic_to_value(ruby: &Ruby, value: &DynamicValue) -> Result<Value, Error> {
+    match value {
+        DynamicValue::Nil => Ok(ruby.qnil().as_value()),
+        DynamicValue::Boolean(b) => Ok(if *b { ruby.qtrue().as_value() } else { ruby.qfalse().as_value() }),
+        DynamicValue::Integer(i) => Ok(ruby.into_value(*i)),
+        DynamicValue::Float(f) => Ok(ruby.into_value(*f)),
+        DynamicValue::String(s) => Ok(ruby.into_value(s.clone())),
+        DynamicValue::Symbol(s) => Ok(ruby.into_value(s.clone())),
+        DynamicValue::Array(arr) => {
+            let array = ruby.ary_new_capa(arr.len());
+            for item in arr {
+                array.push(dynamic_to_value(ruby, item)?)?;
+            }
+            Ok(array.as_value())
+        }
+        DynamicValue::Hash(h) => {
+            let hash = ruby.hash_new();
+            for (k, v) in h {
+                hash.aset(k.clone(), dynamic_to_value(ruby, v)?)?;
+            }
+            Ok(hash.as_value())
+        }
+    }
+}
+
+pub fn vec2_from_hash(ruby: &Ruby, hash: &RHash) -> Result<RubyVec2, Error> {
+    let x: f64 = get_hash_value_or_default(ruby, hash, "x", 0.0)?;
+    let y: f64 = get_hash_value_or_default(ruby, hash, "y", 0.0)?;
+    Ok(RubyVec2::new(x as f32, y as f32))
+}
+
+pub fn vec3_from_hash(ruby: &Ruby, hash: &RHash) -> Result<RubyVec3, Error> {
+    let x: f64 = get_hash_value_or_default(ruby, hash, "x", 0.0)?;
+    let y: f64 = get_hash_value_or_default(ruby, hash, "y", 0.0)?;
+    let z: f64 = get_hash_value_or_default(ruby, hash, "z", 0.0)?;
+    Ok(RubyVec3::new(x as f32, y as f32, z as f32))
+}
+
+pub fn quat_from_hash(ruby: &Ruby, hash: &RHash) -> Result<RubyQuat, Error> {
+    let x: Option<f64> = get_hash_value(ruby, hash, "x")?;
+    let y: Option<f64> = get_hash_value(ruby, hash, "y")?;
+    let z: Option<f64> = get_hash_value(ruby, hash, "z")?;
+
+    if x.is_some() || y.is_some() || z.is_some() {
+        Ok(RubyQuat::from_euler(
+            x.unwrap_or(0.0) as f32,
+            y.unwrap_or(0.0) as f32,
+            z.unwrap_or(0.0) as f32,
+        ))
+    } else {
+        Ok(RubyQuat::identity())
+    }
+}
+
+pub fn color_from_hash(ruby: &Ruby, hash: &RHash) -> Result<RubyColor, Error> {
+    let r: f64 = get_hash_value_or_default(ruby, hash, "r", 1.0)?;
+    let g: f64 = get_hash_value_or_default(ruby, hash, "g", 1.0)?;
+    let b: f64 = get_hash_value_or_default(ruby, hash, "b", 1.0)?;
+    let a: f64 = get_hash_value_or_default(ruby, hash, "a", 1.0)?;
+    Ok(RubyColor::rgba(r as f32, g as f32, b as f32, a as f32))
+}
+
+pub fn transform_from_hash(ruby: &Ruby, hash: &RHash) -> Result<RubyTransform, Error> {
+    let tx: f64 = get_hash_value_or_default(ruby, hash, "x", 0.0)?;
+    let ty: f64 = get_hash_value_or_default(ruby, hash, "y", 0.0)?;
+    let tz: f64 = get_hash_value_or_default(ruby, hash, "z", 0.0)?;
+
+    let translation = RubyVec3::new(tx as f32, ty as f32, tz as f32);
+
+    let rotation: f64 = get_hash_value_or_default(ruby, hash, "rotation", 0.0)?;
+    let quat = RubyQuat::from_rotation_z(rotation as f32);
+
+    let sx: f64 = get_hash_value_or_default(ruby, hash, "scale_x", 1.0)?;
+    let sy: f64 = get_hash_value_or_default(ruby, hash, "scale_y", 1.0)?;
+    let sz: f64 = get_hash_value_or_default(ruby, hash, "scale_z", 1.0)?;
+    let scale = RubyVec3::new(sx as f32, sy as f32, sz as f32);
+
+    Ok(RubyTransform::from_translation_rotation_scale(translation, quat, scale))
+}
+
+fn get_hash_value<T: TryConvert>(ruby: &Ruby, hash: &RHash, key: &str) -> Result<Option<T>, Error> {
+    let sym = ruby.to_symbol(key);
+    match hash.get(sym) {
+        Some(val) => {
+            if val.is_nil() {
+                Ok(None)
+            } else {
+                Ok(Some(TryConvert::try_convert(val)?))
+            }
+        }
+        None => Ok(None),
+    }
+}
+
+fn get_hash_value_or_default<T: TryConvert>(ruby: &Ruby, hash: &RHash, key: &str, default: T) -> Result<T, Error> {
+    get_hash_value(ruby, hash, key).map(|opt| opt.unwrap_or(default))
+}

data/ext/bevy/src/lib.rs

@@ -0,0 +1,29 @@
+mod conversions;
+mod ruby_app;
+mod ruby_color;
+mod ruby_component;
+mod ruby_entity;
+mod ruby_math;
+mod ruby_query;
+mod ruby_render_app;
+mod ruby_system;
+mod ruby_world;
+
+use magnus::{Error, Ruby};
+
+#[magnus::init]
+fn init(ruby: &Ruby) -> Result<(), Error> {
+    let module = ruby.define_module("Bevy")?;
+
+    ruby_app::define(ruby, &module)?;
+    ruby_color::define(ruby, &module)?;
+    ruby_component::define(ruby, &module)?;
+    ruby_math::define(ruby, &module)?;
+    ruby_query::define(ruby, &module)?;
+    ruby_system::define(ruby, &module)?;
+    ruby_world::define(ruby, &module)?;
+    ruby_entity::define(ruby, &module)?;
+    ruby_render_app::define(ruby, &module)?;
+
+    Ok(())
+}

data/ext/bevy/src/ruby_app.rs

@@ -0,0 +1,65 @@
+use bevy_ruby::{AppBuilder, WorldWrapper};
+use bevy_ruby::system::ScheduleLabel;
+use magnus::{function, method, prelude::*, Error, RModule, Ruby, Symbol};
+use std::cell::RefCell;
+use std::sync::Arc;
+
+use crate::ruby_world::RubyWorld;
+
+#[magnus::wrap(class = "Bevy::AppBuilder", free_immediately, size)]
+pub struct RubyAppBuilder {
+    inner: RefCell<AppBuilder>,
+}
+
+impl RubyAppBuilder {
+    fn new() -> Self {
+        Self {
+            inner: RefCell::new(AppBuilder::new()),
+        }
+    }
+
+    fn add_system(&self, schedule: Symbol, _param_types: Vec<String>) -> Result<(), Error> {
+        let ruby = Ruby::get().unwrap();
+        let schedule_str = schedule.name().map_err(|e| {
+            Error::new(ruby.exception_runtime_error(), format!("Invalid schedule symbol: {}", e))
+        })?;
+        let label = ScheduleLabel::from_str(&schedule_str).map_err(|e| {
+            Error::new(ruby.exception_runtime_error(), e.to_string())
+        })?;
+        let descriptor = bevy_ruby::system::SystemDescriptor::new(label);
+        self.inner.borrow_mut().add_system(descriptor);
+        Ok(())
+    }
+
+    fn systems_for_schedule(&self, schedule: Symbol) -> Result<usize, Error> {
+        let ruby = Ruby::get().unwrap();
+        let schedule_str = schedule.name().map_err(|e| {
+            Error::new(ruby.exception_runtime_error(), format!("Invalid schedule symbol: {}", e))
+        })?;
+        let label = ScheduleLabel::from_str(&schedule_str).map_err(|e| {
+            Error::new(ruby.exception_runtime_error(), e.to_string())
+        })?;
+        Ok(self.inner.borrow().systems_for_schedule(label).len())
+    }
+
+    fn create_world(&self) -> RubyWorld {
+        RubyWorld::from_wrapper(self.inner.borrow().create_world())
+    }
+
+    #[allow(dead_code)]
+    pub fn inner(&self) -> std::cell::Ref<'_, AppBuilder> {
+        self.inner.borrow()
+    }
+}
+
+unsafe impl Send for RubyAppBuilder {}
+
+pub fn define(ruby: &Ruby, module: &RModule) -> Result<(), Error> {
+    let class = module.define_class("AppBuilder", ruby.class_object())?;
+    class.define_singleton_method("new", function!(RubyAppBuilder::new, 0))?;
+    class.define_method("add_system", method!(RubyAppBuilder::add_system, 2))?;
+    class.define_method("systems_for_schedule", method!(RubyAppBuilder::systems_for_schedule, 1))?;
+    class.define_method("create_world", method!(RubyAppBuilder::create_world, 0))?;
+
+    Ok(())
+}

data/ext/bevy/src/ruby_color.rs

@@ -0,0 +1,149 @@
+use bevy_ruby::RubyColor;
+use magnus::{function, method, prelude::*, Error, RArray, RModule, Ruby};
+use std::cell::RefCell;
+
+#[magnus::wrap(class = "Bevy::Color", free_immediately, size)]
+pub struct MagnusColor {
+    inner: RefCell<RubyColor>,
+}
+
+impl MagnusColor {
+    fn new(r: f64, g: f64, b: f64, a: f64) -> Self {
+        Self {
+            inner: RefCell::new(RubyColor::new(r as f32, g as f32, b as f32, a as f32)),
+        }
+    }
+
+    fn rgb(r: f64, g: f64, b: f64) -> Self {
+        Self {
+            inner: RefCell::new(RubyColor::rgb(r as f32, g as f32, b as f32)),
+        }
+    }
+
+    fn rgba(r: f64, g: f64, b: f64, a: f64) -> Self {
+        Self {
+            inner: RefCell::new(RubyColor::rgba(r as f32, g as f32, b as f32, a as f32)),
+        }
+    }
+
+    fn from_hex(hex: String) -> Result<Self, Error> {
+        RubyColor::from_hex(&hex)
+            .map(|c| Self {
+                inner: RefCell::new(c),
+            })
+            .ok_or_else(|| Error::new(magnus::exception::arg_error(), "Invalid hex color"))
+    }
+
+    fn white() -> Self {
+        Self {
+            inner: RefCell::new(RubyColor::white()),
+        }
+    }
+
+    fn black() -> Self {
+        Self {
+            inner: RefCell::new(RubyColor::black()),
+        }
+    }
+
+    fn red() -> Self {
+        Self {
+            inner: RefCell::new(RubyColor::red()),
+        }
+    }
+
+    fn green() -> Self {
+        Self {
+            inner: RefCell::new(RubyColor::green()),
+        }
+    }
+
+    fn blue() -> Self {
+        Self {
+            inner: RefCell::new(RubyColor::blue()),
+        }
+    }
+
+    fn transparent() -> Self {
+        Self {
+            inner: RefCell::new(RubyColor::transparent()),
+        }
+    }
+
+    fn r(&self) -> f64 {
+        self.inner.borrow().r() as f64
+    }
+
+    fn g(&self) -> f64 {
+        self.inner.borrow().g() as f64
+    }
+
+    fn b(&self) -> f64 {
+        self.inner.borrow().b() as f64
+    }
+
+    fn a(&self) -> f64 {
+        self.inner.borrow().a() as f64
+    }
+
+    fn set_r(&self, r: f64) {
+        self.inner.borrow_mut().set_r(r as f32);
+    }
+
+    fn set_g(&self, g: f64) {
+        self.inner.borrow_mut().set_g(g as f32);
+    }
+
+    fn set_b(&self, b: f64) {
+        self.inner.borrow_mut().set_b(b as f32);
+    }
+
+    fn set_a(&self, a: f64) {
+        self.inner.borrow_mut().set_a(a as f32);
+    }
+
+    fn with_alpha(&self, alpha: f64) -> Self {
+        Self {
+            inner: RefCell::new(self.inner.borrow().with_alpha(alpha as f32)),
+        }
+    }
+
+    fn to_a(&self) -> Result<RArray, Error> {
+        let ruby = Ruby::get().unwrap();
+        let arr = ruby.ary_new();
+        let c = self.inner.borrow();
+        arr.push(c.r() as f64)?;
+        arr.push(c.g() as f64)?;
+        arr.push(c.b() as f64)?;
+        arr.push(c.a() as f64)?;
+        Ok(arr)
+    }
+}
+
+unsafe impl Send for MagnusColor {}
+
+pub fn define(ruby: &Ruby, module: &RModule) -> Result<(), Error> {
+    let color_class = module.define_class("Color", ruby.class_object())?;
+    color_class.define_singleton_method("new", function!(MagnusColor::new, 4))?;
+    color_class.define_singleton_method("rgb", function!(MagnusColor::rgb, 3))?;
+    color_class.define_singleton_method("rgba", function!(MagnusColor::rgba, 4))?;
+    color_class.define_singleton_method("from_hex", function!(MagnusColor::from_hex, 1))?;
+    color_class.define_singleton_method("white", function!(MagnusColor::white, 0))?;
+    color_class.define_singleton_method("black", function!(MagnusColor::black, 0))?;
+    color_class.define_singleton_method("red", function!(MagnusColor::red, 0))?;
+    color_class.define_singleton_method("green", function!(MagnusColor::green, 0))?;
+    color_class.define_singleton_method("blue", function!(MagnusColor::blue, 0))?;
+    color_class.define_singleton_method("transparent", function!(MagnusColor::transparent, 0))?;
+    color_class.define_method("r", method!(MagnusColor::r, 0))?;
+    color_class.define_method("g", method!(MagnusColor::g, 0))?;
+    color_class.define_method("b", method!(MagnusColor::b, 0))?;
+    color_class.define_method("a", method!(MagnusColor::a, 0))?;
+    color_class.define_method("r=", method!(MagnusColor::set_r, 1))?;
+    color_class.define_method("g=", method!(MagnusColor::set_g, 1))?;
+    color_class.define_method("b=", method!(MagnusColor::set_b, 1))?;
+    color_class.define_method("a=", method!(MagnusColor::set_a, 1))?;
+    color_class.define_method("with_alpha", method!(MagnusColor::with_alpha, 1))?;
+    color_class.define_method("to_a", method!(MagnusColor::to_a, 0))?;
+
+    Ok(())
+}