new chrome stuff

OpenRa.Game/Chrome.cs

@@ -0,0 +1,47 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using OpenRa.Game.Graphics;
+using OpenRa.Game.Support;
+using System.Drawing;
+
+namespace OpenRa.Game
+{
+	class Chrome
+	{
+		readonly Renderer renderer;
+		readonly Sheet specialBin;
+		readonly SpriteRenderer spriteRenderer;
+		readonly Sprite specialBinSprite;
+		readonly Sprite moneyBinSprite;
+
+		public Chrome(Renderer r)
+		{
+			this.renderer = r;
+			specialBin = new Sheet(renderer, "specialbin.png");
+			spriteRenderer = new SpriteRenderer(renderer, true, renderer.RgbaSpriteShader);
+			specialBinSprite = new Sprite(specialBin, new Rectangle(0, 0, 64, 256), TextureChannel.Alpha);
+			moneyBinSprite = new Sprite(specialBin, new Rectangle(128, 0, 384, 64), TextureChannel.Alpha);
+		}
+
+		public void Draw()
+		{
+			renderer.Device.DisableScissor();
+			renderer.DrawText(string.Format("RenderFrame {0} ({2:F1} ms)\nTick {1} ({3:F1} ms)\n$ {4}\nPower {5}",
+				Game.RenderFrame,
+				Game.orderManager.FrameNumber,
+				PerfHistory.items["render"].LastValue,
+				PerfHistory.items["tick_time"].LastValue,
+				Game.LocalPlayer.Cash,
+				Game.LocalPlayer.GetTotalPower()
+				), new int2(140, 5), Color.White);
+
+			PerfHistory.Render(renderer, Game.worldRenderer.lineRenderer);
+
+			spriteRenderer.DrawSprite(specialBinSprite, float2.Zero, 0);
+			spriteRenderer.DrawSprite(moneyBinSprite, new float2( Game.viewport.Width - 384, 0 ), 0);
+			spriteRenderer.Flush();
+		}
+	}
+}

OpenRa.Game/Game.cs

@@ -24,6 +24,7 @@ namespace OpenRa.Game
 		public static PathFinder PathFinder;
 		public static WorldRenderer worldRenderer;
 		public static Controller controller;
+		public static Chrome chrome;
 
 		public static OrderManager orderManager;
 
@@ -86,6 +87,8 @@ namespace OpenRa.Game
 
 			skipMakeAnims = false;
 			PerfHistory.items["render"].hasNormalTick = false;
+
+			chrome = new Chrome(renderer);
 		}
 
 		static void LoadMapBuildings( IniFile mapfile )
@@ -174,7 +177,6 @@ namespace OpenRa.Game
 
 			using (new PerfSample("render"))
 			{
-				
 				++RenderFrame;
 				viewport.cursor = controller.ChooseCursor();
 				viewport.DrawRegions();

OpenRa.Game/Graphics/Renderer.cs

@@ -10,8 +10,9 @@ namespace OpenRa.Game.Graphics
 	{
 		readonly GraphicsDevice device;
 		Texture[] palettes;
-        public Shader SpriteShader { get; private set; }    /* note: shared shader params */
+		public Shader SpriteShader { get; private set; }    /* note: shared shader params */
-        public Shader LineShader { get; private set; }
+		public Shader LineShader { get; private set; }
+		public Shader RgbaSpriteShader { get; private set; }
 
 		readonly SpriteHelper sh;
 		readonly FontHelper fhDebug;
@@ -34,26 +35,29 @@ namespace OpenRa.Game.Graphics
 
 			SpriteShader = new Shader(device, FileSystem.Open("sprite.fx"));
 			SpriteShader.Quality = ShaderQuality.Low;
-            LineShader = new Shader(device, FileSystem.Open("line.fx"));
+			LineShader = new Shader(device, FileSystem.Open("line.fx"));
-            LineShader.Quality = ShaderQuality.High;
+			LineShader.Quality = ShaderQuality.High;
+			RgbaSpriteShader = new Shader(device, FileSystem.Open("rgbasprite.fx"));
+			RgbaSpriteShader.Quality = ShaderQuality.High;
 
-			sh = new SpriteHelper(device );
+			sh = new SpriteHelper(device);
-			fhDebug = new FontHelper(device, "Tahoma", 10, false );
+			fhDebug = new FontHelper(device, "Tahoma", 10, false);
 		}
 
 		public GraphicsDevice Device { get { return device; } }
 
 		public static float waterFrame = 0.0f;
 
-		public void BeginFrame( float2 r1, float2 r2, float2 scroll )
+		public void BeginFrame(float2 r1, float2 r2, float2 scroll)
 		{
 			device.Begin();
+			device.Clear(0, Surfaces.Color);
 
-			SpriteShader.SetValue("Palette", palettes[ (int)(waterFrame * palettes.Length) % palettes.Length ]);
+			SpriteShader.SetValue("Palette", palettes[(int)(waterFrame * palettes.Length) % palettes.Length]);
 			SpriteShader.SetValue("Scroll", scroll);
 			SpriteShader.SetValue("r1", r1);
 			SpriteShader.SetValue("r2", r2);
-            SpriteShader.Commit();
+			SpriteShader.Commit();
 		}
 
 		public void EndFrame()
@@ -63,7 +67,21 @@ namespace OpenRa.Game.Graphics
 		}
 
 		public void DrawBatch<T>(FvfVertexBuffer<T> vertices, IndexBuffer indices,
-			Range<int> vertexRange, Range<int> indexRange, Texture texture, PrimitiveType type)
+			Range<int> vertexRange, Range<int> indexRange, Texture texture, PrimitiveType type, Shader shader)
+			where T : struct
+		{
+			shader.SetValue("DiffuseTexture", texture);
+			shader.Commit();
+
+			vertices.Bind(0);
+			indices.Bind();
+
+			device.DrawIndexedPrimitives(type,
+				vertexRange, indexRange);
+		}
+
+		public void DrawBatch<T>(FvfVertexBuffer<T> vertices, IndexBuffer indices,
+			int vertexPool, int numPrimitives, Texture texture, PrimitiveType type)
 			where T : struct
 		{
 			SpriteShader.SetValue("DiffuseTexture", texture);
@@ -73,23 +91,9 @@ namespace OpenRa.Game.Graphics
 			indices.Bind();
 
 			device.DrawIndexedPrimitives(type,
-				vertexRange, indexRange);
+				vertexPool, numPrimitives);
 		}
 
