3D Game Programming

Collections Part 1

Brecht Kets - Microsoft XNA MVP — Wed, 11 Apr 2012 13:24:53 +0000

1. Introduction
2. Array
3. Collections

1. Introduction

Just like C++, C# has different types of collections you can use to manage data. In this knol, we’ll discuss arrays and the containers from the System.Collections namespace.

Note that the containers of the System.Collections namespace are not recommended. The reason is that they cause a lot of boxing and unboxing. You should use generic collections from the System.Collections.Generic namespace (like List), which I will explain in part 2.

2. Array

2.1 General

Unlike C++, where an array is just a pointer to the first item in that array, in C# an array is an object of type System.Array. This means an array is a real class with properties and methods, which makes handling arrays a lot easier in C# than C++. You also can’t go beyond the memory allocation of the array. If you try to access an element outside of the bounds of the array, you will get an IndexOutOfRange exception.

Just like C++, an array is a sequence of elements, and all elements must be of the same type. The elements also live in a continuous block of memory.

Declaring an array is similar to the way you do it in C++, except the fact that you put the square brackets after the type, not the variable name.

int[] arr = new int [5];

The code above creates an array of integers, that reserves memory for 5 elements. You always have to call new in order to create a new array. The size of the array can be determined at runtime. The code below is completely valid (assuming you enter the correct input in the console).

int[] arr = new int[int.Parse(Console.ReadLine())];

When you create an array instance, all elements are initialized to their default value (depending on their type). You can also initialize the elements to a specific value, by specifying them between curly braces.

int[] arr = new int [5] {1,2,3,4,5};

Or even shorter:

int[] arr = {1,2,3,4,5};

2.2 Iterating an array

An array has a property Length, which tells you how many items the array contains. This property makes iterating an array very easy.

for (int i = 0; i < arr.Length; ++i)
Console.WriteLine(i.ToString());

You can also use the foreach statement to iterate through an array, and all collections as a matter of a fact. This is because they implement the IEnumerable interface. In future knols, you will learn more of IEnumerable, but for now it’s enough if you know that implementing the interface enables you to loop through a collection using a foreach statement.

foreach(int i in arr)
Console.WriteLine(i.ToString());

Foreach always iterates though all the items of the collection, from the first to the last element. If you want to iterate backwards, or skip certain items, you must use the ‘for’ statement.

2.3 Copying arrays

2.3.1 Shallow and deep copy

First of all, it’s necessary that you know the difference between shallow and deep copy. If the elements that your array contains are reference types, a shallow copy will copy the references, but not the objects to which they point. So after the copy operation both the original and the copy point to the same objects. A deep copy will clone the objects themselves, so the original and the copy don’t point to the same objects.

All copy methods you will see below perform shallow copying. If you want to create a deep copy, you’ll need to write the code yourself.

2.3.2 Copy

The System.Array class has a static method Copy. You can use this method to create a shallow copy of an array. It takes the original array, the destination array and the length as arguments.

int[] original = new int[10] { 1, 2, 3, 4, 5 };
int[] copy = new int[5];

Array.Copy(original, copy, 5);

2.3.3 CopyTo

Another way to copy an array is to use the CopyTo method. It takes to destination array and a starting index as arguments.

int[] original = new int[5] { 1, 2, 3, 4, 5 };
int[] copy = new int[5];

original.CopyTo(copy, 0);

2.3.4 Clone

An array also has a Clone method, which creates a shallow copy of the array and returns the copy. The Clone method creates the object for you; you do have to cast the return value to the appropriate type.

int[] original = new int[5] { 1, 2, 3, 4, 5 };
int[] copy = (int[]) original.Clone();

3. Collections

Unlike C++, it is safe to use arrays in C#. However they do have certain limitations. In the System.Collections namespace, several collections that will make your life easier are provided. All collections implement the IEnumerable interface, so you can make use of the foreach statement. Most collections from the System.Collection namespace use object as type for their elements. So object[] instead of int[] for example. The System.Collections.Generics namespace offers a solution for that. This will be discussed in the 2^ndcollections knoll.

3.1 ArrayList

An arraylist is a collection that doesn’t have a fixed number of elements like an array does. It’s also very useful when you want to add, insert and remove a lot of elements at runtime.

