コード例 #1
0
        public static List <LayerComponentMapping> SortComponents(TerrainWrapper wrapper, string layerFilter)
        {
            Profiler.BeginSample("CollectAndOrganise");

            // Collect all layerComponents that lie within the bounds of the TerrainWrapper and satisfy the layerFilter (if one is specified)
            var allLayerComponents = new List <LayerComponentBase>(Object.FindObjectsOfType <LayerComponentBase>());
            var tBounds            = new Bounds(wrapper.Terrain.GetPosition() + wrapper.Terrain.terrainData.size / 2,
                                                wrapper.Terrain.terrainData.size);

            for (var i = allLayerComponents.Count - 1; i >= 0; i--)
            {
                var layerComponent = allLayerComponents[i];

                if (!String.IsNullOrEmpty(layerFilter) && layerComponent.GetLayerName() != layerFilter)
                {
                    allLayerComponents.RemoveAt(i);
                    continue;
                }

                if (!layerComponent.GetEnabled())
                {
                    allLayerComponents.RemoveAt(i);
                    continue;
                }

                var stampBounds = new ObjectBounds(layerComponent.transform.position, layerComponent.Size / 2,
                                                   layerComponent.transform.rotation);
                var axisStampBounds = stampBounds.ToAxisBounds();
                if (!tBounds.Intersects(axisStampBounds))
                {
                    allLayerComponents.RemoveAt(i);
                }
            }

            // Sort the Components into what layer they each point to
            List <LayerComponentMapping> mappings = new List <LayerComponentMapping>();

            for (int i = 0; i < allLayerComponents.Count; i++)
            {
                var component = allLayerComponents[i];
                LayerComponentMapping mapping = null;
                foreach (var layerStampMapping in mappings)
                {
                    if (layerStampMapping.LayerName == component.GetLayerName())
                    {
                        mapping = layerStampMapping;
                        break;
                    }
                }
                if (mapping == null)
                {
                    mapping = new LayerComponentMapping()
                    {
                        LayerIndex = wrapper.GetLayerIndex(component.GetLayerName()),
                        LayerName  = component.GetLayerName()
                    };
                    mappings.Add(mapping);
                }
                mapping.Components.Add(component);
            }

            // Sort this mapping by layer index, then the contents of the mappings by priority
            mappings = mappings.OrderByDescending(mapping => mapping.LayerIndex).ToList();
            for (int i = 0; i < mappings.Count; i++)
            {
                mappings[i].Components = mappings[i].Components.OrderBy(component => component.GetPriority())
                                         .ThenBy(component => component.transform.GetSiblingIndex())
                                         .ToList();
            }

            // Go through and create new layers as needed
            HashSet <LayerBase> cache = new HashSet <LayerBase>();

            for (int i = mappings.Count - 1; i >= 0; i--)
            {
                var layerStampMapping = mappings[i];
                for (var j = 0; j < layerStampMapping.Components.Count; ++j)
                {
                    var component = layerStampMapping.Components[j];
                    var type      = component.GetLayerType();
                    var layer     = wrapper.GetLayer(type, layerStampMapping.LayerName, false, true);
                    if (cache.Contains(layer))
                    {
                        continue;
                    }
                    cache.Add(layer);

                    if (layer.Locked)
                    {
                        Debug.LogWarningFormat(layer, "Attempted to write to layer {0} but it was locked!", layer.name);
                        mappings.RemoveAt(i);
                        continue;
                    }

                    layer.Clear(wrapper);
                    layer.PrepareApply(wrapper, wrapper.GetLayerIndex(layer));
                }
            }
            Profiler.EndSample();
            return(mappings);
        }