This version has lots of new functionality with no specific aim, so let's just present them:

• Mipmapping - This helps images scale smoothly with no pixelation by pre-drawing the image at different resolutions.
• Maximize FPS - Sometimes a high framerate is the most important factor, so let's try it out.
• GetDisplayModeBestMatch() - Returns the best match for the requested fullscreen resolution.
• Some code which adds new skulls (images) at random position and random scale to show the mipmap in action.
• Bugfixes and other fixes.

https://github.com/tornseglare/ShootThemAll/releases/tag/v1.5

Let's start with the required change in ShootThemAll.mgcb:

/processorParam:GenerateMipmaps=True

This will instruct the content builder to generate the mipmap images, which basically means it creates several versions of each image at different scales. (Each image is at half the size of the previous until it reaches 1×1 pixel.)

This is the only code change needed to enable mipmapping!

To show the mipmapping in action we must draw the images at different scale, so lets do that.

First let's have a basic class which contains a position and the scale for an image:

  public class PositionAndScale
  {
      public Vector2 position;
      public float scale;
  }

In the ShootThemAllGame class let's have a list of these:

  List<PositionAndScale> objects = new();

In the Update() function we add a new skull (image) every now and then, with a random position and a random scale between 0 and 1:

if (randomizer.Next(0, 100) < 1)
{
	PositionAndScale obj = new() { 
		position = new(randomizer.Next(0, windowedWidth), randomizer.Next(0, windowedHeight)), 
		scale = randomizer.NextSingle() };
	
	objects.Add(obj);
}

Finally, let's draw the ugly things on screen:

          foreach(PositionAndScale obj in objects)
          {
              spriteBatch.Draw(Art.Skull, obj.position, null, 
                  Color.White, 0f, Vector2.Zero, 
                  obj.scale, SpriteEffects.None, 0);
          }

Please note we send the obj.position and obj.scale to the Draw() call, the mipmapping we enabled earlier will do its work all by itself.

The final result will look something like this:

Try set the GenerateMipmaps to false to see the difference. The skull image is a bit cloudy, so try create your own image, and make sure there are a few sharp lines one pixel wide. You will see how these lines simply disappear when mipmaps are turned off! When mipmapping is on, the lines will be scaled down and smoothed properly.

          // To allow for higher fps than 60, set to false.
          // This means the screen will be redrawn as fast as possible, possibly
          // several thousand frames per second, so you need to think about it. :-)
          IsFixedTimeStep = false;
          
          // Turn off the vertical sync to achieve even higher framerates at the
          // cost of tearing issues.
          graphics.SynchronizeWithVerticalRetrace = false;
          graphics.ApplyChanges();

Setting Game.IsFixedTimeStep to false means monogame will call your Draw() as fast as possible, which can be interesting for some games.

If you need even higher framerates and don't care about screen tearing, set graphics.SynchronizeWithVerticalRetrace to false as well!

This is a neat function which will return the best match for the requested fullscreen resolution. I use this when the game requires for example a specific resolution like HD, like 1920 x 1080 pixels. If the hardware cannot give me the exact resolution I need but at least the width (or height) the scale-down math looks nicer, and the end result too.

It searches in three steps:

1. First, try to find an exact match or a resolution where both width and height are greater than the requested.
2. Second, try to find a resolution where either the width or height match or are greater than the requested.
3. Lastly, just find the highest resolution available.

      /// <summary>
      /// Get the best matching DisplayMode the system can give you. 
      /// </summary>
      public static DisplayMode GetDisplayModeBestMatch(int width, int height)
      {
          // Fetch the first one matching width and height.
          DisplayMode sdMode = GraphicsAdapter.DefaultAdapter.SupportedDisplayModes.Where(dm => dm.Width >= width && dm.Height >= height).OrderBy(dm => dm.Width).ThenBy(dm => dm.Height).FirstOrDefault();
          
          if (sdMode == null)
          {
              // Either the requested width or the height are too large. Let's find a dmode matching at least the height or the width.
              sdMode = GraphicsAdapter.DefaultAdapter.SupportedDisplayModes.Where(dm => dm.Width >= width || dm.Height >= height).OrderBy(dm => dm.Width).ThenBy(dm => dm.Height).FirstOrDefault();
          
              if (sdMode == null)
              {
                  // Neither requested width or height can be satisfied, lets just find the display mode with the largest width and height.
                  sdMode = GraphicsAdapter.DefaultAdapter.SupportedDisplayModes.OrderByDescending(dm => dm.Width).ThenByDescending(dm => dm.Height).FirstOrDefault();
          
                  if (sdMode == null)
                  {
                      throw new Exception("No display modes available.");
                  }
              }
          }
          
          return sdMode;
      }
          

I changed SpriteSortMode to Deferred instead of Texture since you typically want the sprites drawn on top of each other in the order you call Draw() on each.

          spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.NonPremultiplied);

You cannot set the window position until you have set IsFullScreen to false and called ApplyChanges(). Please see the GoWindowed() function, where I set the Window.Position last of all.

To improve runtime speed I disabled PublishReadyToRun and TieredCompilation in the .csproj file:

  <PublishReadyToRun>false</PublishReadyToRun>
  <TieredCompilation>false</TieredCompilation>

Back to index