NewGamePhysics.StateManager.ScreenManager Class Reference

The screen manager is a component which manages one or more GameScreen instances. It maintains a stack of screens, calls their Update and Draw methods at the appropriate times, and automatically routes input to the topmost active screen. More...

List of all members.

Public Member Functions
	ScreenManager (Game game)
	Constructs a new screen manager component.
override void	Initialize ()
	Initializes the screen manager component.
override void	Update (GameTime gameTime)
	Allows each screen to run logic.
override void	Draw (GameTime gameTime)
	Tells each screen to draw itself.
void	AddTexture (string textureKey, string texturePath)
	Adds a texture to the manager pool and loads if it has not been loaded yet.
void	AddFont (string fontKey, string fontPath)
	Adds a sprite font to the manager pool and loads if it has not been loaded yet.
void	AddSound (string soundKey, string soundPath)
	Adds a sound effect to the manager pool and loads if it has not been loaded yet.
void	AddScreen (GameScreen screen, PlayerIndex?controllingPlayer)
	Adds a new screen to the screen manager.
void	RemoveScreen (GameScreen screen)
	Removes a screen from the screen manager. You should normally use GameScreen.ExitScreen instead of calling this directly, so the screen can gradually transition off rather than just being instantly removed.
GameScreen[]	GetScreens ()
	Expose an array holding all the screens. We return a copy rather than the real master list, because screens should only ever be added or removed using the AddScreen and RemoveScreen methods.
void	FadeBackBufferToBlack (int alpha)
	Helper draws a translucent black fullscreen sprite, used for fading screens in and out, and for darkening the background behind popups.
void	SetVolume (string category, float volume)
	Sets the audio volume for the category.
Protected Member Functions
override void	LoadContent ()
	Load your graphics content.
override void	UnloadContent ()
	Unload your graphics content.
Properties
SpriteBatch	SpriteBatch [get]
	Gets a default SpriteBatch shared by all the screens. This saves each screen having to bother creating their own local instance.
PrimitiveBatch	PrimitiveBatch [get]
	Gets a default PrimitiveBatch shared by all the screens. This saves each screen having to bother creating their own local instance.
VideoPlayer	VideoPlayer [get]
	Gets a default VideoPlayer shared by all the screens. This saves each screen having to bother creating their own local instance.
Dictionary< string, Texture2D >	Textures [get]
	Gets the texture cache.
Dictionary< string, SpriteFont >	Fonts [get]
	Gets the font cache.
Dictionary< string, Model >	Models [get]
	Gets the model cache.
Dictionary< string, SoundEffect >	Sounds [get]
	Gets the sound effects cache.
SoundBank	SoundBank [get]
	Gets the soundbank.
bool	TraceEnabled [get, set]
	If true, the manager prints out a list of all the screens each time it is updated. This can be useful for making sure everything is being added and removed at the right times.

---

Detailed Description

The screen manager is a component which manages one or more GameScreen instances. It maintains a stack of screens, calls their Update and Draw methods at the appropriate times, and automatically routes input to the topmost active screen.

Definition at line 25 of file ScreenManager.cs.

---

Constructor & Destructor Documentation

NewGamePhysics.StateManager.ScreenManager.ScreenManager

(

Game

game

)

Constructs a new screen manager component.

Definition at line 193 of file ScreenManager.cs.

            : base(game)
        {
        }

---

Member Function Documentation

void NewGamePhysics.StateManager.ScreenManager.AddFont	(	string	fontKey,
		string	fontPath
	)

Adds a sprite font to the manager pool and loads if it has not been loaded yet.

Parameters:

	fontKey	The reference key to use for the font.
	fontPath	The content loader path for the font.

Definition at line 378 of file ScreenManager.cs.

        {
            if (!this.fonts.ContainsKey(fontKey))
            {
                this.fonts.Add(fontKey, Game.Content.Load<SpriteFont>(fontPath));
            }
        }

void NewGamePhysics.StateManager.ScreenManager.AddScreen	(	GameScreen	screen,
		PlayerIndex?	controllingPlayer
	)

Adds a new screen to the screen manager.

Definition at line 403 of file ScreenManager.cs.

        {
            screen.ControllingPlayer = controllingPlayer;
            screen.ScreenManager = this;
            screen.IsExiting = false;

            // If we have a graphics device, tell the screen to load content.
            if (isInitialized)
            {
                screen.LoadContent();
            }

            screens.Add(screen);
        }

void NewGamePhysics.StateManager.ScreenManager.AddSound	(	string	soundKey,
		string	soundPath
	)

Adds a sound effect to the manager pool and loads if it has not been loaded yet.

