encompass-cs/encompass-cs/RenderManager.cs

using System;
using System.Reflection;
using System.Collections.Generic;

namespace Encompass
{ 
    internal class RenderManager
    {
        private EntityManager entityManager;
        private ComponentManager componentManager;

        private SortedList<int, int> layerOrder = new SortedList<int, int>();
        private Dictionary<int, HashSet<Guid>> layerIndexToComponentIDs = new Dictionary<int, HashSet<Guid>>();
        private Dictionary<int, HashSet<GeneralRenderer>> layerIndexToGeneralRenderers = new Dictionary<int, HashSet<GeneralRenderer>>();

        private Dictionary<Type, EntityRenderer> drawComponentTypeToEntityRenderer = new Dictionary<Type, EntityRenderer>();

        public RenderManager(EntityManager entityManager, ComponentManager componentManager)
        {
            this.entityManager = entityManager;
            this.componentManager = componentManager;
        }

        public void RegisterEntityRenderer(EntityRenderer renderer)
        {
            var rendersAttribute = renderer.GetType().GetCustomAttribute<Renders>(false);
            if (rendersAttribute != null)
            {
                drawComponentTypeToEntityRenderer.Add(rendersAttribute.drawComponentType, renderer);
            }
        }

        public void RegisterGeneralRendererWithLayer(GeneralRenderer renderer, int layer)
        {
            if (layerIndexToGeneralRenderers.ContainsKey(layer))
            {
                var set = layerIndexToGeneralRenderers[layer];
                set.Add(renderer);
            }
            else
            {
                var set = new HashSet<GeneralRenderer>();
                layerIndexToGeneralRenderers.Add(layer, set);
                set.Add(renderer);
            }

            if (!layerOrder.ContainsKey(layer))
            {
                layerOrder.Add(layer, layer);
            }
        }

        public void UnregisterGeneralRendererWithLayer(GeneralRenderer renderer, int layer)
        {
            if (layerIndexToGeneralRenderers.ContainsKey(layer))
            {
                layerIndexToGeneralRenderers[layer].Remove(renderer);
            }
        }

        public void AdjustRendererLayer(GeneralRenderer renderer, int oldLayer, int newLayer)
        {
            UnregisterGeneralRendererWithLayer(renderer, oldLayer);
            RegisterGeneralRendererWithLayer(renderer, newLayer);
        }

        public void RegisterComponentWithLayer(Guid id, int layer)
        {
            if (layerIndexToComponentIDs.ContainsKey(layer))
            {
                var set = layerIndexToComponentIDs[layer];
                set.Add(id);
            }
            else
            {
                var set = new HashSet<Guid>();
                layerIndexToComponentIDs.Add(layer, set);
                set.Add(id);
            }

            if (!layerOrder.ContainsKey(layer))
            {
                layerOrder.Add(layer, layer);
            }
        }

        public void UnRegisterComponentWithLayer(Guid id, int layer)
        {
            if (layerIndexToComponentIDs.ContainsKey(layer))
            {
                layerIndexToComponentIDs[layer].Remove(id);
            }
        }

        public void AdjustComponentLayer(Guid id, int oldLayer, int newLayer)
        {
            UnRegisterComponentWithLayer(id, oldLayer);
            RegisterComponentWithLayer(id, newLayer);
        }

        public void Draw()
        {
            foreach (var layerKVPair in layerOrder)
            {
                var layer = layerKVPair.Key;
                var componentIDSet = layerIndexToComponentIDs[layer];
                var generalRendererSet = layerIndexToGeneralRenderers[layer];

                foreach (var componentID in componentIDSet)
                {
                    var component = componentManager.GetComponentByID(componentID);
                    var componentType = componentManager.GetComponentTypeByID(componentID);

                    if (drawComponentTypeToEntityRenderer.ContainsKey(componentType))
                    {
                        var renderer = drawComponentTypeToEntityRenderer[componentType];
                        var entityID = componentManager.GetEntityIDFromComponentID(componentID);

                        if (renderer.IsTracking(entityID))
                        {
                            var entity = entityManager.GetEntity(entityID);
                            renderer.Render(entity);
                        }
                    }
                }

                foreach (var generalRenderer in generalRendererSet)
                {
                    generalRenderer.Render();
                }
            }
        }
    }
}