Some of our bits …

Juan Pablo — Mon, 28 Feb 2011 18:54:44 +0000

Hi!

Today I did some minors changes to our main site (please tell us if there is something wrong ) and I thought it would be good to add another entry to the blog.
Well, since some time I was thinking about sharing this beautiful piece of code. It is beautiful because of the use we have given to it, we used this tool for almost everything.

template <class T, int N> class IntegratorBase {
protected:
T mV[N];

public:
T& operator[](const int i) { assert(i>=0 && i<N); return mV[i]; }
const T& operator[](const int i) const { assert(i>=0 && i<N); return mV[i]; }
};

template <class T> class FirstOrderIntegrator : public IntegratorBase<T,2> {
public:
FirstOrderIntegrator() { }

FirstOrderIntegrator(const T& x, const T& v)
{
this->mV[0] = x; this->mV[1] = v;
}

void Update(float t)
{
this->mV[0] += this->mV[1] * t;
}
};

template <class T> class SecondOrderIntegrator : public IntegratorBase<T,3> {
public:
SecondOrderIntegrator() { }

SecondOrderIntegrator(const T& x, const T& v, const T& a) {
this->mV[0] = x; this->mV[1] = v; this->mV[2] = a;
}

void Update(float t)
{
T vt = this->mV[2] * t;
this->mV[0] += (this->mV[1] + vt * 0.5f) * t;
this->mV[1] += vt;
}
};

// This is a fat one.
template <class T> class ThirdOrderIntegrator : public IntegratorBase<T,4> {
public:
ThirdOrderIntegrator() { }

ThirdOrderIntegrator(const T& x, const T& v, const T& a, const T& w) {
this->mV[0] = x; this->mV[1] = v; this->mV[2] = a; this->mV[3] = w;
}

void Update(float t) {
T mv3t = this->mV[3] * t;
T mv2t = (this->mV[2] + mv3t * 0.5f ) * t;
this->mV[2] += mv3t;
this->mV[0] += (this->mV[1] + mv2t * 0.5f) * t;
this->mV[1] += mv2t;
}
};

It is a template structure for elements that can be integrated over time.
It is Game development related and actually it is not as precise since it uses Euler integration. However, you can modify it to use the integration you want … and actually, it wouldn’t be as hard to create a RK4 version of the mechanic.

With this mechanic you will be able to access the derivatives with the index operator []:

X[0] -> The thing you are integrating
X[1] -> First derivative over time
X[2] -> Second derivative over time

Which is really really handy (you won’t believe me how much).

A tipical usage:

struct Particle {

FirstOrderIntegrator<Vector2f> mPosition;
FirstOrderIntegrator<Color4f> mColor;

void Update(float t) {
mPosition.Update(t);
mColor.Update(t);
}

void Draw( GraphicThing& gt ) {
gt.Draw( mPosition[0], mColor[0] );
}

void InvertDirection() {
mPosition[1] *= -1.0f;
}

};

You probably know about templates and integrators but haven’t thought about using them that way … yeah, there are many situations where this structure cannot help you, but in many cases it will save you to write a lot of code

See you later!

Fast Integer Log2 function in C/C++

Juan Pablo — Tue, 20 Jan 2009 03:14:14 +0000

Some times, it happens that you need to have a high performance function that you usually use in a not optimized way. And since you never needed to optimize it you hesitated before realising it can be severly improved. Probably, this is what you would think of the integer log2 function, in general this function is used on not critic code so it can be “slow” without creating any problem (often used to calculate the size of a power of 2 texture to hold an image)

The usual way of calculating this log2 function is testing until the base elevated to the log is bigger than the value. This is easy with the << operator.
This function returns the truncated to the integer unit log2 of value:

inline unsigned int iLog2(unsigned int value)
{
unsigned int l = 0;
while( (value >> l) > 1 ) ++l;
return l;
}

Easy, isn’t it? And it is quite fast! you will do 8 comparations to return the log2 of 256.
But what if we do a binary search instead of this linear search …

inline unsigned int Log2(unsigned int value)
{
unsigned int f=0, s=32;
while(s) {
s>>=1;
if( value > 1<<(f+s) ) f+=s;
}
return f;
}

Even faster since we will be doing a fixed number of comparations.
And so, if they are fixed …

inline unsigned int ilog2(register unsigned int x)
{
register unsigned int l=0;
if(x >= 1<<16) { x>>=16; l|=16; }
if(x >= 1<<8) { x>>=8; l|=8; }
if(x >= 1<<4) { x>>=4; l|=4; }
if(x >= 1<<2) { x>>=2; l|=2; }
if(x >= 1<<1) l|=1;
return l;
}

You can hardcode the answers and the bit settings, and this one compiles really well!
If you want to go further you can expand the ifs to 32 branches with 32 results, and so you will collapse the search time to the minimal (I cannot think on something better), but it is up to you if you want to go further. As well this function can be bounded with template arguments, but I don’t think this will ever pay off.

Probably you won’t find this function useful (except if you are here because you were looking for it), but in any case I liked this function so much and I wanted to share it because it shows us that even the most every day used things can be improved, refined, and can be prepared for different contexts. It isn’t all invented, you can keep discovering and creating

- Juan Pablo

South Winds Games :: Blog » C++

Some of our bits …

Fast Integer Log2 function in C/C++