Oh, I didn't think about it like that. Sure, that actually seems like a pretty good solution.
well its pretty much a standard when it comes to abstract different API in C++.. I didnt come up with it, it's used pretty much everywhere. DirectX/COM is doing exactly that abstracting the driver part (well sort of anyway).. OpenGL is using the other "C" based approach that I also use in my project, and I tend to prefer because it seems to map to less boilerplate.. it looks something like this.. very OpenGL-like (ODE also use this approach to expose it's C++ to the rest of the world through C):
You have a .h with your functions:
int CreatePhysicsEngine();
unsigned int CreateRigidBody();
void RigidBodyAddForce(unsigned int rigidBody,blablalblal);
The hacky part here is to translate that unsigned int to an instance of a class.. it could be a brutal static cast.. or a even more brutal C style cast.. so the implementation code.. in something like BulletPhysicsEngine.cpp would look like:
BulletPhysicsEngine* theEngine=nullptr;
int CreatePhysicsEngine()
{
theEngine=new BulletPhysicsEngine(); // This will only allow 1 physics engine per application.. YMMV
}
unsigned int CreateRigidBody()
{
// Same stuff
return (unsigned int) new BulletRigidBody(theEngine);
}
// Now the hacky part
void AddForce(unsigned int rigidBody,blalblblla)
{
auto bullet_rigid_body=(BulletRigidBody*)rigidBody;
bullet_rigid_body->addForce();
}
This is as hacky as a void* I have to admit.. but it does come with the added bonus the the code requires much less boilerplate and it is easily consumable from other languages because of the C interface... and perhaps because of its C nature it doesnt feel that bad to use C brutal casts .