Add IResourceRenderer interface.

OpenRA.Mods.Common/EditorBrushes/EditorResourceBrush.cs

@@ -29,10 +29,10 @@ namespace OpenRA.Mods.Common.Widgets
 		AddResourcesEditorAction action;
 		bool resourceAdded;
 
-		public EditorResourceBrush(EditorViewportControllerWidget editorWidget, ResourceTypeInfo resource, WorldRenderer wr)
+		public EditorResourceBrush(EditorViewportControllerWidget editorWidget, ResourceType resource, WorldRenderer wr)
 		{
 			this.editorWidget = editorWidget;
-			ResourceType = resource;
+			ResourceType = resource.Info;
 			worldRenderer = wr;
 			world = wr.World;
 			editorActionManager = world.WorldActor.Trait<EditorActionManager>();

OpenRA.Mods.Common/Traits/Harvester.cs

@@ -386,7 +386,7 @@ namespace OpenRA.Mods.Common.Traits
 					return false;
 
 				var info = self.Info.TraitInfo<HarvesterInfo>();
-				var res = self.World.WorldActor.TraitsImplementing<ResourceRenderer>()
+				var res = self.World.WorldActor.TraitsImplementing<IResourceRenderer>()
 					.Select(r => r.GetRenderedResourceType(location))
 					.FirstOrDefault(r => r != null && info.Resources.Contains(r.Info.Type));
 

OpenRA.Mods.Common/Traits/World/EditorCursorLayer.cs

@@ -27,12 +27,13 @@ namespace OpenRA.Mods.Common.Traits
 		public override object Create(ActorInitializer init) { return new EditorCursorLayer(init.Self, this); }
 	}
 
-	public class EditorCursorLayer : ITickRender, IRenderAboveShroud, IRenderAnnotations
+	public class EditorCursorLayer : IWorldLoaded, ITickRender, IRenderAboveShroud, IRenderAnnotations
 	{
 		readonly EditorCursorLayerInfo info;
 		readonly EditorActorLayer editorLayer;
 		readonly ITiledTerrainRenderer terrainRenderer;
 		readonly World world;
+		IResourceRenderer[] resourceRenderers;
 
 		public int CurrentToken { get; private set; }
 		public EditorCursorType Type { get; private set; }
@@ -43,7 +44,7 @@ namespace OpenRA.Mods.Common.Traits
 		bool actorSharesCell;
 
 		public TerrainTemplateInfo TerrainTemplate { get; private set; }
-		public ResourceTypeInfo Resource { get; private set; }
+		public ResourceType Resource { get; private set; }
 		CPos terrainOrResourceCell;
 		bool terrainOrResourceDirty;
 		readonly List<IRenderable> terrainOrResourcePreview = new List<IRenderable>();
@@ -58,6 +59,11 @@ namespace OpenRA.Mods.Common.Traits
 			Type = EditorCursorType.None;
 		}
 
+		void IWorldLoaded.WorldLoaded(World w, WorldRenderer wr)
+		{
+			resourceRenderers = w.WorldActor.TraitsImplementing<IResourceRenderer>().ToArray();
+		}
+
 		void ITickRender.TickRender(WorldRenderer wr, Actor self)
 		{
 			if (wr.World.Type != WorldType.Editor)
@@ -71,21 +77,12 @@ namespace OpenRA.Mods.Common.Traits
 					terrainOrResourceCell = cell;
 					terrainOrResourceDirty = false;
 					terrainOrResourcePreview.Clear();
-					var pos = world.Map.CenterOfCell(cell);
 
+					var pos = world.Map.CenterOfCell(cell);
 					if (Type == EditorCursorType.TerrainTemplate)
 						terrainOrResourcePreview.AddRange(terrainRenderer.RenderPreview(wr, TerrainTemplate, pos));
 					else
-					{
+						terrainOrResourcePreview.AddRange(resourceRenderers.SelectMany(r => r.RenderPreview(wr, Resource, pos)));
-						var variant = Resource.Sequences.FirstOrDefault();
-						var sequence = wr.World.Map.Rules.Sequences.GetSequence("resources", variant);
-						var sprite = sequence.GetSprite(Resource.MaxDensity - 1);
-						var palette = wr.Palette(Resource.Palette);
-						var alpha = sequence.GetAlpha(Resource.MaxDensity - 1);
-
-						var tintModifiers = sequence.IgnoreWorldTint ? TintModifiers.IgnoreWorldTint : TintModifiers.None;
-						terrainOrResourcePreview.Add(new SpriteRenderable(sprite, pos, WVec.Zero, 0, palette, 1f, alpha, float3.Ones, tintModifiers, false));
-					}
 				}
 			}
 			else if (Type == EditorCursorType.Actor)