-        public void DrawBatch<T>(FvfVertexBuffer<T> vertices, IndexBuffer indices,
-            int vertexPool, int numPrimitives, Texture texture, PrimitiveType type)
-            where T : struct
-        {
-            SpriteShader.SetValue("DiffuseTexture", texture);
-            SpriteShader.Commit();
-
-            vertices.Bind(0);
-            indices.Bind();
-
-            device.DrawIndexedPrimitives(type,
-                vertexPool, numPrimitives);
-        }
-
 		public void DrawText(string text, int2 pos, Color c)
 		{
 			sh.Begin();
@@ -101,5 +105,19 @@ namespace OpenRa.Game.Graphics
 		{
 			return new int2(fhDebug.MeasureText(sh, text));
 		}
+
+		public void DrawTexture(Texture t, int2 pos)
+		{
+			sh.Begin();
+			sh.SetTransform(1,1, pos.X, pos.Y);
+			sh.Draw(t, 0, 0, 256,256, -1);
+			sh.End();
+		}
+
+		public Texture LoadTexture(string filename)
+		{
+			using (var stream = FileSystem.Open(filename))
+				return Texture.Create(stream, device);
+		}
 	}
 }

OpenRa.Game/Graphics/Sheet.cs

@@ -1,6 +1,7 @@
 using System.Drawing;
 using System.IO;
 using Ijw.DirectX;
+using OpenRa.FileFormats;
 
 namespace OpenRa.Game.Graphics
 {
@@ -18,6 +19,12 @@ namespace OpenRa.Game.Graphics
 			this.bitmap = new Bitmap(size.Width, size.Height);
 		}
 