Parameters:

	soundKey	The reference key to use for the sound.
	fontPath	The content loader path for the sound.

Definition at line 392 of file ScreenManager.cs.

        {
            if (!this.sounds.ContainsKey(soundKey))
            {
                this.sounds.Add(soundKey, Game.Content.Load<SoundEffect>(soundPath));
            }
        }

void NewGamePhysics.StateManager.ScreenManager.AddTexture	(	string	textureKey,
		string	texturePath
	)

Adds a texture to the manager pool and loads if it has not been loaded yet.

Parameters:

	textureKey	The reference key to use for the texture.
	texturePath	The content loader path for the texture.

Definition at line 364 of file ScreenManager.cs.

        {
            if (!this.textures.ContainsKey(textureKey))
            {
                this.textures.Add(textureKey, Game.Content.Load<Texture2D>(texturePath));
            }
        }

override void NewGamePhysics.StateManager.ScreenManager.Draw

(

GameTime

gameTime

)

Tells each screen to draw itself.

Definition at line 341 of file ScreenManager.cs.

        {
            foreach (GameScreen screen in screens)
            {
                if (screen.ScreenState == ScreenState.Hidden)
                {
                    continue;
                }

                screen.Draw(gameTime);
            }
        }

void NewGamePhysics.StateManager.ScreenManager.FadeBackBufferToBlack

(

int

alpha

)

Helper draws a translucent black fullscreen sprite, used for fading screens in and out, and for darkening the background behind popups.

Definition at line 450 of file ScreenManager.cs.

        {
            Viewport viewport = GraphicsDevice.Viewport;

            spriteBatch.Begin();

            spriteBatch.Draw(this.Textures["blank"],
                             new Rectangle(0, 0, viewport.Width, viewport.Height),
                             new Color(0, 0, 0, (byte)alpha));

            spriteBatch.End();
        }

GameScreen [] NewGamePhysics.StateManager.ScreenManager.GetScreens

(

)

Expose an array holding all the screens. We return a copy rather than the real master list, because screens should only ever be added or removed using the AddScreen and RemoveScreen methods.

Definition at line 441 of file ScreenManager.cs.

        {
            return screens.ToArray();
        }

override void NewGamePhysics.StateManager.ScreenManager.Initialize

(

)

Initializes the screen manager component.

Definition at line 201 of file ScreenManager.cs.

        {
            base.Initialize();

            // Initialize audio objects.
            this.engine = new AudioEngine("Content\\Sounds\\audio.xgs");
            this.soundBank = new SoundBank(engine, "Content\\Sounds\\Sound Bank.xsb");
            this.waveBank = new WaveBank(engine, "Content\\Sounds\\Wave Bank.xwb");

            isInitialized = true;
        }

override void NewGamePhysics.StateManager.ScreenManager.LoadContent

(

)

[protected]

Load your graphics content.

Definition at line 216 of file ScreenManager.cs.

        {
            // Load content belonging to the screen manager.
            ContentManager content = Game.Content;
            this.spriteBatch = new SpriteBatch(GraphicsDevice);
            this.primitiveBatch = new PrimitiveBatch(GraphicsDevice);
            this.videoPlayer = new VideoPlayer();

            // Prepare caches
            this.textures = new Dictionary<string, Texture2D>();
            this.fonts = new Dictionary<string, SpriteFont>();
            this.models = new Dictionary<string, Model>();
            this.sounds = new Dictionary<string, SoundEffect>();

            // Prep font cache
            this.fonts.Add("menu", content.Load<SpriteFont>(@"Fonts\menufont"));
            this.fonts.Add("game", content.Load<SpriteFont>(@"Fonts\gamefont"));
            this.fonts.Add("small", content.Load<SpriteFont>(@"Fonts\smallfont"));
            
            // Prep texture cache
            this.textures.Add("blank",content.Load<Texture2D>(@"Sprites\blank"));

            // Tell each of the screens to load their content.
            foreach (GameScreen screen in screens)
            {
                screen.LoadContent();
            }
        }

void NewGamePhysics.StateManager.ScreenManager.RemoveScreen

(

GameScreen

screen

)

Removes a screen from the screen manager. You should normally use GameScreen.ExitScreen instead of calling this directly, so the screen can gradually transition off rather than just being instantly removed.

Definition at line 424 of file ScreenManager.cs.

        {
            // If we have a graphics device, tell the screen to unload content.
            if (isInitialized)
            {
                screen.UnloadContent();
            }

            screens.Remove(screen);
            screensToUpdate.Remove(screen);
        }