When you use an array and you want to resize it, you have to create a new one, copy the elements, update references, … Removing items from the array means you’ll have to move all trailing elements, … The arraylist does all this for you. You use an ArrayList as is shown below:

// Create a new arraylist
ArrayList myAL = new ArrayList();
myAL.Add(“Hello”);
myAL.Add(“!”);

// Insert World between Hello and !
myAL.Insert(1, “World”);

// Add two items to the end of the arraylist
myAL.Add(“test”);
myAL.Add(“test2″);

// Remove the items that have “test” as value
myAL.Remove(“test”);

// Remove the item at index 3
myAL.RemoveAt(3);

// Displays the properties and values of the ArrayList.
Console.WriteLine(“myAL”);
Console.WriteLine(“    Count:    {0}”, myAL.Count);
Console.WriteLine(“    Capacity: {0}”, myAL.Capacity);
Console.Write(“    Values:”);

// Write all objects to console. Note the object keyword!
foreach (Object obj in myAL)
Console.Write(“ {0}”, obj);

Console.WriteLine();

3.2 BitArray

The BitArray container is a compact array of bit values that represent booleans. 1 indicates that the bit is on (true), 0 that the bit is off (false).

3.3 Hashtable

An arraylist for example, makes it easy to map an integer (index) to a certain value. But sometimes we want the key (the index) to be something different than an integer. A hashtable has two arrays internally, one for the keys, and one for the objects. A hashtable is very similar to the C++ map.

There are some things one should be aware of however:

A hashtable cannot contain duplicate keys.
A hashtable can contain duplicate values.
When using the foreach statement on a hashtable, you get back objects of type DictionaryEntry.

Hashtable openWith = new Hashtable();

// Add some elements to the hash table. There are no
// duplicate keys, but some of the values are duplicates.
openWith.Add(“txt”, “notepad.exe”);
openWith.Add(“bmp”, “paint.exe”);
openWith.Add(“dib”, “paint.exe”);
openWith.Add(“rtf”, “wordpad.exe”);

// The Add method throws an exception if the new key is
// already in the hash table.
try
{
openWith.Add(“txt”, “winword.exe”);
}
catch
{
Console.WriteLine(“An element with Key = \”txt\” already exists.”);
}

foreach (DictionaryEntry entry in openWith)
Console.Write(“ {0}, {1}”, entry.Key, entry.Value);

Console.WriteLine();

3.4 Queue

The queue in C# is very similar to the C++ queue. It’s a collection that implements the first-in, first-out (FIFO) principle. Items that are queued are inserted at the back, and removed from the front.

Usage is very straightforward:

Queue myQ = new Queue();
myQ.Enqueue(“Hello”);
myQ.Enqueue(“World”);
myQ.Enqueue(“!”);

// Displays the properties and values of the Queue.
Console.WriteLine(“myQ”);
Console.WriteLine(“\tCount: {0}”, myQ.Count);
Console.Write(“\tValues:”);

// Write all items to the console
foreach (Object obj in myQ)
Console.Write(“ {0}”, obj);

// dequeue the first item (Hello)
string hello = (string) myQ.Dequeue();
Console.WriteLine();

3.5 SortedList

A sorted list is very similar to a hashtable, except that the values are sorted by key. The usage and restrictions of the sorted list are similar to the hashtable.

// The items will be sorted by key
SortedList mySL = new SortedList();
mySL.Add(“First”, “Hello”);
mySL.Add(“Third”, “!”);
mySL.Add(“Second”, “World”);

// Displays the properties and values of the SortedList.
Console.WriteLine(“mySL”);
Console.WriteLine(“ Count: {0}”, mySL.Count);
Console.WriteLine(“ Capacity: {0}”, mySL.Capacity);
Console.WriteLine(“ Values:”);

foreach (DictionaryEntry entry in mySL)
Console.Write(“ {0}, {1}”, entry.Key, entry.Value);

Console.WriteLine();

3.6 Stack

The stack in C# is also very similar to the C++ stack. It’s a collection that implements the last-in, first-out (LIFO) principle. An element is added (push) to the top of the stack, and removed (pop) from the top as well.