+		public Sheet(Renderer renderer, string filename)
+		{
+			this.renderer = renderer;
+			this.bitmap = (Bitmap)Image.FromStream(FileSystem.Open(filename));
+		}
+
 		void Resolve()
 		{
 			string filename = string.Format("../../../sheet-{0}.png", suffix++);

OpenRa.Game/Graphics/SpriteRenderer.cs

@@ -12,6 +12,7 @@ namespace OpenRa.Game.Graphics
 		FvfVertexBuffer<Vertex> vertexBuffer;
 		IndexBuffer indexBuffer;
 		Renderer renderer;
+		Shader shader;
 
 		const int spritesPerBatch = 1024;
 
@@ -22,9 +23,10 @@ namespace OpenRa.Game.Graphics
 		ShaderQuality quality;
         int nv = 0, ni = 0;
 
-		public SpriteRenderer(Renderer renderer, bool allowAlpha)
+		public SpriteRenderer(Renderer renderer, bool allowAlpha, Shader shader)
 		{
 			this.renderer = renderer;
+			this.shader = shader;
 
 			vertexBuffer = new FvfVertexBuffer<Vertex>(renderer.Device, vertices.Length, Vertex.Format);
 			indexBuffer = new IndexBuffer(renderer.Device, indices.Length);
@@ -32,19 +34,23 @@ namespace OpenRa.Game.Graphics
 			quality = allowAlpha ? ShaderQuality.High : ShaderQuality.Low;
 		}
 
+		public SpriteRenderer(Renderer renderer, bool allowAlpha)
+			: this(renderer, allowAlpha, renderer.SpriteShader) { }
+
 		public void Flush()
 		{
 			if (sprites > 0)
 			{
-                renderer.SpriteShader.Quality = quality;
+                shader.Quality = quality;
-                renderer.SpriteShader.Render(() =>
+                shader.Render(() =>
                  {
                      vertexBuffer.SetData(vertices);
                      indexBuffer.SetData(indices);
                      renderer.DrawBatch(vertexBuffer, indexBuffer,
                          new Range<int>(0, nv),
                          new Range<int>(0, ni),
-                         currentSheet.Texture, PrimitiveType.TriangleList);
+                         currentSheet.Texture, PrimitiveType.TriangleList,
+						 shader);
                  });
 
                 nv = 0; ni = 0;

OpenRa.Game/Graphics/TerrainRenderer.cs

@@ -76,7 +76,7 @@ namespace OpenRa.Game.Graphics
                 renderer.DrawBatch(vertexBuffer, indexBuffer,
                     new Range<int>(verticesPerRow * firstRow, verticesPerRow * lastRow),
                     new Range<int>(indicesPerRow * firstRow, indicesPerRow * lastRow),
-                    terrainSheet.Texture, PrimitiveType.TriangleList));
+                    terrainSheet.Texture, PrimitiveType.TriangleList, renderer.SpriteShader));
 
 			overlayRenderer.Draw();
 		}

OpenRa.Game/Graphics/Viewport.cs

@@ -24,18 +24,19 @@ namespace OpenRa.Game.Graphics
 
 		public void Scroll(float2 delta)
 		{
-			scrollPosition = ( scrollPosition + delta ).Constrain( scrollLowBounds, scrollHighBounds );
+			scrollPosition = scrollPosition + delta;// (scrollPosition + delta).Constrain(scrollLowBounds, scrollHighBounds);
 		}
 
 		public Viewport(float2 screenSize, int2 mapStart, int2 mapEnd, Renderer renderer)
 		{
 			this.screenSize = screenSize;
-			this.scrollLowBounds = Game.CellSize * mapStart;
+//			this.scrollLowBounds = Game.CellSize * mapStart;
-			this.scrollHighBounds = float2.Max( scrollLowBounds, Game.CellSize * mapEnd - ( screenSize - new float2( 128, 0 ) ) );
+//			this.scrollHighBounds = float2.Max( scrollLowBounds, Game.CellSize * mapEnd - ( screenSize /*- new float2( 128, 0 )*/ ) );
 			this.renderer = renderer;
 			cursorRenderer = new SpriteRenderer(renderer, true);
 
-			this.scrollPosition = scrollLowBounds;
+			this.scrollPosition = Game.CellSize* mapStart;
+//			this.scrollPosition = scrollLowBounds;
 		}
 
 		List<Region> regions = new List<Region>();
@@ -52,6 +53,8 @@ namespace OpenRa.Game.Graphics
 			foreach (Region region in regions)
 				region.Draw(renderer);
 
+			Game.chrome.Draw();
+
 			var c = (Game.worldRenderer.region.Contains(mousePos)) ? cursor : Cursor.Default;
 			cursorRenderer.DrawSprite(c.GetSprite((int)cursorFrame), mousePos + Location - c.GetHotspot(), 0);
 			cursorRenderer.Flush();

OpenRa.Game/Graphics/WorldRenderer.cs

@@ -5,6 +5,7 @@ using IjwFramework.Types;
 using System.Collections.Generic;
 using OpenRa.Game.Traits;
 using OpenRa.Game.Support;