@@ -202,7 +199,7 @@ namespace OpenRA.Mods.Common.Traits
 			return ++CurrentToken;
 		}
 
-		public int SetResource(WorldRenderer wr, ResourceTypeInfo resource)
+		public int SetResource(WorldRenderer wr, ResourceType resource)
 		{
 			terrainOrResourceCell = wr.Viewport.ViewToWorld(wr.Viewport.WorldToViewPx(Viewport.LastMousePos));
 

OpenRA.Mods.Common/Traits/World/ResourceRenderer.cs

@@ -28,11 +28,12 @@ namespace OpenRA.Mods.Common.Traits
 		public override object Create(ActorInitializer init) { return new ResourceRenderer(init.Self, this); }
 	}
 
-	public class ResourceRenderer : IWorldLoaded, IRenderOverlay, ITickRender, INotifyActorDisposing
+	public class ResourceRenderer : IResourceRenderer, IWorldLoaded, IRenderOverlay, ITickRender, INotifyActorDisposing
 	{
 		protected readonly IResourceLayer ResourceLayer;
 		protected readonly CellLayer<RendererCellContents> RenderContent;
 		protected readonly ResourceRendererInfo Info;
+		protected readonly World World;
 
 		readonly HashSet<CPos> dirty = new HashSet<CPos>();
 		readonly Queue<CPos> cleanDirty = new Queue<CPos>();
@@ -42,7 +43,7 @@ namespace OpenRA.Mods.Common.Traits
 		public ResourceRenderer(Actor self, ResourceRendererInfo info)
 		{
 			Info = info;
-
+			World = self.World;
 			ResourceLayer = self.Trait<IResourceLayer>();
 			ResourceLayer.CellChanged += AddDirtyCell;
 
@@ -198,7 +199,43 @@ namespace OpenRA.Mods.Common.Traits
 			return t.Variants.Keys.Random(Game.CosmeticRandom);
 		}
 
-		public ResourceType GetRenderedResourceType(CPos cell) { return RenderContent[cell].Type; }
+		protected virtual ResourceType GetRenderedResourceType(CPos cell) { return RenderContent[cell].Type; }
+
+		protected virtual string GetRenderedResourceTooltip(CPos cell) { return RenderContent[cell].Type?.Info.Name; }
+
+		IEnumerable<ResourceType> IResourceRenderer.ResourceTypes => World.WorldActor.TraitsImplementing<ResourceType>();
+
+		ResourceType IResourceRenderer.GetRenderedResourceType(CPos cell) { return GetRenderedResourceType(cell); }
+
+		string IResourceRenderer.GetRenderedResourceTooltip(CPos cell) { return GetRenderedResourceTooltip(cell); }
+
+		IEnumerable<IRenderable> IResourceRenderer.RenderUIPreview(WorldRenderer wr, ResourceType resourceType, int2 origin, float scale)
+		{
+			var sequence = resourceType.Variants.First().Value;
+			var sprite = sequence.GetSprite(sequence.Length - 1);
+			var shadow = sequence.GetShadow(sequence.Length - 1, WAngle.Zero);
+			var palette = resourceType.Palette;
+
+			if (shadow != null)
+				yield return new UISpriteRenderable(shadow, WPos.Zero, origin, 0, palette, scale);
+
+			yield return new UISpriteRenderable(sprite, WPos.Zero, origin, 0, palette, scale);
+		}
+
+		IEnumerable<IRenderable> IResourceRenderer.RenderPreview(WorldRenderer wr, ResourceType resourceType, WPos origin)
+		{
+			var sequence = resourceType.Variants.First().Value;
+			var sprite = sequence.GetSprite(sequence.Length - 1);
+			var shadow = sequence.GetShadow(sequence.Length - 1, WAngle.Zero);
+			var alpha = sequence.GetAlpha(sequence.Length - 1);
+			var palette = resourceType.Palette;
+			var tintModifiers = sequence.IgnoreWorldTint ? TintModifiers.IgnoreWorldTint : TintModifiers.None;
+
+			if (shadow != null)
+				yield return new SpriteRenderable(shadow, origin, WVec.Zero, 0, palette, sequence.Scale, alpha, float3.Ones, tintModifiers, false);
+
+			yield return new SpriteRenderable(sprite, origin, WVec.Zero, 0, palette, sequence.Scale, alpha, float3.Ones, tintModifiers, false);
+		}
 
 		public readonly struct RendererCellContents
 		{

OpenRA.Mods.Common/TraitsInterfaces.cs

@@ -662,4 +662,14 @@ namespace OpenRA.Mods.Common.Traits
 		IEnumerable<IRenderable> RenderUIPreview(WorldRenderer wr, TerrainTemplateInfo template, int2 origin, float scale);
 		IEnumerable<IRenderable> RenderPreview(WorldRenderer wr, TerrainTemplateInfo template, WPos origin);
 	}
+
+	[RequireExplicitImplementation]
+	public interface IResourceRenderer
+	{
+		IEnumerable<ResourceType> ResourceTypes { get; }
+		ResourceType GetRenderedResourceType(CPos cell);
+		string GetRenderedResourceTooltip(CPos cell);
+		IEnumerable<IRenderable> RenderUIPreview(WorldRenderer wr, ResourceType resourceType, int2 origin, float scale);
+		IEnumerable<IRenderable> RenderPreview(WorldRenderer wr, ResourceType resourceType, WPos origin);
+	}
 }

