Unity support

[gaozhou]

Can you provide a unity example?

[genaray]

I will do that once i have some time :) Pretty busy rn with my thesis.
Just out of curiosity, have you tried integrating it via a nuget unity plugin?

Arch sources can not be used, nugets however should be usable even if they make use of higher language features.

[mikhail-dcl]

In Decentraland we are already doing a PoC using Arch as an ECS framework. it's totally possible to use Arch DLLs compiled for netstandard2.1. There is one limitation though, Marshal.SizeOf in the static ctor of ComponentType does not work on IL2CPP for non-blittable (e.g. with reference type fields) and generic structures. @genaray It would be great if you could give advice if it's possible to replace Marshal.SizeOf with something else.

[genaray]

First of all, it's probably the coolest thing I've heard in a long time and makes myself kind of proud too :) Also saw that you created a SystemGroups framework, I'll link it on the github page, maybe others are interested in it too ^^

To the second... there we, unfortunately, come across a limitation of C#. As an alternative there would be Unsafe.SizeOf, but this does not provide a type overload and is therefore only limited usable.

The easiest option here is to never use managed structs. Or... and here comes your solution... register them yourself beforehand. ComponentRegistry has methods to pre-register components and so this hurdle is avoided :)

public struct ManagedStruct{ public List<int> SomeInts{ get; set; } }

// Register
var componentType = new ComponentType(ComponentRegistry.Size - 1, typeof(ManagedStruct), 8, false); // 8 = Size in bytes of the managed struct.
ComponentRegistry.Add(componentType);

// Use
var entity = world.Create(new ManagedStruct());

[mikhail-dcl]

// Register
var componentType = new ComponentType(ComponentRegistry.Size - 1, typeof(ManagedStruct), 8, false); // 8 = Size in bytes of the managed struct.
ComponentRegistry.Add(componentType);

Great, it may work out, I will give it a try. Thank you

Also saw that you created a SystemGroups framework, I'll link it on the github page, maybe others are interested in it too

Sure, feel free

[genaray]

// Register
var componentType = new ComponentType(ComponentRegistry.Size - 1, typeof(ManagedStruct), 8, false); // 8 = Size in bytes of the managed struct.
ComponentRegistry.Add(componentType);

Great, it may work out, I will give it a try. Thank you

Also saw that you created a SystemGroups framework, I'll link it on the github page, maybe others are interested in it too

Sure, feel free

Perfect! Lemme know if it works for your case :)

[mikhail-dcl]

I can confirm that the proposed solution works nicely with Unity IL2CPP with both a manually calculated size
and Unsafe.SizeOf

var componentType = new ComponentType(ComponentRegistry.Size - 1, typeof(ManagedStruct), 8, false); // 8 = Size in bytes of the managed struct.
ComponentRegistry.Add(componentType);

var componentType = new ComponentType(ComponentRegistry.Size - 1, typeof(ManagedStruct), Unsafe.SizeOf<ManagedStruct>(), false); 
ComponentRegistry.Add(componentType);

[genaray]

I can confirm that the proposed solution works nicely with Unity IL2CPP with both a manually calculated size and Unsafe.SizeOf

var componentType = new ComponentType(ComponentRegistry.Size - 1, typeof(ManagedStruct), 8, false); // 8 = Size in bytes of the managed struct.
ComponentRegistry.Add(componentType);

var componentType = new ComponentType(ComponentRegistry.Size - 1, typeof(ManagedStruct), Unsafe.SizeOf<ManagedStruct>(), false); 
ComponentRegistry.Add(componentType);

Great to see that it works! :) 33013b9 recently added automatic size detection for managed structs. That makes use of reflection during the component registration. Should also work on unity and will reduce the boilerplate a bit in the future ^^

[mikhail-dcl]

That's actually great so there will be no boilerplate.

IL2CPP though will not generate the generic version of Unsafe for structures if it was not mentioned explicitly anywhere in conjunction with Unsafe so

private static int SizeOf(Type type)
    {
        if (type.IsValueType)
        {
            return (int) typeof(Unsafe)
                .GetMethod(nameof(Unsafe.SizeOf))!
                .MakeGenericMethod(type)
                .Invoke(null, null)!;
        }

        return IntPtr.Size;
    }

may not work in Unity. It should not be critical as all usual paths I saw so far were via an explicitly mentioned generic Component

[genaray]

That's actually great so there will be no boilerplate.

IL2CPP though will not generate the generic version of Unsafe for structures if it was not mentioned explicitly anywhere in conjunction with Unsafe so

private static int SizeOf(Type type)
    {
        if (type.IsValueType)
        {
            return (int) typeof(Unsafe)
                .GetMethod(nameof(Unsafe.SizeOf))!
                .MakeGenericMethod(type)
                .Invoke(null, null)!;
        }

        return IntPtr.Size;
    }

may not work in Unity. It should not be critical as all usual paths I saw so far were via an explicitly mentioned generic Component

I assume that's because Unitys IL2CPP strips out most reflection code, especially if not mentioned before... correct?
Well that's actually a pitty, but quite understandable. Unity really has a advantage here, since their implement their own "Runtime" they have access to all type data needed without reflection.

For the future i could look into unity specific way. If i saw that correctly, unity has their own SizeOf API.

[mikhail-dcl]

You can read more about IL2CPP Code stripping here. Essentially, the most relevant part is the "Annotate roots using a Link XML file" section with generics examples. This is how the limitation can be circumvented.

When it comes to generics with value types it's not like they are stripped out, it's rather the AOT compiler does not generate them at all. For every value type, the size needed to allocate the type itself and the values on the stack (for methods invocations for instance) is different. Unlike the ref type when it can be always treated as an object and then casted to the required type (this is exactly how IL2CPP produces c++ code).

For example, Unsafe.SizeOf<T> returns a compile-time constant:

[NonVersionable]
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static int SizeOf<T>() => sizeof (T);

It's a perfect example of the necessity for the AOT compiler to know about the generic type ahead. If the code is not generated (and without JIT it can't be generated at runtime) the runtime has no idea about the size of the type

[mikhail-dcl]

When I have time I will create a Unity preprocessor to generate a link.xml with every Arch-related component. I don't know how I will find them through reflection at the moment though 😄 , so if you have any ideas you are very welcome to share 😉