Added #[proto_comp(with=...)] and #[proto_comp(into=...)] attributes

Cargo.toml

@@ -35,6 +35,10 @@ path = "examples/basic.rs"
 name = "bundles"
 path = "examples/bundles.rs"
 
+[[example]]
+name = "attributes"
+path = "examples/attributes.rs"
+
 [[example]]
 name = "templates"
 path = "examples/templates.rs"

README.md

@@ -131,21 +131,19 @@ For simple components, `ProtoComponent` may be derived:
 ```rust
 use bevy_proto::ProtoComponent;
 
-#[derive(Serialize, Deserialize, ProtoComponent)]
+#[derive(Clone, Serialize, Deserialize, ProtoComponent, Component)]
 struct Movement {
-    #[proto_comp(Copy)]
     speed: u16
 }
 
 // Also works on tuple structs:
-#[derive(Serialize, Deserialize, ProtoComponent)]
-struct Inventory ( 
-    // Optional: #[proto_comp(Clone)]
+#[derive(Clone, Serialize, Deserialize, ProtoComponent, Component)]
+struct Inventory (
     Option<Vec<String>>
-)
+);
 ```
 
-> By default, the fields of a `ProtoComponent` are cloned into spawned entities. This can be somewhat controlled via the `proto_comp` attribute, which can tell the compiler to use the `Copy` trait instead.
+> By default, the `ProtoComponent` is cloned into spawned entities.
 
 Otherwise, you can define them manually (the two attributes are required with this method):
 
@@ -170,6 +168,8 @@ impl ProtoComponent for Inventory {
 ```
 
 > A `ProtoComponent` does *not* need to be a component itself. It can be used purely as a [DTO](https://en.wikipedia.org/wiki/Data_transfer_object) to generate other components or bundles. You have full access to the `EntityCommands` so you can insert bundles or even multiple components at once.
+>
+> Other ways of generating components from non-component `ProtoComponent` structs can be found in the [attributes](https://github.com/MrGVSV/bevy_proto/blob/main/examples/attributes.rs) example.
 
 ### Defining the Prototype
 

assets/prototypes/emoji_angry.yaml

@@ -0,0 +1,5 @@
+---
+name: "Angry"
+components:
+  - type: Face
+    value: Frowning

assets/prototypes/emoji_happy.yaml

@@ -0,0 +1,6 @@
+---
+name: "Happy"
+components:
+  - type: EmojiDef
+    value:
+      emoji: 😁

assets/prototypes/emoji_sad.yaml

@@ -0,0 +1,6 @@
+---
+name: "Sad"
+components:
+  - type: EmojiDef
+    value:
+      emoji: 😢

assets/prototypes/emoji_silly.yaml

@@ -0,0 +1,5 @@
+---
+name: "Silly"
+components:
+  - type: Mood
+    value: Silly

bevy_proto_derive/src/attributes.rs

@@ -0,0 +1,71 @@
+use proc_macro2::{Ident, Span, TokenStream};
+use quote::{format_ident, quote, ToTokens};
+use syn::parse::{Parse, ParseStream};
+use syn::{Error, LitStr, Path, Result, Token};
+
+use crate::constants::{INTO_IDENT, WITH_IDENT};
+
+/// ProtoComponent attributes applied on structs
+pub(crate) enum ProtoCompAttr {
+	/// Captures the `#[proto_comp(into = "ActualComponent")]` attribute
+	///
+	/// This is used to specify a separate Component that this marked struct will be cloned into.
+	///
+	/// Generates the following code:
+	/// ```rust
+	/// let component: ActualComponent = self.clone().into();
+	/// commands.insert(component);
+	/// ```
+	Into(Ident),
+	/// Captures the `#[proto_comp(with = "my_function")]` attribute
+	///
+	/// This is used to specify a custom function with which custom Components will be creatde and/or inserted.
+	/// This is essentially identical to just simply implementing `ProtoComponent` yourself.
+	///
+	/// Generates the following code:
+	/// ```rust
+	/// my_function(self, commands, asset_server);
+	/// ```
+	With(Ident),
+}
+
+impl Parse for ProtoCompAttr {
+	fn parse(input: ParseStream) -> Result<Self> {
+		let path: Path = input.parse()?;
+		let _: Token![=] = input.parse()?;
+		let item: LitStr = input.parse()?;
+		let ident = format_ident!("{}", item.value());
+
+		if path == WITH_IDENT {
+			Ok(Self::With(ident))
+		} else if path == INTO_IDENT {
+			Ok(Self::Into(ident))
+		} else {
+			Err(Error::new(
+				Span::call_site(),
+				format!("Unexpected path '{:?}'", path),
+			))
+		}
+	}
+}
+
+impl ToTokens for ProtoCompAttr {
+	fn to_tokens(&self, tokens: &mut TokenStream) {
+		match self {
+			Self::Into(ident) => {
+				let into_ident = quote! {
+					let cloned = self.clone();
+					let component: #ident = cloned.into();
+					commands.insert(component);
+				};
+				into_ident.to_tokens(tokens);
+			}
+			Self::With(ident) => {
+				let with_ident = quote! {
+					#ident(self, commands, asset_server);
+				};
+				with_ident.to_tokens(tokens);
+			}
+		}
+	}
+}

bevy_proto_derive/src/constants.rs

@@ -14,6 +14,5 @@ impl PartialEq<Symbol> for syn::Path {
 	}
 }
 
-pub(crate) const ATTR_IDENT: Symbol = Symbol("proto_comp");
-pub(crate) const COPY_IDENT: Symbol = Symbol("Copy");
-pub(crate) const CLONE_IDENT: Symbol = Symbol("Clone");
+pub(crate) const WITH_IDENT: Symbol = Symbol("with");
+pub(crate) const INTO_IDENT: Symbol = Symbol("into");