Communist Games

Free memory allocated on the free-store(heap) when exiting scope

2012-02-18T16:01:00.000+02:00

In C++ to free memory allocated on the free-store when you exit form a scope{} or when an exception occurs you could use a smart pointer or you could use something like this :

#include <iostream>

#include <exception>

template<typename O>

struct _DeletePointerOnEndScope

{

inline _DeletePointerOnEndScope(O pointer) throw()

{

static_assert(false,"DeletePointerOnEndOfScope can only be used withpointers");

}

inline ~_DeletePointerOnEndScope() throw()

{

}

};

template<typename O>

struct _DeletePointerOnEndScope<O*>

{

O* ptr;

inline _DeletePointerOnEndScope(O* pointer) throw() :ptr(pointer)

{

}

inline ~_DeletePointerOnEndScope() throw()

{

delete ptr;

}

};

#define DeletePointerOnEndOfScope(pointer)_DeletePointerOnEndScope< decltype(pointer)> scope_##__LINE__ ((pointer))

/*You should probably place the part above this comment in a proper header with a proper include guard.*/

void ThrowTest()

{

struct ThrowTestClass

{

~ThrowTestClass()

{

std::cout<< "I was destroyed !!!!"<< std::endl;

}

};

try

{

auto throw_test = newThrowTestClass();

DeletePointerOnEndOfScope(throw_test);

throw std::exception("Ican has exception !");

}

catch(std::exception& e)

{

std::cout<< e.what() << std::endl;

}

int main(int argc, char* argv[])

{

ThrowTest();

return 0;

}

This is legal C++11 and it can be used with any modern C++ compiler.

DDS from file on XNA 4.0

2010-12-06T14:41:00.052+02:00

In XNA 4.0 the Texture.FromFile() and Texture.Save() methods where removed letting us with no option on directly loading or saving dds files in our applications, we can load dds files trough the content pipeline but for an editor or for any application/game where you can create or even add content dynamically this is simply not an option.
For this reason I created a small dds manipulation library for XNA 4.0, it can load almost any Directx9 dds type that containes a 2d texture a volume texture or a cube-map and it can save Texture2D,Texture3D and TextureCube with all the available XNA surface formats except for HdrBlendable.
It will load mip-maps only if the data contains a complete chain, this is for consistency with the rest of the XNA 4.0 framework, if an incomplete mip-map chain is discovered only the main surface will be loaded.

Save a Texture2D or a TextureCube as a dds to a file:
DDSLib.DDSToFile("texture.dds", true, texture, false);

Save a Texture2D or a TextureCube as a dds to a stream:
DDSLib.DDSToStream(stream,0, true, texture);

Load a dds from a file:

DDSLib.DDSFromFile("texture.dds", GraphicsDevice,true, out texture);

Load a dds from a stream:

DDSLib.DDSFromStream(stream,0, GraphicsDevice,true, out texture);

Get the size in bytes for a mip-map level:

DDSLib.GetDataByteSize(texture, level)

DDS Formats it can read :
Dxt1,Dxt2,Dxt3,Dxt4,Dxt5,A8R8G8B8/Color,X8R8G8B8,R8G8B8,A4R4G4B4,
A1R5G5B5,R5G6B5,A8,FP32/Single,FP16/HalfSingle,FP32x4/Vector4,
FP16x4/HalfVector4,CxV8U8/NormalizedByte2/CxVU,
Q8VW8V8U8/NormalizedByte4/8888QWVU,HalfVector2/G16R16F/16.16fGR,
Vector2/G32R32F,G16R16/RG32/1616GB,B8G8R8,X8B8G8R8,A8B8G8R8/Color,L8,
A2B10G10R10/Rgba1010102,A16B16G16R16/Rgba64

DDS Formats it can write:
Dxt1,Dxt3,Dxt5,A8R8G8B8/Color,A4R4G4B4,A1R5G5B5,R5G6B5,A8,
FP32/Single,FP16/HalfSingle,FP32x4/Vector4,FP16x4/HalfVector4,
CxV8U8/NormalizedByte2/CxVU,
Q8VW8V8U8/NormalizedByte4/8888QWVU,HalfVector2/G16R16F/16.16fGR,
Vector2/G32R32F,G16R16/RG32/1616GB,A8B8G8R8,
A2B10G10R10/Rgba1010102,A16B16G16R16/Rgba64

It has support for cube-maps.
It has support for volume textures.

It is released under the MIT/X11 license as a result you can do whatever you want with it, you just have to mention me on the credits.

If you download it you agree with the terms of the license.

License :

http://cid-58baf3506093b62a.office.live.com/self.aspx/.Documents/DDSLib/LICENSE.txt

You can download it from here :

http://cid-58baf3506093b62a.office.live.com/self.aspx/.Documents/DDSLib/DDSLib.cs

Notes :

-For the A2B10G10R10 known in XNA as Rgba1010102 there is a problem the RED and BLUE masks are backwards from the actual data ordering, this is for consistency with XNA and Directx, if you try to open such files in an editor the red and blue channel might get changed with each other, but if you open them with the Directx Texture Tool or trough the XNA Content Pipeline they will look as they should.

-At some point I will release a standalone c# dds reader for the gdi+.

If you have something to say live a comment here or send me an email on kiki_karon@yahoo.com
I hope the gods of coding watch over you :)

Animation library for XNA 4.0

2010-12-04T04:29:00.011+02:00

This is a simple animation library it offers animation blending, when changing animation or animation blending from multiple animations on the same set of bones.
It has a quaternion based implementation and a matrix based implementation, the matrix based implementation doesn't offer multiple animations on the same set of bones but unlike the quaternion implementation it has scale support;When used in code there should be no big difference.
It is time-based so it doesn't count if your game is playing at 60 frames/second or at 5000.