Stack myStack = new Stack();
myStack.Push(“Hello”);
myStack.Push(“World”);
myStack.Push(“!”);

// Displays the properties and values of the Stack.
Console.WriteLine(“myStack”);
Console.WriteLine(“\tCount: {0}”, myStack.Count);
Console.Write(“\tValues:”);

foreach (Object obj in myStack)
Console.Write(“ {0}”, obj);

// Pop the first item (!)
string exlamationmark = (string)myStack.Pop();

Console.WriteLine();

Value types and reference types

Brecht Kets - Microsoft XNA MVP — Wed, 11 Apr 2012 08:26:48 +0000

Introduction
Value Types
Reference Types
Ref and Out parameters
- General
- Ref
- Out
Nullable Types
- General

Introduction

When programming in C#, it is of utter importance that you understand the differences between value types and reference types, because using them has consequences that will become apparent after reading this document.

Value Types

Types such as int, float, double, char, structs, … are value types. This means that when you declare a variable of such a type, the compiler will allocate a block of memory that is large enough to contain the corresponding value. For example, the compiler will allocate 4 bytes of memory when you declare a variable of type int. When assigning a value to this variable (example 1), the block of memory will be copied.

Example 1:

Declare a variable of type integer (i) and initialize it to 1. Then declare a second variable of type integer (y), and assign it to the value of i. Executing i++ doesn’t affect y, because a copy is made.

int i = 1; // Declare and initialize i

int y = i; // Make a copy

i++; // Increment i, y doesn’t change

It is often stated that value types reside on the stack and reference types reside on the heap. This is incorrect. Value types are types which reside in their own memory, and don’t have a pointer to them. The type of an object doesn’t really have anything to do with the place where it’s stored; it’s the lifetime that matters. More info about this confusion can be found in the article “The truth about value types”.

In C#, almost all primitives are value types, with string as an exception. All structs are also value types. This has some consequences.

An example: a form has a property Location that you can use to set the location of your form. This property is a struct. When I access the location of the form, I get back a copy. This means you can’t change the location like follows:

this.Location.X = 3;

This code will result in a compiler error, although it looks like reasonable code. Let us write the code above in C++:

this->getLocation().setX(3);

Obviously this doesn’t have the intented effect: getLocation returns a local copy of the location, and setX would change this local copy, having no effect on the instance itself.

You have to use the following workaround:

Point loc = this.Location;
loc.X = 3;
this.Location = loc;

Reference Types

