modtainers
/
Svelto.ECS
mirror of https://github.com/sebas77/Svelto.ECS
Watch 4
Star 0
Fork 0
Code Issues 0 Releases 49 Wiki Activity
Mirror of Svelto.ECS because we're a fan of it
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
427 Commits
4 Branches
3.7MB
Tree: 01d75b3f32
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '01d75b3f32'
${ noResults }
Svelto.ECS/Core/Groups/GroupCompound.cs

294 lines
13KB
Raw Blame History 

  1. using System;

  2. using System.Collections.Generic;

  3. using System.Threading;

  4. using Svelto.DataStructures;

  5. 

  6. namespace Svelto.ECS

  7. {

  8.     public abstract class GroupCompound<G1, G2, G3, G4> where G1 : GroupTag<G1>

  9.                                                         where G2 : GroupTag<G2>

  10.                                                         where G3 : GroupTag<G3>

  11.                                                         where G4 : GroupTag<G4>

  12.     {

  13.         static readonly FasterList<ExclusiveGroupStruct> _Groups;

  14.         static readonly HashSet<ExclusiveGroupStruct>    _GroupsHashSet;

  15. 

  16.         public static FasterReadOnlyList<ExclusiveGroupStruct> Groups =>

  17.             new FasterReadOnlyList<ExclusiveGroupStruct>(_Groups);

  18. 

  19.         public static ExclusiveBuildGroup BuildGroup => new ExclusiveBuildGroup(_Groups[0]);

  20. 

  21.         static int isInitializing;

  22. 

  23.         static GroupCompound()

  24.         {

  25.             if (Interlocked.CompareExchange(ref isInitializing, 1, 0) == 0)

  26.             {

  27.                 _Groups = new FasterList<ExclusiveGroupStruct>(1);

  28. 

  29.                 var Group = new ExclusiveGroup();

  30.                 _Groups.Add(Group);

  31.                 _GroupsHashSet = new HashSet<ExclusiveGroupStruct>(_Groups.ToArrayFast(out _));

  32. 

  33.                 GroupCompound<G1, G2, G3>.Add(Group);

  34.                 GroupCompound<G1, G2, G4>.Add(Group);

  35.                 GroupCompound<G1, G3, G4>.Add(Group);

  36.                 GroupCompound<G2, G3, G4>.Add(Group);

  37. 

  38.                 GroupCompound<G1, G2>.Add(Group); //<G1/G2> and <G2/G1> must share the same array

  39.                 GroupCompound<G1, G3>.Add(Group);

  40.                 GroupCompound<G1, G4>.Add(Group);

  41.                 GroupCompound<G2, G3>.Add(Group);

  42.                 GroupCompound<G2, G4>.Add(Group);

  43.                 GroupCompound<G3, G4>.Add(Group);

  44. 

  45.                 //This is done here to be sure that the group is added once per group tag

  46.                 //(if done inside the previous group compound it would be added multiple times)

  47.                 GroupTag<G1>.Add(Group);

  48.                 GroupTag<G2>.Add(Group);

  49.                 GroupTag<G3>.Add(Group);

  50.                 GroupTag<G4>.Add(Group);

  51. 

  52. #if DEBUG

  53.                 GroupNamesMap.idToName[(uint) Group] =

  54.                     $"Compound: {typeof(G1).Name}-{typeof(G2).Name}-{typeof(G3).Name}-{typeof(G4).Name} ID {(uint) Group}";

  55. #endif

  56.                  GroupHashMap.RegisterGroup(BuildGroup,

  57.                     $"Compound: {typeof(G1).Name}-{typeof(G2).Name}-{typeof(G3).Name}-{typeof(G4).Name}");

  58. 

  59.                 //all the combinations must share the same group and group hashset

  60.                 GroupCompound<G1, G2, G4, G3>._Groups = _Groups;

  61.                 GroupCompound<G1, G3, G2, G4>._Groups = _Groups;

  62.                 GroupCompound<G1, G3, G4, G2>._Groups = _Groups;

  63.                 GroupCompound<G1, G4, G2, G3>._Groups = _Groups;

  64.                 GroupCompound<G2, G1, G3, G4>._Groups = _Groups;

  65.                 GroupCompound<G2, G3, G4, G1>._Groups = _Groups;

  66.                 GroupCompound<G3, G1, G2, G4>._Groups = _Groups;

  67.                 GroupCompound<G4, G1, G2, G3>._Groups = _Groups;

  68.                 GroupCompound<G1, G4, G3, G2>._Groups = _Groups;

  69.                 GroupCompound<G2, G1, G4, G3>._Groups = _Groups;

  70.                 GroupCompound<G2, G4, G3, G1>._Groups = _Groups;

  71.                 GroupCompound<G3, G1, G4, G2>._Groups = _Groups;

  72.                 GroupCompound<G4, G1, G3, G2>._Groups = _Groups;

  73.                 GroupCompound<G2, G3, G1, G4>._Groups = _Groups;

  74.                 GroupCompound<G3, G4, G1, G2>._Groups = _Groups;

  75.                 GroupCompound<G2, G4, G1, G3>._Groups = _Groups;

  76.                 GroupCompound<G3, G2, G1, G4>._Groups = _Groups;

  77.                 GroupCompound<G3, G2, G4, G1>._Groups = _Groups;

  78.                 GroupCompound<G3, G4, G2, G1>._Groups = _Groups;

  79.                 GroupCompound<G4, G2, G1, G3>._Groups = _Groups;

  80.                 GroupCompound<G4, G2, G3, G1>._Groups = _Groups;

  81.                 GroupCompound<G4, G3, G1, G2>._Groups = _Groups;

  82.                 GroupCompound<G4, G3, G2, G1>._Groups = _Groups;

  83. 

  84.                 GroupCompound<G1, G2, G4, G3>._GroupsHashSet = _GroupsHashSet;

  85.                 GroupCompound<G1, G3, G2, G4>._GroupsHashSet = _GroupsHashSet;

  86.                 GroupCompound<G1, G3, G4, G2>._GroupsHashSet = _GroupsHashSet;

  87.                 GroupCompound<G1, G4, G2, G3>._GroupsHashSet = _GroupsHashSet;

  88.                 GroupCompound<G2, G1, G3, G4>._GroupsHashSet = _GroupsHashSet;

  89.                 GroupCompound<G2, G3, G4, G1>._GroupsHashSet = _GroupsHashSet;

  90.                 GroupCompound<G3, G1, G2, G4>._GroupsHashSet = _GroupsHashSet;

  91.                 GroupCompound<G4, G1, G2, G3>._GroupsHashSet = _GroupsHashSet;

  92.                 GroupCompound<G1, G4, G3, G2>._GroupsHashSet = _GroupsHashSet;

  93.                 GroupCompound<G2, G1, G4, G3>._GroupsHashSet = _GroupsHashSet;

  94.                 GroupCompound<G2, G4, G3, G1>._GroupsHashSet = _GroupsHashSet;

  95.                 GroupCompound<G3, G1, G4, G2>._GroupsHashSet = _GroupsHashSet;

  96.                 GroupCompound<G4, G1, G3, G2>._GroupsHashSet = _GroupsHashSet;

  97.                 GroupCompound<G2, G3, G1, G4>._GroupsHashSet = _GroupsHashSet;

  98.                 GroupCompound<G3, G4, G1, G2>._GroupsHashSet = _GroupsHashSet;

  99.                 GroupCompound<G2, G4, G1, G3>._GroupsHashSet = _GroupsHashSet;

  100.                 GroupCompound<G3, G2, G1, G4>._GroupsHashSet = _GroupsHashSet;

  101.                 GroupCompound<G3, G2, G4, G1>._GroupsHashSet = _GroupsHashSet;

  102.                 GroupCompound<G3, G4, G2, G1>._GroupsHashSet = _GroupsHashSet;

  103.                 GroupCompound<G4, G2, G1, G3>._GroupsHashSet = _GroupsHashSet;

  104.                 GroupCompound<G4, G2, G3, G1>._GroupsHashSet = _GroupsHashSet;

  105.                 GroupCompound<G4, G3, G1, G2>._GroupsHashSet = _GroupsHashSet;

  106.                 GroupCompound<G4, G3, G2, G1>._GroupsHashSet = _GroupsHashSet;

  107.             }

  108.         }

  109. 

  110.         internal static void Add(ExclusiveGroupStruct @group)

  111.         {

  112.             for (int i = 0; i < _Groups.count; ++i)

  113.                 if (_Groups[i] == group)

  114.                     throw new Exception("temporary must be transformed in unit test");

  115. 

  116.             _Groups.Add(group);

  117.             _GroupsHashSet.Add(group);

  118.         }

  119. 

  120.         public static bool Includes(ExclusiveGroupStruct @group) { return _GroupsHashSet.Contains(@group); }

  121.     }

  122. 

  123.     public abstract class GroupCompound<G1, G2, G3>

  124.         where G1 : GroupTag<G1> where G2 : GroupTag<G2> where G3 : GroupTag<G3>

  125.     {

  126.         static readonly FasterList<ExclusiveGroupStruct> _Groups;

  127.         static readonly HashSet<ExclusiveGroupStruct>    _GroupsHashSet;

  128. 

  129.         public static FasterReadOnlyList<ExclusiveGroupStruct> Groups =>

  130.             new FasterReadOnlyList<ExclusiveGroupStruct>(_Groups);

  131. 

  132.         public static ExclusiveBuildGroup BuildGroup => new ExclusiveBuildGroup(_Groups[0]);

  133.         

  134.         static int isInitializing;

  135. 

  136.         internal static void Add(ExclusiveGroupStruct group)

  137.         {

  138.             for (var i = 0; i < _Groups.count; ++i)

  139.                 if (_Groups[i] == group)

  140.                     throw new Exception("temporary must be transformed in unit test");

  141. 

  142.             _Groups.Add(group);

  143.             _GroupsHashSet.Add(group);

  144.         }

  145. 

  146.         public static bool Includes(ExclusiveGroupStruct @group) { return _GroupsHashSet.Contains(@group); }

  147. 

  148.         static GroupCompound()

  149.         {

  150.             if (Interlocked.CompareExchange(ref isInitializing, 1, 0) == 0)

  151.             {

  152.                 _Groups = new FasterList<ExclusiveGroupStruct>(1);

  153. 

  154.                 var Group = new ExclusiveGroup();

  155.                 _Groups.Add(Group);

  156.                 _GroupsHashSet = new HashSet<ExclusiveGroupStruct>(_Groups.ToArrayFast(out _));

  157. 

  158.                 GroupCompound<G1, G2>.Add(Group); //<G1/G2> and <G2/G1> must share the same array

  159.                 GroupCompound<G1, G3>.Add(Group);

  160.                 GroupCompound<G2, G3>.Add(Group);

  161. 

  162.                 //This is done here to be sure that the group is added once per group tag

  163.                 //(if done inside the previous group compound it would be added multiple times)

  164.                 GroupTag<G1>.Add(Group);

  165.                 GroupTag<G2>.Add(Group);

  166.                 GroupTag<G3>.Add(Group);

  167. 

  168. #if DEBUG

  169.                 GroupNamesMap.idToName[(uint) Group] =

  170.                     $"Compound: {typeof(G1).Name}-{typeof(G2).Name}-{typeof(G3).Name} ID {(uint) Group}";

  171. #endif

  172.                 GroupHashMap.RegisterGroup(BuildGroup,

  173.                     $"Compound: {typeof(G1).Name}-{typeof(G2).Name}-{typeof(G3).Name}");

  174.                 

  175.                 //all the combinations must share the same group and group hashset

  176.                 GroupCompound<G3, G1, G2>._Groups = _Groups;

  177.                 GroupCompound<G2, G3, G1>._Groups = _Groups;

  178.                 GroupCompound<G3, G2, G1>._Groups = _Groups;

  179.                 GroupCompound<G1, G3, G2>._Groups = _Groups;

  180.                 GroupCompound<G2, G1, G3>._Groups = _Groups;

  181. 

  182.                 GroupCompound<G3, G1, G2>._GroupsHashSet = _GroupsHashSet;

  183.                 GroupCompound<G2, G3, G1>._GroupsHashSet = _GroupsHashSet;

  184.                 GroupCompound<G3, G2, G1>._GroupsHashSet = _GroupsHashSet;

  185.                 GroupCompound<G1, G3, G2>._GroupsHashSet = _GroupsHashSet;

  186.                 GroupCompound<G2, G1, G3>._GroupsHashSet = _GroupsHashSet;

  187.             }

  188.         }

  189.     }

  190. 

  191.     public abstract class GroupCompound<G1, G2> where G1 : GroupTag<G1> where G2 : GroupTag<G2>

  192.     {

  193.         static readonly FasterList<ExclusiveGroupStruct> _Groups;

  194.         static readonly HashSet<ExclusiveGroupStruct>    _GroupsHashSet;

  195. 

  196.         public static FasterReadOnlyList<ExclusiveGroupStruct> Groups =>

  197.             new FasterReadOnlyList<ExclusiveGroupStruct>(_Groups);

  198. 

  199.         public static ExclusiveBuildGroup BuildGroup => new ExclusiveBuildGroup(_Groups[0]);

  200.         

  201.         static int isInitializing;

  202. 

  203.         internal static void Add(ExclusiveGroupStruct group)

  204.         {

  205.             for (var i = 0; i < _Groups.count; ++i)

  206.                 if (_Groups[i] == group)

  207.                     throw new Exception("temporary must be transformed in unit test");

  208. 

  209.             _Groups.Add(group);

  210.             _GroupsHashSet.Add(group);

  211.         }

  212. 

  213.         public static bool Includes(ExclusiveGroupStruct @group) { return _GroupsHashSet.Contains(@group); }

  214. 

  215.         static GroupCompound()

  216.         {

  217.             if (Interlocked.CompareExchange(ref isInitializing, 1, 0) == 0)

  218.             {

  219.                 var Group = new ExclusiveGroup();

  220. 

  221.                 _Groups = new FasterList<ExclusiveGroupStruct>(1);

  222.                 _Groups.Add(Group);

  223.                 _GroupsHashSet = new HashSet<ExclusiveGroupStruct>(_Groups.ToArrayFast(out _));

  224. 

  225.                 //every abstract group preemptively adds this group, it may or may not be empty in future

  226.                 GroupTag<G1>.Add(Group);

  227.                 GroupTag<G2>.Add(Group);

  228. 

  229. #if DEBUG

  230.                 GroupNamesMap.idToName[(uint) Group] = $"Compound: {typeof(G1).Name}-{typeof(G2).Name} ID {(uint) Group}";

  231. #endif

  232.                  GroupHashMap.RegisterGroup(BuildGroup,

  233.                     $"Compound: {typeof(G1).Name}-{typeof(G2).Name}");

  234. 

  235.                 GroupCompound<G2, G1>._Groups                  = _Groups;

  236.                 GroupCompound<G2, G1>._GroupsHashSet           = _GroupsHashSet;

  237.             }

  238.         }

  239.     }

  240. 

  241.     /// <summary>

  242.     ///A Group Tag holds initially just a group, itself. However the number of groups can grow with the number of

  243.     ///combinations of GroupTags including this one. This because a GroupTag is an adjective and different entities

  244.     ///can use the same adjective together with other ones. However since I need to be able to iterate over all the

  245.     ///groups with the same adjective, a group tag needs to hold all the groups sharing it.

  246.     /// </summary>

  247.     /// <typeparam name="T"></typeparam>

  248.     public abstract class GroupTag<T> where T : GroupTag<T>

  249.     {

  250.         static readonly FasterList<ExclusiveGroupStruct> _Groups = new FasterList<ExclusiveGroupStruct>(1);

  251.         static readonly HashSet<ExclusiveGroupStruct>    _GroupsHashSet;

  252. 

  253.         public static FasterReadOnlyList<ExclusiveGroupStruct> Groups =>

  254.             new FasterReadOnlyList<ExclusiveGroupStruct>(_Groups);

  255. 

  256.         public static ExclusiveBuildGroup BuildGroup => new ExclusiveBuildGroup(_Groups[0]);

  257.         

  258.         static int isInitializing;

  259. 

  260.         static GroupTag()

  261.         {

  262.             if (Interlocked.CompareExchange(ref isInitializing, 1, 0) == 0)

  263.             {

  264.                 var group = new ExclusiveGroup();

  265.                 _Groups.Add(group);

  266.                 _GroupsHashSet = new HashSet<ExclusiveGroupStruct>(_Groups.ToArrayFast(out _));

  267. 

  268. #if DEBUG

  269.                 var typeInfo         = typeof(T);

  270.                 var typeInfoBaseType = typeInfo.BaseType;

  271.                 if (typeInfoBaseType.GenericTypeArguments[0] != typeInfo)

  272.                     throw new ECSException("Invalid Group Tag declared");

  273. 

  274.                 GroupNamesMap.idToName[(uint)group] = $"Compound: {typeInfo.Name} ID {(uint)group}";

  275. #endif

  276.  GroupHashMap.RegisterGroup(BuildGroup,

  277.                 $"Compound: {typeof(T).FullName}");

  278.                 }

  279.         }

  280. 

  281.         //Each time a new combination of group tags is found a new group is added.

  282.         internal static void Add(ExclusiveGroupStruct group)

  283.         {

  284.             for (var i = 0; i < _Groups.count; ++i)

  285.                 if (_Groups[i] == group)

  286.                     throw new Exception("temporary must be transformed in unit test");

  287. 

  288.             _Groups.Add(group);

  289.             _GroupsHashSet.Add(group);

  290.         }

  291. 

  292.         public static bool Includes(ExclusiveGroupStruct @group) { return _GroupsHashSet.Contains(@group); }

  293.     }

  294. }