It is licensed under the MIT/X11 license so you can do what you feel with it you just have to mention my name on your credits.
If you download it you agree with the terms of the license.

It is on Microsoft SkyDrive :

Reference :
http://cid-58baf3506093b62a.office.live.com/self.aspx/.Documents/SkinningLib/v15/CommunistSkinning.rtf
License:
http://cid-58baf3506093b62a.office.live.com/self.aspx/.Documents/SkinningLib/v15/LICENSE.txt
You can download it from here:
http://cid-58baf3506093b62a.office.live.com/self.aspx/.Documents/SkinningLib/v15/CommunistSkinning^_15d.zip

If you have something to say live a comment here or send me an email on kiki_karon@yahoo.com
I hope the gods of coding watch over you :)

I decided to make a game(yay for me)

2010-11-20T23:17:00.004+02:00

I started working on an engine on and off so this is not by far a from scratch experience.
I think it will be a Descent like game with a few mini-games for flavor and some rpg elements because in the end I'm a geek.
I know every game should start with a design document,because I worked in this industry for a long time, but as for the moment I haven't recruited anyone and I'm still coding the nonspecific stuff so I don't see the point of that, but when it will be made it will be published on this blog so you can show me how floded my ideas are.
I will base my work on xna 4.0 because I love C# and I have a lot of experience with directx.
I live in Romania that means I wont be able to sell my game on xbox live arcade indi(that makes me angry), so I'm going to make a PC game.
I will post my progress as this experiment continues.
Here is the first screen-shot from the my world/game-play editor:

The Depth Buffer(Z-Buffer) and it's precision problems

2010-11-09T00:33:00.037+02:00

Introduction to the problem :

-The first thing that any graphics programmer will start cursing is the depth buffer, and this is because of it's precision and the leak of understanding on how it works.
-Setting the bit depth is a straight forward process,select the biggest depth buffer available that feats in your video memory plane.
-Creating the projection matrix,specifically setting the near and far planes is a little more challenging,because the leak of math education + some leek of knowledge on how computer works makes a noob programmer to set the near planes at 0.000001f and far planes at 9999999,this is a bad thing,because the z-buffer advertises as something that it is not; when you are setting the near and far plane you are not just setting your convenient frustum but also it's compression, I will talk more about this later.
-The other element that is hard for beginners to understand is that in computer programming like in any real application made in this universe the real number is a pipe dream,floats and double look like they have a place in continues mathematics but they are just convinces over discreet mathematics.

The core of the problem :

-First let's look at the bit depth and it's meaning, depth buffer come in many flavors, in recent video cards the selection was reduced but we steal have a few :
                      +15bit, that's 32768 discrete values(as in the 16bit depth buffer with 1 bit stencil).
                      +16bit, that's 65536 discrete values(as in the standard 16bit depth buffer and the 24bit depth buffer with 8bit stencil).
                      +24bit, that's 16777216 discrete values(as in the standard 24bit depth buffer and the 32bit depth buffer with 8bit stencil).
                      +32bit, that's 4294967296 discrete values.
When you see this values you will probably say yawn that's a lot of discreet values,but there is another catch, the depth buffer DOES NOT HAVE A LINEAR DISTRIBUTION, almost all the values are in the first 10% of the interval, it has almost a hyperbolic distribution.
Lets see some examples :
-For a 32 bit depth with the z-near at 0.1f and the z-far at 100 we will have
               at                             z-buffer value                 error
              0.25                         2579559936    0.00000000014537363
              0.2505                     2582992440    0.000000000145955692
              0.26                         2645702437    0.000000000157236113
              1.00                         3869339904    2.325978E-9
              4.00                         4191784896    0.00000003721565
              10.00                       4256273894    0.000000232597813
              20.00                       4277770227    0.0000009303912
              80.00                       4293892476 0.0000148862573
              90.00                       4294489597    0.00001884042
              99.00                       4294923866    0.0000227969067
              99.0005                   4294923888    0.0000227971377
              100.00                     4294967293    0.0000232597758

Here is a graph representing the error as it grows (at the bottom of the page there is a link for a depth error calculator that I made):

Can you spot the problem, the difference between 0.25 and 0.2505 is of 0.0005 units in the 3d world but the difference in the depth buffer is of 3432504 units, now let's see
between 99 and 99.0005 in 3d space logic dictates that it will also be 0.0005 units but in the z-buffer the difference is only of 22.

-For a 16 bit depth buffer the situation is a lot more tragic :
               at                             z-buffer value                 error
             0.25                              39360                  0.000009526843
             0.2505                          39413                  0.00000956498752
             99                                65535                  1.47180724
             99.0005                        65535                  1.471822

-For 15 bits I won't even show you the numbers(but you can calculate them yourself with the calculator that you can download at the bottom of this page):

As you can see near the z-far we can't even distinguish values.
And I hope you noticed that at 0.25 we stored 39360 and our full precision is 65563 more then half of our precision is in the first 0.25 units of our depth !!!!

Why we have the problem

-After the projection matrix transforms the coordinates, the XYZ-vertex values are divided by their clip coordinate W value, which results in normalized device coordinates. This step is known as the perspective divide. The clip coordinate W value represents the distance from the eye. As the distance from the eye
increases, 1/W approaches 0. Therefore, X/W and Y/W also approach zero, causing the rendered primitives
to occupy less screen space and appear smaller.This is how computers simulate a perspective view.
As part of the perspective divide, Z is also divided by W. For objects that are already close to the back of the view volume, a change in distance of one coordinate unit has less impact on Z/W than if the object is near the front of the view volume.What you should realize is that because of this the z is not linear in precision and it's precision is proportional with the reciprocal of (zFar / (zFar - zNear) + zFar * zNear / (zNear - zFar)) / z as a result we have a but load of precision near the camera and almost no precision at the far plane.The perspective divide, by its nature, causes more Z precision close to the front of the view volume than near the back.Half of the resolution of the z-buffer is "wasted"(read used) for the first 5% of the interval between the near and far planes.

This is not such a bad thing if you think about it,because you need more precision where the action lies near the camera, but this is something that you have to understand and work in your design.

-The depth buffer compression, when the depth is stored, it must be feted in 15,16 or 32 bits so :
int storeZ = Math.Floor((1 << resolution) * depth);
where the resolution is how many bits we have to spare for the precision.

-In Directx you don't have direct access to the depth-buffer as a result video card manufacturers use unicorn magic in the compression algorithms because of this the precision may be slightly smaller then you expect or the distribution may have a different shape then you expect on some devices so always use a hysteresis.

Possible solutions

-Understand that there is no magic bullet here(some people that work in the game industry still think there is)

-You can't have a depth buffer that will draw with high precision objects near the camera and objects far away,you must compromise.

-For huge distances you can use a logarithmic depth buffer, a technology made by the SGI people, where basically you want to simulate a logarithmic curve in your depth buffer, this is a god technique as it spreads the precision a little bit better(I will have a post about it),as an side-effect of the logarithmic evolution you will start having problems with the polygons that are near the camera especially if you have big polygons.

-The best thing you can do is to keep you near plane as far as possible from the camera and your far plane as close as possible, this is because the z-buffer distribution is almost hyperbolic, as a result if you compress it, it will become more linear, example of the error curve :

For 16bit depth buffer from 0.1 to 100

For 16bit depth buffer from 0.5 to 100

As you can see the error was reduced dramatically just by taking the near plane closer to the camera.

Remember
-The clip coordinate W after perspective transform represents the distance from the eye.
-The clip coordinate Z represents the distance from the eye corrected by the perspective transform.
-The z-buffer contrary to it's name doesn't hold the z value but the z/w value.

-Near plane as far as possible without compromising the quality of your game.

-Far plane as close as possible without compromising the quality of your game.

-The z-buffer is discreet, you don't have an unlimited number of values, it can only grow with fixed increments of approximately 1/(2^number_of_bits - 1).

-Try not to use stencil buffers, every bit counts.

-If you need to render depth in to a texture don't save the z component save the z/w because in the depth buffer we need normalized device coordinates, that's coordinates that can be feted in to axis aligned bounding box with the min in [-1,-1,0] and max in [1,1,1],also don't do the division operation in the vertex shader, do it in the pixel shader because z and w don't change proportionally, if you don't have a very tessellated mesh you will encounter problems.
-Perspectiv ecuations :

z' = z*(zf/zf-zn)-((zn*zf)/zf-zn)

w' = z
where z',w' are clip space coordinates, z is a camera space coordinate,zn is the near plane and zf is the far plane.

-As a bonus because you used your precious time to read this article I uploaded a depth-buffer error calculator so you can calculate your near and far planes with more ease :

It's pretty straight forward to use, simply type in your near plane, your far plane, the biggest error that you are interested in and your bit depth and you will get a graph that you can sample presenting the error as you approach the far plane.

Here is the download link it's on Microsoft SkyDrive so if you have an account and you are not logged you may not see it, it was written in c# .net 4.0 and you will need at least .net 4.0 client framework installed, you also have the source there :

theDepthCalculator

If you want to know more about the history of the depth buffer, see this article on Wikipedia and know that the guy who invented it was Edwin Catmull, the guy who also invented the Catmul-Rom spline and the Catmul-Clark subdivision also known as Mesh-Smooth,Sub-D or NURMS.

Thanks for reading,hope it was a useful experience for you, leave a comment if you think something is not write, or if you enjoyed it and good coding :)

Targeting Reach and HiDef PCs with the same XNA 4.0 Game

2010-11-04T19:06:00.007+02:00

I will present a short implementation on what I consider to be an easy way for a Windows PC XNA 4.0 game that can adapt on what assets to load based on the available video-card.

You can make a game that sets the proper profile with just a few lines :
-First make sure that that you set the Reach profile for your Game, in the property tab.

-Next in your Game constructor after the GraphicDeviceManager was created handle the .PreparingDeviceSettings event on the newly created device manager.

graphics = new GraphicsDeviceManager(this);

//This event is called when the device is created,reseated or recreated so it's the perfect place to set the profile.

graphics.PreparingDeviceSettings += new EventHandler<PreparingDeviceSettingsEventArgs>(graphics_PreparingDeviceSettings);

-In the handling function simply iterate trough all the available devices and select the one that satisfies your needs.

#if !FORCE_REACH

for (int i = 0; i < GraphicsAdapter.Adapters.Count; i++)

{

if (GraphicsAdapter.Adapters[i].IsProfileSupported(GraphicsProfile.HiDef))

{

e.GraphicsDeviceInformation.Adapter = GraphicsAdapter.Adapters[i];

e.GraphicsDeviceInformation.GraphicsProfile = GraphicsProfile.HiDef;

IsHiDef = true;

return;

}

#endif

for (int i = 0; i < GraphicsAdapter.Adapters.Count; i++)

{

if (GraphicsAdapter.Adapters[i].IsProfileSupported(GraphicsProfile.Reach))

{

e.GraphicsDeviceInformation.Adapter = GraphicsAdapter.Adapters[i];

e.GraphicsDeviceInformation.GraphicsProfile = GraphicsProfile.Reach;

IsHiDef = false;

return;

}

-To work around the fact that we can't have ContentProjects with different profiles we can create little projects with different profiles that reference the content projects specific for each content type and reference those project in our main game.

That's all you have to do, now if you want to simplify the way you load content and not bother with the type of the content you are loading you can create a ContentManager that is aware of the current GraphicProfile, for this :

-Create a new class that inherits from ContentManage.

-Create a new constructor that takes as parameters an instance of the IServiceProvider and 3 strings for the different kind of assets we need(Common,HiDef and Reach)

public ContentManager2(IServiceProvider services, string commonAssetRoot, string hiDefAssetRoot, string reachAssetRoot)

: base(services)

{

this.commonAssetRoot = commonAssetRoot;

this.hiDefAssetRoot = hiDefAssetRoot;

this.reachAssetRoot = reachAssetRoot;

}

-Then create a method that can detect if the current device is a HiDef device.

private IGraphicsDeviceService graphicsDeviceService;

private bool? usingHiDeffDevice;

/// <summary>

/// Returns true if the current graphic device supports the HiDef profile.

/// </summary>

public bool IsHiDef

{

get

{

if (graphicsDeviceService == null)

{

graphicsDeviceService = this.ServiceProvider.GetService(typeof(IGraphicsDeviceService)) as IGraphicsDeviceService;

if (graphicsDeviceService == null)

{

throw new Exception("No GraphicDevice available!!!");

}

if (usingHiDeffDevice == null)

{

usingHiDeffDevice = graphicsDeviceService.GraphicsDevice.Adapter.IsProfileSupported(GraphicsProfile.HiDef);

}

#if FORCE_REACH

return false;

#endif

return usingHiDeffDevice.Value;

}

-Next we need to change the Load() method.

public override T Load<T>(string assetName)

{

try

{

return base.Load<T>(commonAssetRoot + "\\" + assetName);

}

catch

{

if (IsHiDef)

{

return base.Load<T>(hiDefAssetRoot + "\\" + assetName);

}

else

{

return base.Load<T>(reachAssetRoot + "\\" + assetName);

}

-We will have to change the default ContentManager that comes with the Game class with ours so in the Game class constructor we will.

Content = new ContentManager2(this.Services, "Common_Content", "HiDef_Content", "Reach_Content");

-And we are done now if we need an asset we will load it like with a standard ContentManager

-Here is a project set using what I was talking about, it's on SkyDrive so if you have an account and you are not logged you might not see it :

MultipleTargetProject

-To force the load in Reach profile you must define FORCE_REACH :

-As a last note if you use this method always test your game with and without forcing the Reach profile.

Simple collection that returns random objects based on a stored probabilities

2010-10-27T01:47:00.008+03:00

Simple collection that returns a random object based on a probability(weight)
Add an object using the Add() function and use the Next() function to return a random object:

Here is a download link from Microsoft SkyDrive:

Random by probability/weight

public class RandomByProbabilityCollection<T>

{

/// <summary>

/// The object you are pooling.

/// </summary>

private List<T> options;

/// <summary>

/// The inverse of the probability that object will be selected.

/// </summary>

private List<byte> probability;

/// <summary>

/// Inverse probability that the items had last SelectNext call.

/// </summary>

private List<byte> lastCallProbability;

/// <summary>

/// Currently selectable objects.

/// </summary>

private List<int> currentList;

/// <summary>

/// Objects that can't be selected now.

/// </summary>

private List<int> candidateList;

/// <summary>

/// Rendom number generator.

/// </summary>

private Random randomGenerator;

/// <summary>

/// Generate a new collection of items that can be selected based on a probability.

/// </summary>

/// <param name="initialSize">The initial size of the collection.</param>

/// <param name="maxProbability">The maximum priority for an item.</param>

/// <param name="maxExtraIterations">Extra iteration to try and load more then 2 items.</param>

public RandomByProbabilityCollection(int initialSize, byte maxProbability, int maxExtraIterations)

{

probability = new List<byte>(initialSize);

lastCallProbability = new List<byte>(initialSize);

options = new List<T>(initialSize);

currentList = new List<int>(initialSize);

candidateList = new List<int>(initialSize);

randomGenerator = new Random();

this.max2Iteration = maxExtraIterations;

this.maxProbability = maxProbability;

}

//Disabled items iteration step.

private byte min = 1;

//The maximum available priority.

private readonly byte maxProbability = 75;

//Maximum number of iteration used to discover atleast 2 comparable objects.

private readonly int max2Iteration = 10;

//Set the items iteration step.

private void SetMin(byte current)

{

if (current < min && current > 0)

{

min = current;

}

//Calculate the priority for a given item.

private byte CalculatePriority(int probability)

{

int p = (probability > maxProbability ? maxProbability : probability);

p = (maxProbability - p);

return (byte)p;

}

/// <summary>

/// Add an item to the collection.

/// </summary>

/// <param name="probability">The probability that this item will be selected 0 to 75.</param>

/// <param name="obj">The object.</param>

public void Add(byte probability, T obj)

{

byte p2 = CalculatePriority(probability);

SetMin(p2);

this.probability.Add(p2);

this.lastCallProbability.Add(p2);

this.candidateList.Add(this.probability.Count - 1);

this.options.Add(obj);

}

//Check if there are any objects available for selection.

private void CheckPosibility()

{

if (candidateList.Count > 0)

{

for (int i = 0; i < candidateList.Count; i++)

{

int theIndex = candidateList[i];

if (probability[theIndex] == maxProbability)

{

continue;

}

int lastProbability = lastCallProbability[theIndex];

if (lastProbability < 1)

{

lastCallProbability[theIndex] = probability[theIndex];

candidateList.RemoveAt(i);

currentList.Add(theIndex);

i--;

}

else

{

if (lastCallProbability[theIndex] < min)

{

lastCallProbability[theIndex] = min;

continue;

}

lastCallProbability[theIndex] -= min;

}

/// <summary>

/// Select a random object from the collection based on it's probability.

/// </summary>

/// <returns></returns>

public T Next()

{

if (options.Count < 1)

{

//throw new Exception("The collection is empty but you are trying to ge a value");

return default(T);

}

if (options.Count == 1)

{

return options[0];

}

int skipCount = max2Iteration;

while (currentList.Count < 2 && skipCount > 0)

{

skipCount--;

CheckPosibility();

}

int overflowTest = 0;

while (currentList.Count < 1)

{

overflowTest++;

CheckPosibility();

if (overflowTest > 100)

{

for (int i = 0; i < probability.Count; i++)

{

if (probability[i] != maxProbability)

{

overflowTest = 0;

break;

}

if (overflowTest != 0)

{

throw new Exception("All objects have a priority of 0, this function will never return");

}

int option = randomGenerator.Next(0, currentList.Count);

int selectedIndex = currentList[option];

candidateList.Add(selectedIndex);

currentList.RemoveAt(option);

return options[selectedIndex];

}

/// <summary>

/// Remove an item from the collection based on it's index in the collection.

/// </summary>

/// <param name="index">The index of the item to remove.</param>

/// <returns>True if an item was removed.</returns>

public bool RemoveAt(int index)

{

if (options.Count > index)

{

int maxProbability = probability[index];

this.probability.RemoveAt(index);

int currentLastCallProbability = lastCallProbability[index];

this.lastCallProbability.RemoveAt(index);

if (currentLastCallProbability >= maxProbability)

{

this.currentList.Remove(index);

}

else

{

this.candidateList.Remove(index);

}

this.options.RemoveAt(index);

for (int i = 0; i < currentList.Count; i++)

{

if (currentList[i] > index)

{

currentList[i]--;

}

for (int i = 0; i < candidateList.Count; i++)

{

if (candidateList[i] > index)

{

candidateList[i]--;

}

return true;

}

else

{

return false;

}

/// <summary>

/// Remove an item from the collection.

/// </summary>

/// <param name="obj">The item to remove.</param>

/// <returns>True if an item was removed.</returns>

public bool Remove(T obj)

{

int indexOfT = options.IndexOf(obj);

return RemoveAt(indexOfT);

}

/// <summary>

/// Clear the collection.

/// </summary>

public void Clear()

{

this.probability.Clear();

this.lastCallProbability.Clear();

this.currentList.Clear();

this.candidateList.Clear();

this.options.Clear();

}

/// <summary>

/// Sets the capacity to the actual number of elements in the list,

/// if that number is less than a threshold value.

/// </summary>

public void TrimExcess()

{

options.TrimExcess();

probability.TrimExcess();

lastCallProbability.TrimExcess();

}

/// <summary>

/// Change priority on a item at a given index.

/// </summary>

/// <param name="index">The index of the item that you want to change probability for.</param>

/// <param name="probability">The new probability.</param>

/// <returns>True if changed.</returns>

public bool ChangeProbabilityAt(int index, byte probability)

{

if (options.Count > index)

{

this.probability[index] = CalculatePriority(probability);

if (this.currentList.Contains(index))

{

this.currentList.Remove(index);

this.candidateList.Add(index);

}

return true;

}

return false;

}

/// <summary>

/// Change priority on a item.

/// </summary>

/// <param name="index">The item that you want to change probability for.</param>

/// <param name="probability">The new probability.</param>

/// <returns>True if changed.</returns>

public bool ChangeProbability(T obj, byte probability)

{

int indexOfT = options.IndexOf(obj);

return ChangeProbabilityAt(indexOfT, probability);

}

/// <summary>

/// Number of items in the collection.

/// </summary>

public int Count

{

get

{

return options.Count;

}

/// <summary>

/// Indexed return.

/// </summary>

/// <param name="index">The index of the object.</param>

/// <returns>The object.</returns>

public T this[int index]

{

get

{

return options[index];

}

PIX,PerfHUD and XNA 4.0

2010-10-22T22:15:00.010+03:00

This is a short tutorial on how to use PIX and PerfHud with XNA 4.0,this is not a how to on PerfHUD nor PIX,for this you can search Google and find 1000 tutorials.

In XNA 4.0 to analyze a program with PIX you need to press the "More options" button and then check the "Disable D3DX analysis" check-box.

If you want to use futures like events and markers from your game I attached a file containing methods that give you access to those function.
Here is a download link from Microsoft SkyDrive(if you have an account and you are not logged in you might not see it):

PIX XNA C#

Status() - Determine if the profiler is connected to the program.
Disable() - Notify PIX that the target program does not give permission to be profiled.
BeginEvent(Color color,String name) - Marks the beginning of a user-defined event. PIX can use this event to trigger an action.
EndEvent() - Mark the end of a user-defined event. PIX can use this event to trigger an action.
SetMarker() -Mark an instantaneous event. PIX can use this event to trigger an action.

This functions should work under windows and give no errors on any other platform.
I always place a if Status() then Disable() in my final product on the end of all the load sequences so others can's find exploits in my games.
If you open an event close it, if you don't close an event it will be automatically closed at the end of the frame by PIX.
For more information see the PIX helper function page on MSDN, i used the same summary for the functions that they gave.
Events can be nested in other events.
I never was able to see the color of an event change,not on native Directx nor on XNA.

To use PerfHud under XNA 4.0 you need to add an event on the GraphicsDeviceManager just after you create it for it's PreparingDeviceSettings(+= new EventHandler<PreparingDeviceSettingsEventArgs>)
in that event you must go trough each available adapter, and set on the e.GraphicsDeviceInformation.Adapter
that adaptor that has "PerfHUD" in it's description,after that set the GraphicsAdapter.UseReferenceDevice to true :

public Game1()

{

graphics = new GraphicsDeviceManager(this);

graphics.PreparingDeviceSettings += new EventHandler<PreparingDeviceSettingsEventArgs>(graphics_PreparingDeviceSettings);

}

void graphics_PreparingDeviceSettings(object sender, PreparingDeviceSettingsEventArgs e)

{

foreach (GraphicsAdapter adapter in GraphicsAdapter.Adapters)

{

if (adapter.Description.Contains("PerfHUD"))

{

e.GraphicsDeviceInformation.Adapter = adapter;

GraphicsAdapter.UseReferenceDevice = true;

break;

}

If you create your own device simply set the device with the description "PerfHUD" :

foreach (GraphicsAdapter adapter in GraphicsAdapter.Adapters)

{

if (adapter.Description.Contains("PerfHUD"))

{

GraphicsAdapter.UseReferenceDevice = true;

graphicsDevice = new GraphicsDevice(adapter,p, parameters);

break;

}

if (graphicsDevice == null)

{

graphicsDevice = new GraphicsDevice(GraphicsAdapter.DefaultAdapter, p, parameters);

}

Now you can run PerfHud by using the send to option on the exe :

This products complement each other in many ways, PIX uses a static approach but has per vertex and per pixel debugging while PerhHud offers live information about your graphic card,driver level and cpu plus it lets you change on the fly textures,states,shaders and rendertargets and you can even playback and analyze drawcals on all levels.

If you want to make something different then the next pong you will need access to this tools.
For information on how to use PerfHUD see the nvidia site as they have a lot of documentation and vide info about it.
For PIX information see the Microsoft sites or do a Google search as there are many tutorials about the subject.

Using NProf 0.11 and CLRProfiler in .NET 4.0

2010-10-21T03:19:00.001+03:00

I am obsessed about memory allocation and function speed optimization so my favorite tools where the CLRProfiler and NProf but when I moved to .NET 4.0 they where not working anymore, luckily there is a fix.

Create a bat in the directory where you have CLRProfiler or NProf and type in it :
set COMPLUS_ProfAPI_ProfilerCompatibilitySetting=EnableV2Profiler
NProf.exe(or CLRProfiler.exe)

That's it now when you will call the bat you will be able to use the profilers like in the past.

Fog in HLSL

2010-10-17T16:07:00.013+03:00

To simulate fog in hlsl you simply need to make an interpolation between your final obtained color and some color that you want your fog to have.

First we need the depth witch is basically the z component of the final position in view space that you calculate for your pixel shader :

VSPerPixelFogOutput output = (VSPerPixelFogOutput)0;

float4 worldPosition = mul(input.Position, World);
float4 viewPosition = mul(worldPosition, View);
output.Position = mul(viewPosition, Projection);

output.Depth = output.Position.z;

The interpolation factor can be calculated as :
float l = saturate((Depth - FogStart) / (FogEnd - FogStart));

where:

FogStart is the distance where you want your fog to start from your camera.

FogEnd is the distance where you want your fog to end from your camera.

Finally in the pixel shader all you have to do is interpolate between your fog color and your color obtained in the shader based on that factor :

return float4(lerp(OriginalColor,FogColor, l), 1);

And this is how you can simply and efficiently emulate the fog that was in the fixed pipeline.

Here is an example of this executed in XNA 4.0 with per vertex and per pixel fog, it's on Microsoft SkyDrive(if you have an account and you are not logged in you might not see it):

FogDemo

Converting between Texture2D and Image in XNA 4.0

2010-10-14T19:04:00.027+03:00

In xna 4.0 we lost the FromFile property of the Texture2D and we gained FromStream, a more general method of input.

In this post I will present 2 little methods used on converting from a System.Drawing.Image to a Microsoft.Xna.Graphics.Texture2D and back again.

To convert a Texture2D to an Image :

public static System.Drawing.Image Texture2Image(Texture2D texture)
{

if (texture == null)

{

return null;

}

if (texture.IsDisposed)

{

return null;

}

//Memory stream to store the bitmap data.

MemoryStream ms = new MemoryStream();

//Save the texture to the stream.

texture.SaveAsPng(ms, texture.Width, texture.Height);

//Seek the beginning of the stream.

ms.Seek(0, SeekOrigin.Begin);

//Create an image from a stream.

System.Drawing.Image bmp2 = System.Drawing.Bitmap.FromStream(ms);

//Close the stream, we nolonger need it.

ms.Close();

ms = null;

return bmp2;

}

To convert an Image to a Texture2D:

public static void Image2Texture(System.Drawing.Image image,
GraphicsDevice graphics,
ref Texture2D texture)
{

if (image == null)

{

return;

}

if (texture == null || texture.IsDisposed ||

texture.Width != image.Width ||

texture.Height != image.Height ||

texture.Format != SurfaceFormat.Color)

{

if (texture != null && !texture.IsDisposed)

{

texture.Dispose();

}

texture = new Texture2D(graphics,image.Width,image.Height,false,SurfaceFormat.Color);

}

else

{

for (int i = 0; i < 16; i++)

{

if (graphics.Textures[i] == texture)

{

graphics.Textures[i] = null;

break;

}

//Memory stream to store the bitmap data.

MemoryStream ms = new MemoryStream();

//Save to that memory stream.

image.Save(ms, System.Drawing.Imaging.ImageFormat.Png);

//Go to the beginning of the memory stream.

ms.Seek(0, SeekOrigin.Begin);

//Fill the texture.

texture = Texture2D.FromStream(graphics, ms, image.Width, image.Height, false);

//Close the stream.

ms.Close();

ms = null;

}

This methods can be handy when you are building an editor that is using both XNA and WindowsForms(GDI+)

Here is a link, it's on SkyDrive so if you have an account and you are not logged in you might not see it :

Image2Texture2D

Lights in Games : Point light

2010-10-14T00:34:00.005+03:00

I will write a series of articles about light models that are used in games, I will start with the simplest models like point lights,directional lights,spot lights and linear lights after that I will talk about how we can calculate shadows for some of this models and finally I will talk about screen space ambient occlusion, transmission and sub surface scattering on the gpu.

So let's get started with the point light, the simplest light model to understand and to implement, that is if you don't want to talk about shadows, but that is another ballgame.

Basically the minimum number of parameters your point light can have are :

-Position in world space

-Color

-Decay ratio

-Maximum reach distance

For your model that you want to lit you need vertice with:

-Normals

-Positions

For your camera :

-Position

The way it works is easy to understand, we are going to use something called the Blinn shading model witch is basically a chip version of the Phong shading model and the standard in the game industry today.

We can calculate this light model on the pixel shader or on the vertex shader, but the equation behind it is the same, I will provide at the bottom of the page a sample that is using both models.

First we must calculate the diffuse factor this is easy enough :

float3 lightVector = localPointWorldSpace - lightPosition;

float3 normalizedLightVector = normalize(lightVector );

float diffuseComponent = dot(localNormalWorldSpace , -normalizedLightVector );

First we have calculated the lightVector this is simply a vector between the light position and the point that we are trying to lit in world space.

Next we normalized that vector so his length will be one.

Next we simply calculate the dot product between the normal of the point in world space and that vector that we have just created, this will give as the facing ratio between the 2 vectors or how much is this point looking at the light.

We can multiply this with a value stored at the level of the vertex or in a texture called the diffuse factor, to integrate this simply multiply the given factor with this value.

Now we will calculate the specular factor, this is the simulation of the reflection generated by the light on the material:

float3 cameraVector = cameraPositionInWorldSpace - localPointWorldSpace ;

cameraVector =normalize(cameraVector);

float3 halfVector = normalize(cameraVector + normalizedLightVector);

float specular = dot(normal,-halfVector);

This is the main difference between the Blinn and the Phong model, Blinn is using a replacement for the reflection vector called the half vector.

float3 reflect = normalize(2 * diffuseComponent * localNormalWorldSpace - normalizedLightVector);
float specular = saturate(dot(reflect, -cameraVector));

As you can see the Blinn version is a lot cheaper, and the visual result are almost identical plus the Blinn light model generates less artifacts making it easier for the artists to tweak their models.

We can also add here a specular power by simply multiplying this value with information stored in a texture

or in the vertex.

Another future we can add is a gloss power by raising the given value to a given power, bigger for a more precise reflection or smaller for a more diffuse reflection, this information can also be stored on a vertex or texture level.

The last element that you need to consider is the attenuation :

float lightDistance = length(lightVector);

float lightAttenuation= 1/(lightDistance*decayRatio);

lightAttenuation= maximumLightDistance < lightDistance ? lightAttenuation: 0;

Here we simply calculate the decay of the light based on the distance from the light, if an object is close to the light it will have a brighter color.

Next we are using an if instruction to determine if we are in the range allowed for this light, we are not using the standard if instruction because on the gpu that turns in to 3-7 commands in shader model 1.0 -> 2.0 or in 2 commands + 1 flow control command on shader model 3.0, this kind of if for floats takes 1 command and for float2 and greater takes 2 commands and that is an important difference on the gpu, try to keep everything as cheep as possible.

In the real world lights decay with a ratio of the inverse square of the distance, but this generates lights that are hard to tweak.

Now all we have to do is combine all the information :

float3 finalColor = (lightColor * diffuseComponent + specular)*lightAttenuation;

And this is the final color that you draw on the screen.

Here is an example made in XNA 4.0 presenting the point lighting model on pixel and on vertex level, it's on Microsoft SkyDrive(if you have an account and you are not logged in you might not see it):

PointLightDemo

XNA 4.0 Reach and ShadowMaping

2010-10-12T22:15:00.011+03:00

Compress the float as a color :

const float4 mask =float4(1.0/255.0,1.0/255.0,1.0/255.0,0.0);

const float4 decode_mask = float4(1.0f, 1.0/255.0,1.0/65025.0, 1.0/16581375.0);

inline float4 FloatToFloat4( float v )

{

float4 enc = float4(1.0, 255.0, 65025.0, 16581375.0) * v;

enc= frac(enc);

enc-= enc.yzww * mask;

return enc;

}

You take this float4 and save it in a standard Color(A8R8G8B8) render-target.

Where you need that value you sample it just like any texture and pass it trough this function:

inline floatFloat4ToFloat( float4 rgba )

{

return dot( rgba, decode_mask );

}

Depending on the situation you may decide to use a render-target with less channels that will take up less memory or maybe you have other info to keep in the other channels, for thoes situations you could use :

const float3 decode_mask= float3(1, 1.0/255, 1.0/65025);

const float3 factor= float3(1, 255, 65025);

const float2 mask =float2(1.0 / 255.0,1.0 / 255.0);

inline float3 FloatToFloat3(in float unit)

{

float3 color = unit * factor.rgb;

color.yz = frac(color.yz);

color.xy -= color.yz * mask;

return color;

}

inline floatFloat3ToFloat(in float3color)

{

return dot(color, decode_mask);

}

or:

const float2 decode_mask= float2(1, 1.0/255.0);

const float2 factor= float2(1, 255);

const float mask =1.0 / 255.0;

inline float2 FloatToFloat2(in float unit)

{

float2 color = unit * factor;

color.g = frac(color.g);

color.r -= color.g * mask;

return color;

}

inline floatFloat2ToFloat(in float2color)

{

return dot(color, decode_mask);

}

-This operations are not lossless , if you have float and you save it as a color then you re-transform it in a float you are bound to get rounding errors.
-This methods will only help you to encode values between 0 and 1.

-To develop this methods I used a lot of help from PiotrWPL and skytigercube on the http://forums.create.msdn.com/forums

I have uploaded a modified version of the XNA 3.1 shadow mapping example converted for XNA 4.0 using this tehnique, here is a download link from Microsoft SkyDrive(if you have an account and you are not logged in you might not see it):

http://cid-58baf3506093b62a.office.live.com/self.aspx/.Documents/ShadowMapping^_2.zip

Have fun !!!

Using XNA and GJK for convex mesh intersections

2010-10-12T18:42:00.004+03:00

In games at some point you will need mesh intersections, you might say "but I have boxes and spheres and pills" and your artists are going to say "Screw you!!!" and that is sometimes bad.

This class is a modified version of my ThreadSafeBoundingFrustum class from this article multithreading the BoundingFrustum post .

You can find at the bottom of the page the transformed class, the most important difference is the SupportMapping function that generates the point for the simplex :

internal void SupportMapping(ref Vector3 v, out Vector3 result)

{

Vector3 worldSpaceConvexData0;

Vector3.Transform(ref this.VerticesData[0], ref this.transform, out worldSpaceConvexData0);

Vector3 worldSpaceConvexDataI;

float num3;

int index = 0;

Vector3.Dot(ref worldSpaceConvexData0, ref v, out num3);

for (int i = 1; i < this.VerticesData.Length; i++)

{

float num2;

Vector3.Transform(ref this.VerticesData[i], ref this.transform, out worldSpaceConvexDataI);

Vector3.Dot(ref worldSpaceConvexDataI, ref v, out num2);

if (num2 > num3)

{

index = i;

num3 = num2;

}

Vector3.Transform

(ref this.VerticesData[index], ref this.transform,out worldSpaceConvexDataI);

result = worldSpaceConvexDataI;

}

The main thing changed is that we no longer test a limited 4 elements array we test against a list

this.VerticesData and we transform the point from local space to world space by multiplying

the given point with a transform that we store for each convex collision mesh.

Here is the code transformed for you to use in your projects, it's on Microsoft SkyDrive(if you have an account and you are not logged in you might not see them):

GJK

BoundingFrustum

ConvexMesh

Using the "BoundingFrustum" Class in multithreaded solutions

2010-10-12T16:23:00.008+03:00

The Bounding-Frustum class can be used by many systems in many situations from lights and cameras to traversing binary space partitions and most likely this systems work on different threads(if you are not programming the next great pong), but the XNA implementation presents one problem:

it can’t be used from more than one thread at a time.

Some random person will come with something stupid to say here like “but you can lock the object“and my answer will then be “and waste valuable cycles while waiting for another thread to finish with this object and add some more overhead”, if you use this kind of scenarios in a game you will end up with code that is slower then it’s single-threaded counterpart.

To see the root of the problem you need a code reflection program, like Red Gate’s Reflector some multithreading background and some GJK background:

And the root of the problem is the Gjk object, why because it was designed to be used only from 1 thread at a time:
The first thread generates a gjk object
if (gjk == null)
{
gjk = new Gjk();
}
The second thread sees that a gjk already exists and will call the Reset() function on the gjk invalidating the
data collected by the first thread
When the first thread looks for that data it can't find it and you get an exception.

Here is how I see a fix for the problem:

-The Gjk is an algorithmic object, this means it has no value after the end of the operation where it was involved.

-There is no reason to have more than one Gjk object per active thread because you can’t use more then one on the same thread and as stated it has no value after the operation was concluded.

Because of that a Gjk object should be static and more then that it should be thread static.

On a Pc this is easy enough just:

[ThreadStatic]
private static Gjk gjk;

ThreadStatic - means just that make an object that is static available just in the thread that spawned it.

static – the same object is available on all the instances of the object where it was stated.

But on the Xbox you must use a little bit of creativity:

private static Dictionary<int, Gjk> gjkObjects;

private static Gjk gjk2

{

get

{

lock (typeof(BoundingFrustumThreedSafe))

{

if (gjkObjects == null)

{

gjkObjects = new Dictionary<int, Gjk>();

}

if (gjkObjects.ContainsKey(System.Threading.Thread.CurrentThread.ManagedThreadId))

{

return gjkObjects[System.Threading.Thread.CurrentThread.ManagedThreadId];

}

else

{

gjkObjects.Add(System.Threading.Thread.CurrentThread.ManagedThreadId, new Gjk());

return gjkObjects[System.Threading.Thread.CurrentThread.ManagedThreadId];

}

Basically the compact framework, the one on the Xbox has no knowledge about the ThreadStatic attribute so you must make one yourself.

When you will use this approach on the Xbox to bust your performance you should probably use it like this:

#if WINDOWS

if (gjk2 == null)

{

gjk2 = new Gjk();
}

#endif

Gjk gjk = gjk2;

gjk.Reset();

So the whole lock operation can be performed only once per execution.

Another advantage on this approach is that you don’t generate as much garbage because you only generate as much Gjk objects as you need and you never dispose of them so the garbage collector never starts .

Now some words on the final implementation, Gjk and a bit of renting on my part.

Because the XNA Team in its infinite wisdom decided to make the Gjk object internal and some of the mapping functions internal I had to add them all in the class itself, this is wrong on so many levels(the function that generates the next point from an object in an algorithm should be part of that object),

But there was no other way.

The Gjk is one of the most used and abused types of algorithms in games today, it is good for any kind of convex object intersection including mesh intersections or object orientated bounding boxes, and it’s very fast the whole operation ends up in 4 to 6 steps.

I will add more articles on how to use it on convex mesh intersection detection, the idea is that this object should have been declared as a public object.

If you want a great explanation on how the Gjk works check this link http://mollyrocket.com/849 or if you don’t fancy video http://www.codezealot.org/archives/88 or do a Google search on "Gjk implementation" you will get a ton of hits.

Here is the complete source code of the modified files so you can use in your project, it's on Microsoft SkyDrive(if you have an account and you are not logged in you might not see them):
BoundingFrustum
GJK