OpenRA.Mods.Common/Widgets/Logic/Editor/LayerSelectorLogic.cs

@@ -43,35 +43,30 @@ namespace OpenRA.Mods.Common.Widgets.Logic
 		{
 			layerTemplateList.RemoveChildren();
 			var rules = worldRenderer.World.Map.Rules;
-			var resources = rules.Actors["world"].TraitInfos<ResourceTypeInfo>();
 			var tileSize = worldRenderer.World.Map.Grid.TileSize;
-			foreach (var resource in resources)
+			foreach (var resourceRenderer in worldRenderer.World.WorldActor.TraitsImplementing<IResourceRenderer>())
 			{
-				var newResourcePreviewTemplate = ScrollItemWidget.Setup(layerPreviewTemplate,
+				foreach (var resourceType in resourceRenderer.ResourceTypes)
-					() => editorCursor.Type == EditorCursorType.Resource && editorCursor.Resource == resource,
+				{
-					() => editor.SetBrush(new EditorResourceBrush(editor, resource, worldRenderer)));
+					var newResourcePreviewTemplate = ScrollItemWidget.Setup(layerPreviewTemplate,
+						() => editorCursor.Type == EditorCursorType.Resource && editorCursor.Resource == resourceType,
+						() => editor.SetBrush(new EditorResourceBrush(editor, resourceType, worldRenderer)));
 
-				newResourcePreviewTemplate.Bounds.X = 0;
+					newResourcePreviewTemplate.Bounds.X = 0;
-				newResourcePreviewTemplate.Bounds.Y = 0;
+					newResourcePreviewTemplate.Bounds.Y = 0;
 
-				var layerPreview = newResourcePreviewTemplate.Get<SpriteWidget>("LAYER_PREVIEW");
+					var layerPreview = newResourcePreviewTemplate.Get<ResourcePreviewWidget>("LAYER_PREVIEW");
-				layerPreview.IsVisible = () => true;
+					layerPreview.IsVisible = () => true;
-				layerPreview.GetPalette = () => resource.Palette;
+					layerPreview.ResourceType = resourceType;
+					layerPreview.Bounds.Width = tileSize.Width;
+					layerPreview.Bounds.Height = tileSize.Height;
+					newResourcePreviewTemplate.Bounds.Width = tileSize.Width + (layerPreview.Bounds.X * 2);
+					newResourcePreviewTemplate.Bounds.Height = tileSize.Height + (layerPreview.Bounds.Y * 2);
+					newResourcePreviewTemplate.IsVisible = () => true;
+					newResourcePreviewTemplate.GetTooltipText = () => resourceType.Info.Type;
 
-				var variant = resource.Sequences.FirstOrDefault();
+					layerTemplateList.AddChild(newResourcePreviewTemplate);
-				var sequence = rules.Sequences.GetSequence("resources", variant);
+				}
-				var frame = sequence.Frames?.Last() ?? resource.MaxDensity - 1;
-				layerPreview.GetSprite = () => sequence.GetSprite(frame);
-
-				layerPreview.Bounds.Width = tileSize.Width;
-				layerPreview.Bounds.Height = tileSize.Height;
-				newResourcePreviewTemplate.Bounds.Width = tileSize.Width + (layerPreview.Bounds.X * 2);
-				newResourcePreviewTemplate.Bounds.Height = tileSize.Height + (layerPreview.Bounds.Y * 2);
-
-				newResourcePreviewTemplate.IsVisible = () => true;
-				newResourcePreviewTemplate.GetTooltipText = () => resource.Type;
-
-				layerTemplateList.AddChild(newResourcePreviewTemplate);
 			}
 		}
 	}

