Please, by all means if I am incorrect somewhere please correct me. Also, if you wish to add to this list, feel free to do so.

Cross-Compilation Helpers

First up, one of the more common tasks, especially when writing libraries versus executable programs, is exporting symbols. The process to export symbols is different for the various compilers. The following should take care of GCC and MSVC:

[cpp]
#if defined(_MSC_VER)
#  define LIB_EXPORT __declspec(dllexport)
#  define LIB_IMPORT __declspec(dllimport)
#elif defined(__GNUC__)
#  define LIB_EXPORT /* */
#  define LIB_IMPORT extern
#endif
#
#if defined(__cplusplus)
#  define EXTERN_C extern “C”
#else
#  define EXTERN_C /* */
#endif
[/cpp]

Use the EXTERN_C macro when name-mangling on exported functions must be avoided.

There are many ways to tackle symbol exports. In fact if I’m not mistaken, GCC now has synonyms for __declspec(dllexport/dllimport) so there may not even be a need to use the pre-processor to first establish which compiler is in use for the import/export macros mentioned above. It all depends on which version of GCC you’re using.

Calling Convention Helpers

Most, if not all compilers assume a calling convention when a function is not decorated with one. When problems arise with mis-matched calling conventions (almost always with exported functions) then use the following macros to specify a calling convention rather than leaving it up to the compiler.

[cpp]
#if defined(_MSC_VER)
#  define STDCALL __stdcall
#  define CDECL __cdecl
#  define FASTCALL __fastcall
#elif defined(__GNUC__)
#  define STDCALL  __attribute__((stdcall))
#  define CDECL /* */
#  define FASTCALL __attribute__((fastcall))
#endif
[/cpp]

Function Inlining

Compilers will often attempt to make functions inline where it makes sense to do so (depending on compiler flags, etc.). If you wish to force the compiler to make a function inline, use the following macro:

[cpp]
#if defined(_MSC_VER)
#  define FORCEINLINE __forceinline
#elif defined(__GNUC__)
#  define FORCEINLINE inline
#endif
[/cpp]

Struct Member Alignment

Another possible area of compatibility mismatch is with member alignment. To force the compiler to use a specific member alignment byte-boundary, use the following macro:

[cpp]
#if defined(_MSC_VER)
#  define DECL_ALIGN(x) __declspec(align(x))
#elif defined(__GNUC__)
#  define DECL_ALIGN(x) __attribute((aligned(x)))
#endif
[/cpp]

Utility Macros

I’ll end this post with some utility macros that I find to be pretty helpful…

Inline-Square

[cpp]
#if !defined(sqr)
#  define sqr(x) ((x)*(x))
#endif
[/cpp]

Min/Max

[cpp]
#if defined(min)
# undef min
# define min(a, b) (((a)<(b))?(a):(b))
#endif
#if defined(max)
# undef max
# define max(a,b) (((a)>(b))?(a):(b))
#endif
[/cpp]

Class Declarations (my personal favorite)

[cpp]
#define DECLARE_CLASS_NOBASE(className) typedef className ThisClass
#define DECLARE_CLASS(className, baseClass) typedef baseClass BaseClass;\
DECLARE_CLASS_NOBASE(className)
[/cpp]

You can get rather creative with the above macro. I use it for a redumentary form of reflection or for logging purposes by converting the class name to a string that can be evaluated at run-time.