+using Ijw.DirectX;
 
 namespace OpenRa.Game.Graphics
 {
@@ -16,6 +17,7 @@ namespace OpenRa.Game.Graphics
 		public readonly Region region;
 		public readonly UiOverlay uiOverlay;
 		readonly Renderer renderer;
+		readonly Texture specialbin;
 
 		public static bool ShowUnitPaths = false;
 
@@ -25,7 +27,7 @@ namespace OpenRa.Game.Graphics
 
 			// TODO: this is layout policy. it belongs at a higher level than this.
 			region = Region.Create(Game.viewport, DockStyle.Left,
-				Game.viewport.Width - 128, Draw, 
+				Game.viewport.Width - /*128*/ 0, Draw, 
                 Game.controller.HandleMouseInput);		
 
 			Game.viewport.AddRegion(region);
@@ -34,6 +36,8 @@ namespace OpenRa.Game.Graphics
 			spriteRenderer = new SpriteRenderer(renderer, true);
             lineRenderer = new LineRenderer(renderer);
 			uiOverlay = new UiOverlay(spriteRenderer);
+
+			specialbin = renderer.LoadTexture("specialbin.png");
 		}
 
 		void DrawSpriteList(RectangleF rect,
@@ -67,7 +71,7 @@ namespace OpenRa.Game.Graphics
 			foreach (var a in Game.world.Actors
 				.Where(u => u.traits.Contains<Traits.RenderWarFactory>())
 				.Select(u => u.traits.Get<Traits.RenderWarFactory>()))
-				DrawSpriteList(rect, a.RenderRoof(a.self));		/* RUDE HACK */
+				DrawSpriteList(rect, a.RenderRoof(a.self));	
 
 			foreach (IEffect e in Game.world.Effects)
 				DrawSpriteList(rect, e.Render());
@@ -98,17 +102,6 @@ namespace OpenRa.Game.Graphics
 					DrawSelectionBox(a, Color.White, true);
 
 			lineRenderer.Flush();
-
-			renderer.DrawText(string.Format("RenderFrame {0} ({2:F1} ms)\nTick {1} ({3:F1} ms)\n$ {4}\nPower {5}",				
-				Game.RenderFrame,
-				Game.orderManager.FrameNumber,
-				PerfHistory.items["render"].LastValue,
-				PerfHistory.items["tick_time"].LastValue,
-				Game.LocalPlayer.Cash,
-				Game.LocalPlayer.GetTotalPower()
-				), new int2(5, 5), Color.White);
-
-			PerfHistory.Render(renderer, lineRenderer);
 		}
 
         void DrawSelectionBox(Actor selectedUnit, Color c, bool drawHealthBar)

OpenRa.Game/OpenRa.Game.csproj

@@ -75,6 +75,7 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Chrome.cs" />
     <Compile Include="GameRules\GeneralInfo.cs" />
     <Compile Include="GameRules\TechTree.cs" />
     <Compile Include="OrderManager.cs" />

OpenRa.Game/Sidebar.cs

@@ -37,7 +37,7 @@ namespace OpenRa.Game
 		{
 			this.player = player;
 			this.renderer = renderer;
-			region = GRegion.Create(Game.viewport, DockStyle.Right, 128, Paint, MouseHandler);
+			region = GRegion.Create(Game.viewport, DockStyle.Right, /*128*/0, Paint, MouseHandler);
 			region.UseScissor = false;
 			region.AlwaysWantMovement = true;
 			Game.viewport.AddRegion( region );

rgbasprite.fx

@@ -0,0 +1,74 @@
+// OpenRA ui shader for non-SHP sprites (mostly just chrome)
+// Author: C. Forbes
+//--------------------------------------------------------
+
+shared texture DiffuseTexture;
+shared float2 r1, r2;		// matrix elements
+
+sampler s_DiffuseTexture = sampler_state {
+	Texture = <DiffuseTexture>;
+	MinFilter = None;
+	MagFilter = None;
+	MipFilter = None;
+  
+	AddressU = Wrap;
+	AddressV = Wrap;
+	AddressW = Wrap;
+};
+
+struct VertexIn {
+	float4 Position: POSITION;
+	float2 Tex0: TEXCOORD0;
+	float2 Tex1: TEXCOORD1;
+};
+
+struct VertexOut {
+	float4 Position: POSITION;
+	float2 Tex0: TEXCOORD0;
+};
+
+struct FragmentIn {
+	float2 Tex0: TEXCOORD0;
+};
+
+VertexOut Simple_vp(VertexIn v) {
+	VertexOut o;	
+	float2 p = v.Position.xy * r1 + r2;
+	o.Position = float4(p.x,p.y,0,1);
+	o.Tex0 = v.Tex0;
+	return o;
+}
+
+float4 Simple_fp(FragmentIn f) : COLOR0 {
+	float4 r = tex2D(s_DiffuseTexture, f.Tex0.xy);
+	return r;
+}
+
+/*
+technique low_quality {
+	pass p0 {
+		AlphaBlendEnable = false;
+		ZWriteEnable = false;
+		ZEnable = false;
+		CullMode = None;
+		FillMode = Solid;
+		VertexShader = compile vs_2_0 Simple_vp();
+		PixelShader = compile ps_2_0 Simple_fp();
+	}
+}
+*/
+
+technique high_quality {
+	pass p0	{
+		AlphaBlendEnable = true;
+		ZWriteEnable = false;
+		ZEnable = false;
+		CullMode = None;
+		FillMode = Solid;
+		VertexShader = compile vs_2_0 Simple_vp();
+		PixelShader = compile ps_2_0 Simple_fp();
+		
+		SrcBlend = SrcAlpha;
+		DestBlend = InvSrcAlpha;
+	}
+}