OpenRA.Mods.Common/Widgets/Logic/Ingame/WorldTooltipLogic.cs

@@ -57,7 +57,7 @@ namespace OpenRA.Mods.Common.Widgets.Logic
 						labelText = "Unrevealed Terrain";
 						break;
 					case WorldTooltipType.Resource:
-						labelText = viewport.ResourceTooltip.Info.Name;
+						labelText = viewport.ResourceTooltip;
 						break;
 					case WorldTooltipType.Actor:
 						{

OpenRA.Mods.Common/Widgets/ResourcePreviewWidget.cs

@@ -0,0 +1,80 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2021 The OpenRA Developers (see AUTHORS)
+ * This file is part of OpenRA, which is free software. It is made
+ * available to you under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version. For more
+ * information, see COPYING.
+ */
+#endregion
+
+using System;
+using System.IO;
+using System.Linq;
+using OpenRA.Graphics;
+using OpenRA.Mods.Common.Terrain;
+using OpenRA.Mods.Common.Traits;
+using OpenRA.Primitives;
+using OpenRA.Widgets;
+
+namespace OpenRA.Mods.Common.Widgets
+{
+	public class ResourcePreviewWidget : Widget
+	{
+		public Func<float> GetScale = () => 1f;
+
+		readonly WorldRenderer worldRenderer;
+		readonly IResourceRenderer[] resourceRenderers;
+		readonly Size tileSize;
+
+		ResourceType resourceType;
+		IResourceRenderer resourceRenderer;
+
+		public ResourceType ResourceType
+		{
+			get => resourceType;
+
+			set
+			{
+				resourceType = value;
+				if (resourceType != null)
+					resourceRenderer = resourceRenderers.FirstOrDefault(r => r.ResourceTypes.Contains(resourceType));
+				else
+					resourceRenderer = null;
+			}
+		}
+
+		[ObjectCreator.UseCtor]
+		public ResourcePreviewWidget(WorldRenderer worldRenderer, World world)
+		{
+			this.worldRenderer = worldRenderer;
+			resourceRenderers = world.WorldActor.TraitsImplementing<IResourceRenderer>().ToArray();
+			tileSize = world.Map.Grid.TileSize;
+		}
+
+		protected ResourcePreviewWidget(ResourcePreviewWidget other)
+			: base(other)
+		{
+			GetScale = other.GetScale;
+			worldRenderer = other.worldRenderer;
+			resourceRenderers = other.resourceRenderers;
+			tileSize = other.tileSize;
+			resourceType = other.resourceType;
+			resourceRenderer = other.resourceRenderer;
+		}
+
+		public override Widget Clone() { return new ResourcePreviewWidget(this); }
+
+		public override void Draw()
+		{
+			if (resourceRenderer == null)
+				return;
+
+			var scale = GetScale();
+			var origin = RenderOrigin + new int2((RenderBounds.Size.Width - tileSize.Width) / 2, (RenderBounds.Size.Height - tileSize.Height) / 2);
+			foreach (var r in resourceRenderer.RenderUIPreview(worldRenderer, resourceType, origin, scale))
+				r.PrepareRender(worldRenderer).Render(worldRenderer);
+		}
+	}
+}

OpenRA.Mods.Common/Widgets/ViewportControllerWidget.cs

@@ -25,7 +25,7 @@ namespace OpenRA.Mods.Common.Widgets
 	public class ViewportControllerWidget : Widget
 	{
 		readonly ModData modData;
-		readonly IEnumerable<ResourceRenderer> resourceRenderers;
+		readonly IEnumerable<IResourceRenderer> resourceRenderers;
 
 		public readonly HotkeyReference ZoomInKey = new HotkeyReference();
 		public readonly HotkeyReference ZoomOutKey = new HotkeyReference();
@@ -52,7 +52,7 @@ namespace OpenRA.Mods.Common.Widgets
 		public ITooltip ActorTooltip { get; private set; }
 		public IProvideTooltipInfo[] ActorTooltipExtra { get; private set; }
 		public FrozenActor FrozenActorTooltip { get; private set; }
-		public ResourceType ResourceTooltip { get; private set; }
+		public string ResourceTooltip { get; private set; }
 
 		static readonly Dictionary<ScrollDirection, string> ScrollCursors = new Dictionary<ScrollDirection, string>
 		{
@@ -145,7 +145,7 @@ namespace OpenRA.Mods.Common.Widgets
 			tooltipContainer = Exts.Lazy(() =>
 				Ui.Root.Get<TooltipContainerWidget>(TooltipContainer));
 
-			resourceRenderers = world.WorldActor.TraitsImplementing<ResourceRenderer>().ToArray();
+			resourceRenderers = world.WorldActor.TraitsImplementing<IResourceRenderer>().ToArray();
 		}
 
 		public override void Initialize(WidgetArgs args)
@@ -269,11 +269,11 @@ namespace OpenRA.Mods.Common.Widgets
 
 			foreach (var resourceRenderer in resourceRenderers)
 			{
-				var resource = resourceRenderer.GetRenderedResourceType(cell);
+				var resourceTooltip = resourceRenderer.GetRenderedResourceTooltip(cell);
-				if (resource != null)
+				if (resourceTooltip != null)
 				{
 					TooltipType = WorldTooltipType.Resource;
-					ResourceTooltip = resource;
+					ResourceTooltip = resourceTooltip;
 					break;
 				}
 			}

mods/cnc/chrome/editor.yaml

@@ -444,7 +444,7 @@ Container@EDITOR_WORLD_ROOT:
 									IgnoreChildMouseOver: true
 									TooltipContainer: TOOLTIP_CONTAINER
 									Children:
-										Sprite@LAYER_PREVIEW:
+										ResourcePreview@LAYER_PREVIEW:
 											X: 4
 											Y: 4
 											Visible: false

mods/common/chrome/editor.yaml

@@ -417,7 +417,7 @@ Container@EDITOR_WORLD_ROOT:
 									IgnoreChildMouseOver: true
 									TooltipContainer: TOOLTIP_CONTAINER
 									Children:
-										Sprite@LAYER_PREVIEW:
+										ResourcePreview@LAYER_PREVIEW:
 											X: 4
 											Y: 4
 											Visible: false