void NewGamePhysics.StateManager.ScreenManager.SetVolume	(	string	category,
		float	volume
	)

Sets the audio volume for the category.

Parameters:

	category	Friendly name of the audio cues.
	volume	The new volume.

Definition at line 468 of file ScreenManager.cs.

        {
            AudioCategory musicCategory = this.engine.GetCategory(category);
            if (null != musicCategory)
            {
                musicCategory.SetVolume(volume);
            }
        }

override void NewGamePhysics.StateManager.ScreenManager.UnloadContent

(

)

[protected]

Unload your graphics content.

Definition at line 248 of file ScreenManager.cs.

        {
            // Tell each of the screens to unload their content.
            foreach (GameScreen screen in screens)
            {
                screen.UnloadContent();
            }
        }

override void NewGamePhysics.StateManager.ScreenManager.Update

(

GameTime

gameTime

)

Allows each screen to run logic.

Definition at line 264 of file ScreenManager.cs.

        {
            // Read the keyboard and gamepad.
            this.input.Update();

            // Update the sound engine
            this.engine.Update();

            // Make a copy of the master screen list, to avoid confusion if
            // the process of updating one screen adds or removes others.
            screensToUpdate.Clear();

            foreach (GameScreen screen in screens)
            {
                screensToUpdate.Add(screen);
            }

            bool otherScreenHasFocus = !Game.IsActive;
            bool coveredByOtherScreen = false;

            // Loop as long as there are screens waiting to be updated.
            while (screensToUpdate.Count > 0)
            {
                // Pop the topmost screen off the waiting list.
                GameScreen screen = screensToUpdate[screensToUpdate.Count - 1];

                screensToUpdate.RemoveAt(screensToUpdate.Count - 1);

                // Update the screen.
                screen.Update(gameTime, otherScreenHasFocus, coveredByOtherScreen);

                if (screen.ScreenState == ScreenState.TransitionOn ||
                    screen.ScreenState == ScreenState.Active)
                {
                    // If this is the first active screen we came across,
                    // give it a chance to handle input.
                    if (!otherScreenHasFocus)
                    {
                        screen.HandleInput(input);

                        otherScreenHasFocus = true;
                    }

                    // If this is an active non-popup, inform any subsequent
                    // screens that they are covered by it.
                    if (!screen.IsPopup)
                    {
                        coveredByOtherScreen = true;
                    }
                }
            }

            // Print debug trace?
            if (traceEnabled)
            {
                TraceScreens();
            }
        }

---

Property Documentation

Dictionary<string, SpriteFont> NewGamePhysics.StateManager.ScreenManager.Fonts [get]

Gets the font cache.

Definition at line 147 of file ScreenManager.cs.

Dictionary<string, Model> NewGamePhysics.StateManager.ScreenManager.Models [get]

Gets the model cache.

Definition at line 155 of file ScreenManager.cs.

PrimitiveBatch NewGamePhysics.StateManager.ScreenManager.PrimitiveBatch [get]

Gets a default PrimitiveBatch shared by all the screens. This saves each screen having to bother creating their own local instance.

Definition at line 122 of file ScreenManager.cs.

SoundBank NewGamePhysics.StateManager.ScreenManager.SoundBank [get]

Gets the soundbank.

Definition at line 171 of file ScreenManager.cs.

Dictionary<string, SoundEffect> NewGamePhysics.StateManager.ScreenManager.Sounds [get]

Gets the sound effects cache.

Definition at line 163 of file ScreenManager.cs.

SpriteBatch NewGamePhysics.StateManager.ScreenManager.SpriteBatch [get]

Gets a default SpriteBatch shared by all the screens. This saves each screen having to bother creating their own local instance.

Definition at line 113 of file ScreenManager.cs.

Dictionary<string, Texture2D> NewGamePhysics.StateManager.ScreenManager.Textures [get]

Gets the texture cache.

Definition at line 139 of file ScreenManager.cs.

bool NewGamePhysics.StateManager.ScreenManager.TraceEnabled [get, set]

If true, the manager prints out a list of all the screens each time it is updated. This can be useful for making sure everything is being added and removed at the right times.

Definition at line 181 of file ScreenManager.cs.

VideoPlayer NewGamePhysics.StateManager.ScreenManager.VideoPlayer [get]

Gets a default VideoPlayer shared by all the screens. This saves each screen having to bother creating their own local instance.

Definition at line 131 of file ScreenManager.cs.

---

The documentation for this class was generated from the following file:

• C:/Users/Andreas Schiffler/Desktop/SVN/NewGamePhysics/NewGamePhysics/StateManager/ScreenManager.cs