When declaring an object that is a reference type, the compiler takes different actions than with value types. The compiler won’t allocate a block of memory that is large enough to contain your object. Instead it will allocate a small block of memory that can contain a reference (managed pointer) to your object. It is often said that references go on the stack because they themselves are value types. This is incorrect. References aren’t value types, they’re just values (they have no type in the c# type system). The reference does point to your object, which resides on the heap. So reference types have references to blocks of memory on the heap.

Objects of type string are also reference types, as the keyword string is just an alias for the class System.String.

Example:

Declare a variable of type Button (button1). This variable can point to a Button object. Declare a second variable of type Button (button2). When I assign the value of button1 to button2, both references point to the same object. There is only 1 Button object, but there are two references. When changing button2, button1 also changes.

// Declare and initialize a new Button
Button button1 = new Button();

// Declare a variable of type Button and let it point to button1
Button button2 = button1;

// button2 also changes the text of button1, because
// only 1 object exists
button2.Text = (“I also change button1″);

One consequence of reference types is that you can changes these from within a method. An example: when I pass button1 as argument to a function, this function can change the object. With value types, you would just pass a copy.

private void ReferenceDemo(Button btn)
{
// I change the original Button here
btn.Text = “changed”;
}

Note that in C#, there is no way to pass the button object as a const argument.

Ref and Out parameters

General

When passing an argument to a method or function, a copy is passed by default. This is true for value types and reference types. It is however so that with reference types, a copy of the reference is passed, and the object to whom it refers stays the same. This has as a consequence that you can’t change the value of the parameter passed.

Example:

private void ReferenceDemo(Button btn)
{
     // I change the original Button here
     btn.Text = “changed”;

   // The original reference isn’t changed
        btn = null;
}

In the method above, it is possible to change the text of the button, but making the reference point to null has no impact on the original object, only on the copy of the reference which has been passed to the method ReferenceDemo.

On the other hand, when I pass a variable of type int as parameter to a method, I can’t change the value of the original int. In C++, you would pass an int-reference (not to be mistaken with a C# reference) to solve this.

In C#, there are 2 ways to get the results we want, via the keywords ref and out.

Ref

When you place the ref keyword before the type of an argument, the parameter becomes an alias to the argument, and not a copy. So by using the ref keyword, you can change the original object.

Example 1: int

private void RefDemo(ref int i)
{
// I change the original object here
i = 3;
}

Example 2: Button

private void ReferenceDemo(ref Button btn)
{
// I change the original object here
btn.Text = “changed”;

// The original reference is changed
btn = null;
}

To call a method which has a ref parameter as argument, you also need to add the ref keyword during the method call:

int i = 10;

RefDemo(ref i);

Button btn = new Button();

ReferenceDemo(ref btn);

One thing you have to be aware of when using the ref keyword is that the variable has to be initialized in order to pass it as an argument to a method. The code below will result in a compile error.

Button btn;

ReferenceDemo(ref btn);

In some cases, this could be a problem. Sometimes you want the method itself to initialize the variable. For example, in this case, I could want that the method ReferenceDemo has a bool as return value, that informs me if everything went right (the C++ way ), and as argument an object of type Button that is initialized in the method ReferenceDemo. This behavior can be obtained by making usage of the out keyword.

Out

The out keyword is very similar to the ref keyword. Prefixing an argument with the out keyword passes an alias to the argument, and not a copy. The only difference is that when making use of the out keyword, the method itself must assign a value to the object. The code below will result in a compile error.

private void ReferenceDemo(out int i)
{

}

The code below will work:

int i;

ReferenceDemo(out i);

private void ReferenceDemo(out int i)
{
i = 42;
}

Nullable Types

General

The keyword null is very handy when using reference types, because then you can see if the object is initialized. With value types, it is not possible to use the null keyword. The code below will result in a compile error.

int i = null;

This is because null itself is a reference type. But there is a way to assign null to a value type, by using the ‘?’ operand. An example will clarify things.

int? i = null;

The code above works, but what happens? The C# compiler will make an object of type Nullable. Nullable is a generic structure that internally looks like this:

public struct Nullable where T : struct
{

public Nullable(T value);

public static explicit operator T(T? value);

public static implicit operator T?(T value);

public bool HasValue { get; }

public T Value { get; }

public override bool Equals(object other);

public override int GetHashCode();

public T GetValueOrDefault();

public T GetValueOrDefault(T defaultValue);

public override string ToString();
}

The rule int? i creates an object of type Nullable with as generic parameter an integer. Take into account that this object is still a value type (Nullable is a struct). Note that the Nullable class has a property HasValue; because it is possible to assign null to the variable, there has to be a way to see if the object has a value.

Also note that when you want to pass a nullable type as argument to a method, this also has to be a nullable type.

int? i = null;

NullableDemo(i);

private void NullableDemo(int? i)
{
if(i.HasValue)
int valueOfi = i.Value;
}

The code above can also be written as follows:

private void NullableDemo(int? i)
{
if(i != null)
int valueOfi = (int) i;
}

An introduction to C# and the .NET framework

Brecht Kets - Microsoft XNA MVP — Tue, 10 Apr 2012 12:13:26 +0000

1. Introduction

C# is an object oriented programming language built on top of the .NET framework. C# Is a higher level language that enables you to write code fast. Compared to C++, there are some differences one should be aware of. These differences will be handled in this article. This article will not offer you in depth knowledge about C# and the .NET framework, but rather glance at the differences. You will gain in depth knowledge in future articles. At the moment of writing, we’re at C# version 4.

2. .NET framework

2.1 General

The .NET framework is built by Microsoft. It offers seamless collaboration between libraries written in different programming languages. .NET is a managed framework, meaning certain things are handled for you, such as garbage collection. .NET programs aren’t, unlike C++, compiled to machine code, but rather to an intermediate language, called CIL (Common Intermediate Language). This CIL code is then translated to machine code at run time by the CLR (Common Language Runtime), by making usage of JIT (Just In Time) compilation.

There are several programming languages you can use to develop on the .NET framework, such as C#, VB.NET, C++/CLI, Boo, … All these languages are compiled to the same CIL. Because all programs are compiled to an intermediate language, it’s also fairly easy to decompile it again (to the same, or another programming language). If you want to decompile .NET code, take a look at Reflector.NET.

2.2 History

2002: .NET framework 1.0 + Visual Studio 2002

2003: .NET framework 1.1 + Visual Studio 2003

2005: .NET framework 2.0 + Visual Studio 2005

2006: .NET framework 3.0

2007: .NET framework 3.5 + Visual Studio 2008

2010: .NET framework 4.0 + Visual Studio 2010

2.3 Advantages and Disadvantages

Development using the .NET framework has its advantages and disadvantages when comparing to development in C++. Let us start with the advantages. First of all, you can develop a lot faster when compared to C++. One might say that you produce code at about 5 times the speed than you would in C++. Second of all, it’s a lot easier an more accessible than C++. And you have a garbage collection system which offers automatic deallocation, eliminating almost all memory leaks. It’s also cross platform, meaning your code will work on several versions of Windows, and if you use the compact framework, your code will work on mobile devices, Xbox 360 and Windows Phone. With the help Mono, your code will even run on Linux (Note: not all .NET features are supported on Mono). The Unity3D gamdev IDE is built on top of Mono.

Development using the .NET code also has some disadvantages. First of all, because your code is compiled to an intermediate language, it’s a lot easier to decompile code than it would be with C++ code. Luckily several obfuscating techniques exist that make this process more difficult. The garbage collector (“GC”) can also be a disadvantage. One has to have a good understanding about what it does to make sure it doesn’t become a bottleneck. The GC on the Windows is fairly advanced, but the one on the compact framework isn’t as effective. When building games in XNA for Xbox 360 and Phone 7 Series, the GC will be something you will have to pay attention to. Then the final thing is that .NET code can run slower than C++. But let us be honest, isn’t this the same discussion that we have when moving from Assembler to C? Or from C to C++? Also, bear into mind that it’s fairly easy to write slow C++ code if you don’t know what you’re doing; doing so in .NET is a bit harder since the framework manages a lot for you.

3. The C# programming language

3.1 Introduction

C# (pronounced C Sharp) is an object oriented programming language developed by Microsoft. It is accepted as a standard by the ECMA (ECMA-334) and ISO (ISO/IEC 23270). C# has an object oriented, procedural syntax and is based upon the C++ syntax. It also has some Java elements, and even some functional and dynamic programming language influences. At the moment of writing, C# is at version 4.0. The Microsoft compiler for C# 4.0 was released in 2010, but the language specification dates from 2006.

Now let us start with mentioning some differences between C# and C++.

3.2 Everything is an Object

In C#, and the .NET framework, everything inherits from System.Object. This leads to the fact that in C#, you could write the following code:

(7).ToString();

“THIS IS A STRING”.CompareTo(“SECOND STRING”);

This means you can also cast everything to System.Object, since they’re all derived from that base class.

3.3 Headers

C# doesn’t use header files. Because .NET is compiled to an intermediate language, there is no need for header files, since the DLLs it compiles to (called “assemblies”) contain all information about the classes and methods in it.

Take a look at the class below:

public class Hero

{

// FIELD (called data member in C++)

private string _nemesis;

// CONSTRUCTOR

public Hero()

{

}

// NO DESTRUCTOR IS NEEDED!!!

// METHOD (called member function in C++)

public void SaveTheWorld()

{

}

private void AskForHelp()

{

}

The class itself has the ‘public’ access specifier. Each method has its own access specifier as well. So do the fields.

Note that classes in C# don’t have destructors, since they are collected automatically by the GC (you do have finalizers, but these are only used when you inter-operate with native APIs like DirectX)

3.4 Pointers

C# has pointers (in unsafe mode), but you’ll almost never use them. C# has two different kinds of types: value types (structs and enums), that hold the data in its own memory allocation and reference types (classes and arrays), that store a reference to the data. Unlike C++, it is the definition of type itself that determines if the data is passed by copy or by reference. This reference is not to be confused with C++ references. References in C# can be compared with a sort of managed pointer, without the overloaded pointer operations. This also means you shall almost never use the -> operand. You can always access type members by using the “.” operand. For example, if I would want to call the method SaveTheWorld on a Hero object, I would just write the following code:

// Create a new instance of the Hero class,

// and store a reference to it in the hero local variable

Hero hero = new Hero();

// Call the method SaveTheWorld.

hero.SaveTheWorld();

In C++, this would look like:

Hero* hero = new Hero();

hero->SaveTheWorld();

3.5 Properties

C# has a special syntax for writing getters and setters, called properties. When you would want to expose a member called Nemesis, in C++, you would write the following code:

class Hero

{

public:

const char* getNemesis() {return m_Nemesis;}

void setNemesis(const char* nemesis) {m_Nemesis = nemesis;}

private:

const char* m_Nemesis;

};

If you want to set the name of the hero, you need to call hero->setName(“Name”).

In C#, you would write the code as follows:

public class Hero

{

private string _nemesis;

public string Nemesis

{

get { return _nemesis; }

set { _nemesis = value; }
}

}

The C# compiler will then generate getters and setters methods for you. If you would like to set the name of the hero, you would have to write the following code:

hero.Nemesis = “nemesis”;

If you would like to get the name of the nemesis, you would have to write the following code:

string nemesis = hero.Nemesis;

If the property call is on the left of the assignment operator, then the setter is called; if it is on the right side, the getter is called.

3.6 Interfaces

An interface contains the signatures of methods, delegates, events, but has no implementation. You can compare an interface with an abstract class that only contains pure virtual methods.

public interface IHero

{

void SaveTheWorld();

}

public class Hero : IHero

{

public void SaveTheWorld()

{

// IMPLEMENTATION

}

An interface could be seen as a blueprint of what methods a class should contain. An interface can inherit from one or more base interfaces.

3.7 Inheritance

In C#, inheritance is different than in C++. First of all, the distinction between structs and classes has to be made. Structs (value types) do not support inheritance, classes (reference types) do. C# doesn’t have multiple inheritance where one class can be derived from several other classes. You can only derive from one base class. You can implement multiple interfaces though.

So our class Hero could inherit from a base class person, and still implement the IHero interface.

3.8 Arrays

An array in C# is an object of type Array (a reference type). An Array is a class (unlike C++, where an array is just a pointer to the first element of the array). An array in C# has methods and properties, such as the property Length. Another difference is that the square brackets ([]) follow the type and not the variable.

In C#, a variety of higher level collection classes exists, such as List, Dictionary (these are similar to C++ std::vector, std:map, …)

3.9 Strings

A C# string object is an instance of the System.String class. In C++, strings are an array of characters, and always a hassle to work with. In C#, a string is an immutable object, meaning you cannot change the string object itself. You can however combine strings into new strings (for example concatenating two strings using the + operator).

3.10 Casting

C# has support for c-style casts, just like C++, but it doesn’t have static_cast support. All casts in C# are like C++ dynamic_cast, but they will throw an exception if the object is not of the correct type.

object obj = …

Hero hero = (Hero)obj;

You can also use the ‘as’ keyword, which returns null it the cast fails. This is similar to the dynamic_cast in C++.

Hero hero = obj as Hero;

HLSL Shaders

Brecht Kets - Microsoft XNA MVP — Mon, 19 Jan 2009 10:17:29 +0000

Koen Samyn, lecturer interactive programming at the University College of West Flanders (curriculum Digital Arts and Entertainment) wrote an excellent KNOL (a unit of knowledge) on HLSL Shaders. You can find the article here:
http://knol.google.com/k/samyn-koen/-/2lijysgth48w1/2#

Extract:

What is a shader ?
A shader ( or effect) is a program that is executed on the GPU (Graphical Processing Unit). The GPU is located on the graphics card off course and the GPU contains many cores that can execute a shader program concurrently. This allows the GPU to have high throughput (number of triangles that can be processed per second).

If for example a GPU has 4 available cores (run of the mill GPU have much more then that) each code transform the vertices of 4 triangles simultaneously. There are several shader API’s and languages that are targeted to curent GPU’s : …

Ziggyware Fall 2008 XNA Article Contest – Win an Xbox 360 Elite and More

Brecht Kets - Microsoft XNA MVP — Mon, 13 Oct 2008 08:42:39 +0000

Ziggyware has announced a new Article Contest, where you have to write an XNA related tutorial for XNA developers.

You can win an Xbox 360 Elite and several creators club subscriptions.

More info: ziggyware

XNA 3.0 Beta Released

Brecht Kets - Microsoft XNA MVP — Thu, 18 Sep 2008 08:46:09 +0000

Microsoft has released a Beta for XNA 3.0. This new update features many improvements and new features for Zune, XBox 360 and PC.

Zune

* Compatibility with the upcoming Zune 3.0 Firmware release. Please note that the XNA Game Studio 3.0 CTP will no longer work once you have upgraded your Zune device to the 3.0 firmware.
* Improved deployment stability.
* Support for Zune deployment on Windows Vista x64 Systems!
* You can now use the Remote Performance Monitor for Zune games.

Xbox 360

* Xbox 360 project templates (You will not be able to develop on the Xbox 360 until our final release. We felt this was important to include so that you could get projects converted over and look at the system, even if you are not able to run the games, yet).
* Support for the Big Button Pad.

Framework & Visual Studio Features

* Enumerate and play back media on your Windows computer or Xbox 360.
* Simple sound effect support on Windows computers and Xbox 360.
* Support for Rich Presence (lets friends know what’s going on in your game).
* Support for Invites (ask your friends to join you in a multiplayer game) and Join Session In Progress (after you see what your friends are doing, you can join their current session with just a couple of button presses, even if that’s a different game to the one you are currently playing)
* Compress your content and save space with the new content compression features!
* ClickOnce packaging support for distributing your XNA Framework games on Windows.
* Upgrade your project from XNA Game Studio 2.0 using the Project Upgrade Wizard!
* Take screen captures of your game running on Zune through the XNA Game Studio Device Center.
* Support for .NET language features like Linq
* Create multiple content projects and leverage cross project synchronization in Visual Studio.
* FBX importer improvements: read materials containing multiple textures, and export custom shader materials directly out of Max or Maya.

Earn Money from your Xbox LIVE Community Games

Brecht Kets - Microsoft XNA MVP — Wed, 23 Jul 2008 17:12:35 +0000

Today Microsoft announced the pricing plan for your XNA Community Games on Xbox LIVE. This payment plan is fairly flexible allowing you to charget between 2.50 and 10.00 dollars for your game on Xbox LIVE. Microsoft will let you keep 70 percent of the profit and may even advertise the game for you if it is very successful.

Read More on the XNA Team Blog

Xbox Live Community Games

Source: ziggyware

XNA games coming to the Zune, Xbox Live Arcade

Brecht Kets - Microsoft XNA MVP — Thu, 21 Feb 2008 20:57:30 +0000

This morning at the Game Developers Conference in San Francisco, Microsoft announced the next step in its Xbox Live and XNA initiative: the Zune will become the third pillar supporting XNA software, with over 1,000 games ready for the device by year end. XNA software developed for the Xbox Live Arcade is now going to be opened to the public.

Microsoft showed off an XNA game running on a Zune during a keynote speech presented by vice president John Schappert. A top-scrolling space shooter was shown running on a PC, an Xbox 360, and, lastly, a Zune. In addition, Zune games will be multiplayer: users will be able to play against each other online. Games for the platform will be arriving this year alongside the launch of Xbox Live Community Games.

The new XNA-oriented service, Xbox Live Community Games, allows select user-created software to be distributed through Xbox Live, effectively opening user-created games to the masses. Titles will be selected through a democratized game distribution system pulling on the Creator’s Club user base. Members will be able to screen and vote on games, with those reaching a certain level of approval cleared and released to the public. A handful of these games are now available as trials on the Xbox Live Marketplace.

Creator’s Club members are paying subscribers who have access to the XNA development platform. Much like the gamercard, a “creator card” will show what games specific creators have built. XNA is a suite of development software which Microsoft introduced in 2006. The suite allows developers to create projects that can easily be translated between the support platforms. Previously only the PC and the Xbox 360 were supported, but the Zune represents Microsoft’s first significant step into the mobile gaming market.

excerpt from http://arstechnica.com/news.ars/post/20080220-xna-games-coming-to-the-zune-xbox-live-arcade.html

A preview release of XNA Game Studio 3.0 will be available in the Spring 2008 timeframe, with a final release scheduled for the holiday 2008 season.

Xbox LIVE Community Games

Brecht Kets - Microsoft XNA MVP — Thu, 21 Feb 2008 08:02:22 +0000

The XNA team is delighted to announce the Xbox LIVE community games, scheduled for launch in the holiday 2008 season, with a beta coming in spring 2008. This offering gives the opportunity to share, peer review, download and play games created by the community, for the community. Read the FAQ for more details, or discuss in the special forum thread.

FAQ Link
Forum Thread Discussion Link

XNA_BUG : February 2008 XNA Contest

Brecht Kets - Microsoft XNA MVP — Fri, 01 Feb 2008 21:31:16 +0000

The XNA Belgian User Group organizes the February 2008 XNA Contest

This contest is open for developers and designers, working on XNA Games. The development and demo can be done on a PC platform or XBOX 360.
The participants can form teams of 2 people working together. Participants have to be 16 years old at the days of the finals, but not older than 36 years (born between February 23, 1972 and February 23, 1992) AND live in Belgium.

The contest is based on a ‘starter kit’, consisting of a ‘nearly finished’ game, build on top of XNA. The purpose of the contest is to extend this starter kit in the best and most creative way. The starter kit will be made available from February 1 on http://www.xnabug.net/starterkits.htm
Submissions will be judged on creativity, innovation and ‘playability’ of the demo.

To judge the submissions, participating teams need to:
- Enroll for the contest by mailing an enrollment form to [BRECHT at XNABUG dot NET]. The enrollment form is available here. The enrollment form has to be received by February 18 midnight.

- Prepare 2 ‘posters’ explaining the submission. The posters have to be printed on A3 paper size. These posters will be used during round one on during the finals, February 23. Based on the posters and questions and answers, the jury will select the teams which will present and demo their submission.

- Prepare a presentation/demo of 10 minutes and 5 minutes of questions and answers. This demo and presentation will be done February 23 in front of the jury and the audience. It will be executed on the equipment of the participating team. The facility to project on a large screen will be provided by the organization.

Judging criteria:
The submissions, posters and presentations/demo’s will be judged by a multidisciplinary team of gaming specialists., active in training, development, design and press. The judging criteria will be: |innovation|, |creativity| and |play, demo|.

What can you win:
The winning team will receive an XBOX 360 elite for every participant (up to 2). Every team presenting / demo during the finals will receive an XNA Creators Club account and more.
The finals will take place in the auditoria of Groep T, Campus Vesalius, Vesaliusstraat 13, 3000 Leuven (INFO).

For more information:
http://www.xnabug.net
http://www.microsoft.com/xna

3D Game Programming

Collections Part 1

Contents

1. Introduction

2. Array

2.1 General

2.2 Iterating an array

2.3 Copying arrays

2.3.1 Shallow and deep copy

2.3.2 Copy

2.3.3 CopyTo

2.3.4 Clone

3. Collections

3.1 ArrayList

3.2 BitArray

3.3 Hashtable

3.4 Queue

3.5 SortedList

3.6 Stack

Value types and reference types

Contents

Introduction

Value Types

Reference Types

Ref and Out parameters

General

Ref

Out

Nullable Types

General

An introduction to C# and the .NET framework

1. Introduction

2. .NET framework

2.1 General

2.2 History

2.3 Advantages and Disadvantages

3. The C# programming language

3.1 Introduction

3.2 Everything is an Object

3.3 Headers

3.4 Pointers

3.5 Properties

3.6 Interfaces

3.7 Inheritance

3.8 Arrays

3.9 Strings

3.10 Casting

HLSL Shaders

Ziggyware Fall 2008 XNA Article Contest – Win an Xbox 360 Elite and More

XNA 3.0 Beta Released

Earn Money from your Xbox LIVE Community Games

XNA games coming to the Zune, Xbox Live Arcade

Xbox LIVE Community Games

XNA_BUG : February 2008 XNA Contest