1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use proc_macro2::TokenStream;
use quote::quote;
use syn::{parse_macro_input, DeriveInput};

/// Implements archetype capabilities for `struct`.
#[proc_macro_derive(Archetype)]
pub fn derive_archetype_fn(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
    let main_crate = quote!(::entity_data);

    let DeriveInput {
        ident,
        data,
        generics,
        ..
    } = parse_macro_input!(input as DeriveInput);

    let where_clause = &generics.where_clause;

    let fields = if let syn::Data::Struct(data) = data {
        data.fields
    } else {
        panic!("Not a structure!");
    };

    let types: Vec<_> = fields
        .iter()
        .map(|field| {
            let field_ty = &field.ty;
            quote! {
                ::std::any::TypeId::of::<#field_ty>(),
            }
        })
        .collect();

    let field_impls: Vec<_> = fields
        .into_iter().enumerate()
        .map(|(i, field)| {
            let field_ty = field.ty;

            let offset = if let Some(field_ident) = &field.ident {
                quote! {
                    #main_crate::private::offset_of!(Self, #field_ident)
                }
            } else {
                let i = syn::Index::from(i);
                quote! {
                    #main_crate::private::offset_of!(Self, #i)
                }
            };

            quote! {
                #main_crate::private::ComponentInfo {
                    type_id: ::std::any::TypeId::of::<#field_ty>(),
                    range: {
                        let offset = #offset;
                        let size = ::std::mem::size_of::<#field_ty>();
                        offset..(offset + size)
                    },
                    needs_drop: ::std::mem::needs_drop::<#field_ty>(),
                    drop_func: |p: *mut u8| unsafe { ::std::ptr::drop_in_place(p as *mut #field_ty) }
                },
            }
        })
        .collect();

    let fields_len = field_impls.len();

    // Check component uniqueness
    {
        let mut field_names: Vec<_> = types.iter().map(|v| v.to_string()).collect();
        field_names.sort();
        let initial_len = field_names.len();

        field_names.dedup();
        let deduped_len = field_names.len();

        if initial_len != deduped_len {
            panic!("Archetype contains multiple components of the same type.");
        }
    }

    let mut field_types = TokenStream::new();
    field_types.extend(types.into_iter());

    let mut fields = TokenStream::new();
    fields.extend(field_impls.into_iter());

    quote! {
        impl #generics #main_crate::StaticArchetype for #ident #generics #where_clause {
            const N_COMPONENTS: usize = #fields_len;

            fn metadata() -> fn() -> #main_crate::private::ArchetypeMetadata {
                || #main_crate::private::ArchetypeMetadata {
                    component_type_ids: || #main_crate::private::smallvec![#field_types],
                    component_infos: || #main_crate::private::smallvec![#fields],
                    needs_drop: ::std::mem::needs_drop::<Self>(),
                    drop_func: |p: *mut u8| unsafe { ::std::ptr::drop_in_place(p as *mut Self) },
                }
            }
        }

        impl #generics #main_crate::ArchetypeState for #ident #generics #where_clause {
            fn ty(&self) -> ::std::any::TypeId {
                ::std::any::TypeId::of::<Self>()
            }

            fn as_ptr(&self) -> *const u8 {
                self as *const _ as *const u8
            }

            fn forget(self) {
                ::std::mem::forget(self);
            }

            fn metadata(&self) -> fn() -> #main_crate::private::ArchetypeMetadata {
                <Self as #main_crate::StaticArchetype>::metadata()
            }

            fn as_any(&self) -> &dyn ::std::any::Any {
                self
            }

            fn as_any_mut(&mut self) -> &mut dyn ::std::any::Any {
                self
            }
        }
    }
    .into()
}