2019-12-17 03:55:27 +00:00
|
|
|
|
using System;
|
2019-06-15 00:03:56 +00:00
|
|
|
|
using System.Collections.Generic;
|
2019-06-17 00:56:36 +00:00
|
|
|
|
using System.Reflection;
|
|
|
|
|
using System.Linq;
|
2019-06-24 19:14:37 +00:00
|
|
|
|
using Encompass.Exceptions;
|
2019-10-24 20:13:43 +00:00
|
|
|
|
using MoonTools.Core.Graph;
|
|
|
|
|
using MoonTools.Core.Graph.Extensions;
|
2019-06-15 00:03:56 +00:00
|
|
|
|
|
2019-06-16 01:05:56 +00:00
|
|
|
|
namespace Encompass
|
|
|
|
|
{
|
2019-10-24 19:48:36 +00:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// WorldBuilder is used to construct a World from Engines, Renderers, and an initial state of Entities, Components, and Messages.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <remarks>
|
|
|
|
|
/// WorldBuilder enforces certain rules about Engine structure. It is forbidden to have messages create cycles between Engines,
|
|
|
|
|
/// and no Component may be written by more than one Engine.
|
|
|
|
|
/// The WorldBuilder uses Engines and their Message read/emit information to determine a valid ordering of the Engines, which is given to the World.
|
|
|
|
|
/// </remarks>
|
2019-06-16 01:05:56 +00:00
|
|
|
|
public class WorldBuilder
|
|
|
|
|
{
|
2020-03-20 07:09:57 +00:00
|
|
|
|
private readonly int _entityCapacity;
|
|
|
|
|
private readonly List<Engine> _engines = new List<Engine>();
|
|
|
|
|
private readonly DirectedGraph<Engine, Unit> _engineGraph = GraphBuilder.DirectedGraph<Engine>();
|
|
|
|
|
private readonly ComponentStore _startingExistingComponentStore;
|
|
|
|
|
private readonly ComponentStore _startingUpToDateComponentStore;
|
2019-06-15 00:51:06 +00:00
|
|
|
|
|
2020-03-20 07:09:57 +00:00
|
|
|
|
private readonly ComponentManager _componentManager;
|
|
|
|
|
private readonly EntityManager _entityManager;
|
|
|
|
|
private readonly MessageManager _messageManager;
|
|
|
|
|
private readonly TimeManager _timeManager;
|
|
|
|
|
private readonly DrawLayerManager _drawLayerManager;
|
|
|
|
|
private readonly RenderManager _renderManager;
|
|
|
|
|
private readonly TrackingManager _trackingManager;
|
2019-06-15 00:03:56 +00:00
|
|
|
|
|
2020-03-20 07:09:57 +00:00
|
|
|
|
private readonly Dictionary<Type, HashSet<Engine>> _typeToReaders = new Dictionary<Type, HashSet<Engine>>();
|
|
|
|
|
private readonly HashSet<Engine> _senders = new HashSet<Engine>();
|
|
|
|
|
private readonly HashSet<Type> _componentTypesToPreload = new HashSet<Type>();
|
|
|
|
|
private readonly HashSet<Type> _messageTypes = new HashSet<Type>();
|
|
|
|
|
private readonly Dictionary<Type, int> _typeToIndex = new Dictionary<Type, int>();
|
2019-12-22 09:15:58 +00:00
|
|
|
|
|
2020-07-10 19:37:10 +00:00
|
|
|
|
private bool _rendererRegistered = false;
|
|
|
|
|
|
2019-12-20 20:52:38 +00:00
|
|
|
|
public WorldBuilder(int entityCapacity = 32768)
|
2019-06-16 01:05:56 +00:00
|
|
|
|
{
|
2020-03-20 07:09:57 +00:00
|
|
|
|
_entityCapacity = entityCapacity;
|
2020-03-20 07:58:33 +00:00
|
|
|
|
_drawLayerManager = new DrawLayerManager();
|
2020-03-20 07:09:57 +00:00
|
|
|
|
_timeManager = new TimeManager();
|
|
|
|
|
_trackingManager = new TrackingManager();
|
|
|
|
|
_componentManager = new ComponentManager(_drawLayerManager, _typeToIndex);
|
|
|
|
|
_messageManager = new MessageManager(_timeManager);
|
|
|
|
|
_entityManager = new EntityManager(_componentManager, entityCapacity);
|
|
|
|
|
_renderManager = new RenderManager(_entityManager, _drawLayerManager);
|
|
|
|
|
|
|
|
|
|
_startingExistingComponentStore = new ComponentStore(_typeToIndex);
|
|
|
|
|
_startingUpToDateComponentStore = new ComponentStore(_typeToIndex);
|
2019-06-15 00:03:56 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-10-24 19:48:36 +00:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Creates and returns a new empty Entity.
|
|
|
|
|
/// </summary>
|
2019-06-16 01:05:56 +00:00
|
|
|
|
public Entity CreateEntity()
|
|
|
|
|
{
|
2020-03-20 07:09:57 +00:00
|
|
|
|
return _entityManager.CreateEntity();
|
2019-06-15 00:03:56 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-10-24 19:48:36 +00:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Specifies that the given Message should be sent immediately on the first World Update.
|
|
|
|
|
/// </summary>
|
2020-03-22 20:41:55 +00:00
|
|
|
|
public void SendMessage<TMessage>(in TMessage message) where TMessage : struct, IMessage
|
2019-06-29 05:07:48 +00:00
|
|
|
|
{
|
2020-03-20 07:09:57 +00:00
|
|
|
|
_messageManager.AddMessage(message);
|
2019-06-29 05:07:48 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-10-24 19:48:36 +00:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Specifies that the given Message should be sent after the specified number of seconds after the first World Update.
|
|
|
|
|
/// </summary>
|
2020-03-22 20:41:55 +00:00
|
|
|
|
public void SendMessage<TMessage>(in TMessage message, double time) where TMessage : struct, IMessage
|
2019-08-20 02:05:18 +00:00
|
|
|
|
{
|
2020-03-20 07:09:57 +00:00
|
|
|
|
_messageManager.AddMessage<TMessage>(message, time);
|
2019-08-20 02:05:18 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-10-24 19:48:36 +00:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Sets Component data for the specified Component Type on the specified Entity.
|
|
|
|
|
/// </summary>
|
2020-03-22 05:19:31 +00:00
|
|
|
|
public void SetComponent<TComponent>(Entity entity, in TComponent component) where TComponent : struct
|
2019-07-17 18:24:21 +00:00
|
|
|
|
{
|
2019-12-16 07:28:02 +00:00
|
|
|
|
RegisterComponentType<TComponent>();
|
2020-03-20 07:09:57 +00:00
|
|
|
|
_startingExistingComponentStore.Set(entity.ID, component);
|
|
|
|
|
_startingUpToDateComponentStore.Set(entity.ID, component);
|
2019-12-06 06:32:09 +00:00
|
|
|
|
|
2019-11-21 03:16:44 +00:00
|
|
|
|
if (component is IDrawableComponent drawableComponent)
|
|
|
|
|
{
|
2020-03-20 07:58:33 +00:00
|
|
|
|
_componentManager.RegisterDrawableComponent<TComponent>(entity.ID, drawableComponent.Layer);
|
2020-03-20 07:09:57 +00:00
|
|
|
|
_drawLayerManager.RegisterOrderedDrawable<TComponent>();
|
2019-11-21 03:16:44 +00:00
|
|
|
|
}
|
2019-07-17 18:24:21 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-03-22 00:38:35 +00:00
|
|
|
|
internal void RegisterComponentType<TComponent>() where TComponent : struct
|
2019-12-16 07:28:02 +00:00
|
|
|
|
{
|
2020-03-20 07:09:57 +00:00
|
|
|
|
if (!_typeToIndex.ContainsKey(typeof(TComponent)))
|
2019-12-22 09:15:58 +00:00
|
|
|
|
{
|
2020-03-20 07:09:57 +00:00
|
|
|
|
_typeToIndex.Add(typeof(TComponent), _typeToIndex.Count);
|
|
|
|
|
_componentTypesToPreload.Add(typeof(TComponent));
|
|
|
|
|
_componentManager.RegisterComponentType<TComponent>();
|
|
|
|
|
_startingExistingComponentStore.RegisterComponentType<TComponent>();
|
|
|
|
|
_startingUpToDateComponentStore.RegisterComponentType<TComponent>();
|
2019-12-22 09:15:58 +00:00
|
|
|
|
}
|
2019-12-16 07:28:02 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-12-17 03:55:27 +00:00
|
|
|
|
internal void RegisterMessageTypes(IEnumerable<Type> types)
|
|
|
|
|
{
|
2020-03-20 07:09:57 +00:00
|
|
|
|
_messageTypes.UnionWith(types);
|
2019-12-17 03:55:27 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-10-24 19:48:36 +00:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Adds the specified Engine to the World.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="engine">An instance of an Engine.</param>
|
2019-06-24 19:26:19 +00:00
|
|
|
|
public Engine AddEngine<TEngine>(TEngine engine) where TEngine : Engine
|
2019-06-16 01:05:56 +00:00
|
|
|
|
{
|
2020-03-20 07:09:57 +00:00
|
|
|
|
engine.AssignEntityManager(_entityManager);
|
|
|
|
|
engine.AssignComponentManager(_componentManager);
|
|
|
|
|
engine.AssignMessageManager(_messageManager);
|
|
|
|
|
engine.AssignTimeManager(_timeManager);
|
|
|
|
|
engine.AssignTrackingManager(_trackingManager);
|
2019-06-15 00:51:06 +00:00
|
|
|
|
|
2020-03-20 07:09:57 +00:00
|
|
|
|
_engines.Add(engine);
|
|
|
|
|
_engineGraph.AddNode(engine);
|
2019-06-17 00:56:36 +00:00
|
|
|
|
|
2020-03-20 07:09:57 +00:00
|
|
|
|
var messageReceiveTypes = engine.ReceiveTypes;
|
|
|
|
|
var messageSendTypes = engine.SendTypes;
|
2019-06-17 00:56:36 +00:00
|
|
|
|
|
2020-03-20 07:09:57 +00:00
|
|
|
|
RegisterMessageTypes(engine.ReceiveTypes.Union(engine.SendTypes));
|
2019-12-17 03:55:27 +00:00
|
|
|
|
|
2020-03-20 07:09:57 +00:00
|
|
|
|
foreach (var writeImmediateType in engine.WriteImmediateTypes.Intersect(engine.ReadImmediateTypes))
|
2019-07-18 21:02:57 +00:00
|
|
|
|
{
|
2019-12-24 03:04:26 +00:00
|
|
|
|
throw new EngineSelfCycleException("Engine {0} both writes and reads immediate Component {1}", engine.GetType().Name, writeImmediateType.Name);
|
2019-12-06 03:55:17 +00:00
|
|
|
|
}
|
2019-07-19 23:15:48 +00:00
|
|
|
|
|
2019-12-06 03:55:17 +00:00
|
|
|
|
foreach (var messageType in messageReceiveTypes.Intersect(messageSendTypes))
|
|
|
|
|
{
|
2019-07-19 23:15:48 +00:00
|
|
|
|
throw new EngineSelfCycleException("Engine {0} both receives and sends Message {1}", engine.GetType().Name, messageType.Name);
|
2019-07-18 21:02:57 +00:00
|
|
|
|
}
|
2019-06-17 00:56:36 +00:00
|
|
|
|
|
2020-03-20 07:09:57 +00:00
|
|
|
|
if (messageSendTypes.Count > 0 || engine.WriteImmediateTypes.Count > 0)
|
2019-07-18 21:02:57 +00:00
|
|
|
|
{
|
2020-03-20 07:09:57 +00:00
|
|
|
|
_senders.Add(engine);
|
2019-07-18 21:02:57 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-03-20 07:09:57 +00:00
|
|
|
|
foreach (var componentType in engine.QueryWithTypes.Union(engine.QueryWithoutTypes))
|
2019-12-28 21:53:02 +00:00
|
|
|
|
{
|
2020-03-20 07:09:57 +00:00
|
|
|
|
_trackingManager.RegisterComponentTypeToEngine(componentType, engine);
|
|
|
|
|
if (engine.ReadImmediateTypes.Contains(componentType))
|
2019-12-28 22:30:26 +00:00
|
|
|
|
{
|
2020-03-20 07:09:57 +00:00
|
|
|
|
_trackingManager.RegisterImmediateComponentTypeToEngine(componentType, engine);
|
2019-12-28 22:30:26 +00:00
|
|
|
|
}
|
2019-12-28 21:53:02 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-03-20 07:09:57 +00:00
|
|
|
|
foreach (var receiveType in engine.ReceiveTypes.Union(engine.ReadImmediateTypes))
|
2019-12-06 03:55:17 +00:00
|
|
|
|
{
|
2020-03-20 07:09:57 +00:00
|
|
|
|
if (!_typeToReaders.ContainsKey(receiveType))
|
2019-06-17 00:56:36 +00:00
|
|
|
|
{
|
2020-03-20 07:09:57 +00:00
|
|
|
|
_typeToReaders.Add(receiveType, new HashSet<Engine>());
|
2019-06-29 05:57:18 +00:00
|
|
|
|
}
|
2019-06-17 00:56:36 +00:00
|
|
|
|
|
2020-03-20 07:09:57 +00:00
|
|
|
|
_typeToReaders[receiveType].Add(engine);
|
2019-07-19 19:47:17 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-06-15 00:51:06 +00:00
|
|
|
|
return engine;
|
|
|
|
|
}
|
|
|
|
|
|
2019-12-16 07:28:02 +00:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Registers a draw layer. This must be done before any Renderers are registered.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="layer">The draw layer to register.</param>
|
|
|
|
|
public void RegisterDrawLayer(int layer)
|
|
|
|
|
{
|
2020-07-16 07:10:21 +00:00
|
|
|
|
if (_rendererRegistered)
|
|
|
|
|
{
|
2020-07-10 19:37:10 +00:00
|
|
|
|
throw new IllegalDrawLayerException("Cannot register a draw layer after a Renderer has been registered.");
|
|
|
|
|
}
|
2020-03-20 07:09:57 +00:00
|
|
|
|
_drawLayerManager.RegisterDrawLayer(layer);
|
2019-12-16 07:28:02 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-10-24 19:48:36 +00:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Adds the specified OrderedRenderer to the World.
|
|
|
|
|
/// </summary>
|
2020-03-25 04:28:56 +00:00
|
|
|
|
public OrderedRenderer<TComponent> AddOrderedRenderer<TComponent>(OrderedRenderer<TComponent> renderer) where TComponent : struct, IComponent, IDrawableComponent
|
2019-06-19 21:14:44 +00:00
|
|
|
|
{
|
2020-01-28 22:05:11 +00:00
|
|
|
|
RegisterComponentType<TComponent>();
|
2020-03-20 07:09:57 +00:00
|
|
|
|
renderer.AssignEntityManager(_entityManager);
|
|
|
|
|
renderer.AssignComponentManager(_componentManager);
|
|
|
|
|
_renderManager.RegisterOrderedRenderer<TComponent>(renderer.InternalRender);
|
2020-07-10 19:37:10 +00:00
|
|
|
|
_rendererRegistered = true;
|
2019-06-20 05:38:56 +00:00
|
|
|
|
return renderer;
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-24 19:48:36 +00:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Adds the specified GeneralRenderer to the World at the specified layer.
|
|
|
|
|
/// Higher layer numbers draw on top of lower layer numbers.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="renderer">An instance of a GeneralRenderer.</param>
|
|
|
|
|
/// <param name="layer">The layer at which the GeneralRenderer should render. Higher numbers draw over lower numbers.</param>
|
2019-06-24 23:49:26 +00:00
|
|
|
|
public TRenderer AddGeneralRenderer<TRenderer>(TRenderer renderer, int layer) where TRenderer : GeneralRenderer
|
2019-06-20 05:38:56 +00:00
|
|
|
|
{
|
2020-03-20 07:09:57 +00:00
|
|
|
|
renderer.AssignEntityManager(_entityManager);
|
|
|
|
|
renderer.AssignComponentManager(_componentManager);
|
|
|
|
|
_renderManager.RegisterGeneralRendererWithLayer(renderer, layer);
|
2020-07-10 19:37:10 +00:00
|
|
|
|
_rendererRegistered = true;
|
2019-06-19 21:14:44 +00:00
|
|
|
|
return renderer;
|
|
|
|
|
}
|
|
|
|
|
|
2019-07-18 21:02:57 +00:00
|
|
|
|
private void BuildEngineGraph()
|
|
|
|
|
{
|
2020-03-20 07:09:57 +00:00
|
|
|
|
foreach (var senderEngine in _senders)
|
2019-07-18 21:02:57 +00:00
|
|
|
|
{
|
2020-03-20 07:09:57 +00:00
|
|
|
|
foreach (var messageType in senderEngine.SendTypes.Union(senderEngine.WriteImmediateTypes))
|
2019-07-18 21:02:57 +00:00
|
|
|
|
{
|
2020-03-20 07:09:57 +00:00
|
|
|
|
if (_typeToReaders.ContainsKey(messageType))
|
2019-07-18 21:02:57 +00:00
|
|
|
|
{
|
2020-03-20 07:09:57 +00:00
|
|
|
|
foreach (var readerEngine in _typeToReaders[messageType])
|
2019-07-18 21:02:57 +00:00
|
|
|
|
{
|
2019-07-19 04:07:26 +00:00
|
|
|
|
if (senderEngine != readerEngine)
|
|
|
|
|
{
|
2020-03-20 07:09:57 +00:00
|
|
|
|
if (!_engineGraph.Exists(senderEngine, readerEngine))
|
2019-11-13 21:05:31 +00:00
|
|
|
|
{
|
2020-03-20 07:09:57 +00:00
|
|
|
|
_engineGraph.AddEdge(senderEngine, readerEngine);
|
2019-11-13 21:05:31 +00:00
|
|
|
|
}
|
2019-07-19 04:07:26 +00:00
|
|
|
|
}
|
2019-07-18 21:02:57 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-24 19:48:36 +00:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Builds the World out of the state specified on the WorldBuilder.
|
|
|
|
|
/// Validates and constructs an ordering of the given Engines.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <returns>An instance of World.</returns>
|
2019-06-16 01:05:56 +00:00
|
|
|
|
public World Build()
|
|
|
|
|
{
|
2019-07-18 21:02:57 +00:00
|
|
|
|
BuildEngineGraph();
|
|
|
|
|
|
2020-03-20 07:09:57 +00:00
|
|
|
|
if (_engineGraph.Cyclic())
|
2019-06-17 00:56:36 +00:00
|
|
|
|
{
|
2020-03-20 07:09:57 +00:00
|
|
|
|
var cycles = _engineGraph.SimpleCycles();
|
2019-06-17 00:56:36 +00:00
|
|
|
|
var errorString = "Cycle(s) found in Engines: ";
|
2019-07-19 23:15:48 +00:00
|
|
|
|
foreach (var cycle in cycles)
|
2019-06-17 00:56:36 +00:00
|
|
|
|
{
|
2019-07-19 23:15:48 +00:00
|
|
|
|
var reversed = cycle.Reverse();
|
2019-06-17 00:56:36 +00:00
|
|
|
|
errorString += "\n" +
|
2019-07-19 23:15:48 +00:00
|
|
|
|
string.Join(" -> ", reversed.Select((engine) => engine.GetType().Name)) +
|
2019-06-17 00:56:36 +00:00
|
|
|
|
" -> " +
|
2019-07-19 23:15:48 +00:00
|
|
|
|
reversed.First().GetType().Name;
|
2019-06-17 00:56:36 +00:00
|
|
|
|
}
|
|
|
|
|
throw new EngineCycleException(errorString);
|
|
|
|
|
}
|
|
|
|
|
|
2019-08-21 02:25:59 +00:00
|
|
|
|
var writtenComponentTypesWithoutPriority = new HashSet<Type>();
|
|
|
|
|
var writtenComponentTypesWithPriority = new HashSet<Type>();
|
|
|
|
|
var duplicateWritesWithoutPriority = new List<Type>();
|
2019-08-22 00:54:43 +00:00
|
|
|
|
var duplicateWritesWithSamePriority = new List<Type>();
|
|
|
|
|
var writePriorities = new Dictionary<Type, HashSet<int>>();
|
2019-08-21 02:25:59 +00:00
|
|
|
|
var writeMessageToEngines = new Dictionary<Type, List<Engine>>();
|
2019-06-17 00:56:36 +00:00
|
|
|
|
|
2020-03-20 07:09:57 +00:00
|
|
|
|
foreach (var engine in _engines)
|
2019-06-17 00:56:36 +00:00
|
|
|
|
{
|
2019-11-21 21:53:33 +00:00
|
|
|
|
if (engine.GetType().GetCustomAttribute<IgnoresTimeDilation>() != null)
|
|
|
|
|
{
|
2020-03-20 07:09:57 +00:00
|
|
|
|
engine._usesTimeDilation = false;
|
2019-11-21 21:53:33 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-09-26 20:26:48 +00:00
|
|
|
|
var defaultWritePriorityAttribute = engine.GetType().GetCustomAttribute<DefaultWritePriority>(false);
|
|
|
|
|
|
2020-03-20 07:09:57 +00:00
|
|
|
|
foreach (var writeType in engine.WriteTypes)
|
2019-06-17 00:56:36 +00:00
|
|
|
|
{
|
2019-09-26 20:26:48 +00:00
|
|
|
|
int? priority = null;
|
2020-03-20 07:09:57 +00:00
|
|
|
|
if (engine.WritePriorities.ContainsKey(writeType))
|
2019-06-17 00:56:36 +00:00
|
|
|
|
{
|
2020-03-20 07:09:57 +00:00
|
|
|
|
priority = engine.WritePriorities[writeType];
|
2019-09-26 20:26:48 +00:00
|
|
|
|
}
|
|
|
|
|
else if (defaultWritePriorityAttribute != null)
|
|
|
|
|
{
|
2020-03-20 07:09:57 +00:00
|
|
|
|
priority = defaultWritePriorityAttribute.WritePriority;
|
2019-09-26 20:26:48 +00:00
|
|
|
|
}
|
2019-08-22 00:54:43 +00:00
|
|
|
|
|
2019-09-26 20:26:48 +00:00
|
|
|
|
if (priority.HasValue)
|
|
|
|
|
{
|
2019-12-06 03:55:17 +00:00
|
|
|
|
writtenComponentTypesWithPriority.Add(writeType);
|
2019-08-22 00:54:43 +00:00
|
|
|
|
|
2019-12-06 03:55:17 +00:00
|
|
|
|
if (!writePriorities.ContainsKey(writeType))
|
2019-08-22 00:54:43 +00:00
|
|
|
|
{
|
2019-12-06 03:55:17 +00:00
|
|
|
|
writePriorities[writeType] = new HashSet<int>();
|
2019-08-22 00:54:43 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-12-06 03:55:17 +00:00
|
|
|
|
if (writePriorities[writeType].Contains(priority.Value))
|
2019-08-22 00:54:43 +00:00
|
|
|
|
{
|
2019-12-06 03:55:17 +00:00
|
|
|
|
duplicateWritesWithSamePriority.Add(writeType);
|
2019-08-22 00:54:43 +00:00
|
|
|
|
}
|
2019-12-06 03:55:17 +00:00
|
|
|
|
else if (writtenComponentTypesWithoutPriority.Contains(writeType))
|
2019-08-21 02:25:59 +00:00
|
|
|
|
{
|
2019-12-06 03:55:17 +00:00
|
|
|
|
duplicateWritesWithoutPriority.Add(writeType);
|
2019-08-21 02:25:59 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2019-12-06 03:55:17 +00:00
|
|
|
|
writePriorities[writeType].Add(priority.Value);
|
2019-08-21 02:25:59 +00:00
|
|
|
|
}
|
2019-07-19 23:15:48 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2019-12-06 03:55:17 +00:00
|
|
|
|
if (writtenComponentTypesWithoutPriority.Contains(writeType) || writtenComponentTypesWithPriority.Contains(writeType))
|
2019-08-22 00:54:43 +00:00
|
|
|
|
{
|
2019-12-06 03:55:17 +00:00
|
|
|
|
duplicateWritesWithoutPriority.Add(writeType);
|
2019-08-22 00:54:43 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2019-12-06 03:55:17 +00:00
|
|
|
|
writtenComponentTypesWithoutPriority.Add(writeType);
|
2019-08-22 00:54:43 +00:00
|
|
|
|
}
|
2019-07-19 23:15:48 +00:00
|
|
|
|
}
|
2019-07-19 01:20:38 +00:00
|
|
|
|
|
2019-12-06 03:55:17 +00:00
|
|
|
|
if (!writeMessageToEngines.ContainsKey(writeType))
|
2019-07-19 23:15:48 +00:00
|
|
|
|
{
|
2019-12-06 03:55:17 +00:00
|
|
|
|
writeMessageToEngines[writeType] = new List<Engine>();
|
2019-06-17 00:56:36 +00:00
|
|
|
|
}
|
2019-07-19 23:15:48 +00:00
|
|
|
|
|
2019-12-06 03:55:17 +00:00
|
|
|
|
writeMessageToEngines[writeType].Add(engine);
|
2019-06-17 00:56:36 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2019-08-21 02:25:59 +00:00
|
|
|
|
if (duplicateWritesWithoutPriority.Count > 0)
|
2019-06-17 00:56:36 +00:00
|
|
|
|
{
|
2019-08-21 02:25:59 +00:00
|
|
|
|
var errorString = "Multiple Engines write the same Component without declaring priority: ";
|
|
|
|
|
foreach (var componentType in duplicateWritesWithoutPriority)
|
2019-06-17 00:56:36 +00:00
|
|
|
|
{
|
|
|
|
|
errorString += "\n" +
|
2019-08-21 02:25:59 +00:00
|
|
|
|
componentType.Name + " written by: " +
|
|
|
|
|
string.Join(", ", writeMessageToEngines[componentType].Select((engine) => engine.GetType().Name));
|
2019-06-17 00:56:36 +00:00
|
|
|
|
}
|
2019-09-26 20:26:48 +00:00
|
|
|
|
errorString += "\nTo resolve the conflict, add priority arguments to the Writes declarations or use a DefaultWritePriority attribute.";
|
2019-06-17 00:56:36 +00:00
|
|
|
|
|
2019-08-21 02:25:59 +00:00
|
|
|
|
throw new EngineWriteConflictException(errorString);
|
2019-06-17 00:56:36 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-08-22 00:54:43 +00:00
|
|
|
|
if (duplicateWritesWithSamePriority.Count > 0)
|
2019-06-17 00:56:36 +00:00
|
|
|
|
{
|
2019-08-22 00:54:43 +00:00
|
|
|
|
var errorString = "Multiple Engines write the same Component with the same priority: ";
|
|
|
|
|
foreach (var componentType in duplicateWritesWithSamePriority)
|
2019-06-17 00:56:36 +00:00
|
|
|
|
{
|
|
|
|
|
errorString += "\n" +
|
2019-08-22 00:54:43 +00:00
|
|
|
|
componentType.Name + " written by: " +
|
|
|
|
|
string.Join(", ", writeMessageToEngines[componentType].Select(engine => engine.GetType().Name));
|
2019-06-17 00:56:36 +00:00
|
|
|
|
}
|
2019-09-26 20:26:48 +00:00
|
|
|
|
errorString += "\nTo resolve the conflict, add priority arguments to the Writes declarations or use a DefaultWritePriority attribute.";
|
2019-06-17 00:56:36 +00:00
|
|
|
|
|
2019-08-22 00:54:43 +00:00
|
|
|
|
throw new EngineWriteConflictException(errorString);
|
2019-06-17 00:56:36 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-03-25 04:28:56 +00:00
|
|
|
|
PreloadJIT(_messageTypes);
|
2020-03-18 20:49:37 +00:00
|
|
|
|
|
|
|
|
|
var engineOrder = new List<Engine>();
|
2019-12-22 09:15:58 +00:00
|
|
|
|
|
2020-03-20 07:09:57 +00:00
|
|
|
|
foreach (var engine in _engineGraph.TopologicalSort())
|
2019-06-17 00:56:36 +00:00
|
|
|
|
{
|
|
|
|
|
engineOrder.Add(engine);
|
2019-12-23 02:13:35 +00:00
|
|
|
|
engine.BuildEntityQuery();
|
2019-06-17 00:56:36 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-06-15 00:51:06 +00:00
|
|
|
|
var world = new World(
|
2019-06-17 00:56:36 +00:00
|
|
|
|
engineOrder,
|
2020-03-20 07:09:57 +00:00
|
|
|
|
_entityManager,
|
|
|
|
|
_componentManager,
|
|
|
|
|
_trackingManager,
|
|
|
|
|
_messageManager,
|
|
|
|
|
_timeManager,
|
|
|
|
|
_renderManager
|
2019-06-15 00:51:06 +00:00
|
|
|
|
);
|
2019-06-15 00:03:56 +00:00
|
|
|
|
|
2020-03-20 07:09:57 +00:00
|
|
|
|
_componentManager.SetExistingComponentStore(_startingExistingComponentStore);
|
|
|
|
|
_componentManager.SetUpToDateComponentStore(_startingUpToDateComponentStore);
|
2019-07-18 01:53:31 +00:00
|
|
|
|
|
2020-03-20 07:09:57 +00:00
|
|
|
|
_trackingManager.InitializeTracking(_entityManager.EntityIDs);
|
2019-12-28 21:53:02 +00:00
|
|
|
|
|
2019-06-15 00:03:56 +00:00
|
|
|
|
return world;
|
|
|
|
|
}
|
2019-12-16 22:51:12 +00:00
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// This is necessary because Encompass heavily uses generic methods with value types,
|
|
|
|
|
/// so the first time any code path runs the JIT gets smashed. This method warms up the runtime.
|
2019-12-20 19:10:42 +00:00
|
|
|
|
/// It does so by grabbing all component and message types known to the WorldBuilder and
|
2019-12-17 04:40:15 +00:00
|
|
|
|
/// executing every possible generic method that could be executed with those types.
|
2019-12-16 22:51:12 +00:00
|
|
|
|
/// </summary>
|
2020-03-25 04:28:56 +00:00
|
|
|
|
private void PreloadJIT(IEnumerable<Type> messageTypes)
|
2019-12-16 22:51:12 +00:00
|
|
|
|
{
|
2019-12-17 02:51:45 +00:00
|
|
|
|
var dummyTimeManager = new TimeManager();
|
|
|
|
|
var dummyMessageManager = new MessageManager(dummyTimeManager);
|
2020-03-20 07:58:33 +00:00
|
|
|
|
var dummyDrawLayerManager = new DrawLayerManager();
|
2019-12-29 00:16:21 +00:00
|
|
|
|
var dummyTrackingManager = new TrackingManager();
|
2020-03-20 07:09:57 +00:00
|
|
|
|
var dummyComponentManager = new ComponentManager(dummyDrawLayerManager, _typeToIndex);
|
|
|
|
|
var dummyEntityManager = new EntityManager(dummyComponentManager, _entityCapacity);
|
2019-12-24 02:45:49 +00:00
|
|
|
|
var dummyRenderManager = new RenderManager(dummyEntityManager, dummyDrawLayerManager);
|
2019-12-17 02:51:45 +00:00
|
|
|
|
|
2020-03-25 04:28:56 +00:00
|
|
|
|
// doing reflection to grab all component types, because not all writes need to be declared
|
|
|
|
|
foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
|
|
|
|
|
{
|
|
|
|
|
foreach (var componentType in assembly.GetTypes())
|
|
|
|
|
{
|
|
|
|
|
if (typeof(IComponent).IsAssignableFrom(componentType) && componentType.IsValueType && !componentType.IsEnum && !componentType.IsPrimitive)
|
|
|
|
|
{
|
|
|
|
|
var method = typeof(WorldBuilder).GetMethod("RegisterComponentType", BindingFlags.NonPublic | BindingFlags.Instance);
|
|
|
|
|
var generic = method.MakeGenericMethod(componentType);
|
|
|
|
|
generic.Invoke(this, null);
|
2020-03-25 18:52:42 +00:00
|
|
|
|
|
|
|
|
|
var dummyRegisterMethod = typeof(ComponentManager).GetMethod("RegisterComponentType", BindingFlags.Public | BindingFlags.Instance);
|
|
|
|
|
var dummyGeneric = dummyRegisterMethod.MakeGenericMethod(componentType);
|
|
|
|
|
dummyGeneric.Invoke(dummyComponentManager, null);
|
2020-03-25 04:28:56 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (componentType.GetInterface("IDrawableComponent") != null)
|
|
|
|
|
{
|
2020-07-16 07:10:21 +00:00
|
|
|
|
// register draw layer using property value
|
|
|
|
|
var instance = Activator.CreateInstance(componentType);
|
|
|
|
|
var layerPropertyInfo = componentType.GetProperty("Layer");
|
|
|
|
|
dummyDrawLayerManager.RegisterDrawLayer((int)layerPropertyInfo.GetValue(instance));
|
|
|
|
|
|
2020-03-25 04:28:56 +00:00
|
|
|
|
var drawLayerManagerRegisterMethod = typeof(DrawLayerManager).GetMethod("RegisterOrderedDrawable");
|
|
|
|
|
var drawLayerManagerRegisterGenericMethod = drawLayerManagerRegisterMethod.MakeGenericMethod(componentType);
|
|
|
|
|
drawLayerManagerRegisterGenericMethod.Invoke(dummyDrawLayerManager, null);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2019-12-17 02:51:45 +00:00
|
|
|
|
var prepEngineOrder = new List<Engine>();
|
2019-12-17 04:16:46 +00:00
|
|
|
|
|
2020-03-25 04:28:56 +00:00
|
|
|
|
var uberEngine = new UberEngine(_componentTypesToPreload, messageTypes);
|
2019-12-17 02:51:45 +00:00
|
|
|
|
|
|
|
|
|
uberEngine.AssignEntityManager(dummyEntityManager);
|
|
|
|
|
uberEngine.AssignComponentManager(dummyComponentManager);
|
|
|
|
|
uberEngine.AssignMessageManager(dummyMessageManager);
|
|
|
|
|
uberEngine.AssignTimeManager(dummyTimeManager);
|
2019-12-28 21:53:02 +00:00
|
|
|
|
uberEngine.AssignTrackingManager(dummyTrackingManager);
|
2019-12-17 02:51:45 +00:00
|
|
|
|
|
2020-03-25 04:28:56 +00:00
|
|
|
|
var uberRenderer = new UberRenderer(_componentTypesToPreload);
|
2019-12-17 04:16:46 +00:00
|
|
|
|
uberRenderer.AssignComponentManager(dummyComponentManager);
|
|
|
|
|
uberRenderer.AssignEntityManager(dummyEntityManager);
|
|
|
|
|
|
2019-12-17 02:51:45 +00:00
|
|
|
|
prepEngineOrder.Add(uberEngine);
|
2019-12-16 22:51:12 +00:00
|
|
|
|
|
2019-12-17 02:51:45 +00:00
|
|
|
|
var dummyWorld = new World(
|
|
|
|
|
prepEngineOrder,
|
|
|
|
|
dummyEntityManager,
|
|
|
|
|
dummyComponentManager,
|
2019-12-28 21:53:02 +00:00
|
|
|
|
dummyTrackingManager,
|
2019-12-17 02:51:45 +00:00
|
|
|
|
dummyMessageManager,
|
|
|
|
|
dummyTimeManager,
|
|
|
|
|
dummyRenderManager
|
|
|
|
|
);
|
2019-12-16 22:51:12 +00:00
|
|
|
|
|
2019-12-17 02:51:45 +00:00
|
|
|
|
uberEngine.Write();
|
|
|
|
|
dummyComponentManager.WriteComponents();
|
2019-12-16 22:51:12 +00:00
|
|
|
|
|
|
|
|
|
dummyWorld.Update(1);
|
2019-12-17 04:16:46 +00:00
|
|
|
|
|
|
|
|
|
uberEngine.Write();
|
|
|
|
|
dummyComponentManager.WriteComponents();
|
|
|
|
|
|
2019-12-24 02:45:49 +00:00
|
|
|
|
uberRenderer.SetEntity(uberEngine.Entity);
|
2019-12-17 04:16:46 +00:00
|
|
|
|
uberRenderer.Render();
|
2019-12-16 22:51:12 +00:00
|
|
|
|
}
|
2019-06-15 00:03:56 +00:00
|
|
|
|
}
|
|
|
|
|
}
|