private static void SetupWindowSizeProperties(Mock<Window> windowMock)
 {
     Window window = windowMock.Object;
     var currentSize = new Size(1024, 640);
     windowMock.SetupGet(w => w.TotalPixelSize).Returns(() => currentSize);
     #pragma warning disable 0618
     windowMock.SetupSet(w => w.TotalPixelSize).Callback(s =>
     {
         currentSize = s;
         windowMock.Raise(w => w.ViewportSizeChanged += null, s);
     });
     windowMock.SetupGet(w => w.ViewportPixelSize).Returns(() => currentSize);
     bool isFullscreen = false;
     var rememberSizeBeforeFullscreen = new Size();
     windowMock.Setup(w => w.SetFullscreen(It.IsAny<Size>())).Callback((Size displaySize) =>
     {
         isFullscreen = true;
         rememberSizeBeforeFullscreen = window.TotalPixelSize;
         window.TotalPixelSize = displaySize;
     });
     windowMock.Setup(w => w.SetWindowed()).Callback(() =>
     {
         isFullscreen = false;
         window.TotalPixelSize = rememberSizeBeforeFullscreen;
     });
     windowMock.SetupGet(w => w.IsFullscreen).Returns(() => isFullscreen);
 }

		public MovingSprite(string image, Color color, Vector2D position, Size size)
			: base(image, Rectangle.One)
		{
			Size = size;
			Center = position;
			ID += 1;
		}

 private static void CreateFontTexts(Vector2D[] centers, Size size)
 {
     new FontText(Font.Default, "Up", Rectangle.FromCenter(centers[0], size));
     new FontText(Font.Default, "Down", Rectangle.FromCenter(centers[1], size));
     new FontText(Font.Default, "Left", Rectangle.FromCenter(centers[2], size));
     new FontText(Font.Default, "Right", Rectangle.FromCenter(centers[3], size));
 }

 private static Rectangle GetScoreWindowDrawArea(Size size)
 {
     var left = Brick.OffsetPortrait.X + GridRenderLeftOffset;
     var top = Brick.OffsetPortrait.Y - Brick.ZoomPortrait + ScoreRenderTopOffset;
     var height = Width / size.AspectRatio;
     return new Rectangle(left, top, Width, height);
 }

		public AutoArrangingMenu(Size buttonSize, int renderLayer = 0)
			: base("<GeneratedScene>")
		{
			this.buttonSize = buttonSize;
			center = Vector2D.Half;
			this.renderLayer = renderLayer;
		}

 private void ResetDeviceToNewViewportSize(Size newSizeInPixel)
 {
     Screen = new ScreenSpace(newSizeInPixel);
     NativeDevice.PresentationParameters.BackBufferWidth = (int)newSizeInPixel.Width;
     NativeDevice.PresentationParameters.BackBufferHeight = (int)newSizeInPixel.Height;
     NativeDevice.Reset(NativeDevice.PresentationParameters);
 }

		private static Vertex[] SetDataColored(Size size, ShaderWithFormat shader, Material material)
		{
			if ((shader.Flags & ShaderFlags.Textured) != 0)
				return CreateVerticesColoredTextured(size, material.DefaultColor);
			return CreateVerticesColored(size, material.DefaultColor);

		}

		public Logo Create()
		{
			Randomizer random = Randomizer.Current;
			Size size = new Size(random.Get(0.02f, 0.08f));
			var halfWidth = size.Width / 2f;
			var doubleWidth = size.Width * 2f;
			Rectangle view = screen.Viewport;
			Vector2D position = new Vector2D(random.Get(doubleWidth, view.Width - doubleWidth), view.Bottom - size.Height / 2);
			float direction = position.X > 0.5f ? -1 : 1;
			if (random.Get(1, 100) >= 30) direction *= -1;
			float r = direction > 0
				? random.Get(0, view.Width - position.X - doubleWidth)
				: random.Get(0, position.X - doubleWidth);
			var h = random.Get(0.3f, view.Height - 0.05f);
			var angle = Math.Atan((4 * h) / r);
			if (angle == 0)
				angle = 1.57079f;
			var v0 = Math.Sqrt(r * MovingSprite.Gravity / Math.Sin(2 * angle));
			var v_x = (float)(v0 * Math.Cos(angle));
			var v_y = (float)(v0 * Math.Sin(angle));
			v_x *= direction;
			var data = new SimplePhysics.Data()
			{
				Gravity = new Vector2D(0f, MovingSprite.Gravity),
				Velocity = new Vector2D(v_x, -v_y),
				RotationSpeed = random.Get(10, 50) * direction
			};
			return new Logo("DeltaEngineLogo", Color.GetRandomBrightColor(), position, size, data);
		}

		protected override void OnFullscreenChanged(Size displaySize, bool isFullScreenEnabled)
		{
			deviceManager.PreferredBackBufferWidth = (int)displaySize.Width;
			deviceManager.PreferredBackBufferHeight = (int)displaySize.Height;
			deviceManager.IsFullScreen = isFullScreenEnabled;
			base.OnFullscreenChanged(displaySize, isFullScreenEnabled);
		}

		public static LevelTileType[] MapInfo(Size gridSize)
		{
			size = gridSize;
			var mapData = new LevelTileType[(int)(BathRoomLevelInfo.size.Width * BathRoomLevelInfo.size.Height)];
			for (int i = 0; i < mapData.Length; i++)
				mapData[i] = LevelTileType.Nothing;

			//walls and emoty grid spaces
			SetMapValuesToBlocked(mapData, 0, 0, 0, 23);
			SetMapValuesToBlocked(mapData, 12, 13, 0, 23);
			SetMapValuesToBlocked(mapData, 1, 1, 17, 23);
			SetMapValuesToBlocked(mapData, 11, 11, 0, 6);

			SetTile(mapData, 9, 0, LevelTileType.Blocked);
			SetTile(mapData, 10, 0, LevelTileType.Blocked);
			SetTile(mapData, 11, 0, LevelTileType.Blocked);
			SetTile(mapData, 11, 12, LevelTileType.Blocked);

			//towel shelf
			SetTile(mapData, 6, 8, LevelTileType.Blocked);
			SetTile(mapData, 7, 8, LevelTileType.Blocked);
			SetTile(mapData, 8, 8, LevelTileType.Blocked);
			SetTile(mapData, 6, 9, LevelTileType.Blocked);
			SetTile(mapData, 7, 9, LevelTileType.Blocked);
			SetTile(mapData, 8, 9, LevelTileType.Blocked);

			//plant
			SetTile(mapData, 2, 23, LevelTileType.Blocked);

			//toilet
			SetTile(mapData, 1, 14, LevelTileType.Blocked);

			//towels
			SetTile(mapData, 3, 4, LevelTileType.Blocked);
			SetTile(mapData, 4, 5, LevelTileType.Blocked);

			SetTile(mapData, 5, 15, LevelTileType.Blocked);
			SetTile(mapData, 7, 16, LevelTileType.Blocked);
			SetTile(mapData, 9, 14, LevelTileType.Blocked);

			//stools
			SetTile(mapData, 4, 20, LevelTileType.Blocked);
			SetTile(mapData, 2, 10, LevelTileType.Blocked);

			//toilet paper
			SetTile(mapData, 5, 14, LevelTileType.Blocked);

			//spawn points
			SetTile(mapData, 2, 1, LevelTileType.SpawnPoint);

			//Exit Points
			SetTile(mapData, 7, 23, LevelTileType.ExitPoint);

			//Tower Placeable Points
			SetTile(mapData, 3, 7, LevelTileType.Yellow); //impact tower
			SetTile(mapData, 6, 13, LevelTileType.Red); //fire tower
			SetTile(mapData, 8, 20, LevelTileType.Blue); //water tower
			return mapData;
		}

		public void CreateFromFloat()
		{
			const float Width = 3.51f;
			const float Height = 0.23f;
			var s = new Size(Width, Height);
			Assert.AreEqual(s.Width, Width);
			Assert.AreEqual(s.Height, Height);
		}

		private static Rectangle GetScoreWindowDrawArea(Size size)
		{
			var left = Brick.OffsetLandscape.X + GridRenderLeftOffset;
			var top = Brick.OffsetLandscape.Y - Brick.ZoomLandscape + ScoreRenderTopOffset;
			const float Width = Grid.Width * Brick.ZoomLandscape + GridRenderWidthOffset;
			var height = Width / size.AspectRatio;
			return new Rectangle(left, top, Width, height);
		}

 protected ScreenSpace(Window window)
 {
     this.window = window;
     viewportPixelSize = window.ViewportPixelSize;
     window.ViewportSizeChanged += Update;
     window.OrientationChanged += UpdateOrientationChanged;
     current = this;
 }

		public void ShowManyRabbits()
		{
			var viewport = Resolve<ScreenSpace>().Viewport;
			var size = new Size(0.1f);
			for (float x = viewport.Left + size.Width / 2; x <= viewport.Right; x += size.Width)
				for (float y = viewport.Top + size.Height / 2; y <= viewport.Bottom; y += size.Height)
					CreateRabbitWith50Health(new Vector2D(x, y));
		}

		public Grid3D(Vector3D center, Size dimension, float gridScale = 1.0f)
			: base(center)
		{
			this.dimension = dimension;
			this.gridScale = gridScale;
			lines = new List<Line3D>();
			DrawGrid();
		}

		public static Matrix CreateOrthoProjectionMatrix(Size viewportSize)
		{
			return new Matrix(
				2.0f / viewportSize.Width, 0.0f, 0.0f, 0.0f,
				0.0f, 2.0f / -viewportSize.Height, 0.0f, 0.0f,
				0.0f, 0.0f, -1.0f, 0.0f,
				-1.0f, 1.0f, 0.0f, 1.0f);
		}

		public override void SetViewport(Size newSizeInPixel)
		{
			NativeDevice.PresentationParameters.BackBufferWidth = (int)newSizeInPixel.Width;
			NativeDevice.PresentationParameters.BackBufferHeight = (int)newSizeInPixel.Height;
			NativeDevice.Reset(NativeDevice.PresentationParameters);
			NativeDevice.Clear(new Color(0, 0, 0));
			SetModelViewProjectionMatrixFor2D();
		}

		public Billboard(Vector3D position, Size size, Material material,
			BillboardMode billboardMode = BillboardMode.CameraFacing)
			: base(position)
		{
			mode = billboardMode;
			planeQuad = new PlaneQuad(size, material);
			OnDraw<BillboardRenderer>();
		}

		private static Rectangle CalculateArrowDrawArea(Material material, Vector2D start, Vector2D target)
		{
			start += Vector2D.Normalize(start.DirectionTo(target)) * 0.033f;
			target -= Vector2D.Normalize(start.DirectionTo(target)) * 0.033f;
			var distance = start.DistanceTo(target);
			var size = new Size(distance, distance / material.DiffuseMap.PixelSize.AspectRatio);
			return Rectangle.FromCenter((start + target) / 2, size * GameLogic.ArrowSize);
		}

		public void NearlyEquals()
		{
			var s1 = new Size(1, 2);
			Assert.IsTrue(s1.IsNearlyEqual(new Size(0.99999f, 2.00001f)));
			Assert.IsTrue(s1.IsNearlyEqual(new Size(1, 2.00001f)));
			Assert.IsFalse(s1.IsNearlyEqual(new Size(0.9f, 2.00001f)));
			Assert.IsFalse(s1.IsNearlyEqual(new Size(1, 2.1f)));
		}