Microsoft XNA Game Studio 3.0 : Controlling Color (part 2)

2/16/2011 11:38:58 AM

4. Storing Data in Computer Memory

The data for each color intensity is being held in a variable of type byte. The byte type is interesting because it uses 8 bits of computer memory to hold the value that it is trying to represent. Computer memory is actually a huge number of such locations, each of which is 1 byte in size. The Xbox 360 has 512 megabytes of memory. This means that the memory inside the console has about 512 million storage locations, each of which can hold a single byte value. The memory is addressed by number, and the compiler generates a program that uses a particular memory location when it accesses a particular variable. Figure 4 shows how this might work. The compiler has decided that blueIntensity is to be held in memory byte number 1003, greenIntensity in memory byte number 1004, and so on.

When the program runs, the statements that work with redIntensity, blueIntensity, and greenIntensity are directed to these locations in memory. Each data type uses a particular amount of computer memory; a byte uses a single memory location. The Color type uses at least 4 bytes of memory; other types can use a lot more. When the program needs to hold a Color value, the compiler allocates a number of adjacent memory locations.

Figure 4. Storing the color intensity values in memory


In XNA, we never have to worry about precisely where the compiler chooses to put things. These issues are managed automatically and hidden from our programs. In fact, the way things really work is a little more complex than the explanation given, but for now, it is important for you to remember that computer data is held in memory locations of a particular size and that a particular number of memory locations is available for a program to use.

The same memory locations that store data can also be used to hold program instructions. When an Xbox game is running, it might be that half the memory space holds the game program code (the methods) and the other half holds the data that is being used (the variables). When a game is showing the dreaded "Loading" screen, the Xbox is actually transferring program code and data values from the game disk into the memory.

5. Drawing by Using Our Color Intensity Variables

The color intensity variables that we have created represent the amounts of red, green, and blue that the mood light has. You can use them in your Draw method to create the color to be used to clear the screen:

class Game1 {

// The Game World - our color values
byte redIntensity ;
byte greenIntensity ;
byte blueIntensity ;

protected override void Draw(GameTime gameTime)
Color backgroundColor;
backgroundColor =
new Color(redIntensity, greenIntensity, blueIntensity);

// TODO: Update method goes here


This Draw method looks very like the previous one, except that it uses member variables to define the color that is created rather than specifying particular values. Note that the assignment to backgroundColor has been spread over two lines. The C# compiler is quite happy with this.


Our Great Programmer is very keen on sensible program layout. This means not letting program lines extend off the end of the page. She says if a line gets too long, you should break it at a sensible point (not in the middle of an identifier) and then continue to the next line, slightly indented. She has personally checked all the program listings in this book to make sure that the layout meets her exacting requirements.

6. Updating Our Colors

When the program starts, the values of byte data members are automatically set to 0 and the background color is set to black. If you run a program with the preceding Draw method, you see that the screen just goes black. What you now need to do is take control of the update process and make the colors change over time. When an empty project is created, XNA Game Studio creates a bare-bones Update method that contains a TODO reminding the programmer to add the required code:

protected override void Update(GameTime gameTime)
// Allows the game to exit
if (GamePad.GetState(PlayerIndex.One).Buttons.Back==ButtonState.Pressed)

// TODO: Add your update logic here


The Update method is rather similar to Draw but has an extra couple of statements in it, one of which starts with the word if. This is the part of the code that decides when the game should end. When you ran your program, you may have noticed that pressing the Back button on the gamepad stops the game. These two statements are the ones that dictate that behavior.

The first statement says, "If the Back button on the gamepad for player 1 is pressed, do the next statement," and the second statement says, "Exit the program." Put those together, and you get a behavior that means that when the Update method is called, if the Back button is pressed, the program exits. You are going to spend some time on conditions later, but for now, just remember that if you delete these two lines from your program, it is impossible to stop it via the Xbox gamepad. So don’t delete them.

You may be wondering who calls Update and how often. The answers at the moment are "the XNA engine" and "60 times a second." Whenever your game is active, it needs to update the game world. This has to happen repeatedly for a game to be any fun. The XNA engine calls the Update method to give it a chance to perform. In a full-blown game, this involves reading the gamepad, moving all the objects in the game world, checking to see if any have collided, and so on. In the mood light, the Update method just changes the color values that Draw uses to draw the display.

To start with, you are just going to make a mood light that gets steadily brighter over time, so the Update method increases the value of the red, green, and blue intensities by one each time that it is called:

protected override void Update(GameTime gameTime)
// Allows the game to exit
if (GamePad.GetState(PlayerIndex.One).Buttons.Back==ButtonState.Pressed)

// Make each color brighter


The Update method works by using the ++ operator. An operator is something in the program that tells the compiler that you want to perform an operation on a particular item. In this case, you are using the operator ++ on each of the intensity variables. The item that an operator works on is called an operand. Sometimes operators work by combining operands, and sometimes they work on a single operand. The ++ operator works only on a single operand. The Update method uses it on each color in turn so that each color intensity increases by one. This means that each time the Update method is called, the display should get a little bit brighter.

If you run the program with this Update method, you see that the display does get steadily brighter for about four seconds. Then it goes black again. This does not seem right. One of the additions seems to be making the value much smaller rather than increasing it. To understand why this is, you need to take a look at how numbers are stored in computers.

7. Memory Overflow and Data Values

You have already seen that byte values are actually represented by 8 memory bits. Now you need to understand what this means and the problems that it can cause.

A bit is the smallest unit of data that you can have. A bit is either on or off; in other words, it can store just two different values. The two values are often referred to as true or false. Each value is represented by a particular voltage in the memory of the Xbox, but we don’t need to worry about that in detail.

Think of a bit as a coin on a table. The coin can be either heads or tails; that is, in one of two possible states. If you put a second coin on the table, the two coins in combination now have four possible states, head-head, head-tail, tail-head, and tail-tail. Each coin that you add to the table doubles the number of possible states (that is, when you add the coin, you can have all the previous states with the new coin on heads plus all the previous states with the new coin on tails).

If you do the math with eight coins, you find that they can occupy 256 different states. So 8 data bits can hold 256 different values. One of these values is 0 (all false or all tails), which means that the largest possible integer value that a byte can hold is 255 (all true or all heads). When the ++ operator tries to increase the value of 255, it will produce the value of 256, which cannot be represented by 8 bits. The addition process would like to set the value of a ninth data bit to 1, so that it can represent the value of 256, but there is no ninth bit to set. So what happens is that the other 8 bits are cleared to zero. This causes the value to wrap around, which means that the value in the byte goes back to 0 again. The result of this is that the screen goes from maximum brightness to minimum brightness in a single step. The technical name for this is overflow.

One very important thing to note here is that no error messages are produced. The computer does not "know" that it has done anything wrong. Sometimes if your program does something stupid, you get an error and your program stops. However, in this case, the game does not seem to notice that you have just fallen off the end of a byte and it continues to run. Your program may well do the wrong thing, though. This means that your program has a bug in it. When you create the finished mood light code, you need to make sure that the values never "wrap around" like this.


Note that you have not "run out of memory." Rather, the program has tried to put too much information in a single memory location. The Xbox can work with values much larger than 256; it does this by using multiple storage locations to hold a single item. As an example, you have seen that the information to describe a color fills at least four memory locations.


Our Great Programmer finds it very amusing when people say, "The stupid computer got it wrong." She says this is not what happens. What really happened was that the person who wrote the program did a bad job. She has been known to roll around on the floor laughing when people ask her, "But why didn’t the computer notice it was wrong?" She knows that the computer really doesn’t know or care what a program actually does. The job of the computer is to follow the instructions that the program gives it. The job of the programmer is to write instructions that are correct in every scenario.