Example:
[cpp]
#define DECLARE_CLASS_NOBASE(className) typedef className ThisClass;\
virtual const char * ThisClassName() const { return #className; }
#define DECLARE_CLASS(className, baseClass) typedef baseClass BaseClass;\
virtual const char * BaseClassName() const { return #baseClass; }\
DECLARE_CLASS_NOBASE(className)
[/cpp]

Sorry for any inconvenience.

For the longest time I chalked it up to my anti-virus software obtaining a lock on the file and not letting go of it. As it turns out, its a bug in VS2008.

Now I’m not entirely sure how closely my model fits to the typical factory pattern but as far as I understand factory pattern, it is pretty close if not exact.

Basically a factory consists of an interface class which is common to all of the implementation classes that the factory will create. Then you have the factory class which is usually a singleton class that spawns instances of these implementation classes.

So lets create a quick interface class to start with. In this example I used IAnimal:

[cpp]
class IAnimal
{
public:
virtual int GetNumberOfLegs() const = 0;
virtual void Speak() = 0;
virtual void Free() = 0;
};
[/cpp]

Now for simplicity’s sake I used a typedef to define a type for the function that is used by the implementation classes to create instances of IAnimal. This typedef is also used in declaring the map that maps the animal name to the function that creates that particular type of animal. You can use whatever calling convention you like, but for this example I chose __stdcall.

[cpp]typedef IAnimal* (__stdcall *CreateAnimalFn)(void);[/cpp]

Now comes the factory class. This is a singleton pattern implementation so that only one instance of the factory can ever be instantiated, no more, no less.

[cpp]
// Factory for creating instances of IAnimal
class AnimalFactory
{
private:
AnimalFactory();
AnimalFactory(const AnimalFactory &) { }
AnimalFactory &operator=(const AnimalFactory &) { return *this; }

typedef map FactoryMap;
FactoryMap m_FactoryMap;
public:
~AnimalFactory() { m_FactoryMap.clear(); }

static AnimalFactory *Get()
{
static AnimalFactory instance;
return &instance;
}

void Register(const string &animalName, CreateAnimalFn pfnCreate);
IAnimal *CreateAnimal(const string &animalName);
};
[/cpp]

Now comes the implementation classes. These are the classes that implement the IAnimal interface. Here’s a few examples:
[cpp]
// IAnimal implementations
class Cat : public IAnimal
{
public:
int GetNumberOfLegs() const { return 4; }
void Speak() { cout << “Meow” << endl; }
void Free() { delete this; }

static IAnimal * __stdcall Create() { return new Cat(); }
};

class Dog : public IAnimal
{
public:
int GetNumberOfLegs() const { return 4; }
void Speak() { cout << “Woof” << endl; }
void Free() { delete this; }

static IAnimal * __stdcall Create() { return new Dog(); }
};

class Spider : public IAnimal // Yeah it isn’t really an animal…
{
public:
int GetNumberOfLegs() const { return 8; }
void Speak() { }
void Free() { delete this; }

static IAnimal * __stdcall Create() { return new Spider(); }
};

class Horse : public IAnimal
{
public:
int GetNumberOfLegs() const { return 4; }
void Speak() { cout << “A horse is a horse, of course, of course.” << endl; }
void Free() { delete this; }

static IAnimal * __stdcall Create() { return new Horse(); }
};
[/cpp]

Now we need to work out a few definitions of the AnimalFactory class. Specifically the constructor, the Register, and the CreateAnimal functions. The constructor is where you might consider registering your factory functions. Though this doesn’t have to be done here, I’ve done it here for the purposes of this example. You could for instance register your factory types with the factory class from somewhere else in code.
[cpp]
/* Animal factory constructor.
Private, called by the singleton accessor on first call.
Register the types of animals here.
*/
AnimalFactory::AnimalFactory()
{
Register(“Horse”, &Horse::Create);
Register(“Cat”, &Cat::Create);
Register(“Dog”, &Dog::Create);
Register(“Spider”, &Spider::Create);
}
[/cpp]

Now lets implement the Register function. This function is pretty straight forward since I used a std::map to hold the mapping between my string (the animal type) and the create function.
[cpp]
void AnimalFactory::Register(const string &animalName, CreateAnimalFn pfnCreate)
{
m_FactoryMap[animalName] = pfnCreate;
}
[/cpp]

And last but not least, the CreateAnimal function. This function accepts a string parameter which co-responds to the string registered in the AnimalFactory’s constructor. When this function receives “Horse” for example, it will return an instance of the Horse class, which implements the IAnimal interface.
[cpp]
IAnimal *AnimalFactory::CreateAnimal(const string &animalName)
{
FactoryMap::iterator it = m_FactoryMap.find(animalName);
if( it != m_FactoryMap.end() )
return it->second();
return NULL;
}
[/cpp]

Here’s an example of how to use the above code:
[cpp]
int main( int argc, char **argv )
{
IAnimal *pAnimal = NULL;
string animalName;

while( pAnimal == NULL )
{
cout << “Type the name of an animal or ‘q’ to quit: “;
cin >> animalName;

if( animalName == “q” )
break;

IAnimal *pAnimal = AnimalFactory::Get()->CreateAnimal(animalName);
if( pAnimal )
{
cout << “Your animal has ” << pAnimal->GetNumberOfLegs() << ” legs.” << endl;
cout << “Your animal says: “;
pAnimal->Speak();
}
else
{
cout << “That animal doesn’t exist in the farm! Choose another!” << endl;
}
if( pAnimal )
pAnimal->Free();
pAnimal = NULL;
animalName.clear();
}
return 0;
}
[/cpp]

To sum it up… I have been working my rocks off. Incase you haven’t read my LinkedIn profile, I’m working as a serious game software developer at a research company that primarily focuses on US Army dismounted infantry simulators. We have a demo coming up in September so we’re all pretty strapped for time while trying to make this demo as clean and bug-free as possible.

One of the more interesting aspects of my work lately has been using motion capture equipment to retrieve realtime data about the anatomical positions of bones and joins throughout the body in order to get a computer (NPC, non-player character) to recognize what the user is actually doing with their body. In essence this is gesture recognition. Much like speech recognition, it is the process of looking for patterns inside of a set of input data. This input data however is not a sound-wave. It is a huge sequence of 3D vectors and Quaternions (for the bone positions and orientations) and a long sequence of values between 0 and 1 for the fingers.

The finger data is captured using a glove that has potentiometers (variable resistors for the layperson) that react to the closing and opening of each finger along with the abduction between each digit on the hand (thats the webbing between your fingers). The rest of the body is measured using accelerometers, g-force sensors, and compasses placed in key locations on the human body. As the body moves it creates various changes in this data which is translated into 3-dimensional vectors for position and 4-dimensional vectors (Quaternions) for orientation.

This data is then sent through a processor (the software I’m working on) which looks for patterns in the data and attempts to match these patterns with pre-recorded “template” gestures. The match with the highest confidence level wins out and ultimately becomes what is deemed recognized by the NPC.

This recognition is then tied to key events in the training software such as directing your squad of NPCs to clear a building, freeze, follow (in various formations), or commence firing among many others. The other purpose for recognizing when a gesture has been made by the user is for locomotion through the virtual world. This means the user of the system can walk around in the virtual world, fully immersed in the equipment, and not move outside of a 6ftx6ft square on the floor. Its pretty remarkable what we’ve been able to accomplish with this.

It still has some distance to go before it is production ready, but these early tests look very promising. It has been quite a task to figure out this problem. In the process we have all learned how complex the human body really is and what we as humans take for granted in terms of how we move and act. The human body and brain is a very remarkable feat of biological engineering.