add with_options to RonAssetPlugin

assets/trees.level.ron

@@ -6,5 +6,6 @@
         (-61., 149., 0.),
         (-96., -52., 0.),
         (69., -189., 0.),
-    ]
+    ],
+    alpha: 0.5
 )

examples/ron.rs

@@ -1,6 +1,7 @@
 use bevy::prelude::*;
 use bevy::reflect::TypePath;
 use bevy_common_assets::ron::RonAssetPlugin;
+use serde_ron::{Options, extensions::Extensions};
 
 fn main() {
     App::new()
@@ -28,9 +29,15 @@ fn spawn_level(
     mut state: ResMut<NextState<AppState>>,
 ) {
     if let Some(level) = levels.remove(level.0.id()) {
+        // Default to fully opaque if alpha is None.
+        let color = Color::default().with_alpha(level.alpha.unwrap_or(1.0));
         for position in level.positions {
             commands.spawn((
-                Sprite::from_image(tree.0.clone()),
+                Sprite {
+                    image: tree.0.clone(),
+                    color,
+                    ..default()
+                },
                 Transform::from_translation(position.into()),
             ));
         }
@@ -42,6 +49,7 @@ fn spawn_level(
 #[derive(serde::Deserialize, Asset, TypePath)]
 struct Level {
     positions: Vec<[f32; 3]>,
+    alpha: Option<f32>,
 }
 
 #[derive(Debug, Clone, Copy, Default, Eq, PartialEq, Hash, States)]

src/ron.rs

@@ -3,13 +3,14 @@ use bevy_asset::io::Reader;
 use bevy_asset::{Asset, AssetApp, AssetLoader, AsyncWriteExt, LoadContext, saver::AssetSaver};
 use bevy_reflect::TypePath;
 use serde::{Deserialize, Serialize};
-use serde_ron::de::from_bytes;
+use serde_ron::{Options, extensions::Extensions};
 use std::marker::PhantomData;
 use thiserror::Error;
 
 /// Plugin to load your asset type `A` from ron files.
 pub struct RonAssetPlugin<A> {
     extensions: Vec<&'static str>,
+    options: Options,
     _marker: PhantomData<A>,
 }
 
@@ -21,6 +22,7 @@ where
         app.init_asset::<A>()
             .register_asset_loader(RonAssetLoader::<A> {
                 extensions: self.extensions.clone(),
+                options: self.options.clone(),
                 _marker: PhantomData,
             });
     }
@@ -31,18 +33,38 @@ where
     for<'de> A: serde::Deserialize<'de> + Asset,
 {
     /// Create a new plugin that will load assets from files with the given extensions.
+    ///
+    /// Enables [`Extensions::IMPLICIT_SOME`] by default.
     pub fn new(extensions: &[&'static str]) -> Self {
         Self {
             extensions: extensions.to_owned(),
+            options: Options::default().with_default_extension(Extensions::IMPLICIT_SOME),
             _marker: PhantomData,
         }
     }
+
+    /// Customize RON deserialization options.
+    ///
+    /// ```no_run
+    /// use serde_ron::{extensions::Extensions, Options};
+    ///
+    /// App::new()
+    ///     .add_plugins(RonAssetPlugin::<Level>::new(&["level.ron"])
+    ///         .with_options(Options::default().with_default_extension(
+    ///             Extensions::UNWRAP_NEWTYPES | Extensions::IMPLICIT_SOME,
+    ///         )));
+    /// ```
+    pub fn with_options(mut self, options: Options) -> Self {
+        self.options = options;
+        self
+    }
 }
 
 /// Loads your asset type `A` from ron files
 #[derive(TypePath)]
 pub struct RonAssetLoader<A> {
     extensions: Vec<&'static str>,
+    options: Options,
     _marker: PhantomData<A>,
 }
 
@@ -81,7 +103,7 @@ where
     ) -> Result<Self::Asset, Self::Error> {
         let mut bytes = Vec::new();
         reader.read_to_end(&mut bytes).await?;
-        let asset = from_bytes::<A>(&bytes)?;
+        let asset = self.options.from_bytes::<A>(&bytes)?;
         Ok(asset)
     }