  •  Microsoft XNA Game Studio 3.0 : Working with Colors
  •  iPhone 3D Programming : Textures and Image Capture - Creating Textures with the Camera
  •  iPhone 3D Programming : Textures and Image Capture - Dealing with Size Constraints
  •  Programming with DirectX : Game Math - Vectors
  •  iPhone 3D Programming : Textures and Image Capture - Generating and Transforming OpenGL Textures with Quartz
  •  iPhone 3D Programming : Textures and Image Capture - The PowerVR SDK and Low-Precision Textures
  •  Building LOB Applications : Using Visual Studio 2010 WCF Data Services Tooling
  •  Building LOB Applications : Accessing RESTful Data using OData
  •  Programming with DirectX : Additional Texture Mapping - Image Filters
  •  Microsoft XNA Game Studio 3.0 : Making a Game Program
  •  iPhone 3D Programming : Textures and Image Capture - Texture Compression with PVRTC
  •  iPhone 3D Programming : Textures and Image Capture - Texture Formats and Types
  •  iPhone 3D Programming : Textures and Image Capture - Fight Aliasing with Filtering
  •  iPhone 3D Programming : Textures and Image Capture - Texture Coordinates Revisited
  •  Programming with DirectX : Additional Texture Mapping - Sprites
  •  Programming with DirectX : Additional Texture Mapping - Alpha Mapping
  •  Microsoft XNA Game Studio 3.0 : Writing Your First Program (part 2) - Running the Same XNA Game on Different Devices
  •  Microsoft XNA Game Studio 3.0 : Writing Your First Program (part 1)
  •  Programming with DirectX : Shading and Surfaces - Additional Texturing Topics
  •  iPhone 3D Programming : Adding Textures to ModelViewer (part 4) - Enabling Textures with ES2::RenderingEngine
    Most View
    Man In The Middle Attacks
    How did Webs put the world on maps? (Part 3)
    Programming WCF Services : Queued Services - Instance Management
    AMD Trinity: Intel-Beating Gaming Power
    sharepoint 2010 : Utilizing Security Templates to Secure a SharePoint Server
    BlackBerry Java Application : installing the Java Development Kit (JDK), downloading Eclipse with the JDE plugin
    Who’s Watching You? (Part 2)
    Sonance Doi - Degrees Of Invisibility
    Serif WebPlus X6 - Easy-To-Use WYSIWYG Website-Development Tool
    iPhone Application Development : Making Multivalue Choices with Pickers - Using Date Pickers (part 1)
    Top 10
    10 Contenders For The 'Ultimate Protector' Crown (Part 5) : Microsoft Security Essentials 4.1, AVG Antivirus Free 2013
    10 Contenders For The 'Ultimate Protector' Crown (Part 4) : Norton Internet Security, Avast Free Antivirus Version 7
    10 Contenders For The 'Ultimate Protector' Crown (Part 3) : Eset Smart Security 6, Kaspersky Internet Security 2013, Zonealarm Internet Security 2013
    10 Contenders For The 'Ultimate Protector' Crown (Part 2) : Bitdefender Total Security 2013, Trend Micro Maximum Security, Mcafee Internet Security 2013
    10 Contenders For The 'Ultimate Protector' Crown (Part 1)
    Sony Xperia TL - Much Improved But Still Imperfect (Part 3)
    Sony Xperia TL - Much Improved But Still Imperfect (Part 2)
    Sony Xperia TL - Much Improved But Still Imperfect (Part 1)
    Simple.TV - Transmits TV Programs To Mobile (Part 2)
    Simple.TV - Transmits TV Programs To Mobile (Part 1)