diff --git a/Svelto.ECS/.github/FUNDING.yml b/Svelto.ECS/.github/FUNDING.yml new file mode 100644 index 0000000..f6dca80 --- /dev/null +++ b/Svelto.ECS/.github/FUNDING.yml @@ -0,0 +1,3 @@ +# These are supported funding model platforms + +custom: https://www.paypal.me/smandala diff --git a/Svelto.ECS/.gitignore b/Svelto.ECS/.gitignore new file mode 100644 index 0000000..7ef0a76 --- /dev/null +++ b/Svelto.ECS/.gitignore @@ -0,0 +1,3 @@ +/obj +/bin/Release/netstandard2.0 +/bin/Debug/netstandard2.0 diff --git a/Svelto.ECS/.gitmodules b/Svelto.ECS/.gitmodules new file mode 100644 index 0000000..e69de29 diff --git a/Svelto.ECS/LICENSE b/Svelto.ECS/LICENSE new file mode 100644 index 0000000..d3cfdc7 --- /dev/null +++ b/Svelto.ECS/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2018 Sebastiano Mandalà + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/Svelto.ECS/README.md b/Svelto.ECS/README.md new file mode 100644 index 0000000..8452fda --- /dev/null +++ b/Svelto.ECS/README.md @@ -0,0 +1,84 @@ +[![openupm](https://img.shields.io/npm/v/com.sebaslab.svelto.ecs?label=openupm®istry_uri=https://package.openupm.com)](https://openupm.com/packages/com.sebaslab.svelto.ecs/) + +# Svelto Entity Component System 2.9 + +===================================== + +Real ECS framework for c\#. Enables to write encapsulated, decoupled, maintainable, highly efficient, data oriented, cache friendly, multi-threaded (if used with Svelto.Tasks), code without pain. Although the framework is platform agnostic \(compatible with c\# 7 and .net standard 2.0\), it comes with several Unity extensions. + +## Why using Svelto.ECS with Unity? + +_Svelto.ECS wasn't born just from the needs of a large team, but also as result of years of reasoning behind software engineering applied to game development\(\*\). Compared to Unity.ECS, the main goals and reasons for Svelto.ECS to exist are different enough to justify its on going development \(plus Svelto is platform agnostic, so it has been written with portability in mind\). Svelto.ECS hasn't been written just to develop faster code, it has been built to help develop better code. Performance gain is one of the benefits in using Svelto.ECS, as ECS in general is a great way to write cache-friendly code. However Svelto.ECS has been designed around the shift of paradigm from Object Oriented Programming and the consequent improvement of the code design and maintainability. Svelto.ECS is the result of years of iteration of the ECS paradigm applied to real game development with the intent to be "junior coder proof"._ + +## Official Examples + +* **Mini Examples**: [https://github.com/sebas77/Svelto.MiniExamples](https://github.com/sebas77/Svelto.MiniExamples) \(including articles\) +* **Unity Boids Simulation**: [https://github.com/sebas77/Svelto.ECS.Examples.Boids](https://github.com/sebas77/Svelto.ECS.Examples.Boids) \(including article\) +* **Unit Tests**: [https://github.com/sebas77/Svelto.ECS.Tests](https://github.com/sebas77/Svelto.ECS.Tests) + +**Official Chat \(join to get help from me!\)** + +* [https://discord.gg/3qAdjDb](https://discord.gg/3qAdjDb) + +## Official Articles + +**Framework articles:** + +* [http://www.sebaslab.com/introducing-svelto-ecs-2-9/](http://www.sebaslab.com/introducing-svelto-ecs-2-9/) \(shows what's changed since 2.8\) +* [http://www.sebaslab.com/introducing-svelto-ecs-2-8/](http://www.sebaslab.com/introducing-svelto-ecs-2-8/) \(shows what's changed since 2.7\) +* [http://www.sebaslab.com/svelto-2-7-whats-new-and-best-practices/](http://www.sebaslab.com/svelto-2-7-whats-new-and-best-practices/) \(shows what's changed since 2.5\) +* [http://www.sebaslab.com/svelto-ecs-2-5-and-allocation-0-code/](http://www.sebaslab.com/svelto-ecs-2-5-and-allocation-0-code/) \(shows what's changed since 2.0\) +* [http://www.sebaslab.com/svelto-ecs-2-0-almost-production-ready/](http://www.sebaslab.com/svelto-ecs-2-0-almost-production-ready/) \(shows what's changed since 1.0\) +* [http://www.sebaslab.com/ecs-1-0/](http://www.sebaslab.com/ecs-1-0/) +* [http://www.sebaslab.com/learning-svelto-ecs-by-example-the-unity-survival-example/](http://www.sebaslab.com/learning-svelto-ecs-by-example-the-unity-survival-example/) +* [http://www.sebaslab.com/learning-svelto-ecs-by-example-the-vanilla-example/](http://www.sebaslab.com/learning-svelto-ecs-by-example-the-vanilla-example/) +* [http://www.sebaslab.com/svelto-ecs-svelto-tasks-to-write-data-oriented-cache-friendly-multi-threaded-code-in-unity/](http://www.sebaslab.com/svelto-ecs-svelto-tasks-to-write-data-oriented-cache-friendly-multi-threaded-code-in-unity/) + +**Theory related articles \(in order of publishing date\):** + +* [http://www.sebaslab.com/ioc-container-for-unity3d-part-1/](http://www.sebaslab.com/ioc-container-for-unity3d-part-1/) +* [http://www.sebaslab.com/ioc-container-for-unity3d-part-2/](http://www.sebaslab.com/ioc-container-for-unity3d-part-2/) +* [http://www.sebaslab.com/the-truth-behind-inversion-of-control-part-i-dependency-injection/](http://www.sebaslab.com/the-truth-behind-inversion-of-control-part-i-dependency-injection/) +* [http://www.sebaslab.com/the-truth-behind-inversion-of-control-part-ii-inversion-of-control/](http://www.sebaslab.com/the-truth-behind-inversion-of-control-part-ii-inversion-of-control/) +* [http://www.sebaslab.com/the-truth-behind-inversion-of-control-part-iii-entity-component-systems/](http://www.sebaslab.com/the-truth-behind-inversion-of-control-part-iii-entity-component-systems/) +* [http://www.sebaslab.com/the-truth-behind-inversion-of-control-part-iv-dependency-inversion-principle/](http://www.sebaslab.com/the-truth-behind-inversion-of-control-part-iv-dependency-inversion-principle/) +* [http://www.sebaslab.com/the-truth-behind-inversion-of-control-part-v-drifting-away-from-ioc-containers/](http://www.sebaslab.com/the-truth-behind-inversion-of-control-part-v-drifting-away-from-ioc-containers/) +* [http://www.sebaslab.com/the-quest-for-maintainable-code-and-the-path-to-ecs/](http://www.sebaslab.com/the-quest-for-maintainable-code-and-the-path-to-ecs/) + +Note: I included the IoC articles just to show how I shifted over the years from using an IoC container to use an ECS framework and the rationale behind its adoption. + +**The perfect companion for Svelto.ECS is Svelto.Tasks to run the logic of the Systems even on other threads!** + +* [https://github.com/sebas77/Svelto.Tasks](https://github.com/sebas77/Svelto.Tasks) + +## Users Generated Content \(may use old versions of Svelto and be quite outdated\) + +* [https://github.com/grovemaster/Unity3D-Game-App](https://github.com/grovemaster/Unity3D-Game-App) +* [https://github.com/colonelsalt/ZombieDeathBoomECS](https://github.com/colonelsalt/ZombieDeathBoomECS) +* [https://eagergames.wordpress.com/category/ecs/](https://eagergames.wordpress.com/category/ecs/) \(Dario Oliveri\) +* [https://blogs.msdn.microsoft.com/uk\_faculty\_connection/2018/05/08/entity-component-system-in-unity-a-tutorial/](https://blogs.msdn.microsoft.com/uk_faculty_connection/2018/05/08/entity-component-system-in-unity-a-tutorial/) \(Lee Stott\) +* [https://github.com/sebas77/Svelto.ECS.Debugger](https://github.com/sebas77/Svelto.ECS.Debugger) \(work just started\) +* [https://github.com/NED-Studio/LGK.Inspector](https://github.com/NED-Studio/LGK.Inspector) \(probably not working anymore\) + +## In case of bugs + +Best option is to fork and clone [https://github.com/sebas77/Svelto.ECS.Tests](https://github.com/sebas77/Svelto.ECS.Tests), add a new test to reproduce the problem and request a pull. Then open a github, I come here pretty often :\). Also feel free to contact me on twitter or leave comments on the blog! + +## [The Github wiki page](https://github.com/sebas77/Svelto.ECS/wiki) + +It needs love and as far as I understood, anyone can edit it. Feel free to do so if you have a good understanding of Svelto! + +## I like the project, how can I help? + +Hey thanks a lot for considering this. You can help in several ways. The simplest is to talk about Svelto.ECS and spread the word, more we are, better it is for the community. Then you can help with the documentation, updating the wiki or writing your own articles. Svelto.ECS has all the features needed to make a game with the ECS pattern, but some areas are lacking: A visual debugger and more unit tests are needed. Other platforms other than Unity could get some love too: Xenko, Godot and monogame. Porting to other languages, expecially c++, would be awesome! + +## Svelto Framework is used to develop the following products\(\*\): + +![Gamecraft](https://steamcdn-a.akamaihd.net/steamcommunity/public/images/clans/35037633/e05ca4fc6f20f1e6150a6ace1d12fe8cd145fa0d.png) +![Robocraft Infinity](https://i.ytimg.com/vi/m_4fpgHwoBs/maxresdefault.jpg) +![Cardlife](https://i.ytimg.com/vi/q2jaUZjnNyg/maxresdefault.jpg) + +\*if you want your products made with Svelto here, just send me an email or whatever, I'll be super happy to add them. + +_**Note: Dear Svelto Users : Although I am committed to help you and write articles as much as I can, I will never be able to keep all the documentation up to date. If you are a happy svelto user and you want to contribute, please feel free to update the github wiki! 🙏👊**_ + diff --git a/Svelto.ECS/SUMMARY.md b/Svelto.ECS/SUMMARY.md new file mode 100644 index 0000000..e6d872c --- /dev/null +++ b/Svelto.ECS/SUMMARY.md @@ -0,0 +1,4 @@ +# Table of contents + +* [Svelto Entity Component System 2.8](README.md) + diff --git a/Svelto.ECS/Svelto.ECS/.github/FUNDING.yml b/Svelto.ECS/Svelto.ECS/.github/FUNDING.yml new file mode 100644 index 0000000..f6dca80 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/.github/FUNDING.yml @@ -0,0 +1,3 @@ +# These are supported funding model platforms + +custom: https://www.paypal.me/smandala diff --git a/Svelto.ECS/Svelto.ECS/.gitignore b/Svelto.ECS/Svelto.ECS/.gitignore new file mode 100644 index 0000000..7ef0a76 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/.gitignore @@ -0,0 +1,3 @@ +/obj +/bin/Release/netstandard2.0 +/bin/Debug/netstandard2.0 diff --git a/Svelto.ECS/Svelto.ECS/.gitmodules b/Svelto.ECS/Svelto.ECS/.gitmodules new file mode 100644 index 0000000..cd05d00 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/.gitmodules @@ -0,0 +1,3 @@ +[submodule "Svelto.Common"] + path = Svelto.Common + url = https://github.com/sebas77/Svelto.Common diff --git a/Svelto.ECS/Svelto.ECS/AllowMultipleAttribute.cs b/Svelto.ECS/Svelto.ECS/AllowMultipleAttribute.cs new file mode 100644 index 0000000..37c26ec --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/AllowMultipleAttribute.cs @@ -0,0 +1,8 @@ +using System; + +namespace Svelto.ECS +{ + public class AllowMultipleAttribute : Attribute + { + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/AllowMultipleAttribute.cs.meta b/Svelto.ECS/Svelto.ECS/AllowMultipleAttribute.cs.meta new file mode 100644 index 0000000..a2d75c9 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/AllowMultipleAttribute.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 29ca2992915771b4eb047f00a7a4b7a6 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/CheckEntityUtilities.cs b/Svelto.ECS/Svelto.ECS/CheckEntityUtilities.cs new file mode 100644 index 0000000..0b061f6 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/CheckEntityUtilities.cs @@ -0,0 +1,81 @@ +#if DEBUG && !PROFILER +using System.Collections.Generic; +using Svelto.DataStructures; +#else +using System.Diagnostics; +#endif + +namespace Svelto.ECS +{ + public partial class EnginesRoot + { +#if DEBUG && !PROFILER + void CheckRemoveEntityID(EGID egid) + { + // Console.LogError("removed".FastConcat(egid.ToString())); + if (_idCheckers.TryGetValue(egid.groupID, out var hash)) + { + if (hash.Contains(egid.entityID) == false) + throw new ECSException("Entity with not found ID is about to be removed: id: " + .FastConcat(egid.entityID) + .FastConcat(" groupid: ") + .FastConcat(egid.groupID)); + + hash.Remove(egid.entityID); + + if (hash.Count == 0) + _idCheckers.Remove(egid.groupID); + } + else + { + throw new ECSException("Entity with not found ID is about to be removed: id: " + .FastConcat(egid.entityID) + .FastConcat(" groupid: ") + .FastConcat(egid.groupID)); + } + } + + void CheckAddEntityID(EGID egid) + { +// Console.LogError("added ".FastConcat(egid.ToString())); + + if (_idCheckers.TryGetValue(egid.groupID, out var hash) == false) + hash = _idCheckers[egid.groupID] = new HashSet(); + else + { + if (hash.Contains(egid.entityID)) + throw new ECSException("Entity with used ID is about to be built: '" + .FastConcat("' id: '") + .FastConcat(egid.entityID) + .FastConcat("' groupid: '") + .FastConcat(egid.groupID) + .FastConcat("'")); + } + + hash.Add(egid.entityID); + } + + void RemoveGroupID(ExclusiveGroup.ExclusiveGroupStruct groupID) + { + _idCheckers.Remove(groupID); + } + + readonly FasterDictionary> _idCheckers = new FasterDictionary>(); +#else + [Conditional("_CHECKS_DISABLED")] + void CheckRemoveEntityID(EGID egid) + { + } + + [Conditional("_CHECKS_DISABLED")] + void CheckAddEntityID(EGID egid) + { + } + + [Conditional("_CHECKS_DISABLED")] + void RemoveGroupID(ExclusiveGroup.ExclusiveGroupStruct groupID) + { + } +#endif + } +} diff --git a/Svelto.ECS/Svelto.ECS/CheckEntityUtilities.cs.meta b/Svelto.ECS/Svelto.ECS/CheckEntityUtilities.cs.meta new file mode 100644 index 0000000..279a311 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/CheckEntityUtilities.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: cda6cb7ffa71b954dbe3711e152399c2 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/DBC.cs b/Svelto.ECS/Svelto.ECS/DBC.cs new file mode 100644 index 0000000..144c690 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/DBC.cs @@ -0,0 +1,446 @@ +#if DISABLE_DBC || !DEBUG || PROFILER +#define DISABLE_CHECKS +using System.Diagnostics; +#endif +using System; + +namespace DBC.ECS +{ + /// + /// Design By Contract Checks. + /// + /// Each method generates an exception or + /// a trace assertion statement if the contract is broken. + /// + /// + /// This example shows how to call the Require method. + /// Assume DBC_CHECK_PRECONDITION is defined. + /// + /// public void Test(int x) + /// { + /// try + /// { + /// Check.Require(x > 1, "x must be > 1"); + /// } + /// catch (System.Exception ex) + /// { + /// Console.WriteLine(ex.ToString()); + /// } + /// } + /// + /// If you wish to use trace assertion statements, intended for Debug scenarios, + /// rather than exception handling then set + /// + /// Check.UseAssertions = true + /// + /// You can specify this in your application entry point and maybe make it + /// dependent on conditional compilation flags or configuration file settings, e.g., + /// + /// #if DBC_USE_ASSERTIONS + /// Check.UseAssertions = true; + /// #endif + /// + /// You can direct output to a Trace listener. For example, you could insert + /// + /// Trace.Listeners.Clear(); + /// Trace.Listeners.Add(new TextWriterTraceListener(Console.Out)); + /// + /// + /// or direct output to a file or the Event Log. + /// + /// (Note: For ASP.NET clients use the Listeners collection + /// of the Debug, not the Trace, object and, for a Release build, only exception-handling + /// is possible.) + /// + /// + static class Check + { + #region Interface + + /// + /// Precondition check. + /// +#if DISABLE_CHECKS + [Conditional("__NEVER_DEFINED__")] +#endif + public static void Require(bool assertion, string message) + { + if (UseExceptions) + { + if (!assertion) + throw new PreconditionException(message); + } + else + { + Trace.Assert(assertion, "Precondition: " + message); + } + } + + /// + /// Precondition check. + /// + /// +#if DISABLE_CHECKS + [Conditional("__NEVER_DEFINED__")] +#endif + public static void Require(bool assertion, string message, Exception inner) + { + if (UseExceptions) + { + if (!assertion) + throw new PreconditionException(message, inner); + } + else + { + Trace.Assert(assertion, "Precondition: " + message); + } + } + + /// + /// Precondition check. + /// + /// +#if DISABLE_CHECKS + [Conditional("__NEVER_DEFINED__")] +#endif + public static void Require(bool assertion) + { + if (UseExceptions) + { + if (!assertion) + throw new PreconditionException("Precondition failed."); + } + else + { + Trace.Assert(assertion, "Precondition failed."); + } + } + + /// + /// Postcondition check. + /// + /// +#if DISABLE_CHECKS + [Conditional("__NEVER_DEFINED__")] +#endif + public static void Ensure(bool assertion, string message) + { + if (UseExceptions) + { + if (!assertion) + throw new PostconditionException(message); + } + else + { + Trace.Assert(assertion, "Postcondition: " + message); + } + } + + /// + /// Postcondition check. + /// + /// +#if DISABLE_CHECKS + [Conditional("__NEVER_DEFINED__")] +#endif + public static void Ensure(bool assertion, string message, Exception inner) + { + if (UseExceptions) + { + if (!assertion) + throw new PostconditionException(message, inner); + } + else + { + Trace.Assert(assertion, "Postcondition: " + message); + } + } + + /// + /// Postcondition check. + /// + /// +#if DISABLE_CHECKS + [Conditional("__NEVER_DEFINED__")] +#endif + public static void Ensure(bool assertion) + { + if (UseExceptions) + { + if (!assertion) + throw new PostconditionException("Postcondition failed."); + } + else + { + Trace.Assert(assertion, "Postcondition failed."); + } + } + + /// + /// Invariant check. + /// + /// +#if DISABLE_CHECKS + [Conditional("__NEVER_DEFINED__")] +#endif + public static void Invariant(bool assertion, string message) + { + if (UseExceptions) + { + if (!assertion) + throw new InvariantException(message); + } + else + { + Trace.Assert(assertion, "Invariant: " + message); + } + } + + /// + /// Invariant check. + /// + /// +#if DISABLE_CHECKS + [Conditional("__NEVER_DEFINED__")] +#endif + public static void Invariant(bool assertion, string message, Exception inner) + { + if (UseExceptions) + { + if (!assertion) + throw new InvariantException(message, inner); + } + else + { + Trace.Assert(assertion, "Invariant: " + message); + } + } + + /// + /// Invariant check. + /// + /// +#if DISABLE_CHECKS + [Conditional("__NEVER_DEFINED__")] +#endif + public static void Invariant(bool assertion) + { + if (UseExceptions) + { + if (!assertion) + throw new InvariantException("Invariant failed."); + } + else + { + Trace.Assert(assertion, "Invariant failed."); + } + } + + /// + /// Assertion check. + /// +#if DISABLE_CHECKS + [Conditional("__NEVER_DEFINED__")] +#endif + public static void Assert(bool assertion, string message) + { + if (UseExceptions) + { + if (!assertion) + throw new AssertionException(message); + } + else + { + Trace.Assert(assertion, "Assertion: " + message); + } + } + + /// + /// Assertion check. + /// + /// +#if DISABLE_CHECKS + [Conditional("__NEVER_DEFINED__")] +#endif + public static void Assert(bool assertion, string message, Exception inner) + { + if (UseExceptions) + { + if (!assertion) + throw new AssertionException(message, inner); + } + else + { + Trace.Assert(assertion, "Assertion: " + message); + } + } + + /// + /// Assertion check. + /// + /// +#if DISABLE_CHECKS + [Conditional("__NEVER_DEFINED__")] +#endif + public static void Assert(bool assertion) + { + if (UseExceptions) + { + if (!assertion) + throw new AssertionException("Assertion failed."); + } + else + { + Trace.Assert(assertion, "Assertion failed."); + } + } + + /// + /// Set this if you wish to use Trace Assert statements + /// instead of exception handling. + /// (The Check class uses exception handling by default.) + /// + public static bool UseAssertions + { + + get + { + return useAssertions; + } + set + { + useAssertions = value; + } + } + + #endregion // Interface + + #region Implementation + + // No creation + + /// + /// Is exception handling being used? + /// + static bool UseExceptions + { + get + { + return !useAssertions; + } + } + + // Are trace assertion statements being used? + // Default is to use exception handling. + static bool useAssertions; + + #endregion // Implementation + + } // End Check + + internal class Trace + { + internal static void Assert(bool assertion, string v) + { +#if NETFX_CORE + System.Diagnostics.Contracts.Contract.Assert(assertion, v); +#else + System.Diagnostics.Trace.Assert(assertion, v); +#endif + } + } + + #region Exceptions + + /// + /// Exception raised when a contract is broken. + /// Catch this exception type if you wish to differentiate between + /// any DesignByContract exception and other runtime exceptions. + /// + /// + public class DesignByContractException : Exception + { + protected DesignByContractException() {} + protected DesignByContractException(string message) : base(message) {} + protected DesignByContractException(string message, Exception inner) : base(message, inner) {} + } + + /// + /// Exception raised when a precondition fails. + /// + public class PreconditionException : DesignByContractException + { + /// + /// Precondition Exception. + /// + public PreconditionException() {} + /// + /// Precondition Exception. + /// + public PreconditionException(string message) : base(message) {} + /// + /// Precondition Exception. + /// + public PreconditionException(string message, Exception inner) : base(message, inner) {} + } + + /// + /// Exception raised when a postcondition fails. + /// + public class PostconditionException : DesignByContractException + { + /// + /// Postcondition Exception. + /// + public PostconditionException() {} + /// + /// Postcondition Exception. + /// + public PostconditionException(string message) : base(message) {} + /// + /// Postcondition Exception. + /// + public PostconditionException(string message, Exception inner) : base(message, inner) {} + } + + /// + /// Exception raised when an invariant fails. + /// + public class InvariantException : DesignByContractException + { + /// + /// Invariant Exception. + /// + public InvariantException() {} + /// + /// Invariant Exception. + /// + public InvariantException(string message) : base(message) {} + /// + /// Invariant Exception. + /// + public InvariantException(string message, Exception inner) : base(message, inner) {} + } + + /// + /// Exception raised when an assertion fails. + /// + public class AssertionException : DesignByContractException + { + /// + /// Assertion Exception. + /// + public AssertionException() {} + /// + /// Assertion Exception. + /// + public AssertionException(string message) : base(message) {} + /// + /// Assertion Exception. + /// + public AssertionException(string message, Exception inner) : base(message, inner) {} + } + + #endregion // Exception classes + +} // End Design By Contract diff --git a/Svelto.ECS/Svelto.ECS/DBC.cs.meta b/Svelto.ECS/Svelto.ECS/DBC.cs.meta new file mode 100644 index 0000000..9b8e7c7 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/DBC.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: f25d12935fd762e40841aa5c56e603e4 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/DataStructures.meta b/Svelto.ECS/Svelto.ECS/DataStructures.meta new file mode 100644 index 0000000..4f856f2 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/DataStructures.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 9d98d8ed291a59c4890021f6391142ca +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/DataStructures/SetEGIDWithoutBoxing.cs b/Svelto.ECS/Svelto.ECS/DataStructures/SetEGIDWithoutBoxing.cs new file mode 100644 index 0000000..828e598 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/DataStructures/SetEGIDWithoutBoxing.cs @@ -0,0 +1,46 @@ +using System; +using System.Linq.Expressions; +using System.Reflection; + +namespace Svelto.ECS.Internal +{ + static class SetEGIDWithoutBoxing where T : struct, IEntityStruct + { + internal delegate void ActionCast(ref T target, EGID egid); + + public static readonly ActionCast SetIDWithoutBoxing = MakeSetter(); + + static ActionCast MakeSetter() + { + if (EntityBuilder.HAS_EGID) + { +#if !ENABLE_IL2CPP + Type myTypeA = typeof(T); + PropertyInfo myFieldInfo = myTypeA.GetProperty("ID"); + + ParameterExpression targetExp = Expression.Parameter(typeof(T).MakeByRefType(), "target"); + ParameterExpression valueExp = Expression.Parameter(typeof(EGID), "value"); + MemberExpression fieldExp = Expression.Property(targetExp, myFieldInfo); + BinaryExpression assignExp = Expression.Assign(fieldExp, valueExp); + + var setter = Expression.Lambda(assignExp, targetExp, valueExp).Compile(); + + return setter; +#else + return (ref T target, EGID value) => + { + var needEgid = (target as INeedEGID); + needEgid.ID = value; + target = (T) needEgid; + }; +#endif + } + + return null; + } + + public static void Warmup() + { + } + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/DataStructures/SetEGIDWithoutBoxing.cs.meta b/Svelto.ECS/Svelto.ECS/DataStructures/SetEGIDWithoutBoxing.cs.meta new file mode 100644 index 0000000..37e4e56 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/DataStructures/SetEGIDWithoutBoxing.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 1e8610cc771cdeb46a808788e49b21d1 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/DataStructures/TypeSafeDictionary.cs b/Svelto.ECS/Svelto.ECS/DataStructures/TypeSafeDictionary.cs new file mode 100644 index 0000000..d902d72 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/DataStructures/TypeSafeDictionary.cs @@ -0,0 +1,222 @@ +using System; +using Svelto.Common; +using Svelto.DataStructures; + +namespace Svelto.ECS.Internal +{ + public interface ITypeSafeDictionary + { + int Count { get; } + ITypeSafeDictionary Create(); + + void AddEntitiesToEngines( + FasterDictionary, FasterList> entityViewEnginesDb, + ITypeSafeDictionary realDic, in PlatformProfiler profiler, ExclusiveGroup.ExclusiveGroupStruct @group); + + void RemoveEntitiesFromEngines(FasterDictionary, FasterList> entityViewEnginesDB, + in PlatformProfiler profiler, ExclusiveGroup.ExclusiveGroupStruct @group); + + void AddEntitiesFromDictionary(ITypeSafeDictionary entitiesToSubmit, uint groupId); + + void MoveEntityFromEngines(EGID fromEntityGid, EGID? toEntityID, ITypeSafeDictionary toGroup, + FasterDictionary, FasterList> engines, in PlatformProfiler profiler); + + void AddEntityToDictionary(EGID fromEntityGid, EGID toEntityID, ITypeSafeDictionary toGroup); + void RemoveEntityFromDictionary(EGID fromEntityGid, in PlatformProfiler profiler); + + void SetCapacity(uint size); + void Trim(); + void Clear(); + void FastClear(); + bool Has(uint entityIdEntityId); + } + + class TypeSafeDictionary : FasterDictionary, + ITypeSafeDictionary where TValue : struct, IEntityStruct + { + static readonly Type _type = typeof(TValue); + static readonly string _typeName = _type.Name; + static readonly bool _hasEgid = typeof(INeedEGID).IsAssignableFrom(_type); + + public TypeSafeDictionary(uint size) : base(size) {} + public TypeSafeDictionary() {} + + public void AddEntitiesFromDictionary(ITypeSafeDictionary entitiesToSubmit, uint groupId) + { + var typeSafeDictionary = entitiesToSubmit as TypeSafeDictionary; + + foreach (var tuple in typeSafeDictionary) + { + try + { + if (_hasEgid) SetEGIDWithoutBoxing.SetIDWithoutBoxing(ref tuple.Value, new EGID(tuple.Key, groupId)); + + Add(tuple.Key, tuple.Value); + } + catch (Exception e) + { + throw new TypeSafeDictionaryException( + "trying to add an EntityView with the same ID more than once Entity: " + .FastConcat(typeof(TValue).ToString()).FastConcat(", group ").FastConcat(groupId).FastConcat(", id ").FastConcat(tuple.Key), e); + } + } + } + + public void AddEntitiesToEngines( + FasterDictionary, FasterList> entityViewEnginesDB, + ITypeSafeDictionary realDic, in PlatformProfiler profiler, ExclusiveGroup.ExclusiveGroupStruct @group) + { + var typeSafeDictionary = realDic as TypeSafeDictionary; + + //this can be optimized, should pass all the entities and not restart the process for each one + foreach (var value in this) + AddEntityViewToEngines(entityViewEnginesDB, ref typeSafeDictionary.GetValueByRef(value.Key), null, + in profiler, new EGID(value.Key, group)); + } + + public void RemoveEntitiesFromEngines( + FasterDictionary, FasterList> entityViewEnginesDB, + in PlatformProfiler profiler, ExclusiveGroup.ExclusiveGroupStruct @group) + { + foreach (var value in this) + RemoveEntityViewFromEngines(entityViewEnginesDB, ref GetValueByRef(value.Key), null, in profiler, + new EGID(value.Key, group)); + } + + public bool Has(uint entityIdEntityId) + { + return ContainsKey(entityIdEntityId); + } + + public void RemoveEntityFromDictionary(EGID fromEntityGid, in PlatformProfiler profiler) + { + Remove(fromEntityGid.entityID); + } + + public void AddEntityToDictionary(EGID fromEntityGid, EGID toEntityID, ITypeSafeDictionary toGroup) + { + var valueIndex = GetIndex(fromEntityGid.entityID); + + if (toGroup != null) + { + var toGroupCasted = toGroup as TypeSafeDictionary; + ref var entity = ref valuesArray[valueIndex]; + + if (_hasEgid) SetEGIDWithoutBoxing.SetIDWithoutBoxing(ref entity, toEntityID); + + toGroupCasted.Add(fromEntityGid.entityID, entity); + } + } + + public void MoveEntityFromEngines(EGID fromEntityGid, EGID? toEntityID, ITypeSafeDictionary toGroup, + FasterDictionary, FasterList> engines, in PlatformProfiler profiler) + { + var valueIndex = GetIndex(fromEntityGid.entityID); + + ref var entity = ref valuesArray[valueIndex]; + + if (toGroup != null) + { + RemoveEntityViewFromEngines(engines, ref entity, fromEntityGid.groupID, in profiler, + fromEntityGid); + + var toGroupCasted = toGroup as TypeSafeDictionary; + var previousGroup = fromEntityGid.groupID; + + if (_hasEgid) SetEGIDWithoutBoxing.SetIDWithoutBoxing(ref entity, toEntityID.Value); + + var index = toGroupCasted.GetIndex(toEntityID.Value.entityID); + + AddEntityViewToEngines(engines, ref toGroupCasted.valuesArray[index], previousGroup, + in profiler, toEntityID.Value); + } + else + RemoveEntityViewFromEngines(engines, ref entity, null, in profiler, fromEntityGid); + } + + public ITypeSafeDictionary Create() + { + return new TypeSafeDictionary(); + } + + void AddEntityViewToEngines(FasterDictionary, FasterList> entityViewEnginesDB, + ref TValue entity, ExclusiveGroup.ExclusiveGroupStruct? previousGroup, + in PlatformProfiler profiler, EGID egid) + { + //get all the engines linked to TValue + if (!entityViewEnginesDB.TryGetValue(new RefWrapper(_type), out var entityViewsEngines)) return; + + if (previousGroup == null) + { + for (var i = 0; i < entityViewsEngines.Count; i++) + try + { + using (profiler.Sample(entityViewsEngines[i], _typeName)) + { + (entityViewsEngines[i] as IReactOnAddAndRemove).Add(ref entity, egid); + } + } + catch (Exception e) + { + throw new ECSException( + "Code crashed inside Add callback ".FastConcat(typeof(TValue).ToString()), e); + } + } + else + { + for (var i = 0; i < entityViewsEngines.Count; i++) + try + { + using (profiler.Sample(entityViewsEngines[i], _typeName)) + { + (entityViewsEngines[i] as IReactOnSwap).MovedTo(ref entity, previousGroup.Value, + egid); + } + } + catch (Exception e) + { + throw new ECSException( + "Code crashed inside MovedTo callback ".FastConcat(typeof(TValue).ToString()), e); + } + } + } + + static void RemoveEntityViewFromEngines( + FasterDictionary, FasterList> @group, ref TValue entity, + ExclusiveGroup.ExclusiveGroupStruct? previousGroup, in PlatformProfiler profiler, EGID egid) + { + if (!@group.TryGetValue(new RefWrapper(_type), out var entityViewsEngines)) return; + + if (previousGroup == null) + { + for (var i = 0; i < entityViewsEngines.Count; i++) + try + { + using (profiler.Sample(entityViewsEngines[i], _typeName)) + (entityViewsEngines[i] as IReactOnAddAndRemove).Remove(ref entity, egid); + } + catch (Exception e) + { + throw new ECSException( + "Code crashed inside Remove callback ".FastConcat(typeof(TValue).ToString()), e); + } + } +#if SEEMS_UNNECESSARY + else + { + for (var i = 0; i < entityViewsEngines.Count; i++) + try + { + using (profiler.Sample(entityViewsEngines[i], _typeName)) + (entityViewsEngines[i] as IReactOnSwap).MovedFrom(ref entity, egid); + } + catch (Exception e) + { + throw new ECSException( + "Code crashed inside Remove callback ".FastConcat(typeof(TValue).ToString()), e); + } + } +#endif + } + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/DataStructures/TypeSafeDictionary.cs.meta b/Svelto.ECS/Svelto.ECS/DataStructures/TypeSafeDictionary.cs.meta new file mode 100644 index 0000000..8af9662 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/DataStructures/TypeSafeDictionary.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 5e812f7d5c7a03d4faebd6bbc9a06a2a +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/DataStructures/TypeSafeDictionaryException.cs b/Svelto.ECS/Svelto.ECS/DataStructures/TypeSafeDictionaryException.cs new file mode 100644 index 0000000..6f0a2c9 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/DataStructures/TypeSafeDictionaryException.cs @@ -0,0 +1,12 @@ +using System; + +namespace Svelto.ECS +{ + public class TypeSafeDictionaryException : Exception + { + public TypeSafeDictionaryException(string message, Exception exception) : + base(message, exception) + { + } + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/DataStructures/TypeSafeDictionaryException.cs.meta b/Svelto.ECS/Svelto.ECS/DataStructures/TypeSafeDictionaryException.cs.meta new file mode 100644 index 0000000..2402112 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/DataStructures/TypeSafeDictionaryException.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 8c21456b4b0c7c9409264d02670f7f4c +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/Dispatcher.meta b/Svelto.ECS/Svelto.ECS/Dispatcher.meta new file mode 100644 index 0000000..4c0bbe2 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Dispatcher.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 67be04a8cde247c4d93885b1ff03ddec +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/Dispatcher/DispatchOnChange.cs b/Svelto.ECS/Svelto.ECS/Dispatcher/DispatchOnChange.cs new file mode 100644 index 0000000..d1ce756 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Dispatcher/DispatchOnChange.cs @@ -0,0 +1,21 @@ +using System; + +namespace Svelto.ECS +{ + public class DispatchOnChange : DispatchOnSet where T:IEquatable + { + public DispatchOnChange(EGID senderID) : base(senderID) + { } + + public new T value + { + set + { + if (value.Equals(_value) == false) + base.value = value; + } + + get => _value; + } + } +} diff --git a/Svelto.ECS/Svelto.ECS/Dispatcher/DispatchOnChange.cs.meta b/Svelto.ECS/Svelto.ECS/Dispatcher/DispatchOnChange.cs.meta new file mode 100644 index 0000000..6d3f060 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Dispatcher/DispatchOnChange.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 8b6d96ff87b04c140ad95db4cb267540 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/Dispatcher/DispatchOnSet.cs b/Svelto.ECS/Svelto.ECS/Dispatcher/DispatchOnSet.cs new file mode 100644 index 0000000..d407ae8 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Dispatcher/DispatchOnSet.cs @@ -0,0 +1,42 @@ +using System; + +namespace Svelto.ECS +{ + public class DispatchOnSet + { + public DispatchOnSet(EGID senderID) + { + _senderID = senderID; + } + + public T value + { + set + { + _value = value; + + if (_paused == false) + _subscribers(_senderID, value); + } + } + + public void NotifyOnValueSet(Action action) + { + _subscribers += action; + } + + public void StopNotify(Action action) + { + _subscribers -= action; + } + + public void PauseNotify() { _paused = true; } + public void ResumeNotify() { _paused = false; } + + protected T _value; + readonly EGID _senderID; + + Action _subscribers; + bool _paused; + } +} diff --git a/Svelto.ECS/Svelto.ECS/Dispatcher/DispatchOnSet.cs.meta b/Svelto.ECS/Svelto.ECS/Dispatcher/DispatchOnSet.cs.meta new file mode 100644 index 0000000..5513460 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Dispatcher/DispatchOnSet.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: f3455e49716d5f44c9ed8da0880dead2 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/DynamicEntityDescriptor.cs b/Svelto.ECS/Svelto.ECS/DynamicEntityDescriptor.cs new file mode 100644 index 0000000..f40d3e7 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/DynamicEntityDescriptor.cs @@ -0,0 +1,128 @@ +using System; +using Svelto.DataStructures; + +namespace Svelto.ECS +{ + /// + /// DynamicEntityDescriptor can be used to add entity views to an existing EntityDescriptor that act as flags, + /// at building time. + /// This method allocates, so it shouldn't be abused + /// + /// + public struct DynamicEntityDescriptor : IEntityDescriptor where TType : IEntityDescriptor, new() + { + internal DynamicEntityDescriptor(bool isExtendible) : this() + { + var defaultEntities = EntityDescriptorTemplate.descriptor.entitiesToBuild; + var length = defaultEntities.Length; + + _entitiesToBuild = new IEntityBuilder[length + 1]; + + Array.Copy(defaultEntities, 0, _entitiesToBuild, 0, length); + + //assign it after otherwise the previous copy will overwrite the value in case the item + //is already present + _entitiesToBuild[length] = new EntityBuilder + ( + new EntityStructInfoView + { + entitiesToBuild = _entitiesToBuild + } + ); + } + + public DynamicEntityDescriptor(IEntityBuilder[] extraEntityBuilders) : this() + { + var extraEntitiesLength = extraEntityBuilders.Length; + + _entitiesToBuild = Construct(extraEntitiesLength, extraEntityBuilders, + EntityDescriptorTemplate.descriptor.entitiesToBuild); + } + + public DynamicEntityDescriptor(FasterList extraEntityBuilders) : this() + { + var extraEntities = extraEntityBuilders.ToArrayFast(); + var extraEntitiesLength = extraEntityBuilders.Count; + + _entitiesToBuild = Construct(extraEntitiesLength, extraEntities, + EntityDescriptorTemplate.descriptor.entitiesToBuild); + } + + public void ExtendWith() where T : IEntityDescriptor, new() + { + var newEntitiesToBuild = EntityDescriptorTemplate.descriptor.entitiesToBuild; + + _entitiesToBuild = Construct(newEntitiesToBuild.Length, newEntitiesToBuild, _entitiesToBuild); + } + + public void ExtendWith(IEntityBuilder[] extraEntities) + { + _entitiesToBuild = Construct(extraEntities.Length, extraEntities, _entitiesToBuild); + } + + static IEntityBuilder[] Construct(int extraEntitiesLength, IEntityBuilder[] extraEntities, + IEntityBuilder[] startingEntities) + { + IEntityBuilder[] localEntitiesToBuild; + + if (extraEntitiesLength == 0) + { + localEntitiesToBuild = startingEntities; + return localEntitiesToBuild; + } + + var defaultEntities = startingEntities; + var length = defaultEntities.Length; + + var index = SetupSpecialEntityStruct(defaultEntities, out localEntitiesToBuild, extraEntitiesLength); + + Array.Copy(extraEntities, 0, localEntitiesToBuild, length, extraEntitiesLength); + + //assign it after otherwise the previous copy will overwrite the value in case the item + //is already present + localEntitiesToBuild[index] = new EntityBuilder + ( + new EntityStructInfoView + { + entitiesToBuild = localEntitiesToBuild + } + ); + + return localEntitiesToBuild; + } + + static int SetupSpecialEntityStruct(IEntityBuilder[] defaultEntities, out IEntityBuilder[] entitiesToBuild, + int extraLenght) + { + int length = defaultEntities.Length; + int index = -1; + + for (var i = 0; i < length; i++) + { + //the special entity already exists + if (defaultEntities[i].GetEntityType() == EntityBuilderUtilities.ENTITY_STRUCT_INFO_VIEW) + { + index = i; + break; + } + } + + if (index == -1) + { + index = length + extraLenght; + entitiesToBuild = new IEntityBuilder[index + 1]; + } + else + entitiesToBuild = new IEntityBuilder[length + extraLenght]; + + Array.Copy(defaultEntities, 0, entitiesToBuild, 0, length); + + return index; + } + + + public IEntityBuilder[] entitiesToBuild => _entitiesToBuild; + + IEntityBuilder[] _entitiesToBuild; + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/DynamicEntityDescriptor.cs.meta b/Svelto.ECS/Svelto.ECS/DynamicEntityDescriptor.cs.meta new file mode 100644 index 0000000..e75eb39 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/DynamicEntityDescriptor.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: f44f311aa89faee408fe3591032a1bb9 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/ECSException.cs b/Svelto.ECS/Svelto.ECS/ECSException.cs new file mode 100644 index 0000000..b815f84 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/ECSException.cs @@ -0,0 +1,13 @@ +using System; + +namespace Svelto.ECS +{ + public class ECSException : Exception + { + public ECSException(string message):base("".FastConcat(message, "")) + {} + + public ECSException(string message, Exception innerE):base("".FastConcat(message, ""), innerE) + {} + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/ECSException.cs.meta b/Svelto.ECS/Svelto.ECS/ECSException.cs.meta new file mode 100644 index 0000000..3edd782 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/ECSException.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: ffc933f6fa0c64f46aa6e501ccac1eca +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/ECSResources.meta b/Svelto.ECS/Svelto.ECS/ECSResources.meta new file mode 100644 index 0000000..5e21225 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/ECSResources.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: ed2ee43790d8ab0408efcd5ee7b4e80f +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/ECSResources/ECSResources.cs b/Svelto.ECS/Svelto.ECS/ECSResources/ECSResources.cs new file mode 100644 index 0000000..70ba614 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/ECSResources/ECSResources.cs @@ -0,0 +1,47 @@ +using Svelto.DataStructures; + +namespace Svelto.ECS.Experimental +{ + public struct ECSResources + { + internal uint id; + + public static implicit operator T(ECSResources ecsString) { return ResourcesECSDB.FromECS(ecsString.id); } + } + + static class ResourcesECSDB + { + static readonly FasterList _resources = new FasterList(); + + internal static ref T resources(uint id) + { + return ref _resources[(int) id - 1]; + } + + internal static uint ToECS(T resource) + { + _resources.Add(resource); + + return (uint)_resources.Count; + } + + public static T FromECS(uint id) + { + if (id - 1 < _resources.Count) + return _resources[(int) id - 1]; + + return default; + } + } + + public static class ResourceExtensions + { + public static void Set(ref this ECSResources resource, T newText) + { + if (resource.id != 0) + ResourcesECSDB.resources(resource.id) = newText; + else + resource.id = ResourcesECSDB.ToECS(newText); + } + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/ECSResources/ECSResources.cs.meta b/Svelto.ECS/Svelto.ECS/ECSResources/ECSResources.cs.meta new file mode 100644 index 0000000..e3f61da --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/ECSResources/ECSResources.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 5afcd85ad92ffb344b04a1aa675814bf +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/ECSResources/ECSString.cs b/Svelto.ECS/Svelto.ECS/ECSResources/ECSString.cs new file mode 100644 index 0000000..4eac06c --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/ECSResources/ECSString.cs @@ -0,0 +1,38 @@ +using System; + +namespace Svelto.ECS.Experimental +{ + [Serialization.DoNotSerialize] + public struct ECSString:IEquatable + { + uint id; + + public ECSString(string newText) + { + id = ResourcesECSDB.ToECS(newText); + } + + public static implicit operator string(ECSString ecsString) + { + return ResourcesECSDB.FromECS(ecsString.id); + } + + public void Set(string newText) + { + if (id != 0) + ResourcesECSDB.resources(id) = newText; + else + id = ResourcesECSDB.ToECS(newText); + } + + public bool Equals(ECSString other) + { + return other.id == id; + } + + public override string ToString() + { + return ResourcesECSDB.FromECS(id); + } + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/ECSResources/ECSString.cs.meta b/Svelto.ECS/Svelto.ECS/ECSResources/ECSString.cs.meta new file mode 100644 index 0000000..64844e6 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/ECSResources/ECSString.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: a851028d58ed0754fa529a196e952859 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/EGID.cs b/Svelto.ECS/Svelto.ECS/EGID.cs new file mode 100644 index 0000000..4e7d768 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EGID.cs @@ -0,0 +1,77 @@ +using System; +using System.Collections.Generic; + +#pragma warning disable 660,661 + +namespace Svelto.ECS +{ + //todo: add debug map + [Serialization.DoNotSerialize] + [Serializable] + public struct EGID:IEquatable,IEqualityComparer,IComparable + { + public uint entityID => (uint) (_GID & 0xFFFFFFFF); + + public ExclusiveGroup.ExclusiveGroupStruct groupID => new ExclusiveGroup.ExclusiveGroupStruct((uint) (_GID >> 32)); + + public static bool operator ==(EGID obj1, EGID obj2) + { + return obj1._GID == obj2._GID; + } + + public static bool operator !=(EGID obj1, EGID obj2) + { + return obj1._GID != obj2._GID; + } + + public EGID(uint entityID, ExclusiveGroup.ExclusiveGroupStruct groupID) : this() + { + _GID = MAKE_GLOBAL_ID(entityID, groupID); + } + + static ulong MAKE_GLOBAL_ID(uint entityId, uint groupId) + { + return (ulong)groupId << 32 | ((ulong)entityId & 0xFFFFFFFF); + } + + public static explicit operator uint(EGID id) + { + return id.entityID; + } + + //in the way it's used, ulong must be always the same for each id/group + public static explicit operator ulong(EGID id) { return id._GID; } + + public bool Equals(EGID other) + { + return _GID == other._GID; + } + + public bool Equals(EGID x, EGID y) + { + return x == y; + } + + public int GetHashCode(EGID obj) + { + return _GID.GetHashCode(); + } + + public int CompareTo(EGID other) + { + return _GID.CompareTo(other._GID); + } + + internal EGID(uint entityID, uint groupID) : this() + { + _GID = MAKE_GLOBAL_ID(entityID, groupID); + } + + public override string ToString() + { + return "id ".FastConcat(entityID).FastConcat(" group ").FastConcat(groupID); + } + + readonly ulong _GID; + } +} diff --git a/Svelto.ECS/Svelto.ECS/EGID.cs.meta b/Svelto.ECS/Svelto.ECS/EGID.cs.meta new file mode 100644 index 0000000..794a3fb --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EGID.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 107bb03a12307bb4f961b85b782e22e1 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/EGIDMapper.cs b/Svelto.ECS/Svelto.ECS/EGIDMapper.cs new file mode 100644 index 0000000..939e20b --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EGIDMapper.cs @@ -0,0 +1,37 @@ +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using Svelto.DataStructures; + +namespace Svelto.ECS +{ + public struct EGIDMapper where T : struct, IEntityStruct + { + internal FasterDictionary map; + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public ref T Entity(uint entityID) + { +#if DEBUG && !PROFILER + if (map.TryFindIndex(entityID, out var findIndex) == false) + throw new Exception("Entity not found in this group ".FastConcat(typeof(T).ToString())); +#else + map.TryFindIndex(entityID, out var findIndex); +#endif + return ref map.valuesArray[findIndex]; + } + + public bool TryGetEntity(uint entityID, out T value) + { + if (map.TryFindIndex(entityID, out var index)) + { + value = map.GetDirectValue(index); + return true; + } + + value = default; + return false; + } + } +} + diff --git a/Svelto.ECS/Svelto.ECS/EGIDMapper.cs.meta b/Svelto.ECS/Svelto.ECS/EGIDMapper.cs.meta new file mode 100644 index 0000000..e5db383 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EGIDMapper.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: c28b51f353894904c831577c2c725122 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/EnginesRoot.DoubleBufferedEntityViews.cs b/Svelto.ECS/Svelto.ECS/EnginesRoot.DoubleBufferedEntityViews.cs new file mode 100644 index 0000000..f6077f3 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EnginesRoot.DoubleBufferedEntityViews.cs @@ -0,0 +1,86 @@ +using System; +using Svelto.DataStructures; +using Svelto.ECS.Internal; + +namespace Svelto.ECS +{ + public partial class EnginesRoot + { + internal class DoubleBufferedEntitiesToAdd + { + const int MaximumNumberOfItemsPerFrameBeforeToClear = 100; + + internal void Swap() + { + Swap(ref current, ref other); + Swap(ref currentEntitiesCreatedPerGroup, ref otherEntitiesCreatedPerGroup); + } + + void Swap(ref T item1, ref T item2) + { + var toSwap = item2; + item2 = item1; + item1 = toSwap; + } + + public void ClearOther() + { + //do not clear the groups created so far, they will be reused, unless they are too many! + var otherCount = other.Count; + if (otherCount > MaximumNumberOfItemsPerFrameBeforeToClear) + { + otherEntitiesCreatedPerGroup.FastClear(); + other.FastClear(); + return; + } + var otherValuesArray = other.valuesArray; + for (int i = 0; i < otherCount; ++i) + { + var safeDictionariesCount = otherValuesArray[i].Count; + var safeDictionaries = otherValuesArray[i].valuesArray; + //do not remove the dictionaries of entities per type created so far, they will be reused + if (safeDictionariesCount <= MaximumNumberOfItemsPerFrameBeforeToClear) + { + for (int j = 0; j < safeDictionariesCount; ++j) + { + //clear the dictionary of entities create do far (it won't allocate though) + safeDictionaries[j].FastClear(); + } + } + else + { + otherValuesArray[i].FastClear(); + } + } + + otherEntitiesCreatedPerGroup.FastClear(); + } + + internal FasterDictionary currentEntitiesCreatedPerGroup; + internal FasterDictionary otherEntitiesCreatedPerGroup; + + internal FasterDictionary, ITypeSafeDictionary>> current; + internal FasterDictionary, ITypeSafeDictionary>> other; + + readonly FasterDictionary, ITypeSafeDictionary>> + _entityViewsToAddBufferA = + new FasterDictionary, ITypeSafeDictionary>>(); + + readonly FasterDictionary, ITypeSafeDictionary>> + _entityViewsToAddBufferB = + new FasterDictionary, ITypeSafeDictionary>>(); + + readonly FasterDictionary _entitiesCreatedPerGroupA = new FasterDictionary(); + readonly FasterDictionary _entitiesCreatedPerGroupB = new FasterDictionary(); + + public DoubleBufferedEntitiesToAdd() + { + currentEntitiesCreatedPerGroup = _entitiesCreatedPerGroupA; + otherEntitiesCreatedPerGroup = _entitiesCreatedPerGroupB; + + current = _entityViewsToAddBufferA; + other = _entityViewsToAddBufferB; + } + } + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/EnginesRoot.DoubleBufferedEntityViews.cs.meta b/Svelto.ECS/Svelto.ECS/EnginesRoot.DoubleBufferedEntityViews.cs.meta new file mode 100644 index 0000000..47f493c --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EnginesRoot.DoubleBufferedEntityViews.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 317edb22c6fdcb447a576d39d928aae7 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/EnginesRoot.Engines.cs b/Svelto.ECS/Svelto.ECS/EnginesRoot.Engines.cs new file mode 100644 index 0000000..8438e5b --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EnginesRoot.Engines.cs @@ -0,0 +1,143 @@ +using System; +using System.Collections.Generic; +using Svelto.DataStructures; +using Svelto.ECS.Internal; +using Svelto.ECS.Schedulers; + +namespace Svelto.ECS +{ + public partial class EnginesRoot + { + public struct EntitiesSubmitter + { + public EntitiesSubmitter(EnginesRoot enginesRoot) + { + _weakReference = new DataStructures.WeakReference(enginesRoot); + } + + public void Invoke() + { + if (_weakReference.IsValid) + _weakReference.Target.SubmitEntityViews(); + } + + readonly DataStructures.WeakReference _weakReference; + } + /// + /// Engines root contextualize your engines and entities. You don't need to limit yourself to one EngineRoot + /// as multiple engines root could promote separation of scopes. The EntitySubmissionScheduler checks + /// periodically if new entity must be submitted to the database and the engines. It's an external + /// dependencies to be independent by the running platform as the user can define it. + /// The EntitySubmissionScheduler cannot hold an EnginesRoot reference, that's why + /// it must receive a weak reference of the EnginesRoot callback. + /// + public EnginesRoot(IEntitySubmissionScheduler entityViewScheduler) + { + _entitiesOperations = new FasterDictionary(); + _reactiveEnginesAddRemove = new FasterDictionary, FasterList>(); + _reactiveEnginesSwap = new FasterDictionary, FasterList>(); + _enginesSet = new FasterList(); + _enginesTypeSet = new HashSet(); + _disposableEngines = new FasterList(); + _transientEntitiesOperations = new FasterList(); + + _groupEntityViewsDB = new FasterDictionary, ITypeSafeDictionary>>(); + _groupsPerEntity = new FasterDictionary, FasterDictionary>(); + _groupedEntityToAdd = new DoubleBufferedEntitiesToAdd(); + + _entitiesStream = new EntitiesStream(); + _entitiesDB = new EntitiesDB(_groupEntityViewsDB, _groupsPerEntity, _entitiesStream); + + _scheduler = entityViewScheduler; + _scheduler.onTick = new EntitiesSubmitter(this); + } + + public EnginesRoot(IEntitySubmissionScheduler entityViewScheduler, bool isDeserializationOnly):this(entityViewScheduler) + { + _isDeserializationOnly = isDeserializationOnly; + } + + public void AddEngine(IEngine engine) + { + var type = engine.GetType(); + var refWrapper = new RefWrapper(type); + DBC.ECS.Check.Require( + _enginesTypeSet.Contains(refWrapper) == false || + type.ContainsCustomAttribute(typeof(AllowMultipleAttribute)) == true, + "The same engine has been added more than once, if intentional, use [AllowMultiple] class attribute " + .FastConcat(engine.ToString())); + try + { + if (engine is IReactOnAddAndRemove viewEngine) + CheckEntityViewsEngine(viewEngine, _reactiveEnginesAddRemove); + + if (engine is IReactOnSwap viewEngineSwap) + CheckEntityViewsEngine(viewEngineSwap, _reactiveEnginesSwap); + + _enginesTypeSet.Add(refWrapper); + _enginesSet.Add(engine); + + if (engine is IDisposable) + _disposableEngines.Add(engine as IDisposable); + + if (engine is IQueryingEntitiesEngine queryableEntityViewEngine) + { + queryableEntityViewEngine.entitiesDB = _entitiesDB; + queryableEntityViewEngine.Ready(); + } + } + catch (Exception e) + { + throw new ECSException("Code crashed while adding engine ".FastConcat(engine.GetType().ToString(), " "), e); + } + } + + void CheckEntityViewsEngine(T engine, FasterDictionary, FasterList> engines) + where T : class, IEngine + { + var interfaces = engine.GetType().GetInterfaces(); + + foreach (var interf in interfaces) + { + if (interf.IsGenericTypeEx() && typeof(T).IsAssignableFrom(interf)) + { + var genericArguments = interf.GetGenericArgumentsEx(); + + AddEngine(engine, genericArguments, engines); + } + } + } + + static void AddEngine(T engine, Type[] entityViewTypes, + FasterDictionary, FasterList> engines) + where T : class, IEngine + { + for (var i = 0; i < entityViewTypes.Length; i++) + { + var type = entityViewTypes[i]; + + AddEngine(engine, engines, type); + } + } + + static void AddEngine(T engine, FasterDictionary, FasterList> engines, Type type) + where T : class, IEngine + { + if (engines.TryGetValue(new RefWrapper(type), out var list) == false) + { + list = new FasterList(); + + engines.Add(new RefWrapper(type), list); + } + + list.Add(engine); + } + + readonly FasterDictionary, FasterList> _reactiveEnginesAddRemove; + readonly FasterDictionary, FasterList> _reactiveEnginesSwap; + readonly FasterList _disposableEngines; + + readonly FasterList _enginesSet; + readonly HashSet _enginesTypeSet; + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/EnginesRoot.Engines.cs.meta b/Svelto.ECS/Svelto.ECS/EnginesRoot.Engines.cs.meta new file mode 100644 index 0000000..1e1c3a4 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EnginesRoot.Engines.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 63f9381d3d2e91f4eb2f890bb36c605b +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/EnginesRoot.Entities.cs b/Svelto.ECS/Svelto.ECS/EnginesRoot.Entities.cs new file mode 100644 index 0000000..08e3ffc --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EnginesRoot.Entities.cs @@ -0,0 +1,305 @@ +using System; +using System.Collections.Generic; +using System.Runtime.CompilerServices; +using Svelto.Common; +using Svelto.DataStructures; +using Svelto.ECS.Internal; + +namespace Svelto.ECS +{ + public partial class EnginesRoot : IDisposable + { + /// + /// Dispose an EngineRoot once not used anymore, so that all the + /// engines are notified with the entities removed. + /// It's a clean up process. + /// + public void Dispose() + { + using (var profiler = new PlatformProfiler("Final Dispose")) + { + foreach (var groups in _groupEntityViewsDB) + { + foreach (var entityList in groups.Value) + { + entityList.Value.RemoveEntitiesFromEngines(_reactiveEnginesAddRemove, + profiler, new ExclusiveGroup.ExclusiveGroupStruct(groups.Key)); + } + } + + _groupEntityViewsDB.Clear(); + _groupsPerEntity.Clear(); + + foreach (var engine in _disposableEngines) + engine.Dispose(); + + _disposableEngines.Clear(); + _enginesSet.Clear(); + _enginesTypeSet.Clear(); + _reactiveEnginesSwap.Clear(); + _reactiveEnginesAddRemove.Clear(); + + _entitiesOperations.Clear(); + _transientEntitiesOperations.Clear(); + _scheduler.Dispose(); +#if DEBUG && !PROFILER + _idCheckers.Clear(); +#endif + _groupedEntityToAdd = null; + + _entitiesStream.Dispose(); + } + + GC.SuppressFinalize(this); + } + + ~EnginesRoot() + { + Console.LogWarning("Engines Root has been garbage collected, don't forget to call Dispose()!"); + + Dispose(); + } + + ///-------------------------------------------- + /// + public IEntityStreamConsumerFactory GenerateConsumerFactory() + { + return new GenericEntityStreamConsumerFactory(this); + } + + public IEntityFactory GenerateEntityFactory() + { + return new GenericEntityFactory(this); + } + + public IEntityFunctions GenerateEntityFunctions() + { + return new GenericEntityFunctions(this); + } + + ///-------------------------------------------- + [MethodImpl(MethodImplOptions.AggressiveInlining)] + EntityStructInitializer BuildEntity(EGID entityID, IEntityBuilder[] entitiesToBuild, + IEnumerable implementors = null) + { + CheckAddEntityID(entityID); + + var dic = EntityFactory.BuildGroupedEntities(entityID, _groupedEntityToAdd, + entitiesToBuild, implementors); + + return new EntityStructInitializer(entityID, dic); + } + + ///-------------------------------------------- + void Preallocate(uint groupID, uint size) where T : IEntityDescriptor, new() + { + var entityViewsToBuild = EntityDescriptorTemplate.descriptor.entitiesToBuild; + var numberOfEntityViews = entityViewsToBuild.Length; + + //reserve space in the database + if (_groupEntityViewsDB.TryGetValue(groupID, out var group) == false) + group = _groupEntityViewsDB[groupID] = new FasterDictionary, ITypeSafeDictionary>(); + + for (var index = 0; index < numberOfEntityViews; index++) + { + var entityViewBuilder = entityViewsToBuild[index]; + var entityViewType = entityViewBuilder.GetEntityType(); + + var refWrapper = new RefWrapper(entityViewType); + if (group.TryGetValue(refWrapper, out var dbList) == false) + group[refWrapper] = entityViewBuilder.Preallocate(ref dbList, size); + else + dbList.SetCapacity(size); + + if (_groupsPerEntity.TryGetValue(refWrapper, out var groupedGroup) == false) + groupedGroup = _groupsPerEntity[refWrapper] = + new FasterDictionary(); + + groupedGroup[groupID] = dbList; + } + } + + ///-------------------------------------------- + /// + void MoveEntityFromAndToEngines(IEntityBuilder[] entityBuilders, EGID fromEntityGID, EGID? toEntityGID) + { + using (var sampler = new PlatformProfiler("Move Entity From Engines")) + { + //for each entity view generated by the entity descriptor + if (_groupEntityViewsDB.TryGetValue(fromEntityGID.groupID, out var fromGroup) == false) + throw new ECSException("from group not found eid: ".FastConcat(fromEntityGID.entityID) + .FastConcat(" group: ").FastConcat(fromEntityGID.groupID)); + + //Check if there is an EntityInfoView linked to this entity, if so it's a DynamicEntityDescriptor! + if (fromGroup.TryGetValue(new RefWrapper(EntityBuilderUtilities.ENTITY_STRUCT_INFO_VIEW), + out var entityInfoViewDic) && + (entityInfoViewDic as TypeSafeDictionary).TryGetValue( + fromEntityGID.entityID, out var entityInfoView)) + MoveEntities(fromEntityGID, toEntityGID, entityInfoView.entitiesToBuild, fromGroup, sampler); + //otherwise it's a normal static entity descriptor + else + MoveEntities(fromEntityGID, toEntityGID, entityBuilders, fromGroup, sampler); + } + } + + void MoveEntities(EGID fromEntityGID, EGID? toEntityGID, IEntityBuilder[] entitiesToMove, + FasterDictionary, ITypeSafeDictionary> fromGroup, PlatformProfiler sampler) + { + FasterDictionary, ITypeSafeDictionary> toGroup = null; + + if (toEntityGID != null) + { + var toGroupID = toEntityGID.Value.groupID; + + if (_groupEntityViewsDB.TryGetValue(toGroupID, out toGroup) == false) + toGroup = _groupEntityViewsDB[toGroupID] = new FasterDictionary, ITypeSafeDictionary>(); + + //Add all the entities to the dictionary + for (var i = 0; i < entitiesToMove.Length; i++) + CopyEntityToDictionary(fromEntityGID, toEntityGID.Value, fromGroup, toGroup, + entitiesToMove[i].GetEntityType()); + } + + //call all the callbacks + for (var i = 0; i < entitiesToMove.Length; i++) + MoveEntityViewFromAndToEngines(fromEntityGID, toEntityGID, fromGroup, toGroup, + entitiesToMove[i].GetEntityType(), sampler); + + //then remove all the entities from the dictionary + for (var i = 0; i < entitiesToMove.Length; i++) + RemoveEntityFromDictionary(fromEntityGID, fromGroup, entitiesToMove[i].GetEntityType(), sampler); + } + + void CopyEntityToDictionary(EGID entityGID, EGID toEntityGID, + FasterDictionary, ITypeSafeDictionary> fromGroup, + FasterDictionary, ITypeSafeDictionary> toGroup, Type entityViewType) + { + var wrapper = new RefWrapper(entityViewType); + + if (fromGroup.TryGetValue(wrapper, out var fromTypeSafeDictionary) == false) + { + throw new ECSException("no entities in from group eid: ".FastConcat(entityGID.entityID) + .FastConcat(" group: ").FastConcat(entityGID.groupID)); + } + +#if DEBUG && !PROFILER + if (fromTypeSafeDictionary.Has(entityGID.entityID) == false) + { + throw new EntityNotFoundException(entityGID, entityViewType); + } +#endif + if (toGroup.TryGetValue(wrapper, out var toEntitiesDictionary) == false) + { + toEntitiesDictionary = fromTypeSafeDictionary.Create(); + toGroup.Add(wrapper, toEntitiesDictionary); + } + + //todo: this must be unit tested properly + if (_groupsPerEntity.TryGetValue(wrapper, out var groupedGroup) == false) + groupedGroup = _groupsPerEntity[wrapper] = + new FasterDictionary(); + + groupedGroup[toEntityGID.groupID] = toEntitiesDictionary; + + fromTypeSafeDictionary.AddEntityToDictionary(entityGID, toEntityGID, toEntitiesDictionary); + } + + void MoveEntityViewFromAndToEngines(EGID entityGID, EGID? toEntityGID, + FasterDictionary, ITypeSafeDictionary> fromGroup, + FasterDictionary, ITypeSafeDictionary> toGroup, Type entityViewType, + in PlatformProfiler profiler) + { + //add all the entities + var refWrapper = new RefWrapper(entityViewType); + if (fromGroup.TryGetValue(refWrapper, out var fromTypeSafeDictionary) == false) + { + throw new ECSException("no entities in from group eid: ".FastConcat(entityGID.entityID) + .FastConcat(" group: ").FastConcat(entityGID.groupID)); + } + + ITypeSafeDictionary toEntitiesDictionary = null; + if (toGroup != null) + toEntitiesDictionary = toGroup[refWrapper]; //this is guaranteed to exist by AddEntityToDictionary + +#if DEBUG && !PROFILER + if (fromTypeSafeDictionary.Has(entityGID.entityID) == false) + throw new EntityNotFoundException(entityGID, entityViewType); +#endif + fromTypeSafeDictionary.MoveEntityFromEngines(entityGID, toEntityGID, + toEntitiesDictionary, toEntityGID == null ? _reactiveEnginesAddRemove : _reactiveEnginesSwap, + in profiler); + } + + void RemoveEntityFromDictionary(EGID entityGID, + FasterDictionary, ITypeSafeDictionary> fromGroup, Type entityViewType, + in PlatformProfiler profiler) + { + var refWrapper = new RefWrapper(entityViewType); + if (fromGroup.TryGetValue(refWrapper, out var fromTypeSafeDictionary) == false) + { + throw new ECSException("no entities in from group eid: ".FastConcat(entityGID.entityID) + .FastConcat(" group: ").FastConcat(entityGID.groupID)); + } + + fromTypeSafeDictionary.RemoveEntityFromDictionary(entityGID, profiler); + + if (fromTypeSafeDictionary.Count == 0) //clean up + { + //todo: this must be unit tested properly + _groupsPerEntity[refWrapper].Remove(entityGID.groupID); + //I don't remove the group if empty on purpose, in case it needs to be reused + } + } + + /// + /// Todo: I should keep the group, but I need to mark the group as deleted for the Exist function to work + /// + /// + /// + void RemoveGroupAndEntitiesFromDB(uint groupID, in PlatformProfiler profiler) + { + var dictionariesOfEntities = _groupEntityViewsDB[groupID]; + + foreach (var dictionaryOfEntities in dictionariesOfEntities) + { + dictionaryOfEntities.Value.RemoveEntitiesFromEngines(_reactiveEnginesAddRemove, profiler, + new ExclusiveGroup.ExclusiveGroupStruct(groupID)); + var groupedGroupOfEntities = _groupsPerEntity[dictionaryOfEntities.Key]; + groupedGroupOfEntities.Remove(groupID); + } + + //careful, in this case I assume you really don't want to use this group anymore + //so I remove it from the database + _groupEntityViewsDB.Remove(groupID); + } + + internal Consumer GenerateConsumer(string name, uint capacity) where T : unmanaged, IEntityStruct + { + return _entitiesStream.GenerateConsumer(name, capacity); + } + + + public Consumer GenerateConsumer(ExclusiveGroup group, string name, uint capacity) where T : unmanaged, + IEntityStruct + { + return _entitiesStream.GenerateConsumer(group, name, capacity); + } + + //one datastructure rule them all: + //split by group + //split by type per group. It's possible to get all the entities of a give type T per group thanks + //to the FasterDictionary capabilities OR it's possible to get a specific entityView indexed by + //ID. This ID doesn't need to be the EGID, it can be just the entityID + //for each group id, save a dictionary indexed by entity type of entities indexed by id + //ITypeSafeDictionary = Key = entityID, Value = EntityStruct + readonly FasterDictionary, ITypeSafeDictionary>> _groupEntityViewsDB; + + //for each entity view type, return the groups (dictionary of entities indexed by entity id) where they are + //found indexed by group id + //EntityViewType //groupID //entityID, EntityStruct + readonly FasterDictionary, FasterDictionary> _groupsPerEntity; + + readonly EntitiesDB _entitiesDB; + readonly EntitiesStream _entitiesStream; + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/EnginesRoot.Entities.cs.meta b/Svelto.ECS/Svelto.ECS/EnginesRoot.Entities.cs.meta new file mode 100644 index 0000000..f6bfa51 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EnginesRoot.Entities.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 40a3f08b64dbbfc42b7863e5c17636ea +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/EnginesRoot.GenericEntityFactory.cs b/Svelto.ECS/Svelto.ECS/EnginesRoot.GenericEntityFactory.cs new file mode 100644 index 0000000..8308e86 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EnginesRoot.GenericEntityFactory.cs @@ -0,0 +1,57 @@ +using System.Collections.Generic; +using Svelto.DataStructures; + +namespace Svelto.ECS +{ + public partial class EnginesRoot + { + class GenericEntityFactory : IEntityFactory + { + public GenericEntityFactory(EnginesRoot weakReference) + { + _enginesRoot = new WeakReference(weakReference); + } + + public EntityStructInitializer BuildEntity(uint entityID, + ExclusiveGroup.ExclusiveGroupStruct groupStructId, IEnumerable implementors = null) + where T : IEntityDescriptor, new() + { + return _enginesRoot.Target.BuildEntity(new EGID(entityID, groupStructId), + EntityDescriptorTemplate.descriptor.entitiesToBuild, implementors); + } + + public EntityStructInitializer BuildEntity(EGID egid, IEnumerable implementors = null) + where T : IEntityDescriptor, new() + { + return _enginesRoot.Target.BuildEntity(egid, + EntityDescriptorTemplate.descriptor.entitiesToBuild, implementors); + } + + public EntityStructInitializer BuildEntity(EGID egid, T entityDescriptor, + IEnumerable implementors) + where T : IEntityDescriptor + { + return _enginesRoot.Target.BuildEntity(egid, entityDescriptor.entitiesToBuild, implementors); + } + + public EntityStructInitializer BuildEntity(uint entityID, + ExclusiveGroup.ExclusiveGroupStruct groupStructId, T descriptorEntity, IEnumerable implementors) + where T : IEntityDescriptor + { + return _enginesRoot.Target.BuildEntity(new EGID(entityID, groupStructId), + descriptorEntity.entitiesToBuild, + implementors); + } + + public void PreallocateEntitySpace(ExclusiveGroup.ExclusiveGroupStruct groupStructId, uint size) + where T : IEntityDescriptor, new() + { + _enginesRoot.Target.Preallocate(groupStructId, size); + } + + //enginesRoot is a weakreference because GenericEntityStreamConsumerFactory can be injected inside +//engines of other enginesRoot + readonly WeakReference _enginesRoot; + } + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/EnginesRoot.GenericEntityFactory.cs.meta b/Svelto.ECS/Svelto.ECS/EnginesRoot.GenericEntityFactory.cs.meta new file mode 100644 index 0000000..5bb9d04 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EnginesRoot.GenericEntityFactory.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: c6b2d3dc41496964f91001a6f66be98a +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/EnginesRoot.GenericEntityFunctions.cs b/Svelto.ECS/Svelto.ECS/EnginesRoot.GenericEntityFunctions.cs new file mode 100644 index 0000000..d5a2cbd --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EnginesRoot.GenericEntityFunctions.cs @@ -0,0 +1,130 @@ +using System.Diagnostics; +using System.Runtime.CompilerServices; +using Svelto.DataStructures; + +namespace Svelto.ECS +{ + public partial class EnginesRoot + { + /// + /// todo: EnginesRoot was a weakreference to give the change to inject + /// entityfunctions from other engines root. It probably should be reverted + /// + sealed class GenericEntityFunctions : IEntityFunctions + { + internal GenericEntityFunctions(EnginesRoot weakReference) + { + _enginesRoot = new WeakReference(weakReference); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public void RemoveEntity(uint entityID, ExclusiveGroup.ExclusiveGroupStruct groupID) where T : + IEntityDescriptor, new() + { + RemoveEntity(new EGID(entityID, groupID)); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public void RemoveEntity(EGID entityEGID) where T : IEntityDescriptor, new() + { + _enginesRoot.Target.CheckRemoveEntityID(entityEGID); + + _enginesRoot.Target.QueueEntitySubmitOperation( + new EntitySubmitOperation(EntitySubmitOperationType.Remove, entityEGID, entityEGID, + EntityDescriptorTemplate.descriptor.entitiesToBuild)); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public void RemoveGroupAndEntities(ExclusiveGroup.ExclusiveGroupStruct groupID) + { + _enginesRoot.Target.RemoveGroupID(groupID); + + _enginesRoot.Target.QueueEntitySubmitOperation( + new EntitySubmitOperation(EntitySubmitOperationType.RemoveGroup, new EGID(0, groupID), new EGID())); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public void SwapEntityGroup(uint entityID, ExclusiveGroup.ExclusiveGroupStruct fromGroupID, + ExclusiveGroup.ExclusiveGroupStruct toGroupID) + where T : IEntityDescriptor, new() + { + SwapEntityGroup(new EGID(entityID, fromGroupID), toGroupID); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public void SwapEntityGroup(EGID fromID, ExclusiveGroup.ExclusiveGroupStruct toGroupID) + where T : IEntityDescriptor, new() + { + SwapEntityGroup(fromID, new EGID(fromID.entityID, (uint) toGroupID)); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public void SwapEntityGroup(EGID fromID, ExclusiveGroup.ExclusiveGroupStruct toGroupID + , ExclusiveGroup.ExclusiveGroupStruct mustBeFromGroup) + where T : IEntityDescriptor, new() + { + if (fromID.groupID != mustBeFromGroup) + throw new ECSException("Entity is not coming from the expected group"); + + SwapEntityGroup(fromID, toGroupID); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public void SwapEntityGroup(EGID fromID, EGID toID + , ExclusiveGroup.ExclusiveGroupStruct mustBeFromGroup) + where T : IEntityDescriptor, new() + { + if (fromID.groupID != mustBeFromGroup) + throw new ECSException("Entity is not coming from the expected group"); + + SwapEntityGroup(fromID, toID); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public void SwapEntityGroup(EGID fromID, EGID toID) + where T : IEntityDescriptor, new() + { + _enginesRoot.Target.CheckRemoveEntityID(fromID); + _enginesRoot.Target.CheckAddEntityID(toID); + + _enginesRoot.Target.QueueEntitySubmitOperation( + new EntitySubmitOperation(EntitySubmitOperationType.Swap, + fromID, toID, EntityDescriptorTemplate.descriptor.entitiesToBuild)); + } + + //enginesRoot is a weakreference because GenericEntityStreamConsumerFactory can be injected inside +//engines of other enginesRoot + readonly WeakReference _enginesRoot; + } + + void QueueEntitySubmitOperation(EntitySubmitOperation entitySubmitOperation) + { +#if DEBUG && !PROFILER + entitySubmitOperation.trace = new StackFrame(1, true); +#endif + _entitiesOperations.Add((ulong) entitySubmitOperation.fromID, entitySubmitOperation); + } + + void QueueEntitySubmitOperation(EntitySubmitOperation entitySubmitOperation) where T : IEntityDescriptor + { +#if DEBUG && !PROFILER + entitySubmitOperation.trace = new StackFrame(1, true); + + if (_entitiesOperations.TryGetValue((ulong) entitySubmitOperation.fromID, out var entitySubmitedOperation)) + { + if (entitySubmitedOperation != entitySubmitOperation) + throw new ECSException("Only one entity operation per submission is allowed" + .FastConcat(" entityViewType: ") + .FastConcat(typeof(T).Name) + .FastConcat(" submission type ", entitySubmitOperation.type.ToString(), + " from ID: ", entitySubmitOperation.fromID.entityID.ToString()) + .FastConcat(" previous operation type: ", + _entitiesOperations[(ulong) entitySubmitOperation.fromID].type + .ToString())); + } + else +#endif + _entitiesOperations.Set((ulong) entitySubmitOperation.fromID, entitySubmitOperation); + } + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/EnginesRoot.GenericEntityFunctions.cs.meta b/Svelto.ECS/Svelto.ECS/EnginesRoot.GenericEntityFunctions.cs.meta new file mode 100644 index 0000000..7491222 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EnginesRoot.GenericEntityFunctions.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: dfc6ec8bc3879b04aae4ab41ecd01e63 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/EnginesRoot.Submission.cs b/Svelto.ECS/Svelto.ECS/EnginesRoot.Submission.cs new file mode 100644 index 0000000..f0e8963 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EnginesRoot.Submission.cs @@ -0,0 +1,162 @@ +using System; +using Svelto.Common; +using Svelto.DataStructures; +using Svelto.ECS.Internal; +using Svelto.ECS.Schedulers; + +namespace Svelto.ECS +{ + public partial class EnginesRoot + { + readonly FasterList _transientEntitiesOperations; + + void SubmitEntityViews() + { + using (var profiler = new PlatformProfiler("Svelto.ECS - Entities Submission")) + { + int iterations = 0; + do + { + SingleSubmission(profiler); + } while ((_groupedEntityToAdd.currentEntitiesCreatedPerGroup.Count > 0 || + _entitiesOperations.Count > 0) && ++iterations < 5); + +#if DEBUG && !PROFILER + if (iterations == 5) + throw new ECSException("possible circular submission detected"); +#endif + } + } + + void SingleSubmission(in PlatformProfiler profiler) + { + if (_entitiesOperations.Count > 0) + { + using (profiler.Sample("Remove and Swap operations")) + { + _transientEntitiesOperations.FastClear(); + var entitySubmitOperations = _entitiesOperations.GetValuesArray(out var count); + _transientEntitiesOperations.AddRange(entitySubmitOperations, count); + _entitiesOperations.FastClear(); + + var entitiesOperations = _transientEntitiesOperations.ToArrayFast(); + for (var i = 0; i < _transientEntitiesOperations.Count; i++) + { + try + { + switch (entitiesOperations[i].type) + { + case EntitySubmitOperationType.Swap: + MoveEntityFromAndToEngines(entitiesOperations[i].builders, + entitiesOperations[i].fromID, + entitiesOperations[i].toID); + break; + case EntitySubmitOperationType.Remove: + MoveEntityFromAndToEngines(entitiesOperations[i].builders, + entitiesOperations[i].fromID, null); + break; + case EntitySubmitOperationType.RemoveGroup: + RemoveGroupAndEntitiesFromDB( + entitiesOperations[i].fromID.groupID, profiler); + break; + } + } + catch (Exception e) + { + var str = "Crash while executing Entity Operation " + .FastConcat(entitiesOperations[i].type.ToString()); + + throw new ECSException(str.FastConcat(" ") +#if DEBUG && !PROFILER + .FastConcat(entitiesOperations[i].trace.ToString()) +#endif + , e); + } + } + } + } + + _groupedEntityToAdd.Swap(); + + if (_groupedEntityToAdd.otherEntitiesCreatedPerGroup.Count > 0) + { + using (profiler.Sample("Add operations")) + { + try + { + AddEntityViewsToTheDBAndSuitableEngines(profiler); + } + finally + { + using (profiler.Sample("clear operates double buffering")) + { + //other can be cleared now, but let's avoid deleting the dictionary every time + _groupedEntityToAdd.ClearOther(); + } + } + } + } + } + + void AddEntityViewsToTheDBAndSuitableEngines(in PlatformProfiler profiler) + { + using (profiler.Sample("Add entities to database")) + { + //each group is indexed by entity view type. for each type there is a dictionary indexed by entityID + foreach (var groupOfEntitiesToSubmit in _groupedEntityToAdd.otherEntitiesCreatedPerGroup) + { + var groupID = groupOfEntitiesToSubmit.Key; + + //if the group doesn't exist in the current DB let's create it first + if (_groupEntityViewsDB.TryGetValue(groupID, out var groupDB) == false) + groupDB = _groupEntityViewsDB[groupID] = + new FasterDictionary, ITypeSafeDictionary>(); + + //add the entityViews in the group + foreach (var entityViewsToSubmit in _groupedEntityToAdd.other[groupID]) + { + var type = entityViewsToSubmit.Key; + var typeSafeDictionary = entityViewsToSubmit.Value; + + var wrapper = new RefWrapper(type); + if (groupDB.TryGetValue(wrapper, out var dbDic) == false) + dbDic = groupDB[wrapper] = typeSafeDictionary.Create(); + + //Fill the DB with the entity views generate this frame. + dbDic.AddEntitiesFromDictionary(typeSafeDictionary, groupID); + + if (_groupsPerEntity.TryGetValue(wrapper, out var groupedGroup) == false) + groupedGroup = _groupsPerEntity[wrapper] = + new FasterDictionary(); + + groupedGroup[groupID] = dbDic; + } + } + } + + //then submit everything in the engines, so that the DB is up to date with all the entity views and struct + //created by the entity built + using (profiler.Sample("Add entities to engines")) + { + foreach (var groupToSubmit in _groupedEntityToAdd.otherEntitiesCreatedPerGroup) + { + var groupID = groupToSubmit.Key; + + var groupDB = _groupEntityViewsDB[groupID]; + + foreach (var entityViewsToSubmit in _groupedEntityToAdd.other[groupID]) + { + var realDic = groupDB[new RefWrapper(entityViewsToSubmit.Key)]; + + entityViewsToSubmit.Value.AddEntitiesToEngines(_reactiveEnginesAddRemove, realDic, in profiler, + new ExclusiveGroup.ExclusiveGroupStruct(groupToSubmit.Key)); + } + } + } + } + + DoubleBufferedEntitiesToAdd _groupedEntityToAdd; + readonly IEntitySubmissionScheduler _scheduler; + readonly FasterDictionary _entitiesOperations; + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/EnginesRoot.Submission.cs.meta b/Svelto.ECS/Svelto.ECS/EnginesRoot.Submission.cs.meta new file mode 100644 index 0000000..317d159 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EnginesRoot.Submission.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 52487a06d015a94438830b74e5a5d7f7 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/EntitiesDB.cs b/Svelto.ECS/Svelto.ECS/EntitiesDB.cs new file mode 100644 index 0000000..fb49c7a --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EntitiesDB.cs @@ -0,0 +1,301 @@ +#if DEBUG && !PROFILER +#define ENABLE_DEBUG_FUNC +#endif + +using System; +using System.Runtime.CompilerServices; +using Svelto.DataStructures; + +namespace Svelto.ECS.Internal +{ + partial class EntitiesDB : IEntitiesDB + { + internal EntitiesDB( + FasterDictionary, ITypeSafeDictionary>> groupEntityViewsDB, + FasterDictionary, FasterDictionary> groupsPerEntity, + EntitiesStream entityStream) + { + _groupEntityViewsDB = groupEntityViewsDB; + _groupsPerEntity = groupsPerEntity; + _entityStream = entityStream; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public ref T QueryUniqueEntity(ExclusiveGroup.ExclusiveGroupStruct group) where T : struct, IEntityStruct + { + var entities = QueryEntities(group, out var count); + + if (count == 0) + throw new ECSException("Unique entity not found '".FastConcat(typeof(T).ToString()).FastConcat("'")); + if (count != 1) + throw new ECSException("Unique entities must be unique! '".FastConcat(typeof(T).ToString()) + .FastConcat("'")); + return ref entities[0]; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public ref T QueryEntity(EGID entityGID) where T : struct, IEntityStruct + { + T[] array; + if ((array = QueryEntitiesAndIndexInternal(entityGID, out var index)) != null) + return ref array[index]; + + throw new EntityNotFoundException(entityGID, typeof(T)); + } + + public ref T QueryEntity(uint id, ExclusiveGroup.ExclusiveGroupStruct group) where T : struct, IEntityStruct + { + return ref QueryEntity(new EGID(id, group)); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public T[] QueryEntities(ExclusiveGroup.ExclusiveGroupStruct groupStruct, out uint count) + where T : struct, IEntityStruct + { + uint group = groupStruct; + count = 0; + if (SafeQueryEntityDictionary(group, out TypeSafeDictionary typeSafeDictionary) == false) + return RetrieveEmptyEntityViewArray(); + + return typeSafeDictionary.GetValuesArray(out count); + } + + public EntityCollection QueryEntities(ExclusiveGroup.ExclusiveGroupStruct groupStruct) + where T : struct, IEntityStruct + { + return new EntityCollection(QueryEntities(groupStruct, out var count), count); + } + + public EntityCollection QueryEntities(ExclusiveGroup.ExclusiveGroupStruct groupStruct) + where T1 : struct, IEntityStruct where T2 : struct, IEntityStruct + { + return new EntityCollection(QueryEntities(groupStruct, out var count), count); + } + + public EntityCollection QueryEntities(ExclusiveGroup.ExclusiveGroupStruct groupStruct) + where T1 : struct, IEntityStruct where T2 : struct, IEntityStruct where T3 : struct, IEntityStruct + { + return new EntityCollection(QueryEntities(groupStruct, out var count), count); + } + + public EntityCollections QueryEntities(ExclusiveGroup[] groups) where T : struct, IEntityStruct + { + return new EntityCollections(this, groups); + } + + public EntityCollections QueryEntities(ExclusiveGroup[] groups) + where T1 : struct, IEntityStruct where T2 : struct, IEntityStruct + { + return new EntityCollections(this, groups); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public (T1[], T2[]) QueryEntities(ExclusiveGroup.ExclusiveGroupStruct groupStruct, out uint count) + where T1 : struct, IEntityStruct + where T2 : struct, IEntityStruct + { + var T1entities = QueryEntities(groupStruct, out var countCheck); + var T2entities = QueryEntities(groupStruct, out count); + + if (count != countCheck) + { + throw new ECSException("Entity views count do not match in group. Entity 1: ' count: " + .FastConcat(countCheck) + .FastConcat(typeof(T1).ToString()) + .FastConcat("'. Entity 2: ' count: ".FastConcat(count) + .FastConcat(typeof(T2).ToString()) + .FastConcat("'"))); + } + + return (T1entities, T2entities); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public (T1[], T2[], T3[]) QueryEntities + (ExclusiveGroup.ExclusiveGroupStruct groupStruct, out uint count) + where T1 : struct, IEntityStruct where T2 : struct, IEntityStruct where T3 : struct, IEntityStruct + { + var T1entities = QueryEntities(groupStruct, out var countCheck1); + var T2entities = QueryEntities(groupStruct, out var countCheck2); + var T3entities = QueryEntities(groupStruct, out count); + + if (count != countCheck1 || count != countCheck2) + throw new ECSException("Entity views count do not match in group. Entity 1: " + .FastConcat(typeof(T1).ToString()).FastConcat(" count: ").FastConcat(countCheck1).FastConcat( + " Entity 2: ".FastConcat(typeof(T2).ToString()) + .FastConcat(" count: ").FastConcat(countCheck2) + .FastConcat(" Entity 3: ".FastConcat(typeof(T3).ToString())).FastConcat(" count: ") + .FastConcat(count))); + + return (T1entities, T2entities, T3entities); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public EGIDMapper QueryMappedEntities(ExclusiveGroup.ExclusiveGroupStruct groupStructId) + where T : struct, IEntityStruct + { + if (SafeQueryEntityDictionary(groupStructId, out TypeSafeDictionary typeSafeDictionary) == false) + throw new EntityGroupNotFoundException(groupStructId, typeof(T)); + + EGIDMapper mapper; + mapper.map = typeSafeDictionary; + + return mapper; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool TryQueryMappedEntities(ExclusiveGroup.ExclusiveGroupStruct groupStructId, + out EGIDMapper mapper) + where T : struct, IEntityStruct + { + mapper = default; + if (SafeQueryEntityDictionary(groupStructId, out TypeSafeDictionary typeSafeDictionary) == false) + return false; + + mapper.map = typeSafeDictionary; + + return true; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public T[] QueryEntitiesAndIndex(EGID entityGID, out uint index) where T : struct, IEntityStruct + { + T[] array; + if ((array = QueryEntitiesAndIndexInternal(entityGID, out index)) != null) + return array; + + throw new EntityNotFoundException(entityGID, typeof(T)); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool TryQueryEntitiesAndIndex(EGID entityGid, out uint index, out T[] array) + where T : struct, IEntityStruct + { + if ((array = QueryEntitiesAndIndexInternal(entityGid, out index)) != null) + return true; + + return false; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public T[] QueryEntitiesAndIndex(uint id, ExclusiveGroup.ExclusiveGroupStruct group, out uint index) + where T : struct, IEntityStruct + { + return QueryEntitiesAndIndex(new EGID(id, group), out index); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool TryQueryEntitiesAndIndex(uint id, ExclusiveGroup.ExclusiveGroupStruct group, out uint index, + out T[] array) where T : struct, IEntityStruct + { + return TryQueryEntitiesAndIndex(new EGID(id, group), out index, out array); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool Exists(EGID entityGID) where T : struct, IEntityStruct + { + if (SafeQueryEntityDictionary(entityGID.groupID, out TypeSafeDictionary casted) == false) return false; + + return casted != null && casted.ContainsKey(entityGID.entityID); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool Exists(uint id, ExclusiveGroup.ExclusiveGroupStruct group) where T : struct, IEntityStruct + { + if (SafeQueryEntityDictionary(group, out TypeSafeDictionary casted) == false) return false; + + return casted != null && casted.ContainsKey(id); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool Exists(ExclusiveGroup.ExclusiveGroupStruct gid) + { + return _groupEntityViewsDB.ContainsKey(gid); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool HasAny(ExclusiveGroup.ExclusiveGroupStruct groupStruct) where T : struct, IEntityStruct + { + QueryEntities(groupStruct, out var count); + return count > 0; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint Count(ExclusiveGroup.ExclusiveGroupStruct groupStruct) where T : struct, IEntityStruct + { + QueryEntities(groupStruct, out var count); + return count; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public void PublishEntityChange(EGID egid) where T : unmanaged, IEntityStruct + { + _entityStream.PublishEntity(ref QueryEntity(egid), egid); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + T[] QueryEntitiesAndIndexInternal(EGID entityGID, out uint index) where T : struct, IEntityStruct + { + index = 0; + if (SafeQueryEntityDictionary(entityGID.groupID, out TypeSafeDictionary safeDictionary) == false) + return null; + + if (safeDictionary.TryFindIndex(entityGID.entityID, out index) == false) + return null; + + return safeDictionary.GetValuesArray(out _); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + bool SafeQueryEntityDictionary(uint group, out TypeSafeDictionary typeSafeDictionary) + where T : struct, IEntityStruct + { + if (UnsafeQueryEntityDictionary(group, TypeCache.type, out var safeDictionary) == false) + { + typeSafeDictionary = default; + return false; + } + + //return the indexes entities if they exist + typeSafeDictionary = safeDictionary as TypeSafeDictionary; + + return true; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal bool UnsafeQueryEntityDictionary(uint group, Type type, out ITypeSafeDictionary typeSafeDictionary) + { + //search for the group + if (_groupEntityViewsDB.TryGetValue(group, out var entitiesInGroupPerType) == false) + { + typeSafeDictionary = null; + return false; + } + + //search for the indexed entities in the group + return entitiesInGroupPerType.TryGetValue(new RefWrapper(type), out typeSafeDictionary); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + static T[] RetrieveEmptyEntityViewArray() + { + return EmptyList.emptyArray; + } + + //grouped set of entity views, this is the standard way to handle entity views entity views are grouped per + //group, then indexable per type, then indexable per EGID. however the TypeSafeDictionary can return an array of + //values directly, that can be iterated over, so that is possible to iterate over all the entity views of + //a specific type inside a specific group. + readonly FasterDictionary, ITypeSafeDictionary>> _groupEntityViewsDB; + + //needed to be able to iterate over all the entities of the same type regardless the group + //may change in future + readonly FasterDictionary, FasterDictionary> _groupsPerEntity; + readonly EntitiesStream _entityStream; + + static class EmptyList + { + internal static readonly T[] emptyArray = new T[0]; + } + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/EntitiesDB.cs.meta b/Svelto.ECS/Svelto.ECS/EntitiesDB.cs.meta new file mode 100644 index 0000000..66b0160 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EntitiesDB.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: cb0042f8a957c1a4d8eb8998a0e4eef9 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/EntityBuilder.CheckFields.cs b/Svelto.ECS/Svelto.ECS/EntityBuilder.CheckFields.cs new file mode 100644 index 0000000..f1f2d25 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EntityBuilder.CheckFields.cs @@ -0,0 +1,138 @@ +#if !DEBUG || PROFILER +#define DISABLE_CHECKS +using System.Diagnostics; +#endif +using System; +using System.Reflection; + +namespace Svelto.ECS +{ + internal static class EntityBuilderUtilities + { + const string MSG = "Entity Structs field and Entity View Struct components must hold value types."; + + +#if DISABLE_CHECKS + [Conditional("_CHECKS_DISABLED")] +#endif + public static void CheckFields(Type entityStructType, bool needsReflection, bool isStringAllowed = false) + { + if (entityStructType == ENTITY_STRUCT_INFO_VIEW || + entityStructType == EGIDType || + entityStructType == EXCLUSIVEGROUPSTRUCTTYPE || + entityStructType == SERIALIZABLE_ENTITY_STRUCT) + { + return; + } + + if (needsReflection == false) + { + if (entityStructType.IsClass) + { + throw new EntityStructException("EntityStructs must be structs.", entityStructType); + } + + FieldInfo[] fields = entityStructType.GetFields(BindingFlags.Public | BindingFlags.Instance); + + for (var i = fields.Length - 1; i >= 0; --i) + { + FieldInfo fieldInfo = fields[i]; + Type fieldType = fieldInfo.FieldType; + + SubCheckFields(fieldType, entityStructType, isStringAllowed); + } + } + else + { + FieldInfo[] fields = entityStructType.GetFields(BindingFlags.Public | BindingFlags.Instance); + + if (fields.Length < 1) + { + ProcessError("Entity View Structs must hold only entity components interfaces.", entityStructType); + } + + for (int i = fields.Length - 1; i >= 0; --i) + { + FieldInfo fieldInfo = fields[i]; + + if (fieldInfo.FieldType.IsInterfaceEx() == false) + { + ProcessError("Entity View Structs must hold only entity components interfaces.", + entityStructType); + } + + PropertyInfo[] properties = fieldInfo.FieldType.GetProperties( + BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly); + + for (int j = properties.Length - 1; j >= 0; --j) + { + if (properties[j].PropertyType.IsGenericType) + { + Type genericTypeDefinition = properties[j].PropertyType.GetGenericTypeDefinition(); + if (genericTypeDefinition == DISPATCHONSETTYPE || + genericTypeDefinition == DISPATCHONCHANGETYPE) + { + continue; + } + } + + Type propertyType = properties[j].PropertyType; + if (propertyType != STRINGTYPE) + { + //for EntityViewStructs, component fields that are structs that hold strings + //are allowed + SubCheckFields(propertyType, entityStructType, isStringAllowed: true); + } + } + } + } + } + + static void SubCheckFields(Type fieldType, Type entityStructType, bool isStringAllowed = false) + { + if (fieldType.IsPrimitive || fieldType.IsValueType || (isStringAllowed == true && fieldType == STRINGTYPE)) + { + if (fieldType.IsValueType && !fieldType.IsEnum && fieldType.IsPrimitive == false) + { + CheckFields(fieldType, false, isStringAllowed); + } + + return; + } + + ProcessError(MSG, entityStructType, fieldType); + } + + static void ProcessError(string message, Type entityViewType, Type fieldType = null) + { + if (fieldType != null) + { + throw new EntityStructException(message, entityViewType, fieldType); + } + + throw new EntityStructException(message, entityViewType); + } + + static readonly Type DISPATCHONCHANGETYPE = typeof(DispatchOnChange<>); + static readonly Type DISPATCHONSETTYPE = typeof(DispatchOnSet<>); + static readonly Type EGIDType = typeof(EGID); + static readonly Type EXCLUSIVEGROUPSTRUCTTYPE = typeof(ExclusiveGroup.ExclusiveGroupStruct); + static readonly Type SERIALIZABLE_ENTITY_STRUCT = typeof(SerializableEntityStruct); + static readonly Type STRINGTYPE = typeof(string); + + internal static readonly Type ENTITY_STRUCT_INFO_VIEW = typeof(EntityStructInfoView); + } + + public class EntityStructException : Exception + { + public EntityStructException(string message, Type entityViewType, Type type) : + base(message.FastConcat(" entity view: '", entityViewType.ToString(), "', field: '", type.ToString())) + { + } + + public EntityStructException(string message, Type entityViewType) : + base(message.FastConcat(" entity view: ", entityViewType.ToString())) + { + } + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/EntityBuilder.CheckFields.cs.meta b/Svelto.ECS/Svelto.ECS/EntityBuilder.CheckFields.cs.meta new file mode 100644 index 0000000..910bc69 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EntityBuilder.CheckFields.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: bbdea957dc4279b449608942ff29174e +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/EntityBuilder.cs b/Svelto.ECS/Svelto.ECS/EntityBuilder.cs new file mode 100644 index 0000000..78aaffa --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EntityBuilder.cs @@ -0,0 +1,146 @@ +using System; +using System.Collections.Generic; +using System.Reflection; +using Svelto.DataStructures; +using Svelto.ECS.Hybrid; +using Svelto.ECS.Internal; +using Svelto.Utilities; + +namespace Svelto.ECS +{ + public class EntityBuilder : IEntityBuilder where T : struct, IEntityStruct + { + static class EntityView + { + internal static readonly FasterList>> cachedFields; + internal static readonly Dictionary cachedTypes; +#if DEBUG && !PROFILER + internal static readonly Dictionary> implementorsByType; +#else + internal static readonly Dictionary implementorsByType; +#endif + static EntityView() + { + cachedFields = new FasterList>>(); + + var type = typeof(T); + + var fields = type.GetFields(BindingFlags.Public | + BindingFlags.Instance); + + for (var i = fields.Length - 1; i >= 0; --i) + { + var field = fields[i]; + + var setter = FastInvoke.MakeSetter(field); + + cachedFields.Add(new KeyValuePair>(field.FieldType, setter)); + } + + cachedTypes = new Dictionary(); + +#if DEBUG && !PROFILER + implementorsByType = new Dictionary>(); +#else + implementorsByType = new Dictionary(); +#endif + } + + internal static void InitCache() + {} + + internal static void BuildEntityView(out T entityView) + { + entityView = new T(); + } + } + + public EntityBuilder() + { + _initializer = DEFAULT_IT; + + EntityBuilderUtilities.CheckFields(ENTITY_VIEW_TYPE, NEEDS_REFLECTION); + + if (NEEDS_REFLECTION) + EntityView.InitCache(); + } + + public EntityBuilder(in T initializer) : this() + { + _initializer = initializer; + } + + public void BuildEntityAndAddToList(ref ITypeSafeDictionary dictionary, EGID egid, + IEnumerable implementors) + { + if (dictionary == null) + dictionary = new TypeSafeDictionary(); + + var castedDic = dictionary as TypeSafeDictionary; + + if (NEEDS_REFLECTION) + { + DBC.ECS.Check.Require(implementors != null, + $"Implementors not found while building an EntityView `{typeof(T)}`"); + DBC.ECS.Check.Require(castedDic.ContainsKey(egid.entityID) == false, + $"building an entity with already used entity id! id: '{(ulong) egid}', {ENTITY_VIEW_NAME}"); + + EntityView.BuildEntityView(out var entityView); + + this.FillEntityView(ref entityView, entityViewBlazingFastReflection, implementors, + EntityView.implementorsByType, EntityView.cachedTypes); + + castedDic.Add(egid.entityID, entityView); + } + else + { + DBC.ECS.Check.Require(!castedDic.ContainsKey(egid.entityID), + $"building an entity with already used entity id! id: '{egid.entityID}'"); + + castedDic.Add(egid.entityID, _initializer); + } + } + + ITypeSafeDictionary IEntityBuilder.Preallocate(ref ITypeSafeDictionary dictionary, uint size) + { + return Preallocate(ref dictionary, size); + } + + static ITypeSafeDictionary Preallocate(ref ITypeSafeDictionary dictionary, uint size) + { + if (dictionary == null) + dictionary = new TypeSafeDictionary(size); + else + dictionary.SetCapacity(size); + + return dictionary; + } + + public Type GetEntityType() + { + return ENTITY_VIEW_TYPE; + } + + static EntityBuilder() + { + ENTITY_VIEW_TYPE = typeof(T); + DEFAULT_IT = default; + NEEDS_REFLECTION = typeof(IEntityViewStruct).IsAssignableFrom(ENTITY_VIEW_TYPE); + HAS_EGID = typeof(INeedEGID).IsAssignableFrom(ENTITY_VIEW_TYPE); + ENTITY_VIEW_NAME = ENTITY_VIEW_TYPE.ToString(); + SetEGIDWithoutBoxing.Warmup(); + } + + readonly T _initializer; + + static FasterList>> entityViewBlazingFastReflection => + EntityView.cachedFields; + + internal static readonly Type ENTITY_VIEW_TYPE; + public static readonly bool HAS_EGID; + + static readonly T DEFAULT_IT; + static readonly bool NEEDS_REFLECTION; + static readonly string ENTITY_VIEW_NAME; + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/EntityBuilder.cs.meta b/Svelto.ECS/Svelto.ECS/EntityBuilder.cs.meta new file mode 100644 index 0000000..5b1c5c6 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EntityBuilder.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 18b343f034fedc946a8a1bea33d0d3b3 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/EntityBuilder.cs.rej b/Svelto.ECS/Svelto.ECS/EntityBuilder.cs.rej new file mode 100644 index 0000000..9ea149e --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EntityBuilder.cs.rej @@ -0,0 +1,8 @@ +diff a/Assets/Svelto/Svelto.ECS/EntityBuilder.cs b/Assets/Svelto/Svelto.ECS/EntityBuilder.cs (rejected hunks) +@@ -1,5 +1,6 @@ + using System; + using System.Collections.Generic; ++using DBC.ECS; + using Svelto.DataStructures; + using Svelto.ECS.Hybrid; + using Svelto.ECS.Internal; diff --git a/Svelto.ECS/Svelto.ECS/EntityBuilder.cs.rej.meta b/Svelto.ECS/Svelto.ECS/EntityBuilder.cs.rej.meta new file mode 100644 index 0000000..a83fa6a --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EntityBuilder.cs.rej.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: cb0c0429aca72c945b88d01cd901f218 +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/EntityCollection.cs b/Svelto.ECS/Svelto.ECS/EntityCollection.cs new file mode 100644 index 0000000..355e0e8 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EntityCollection.cs @@ -0,0 +1,326 @@ +using System; +using System.Collections; +using System.Collections.Generic; + +namespace Svelto.ECS +{ + public struct EntityCollection + { + public EntityCollection(T[] array, uint count) + { + _array = array; + _count = count; + } + + public EntityIterator GetEnumerator() + { + return new EntityIterator(_array, _count); + } + + readonly T[] _array; + readonly uint _count; + + public struct EntityIterator : IEnumerator + { + public EntityIterator(T[] array, uint count) : this() + { + _array = array; + _count = count; + _index = -1; + } + + public bool MoveNext() + { + return ++_index < _count; + } + + public void Reset() + { + _index = -1; + } + + public ref T Current => ref _array[_index]; + + T IEnumerator.Current => throw new NotImplementedException(); + object IEnumerator.Current => throw new NotImplementedException(); + + public void Dispose() {} + + readonly T[] _array; + readonly uint _count; + int _index; + } + } + + public struct EntityCollection + { + public EntityCollection(in (T1[], T2[]) array, uint count) + { + _array = array; + _count = count; + } + + public EntityIterator GetEnumerator() + { + return new EntityIterator(_array, _count); + } + + readonly (T1[], T2[]) _array; + readonly uint _count; + + public struct EntityIterator : IEnumerator> + { + public EntityIterator((T1[], T2[]) array, uint count) : this() + { + _array = array; + _count = count; + _index = -1; + } + + public bool MoveNext() + { + return ++_index < _count; + } + + public void Reset() + { + _index = -1; + } + + public ValueRef Current => new ValueRef(_array, (uint) _index); + + ValueRef IEnumerator>. Current => throw new NotImplementedException(); + object IEnumerator.Current => throw new NotImplementedException(); + + public void Dispose() {} + + readonly (T1[], T2[]) _array; + readonly uint _count; + int _index; + } + } + + public struct EntityCollection + { + public EntityCollection(in (T1[], T2[], T3[]) array, uint count) + { + _array = array; + _count = count; + } + + public EntityIterator GetEnumerator() + { + return new EntityIterator(_array, _count); + } + + readonly (T1[], T2[], T3[]) _array; + readonly uint _count; + + public struct EntityIterator : IEnumerator> + { + public EntityIterator((T1[], T2[], T3[]) array, uint count) : this() + { + _array = array; + _count = count; + _index = -1; + } + + public bool MoveNext() + { + return ++_index < _count; + } + + public void Reset() + { + _index = -1; + } + + public ValueRef Current => new ValueRef(_array, (uint) _index); + + ValueRef IEnumerator>.Current => throw new NotImplementedException(); + object IEnumerator. Current => throw new NotImplementedException(); + + public void Dispose() {} + + readonly (T1[], T2[], T3[]) _array; + readonly uint _count; + int _index; + } + } + + public struct EntityCollections where T : struct, IEntityStruct + { + public EntityCollections(IEntitiesDB db, ExclusiveGroup[] groups) : this() + { + _db = db; + _groups = groups; + } + + public EntityGroupsIterator GetEnumerator() + { + return new EntityGroupsIterator(_db, _groups); + } + + readonly IEntitiesDB _db; + readonly ExclusiveGroup[] _groups; + + public struct EntityGroupsIterator : IEnumerator + { + public EntityGroupsIterator(IEntitiesDB db, ExclusiveGroup[] groups) : this() + { + _db = db; + _groups = groups; + _indexGroup = -1; + _index = -1; + } + + public bool MoveNext() + { + while (_index + 1 >= _count && ++_indexGroup < _groups.Length) + { + _index = -1; + _array = _db.QueryEntities(_groups[_indexGroup], out _count); + } + + return ++_index < _count; + } + + public void Reset() + { + _index = -1; + _indexGroup = -1; + _count = 0; + } + + public ref T Current => ref _array[_index]; + + T IEnumerator.Current => throw new NotImplementedException(); + object IEnumerator.Current => throw new NotImplementedException(); + + public void Dispose() {} + + readonly IEntitiesDB _db; + readonly ExclusiveGroup[] _groups; + + T[] _array; + uint _count; + int _index; + int _indexGroup; + } + } + + public struct EntityCollections where T1 : struct, IEntityStruct where T2 : struct, IEntityStruct + { + public EntityCollections(IEntitiesDB db, ExclusiveGroup[] groups) : this() + { + _db = db; + _groups = groups; + } + + public EntityGroupsIterator GetEnumerator() + { + return new EntityGroupsIterator(_db, _groups); + } + + readonly IEntitiesDB _db; + readonly ExclusiveGroup[] _groups; + + public struct EntityGroupsIterator : IEnumerator> + { + public EntityGroupsIterator(IEntitiesDB db, ExclusiveGroup[] groups) : this() + { + _db = db; + _groups = groups; + _indexGroup = -1; + _index = -1; + } + + public bool MoveNext() + { + while (_index + 1 >= _count && ++_indexGroup < _groups.Length) + { + _index = -1; + var array1 = _db.QueryEntities(_groups[_indexGroup], out _count); + var array2 = _db.QueryEntities(_groups[_indexGroup], out var count1); + _array = (array1, array2); + +#if DEBUG && !PROFILER + if (_count != count1) + throw new ECSException("number of entities in group doesn't match"); +#endif + } + + return ++_index < _count; + } + + public void Reset() + { + _index = -1; + _indexGroup = -1; + + var array1 = _db.QueryEntities(_groups[0], out _count); + var array2 = _db.QueryEntities(_groups[0], out var count1); + _array = (array1, array2); +#if DEBUG && !PROFILER + if (_count != count1) + throw new ECSException("number of entities in group doesn't match"); +#endif + } + + public ValueRef Current + { + get + { + var valueRef = new ValueRef(_array, (uint) _index); + return valueRef; + } + } + + ValueRef IEnumerator>.Current => throw new NotImplementedException(); + object IEnumerator.Current => throw new NotImplementedException(); + + public void Dispose() {} + + readonly IEntitiesDB _db; + readonly ExclusiveGroup[] _groups; + uint _count; + int _index; + int _indexGroup; + (T1[], T2[]) _array; + } + } + + public struct ValueRef + { + readonly (T1[], T2[]) array; + + readonly uint index; + + public ValueRef(in (T1[], T2[]) entity1, uint i) + { + array = entity1; + index = i; + } + + public ref T1 entityStructA => ref array.Item1[index]; + public ref T2 entityStructB => ref array.Item2[index]; + } + + public struct ValueRef + { + readonly (T1[], T2[], T3[]) array; + + readonly uint index; + + public ValueRef(in (T1[], T2[], T3[]) entity1, uint i) + { + array = entity1; + index = i; + } + + public ref T1 entityStructA => ref array.Item1[index]; + public ref T2 entityStructB => ref array.Item2[index]; + public ref T3 entityStructC => ref array.Item3[index]; + + } +} diff --git a/Svelto.ECS/Svelto.ECS/EntityCollection.cs.meta b/Svelto.ECS/Svelto.ECS/EntityCollection.cs.meta new file mode 100644 index 0000000..d4274aa --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EntityCollection.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: b477a77cde9842c4938fe4c4143d6479 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/EntityDescriptorTemplate.cs b/Svelto.ECS/Svelto.ECS/EntityDescriptorTemplate.cs new file mode 100644 index 0000000..b96e3bd --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EntityDescriptorTemplate.cs @@ -0,0 +1,17 @@ +namespace Svelto.ECS +{ + public interface IEntityDescriptor + { + IEntityBuilder[] entitiesToBuild { get; } + } + + static class EntityDescriptorTemplate where TType : IEntityDescriptor, new() + { + static EntityDescriptorTemplate() + { + descriptor = new TType(); + } + + public static IEntityDescriptor descriptor { get; } + } +} diff --git a/Svelto.ECS/Svelto.ECS/EntityDescriptorTemplate.cs.meta b/Svelto.ECS/Svelto.ECS/EntityDescriptorTemplate.cs.meta new file mode 100644 index 0000000..066f83d --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EntityDescriptorTemplate.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 1ecaeae9d21e0e8458a05cf7608e782a +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/EntityFactory.cs b/Svelto.ECS/Svelto.ECS/EntityFactory.cs new file mode 100644 index 0000000..3556ae8 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EntityFactory.cs @@ -0,0 +1,97 @@ +using System; +using System.Collections.Generic; +using Svelto.DataStructures; + +namespace Svelto.ECS.Internal +{ + static class EntityFactory + { + public static FasterDictionary, ITypeSafeDictionary> BuildGroupedEntities(EGID egid, + EnginesRoot.DoubleBufferedEntitiesToAdd groupEntitiesToAdd, + IEntityBuilder[] entitiesToBuild, + IEnumerable implementors) + { + var group = FetchEntityGroup(egid.groupID, groupEntitiesToAdd); + + BuildEntitiesAndAddToGroup(egid, group, entitiesToBuild, implementors); + + return group; + } + + static FasterDictionary, ITypeSafeDictionary> FetchEntityGroup(uint groupID, + EnginesRoot.DoubleBufferedEntitiesToAdd groupEntityViewsByType) + { + if (groupEntityViewsByType.current.TryGetValue(groupID, out var group) == false) + { + group = new FasterDictionary, ITypeSafeDictionary>(); + + groupEntityViewsByType.current.Add(groupID, group); + } + + if (groupEntityViewsByType.currentEntitiesCreatedPerGroup.TryGetValue(groupID, out var value) == false) + groupEntityViewsByType.currentEntitiesCreatedPerGroup[groupID] = 0; + else + groupEntityViewsByType.currentEntitiesCreatedPerGroup[groupID] = value+1; + + return group; + } + + static void BuildEntitiesAndAddToGroup(EGID entityID, + FasterDictionary, ITypeSafeDictionary> group, + IEntityBuilder[] entityBuilders, IEnumerable implementors) + { +#if DEBUG && !PROFILER + HashSet types = new HashSet(); +#endif + InternalBuild(entityID, group, entityBuilders, implementors +#if DEBUG && !PROFILER + , types +#endif + ); + } + + static void InternalBuild(EGID entityID, FasterDictionary, ITypeSafeDictionary> group, + IEntityBuilder[] entityBuilders, IEnumerable implementors +#if DEBUG && !PROFILER + , HashSet types +#endif + ) + { + var count = entityBuilders.Length; +#if DEBUG && !PROFILER + for (var index = 0; index < count; ++index) + { + var entityViewType = entityBuilders[index].GetEntityType(); + if (types.Contains(entityViewType)) + { + throw new ECSException("EntityBuilders must be unique inside an EntityDescriptor"); + } + + types.Add(entityViewType); + } +#endif + for (var index = 0; index < count; ++index) + { + var entityStructBuilder = entityBuilders[index]; + var entityViewType = entityStructBuilder.GetEntityType(); + + BuildEntity(entityID, group, entityViewType, entityStructBuilder, implementors); + } + } + + static void BuildEntity(EGID entityID, FasterDictionary, ITypeSafeDictionary> group, + Type entityViewType, IEntityBuilder entityBuilder, IEnumerable implementors) + { + var entityViewsPoolWillBeCreated = + group.TryGetValue(new RefWrapper(entityViewType), out var safeDictionary) == false; + + //passing the undefined entityViewsByType inside the entityViewBuilder will allow it to be created with the + //correct type and casted back to the undefined list. that's how the list will be eventually of the target + //type. + entityBuilder.BuildEntityAndAddToList(ref safeDictionary, entityID, implementors); + + if (entityViewsPoolWillBeCreated) + group.Add(new RefWrapper(entityViewType), safeDictionary); + } + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/EntityFactory.cs.meta b/Svelto.ECS/Svelto.ECS/EntityFactory.cs.meta new file mode 100644 index 0000000..b561267 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EntityFactory.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 73604bc7f8d240e4e8730f9f28705114 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/EntityGroupNotFoundException.cs b/Svelto.ECS/Svelto.ECS/EntityGroupNotFoundException.cs new file mode 100644 index 0000000..63fb6e6 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EntityGroupNotFoundException.cs @@ -0,0 +1,12 @@ +using System; + +namespace Svelto.ECS.Internal +{ + class EntityGroupNotFoundException : Exception + { + public EntityGroupNotFoundException(uint groupId, Type type) + : base("entity group not found ".FastConcat(type.ToString())) + { + } + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/EntityGroupNotFoundException.cs.meta b/Svelto.ECS/Svelto.ECS/EntityGroupNotFoundException.cs.meta new file mode 100644 index 0000000..752495f --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EntityGroupNotFoundException.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 4263819fdb1fe88498346ad16e7cfc08 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/EntityHierarchyStruct.cs b/Svelto.ECS/Svelto.ECS/EntityHierarchyStruct.cs new file mode 100644 index 0000000..c0fe044 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EntityHierarchyStruct.cs @@ -0,0 +1,11 @@ +namespace Svelto.ECS +{ + public struct EntityHierarchyStruct: IEntityStruct, INeedEGID + { + public readonly ExclusiveGroup.ExclusiveGroupStruct parentGroup; + + public EntityHierarchyStruct(ExclusiveGroup group): this() { parentGroup = group; } + + public EGID ID { get; set; } + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/EntityHierarchyStruct.cs.meta b/Svelto.ECS/Svelto.ECS/EntityHierarchyStruct.cs.meta new file mode 100644 index 0000000..c01f057 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EntityHierarchyStruct.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: ed0c5daf03d0e29458868443df80b239 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/EntityInfoView.cs b/Svelto.ECS/Svelto.ECS/EntityInfoView.cs new file mode 100644 index 0000000..98711f8 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EntityInfoView.cs @@ -0,0 +1,7 @@ +namespace Svelto.ECS +{ + struct EntityStructInfoView: IEntityStruct + { + public IEntityBuilder[] entitiesToBuild; + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/EntityInfoView.cs.meta b/Svelto.ECS/Svelto.ECS/EntityInfoView.cs.meta new file mode 100644 index 0000000..5caa1e4 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EntityInfoView.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 9de43f2cdb7017f4cb3cd7ecf923b932 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/EntityNotFoundException.cs b/Svelto.ECS/Svelto.ECS/EntityNotFoundException.cs new file mode 100644 index 0000000..e2e4fda --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EntityNotFoundException.cs @@ -0,0 +1,12 @@ +using System; + +namespace Svelto.ECS +{ + public class EntityNotFoundException : Exception + { + public EntityNotFoundException(EGID entityEGID, Type entityType) : base( + $"entity of type '{entityType}' with ID '{entityEGID.entityID}', group '{(uint) entityEGID.groupID}' not found!") + { + } + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/EntityNotFoundException.cs.meta b/Svelto.ECS/Svelto.ECS/EntityNotFoundException.cs.meta new file mode 100644 index 0000000..a06d195 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EntityNotFoundException.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 77beec6a936d3ad4f94b89eb4a28b14f +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/EntityStream.cs b/Svelto.ECS/Svelto.ECS/EntityStream.cs new file mode 100644 index 0000000..d8aaf24 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EntityStream.cs @@ -0,0 +1,163 @@ +using System; +using Svelto.DataStructures; + +namespace Svelto.ECS +{ + /// + /// Do not use this class in place of a normal polling. + /// I eventually realised than in ECS no form of communication other than polling entity components can exist. + /// Using groups, you can have always an optimal set of entity components to poll, so EntityStreams must be used + /// only if: + /// - you want to polling engine to be able to track all the entity changes happening in between polls and not + /// just the current state + /// - you want a thread-safe way to read entity states, which includes all the state changes and not the last + /// one only + /// - you want to communicate between EnginesRoots + /// + + class EntitiesStream : IDisposable + { + internal Consumer GenerateConsumer(string name, uint capacity) where T : unmanaged, IEntityStruct + { + if (_streams.ContainsKey(TypeRefWrapper.wrapper) == false) _streams[TypeRefWrapper.wrapper] = new EntityStream(); + + return (_streams[TypeRefWrapper.wrapper] as EntityStream).GenerateConsumer(name, capacity); + } + + public Consumer GenerateConsumer(ExclusiveGroup group, string name, uint capacity) + where T : unmanaged, IEntityStruct + { + if (_streams.ContainsKey(TypeRefWrapper.wrapper) == false) _streams[TypeRefWrapper.wrapper] = new EntityStream(); + + return (_streams[TypeRefWrapper.wrapper] as EntityStream).GenerateConsumer(group, name, capacity); + } + + internal void PublishEntity(ref T entity, EGID egid) where T : unmanaged, IEntityStruct + { + if (_streams.TryGetValue(TypeRefWrapper.wrapper, out var typeSafeStream)) + (typeSafeStream as EntityStream).PublishEntity(ref entity, egid); + else + Console.LogDebug("No Consumers are waiting for this entity to change ", typeof(T)); + } + + readonly ThreadSafeDictionary, ITypeSafeStream> _streams = + new ThreadSafeDictionary, ITypeSafeStream>(); + + public void Dispose() + { + _streams.Clear(); + } + } + + interface ITypeSafeStream + {} + + class EntityStream : ITypeSafeStream where T : unmanaged, IEntityStruct + { + public void PublishEntity(ref T entity, EGID egid) + { + for (int i = 0; i < _consumers.Count; i++) + { + if (_consumers[i]._hasGroup) + { + if (egid.groupID == _consumers[i]._group) + { + _consumers[i].Enqueue(entity, egid); + } + } + else + { + _consumers[i].Enqueue(entity, egid); + } + } + } + + public Consumer GenerateConsumer(string name, uint capacity) + { + var consumer = new Consumer(name, capacity, this); + + _consumers.Add(consumer); + + return consumer; + } + + public Consumer GenerateConsumer(ExclusiveGroup group, string name, uint capacity) + { + var consumer = new Consumer(group, name, capacity, this); + + _consumers.Add(consumer); + + return consumer; + } + + public void RemoveConsumer(Consumer consumer) + { + _consumers.UnorderedRemove(consumer); + } + + readonly FasterListThreadSafe> _consumers = new FasterListThreadSafe>(); + } + + public struct Consumer : IDisposable where T : unmanaged, IEntityStruct + { + internal Consumer(string name, uint capacity, EntityStream stream):this() + { +#if DEBUG && !PROFILER + _name = name; +#endif + _ringBuffer = new RingBuffer>((int) capacity, +#if DEBUG && !PROFILER + _name +#else + string.Empty +#endif + ); + + _stream = stream; + } + + internal Consumer(ExclusiveGroup group, string name, uint capacity, EntityStream stream) : this(name, + capacity, stream) + { + _group = group; + _hasGroup = true; + } + + internal void Enqueue(in T entity, in EGID egid) + { + _ringBuffer.Enqueue((entity, egid)); + } + + public bool TryDequeue(out T entity) + { + var tryDequeue = _ringBuffer.TryDequeue(out var values); + + entity = values.Item1; + + return tryDequeue; + } + + public bool TryDequeue(out T entity, out EGID id) + { + var tryDequeue = _ringBuffer.TryDequeue(out var values); + + entity = values.Item1; + id = values.Item2; + + return tryDequeue; + } + public void Flush() { _ringBuffer.Reset(); } + public void Dispose() { _stream.RemoveConsumer(this); } + public uint Count() { return (uint) _ringBuffer.Count; } + + readonly RingBuffer> _ringBuffer; + readonly EntityStream _stream; + + internal readonly ExclusiveGroup _group; + internal readonly bool _hasGroup; + +#if DEBUG && !PROFILER + readonly string _name; +#endif + } +} diff --git a/Svelto.ECS/Svelto.ECS/EntityStream.cs.meta b/Svelto.ECS/Svelto.ECS/EntityStream.cs.meta new file mode 100644 index 0000000..68e09d6 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EntityStream.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: b3ae4a042b4e3304c921fe85e830ff4c +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/EntityStructInitializer.cs b/Svelto.ECS/Svelto.ECS/EntityStructInitializer.cs new file mode 100644 index 0000000..ed85d53 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EntityStructInitializer.cs @@ -0,0 +1,75 @@ +using System; +using Svelto.DataStructures; +using Svelto.ECS.Internal; + +namespace Svelto.ECS +{ + public ref struct EntityStructInitializer + { + public EntityStructInitializer(EGID id, FasterDictionary, ITypeSafeDictionary> group) + { + _group = group; + _ID = id; + } + + public void Init(T initializer) where T : struct, IEntityStruct + { + if (_group.TryGetValue(new RefWrapper(EntityBuilder.ENTITY_VIEW_TYPE), + out var typeSafeDictionary) == false) return; + + var dictionary = (TypeSafeDictionary) typeSafeDictionary; + + if (EntityBuilder.HAS_EGID) + SetEGIDWithoutBoxing.SetIDWithoutBoxing(ref initializer, _ID); + + if (dictionary.TryFindIndex(_ID.entityID, out var findElementIndex)) + dictionary.GetDirectValue(findElementIndex) = initializer; + } + + public void CopyFrom(T initializer) where T : struct, IEntityStruct + { + var dictionary = (TypeSafeDictionary) _group[new RefWrapper(EntityBuilder.ENTITY_VIEW_TYPE)]; + + if (EntityBuilder.HAS_EGID) + SetEGIDWithoutBoxing.SetIDWithoutBoxing(ref initializer, _ID); + + dictionary[_ID.entityID] = initializer; + } + + public ref T GetOrCreate() where T : struct, IEntityStruct + { + ref var entityDictionary = ref _group.GetOrCreate(new RefWrapper(EntityBuilder.ENTITY_VIEW_TYPE) + , () => new TypeSafeDictionary()); + var dictionary = (TypeSafeDictionary) entityDictionary; + + return ref dictionary.GetOrCreate(_ID.entityID); + } + + public T Get() where T : struct, IEntityStruct + { + return (_group[new RefWrapper(EntityBuilder.ENTITY_VIEW_TYPE)] as TypeSafeDictionary)[_ID.entityID]; + } + + public bool Has() where T : struct, IEntityStruct + { + if (_group.TryGetValue(new RefWrapper(EntityBuilder.ENTITY_VIEW_TYPE), + out var typeSafeDictionary)) + { + var dictionary = (TypeSafeDictionary) typeSafeDictionary; + + if (dictionary.ContainsKey(_ID.entityID)) + return true; + } + + return false; + } + + public static EntityStructInitializer CreateEmptyInitializer() + { + return new EntityStructInitializer(new EGID(), new FasterDictionary, ITypeSafeDictionary>()); + } + + readonly EGID _ID; + readonly FasterDictionary, ITypeSafeDictionary> _group; + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/EntityStructInitializer.cs.meta b/Svelto.ECS/Svelto.ECS/EntityStructInitializer.cs.meta new file mode 100644 index 0000000..0dc1016 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EntityStructInitializer.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 5cb5eea9477898947b16db259b700950 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/EntitySubmissionScheduler.cs b/Svelto.ECS/Svelto.ECS/EntitySubmissionScheduler.cs new file mode 100644 index 0000000..e6d0ffc --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EntitySubmissionScheduler.cs @@ -0,0 +1,9 @@ +using System; + +namespace Svelto.ECS.Schedulers +{ + public interface IEntitySubmissionScheduler: IDisposable + { + EnginesRoot.EntitiesSubmitter onTick { set; } + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/EntitySubmissionScheduler.cs.meta b/Svelto.ECS/Svelto.ECS/EntitySubmissionScheduler.cs.meta new file mode 100644 index 0000000..e46a121 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EntitySubmissionScheduler.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 55fb2dc75e765c9478ff524a893e54a5 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/EntitySubmitOperation.cs b/Svelto.ECS/Svelto.ECS/EntitySubmitOperation.cs new file mode 100644 index 0000000..57299be --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EntitySubmitOperation.cs @@ -0,0 +1,53 @@ +using System; +using System.Diagnostics; + +namespace Svelto.ECS +{ +#pragma warning disable 660,661 + struct EntitySubmitOperation +#pragma warning restore 660,661 + : IEquatable + { + public readonly EntitySubmitOperationType type; + public readonly IEntityBuilder[] builders; + public readonly EGID fromID; + public readonly EGID toID; +#if DEBUG && !PROFILER + public StackFrame trace; +#endif + + public EntitySubmitOperation(EntitySubmitOperationType operation, EGID from, EGID to, + IEntityBuilder[] builders = null) + { + type = operation; + this.builders = builders; + fromID = from; + toID = to; +#if DEBUG && !PROFILER + trace = default; +#endif + } + + public static bool operator ==(EntitySubmitOperation obj1, EntitySubmitOperation obj2) + { + return obj1.Equals(obj2); + } + + public static bool operator !=(EntitySubmitOperation obj1, EntitySubmitOperation obj2) + { + return obj1.Equals(obj2) == false; + } + + public bool Equals(EntitySubmitOperation other) + { + return type == other.type && fromID == other.fromID && toID == other.toID; + } + } + + enum EntitySubmitOperationType + { + Swap, + Remove, + RemoveGroup + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/EntitySubmitOperation.cs.meta b/Svelto.ECS/Svelto.ECS/EntitySubmitOperation.cs.meta new file mode 100644 index 0000000..cca52c4 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EntitySubmitOperation.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 10e7122095a379642afacb59dda231ed +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/EntityViewUtility.cs b/Svelto.ECS/Svelto.ECS/EntityViewUtility.cs new file mode 100644 index 0000000..8e4be9b --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EntityViewUtility.cs @@ -0,0 +1,125 @@ +using System; +using System.Collections.Generic; +using Svelto.DataStructures; +using Svelto.ECS.Internal; +using Svelto.Utilities; + +namespace Svelto.ECS +{ +#if DEBUG && !PROFILER + struct ECSTuple + { + public readonly T1 implementorType; + public T2 numberOfImplementations; + + public ECSTuple(T1 implementor, T2 v) + { + implementorType = implementor; + numberOfImplementations = v; + } + } +#endif + + static class EntityViewUtility + { + + public static void FillEntityView(this IEntityBuilder entityBuilder + , ref T entityView + , FasterList>> + entityViewBlazingFastReflection + , IEnumerable implementors, +#if DEBUG && !PROFILER + Dictionary> implementorsByType +#else + Dictionary implementorsByType +#endif + , Dictionary cachedTypes + ) + { + //efficient way to collect the fields of every EntityViewType + var setters = + FasterList>>.NoVirt.ToArrayFast(entityViewBlazingFastReflection, out var count); + + foreach (var implementor in implementors) + { + if (implementor != null) + { + var type = implementor.GetType(); + + if (cachedTypes.TryGetValue(type, out var interfaces) == false) + interfaces = cachedTypes[type] = type.GetInterfacesEx(); + + for (var iindex = 0; iindex < interfaces.Length; iindex++) + { + var componentType = interfaces[iindex]; +#if DEBUG && !PROFILER + if (implementorsByType.TryGetValue(componentType, out var implementorData)) + { + implementorData.numberOfImplementations++; + implementorsByType[componentType] = implementorData; + } + else + implementorsByType[componentType] = new ECSTuple(implementor, 1); +#else + implementorsByType[componentType] = implementor; +#endif + } + } +#if DEBUG && !PROFILER + else + { + Console.Log(NULL_IMPLEMENTOR_ERROR.FastConcat(" entityView ", + entityBuilder.GetEntityType().ToString())); + } +#endif + } + + for (var i = 0; i < count; i++) + { + var fieldSetter = setters[i]; + var fieldType = fieldSetter.Key; + +#if DEBUG && !PROFILER + ECSTuple component; +#else + object component; +#endif + + if (implementorsByType.TryGetValue(fieldType, out component) == false) + { + var e = new ECSException(NOT_FOUND_EXCEPTION + " Component Type: " + fieldType.Name + + " - EntityView: " + entityBuilder.GetEntityType().Name); + + throw e; + } +#if DEBUG && !PROFILER + if (component.numberOfImplementations > 1) + throw new ECSException(DUPLICATE_IMPLEMENTOR_ERROR.FastConcat( + "Component Type: ", fieldType.Name, + " implementor: ", + component.implementorType + .ToString()) + + " - EntityView: " + + entityBuilder.GetEntityType().Name); +#endif +#if DEBUG && !PROFILER + fieldSetter.Value(ref entityView, component.implementorType); +#else + fieldSetter.Value(ref entityView, component); +#endif + } + + implementorsByType.Clear(); + } + + const string DUPLICATE_IMPLEMENTOR_ERROR = + "Svelto.ECS the same component is implemented with more than one implementor. This is " + + "considered an error and MUST be fixed. "; + + const string NULL_IMPLEMENTOR_ERROR = + "Svelto.ECS Null implementor, please be careful about the implementors passed to avoid " + + "performance loss "; + + const string NOT_FOUND_EXCEPTION = "Svelto.ECS Implementor not found for an EntityView. "; + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/EntityViewUtility.cs.meta b/Svelto.ECS/Svelto.ECS/EntityViewUtility.cs.meta new file mode 100644 index 0000000..bbc02bc --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/EntityViewUtility.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: d94149e37622cb44bad46dccfc619115 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/ExclusiveGroup.cs b/Svelto.ECS/Svelto.ECS/ExclusiveGroup.cs new file mode 100644 index 0000000..959f7cc --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/ExclusiveGroup.cs @@ -0,0 +1,265 @@ +using System; +using System.Collections.Generic; + +#pragma warning disable 660,661 + +namespace Svelto.ECS +{ + /// + /// Exclusive Groups guarantee that the GroupID is unique. + /// + /// The best way to use it is like: + /// + /// public static class MyExclusiveGroups //(can be as many as you want) + /// { + /// public static ExclusiveGroup MyExclusiveGroup1 = new ExclusiveGroup(); + /// + /// public static ExclusiveGroup[] GroupOfGroups = { MyExclusiveGroup1, ...}; //for each on this! + /// } + /// + /// + + ///use this like: + /// public class TriggersGroup : ExclusiveGroup {} + public abstract class NamedExclusiveGroup:ExclusiveGroup + { + public static ExclusiveGroup Group = new ExclusiveGroup(); + public static string name = typeof(T).FullName; + + public NamedExclusiveGroup() { } + + public NamedExclusiveGroup(string recognizeAs) : base(recognizeAs) + {} + + public NamedExclusiveGroup(ushort range) : base(range) + {} + } + + public class ExclusiveGroup + { + public ExclusiveGroup() + { + _group = ExclusiveGroupStruct.Generate(); + } + + public ExclusiveGroup(string recognizeAs) + { + _group = ExclusiveGroupStruct.Generate(); + + _serialisedGroups.Add(recognizeAs, _group); + } + + public ExclusiveGroup(ushort range) + { + _group = new ExclusiveGroupStruct(range); +#if DEBUG + _range = range; +#endif + } + + public static implicit operator ExclusiveGroupStruct(ExclusiveGroup group) + { + return group._group; + } + + public static explicit operator uint(ExclusiveGroup group) + { + return group._group; + } + + public static ExclusiveGroupStruct operator+(ExclusiveGroup a, uint b) + { +#if DEBUG + if (a._range == 0) + throw new ECSException("adding values to a not ranged ExclusiveGroup"); + if (b >= a._range) + throw new ECSException("Using out of range group"); +#endif + return a._group + b; + } + + readonly ExclusiveGroupStruct _group; + + //I use this as parameter because it must not be possible to pass null Exclusive Groups. + public struct ExclusiveGroupStruct : IEquatable, IComparable, + IEqualityComparer + { + public static bool operator ==(ExclusiveGroupStruct c1, ExclusiveGroupStruct c2) + { + return c1.Equals(c2); + } + + public static bool operator !=(ExclusiveGroupStruct c1, ExclusiveGroupStruct c2) + { + return c1.Equals(c2) == false; + } + + public bool Equals(ExclusiveGroupStruct other) + { + return other._id == _id; + } + + public int CompareTo(ExclusiveGroupStruct other) + { + return other._id.CompareTo(_id); + } + + public bool Equals(ExclusiveGroupStruct x, ExclusiveGroupStruct y) + { + return x._id == y._id; + } + + public int GetHashCode(ExclusiveGroupStruct obj) + { + return _id.GetHashCode(); + } + + internal static ExclusiveGroupStruct Generate() + { + ExclusiveGroupStruct groupStruct; + + groupStruct._id = _globalId; + DBC.ECS.Check.Require(_globalId + 1 < ushort.MaxValue, "too many exclusive groups created"); + _globalId++; + + return groupStruct; + } + + /// + /// Use this constructor to reserve N groups + /// + internal ExclusiveGroupStruct(ushort range) + { + _id = _globalId; + DBC.ECS.Check.Require(_globalId + range < ushort.MaxValue, "too many exclusive groups created"); + _globalId += range; + } + + internal ExclusiveGroupStruct(uint groupID) + { + _id = groupID; + } + + public ExclusiveGroupStruct(byte[] data, uint pos) + { + _id = (uint)( + data[pos++] + | data[pos++] << 8 + | data[pos++] << 16 + | data[pos++] << 24 + ); + + DBC.ECS.Check.Ensure(_id < _globalId, "Invalid group ID deserialiased"); + } + + public static implicit operator uint(ExclusiveGroupStruct groupStruct) + { + return groupStruct._id; + } + + public static ExclusiveGroupStruct operator+(ExclusiveGroupStruct a, uint b) + { + var group = new ExclusiveGroupStruct(); + + group._id = a._id + b; + + return group; + } + + uint _id; + static uint _globalId; + } + + public static ExclusiveGroupStruct Search(string holderGroupName) + { + if (_serialisedGroups.ContainsKey(holderGroupName) == false) + throw new Exception("Named Group Not Found ".FastConcat(holderGroupName)); + + return _serialisedGroups[holderGroupName]; + } + + static readonly Dictionary _serialisedGroups = new Dictionary(); +#if DEBUG + readonly ushort _range; +#endif + } +} + +#if future + public static void ConstructStaticGroups() + { + Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies(); + + // Assemblies or types aren't guaranteed to be returned in the same order, + // and I couldn't find proof that `GetTypes()` returns them in fixed order either, + // even for builds made with the exact same source code. + // So will sort reflection results by name before constructing groups. + var groupFields = new List>(); + + foreach (Assembly assembly in assemblies) + { + Type[] types = GetTypesSafe(assembly); + + foreach (Type type in types) + { + if (type == null || !type.IsClass) + { + continue; + } + + // Groups defined as static members in static classes + if (type.IsSealed && type.IsAbstract) + { + FieldInfo[] fields = type.GetFields(); + foreach(var field in fields) + { + if (field.IsStatic && typeof(ExclusiveGroup).IsAssignableFrom(field.FieldType)) + { + groupFields.Add(new KeyValuePair($"{type.FullName}.{field.Name}", field)); + } + } + } + // Groups defined as classes + else if (type.BaseType != null + && type.BaseType.IsGenericType + && type.BaseType.GetGenericTypeDefinition() == typeof(ExclusiveGroup<>)) + { + FieldInfo field = type.GetField("Group", + BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy); + + groupFields.Add(new KeyValuePair(type.FullName, field)); + } + } + } + + groupFields.Sort((a, b) => string.CompareOrdinal(a.Key, b.Key)); + + for (int i = 0; i < groupFields.Count; ++i) + { + groupFields[i].Value.GetValue(null); +#if DEBUG + var group = (ExclusiveGroup) groupFields[i].Value.GetValue(null); + groupNames[(uint) group] = groupFields[i].Key; +#endif + } + } + + static Type[] GetTypesSafe(Assembly assembly) + { + try + { + Type[] types = assembly.GetTypes(); + + return types; + } + catch (ReflectionTypeLoadException e) + { + return e.Types; + } + } + +#if DEBUG + static string[] groupNames = new string[ushort.MaxValue]; +#endif +#endif \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/ExclusiveGroup.cs.meta b/Svelto.ECS/Svelto.ECS/ExclusiveGroup.cs.meta new file mode 100644 index 0000000..dee1153 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/ExclusiveGroup.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 8e5781b2e98b00946971f8e44b2f30be +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/ExecuteOnEntitiesDB.cs b/Svelto.ECS/Svelto.ECS/ExecuteOnEntitiesDB.cs new file mode 100644 index 0000000..375dfb4 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/ExecuteOnEntitiesDB.cs @@ -0,0 +1,61 @@ +using System; +using Svelto.DataStructures; + +namespace Svelto.ECS.Internal +{ + partial class EntitiesDB + { + public void ExecuteOnAllEntities(Action action) + where T : struct, IEntityStruct + { + var type = typeof(T); + + if (_groupsPerEntity.TryGetValue(new RefWrapper(type), out var dictionary)) + { + foreach (var pair in dictionary) + { + var entities = (pair.Value as TypeSafeDictionary).GetValuesArray(out var innerCount); + + if (innerCount > 0) + action(entities, new ExclusiveGroup.ExclusiveGroupStruct(pair.Key), innerCount, this); + } + } + } + + public void ExecuteOnAllEntities + (W value, Action action) + where T : struct, IEntityStruct + { + var type = typeof(T); + + if (_groupsPerEntity.TryGetValue(new RefWrapper(type), out var dic)) + { + foreach (var pair in dic) + { + var entities = (pair.Value as TypeSafeDictionary).GetValuesArray(out var innerCount); + + if (innerCount > 0) + action(entities, new ExclusiveGroup.ExclusiveGroupStruct(pair.Key), innerCount, this, value); + } + } + } + + public void ExecuteOnAllEntities + (ref W value, ExecuteOnAllEntitiesAction action) + where T : struct, IEntityStruct + { + var type = typeof(T); + + if (_groupsPerEntity.TryGetValue(new RefWrapper(type), out var dic)) + { + foreach (var pair in dic) + { + var entities = (pair.Value as TypeSafeDictionary).GetValuesArray(out var innerCount); + + if (innerCount > 0) + action(entities, new ExclusiveGroup.ExclusiveGroupStruct(pair.Key), innerCount, this, ref value); + } + } + } + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/ExecuteOnEntitiesDB.cs.meta b/Svelto.ECS/Svelto.ECS/ExecuteOnEntitiesDB.cs.meta new file mode 100644 index 0000000..725529e --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/ExecuteOnEntitiesDB.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 41fabce3b90aa014bb62d54ab7d21ae1 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/ExtendibleEntityDescriptor.cs b/Svelto.ECS/Svelto.ECS/ExtendibleEntityDescriptor.cs new file mode 100644 index 0000000..3b420fd --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/ExtendibleEntityDescriptor.cs @@ -0,0 +1,48 @@ +using System; +using Svelto.ECS.Serialization; + +namespace Svelto.ECS +{ + /// + /// Inherit from an ExtendibleEntityDescriptor to extend a base entity descriptor that can be used + /// to swap and remove specialized entities from abstract engines + /// + /// + public class ExtendibleEntityDescriptor : IEntityDescriptor where TType : IEntityDescriptor, new() + { + static ExtendibleEntityDescriptor() + { + if (typeof(ISerializableEntityDescriptor).IsAssignableFrom(typeof(TType))) + throw new Exception( + $"SerializableEntityDescriptors cannot be used as base entity descriptor: {typeof(TType)}"); + } + + public ExtendibleEntityDescriptor(IEntityBuilder[] extraEntities) + { + _dynamicDescriptor = new DynamicEntityDescriptor(extraEntities); + } + + public ExtendibleEntityDescriptor() + { + _dynamicDescriptor = new DynamicEntityDescriptor(true); + } + + public ExtendibleEntityDescriptor ExtendWith() where T : IEntityDescriptor, new() + { + _dynamicDescriptor.ExtendWith(); + + return this; + } + + public ExtendibleEntityDescriptor ExtendWith(IEntityBuilder[] extraEntities) + { + _dynamicDescriptor.ExtendWith(extraEntities); + + return this; + } + + public IEntityBuilder[] entitiesToBuild => _dynamicDescriptor.entitiesToBuild; + + DynamicEntityDescriptor _dynamicDescriptor; + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/ExtendibleEntityDescriptor.cs.meta b/Svelto.ECS/Svelto.ECS/ExtendibleEntityDescriptor.cs.meta new file mode 100644 index 0000000..04efb88 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/ExtendibleEntityDescriptor.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 87e1dec70e121e8499d5f7f2ac225394 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/Extensions.meta b/Svelto.ECS/Svelto.ECS/Extensions.meta new file mode 100644 index 0000000..4edb8a5 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Extensions.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: db3beea83bcdd5e43b03e4014f7854f3 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/Extensions/Unity.meta b/Svelto.ECS/Svelto.ECS/Extensions/Unity.meta new file mode 100644 index 0000000..99963cc --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Extensions/Unity.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: f938e83cfb62e2e47880cdca7f0db7d2 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/Extensions/Unity/GenericEntityDescriptorHolder.cs b/Svelto.ECS/Svelto.ECS/Extensions/Unity/GenericEntityDescriptorHolder.cs new file mode 100644 index 0000000..28b6898 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Extensions/Unity/GenericEntityDescriptorHolder.cs @@ -0,0 +1,24 @@ +#if UNITY_5 || UNITY_5_3_OR_NEWER +using UnityEngine; + +namespace Svelto.ECS.Unity +{ + public abstract class GenericEntityDescriptorHolder: + MonoBehaviour , IEntityDescriptorHolder + where T: IEntityDescriptor, new() + { + public IEntityDescriptor GetDescriptor() + { + return EntityDescriptorTemplate.descriptor; + } + + public string groupName => _groupName; + public ushort id => _id; + +#pragma warning disable 649 + [SerializeField] string _groupName; + [SerializeField] ushort _id; +#pragma warning restore 649 + } +} +#endif \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/Extensions/Unity/GenericEntityDescriptorHolder.cs.meta b/Svelto.ECS/Svelto.ECS/Extensions/Unity/GenericEntityDescriptorHolder.cs.meta new file mode 100644 index 0000000..360a7b1 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Extensions/Unity/GenericEntityDescriptorHolder.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 868c4160bf062904793f49af221b1178 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/Extensions/Unity/SveltoGUIHelper.cs b/Svelto.ECS/Svelto.ECS/Extensions/Unity/SveltoGUIHelper.cs new file mode 100644 index 0000000..160615d --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Extensions/Unity/SveltoGUIHelper.cs @@ -0,0 +1,99 @@ +#if UNITY_5 || UNITY_5_3_OR_NEWER +using UnityEngine; + +namespace Svelto.ECS.Unity +{ + public static class SveltoGUIHelper + { + public static T CreateFromPrefab(ref uint startIndex, Transform contextHolder, IEntityFactory factory, + ExclusiveGroup group, string groupNamePostfix = null) where T : MonoBehaviour, IEntityDescriptorHolder + { + var holder = Create(new EGID(startIndex++, group), contextHolder, factory); + var childs = contextHolder.GetComponentsInChildren(true); + + foreach (var child in childs) + { + if (child.GetType() != typeof(T)) + { + var monoBehaviour = child as MonoBehaviour; + var childImplementors = monoBehaviour.GetComponents(); + startIndex = InternalBuildAll( + startIndex, + child, + factory, + group, + childImplementors, + groupNamePostfix); + } + } + + return holder; + } + + public static T Create(EGID ID, Transform contextHolder, IEntityFactory factory) + where T : MonoBehaviour, IEntityDescriptorHolder + { + var holder = contextHolder.GetComponentInChildren(true); + DBC.ECS.Check.Assert(holder != null, $"`{nameof(holder)}` is null! No component of type " + + $"`{typeof(T)}` was found between its children."); + + var implementors = holder.GetComponents(); + + factory.BuildEntity(ID, holder.GetDescriptor(), implementors); + + return holder; + } + + public static EntityStructInitializer CreateWithEntity(EGID ID, Transform contextHolder, + IEntityFactory factory, out T holder) + where T : MonoBehaviour, IEntityDescriptorHolder + { + holder = contextHolder.GetComponentInChildren(true); + var implementors = holder.GetComponents(); + + return factory.BuildEntity(ID, holder.GetDescriptor(), implementors); + } + + public static uint CreateAll(uint startIndex, ExclusiveGroup group, + Transform contextHolder, IEntityFactory factory, string groupNamePostfix = null) where T : MonoBehaviour, IEntityDescriptorHolder + { + var holders = contextHolder.GetComponentsInChildren(true); + + foreach (var holder in holders) + { + var implementors = holder.GetComponents(); + + startIndex = InternalBuildAll(startIndex, holder, factory, group, implementors, groupNamePostfix); + } + + return startIndex; + } + + static uint InternalBuildAll(uint startIndex, IEntityDescriptorHolder descriptorHolder, + IEntityFactory factory, ExclusiveGroup group, IImplementor[] implementors, string groupNamePostfix) + { + ExclusiveGroup.ExclusiveGroupStruct realGroup = group; + + if (string.IsNullOrEmpty(descriptorHolder.groupName) == false) + { + realGroup = ExclusiveGroup.Search(!string.IsNullOrEmpty(groupNamePostfix) + ? $"{descriptorHolder.groupName}{groupNamePostfix}" + : descriptorHolder.groupName); + } + + EGID egid; + var holderId = descriptorHolder.id; + if (holderId == 0) + egid = new EGID(startIndex++, realGroup); + else + egid = new EGID(holderId, realGroup); + + var init = factory.BuildEntity(egid, descriptorHolder.GetDescriptor(), implementors); + + init.Init(new EntityHierarchyStruct(group)); + + return startIndex; + } + } +} +#endif diff --git a/Svelto.ECS/Svelto.ECS/Extensions/Unity/SveltoGUIHelper.cs.meta b/Svelto.ECS/Svelto.ECS/Extensions/Unity/SveltoGUIHelper.cs.meta new file mode 100644 index 0000000..5610133 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Extensions/Unity/SveltoGUIHelper.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 8dcc6bf8a648e51428a0a4c300dc0457 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/Extensions/Unity/UnityEntitySubmissionScheduler.cs b/Svelto.ECS/Svelto.ECS/Extensions/Unity/UnityEntitySubmissionScheduler.cs new file mode 100644 index 0000000..4f4e120 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Extensions/Unity/UnityEntitySubmissionScheduler.cs @@ -0,0 +1,66 @@ +#if UNITY_5 || UNITY_5_3_OR_NEWER +using Object = UnityEngine.Object; +using System; +using System.Collections; +using UnityEngine; + +namespace Svelto.ECS.Schedulers.Unity +{ + //The EntitySubmissionScheduler has been introduced to make the entity views submission logic platform independent + //You can customize the scheduler if you wish + public class UnityEntitySubmissionScheduler : IEntitySubmissionScheduler + { + class Scheduler : MonoBehaviour + { + public Scheduler() + { + _coroutine = Coroutine(); + } + + void Update() + { + _coroutine.MoveNext(); + } + + IEnumerator Coroutine() + { + while (true) + { + yield return _wait; + + onTick.Invoke(); + } + } + + readonly WaitForEndOfFrame _wait = new WaitForEndOfFrame(); + readonly IEnumerator _coroutine; + + public EnginesRoot.EntitiesSubmitter onTick; + } + + public UnityEntitySubmissionScheduler(string name = "ECSScheduler") { _name = name; } + + public void Dispose() + { + Object.Destroy(_scheduler.gameObject); + } + + public EnginesRoot.EntitiesSubmitter onTick + { + set + { + if (_scheduler == null) + { + _scheduler = new GameObject(_name).AddComponent(); + GameObject.DontDestroyOnLoad(_scheduler.gameObject); + } + + _scheduler.onTick = value; + } + } + + Scheduler _scheduler; + readonly string _name; + } +} +#endif \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/Extensions/Unity/UnityEntitySubmissionScheduler.cs.meta b/Svelto.ECS/Svelto.ECS/Extensions/Unity/UnityEntitySubmissionScheduler.cs.meta new file mode 100644 index 0000000..3874d2b --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Extensions/Unity/UnityEntitySubmissionScheduler.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 8f3708168c40939408e5d0f10a9e0fb5 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/GenericEntityDescriptor.cs b/Svelto.ECS/Svelto.ECS/GenericEntityDescriptor.cs new file mode 100644 index 0000000..a8eb7a3 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/GenericEntityDescriptor.cs @@ -0,0 +1,104 @@ +namespace Svelto.ECS +{ + public abstract class GenericEntityDescriptor : IEntityDescriptor where T : struct, IEntityStruct + { + static readonly IEntityBuilder[] _entityBuilders; + static GenericEntityDescriptor() { _entityBuilders = new IEntityBuilder[] {new EntityBuilder()}; } + + public IEntityBuilder[] entitiesToBuild => _entityBuilders; + } + + public abstract class GenericEntityDescriptor : IEntityDescriptor + where T : struct, IEntityStruct where U : struct, IEntityStruct + { + static readonly IEntityBuilder[] _entityBuilders; + + static GenericEntityDescriptor() + { + _entityBuilders = new IEntityBuilder[] {new EntityBuilder(), new EntityBuilder()}; + } + + public IEntityBuilder[] entitiesToBuild => _entityBuilders; + } + + public abstract class GenericEntityDescriptor : IEntityDescriptor + where T : struct, IEntityStruct where U : struct, IEntityStruct where V : struct, IEntityStruct + { + static readonly IEntityBuilder[] _entityBuilders; + + static GenericEntityDescriptor() + { + _entityBuilders = new IEntityBuilder[] + { + new EntityBuilder(), + new EntityBuilder(), + new EntityBuilder() + }; + } + + public IEntityBuilder[] entitiesToBuild => _entityBuilders; + } + + public abstract class GenericEntityDescriptor : IEntityDescriptor + where T : struct, IEntityStruct where U : struct, IEntityStruct where V : struct, IEntityStruct + where W : struct, IEntityStruct + { + static readonly IEntityBuilder[] _entityBuilders; + + static GenericEntityDescriptor() + { + _entityBuilders = new IEntityBuilder[] + { + new EntityBuilder(), + new EntityBuilder(), + new EntityBuilder(), + new EntityBuilder() + }; + } + + public IEntityBuilder[] entitiesToBuild => _entityBuilders; + } + + public abstract class GenericEntityDescriptor : IEntityDescriptor + where T : struct, IEntityStruct where U : struct, IEntityStruct where V : struct, IEntityStruct + where W : struct, IEntityStruct where X : struct, IEntityStruct + { + static readonly IEntityBuilder[] _entityBuilders; + + static GenericEntityDescriptor() + { + _entityBuilders = new IEntityBuilder[] + { + new EntityBuilder(), + new EntityBuilder(), + new EntityBuilder(), + new EntityBuilder(), + new EntityBuilder() + }; + } + + public IEntityBuilder[] entitiesToBuild => _entityBuilders; + } + + public abstract class GenericEntityDescriptor : IEntityDescriptor + where T : struct, IEntityStruct where U : struct, IEntityStruct where V : struct, IEntityStruct + where W : struct, IEntityStruct where X : struct, IEntityStruct where Y : struct, IEntityStruct + { + static readonly IEntityBuilder[] _entityBuilders; + + static GenericEntityDescriptor() + { + _entityBuilders = new IEntityBuilder[] + { + new EntityBuilder(), + new EntityBuilder(), + new EntityBuilder(), + new EntityBuilder(), + new EntityBuilder(), + new EntityBuilder() + }; + } + + public IEntityBuilder[] entitiesToBuild => _entityBuilders; + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/GenericEntityDescriptor.cs.meta b/Svelto.ECS/Svelto.ECS/GenericEntityDescriptor.cs.meta new file mode 100644 index 0000000..a362a94 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/GenericEntityDescriptor.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 73d7a47d7c041014c8e4cdc0c90a0671 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/GenericentityStreamConsumerFactory.cs b/Svelto.ECS/Svelto.ECS/GenericentityStreamConsumerFactory.cs new file mode 100644 index 0000000..4fc0269 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/GenericentityStreamConsumerFactory.cs @@ -0,0 +1,33 @@ +using Svelto.DataStructures; + +namespace Svelto.ECS +{ + class GenericEntityStreamConsumerFactory : IEntityStreamConsumerFactory + { + public GenericEntityStreamConsumerFactory(EnginesRoot weakReference) + { + _enginesRoot = new WeakReference(weakReference); + } + + public Consumer GenerateConsumer(string name, uint capacity) where T : unmanaged, IEntityStruct + { + return _enginesRoot.Target.GenerateConsumer(name, capacity); + } + + public Consumer GenerateConsumer(ExclusiveGroup group, string name, uint capacity) where T : unmanaged, IEntityStruct + { + return _enginesRoot.Target.GenerateConsumer(group, name, capacity); + } + +//enginesRoot is a weakreference because GenericEntityStreamConsumerFactory can be injected inside +//engines of other enginesRoot + readonly WeakReference _enginesRoot; + } + + public interface IEntityStreamConsumerFactory + { + Consumer GenerateConsumer(string name, uint capacity) where T : unmanaged, IEntityStruct; + Consumer GenerateConsumer(ExclusiveGroup group, string name, uint capacity) + where T : unmanaged, IEntityStruct; + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/GenericentityStreamConsumerFactory.cs.meta b/Svelto.ECS/Svelto.ECS/GenericentityStreamConsumerFactory.cs.meta new file mode 100644 index 0000000..7ccc41e --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/GenericentityStreamConsumerFactory.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 02c9be62e6bdb9a49aa9596249bb16b1 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/Hybrid.meta b/Svelto.ECS/Svelto.ECS/Hybrid.meta new file mode 100644 index 0000000..4f6bc62 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Hybrid.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: e4a4259b54484b04ace0e48754701671 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/Hybrid/IEntityViewStruct.cs b/Svelto.ECS/Svelto.ECS/Hybrid/IEntityViewStruct.cs new file mode 100644 index 0000000..b351a50 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Hybrid/IEntityViewStruct.cs @@ -0,0 +1,6 @@ +namespace Svelto.ECS.Hybrid +{ + public interface IEntityViewStruct:IEntityStruct, INeedEGID + {} +} + diff --git a/Svelto.ECS/Svelto.ECS/Hybrid/IEntityViewStruct.cs.meta b/Svelto.ECS/Svelto.ECS/Hybrid/IEntityViewStruct.cs.meta new file mode 100644 index 0000000..9417fa2 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Hybrid/IEntityViewStruct.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: ce31f0fb3a7e1554bb6f3a31128f2bc4 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/Hybrid/IImplementor.cs b/Svelto.ECS/Svelto.ECS/Hybrid/IImplementor.cs new file mode 100644 index 0000000..6d58780 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Hybrid/IImplementor.cs @@ -0,0 +1,6 @@ +namespace Svelto.ECS.Unity +{ + public interface IImplementor + { + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/Hybrid/IImplementor.cs.meta b/Svelto.ECS/Svelto.ECS/Hybrid/IImplementor.cs.meta new file mode 100644 index 0000000..3776d76 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Hybrid/IImplementor.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 6f0dfd0f03d543e469f9c04c79e343be +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/IEngine.cs b/Svelto.ECS/Svelto.ECS/IEngine.cs new file mode 100644 index 0000000..b671fd9 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/IEngine.cs @@ -0,0 +1,17 @@ +namespace Svelto.ECS.Internal +{ + public interface IReactEngine: IEngine + {} + + public interface IReactOnAddAndRemove : IReactEngine + {} + + public interface IReactOnSwap : IReactEngine + {} +} + +namespace Svelto.ECS +{ + public interface IEngine + {} +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/IEngine.cs.meta b/Svelto.ECS/Svelto.ECS/IEngine.cs.meta new file mode 100644 index 0000000..3332be8 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/IEngine.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: fd83d8a0efbd6f54c89b86f87e1fe8f7 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/IEntitiesDB.cs b/Svelto.ECS/Svelto.ECS/IEntitiesDB.cs new file mode 100644 index 0000000..b2734a2 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/IEntitiesDB.cs @@ -0,0 +1,193 @@ +using System; + +namespace Svelto.ECS +{ + public delegate void ExecuteOnAllEntitiesAction(T[] entities, ExclusiveGroup.ExclusiveGroupStruct group, + uint count, IEntitiesDB db, ref W value); + + public interface IEntitiesDB + { + /////////////////////////////////////////////////// + // Query entities + // ECS systems are meant to work on a set of Entities. These methods allow to iterate over entity + // structs inside a given group or an array of groups + /////////////////////////////////////////////////// + + /// + /// Fast and raw return of entities buffer. + /// + /// + /// + /// + /// + T[] QueryEntities(ExclusiveGroup.ExclusiveGroupStruct groupStruct, out uint count) + where T : struct, IEntityStruct; + (T1[], T2[]) QueryEntities(ExclusiveGroup.ExclusiveGroupStruct groupStruct, out uint count) + where T1 : struct, IEntityStruct where T2 : struct, IEntityStruct; + (T1[], T2[], T3[]) QueryEntities(ExclusiveGroup.ExclusiveGroupStruct groupStruct, out uint count) + where T1 : struct, IEntityStruct where T2 : struct, IEntityStruct where T3 : struct, IEntityStruct; + + /// + /// return entities that can be iterated through the EntityCollection iterator + /// + /// + /// + /// + EntityCollection QueryEntities(ExclusiveGroup.ExclusiveGroupStruct groupStruct) + where T : struct, IEntityStruct; + EntityCollection QueryEntities(ExclusiveGroup.ExclusiveGroupStruct groupStruct) + where T1 : struct, IEntityStruct where T2 : struct, IEntityStruct; + EntityCollection QueryEntities(ExclusiveGroup.ExclusiveGroupStruct groupStruct) + where T1 : struct, IEntityStruct + where T2 : struct, IEntityStruct + where T3 : struct, IEntityStruct; + + /// + /// return entities found in multiple groups, that can be iterated through the EntityCollection iterator + /// This method is useful to write abstracted engines + /// + /// + /// + EntityCollections QueryEntities(ExclusiveGroup[] groups) where T : struct, IEntityStruct; + EntityCollections QueryEntities(ExclusiveGroup[] groups) + where T1 : struct, IEntityStruct where T2 : struct, IEntityStruct; + + /////////////////////////////////////////////////// + // Query entities regardless the group + // these methods are necessary to create abstracted engines. Engines that can iterate over entities regardless + // the group + /////////////////////////////////////////////////// + + /// + /// Execute an action on ALL the entities regardless the group. This function doesn't guarantee cache + /// friendliness even if just EntityStructs are used. Safety checks are in place, + /// + /// + /// + void ExecuteOnAllEntities(Action action) + where T : struct, IEntityStruct; + + /// + /// same as above, but can pass some external data to avoid allocations + /// + /// + /// + /// + /// + void ExecuteOnAllEntities(ref W value, ExecuteOnAllEntitiesAction action) + where T : struct, IEntityStruct; + + void ExecuteOnAllEntities(W value, Action action) + where T : struct, IEntityStruct; + + /////////////////////////////////////////////////// + // Query single entities + // ECS systems are meant to work on a set of Entities. Working on a single entity is sometime necessary, hence + // the following methods + // However Because of the double hashing required to identify a specific entity, these function are slower than + // other query methods when used multiple times! + /////////////////////////////////////////////////// + + /// + /// QueryUniqueEntity is a contract method that explicitly declare the intention to have just on entity in a + /// specific group, usually used for GUI elements + /// + /// + /// + /// + ref T QueryUniqueEntity(ExclusiveGroup.ExclusiveGroupStruct group) where T : struct, IEntityStruct; + + /// + /// return a specific entity by reference. + /// + /// + /// + /// + ref T QueryEntity(EGID entityGid) where T : struct, IEntityStruct; + ref T QueryEntity(uint id, ExclusiveGroup.ExclusiveGroupStruct group) where T : struct, IEntityStruct; + + /// + /// + ///QueryEntitiesAndIndex is useful to optimize cases when multiple entity structs from the same entity must + /// be queried. This is the use case: + /// + ///ref var ghostPosition = ref entitiesDB.QueryEntitiesAndIndex + /// (MockupRenderingGroups.GhostCubeID, out var index)[index]; + ///ref var ghostScaling = ref entitiesDB.QueryEntities + /// (MockupRenderingGroups.GhostCubeID.groupID, out _)[index]; + ///ref var ghostRotation = ref entitiesDB.QueryEntities + /// (MockupRenderingGroups.GhostCubeID.groupID, out _)[index]; + ///ref var ghostResource = ref entitiesDB.QueryEntities + /// (MockupRenderingGroups.GhostCubeID.groupID, out _)[index]; + /// + /// + /// + /// + /// + /// + T[] QueryEntitiesAndIndex(EGID entityGid, out uint index) where T : struct, IEntityStruct; + T[] QueryEntitiesAndIndex(uint id, ExclusiveGroup.ExclusiveGroupStruct group, out uint index) + where T : struct, IEntityStruct; + + /// + /// Like QueryEntitiesAndIndex and only way to get an index only if exists + /// + /// + /// + /// + /// + bool TryQueryEntitiesAndIndex(EGID entityGid, out uint index, out T[] array) where T : struct, IEntityStruct; + bool TryQueryEntitiesAndIndex + (uint id, ExclusiveGroup.ExclusiveGroupStruct group, out uint index, out T[] array) + where T : struct, IEntityStruct; + + /// + /// this method returns a mapped version of the entity array so that is possible to work on multiple entities + /// inside the group through their EGID. This version skip a level of indirection so it's a bit faster than + /// using QueryEntity multiple times (with different EGIDs). + /// However mapping can be slow so it must be used for not performance critical paths + /// + /// + /// + EGIDMapper QueryMappedEntities(ExclusiveGroup.ExclusiveGroupStruct groupStructId) + where T : struct, IEntityStruct; + bool TryQueryMappedEntities(ExclusiveGroup.ExclusiveGroupStruct groupStructId, out EGIDMapper mapper) + where T : struct, IEntityStruct; + + /////////////////////////////////////////////////// + // Utility methods + /////////////////////////////////////////////////// + + /// + /// check if a specific entity exists + /// + /// + /// + /// + bool Exists(EGID egid) where T : struct, IEntityStruct; + bool Exists(uint id, ExclusiveGroup.ExclusiveGroupStruct group) where T : struct, IEntityStruct; + bool Exists(ExclusiveGroup.ExclusiveGroupStruct gid); + + /// + /// know if there is any entity struct in a specific group + /// + /// + /// + /// + bool HasAny(ExclusiveGroup.ExclusiveGroupStruct groupStruct) where T : struct, IEntityStruct; + + /// + /// Count the number of entity structs in a specific group + /// + /// + /// + /// + uint Count(ExclusiveGroup.ExclusiveGroupStruct groupStruct) where T : struct, IEntityStruct; + + /// + /// + /// + /// + void PublishEntityChange(EGID egid) where T : unmanaged, IEntityStruct; + } +} diff --git a/Svelto.ECS/Svelto.ECS/IEntitiesDB.cs.meta b/Svelto.ECS/Svelto.ECS/IEntitiesDB.cs.meta new file mode 100644 index 0000000..c5bb99d --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/IEntitiesDB.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 9f9156abddc99104b8be6878efa16914 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/IEntityBuilder.cs b/Svelto.ECS/Svelto.ECS/IEntityBuilder.cs new file mode 100644 index 0000000..da7b527 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/IEntityBuilder.cs @@ -0,0 +1,15 @@ +using System; +using System.Collections.Generic; +using Svelto.ECS.Internal; + +namespace Svelto.ECS +{ + public interface IEntityBuilder + { + void BuildEntityAndAddToList(ref ITypeSafeDictionary dictionary, EGID egid, + IEnumerable implementors); + ITypeSafeDictionary Preallocate(ref ITypeSafeDictionary dictionary, uint size); + + Type GetEntityType(); + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/IEntityBuilder.cs.meta b/Svelto.ECS/Svelto.ECS/IEntityBuilder.cs.meta new file mode 100644 index 0000000..572e1a6 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/IEntityBuilder.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: f1f8923f42d1c1041aeb11e888a377b2 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/IEntityDescriptorHolder.cs b/Svelto.ECS/Svelto.ECS/IEntityDescriptorHolder.cs new file mode 100644 index 0000000..bde2442 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/IEntityDescriptorHolder.cs @@ -0,0 +1,10 @@ +namespace Svelto.ECS +{ + public interface IEntityDescriptorHolder + { + IEntityDescriptor GetDescriptor(); + + string groupName { get; } + ushort id { get; } + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/IEntityDescriptorHolder.cs.meta b/Svelto.ECS/Svelto.ECS/IEntityDescriptorHolder.cs.meta new file mode 100644 index 0000000..12beffb --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/IEntityDescriptorHolder.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 6c0194785042ff948bc389185c9fb852 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/IEntityFactory.cs b/Svelto.ECS/Svelto.ECS/IEntityFactory.cs new file mode 100644 index 0000000..14b7e89 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/IEntityFactory.cs @@ -0,0 +1,66 @@ +using System.Collections.Generic; + +namespace Svelto.ECS +{ + /// + /// Entities are always built in group. Where the group is not specificed, a special standard group is used + /// ID can be reused within groups + /// an EnginesRoot reference cannot be held by anything else than the Composition Root + /// where it has been created. IEntityFactory and IEntityFunctions allow a weakreference + /// of the EnginesRoot to be passed around. + /// + /// ExclusiveGroups must be used in your game like: + /// static class GameExclusiveGroup + ///{ + /// public static readonly ExclusiveGroups PlayerEntitiesGroup = new ExclusiveGroups(); + ///} + /// + /// + public interface IEntityFactory + { + /// + /// where performance is critical, you may wish to pre allocate the space needed + /// to store the entities + /// + /// + /// + /// + void PreallocateEntitySpace(ExclusiveGroup.ExclusiveGroupStruct groupStructId, uint size) + where T : IEntityDescriptor, new(); + + /// + /// The EntityDescriptor doesn't need to be ever instantiated. It just describes the Entity + /// itself in terms of EntityViews to build. The Implementors are passed to fill the + /// references of the EntityViews components. Please read the articles on my blog + /// to understand better the terminologies + /// Using this function is like building a normal entity, but the entity views + /// are grouped by groupID to be more efficiently processed inside engines and + /// improve cache locality. Either class entityViews and struct entityViews can be + /// grouped. + /// + /// + /// + /// + /// + EntityStructInitializer BuildEntity(uint entityID, ExclusiveGroup.ExclusiveGroupStruct groupStructId, + IEnumerable implementors = null) + where T : IEntityDescriptor, new(); + + EntityStructInitializer BuildEntity(EGID egid, IEnumerable implementors = null) + where T:IEntityDescriptor, new(); + + /// + /// When the type of the entity is not known (this is a special case!) an EntityDescriptorInfo + /// can be built in place of the generic parameter T. + /// + /// + /// + /// + /// + EntityStructInitializer BuildEntity(uint entityID, ExclusiveGroup.ExclusiveGroupStruct groupStructId, + T descriptorEntity, IEnumerable implementors = null) where T : IEntityDescriptor; + + EntityStructInitializer BuildEntity(EGID egid, T entityDescriptor, IEnumerable implementors = null) + where T : IEntityDescriptor; + } +} diff --git a/Svelto.ECS/Svelto.ECS/IEntityFactory.cs.meta b/Svelto.ECS/Svelto.ECS/IEntityFactory.cs.meta new file mode 100644 index 0000000..f94a340 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/IEntityFactory.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: b2c2ae8b2df5bac4ea3bd57ef1dc7be9 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/IEntityFunctions.cs b/Svelto.ECS/Svelto.ECS/IEntityFunctions.cs new file mode 100644 index 0000000..9d04e0d --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/IEntityFunctions.cs @@ -0,0 +1,20 @@ +namespace Svelto.ECS +{ + public interface IEntityFunctions + { + //being entity ID globally not unique, the group must be specified when + //an entity is removed. Not specifying the group will attempt to remove + //the entity from the special standard group. + void RemoveEntity(uint entityID, ExclusiveGroup.ExclusiveGroupStruct groupID) where T : IEntityDescriptor, new(); + void RemoveEntity(EGID entityegid) where T : IEntityDescriptor, new(); + + void RemoveGroupAndEntities(ExclusiveGroup.ExclusiveGroupStruct groupID); + + void SwapEntityGroup(uint entityID, ExclusiveGroup.ExclusiveGroupStruct fromGroupID, ExclusiveGroup.ExclusiveGroupStruct toGroupID) where T : IEntityDescriptor, new(); + void SwapEntityGroup(EGID fromID, ExclusiveGroup.ExclusiveGroupStruct toGroupID) where T : IEntityDescriptor, new(); + void SwapEntityGroup(EGID fromID, ExclusiveGroup.ExclusiveGroupStruct toGroupID, ExclusiveGroup.ExclusiveGroupStruct mustBeFromGroup) where T : IEntityDescriptor, new(); + + void SwapEntityGroup(EGID fromID, EGID toId) where T : IEntityDescriptor, new(); + void SwapEntityGroup(EGID fromID, EGID toId, ExclusiveGroup.ExclusiveGroupStruct mustBeFromGroup) where T : IEntityDescriptor, new(); + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/IEntityFunctions.cs.meta b/Svelto.ECS/Svelto.ECS/IEntityFunctions.cs.meta new file mode 100644 index 0000000..754db41 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/IEntityFunctions.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: a673badeddb5afa419ca54acb4bc0ae2 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/IEntityStruct.cs b/Svelto.ECS/Svelto.ECS/IEntityStruct.cs new file mode 100644 index 0000000..379b4b4 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/IEntityStruct.cs @@ -0,0 +1,15 @@ +namespace Svelto.ECS +{ + ///EntityStruct MUST implement IEntityStruct + public interface IEntityStruct + { + } + + /// + /// use INeedEGID on an IEntityStruct only if you need the EGID + /// + public interface INeedEGID + { + EGID ID { get; set; } + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/IEntityStruct.cs.meta b/Svelto.ECS/Svelto.ECS/IEntityStruct.cs.meta new file mode 100644 index 0000000..b1fa529 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/IEntityStruct.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 370a9acd5edaac547b155682e2bf8292 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/IQueryingEntitiesEngine.cs b/Svelto.ECS/Svelto.ECS/IQueryingEntitiesEngine.cs new file mode 100644 index 0000000..57eae65 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/IQueryingEntitiesEngine.cs @@ -0,0 +1,9 @@ +namespace Svelto.ECS +{ + public interface IQueryingEntitiesEngine : IEngine + { + IEntitiesDB entitiesDB { set; } + + void Ready(); + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/IQueryingEntitiesEngine.cs.meta b/Svelto.ECS/Svelto.ECS/IQueryingEntitiesEngine.cs.meta new file mode 100644 index 0000000..5feb6f8 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/IQueryingEntitiesEngine.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 99887923abf06c24592862179da63c83 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/IReactOnAddAndRemove.cs b/Svelto.ECS/Svelto.ECS/IReactOnAddAndRemove.cs new file mode 100644 index 0000000..0e35eb7 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/IReactOnAddAndRemove.cs @@ -0,0 +1,10 @@ +using Svelto.ECS.Internal; + +namespace Svelto.ECS +{ + public interface IReactOnAddAndRemove : IReactOnAddAndRemove where T : IEntityStruct + { + void Add(ref T entityView, EGID egid); + void Remove(ref T entityView, EGID egid); + } + } \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/IReactOnAddAndRemove.cs.meta b/Svelto.ECS/Svelto.ECS/IReactOnAddAndRemove.cs.meta new file mode 100644 index 0000000..40be613 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/IReactOnAddAndRemove.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 222ccc049d9399c42aca73da8900d7d8 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/IReactOnSwap.cs b/Svelto.ECS/Svelto.ECS/IReactOnSwap.cs new file mode 100644 index 0000000..e9d0f0d --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/IReactOnSwap.cs @@ -0,0 +1,12 @@ +using Svelto.ECS.Internal; + +namespace Svelto.ECS +{ + public interface IReactOnSwap : IReactOnSwap where T : IEntityStruct + { + void MovedTo(ref T entityView, ExclusiveGroup.ExclusiveGroupStruct previousGroup, EGID egid); +#if SEEMS_UNNECESSARY + void MovedFrom(ref T entityView, EGID egid); +#endif + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/IReactOnSwap.cs.meta b/Svelto.ECS/Svelto.ECS/IReactOnSwap.cs.meta new file mode 100644 index 0000000..f855b13 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/IReactOnSwap.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 47e8a81e12d846c292e1378a4512e73e +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/LICENSE b/Svelto.ECS/Svelto.ECS/LICENSE new file mode 100644 index 0000000..4c02fa4 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/LICENSE @@ -0,0 +1,22 @@ +The MIT License (MIT) + +Copyright (c) 2015 Sebastiano Mandalà + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + diff --git a/Svelto.ECS/Svelto.ECS/LICENSE.meta b/Svelto.ECS/Svelto.ECS/LICENSE.meta new file mode 100644 index 0000000..e61287c --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/LICENSE.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: eca9f920522a40949a5685091581ba66 +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/README.md b/Svelto.ECS/Svelto.ECS/README.md new file mode 100644 index 0000000..ef18d33 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/README.md @@ -0,0 +1,50 @@ +Svelto Entity Component System for Unity +===================================== + +**Note: The alpha stage of Svelto 2.0 is almost completed, so if you are here to experiment with it, please use the current alpha branch** + +Real Entity-Component-System for c# and Unity (it can be adapted for other c# platforms too). Enables to write encapsulated, uncoupled, highly efficient, data oriented, cache friendly, multi-threaded, code without pain. + +you can find working examples to learn how to use the framework here: + +https://github.com/sebas77/Svelto-ECS-Example (unity) + +https://github.com/sebas77/Svelto.ECS.Vanilla.Example (.net core and standard) + +I advise to clone the example repositories separately from the framework one, both under the same Unity project Assets folder. + +relative article: + +http://www.sebaslab.com/svelto-ecs-2-0-almost-production-ready/ + +http://www.sebaslab.com/ecs-1-0/ + +If you want to know more about the theory and rationale behind this framework: + +http://www.sebaslab.com/ioc-container-for-unity3d-part-1/ + +http://www.sebaslab.com/ioc-container-for-unity3d-part-2/ + +http://www.sebaslab.com/the-truth-behind-inversion-of-control-part-i-dependency-injection/ + +http://www.sebaslab.com/the-truth-behind-inversion-of-control-part-ii-inversion-of-control/ + +http://www.sebaslab.com/the-truth-behind-inversion-of-control-part-iii-entity-component-systems/ + +http://www.sebaslab.com/the-truth-behind-inversion-of-control-part-iv-dependency-inversion-principle/ + +http://www.sebaslab.com/the-truth-behind-inversion-of-control-part-v-drifting-away-from-ioc-containers/ + +new article on optimizations: + +http://www.sebaslab.com/svelto-ecs-svelto-tasks-to-write-data-oriented-cache-friendly-multi-threaded-code-in-unity/ + +Note: if you ever build something with Svelto.ECS that you can share with the community, please do and let me know. Other coders need more examples. + +Copyright (c) Sebastiano Mandalà + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/Svelto.ECS/Svelto.ECS/README.md.meta b/Svelto.ECS/Svelto.ECS/README.md.meta new file mode 100644 index 0000000..1794456 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/README.md.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: 9fc4a7dcb8ca58c4d9cb782d3208ed82 +TextScriptImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/SUMMARY.md b/Svelto.ECS/Svelto.ECS/SUMMARY.md new file mode 100644 index 0000000..e6d872c --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/SUMMARY.md @@ -0,0 +1,4 @@ +# Table of contents + +* [Svelto Entity Component System 2.8](README.md) + diff --git a/Svelto.ECS/Svelto.ECS/Sequencer.cs b/Svelto.ECS/Svelto.ECS/Sequencer.cs new file mode 100644 index 0000000..da67c6f --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Sequencer.cs @@ -0,0 +1,132 @@ +using System; +using System.Collections; +using System.Collections.Generic; + +namespace Svelto.ECS +{ + public class Steps + { + internal readonly Dictionary _steps; + + public Steps(params Step[] values) + { + _steps = new Dictionary(); + + for (var i = 0; i < values.Length; i++) + _steps.Add(values[i].from, values[i].to); + } + } + + public class To + { + public To(IStep engine) + { + this.engine = engine; + } + + public To(params IStep[] engines) + { + this.engines = engines; + } + + public IStep engine { get; set; } + public IStep[] engines { get; set; } + } + + public class To:To, IEnumerable where C : struct, IConvertible + { + internal readonly Dictionary[]> _tos = new Dictionary[]>(); + + public IEnumerator GetEnumerator() + { + throw new NotImplementedException(); + } + + public void Add(C condition, params IStep[] engine) + { + _tos[condition] = engine; + } + } + + public interface IStep + { + void Step(EGID id); + } + + public interface IStep where C:struct,IConvertible + { + void Step(C condition, EGID id); + } + + public struct Step + { + public IEngine from { get; set; } + public To to { get; set; } + } + + /// + /// The sequencer has just one goal: define a complex sequence of engines to call. The sequence is not + /// just "sequential", but can create branches and loops. + /// With the time, I figure out that the majority of the times this class is useful in the rare cases where + /// order execution of the engine is necessary/ + /// Using branching is even rarer, but still useful sometimes. + /// I used loops only once. + /// There is the chance that this class will become obsolete over the time, as by design engines should + /// never rely on the order of execution + /// Using this class to let engines from different EnginesRoot communicate will also become obsolete, as + /// better solution will be implemented once I have the time + /// Trying to work out how to initialize this structure can be painful. This is by design as this class must + /// be initialized using the following pattern: + /// instancedSequence.SetSequence( + /// new Steps //list of steps + /// ( + /// new Step // first step + /// { + /// from = menuOptionEnablerEngine, //starting engine + /// to = new To //targets + /// { + /// { + /// ItemActionsPanelEnableCondition.Enable, //condition 1 + /// menuPanelEnablerEngine //targets for condition 1 + /// }, + /// { + /// ItemActionsPanelEnableCondition.Disable,//condition 2 + /// menuPanelEnablerEngine //targets for condition 2 + /// } + /// } + /// }) + /// ); + /// + public class Sequencer where S: Sequencer, new() + { + public void SetSequence(Steps steps) + { + _steps = steps; + } + + public void Next(IEngine engine, C condition, EGID id) where C:struct, IConvertible + { + var branch = condition; + var to = (_steps._steps[engine] as To); + + var steps = to._tos[branch]; + + for (var i = 0; i < steps.Length; i++) + steps[i].Step(condition, id); + } + + public void Next(IEngine engine, EGID id) + { + var to = _steps._steps[engine]; + var steps = to.engines; + + if (steps != null && steps.Length > 1) + for (var i = 0; i < steps.Length; i++) + steps[i].Step(id); + else + to.engine.Step(id); + } + + Steps _steps; + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/Sequencer.cs.meta b/Svelto.ECS/Svelto.ECS/Sequencer.cs.meta new file mode 100644 index 0000000..9f2bfae --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Sequencer.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 84c9aac474cbf2e48b67dcc3dc96dbfb +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/Serialization.meta b/Svelto.ECS/Svelto.ECS/Serialization.meta new file mode 100644 index 0000000..c902a30 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 8504c379dd2b5044a82f075c4279479f +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/Serialization/ComposedSerializer.cs b/Svelto.ECS/Svelto.ECS/Serialization/ComposedSerializer.cs new file mode 100644 index 0000000..c78bdf3 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization/ComposedSerializer.cs @@ -0,0 +1,43 @@ +using System; + +namespace Svelto.ECS.Serialization +{ + public class ComposedSerializer : ISerializer + where T : unmanaged, IEntityStruct + where X : class, ISerializer, new() + where Y : class, ISerializer, new() + { + public ComposedSerializer() + { + _serializers = new ISerializer[2]; + _serializers[0] = new X(); + _serializers[1] = new Y(); + } + + public bool Serialize(in T value, ISerializationData serializationData) + { + foreach (ISerializer s in _serializers) + { + serializationData.data.ExpandBy(s.size); + if (s.SerializeSafe(value, serializationData)) + return true; + } + + throw new Exception($"ComposedSerializer for {typeof(T)} did not serialize any data!"); + } + + public bool Deserialize(ref T value, ISerializationData serializationData) + { + foreach (ISerializer s in _serializers) + { + if (s.DeserializeSafe(ref value, serializationData)) + return true; + } + + throw new Exception($"ComposedSerializer for {typeof(T)} did not deserialize any data!"); + } + + public uint size => 0; + ISerializer[] _serializers; + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/Serialization/ComposedSerializer.cs.meta b/Svelto.ECS/Svelto.ECS/Serialization/ComposedSerializer.cs.meta new file mode 100644 index 0000000..a0d26c4 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization/ComposedSerializer.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: fe2b9c27c1b82e94dbed52c7d79c6d47 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/Serialization/DefaultSerializer.cs b/Svelto.ECS/Svelto.ECS/Serialization/DefaultSerializer.cs new file mode 100644 index 0000000..38e905f --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization/DefaultSerializer.cs @@ -0,0 +1,43 @@ +using Svelto.Common; + +namespace Svelto.ECS.Serialization +{ + public class DefaultSerializer : ISerializer where T : unmanaged, IEntityStruct + { + public static readonly uint SIZEOFT = SerializableEntityBuilder.SIZE; + + public uint size => SIZEOFT; + + static DefaultSerializer() + { + var _type = typeof(T); + + foreach (var field in _type.GetFields()) + { + if (field.FieldType.ContainsCustomAttribute(typeof(DoNotSerializeAttribute)) && field.IsPrivate == false) + throw new ECSException("field cannot be serialised ".FastConcat(_type.FullName)); + } + + if (_type.GetProperties().Length > (EntityBuilder.HAS_EGID ? 1 : 0)) + throw new ECSException("serializable entity struct must be property less ".FastConcat(_type.FullName)); + } + + public bool Serialize(in T value, ISerializationData serializationData) + { + DefaultSerializerUtils.CopyToByteArray(value, serializationData.data.ToArrayFast(), serializationData.dataPos); + + serializationData.dataPos += SIZEOFT; + + return true; + } + + public bool Deserialize(ref T value, ISerializationData serializationData) + { + value = DefaultSerializerUtils.CopyFromByteArray(serializationData.data.ToArrayFast(), serializationData.dataPos); + + serializationData.dataPos += SIZEOFT; + + return true; + } + } +} diff --git a/Svelto.ECS/Svelto.ECS/Serialization/DefaultSerializer.cs.meta b/Svelto.ECS/Svelto.ECS/Serialization/DefaultSerializer.cs.meta new file mode 100644 index 0000000..fe6fb2b --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization/DefaultSerializer.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 9f0be257d08018d44b5325271088fbcf +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/Serialization/DefaultSerializerUtils.cs b/Svelto.ECS/Svelto.ECS/Serialization/DefaultSerializerUtils.cs new file mode 100644 index 0000000..fcc600d --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization/DefaultSerializerUtils.cs @@ -0,0 +1,46 @@ +using System; +using Svelto.ECS; + +public static class DefaultSerializerUtils +{ + public static unsafe void CopyToByteArray(in T src, byte[] data, uint offsetDst) where T : unmanaged, IEntityStruct + { + fixed (void* dstPtr = data) + { + void* dstOffsetPtr; + if (IntPtr.Size == sizeof(int)) + { + dstOffsetPtr = (void*) (((IntPtr) dstPtr).ToInt32() + ((IntPtr) offsetDst).ToInt32()); + } + else + { + dstOffsetPtr = (void*) (((IntPtr) dstPtr).ToInt64() + ((IntPtr) offsetDst).ToInt64()); + } + + *(T*) dstOffsetPtr = src; + } + } + + public static unsafe T CopyFromByteArray(byte[] data, uint offsetSrc) where T : unmanaged, IEntityStruct + { + T dst = new T(); + + void* dstPtr = &dst; + fixed (void* srcPtr = data) + { + void* srcOffsetPtr; + if (IntPtr.Size == sizeof(int)) + { + srcOffsetPtr = (void*) (((IntPtr) srcPtr).ToInt32() + ((IntPtr) offsetSrc).ToInt32()); + } + else + { + srcOffsetPtr = (void*) (((IntPtr) srcPtr).ToInt64() + ((IntPtr) offsetSrc).ToInt64()); + } + + *(T*) dstPtr = *(T*) srcOffsetPtr; + } + + return dst; + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/Serialization/DefaultSerializerUtils.cs.meta b/Svelto.ECS/Svelto.ECS/Serialization/DefaultSerializerUtils.cs.meta new file mode 100644 index 0000000..437f654 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization/DefaultSerializerUtils.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 5d268cdee1fc7dd4e911569e92ac777a +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/Serialization/DefaultVersioningFactory.cs b/Svelto.ECS/Svelto.ECS/Serialization/DefaultVersioningFactory.cs new file mode 100644 index 0000000..5c3960d --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization/DefaultVersioningFactory.cs @@ -0,0 +1,28 @@ +using System.Collections.Generic; + +namespace Svelto.ECS.Serialization +{ + public class DefaultVersioningFactory : IDeserializationFactory where T : IEntityDescriptor, new() + { + public EntityStructInitializer BuildDeserializedEntity(EGID egid, + ISerializationData serializationData, + ISerializableEntityDescriptor entityDescriptor, + SerializationType serializationType, + IEntitySerialization entitySerialization) + { + var initializer = _factory.BuildEntity(egid, _implementors); + + entitySerialization.DeserializeEntityStructs(serializationData, entityDescriptor, ref initializer, serializationType); + + return initializer; + } + + public DefaultVersioningFactory(IEntityFactory factory) { _factory = factory; } + public DefaultVersioningFactory(IEntityFactory factory, IEnumerable implementors) { _factory = factory; + _implementors = implementors; + } + + readonly IEntityFactory _factory; + readonly IEnumerable _implementors; + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/Serialization/DefaultVersioningFactory.cs.meta b/Svelto.ECS/Svelto.ECS/Serialization/DefaultVersioningFactory.cs.meta new file mode 100644 index 0000000..8606290 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization/DefaultVersioningFactory.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: cd7cf529a33c4b64d8e2a74dcdf8fbd3 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/Serialization/DoNotSerializeAttribute.cs b/Svelto.ECS/Svelto.ECS/Serialization/DoNotSerializeAttribute.cs new file mode 100644 index 0000000..b74485a --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization/DoNotSerializeAttribute.cs @@ -0,0 +1,8 @@ +using System; + +namespace Svelto.ECS.Serialization +{ + public class DoNotSerializeAttribute : Attribute + { + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/Serialization/DoNotSerializeAttribute.cs.meta b/Svelto.ECS/Svelto.ECS/Serialization/DoNotSerializeAttribute.cs.meta new file mode 100644 index 0000000..c4197aa --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization/DoNotSerializeAttribute.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: b063d80a8db16564e84b0e53b7b02169 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/Serialization/DontSerialize.cs b/Svelto.ECS/Svelto.ECS/Serialization/DontSerialize.cs new file mode 100644 index 0000000..f5cba8a --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization/DontSerialize.cs @@ -0,0 +1,17 @@ +namespace Svelto.ECS.Serialization +{ + public class DontSerialize : ISerializer where T : unmanaged, IEntityStruct + { + public uint size => 0; + + public bool Serialize(in T value, ISerializationData serializationData) + { + return false; + } + + public bool Deserialize(ref T value, ISerializationData serializationData) + { + return false; + } + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/Serialization/DontSerialize.cs.meta b/Svelto.ECS/Svelto.ECS/Serialization/DontSerialize.cs.meta new file mode 100644 index 0000000..da83ace --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization/DontSerialize.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 28c9773ad0c2fa04388514abfb44bb7b +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/Serialization/EnginesRoot.GenericEntitySerialization.cs b/Svelto.ECS/Svelto.ECS/Serialization/EnginesRoot.GenericEntitySerialization.cs new file mode 100644 index 0000000..0ca5c63 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization/EnginesRoot.GenericEntitySerialization.cs @@ -0,0 +1,198 @@ +using System; +using Svelto.Common; +using Svelto.ECS.Internal; +using Svelto.ECS.Serialization; + +namespace Svelto.ECS +{ + //todo: this should not be at framework level + public enum SerializationType + { + Network, + Storage, + + Length + } + + public partial class EnginesRoot + { + readonly bool _isDeserializationOnly; + + sealed class EntitySerialization : IEntitySerialization + { + public void SerializeEntity(EGID egid, ISerializationData serializationData, + SerializationType serializationType) + { + var entitiesDb = _enginesRoot._entitiesDB; + + //needs to retrieve the meta data associated with the entity + ref var serializableEntityStruct = ref entitiesDb.QueryEntity(egid); + uint descriptorHash = serializableEntityStruct.descriptorHash; + + SerializationDescriptorMap serializationDescriptorMap = _enginesRoot.serializationDescriptorMap; + var entityDescriptor = serializationDescriptorMap.GetDescriptorFromHash(descriptorHash); + var entityStructsToSerialise = entityDescriptor.entitiesToSerialize; + + var header = + new SerializableEntityHeader(descriptorHash, egid, (byte) entityStructsToSerialise.Length); + header.Copy(serializationData); + + for (int index = 0; index < entityStructsToSerialise.Length; index++) + { + var entityBuilder = entityStructsToSerialise[index]; + + serializationData.BeginNextEntityStruct(); + SerializeEntityStruct(egid, entityBuilder, serializationData, serializationType); + } + } + + public EntityStructInitializer DeserializeNewEntity(EGID egid, ISerializationData serializationData, + SerializationType serializationType) + { + //todo: SerializableEntityHeader may be needed to be customizable + var serializableEntityHeader = new SerializableEntityHeader(serializationData); + + uint descriptorHash = serializableEntityHeader.descriptorHash; + SerializationDescriptorMap serializationDescriptorMap = _enginesRoot.serializationDescriptorMap; + var factory = serializationDescriptorMap.GetSerializationFactory(descriptorHash); + var entityDescriptor = serializationDescriptorMap.GetDescriptorFromHash(descriptorHash); + + //default factory + if (factory == null) + { + var initializer = _enginesRoot.BuildEntity(egid, + _enginesRoot._isDeserializationOnly + ? entityDescriptor.entitiesToSerialize + : entityDescriptor.entitiesToBuild); + + DeserializeEntityStructs(serializationData, entityDescriptor, ref initializer, serializationType); + + return initializer; + } + + //custom factory + return factory.BuildDeserializedEntity(egid, serializationData, entityDescriptor, serializationType, + this); + } + + public void DeserializeEntity(ISerializationData serializationData, SerializationType serializationType) + { + var serializableEntityHeader = new SerializableEntityHeader(serializationData); + + EGID egid = serializableEntityHeader.egid; + + DeserializeEntityInternal(serializationData, egid, serializableEntityHeader, serializationType); + } + + public void DeserializeEntity(EGID egid, ISerializationData serializationData, + SerializationType serializationType) + { + var serializableEntityHeader = new SerializableEntityHeader(serializationData); + + DeserializeEntityInternal(serializationData, egid, serializableEntityHeader, serializationType); + } + + public void DeserializeEntityStructs(ISerializationData serializationData, + ISerializableEntityDescriptor entityDescriptor, + ref EntityStructInitializer initializer, SerializationType serializationType) + { + foreach (var serializableEntityBuilder in entityDescriptor.entitiesToSerialize) + { + serializationData.BeginNextEntityStruct(); + serializableEntityBuilder.Deserialize(serializationData, initializer, serializationType); + } + } + + public void DeserializeEntityToSwap(EGID localEgid, EGID toEgid) + { + EntitiesDB entitiesDb = _enginesRoot._entitiesDB; + ref var serializableEntityStruct = ref entitiesDb.QueryEntity(localEgid); + + SerializationDescriptorMap serializationDescriptorMap = _enginesRoot.serializationDescriptorMap; + uint descriptorHash = serializableEntityStruct.descriptorHash; + var entityDescriptor = serializationDescriptorMap.GetDescriptorFromHash(descriptorHash); + + var entitySubmitOperation = new EntitySubmitOperation( + EntitySubmitOperationType.Swap, + localEgid, + toEgid, + entityDescriptor.entitiesToBuild); + + _enginesRoot.CheckRemoveEntityID(localEgid); + _enginesRoot.CheckAddEntityID(toEgid); + + _enginesRoot.QueueEntitySubmitOperation(entitySubmitOperation); + } + + public void DeserializeEntityToDelete(EGID egid) + { + EntitiesDB entitiesDB = _enginesRoot._entitiesDB; + ref var serializableEntityStruct = ref entitiesDB.QueryEntity(egid); + uint descriptorHash = serializableEntityStruct.descriptorHash; + + SerializationDescriptorMap serializationDescriptorMap = _enginesRoot.serializationDescriptorMap; + var entityDescriptor = serializationDescriptorMap.GetDescriptorFromHash(descriptorHash); + + _enginesRoot.CheckRemoveEntityID(egid); + + var entitySubmitOperation = new EntitySubmitOperation( + EntitySubmitOperationType.Remove, + egid, + egid, + entityDescriptor.entitiesToBuild); + + _enginesRoot.QueueEntitySubmitOperation(entitySubmitOperation); + } + + public void RegisterSerializationFactory(IDeserializationFactory deserializationFactory) + where T : ISerializableEntityDescriptor, new() + { + SerializationDescriptorMap serializationDescriptorMap = _enginesRoot.serializationDescriptorMap; + serializationDescriptorMap.RegisterSerializationFactory(deserializationFactory); + } + + internal EntitySerialization(EnginesRoot enginesRoot) + { + _enginesRoot = enginesRoot; + } + + void SerializeEntityStruct(EGID entityGID, ISerializableEntityBuilder entityBuilder, + ISerializationData serializationData, SerializationType serializationType) + { + uint groupId = entityGID.groupID; + Type entityType = entityBuilder.GetEntityType(); + if (!_enginesRoot._entitiesDB.UnsafeQueryEntityDictionary(groupId, entityType, + out var safeDictionary)) + { + throw new Exception("Entity Serialization failed"); + } + + entityBuilder.Serialize(entityGID.entityID, safeDictionary, serializationData, serializationType); + } + + void DeserializeEntityInternal(ISerializationData serializationData, EGID egid, + SerializableEntityHeader serializableEntityHeader, SerializationType serializationType) + { + SerializationDescriptorMap descriptorMap = _enginesRoot.serializationDescriptorMap; + var entityDescriptor = descriptorMap.GetDescriptorFromHash(serializableEntityHeader.descriptorHash); + + foreach (var serializableEntityBuilder in entityDescriptor.entitiesToSerialize) + { + _enginesRoot._entitiesDB.UnsafeQueryEntityDictionary(egid.groupID, + serializableEntityBuilder.GetEntityType(), out var safeDictionary); + + serializationData.BeginNextEntityStruct(); + serializableEntityBuilder.Deserialize(egid.entityID, safeDictionary, serializationData, + serializationType); + } + } + + readonly EnginesRoot _enginesRoot; + } + + public IEntitySerialization GenerateEntitySerializer() + { + return new EntitySerialization(this); + } + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/Serialization/EnginesRoot.GenericEntitySerialization.cs.meta b/Svelto.ECS/Svelto.ECS/Serialization/EnginesRoot.GenericEntitySerialization.cs.meta new file mode 100644 index 0000000..34ea145 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization/EnginesRoot.GenericEntitySerialization.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 8f9fd3e82f1650343ac47211902571d8 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/Serialization/EnginesRoot.SerializableEntityHeader.cs b/Svelto.ECS/Svelto.ECS/Serialization/EnginesRoot.SerializableEntityHeader.cs new file mode 100644 index 0000000..32ccc67 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization/EnginesRoot.SerializableEntityHeader.cs @@ -0,0 +1,76 @@ +using Svelto.DataStructures; + +namespace Svelto.ECS +{ + public partial class EnginesRoot + { + struct SerializableEntityHeader + { + public readonly uint descriptorHash; + public readonly byte entityStructsCount; + + const uint SIZE = 4 + 4 + 4 + 1; + + internal SerializableEntityHeader(uint descriptorHash_, EGID egid_, byte entityStructsCount_) + { + entityStructsCount = entityStructsCount_; + descriptorHash = descriptorHash_; + egid = egid_; + } + + internal SerializableEntityHeader(ISerializationData serializationData) + { + descriptorHash = (uint) + (serializationData.data[serializationData.dataPos++] + | serializationData.data[serializationData.dataPos++] << 8 + | serializationData.data[serializationData.dataPos++] << 16 + | serializationData.data[serializationData.dataPos++] << 24); + + uint entityID = (uint) + (serializationData.data[serializationData.dataPos++] + | serializationData.data[serializationData.dataPos++] << 8 + | serializationData.data[serializationData.dataPos++] << 16 + | serializationData.data[serializationData.dataPos++] << 24); + + uint groupID = (uint) + (serializationData.data[serializationData.dataPos++] + | serializationData.data[serializationData.dataPos++] << 8 + | serializationData.data[serializationData.dataPos++] << 16 + | serializationData.data[serializationData.dataPos++] << 24); + + entityStructsCount = serializationData.data[serializationData.dataPos++]; + + egid = new EGID(entityID, new ExclusiveGroup.ExclusiveGroupStruct(groupID)); + } + + internal void Copy(ISerializationData serializationData) + { + serializationData.data.ExpandBy(SIZE); + + // Splitting the descriptorHash_ (uint, 32 bit) into four bytes. + serializationData.data[serializationData.dataPos++] = (byte) (descriptorHash & 0xff); + serializationData.data[serializationData.dataPos++] = (byte) ((descriptorHash >> 8) & 0xff); + serializationData.data[serializationData.dataPos++] = (byte) ((descriptorHash >> 16) & 0xff); + serializationData.data[serializationData.dataPos++] = (byte) ((descriptorHash >> 24) & 0xff); + + // Splitting the entityID (uint, 32 bit) into four bytes. + uint entityID = egid.entityID; + serializationData.data[serializationData.dataPos++] = (byte) (entityID & 0xff); + serializationData.data[serializationData.dataPos++] = (byte) ((entityID >> 8) & 0xff); + serializationData.data[serializationData.dataPos++] = (byte) ((entityID >> 16) & 0xff); + serializationData.data[serializationData.dataPos++] = (byte) ((entityID >> 24) & 0xff); + + // Splitting the groupID (uint, 32 bit) into four bytes. + uint groupID = egid.groupID; + serializationData.data[serializationData.dataPos++] = (byte) (groupID & 0xff); + serializationData.data[serializationData.dataPos++] = (byte) ((groupID >> 8) & 0xff); + serializationData.data[serializationData.dataPos++] = (byte) ((groupID >> 16) & 0xff); + serializationData.data[serializationData.dataPos++] = (byte) ((groupID >> 24) & 0xff); + + serializationData.data[serializationData.dataPos++] = entityStructsCount; + } + + internal readonly EGID egid; //this can't be used safely! + } + } +} diff --git a/Svelto.ECS/Svelto.ECS/Serialization/EnginesRoot.SerializableEntityHeader.cs.meta b/Svelto.ECS/Svelto.ECS/Serialization/EnginesRoot.SerializableEntityHeader.cs.meta new file mode 100644 index 0000000..88924b9 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization/EnginesRoot.SerializableEntityHeader.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: bf7dffeb527deee45adbd3230a87ca93 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/Serialization/EntitiesDB.DescriptorMap.cs b/Svelto.ECS/Svelto.ECS/Serialization/EntitiesDB.DescriptorMap.cs new file mode 100644 index 0000000..6e23c57 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization/EntitiesDB.DescriptorMap.cs @@ -0,0 +1,105 @@ +using System; +using System.Collections.Generic; +using System.Reflection; +using Svelto.ECS.Serialization; + +namespace Svelto.ECS +{ + partial class EnginesRoot + { + sealed class SerializationDescriptorMap + { + /// + /// Here we want to register all the EntityDescriptors that need to be serialized for network play. + /// + /// Remember! This needs to in sync across different clients and server as the values are serialized across + /// the network also want this to not change so we can save to a DB + /// + internal SerializationDescriptorMap() + { + _descriptors = new Dictionary(); + _factories = new Dictionary(); + + Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies(); + foreach (Assembly assembly in assemblies) + { + foreach (Type type in GetTypesSafe(assembly)) + { + if (type != null && type.IsClass && type.GetConstructor(Type.EmptyTypes) != null && + typeof(ISerializableEntityDescriptor).IsAssignableFrom(type)) + { + var descriptor = Activator.CreateInstance(type) as ISerializableEntityDescriptor; + + RegisterEntityDescriptor(descriptor); + } + } + } + } + + static IEnumerable GetTypesSafe(Assembly assembly) + { + try + { + Type[] types = assembly.GetTypes(); + + return types; + } + catch (ReflectionTypeLoadException e) + { + return e.Types; + } + } + + void RegisterEntityDescriptor(ISerializableEntityDescriptor descriptor) + { + if (descriptor == null) + { + return; + } + + uint descriptorHash = descriptor.hash; + +#if DEBUG && !PROFILER + if (_descriptors.ContainsKey(descriptorHash)) + { + throw new Exception($"Hash Collision of '{descriptor.GetType()}' against " + + $"'{_descriptors[descriptorHash]} ::: {descriptorHash}'"); + } +#endif + + _descriptors[descriptorHash] = descriptor; + } + + public ISerializableEntityDescriptor GetDescriptorFromHash(uint descriptorID) + { +#if DEBUG && !PROFILER + DBC.ECS.Check.Require(_descriptors.ContainsKey(descriptorID), + $"Could not find descriptor with ID '{descriptorID}'!"); +#endif + + return _descriptors[descriptorID]; + } + + public IDeserializationFactory GetSerializationFactory(uint descriptorID) + { + return _factories.TryGetValue(descriptorID, out var factory) ? factory : null; + } + + public void RegisterSerializationFactory(IDeserializationFactory deserializationFactory) + where Descriptor : ISerializableEntityDescriptor, new() + { + _factories.Add(SerializationEntityDescriptorTemplate.hash, deserializationFactory); + } + + + readonly Dictionary _descriptors; + readonly Dictionary _factories; + } + + /// + /// The map of serializable entity hashes to the serializable entity builders (to know the entity structs + /// to serialize) + /// + SerializationDescriptorMap serializationDescriptorMap { get; } = new SerializationDescriptorMap(); + } +} diff --git a/Svelto.ECS/Svelto.ECS/Serialization/EntitiesDB.DescriptorMap.cs.meta b/Svelto.ECS/Svelto.ECS/Serialization/EntitiesDB.DescriptorMap.cs.meta new file mode 100644 index 0000000..108dda5 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization/EntitiesDB.DescriptorMap.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 91b54f132c85ce4489dc6a925fbc6528 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/Serialization/HashNameAttribute.cs b/Svelto.ECS/Svelto.ECS/Serialization/HashNameAttribute.cs new file mode 100644 index 0000000..f2c6ed2 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization/HashNameAttribute.cs @@ -0,0 +1,15 @@ +using System; + +namespace Svelto.ECS.Serialization +{ + [AttributeUsage(AttributeTargets.Class)] + public class HashNameAttribute:Attribute + { + public HashNameAttribute(string name) + { + _name = name; + } + + internal string _name; + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/Serialization/HashNameAttribute.cs.meta b/Svelto.ECS/Svelto.ECS/Serialization/HashNameAttribute.cs.meta new file mode 100644 index 0000000..08c660b --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization/HashNameAttribute.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: bc42d165d6eee11419bd2bf7e6e46078 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/Serialization/IDeserializationFactory.cs b/Svelto.ECS/Svelto.ECS/Serialization/IDeserializationFactory.cs new file mode 100644 index 0000000..1045f71 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization/IDeserializationFactory.cs @@ -0,0 +1,9 @@ +namespace Svelto.ECS.Serialization +{ + public interface IDeserializationFactory + { + EntityStructInitializer BuildDeserializedEntity(EGID egid, ISerializationData serializationData, + ISerializableEntityDescriptor entityDescriptor, SerializationType serializationType, + IEntitySerialization entitySerialization); + } +} diff --git a/Svelto.ECS/Svelto.ECS/Serialization/IDeserializationFactory.cs.meta b/Svelto.ECS/Svelto.ECS/Serialization/IDeserializationFactory.cs.meta new file mode 100644 index 0000000..dd9bcff --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization/IDeserializationFactory.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: f00a699a48a512540aec209114530fcc +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/Serialization/IEntitySerialization.cs b/Svelto.ECS/Svelto.ECS/Serialization/IEntitySerialization.cs new file mode 100644 index 0000000..6fb1ef8 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization/IEntitySerialization.cs @@ -0,0 +1,69 @@ +namespace Svelto.ECS.Serialization +{ + public interface IEntitySerialization + { + /// + /// Fill the serializationData of the entitiesToSerialize of this descriptor + /// + /// + /// + /// + /// Size in bytes of the newly instantiated entity + void SerializeEntity(EGID egid, ISerializationData serializationData, SerializationType serializationType); + + /// + /// Deserialize a serializationData and copy directly onto the appropriate entities + /// + /// + /// + /// + void DeserializeEntity(ISerializationData serializationData, SerializationType serializationType); + + /// + /// Deserialize a serializationData and copy directly onto the appropriate entities with explicit EGID + /// + /// + /// + /// + /// + void DeserializeEntity(EGID egid, ISerializationData serializationData, SerializationType serializationType); + + /// + /// Deserialize a serializationData and copy directly to an previously created EntityStructInitializer + /// + /// + /// + /// + /// + void DeserializeEntityStructs(ISerializationData serializationData, + ISerializableEntityDescriptor entityDescriptor, + ref EntityStructInitializer initializer, SerializationType serializationType); + + /// + /// Contrary to the other Deserialize methods that assume that the entity exists, this method is used to deserialise + /// a new Entity + /// + /// + /// + /// + /// + EntityStructInitializer DeserializeNewEntity(EGID egid, ISerializationData serializationData, + SerializationType serializationType); + + /// + /// Special Entity Swap method that works without knowing the EntityDescriptor to swap + /// + /// + /// + void DeserializeEntityToSwap(EGID localEgid, EGID toEgid); + + /// + /// Special Entity delete method that works without knowing the EntityDescriptor to delete + /// + /// + void DeserializeEntityToDelete(EGID egid); + + void RegisterSerializationFactory(IDeserializationFactory deserializationFactory) + where T : ISerializableEntityDescriptor, new(); + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/Serialization/IEntitySerialization.cs.meta b/Svelto.ECS/Svelto.ECS/Serialization/IEntitySerialization.cs.meta new file mode 100644 index 0000000..e0e50bb --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization/IEntitySerialization.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 1c582a5f751c68a45bc272318a5ab602 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/Serialization/ISerializableEntityBuilder.cs b/Svelto.ECS/Svelto.ECS/Serialization/ISerializableEntityBuilder.cs new file mode 100644 index 0000000..91c3433 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization/ISerializableEntityBuilder.cs @@ -0,0 +1,15 @@ +using Svelto.ECS.Internal; + +namespace Svelto.ECS.Serialization +{ + public interface ISerializableEntityBuilder : IEntityBuilder + { + void Serialize(uint id, ITypeSafeDictionary dictionary, ISerializationData serializationData, SerializationType serializationType); + + void Deserialize(uint id, ITypeSafeDictionary dictionary, ISerializationData serializationData, SerializationType serializationType); + + void Deserialize(ISerializationData serializationData, in EntityStructInitializer initializer, SerializationType serializationType); + + void CopySerializedEntityStructs(in EntityStructInitializer sourceInitializer, in EntityStructInitializer destinationInitializer, SerializationType serializationType); + } +} diff --git a/Svelto.ECS/Svelto.ECS/Serialization/ISerializableEntityBuilder.cs.meta b/Svelto.ECS/Svelto.ECS/Serialization/ISerializableEntityBuilder.cs.meta new file mode 100644 index 0000000..664cbcd --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization/ISerializableEntityBuilder.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 2a150efc2dba6044db270a9601d35dba +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/Serialization/ISerializableEntityDescriptor.cs b/Svelto.ECS/Svelto.ECS/Serialization/ISerializableEntityDescriptor.cs new file mode 100644 index 0000000..f441bde --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization/ISerializableEntityDescriptor.cs @@ -0,0 +1,10 @@ +namespace Svelto.ECS.Serialization +{ + public interface ISerializableEntityDescriptor : IEntityDescriptor + { + uint hash { get; } + ISerializableEntityBuilder[] entitiesToSerialize { get; } + + void CopySerializedEntityStructs(in EntityStructInitializer sourceInitializer, in EntityStructInitializer destinationInitializer, SerializationType serializationType); + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/Serialization/ISerializableEntityDescriptor.cs.meta b/Svelto.ECS/Svelto.ECS/Serialization/ISerializableEntityDescriptor.cs.meta new file mode 100644 index 0000000..f3dd643 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization/ISerializableEntityDescriptor.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: a8c7b0066ae024f4eb189ab7b4acfe49 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/Serialization/ISerializationData.cs b/Svelto.ECS/Svelto.ECS/Serialization/ISerializationData.cs new file mode 100644 index 0000000..852d43a --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization/ISerializationData.cs @@ -0,0 +1,14 @@ +using Svelto.DataStructures; + +namespace Svelto.ECS +{ + public interface ISerializationData + { + uint dataPos { get; set; } + FasterList data { get; } + + void ReuseAsNew(); + void Reset(); + void BeginNextEntityStruct(); + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/Serialization/ISerializationData.cs.meta b/Svelto.ECS/Svelto.ECS/Serialization/ISerializationData.cs.meta new file mode 100644 index 0000000..85aa901 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization/ISerializationData.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: e1e31262837913840943fd4ae8a363c1 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/Serialization/ISerializer.cs b/Svelto.ECS/Svelto.ECS/Serialization/ISerializer.cs new file mode 100644 index 0000000..39fa588 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization/ISerializer.cs @@ -0,0 +1,55 @@ +#if DEBUG && !PROFILER +using System; +#endif + +namespace Svelto.ECS.Serialization +{ + public interface ISerializer + where T : unmanaged, IEntityStruct + { + bool Serialize(in T value, ISerializationData serializationData); + bool Deserialize(ref T value, ISerializationData serializationData); + + uint size { get; } + } + + public static class SerializerExt + { + public static bool SerializeSafe(this ISerializer serializer, in T value, ISerializationData serializationData) + where T : unmanaged, IEntityStruct + { +#if DEBUG && !PROFILER + uint posBefore = serializationData.dataPos; +#endif + bool res = serializer.Serialize(value, serializationData); +#if DEBUG && !PROFILER + // size == 0 is a special case when we don't know the size in advance + if (serializer.size != 0 && serializationData.dataPos != posBefore + serializer.size) + { + throw new IndexOutOfRangeException( + $"Size mismatch when serializing {typeof(T).FullName} using {serializer.GetType().FullName}, " + + $"expected offset {posBefore + serializer.size}, got {serializationData.dataPos}"); + } +#endif + return res; + } + + public static bool DeserializeSafe(this ISerializer serializer, ref T value, ISerializationData serializationData) + where T : unmanaged, IEntityStruct + { +#if DEBUG && !PROFILER + uint posBefore = serializationData.dataPos; +#endif + bool res = serializer.Deserialize(ref value, serializationData); +#if DEBUG && !PROFILER + if (serializer.size != 0 && serializationData.dataPos != posBefore + serializer.size) + { + throw new IndexOutOfRangeException( + $"Size mismatch when deserializing {typeof(T).FullName} using {serializer.GetType().FullName}, " + + $"expected offset {posBefore + serializer.size}, got {serializationData.dataPos}"); + } +#endif + return res; + } + } +} diff --git a/Svelto.ECS/Svelto.ECS/Serialization/ISerializer.cs.meta b/Svelto.ECS/Svelto.ECS/Serialization/ISerializer.cs.meta new file mode 100644 index 0000000..64fa19e --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization/ISerializer.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 5700d5784e6e6d24d86d70c190080791 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/Serialization/PartialSerializer.cs b/Svelto.ECS/Svelto.ECS/Serialization/PartialSerializer.cs new file mode 100644 index 0000000..a21348f --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization/PartialSerializer.cs @@ -0,0 +1,89 @@ +using System; +using System.Reflection; +using System.Runtime.InteropServices; +using Svelto.DataStructures; +using Attribute = System.Attribute; + +namespace Svelto.ECS.Serialization +{ + [AttributeUsage(AttributeTargets.Field)] + public class PartialSerializerFieldAttribute : Attribute + {} + + public class PartialSerializer : ISerializer + where T : unmanaged, IEntityStruct + { + static PartialSerializer() + { + Type myType = typeof(T); + FieldInfo[] myMembers = myType.GetFields(); + + for (int i = 0; i < myMembers.Length; i++) + { + Object[] myAttributes = myMembers[i].GetCustomAttributes(true); + for (int j = 0; j < myAttributes.Length; j++) + { + if (myAttributes[j] is PartialSerializerFieldAttribute) + { + if (myMembers[i].FieldType == typeof(EGID)) + throw new ECSException("EGID fields cannot be serialised ".FastConcat(myType.FullName)); + + var offset = Marshal.OffsetOf(myMembers[i].Name); + var sizeOf = (uint)Marshal.SizeOf(myMembers[i].FieldType); + offsets.Add(((uint) offset.ToInt32(), sizeOf)); + totalSize += sizeOf; + } + } + } + + if (myType.GetProperties().Length > (EntityBuilder.HAS_EGID ? 1 : 0)) + throw new ECSException("serializable entity struct must be property less ".FastConcat(myType.FullName)); + } + + public bool Serialize(in T value, ISerializationData serializationData) + { + unsafe + { + fixed (byte* dataptr = serializationData.data.ToArrayFast()) + { + var entityStruct = value; + foreach ((uint offset, uint size) offset in offsets) + { + byte* srcPtr = (byte*) &entityStruct + offset.offset; + //todo move to Unsafe Copy when available as it is faster + Buffer.MemoryCopy(srcPtr, dataptr + serializationData.dataPos, + serializationData.data.Count - serializationData.dataPos, offset.size); + serializationData.dataPos += offset.size; + } + } + } + + return true; + } + + public bool Deserialize(ref T value, ISerializationData serializationData) + { + unsafe + { + T tempValue = value; //todo: temporary solution I want to get rid of this copy + fixed (byte* dataptr = serializationData.data.ToArrayFast()) + foreach ((uint offset, uint size) offset in offsets) + { + byte* dstPtr = (byte*) &tempValue + offset.offset; + //todo move to Unsafe Copy when available as it is faster + Buffer.MemoryCopy(dataptr + serializationData.dataPos, dstPtr, offset.size, offset.size); + serializationData.dataPos += offset.size; + } + + value = tempValue; //todo: temporary solution I want to get rid of this copy + } + + return true; + } + + public uint size => totalSize; + + static readonly FasterList<(uint, uint)> offsets = new FasterList<(uint, uint)>(); + static readonly uint totalSize; + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/Serialization/PartialSerializer.cs.meta b/Svelto.ECS/Svelto.ECS/Serialization/PartialSerializer.cs.meta new file mode 100644 index 0000000..88e1705 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization/PartialSerializer.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 729c7823a2412584aacbc42dafd89baa +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/Serialization/SerializableEntityBuilder.cs b/Svelto.ECS/Svelto.ECS/Serialization/SerializableEntityBuilder.cs new file mode 100644 index 0000000..e34caee --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization/SerializableEntityBuilder.cs @@ -0,0 +1,95 @@ +using System; +using Svelto.Common; +using Svelto.ECS.Internal; + +namespace Svelto.ECS.Serialization +{ + public class SerializableEntityBuilder : EntityBuilder, ISerializableEntityBuilder + where T : unmanaged, IEntityStruct + { + public static readonly uint SIZE = UnsafeUtils.SizeOf(); + + static SerializableEntityBuilder() + {} + + public SerializableEntityBuilder() + { + _serializers = new ISerializer[(int) SerializationType.Length]; + for (int i = 0; i < (int) SerializationType.Length; i++) + { + _serializers[i] = new DefaultSerializer(); + } + } + + public SerializableEntityBuilder(params ValueTuple>[] serializers) + { + _serializers = new ISerializer[(int) SerializationType.Length]; + for (int i = 0; i < serializers.Length; i++) + { + ref (SerializationType, ISerializer) s = ref serializers[i]; + _serializers[(int) s.Item1] = s.Item2; + } + + // Just in case the above are the same type + for (int i = 0; i < (int) SerializationType.Length; i++) + { + if (_serializers[i] == null) _serializers[i] = new DontSerialize(); + } + } + + public void Serialize(uint entityID, ITypeSafeDictionary dictionary, + ISerializationData serializationData, SerializationType serializationType) + { + ISerializer serializer = _serializers[(int)serializationType]; + + var safeDictionary = (TypeSafeDictionary) dictionary; + if (safeDictionary.TryFindIndex(entityID, out uint index) == false) + { + throw new ECSException("Entity Serialization failed"); + } + + T[] values = safeDictionary.GetValuesArray(out _); + ref T val = ref values[index]; + + serializationData.dataPos = (uint) serializationData.data.Count; + + serializationData.data.ExpandBy(serializer.size); + serializer.SerializeSafe(val, serializationData); + } + + public void Deserialize(uint entityID, ITypeSafeDictionary dictionary, + ISerializationData serializationData, SerializationType serializationType) + { + ISerializer serializer = _serializers[(int) serializationType]; + + // Handle the case when an entity struct is gone + var safeDictionary = (TypeSafeDictionary) dictionary; + if (safeDictionary.TryFindIndex(entityID, out uint index) == false) + { + throw new ECSException("Entity Deserialization failed"); + } + + T[] values = safeDictionary.GetValuesArray(out _); + ref T val = ref values[index]; + + serializer.DeserializeSafe(ref val, serializationData); + } + + public void Deserialize(ISerializationData serializationData + , in EntityStructInitializer initializer, SerializationType serializationType) + { + ISerializer serializer = _serializers[(int) serializationType]; + + serializer.DeserializeSafe(ref initializer.GetOrCreate(), serializationData); + } + + public void CopySerializedEntityStructs(in EntityStructInitializer sourceInitializer, + in EntityStructInitializer destinationInitializer, SerializationType serializationType) + { + if ((_serializers[(int) serializationType] is DontSerialize) == false) + destinationInitializer.CopyFrom(sourceInitializer.Get()); + } + + readonly ISerializer[] _serializers; + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/Serialization/SerializableEntityBuilder.cs.meta b/Svelto.ECS/Svelto.ECS/Serialization/SerializableEntityBuilder.cs.meta new file mode 100644 index 0000000..cf4bdac --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization/SerializableEntityBuilder.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: a5060d0faaf6ed142ae2e767153bffa2 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/Serialization/SerializableEntityDescriptor.cs b/Svelto.ECS/Svelto.ECS/Serialization/SerializableEntityDescriptor.cs new file mode 100644 index 0000000..f31b902 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization/SerializableEntityDescriptor.cs @@ -0,0 +1,122 @@ +using System; +using System.Reflection; +using System.Text; +using Svelto.DataStructures; +using Svelto.Utilities; + +namespace Svelto.ECS.Serialization +{ + public static class DesignatedHash + { + public static readonly Func Hash = Murmur3.MurmurHash3_x86_32; + } + + public abstract class SerializableEntityDescriptor : ISerializableEntityDescriptor + where TType : IEntityDescriptor, new() + { + static SerializableEntityDescriptor() + { + IEntityBuilder[] defaultEntities = EntityDescriptorTemplate.descriptor.entitiesToBuild; + + var hashNameAttribute = _type.GetCustomAttribute(); + if (hashNameAttribute == null) + { + throw new Exception("HashName attribute not found on the serializable type ".FastConcat(_type.FullName)); + } + + _hash = DesignatedHash.Hash(Encoding.ASCII.GetBytes(hashNameAttribute._name)); + + var (index, dynamicIndex) = SetupSpecialEntityStruct(defaultEntities, out _entitiesToBuild); + if (index == -1) + { + index = _entitiesToBuild.Length - 1; + } + + // Stores the hash of this EntityDescriptor + _entitiesToBuild[index] = new EntityBuilder + ( + new SerializableEntityStruct + { + descriptorHash = _hash + } + ); + + // If the current serializable is an ExtendibleDescriptor, I have to update it. + if (dynamicIndex != -1) + { + _entitiesToBuild[dynamicIndex] = new EntityBuilder + ( + new EntityStructInfoView + { + entitiesToBuild = _entitiesToBuild + } + ); + } + + ///// + var entitiesToSerialize = new FasterList(); + _entitiesToSerializeMap = new FasterDictionary, ISerializableEntityBuilder>(); + foreach (IEntityBuilder e in defaultEntities) + { + if (e is ISerializableEntityBuilder serializableEntityBuilder) + { + var entityType = serializableEntityBuilder.GetEntityType(); + _entitiesToSerializeMap[new RefWrapper(entityType)] = serializableEntityBuilder; + entitiesToSerialize.Add(serializableEntityBuilder); + } + } + + _entitiesToSerialize = entitiesToSerialize.ToArray(); + } + + static (int indexSerial, int indexDynamic) SetupSpecialEntityStruct(IEntityBuilder[] defaultEntities, + out IEntityBuilder[] entitiesToBuild) + { + int length = defaultEntities.Length; + int newLenght = length + 1; + + int indexSerial = -1; + int indexDynamic = -1; + + for (var i = 0; i < length; ++i) + { + if (defaultEntities[i].GetEntityType() == _serializableStructType) + { + indexSerial = i; + --newLenght; + } + + if (defaultEntities[i].GetEntityType() == EntityBuilderUtilities.ENTITY_STRUCT_INFO_VIEW) + { + indexDynamic = i; + } + } + + entitiesToBuild = new IEntityBuilder[newLenght]; + + Array.Copy(defaultEntities, 0, entitiesToBuild, 0, length); + + return (indexSerial, indexDynamic); + } + + public void CopySerializedEntityStructs(in EntityStructInitializer sourceInitializer, in EntityStructInitializer destinationInitializer, SerializationType serializationType) + { + foreach (ISerializableEntityBuilder e in entitiesToSerialize) + { + e.CopySerializedEntityStructs(sourceInitializer, destinationInitializer, serializationType); + } + } + + public IEntityBuilder[] entitiesToBuild => _entitiesToBuild; + public uint hash => _hash; + public ISerializableEntityBuilder[] entitiesToSerialize => _entitiesToSerialize; + + static readonly IEntityBuilder[] _entitiesToBuild; + static readonly FasterDictionary, ISerializableEntityBuilder> _entitiesToSerializeMap; + static readonly ISerializableEntityBuilder[] _entitiesToSerialize; + + static readonly uint _hash; + static readonly Type _serializableStructType = typeof(SerializableEntityStruct); + static readonly Type _type = typeof(TType); + } +} diff --git a/Svelto.ECS/Svelto.ECS/Serialization/SerializableEntityDescriptor.cs.meta b/Svelto.ECS/Svelto.ECS/Serialization/SerializableEntityDescriptor.cs.meta new file mode 100644 index 0000000..5c0bc4c --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization/SerializableEntityDescriptor.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 7abf022f9817b9842a59bc173ec069ce +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/Serialization/SerializableEntityStruct.cs b/Svelto.ECS/Svelto.ECS/Serialization/SerializableEntityStruct.cs new file mode 100644 index 0000000..1e10932 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization/SerializableEntityStruct.cs @@ -0,0 +1,9 @@ +namespace Svelto.ECS +{ + internal struct SerializableEntityStruct : IEntityStruct, INeedEGID + { + public uint descriptorHash; + + public EGID ID { get; set; } + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/Serialization/SerializableEntityStruct.cs.meta b/Svelto.ECS/Svelto.ECS/Serialization/SerializableEntityStruct.cs.meta new file mode 100644 index 0000000..13e340c --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization/SerializableEntityStruct.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 50a91715004d9b144982a488608ea925 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/Serialization/SerializationEntityDescriptorTemplate.cs b/Svelto.ECS/Svelto.ECS/Serialization/SerializationEntityDescriptorTemplate.cs new file mode 100644 index 0000000..1b1de3a --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization/SerializationEntityDescriptorTemplate.cs @@ -0,0 +1,16 @@ +namespace Svelto.ECS.Serialization +{ + public static class SerializationEntityDescriptorTemplate where TType : ISerializableEntityDescriptor, new() + { + static SerializationEntityDescriptorTemplate() + { + var serializableEntityDescriptor = new TType(); + hash = serializableEntityDescriptor.hash; + + entityDescriptor = (ISerializableEntityDescriptor) EntityDescriptorTemplate.descriptor; + } + + public static uint hash { get; } + public static ISerializableEntityDescriptor entityDescriptor { get; } + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/Serialization/SerializationEntityDescriptorTemplate.cs.meta b/Svelto.ECS/Svelto.ECS/Serialization/SerializationEntityDescriptorTemplate.cs.meta new file mode 100644 index 0000000..d65bb28 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization/SerializationEntityDescriptorTemplate.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 8ba82bc07df309b40b63664e6369e55a +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/Serialization/SimpleSerializationData.cs b/Svelto.ECS/Svelto.ECS/Serialization/SimpleSerializationData.cs new file mode 100644 index 0000000..71c7d54 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization/SimpleSerializationData.cs @@ -0,0 +1,37 @@ +using Svelto.DataStructures; + +namespace Svelto.ECS +{ + public class SimpleSerializationData : ISerializationData + { + public uint dataPos { get; set; } + public FasterList data { get; set; } + + public SimpleSerializationData(FasterList d) + { + data = d; + } + + public void ResetWithNewData(FasterList newData) + { + dataPos = 0; + + data = newData; + } + + public void ReuseAsNew() + { + dataPos = 0; + + data.ResetToReuse(); + } + + public void Reset() + { + dataPos = 0; + } + + public void BeginNextEntityStruct() + {} + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/Serialization/SimpleSerializationData.cs.meta b/Svelto.ECS/Svelto.ECS/Serialization/SimpleSerializationData.cs.meta new file mode 100644 index 0000000..c92a7a3 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization/SimpleSerializationData.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 8922b7b8f2f2a46439ec341b3d4292b0 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/Serialization/Unsafe.cs b/Svelto.ECS/Svelto.ECS/Serialization/Unsafe.cs new file mode 100644 index 0000000..dd6ea52 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization/Unsafe.cs @@ -0,0 +1,15 @@ +using Svelto.ECS; + +namespace Svelto.Common +{ + public class UnsafeUtils + { + public static uint SizeOf() where T : unmanaged, IEntityStruct + { + unsafe + { + return (uint) sizeof(T); + } + } + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/Serialization/Unsafe.cs.meta b/Svelto.ECS/Svelto.ECS/Serialization/Unsafe.cs.meta new file mode 100644 index 0000000..55edb98 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Serialization/Unsafe.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: a9620199cb6eff446bc83878081775c8 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/SimpleSubmissionEntityViewScheduler.cs b/Svelto.ECS/Svelto.ECS/SimpleSubmissionEntityViewScheduler.cs new file mode 100644 index 0000000..e2fe657 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/SimpleSubmissionEntityViewScheduler.cs @@ -0,0 +1,25 @@ +using System; +using Svelto.ECS.Schedulers; + +namespace Svelto.ECS +{ + //This scheduler shouldn't be used in production and it's meant to be used for Unit Tests only + public class SimpleSubmissionEntityViewScheduler : IEntitySubmissionScheduler + { + public void SubmitEntities() + { + _onTick.Invoke(); + } + + EnginesRoot.EntitiesSubmitter IEntitySubmissionScheduler.onTick + { + set => _onTick = value; + } + + EnginesRoot.EntitiesSubmitter _onTick; + + public void Dispose() + { + } + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/SimpleSubmissionEntityViewScheduler.cs.meta b/Svelto.ECS/Svelto.ECS/SimpleSubmissionEntityViewScheduler.cs.meta new file mode 100644 index 0000000..1082f15 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/SimpleSubmissionEntityViewScheduler.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: dd6ecdc857bffb14d8cc39580a17e419 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/Svelto.ECS.asmdef b/Svelto.ECS/Svelto.ECS/Svelto.ECS.asmdef new file mode 100644 index 0000000..d561d80 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Svelto.ECS.asmdef @@ -0,0 +1,15 @@ +{ + "name": "Svelto.ECS", + "references": [ + "Svelto.Common" + ], + "optionalUnityReferences": [], + "includePlatforms": [], + "excludePlatforms": [], + "allowUnsafeCode": true, + "overrideReferences": false, + "precompiledReferences": [], + "autoReferenced": true, + "defineConstraints": [], + "versionDefines": [] +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/Svelto.ECS.asmdef.meta b/Svelto.ECS/Svelto.ECS/Svelto.ECS.asmdef.meta new file mode 100644 index 0000000..4456891 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Svelto.ECS.asmdef.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: 1869b46461d119144a089fe5899ab312 +AssemblyDefinitionImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/Svelto.ECS.csproj b/Svelto.ECS/Svelto.ECS/Svelto.ECS.csproj new file mode 100644 index 0000000..9fdf31b --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Svelto.ECS.csproj @@ -0,0 +1,24 @@ + + + Svelto.ECS + 7.3 + netstandard2.0 + + + AnyCPU + false + true + + + AnyCPU + false + true + + + + + + + + + \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/Svelto.ECS.csproj.meta b/Svelto.ECS/Svelto.ECS/Svelto.ECS.csproj.meta new file mode 100644 index 0000000..979f083 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/Svelto.ECS.csproj.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: e060e388fd1b50a45951da9132e3c0df +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/TypeCache.cs b/Svelto.ECS/Svelto.ECS/TypeCache.cs new file mode 100644 index 0000000..bd10908 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/TypeCache.cs @@ -0,0 +1,9 @@ +using System; + +namespace Svelto.ECS.Internal +{ + public class TypeCache + { + public static Type type = typeof(T); + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/TypeCache.cs.meta b/Svelto.ECS/Svelto.ECS/TypeCache.cs.meta new file mode 100644 index 0000000..880cbbe --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/TypeCache.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: b7834d7f465e0eb4987aa4c4bbd399c0 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/WaitForSubmissionEnumerator.cs b/Svelto.ECS/Svelto.ECS/WaitForSubmissionEnumerator.cs new file mode 100644 index 0000000..d5a1732 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/WaitForSubmissionEnumerator.cs @@ -0,0 +1,64 @@ +using System; +using System.Collections; + +namespace Svelto.ECS +{ + public class WaitForSubmissionEnumerator : IEnumerator + { + class SubmissionEntityDescriptor : GenericEntityDescriptor + { + internal static readonly ExclusiveGroup SubmissionGroup = new ExclusiveGroup(); + } + + readonly IEntityFactory _entityFactory; + readonly IEntitiesDB _entitiesDB; + readonly IEntityFunctions _entityFunctions; + + int _state; + + public WaitForSubmissionEnumerator(IEntityFunctions entityFunctions, IEntityFactory entityFactory, + IEntitiesDB entitiesDb) + { + _entityFactory = entityFactory; + _entityFunctions = entityFunctions; + _entitiesDB = entitiesDb; + } + + public bool MoveNext() + { + switch (_state) + { + case 0: + _counter = _COUNTER++; + _entityFactory.BuildEntity(new EGID((uint) _counter, + SubmissionEntityDescriptor.SubmissionGroup)); + _state = 1; + return true; + case 1: + if (_entitiesDB.Exists(new EGID((uint) _counter, + SubmissionEntityDescriptor.SubmissionGroup)) == false) + return true; + + _entityFunctions.RemoveEntity(new EGID((uint) _counter, + SubmissionEntityDescriptor.SubmissionGroup)); + _state = 0; + return false; + } + + throw new Exception("something is wrong"); + } + + void IEnumerator.Reset() + { + throw new NotImplementedException(); + } + + public object Current { get; } + + struct SubmissionSignalStruct : IEntityStruct + {} + + int _counter; + static int _COUNTER; + } +} \ No newline at end of file diff --git a/Svelto.ECS/Svelto.ECS/WaitForSubmissionEnumerator.cs.meta b/Svelto.ECS/Svelto.ECS/WaitForSubmissionEnumerator.cs.meta new file mode 100644 index 0000000..4183c41 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/WaitForSubmissionEnumerator.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 9288428e048eadb4b9a7c01e0416f665 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Svelto.ECS/Svelto.ECS/package.json b/Svelto.ECS/Svelto.ECS/package.json new file mode 100644 index 0000000..9a52443 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/package.json @@ -0,0 +1,15 @@ +{ + "displayName": "Svelto ECS", + "category": "Svelto", + "description": "Svelto ECS C# Lightweight Data Oriented Entity Component System Framework", + "dependencies": { + "com.sebaslab.svelto.common": "2.9.2" + }, + "keywords": [ + "svelto" + ], + "name": "com.sebaslab.svelto.ecs", + "unity": "2019.2", + "version": "2.9.2", + "type": "library" +} diff --git a/Svelto.ECS/Svelto.ECS/package.json.meta b/Svelto.ECS/Svelto.ECS/package.json.meta new file mode 100644 index 0000000..fdb3151 --- /dev/null +++ b/Svelto.ECS/Svelto.ECS/package.json.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: 8bc2178093a5e2f48823ed504d50bc6d +TextScriptImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: