static const f32 totalFadeTime = 4.0

if (m_fadeUp)
{
	timer += delta;
	if (m_timer > m_revealTime)
	{
		timer = m_revealTime;
		m_fadeUp = false;
	}
}
else
{
	timer -= delta;
	if (timer < 0.0f)
	{
		timer = 0.0f;
		m_fadeUp = true;
	}
}

const f32 alpha = timer / totalFadeTime;

icon->SetAlpha(alpha);

The approach above uses linear interpolation so the fade looks quite even and bland. To get a nicer smooth fade you can use sin or cos alongside the linear value to give you a smoother looking effect. This is because of the curve of cos is not linear cos curve. Add the following lines to achieve this effect:

const f32 alpha = timer / totalFadeTime;
const f32 newAlpha = (cosf(TwoPi * alpha) - 1.0f) * -0.5f;
icon->SetAlpha(alpha);

Unfortunately I don’t have an example of this on hand to show but I does the trick nicely.

template
class ATemplateClass
{
public:
	ATemplateClass()
	{
	}

	virtual ~ATemplateClass()
	{
	}

	void Add()
	{
		++size;
	}

        void Reset()
	{
		size = 0;
	}

private:
	int size;
};

(for some reason my code output tags are doing strange things to liek putting in a and messing up the template tag, grrr!

Obviously this isn’t what my class is doing but is illustrative of the problem. When attempting to use this class on the stack like so:

MeanAverage myTemplate = MeanAverage();

I got the compiler warning:

warning: ‘myTemplate ‘ is used uninitialized in this function

After some head scratching (it is clearly being initialised!) one of my colleagues suggested the reason why I was getting the warning. The ‘size’ member of ATemplateClass wasn’t being initialised in the constructor which seems to have the knock on effect of causing the entire template to appear to not be initialised to the compiler! It may be a particularly strict but it fixes the warning nonetheless, hurrah!

I cannot explain this but focus on Visual Studio and press Ctrl + Scroll Lock fixes it. Yes it is mad and doesn’t make sense.

Credit goes to: here

I’ve just uploaded two new two new projects to the site.

The first is a little physics simulation I did last week.

The second is an application framework for DirectX that provides a basic scene along with camera setup and manipulation, logging, mesh loading and rendering support and direct input support.

You can get them in my downloads section of the site.

Cheers,
Eddie

In XCode select File->New Project. Select an Empty Project and name it whatever you want, screenie below:

Within XCode select Project->New Target again. Select Cocoa on the left then Application and name it whatever you’d like.

You will now see a window with a whole bunch of settings. In the General tab press the + button in Linked Libraries. Add OpenGL.Framework and Glut.framework from the list of frameworks in the dialog that appears.

Next select Build in the tabs along the top and clear the bottom field GCC_PREFIX_HEADER so that its blank.

In the Groups and Files explorer right click on the top level project and select Add->New File. Choose C and C++ and select C file. Again choose whatever name you wish.

Paste the following code into the C file:

#include stdlib.h
#include GLUT/glut.h

void myCustomDisplay(void)
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glutSwapBuffers();
}

void myCustomReshape(int width, int height)
{
    glViewport(0, 0, width, height);
}

void doSomethingWhenIdle(void)
{
    glutPostRedisplay();
}

int main(int argc, char** argv)
{
    glutInit(&argc, argv);

    glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);
    glutInitWindowSize(800, 600);

    glutCreateWindow("My First Window");

    glutDisplayFunc(myCustomDisplay);
    glutReshapeFunc(myCustomReshape);
    glutIdleFunc(doSomethingWhenIdle);

    glutMainLoop();
    return EXIT_SUCCESS;
}

Next Build the application using ‘Build and Go’ and you’ll be presented with a 800×600 empty window with the title ‘My First Window’, easy! I won’t go into the explanation of the different functions, there are plenty of sites out there for that!

I haven’t posted for a bit, back to some handy C++. I’ve been working with a lot of text being displayed on a background which can be various colours. Not knowing the background colour is in advance is problematic as if you specify the text colour to be always white and the background colour changes to white then the text is unreadable. Likewise for black and there are a range of colours in between that suffer with the same problem, light grey or dark purple for example.

I needed a way of determining correct text colour based on a given background colour. After doing a little bit of digging I came across this article on CodeProject which almost gives the solution I was looking for. However I want to just display white or black text depending on the background colour. So here is the code I used to do so, it works remarkably well. I’ve pseudo coded it up a bit to remove various bits and pieces that may not be important but you can just replace bits of it with proper objects. Also ignore the magic numbers, they’re there just to show the numbers that worked for me. This algorithm can potentially be used in any language, I’m using C++ here as it is what I’m currently using.

COLOUR GetTextColourFromBackground(COLOUR BackgroundColour)
{
	uint32 uDarkLightColourThreshold(105);
	float fRedThresholdValue(0.299);
	float fGreenThresholdValue(0.587);
	float fBlueThresholdValue(0.114);

	uint8 bgDelta = static_cast((BackgroundColour.GetRed() * fRedThresholdValue) + (BackgroundColour.GetGreen() * fGreenThresholdValue) +
		(BackgroundColour.GetBlue() * fBlueThresholdValue));

	COLOUR TextColour(GetColour(White));
	if((255 - bgDelta) < uDarkLightColourThreshold)
	{
		TextColour = GetColour(Black);
	}

	return TextColour;
}

So on a white background the text colour returned will be black and on a black background the text colour will be white. Also on a light grey background the colour returned will be black and so on.
The formula used above originally comes from the W3C http://www.w3.org/TR/AERT#color-contrast.

During some iPhone dev i noticed that the console on my macbook had many entries like:

Xcode(19838,0xb0103000) malloc: free_garbage: garbage ptr = 0x319a380, has non-zero refcount = 1
Xcode(19838,0xb0103000) malloc: free_garbage: garbage ptr = 0x31bf6e0, has non-zero refcount = 1
Xcode(19838,0xb0103000) malloc: free_garbage: garbage ptr = 0x3263da0, has non-zero refcount = 1
Xcode(19838,0xb0103000) malloc: free_garbage: garbage ptr = 0x3274eb0, has non-zero refcount = 1
Xcode(19838,0xb0103000) malloc: free_garbage: garbage ptr = 0x319a380, has non-zero refcount = 1
Xcode(19838,0xb0103000) malloc: free_garbage: garbage ptr = 0x31bf6e0, has non-zero refcount = 1

These messages I found out are not actually anything to do with my program, I thought I was doing something wrong and not freeing up resources. It is actually the internal workings of XCode which is automatically freeing up resources. Knowing this, I decided to turn off these annoying console outputs and found this XCode project which basically gobbles up output from XCode in the same mould as above.

Just compile the project and it will install the QuietXCode plugin to ~/Library/Application Support/Developer/Shared/Xcode/Plug-ins. Restart Xcode and fire up the console and you’ll see an inital output of:

06/08/2009 19:34:32 Xcode[5147] <QuietXcode> loaded successfully

You should no longer see the annoying output!

Due to a certain restrictive pattern being used at work, I’ve recently had the need to pass along two numbers but only had a single number to do so. It’s a bit of a nasty hack but is my first experience with using bit masking and is a useful technique. The integer being used in the pattern was an unsigned 32 bit integer and the two other integers I wanted to pass along were both unsigned 8 bit integers. The way we figured to send along the two numbers is to basically use half of the 32 bit integer to contain the two 8 bit integers using masking. The process is very simple there are two functions, Encode and Decode. Encode takes in two integers (I’ve made them unsigned 16 bits for the moment but you can easily cast the 8 bit unsigned integer to 16 bit) and returns a 32 bit unsigned int that contains the two. The encode function basically shifts the iFirstNumber into the lower 16 bits of the 32 bit integer. Then iSecondNumber is added to this to give a full 32 bit number.

uint32 Encode(const uint16 iFirstNumber, const uint16 iSecondNumber)
{
	uint32 iEncodedValue((iFirstNumber<< 16) + iSecondNumber);

	return iEncodedValue;
}

To explain it a little clearer suppose we have iFirstNumber set to 3 (0x00000011) and iSecondNumber set to 1 (0x00000001) we would end up with the encoded value being 0x0000001100000001

You can see that the first 16 bits contain iFirstNumber and the second 16 bits contain the second.

To get the two numbers back out again we have a similar Decode function:

void Decode(uint32 iValue, uint16& iFirstNumber, uint16& iSecondNumber)
{
	iFirstNumber = (uint16)((iValue & 0xFFFF0000) >> 16);
	iSecondNumber= (uint16)(iValue & 0x0000FFFF);
}

The first number is the overall value ANDed with 0xFFFF0000 and then shifted 16 bits to the right. ANDing the number with 0xFFFF0000 indicates that we are only interested in the first half of the bits in the overall value. It will turn all the rest of the bits in the value to be 0000000000. So after that we will be left with 0x0000001100000000. Now we need to narrow the number down to a 16 bit number. To do this we shift the bits 16 places to the right and cast to a uint16. Casting will remove the proceeding 16 bits(which are all now 0 anyway) and leave us with 0x00000011 which translates to 3.
For iSecondPosition we say that we want only the last half of the bits in the overall value. This leaves us with 0x0000000000000001. Casting this to a uint16 will leave us with 0x00000001 or 1.

In the end we actually didn't need to do it this way but got it working anyhow. Might be handy for someone maybe!