Monday, August 28

A POD polymorphic object

Impossible, you cry: POD is POD and virtual functions are virtual functions and nary the twain shall meet! More sophisticated readers among you might assume this is a rehash of static polymorphism, but this is not so. I have a POD struct that can be used nonhomegenously in a container, and support run-time polymorphism. Without further ado, here is the code..



simple.h





enum eEngineObjectKind
{
eMeshObject = 0,
eSkeletonObject,
nEngineObjectKinds
};

typedef float t_TRANSFORM[16];


typedef void (*UpdateFunctionPtr)(float time_delta);

extern UpdateFunctionPtr update_jump_table[nEngineObjectKinds];

template <typename T> class EngineObject
{
private:
T* object_data;
enum eEngineObjectKind kind;

public:
void init_object()
{
kind = T::object_kind;
update_jump_table[kind] = T::object_update_fn;
object_data = new T(); // or T::allocate_object
};

void update_object(float time_delta)
{
update_jump_table[kind](time_delta);
}
};

template <> class EngineObject<void>
{
private:
void *object_data;
eEngineObjectKind kind;

public:
void *getData()
{
return object_data;
}

eEngineObjectKind getKind()
{
return kind;
}

void update_object(float time_delta)
{
update_jump_table[kind](time_delta);
}

};

class EngineMeshData
{
public:
static eEngineObjectKind object_kind;
static UpdateFunctionPtr object_update_fn;

static void UpdateMesh(float time_delta);

};

class EngineSkeletonData
{
public:
static eEngineObjectKind object_kind;
static UpdateFunctionPtr object_update_fn;

static void UpdateSkeleton(float time_delta);

};

typedef EngineObject<EngineMeshData> EngineMeshObject;
typedef EngineObject<EngineSkeletonData> EngineSkeletonObject;




simple.cpp





#include <iostream>
#include "simple.h"

/**
* pseudo - vtable !
*/

UpdateFunctionPtr update_jump_table[nEngineObjectKinds];

/**
* skeleton defintions
*/

enum eEngineObjectKind EngineSkeletonData::object_kind = eSkeletonObject;

void EngineSkeletonData::UpdateSkeleton(float time_delta)
{
std::cout << "Update Skeleton\n";
}

UpdateFunctionPtr EngineSkeletonData::object_update_fn = EngineSkeletonData::UpdateSkeleton;

/**
* mesh defintions
*/

enum eEngineObjectKind EngineMeshData::object_kind = eMeshObject;

void EngineMeshData::UpdateMesh(float time_delta)
{
std::cout << "Update Mesh\n";
}

UpdateFunctionPtr EngineMeshData::object_update_fn = EngineMeshData::UpdateMesh;




EngineObject<void> world[2];

int main (int argc, char *argv[])
{
EngineSkeletonObject *skeleton = new(world) EngineSkeletonObject();
skeleton->init_object();

EngineMeshObject *mesh = new(world+1) EngineMeshObject();
mesh->init_object();

world[0].update_object(1.0f);
world[1].update_object(1.0f);

};

Monday, August 21

The autoconf dance..

It goes like this: .in and out....

aclocal -> aclocal.m4
autoheader -> config.h
autoconf -> configure
automake -> Makefile.ac -> Makefile.in
configure -> Makefile.in -> Makefile

Then make finally builds it....