Source Generator

Systems source generator

The Arch.System.SourceGenerator package provides some code generation utils. With them, queries can be written virtually by themselves which saves some boilerplate code.

Query methods can be generated in all classes as long as they are partial. However it makes most sense in the BaseSystem. The attributes can be used to meaningfully describe what query to generate, and the query will always call the annotated method.

The generated methods can also be called manually.

Classes using the source generation should be within a namespace, the global one is NOT supported at the moment.

Syntax

Arch.System provides some attributes that can be used for code generation. These can be arranged and used arbitrarily.

• [Query(Parallel = bool)] > Update marks some method so that the code generator makes a query out of it.
• [All<T0...T25>] > Mirrors QueryDescription.All, defines which components an entity needs.
• [Any<T0...T25>] > Mirrors QueryDescription.Any, defines that an entity needs at least one of the components.
• [None<T0...T25>] > Mirrors QueryDescription.None, defines that an entity should have none of those components.
• [Exclusive<T0...T25>] > Mirrors QueryDescription.Exclusive, defines an exclusive set of entity components.
• [Data] > Marks a method parameter and specifies that this type should be passed through the query.

Query is always required. All, Any, None, Exclusive, Data are optional and independent from each other.

There are also non generic versions of those attributes for projects using .NetStandard2.1 or .Net6 :)

• [All(typeof(...),...)]
• [Any(typeof(...),...)]
• [None(typeof(...),...)]
• [Exclusive(typeof(...),...)]

Let us now look at some example.

Query Methods in BaseSystem

It makes most sense to use the generator directly in the BaseSystem. If this is the case, the BaseSystem.Update method is automatically generated and the queries are called in order.

// Components ( ignore the formatting, this saves space )
public struct Position{ float X, Y };
public struct Velocity{ float Dx, Dy };

// BaseSystem provides several usefull methods for interacting and structuring systems
public partial class MovementSystem : BaseSystem<World, float>{

    public MovementSystem(World world) : base(world) {}
    
    // Generates a query and calls this annotated method for all entities with position and velocity components.
    [Query]  // Marks method inside BaseSystem for source generation.
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public void MoveEntity([Data] ref float time, ref Position pos, ref Velocity vel)  // Entity requires atleast those components. "in Entity" can also be passed. 
    {
        pos.X += time * vel.X;
        pos.Y += time * vel.Y;
    }
    
    /// Generates a query and calls this method for all entities with velocity, player, mob, particle, either moving or idle and no dead component.
    /// All, Any, None are seperate attributes and do not require each other.
    [Query]
    [All<Player, Mob, Particle>, Any<Moving, Idle>, None<Alive>]  // Adds filters to the source generation to adress certain entities. 
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public void StopDeadEntities(ref Velocity vel)
    {
        vel.X = 0;
        vel.Y = 0;
    }
}

If a parameter of a method within a basesystem is marked as Data, then BaseSystem.Data is passed directly to the query. In the example above you can see this at the time: float.

If you use the source generator and its attributes in a class that does not override BaseSystem.Update, this method is implemented by the source generator itself. If the method is already implemented by the user, only "query" methods are generated, which you can call yourself.

public partial class MovementSystem : BaseSystem<World, GameTime>
{
    private readonly QueryDescription _customQuery = new QueryDescription().WithAll<Position, Velocity>();
    public DebugSystem(World world) : base(world) { }

    public override void Update(in GameTime t)
    {
        World.Query(in _customQuery, (in Entity entity) => Console.WriteLine($"Custom : {entity}"));  // Manual query
        MoveEntityQuery(World);  // Call source generated query, which calls the MoveEntity method
    }

    [Query]
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public void MoveEntity(ref Position pos, ref Velocity vel)
    {
        pos.X += vel.X;
        pos.Y += vel.Y;
    }
}

Query Methods in custom classes

Queries can be generated in any class, in the following example a move and a hit query is generated and used for the class. This is useful to group and reuse queries.

// Class which will generate 
public partial class MyQueries{

    [Query]  // Marks method inside BaseSystem for source generation.
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public void MoveEntities([Data] in float time, ref Position pos, ref Velocity vel){
        pos.X += time * vel.X;
        pos.Y += time * vel.Y;
    }
    
    [Query]  // Marks method inside BaseSystem for source generation.
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public void DamageEntities(ref Hitted hit, ref Health health){
        health.value -= hit.value;
    }
    
    ... other Queries
}

// Instantiate class and call the generated methods 
var myQueries = new MyQueries();
myQueries.MoveEntitiesQuery(someWorld, 10.0f);  // World is always required for the generated method, 10.0f is the [Data] parameter
myQueries.DamageEntitiesQuery(someWorld);

The same works for static classes, whose performance is better. The advantage is that no class instance is needed.

// Class which will generate 
public static partial class MyQueries{

    [Query]  // Marks method inside BaseSystem for source generation.
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void MoveEntities([Data] in float time, ref Position pos, ref Velocity vel){
        pos.X += time * vel.X;
        pos.Y += time * vel.Y;
    }
    
    [Query]  // Marks method inside BaseSystem for source generation.
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void DamageEntities(ref Hitted hit, ref Health health){
        health.value -= hit.value;
    }
    
    ... other Queries
}

// Instantiate class and call the generated methods 
MyQueries.MoveEntitiesQuery(someWorld, 10.0f);  // World is always required for the generated method, 10.0f is the [Data] parameter
MyQueries.DamageEntitiesQuery(someWorld);

Parallel / Multithreaded Querys

Since the latest version, the source generator also supports multithreaded/parallel queries. All you have to do is set the attribute in the query attribute, the rest happens automatically. However, this only works for static methods.

[Query(Parallel = true)]  // Method is being called by Archs multithreading. 
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void MoveEntities([Data] in float time, ref Position pos, ref Velocity vel){
    pos.X += time * vel.X;
    pos.Y += time * vel.Y;
}

Project configuration using sources

If you don't use the nugget but the source, you have to make sure that the Sourcegenerator is linked appropriately. To do this, you must store the Sourcegenerator appropriately in the .csproj of your project.

  <ItemGroup>
    ...
    <ProjectReference Include="..\Arch\src\Arch\Arch.csproj" />                        // In case you use Arch by source
    <ProjectReference Include="..\Arch.Extended\Arch.System\Arch.System.csproj" />     // In case you also use Arch.System by source
    <ProjectReference Include="..\Arch.Extended\Arch.System.SourceGenerator\Arch.System.SourceGenerator.csproj" OutputItemType="Analyzer" ReferenceOutputAssembly="false" />
  </ItemGroup>