Hey everyone, I've got a bit of a beginner question regarding C++ interfaces. I'm working on an import system for my game engine library, where my goal is to convert various file formats into a custom format compatible with my engine. I want to use libraries like Assimp and stb just once instead of reloading them every time I need to access an asset. I'm struggling with how to properly implement classes and interfaces for this.
I was initially thinking of creating a single interface like this:
```cpp
class IAssetImporter {
public:
~IAssetImporter() = default;
virtual void importByFile() = 0;
};
class AssimpImporter : public IAssetImporter {};
class StbImporter : public IAssetImporter {};
```
However, I'm considering whether it makes more sense to split these into distinct interfaces based on asset types:
```cpp
class IMeshImporter {};
class AssimpImporter : public IMeshImporter {};
class ITextureImporter {};
class StbImporter : public ITextureImporter {};
```
I feel like having an interface for each type might just add unnecessary complexity, but I'm open to being wrong here. What do you all think?
5 Answers
I generally make interfaces only if I need to create different types of classes that I'll need to manage together. For instance, in my event handling system, all events inherit from a base class, enabling me to support any new event types down the line. There are clever ways to implement polymorphism without strict interfaces too, like using worker classes for various tasks.
First off, check out this video that might clarify things: [Watch Here](https://www.youtube.com/watch?v=tD5NrevFtbU). And remember to consider why you need to create these interfaces. If it's solely to separate importers, think about what issues that is actually solving. You might find that just a single interface does the job without overcomplicating things.
Have you thought about just branching based on asset types? You could simplify your imports like this:
```cpp
if (asset_is_a_3d_model) {
// import using assimp
} else {
// import using stb
}
```
This approach might make your code more straightforward without needing separate interfaces.
You've got a couple of routes you can take. The traditional object-oriented approach would suggest having separate interfaces, like `class IMeshImporter` and `class ITextureImporter`. This way, classes like `AssimpImporter` and `StbImporter` can implement the interfaces relevant to their specific functions. But keep in mind, C++ doesn't have true interfaces – it uses multiple inheritance, which can get tricky.
Also, ask yourself if you actually need runtime polymorphism. Sometimes, it might be simpler to instantiate each importer and select the right one based on the file type directly in a manager class. This bypasses the need for virtual methods altogether!
For a custom game engine, you probably won’t need diverse importers implementing different interfaces often. Assimp and stb likely cover all the formats you'll need. You might want to focus on creating interfaces for your actual assets instead, like `class D3DTexture: public ITextureAsset` and `class VulkanTexture: public ITextureAsset`, where `StbImporter` processes data to these assets.
Related Questions
Set Wordpress Featured Image Using Javascript
How To Fix PHP Random Being The Same
Why no WebP Support with Wordpress
Replace Wordpress Cron With Linux Cron
Customize Yoast Canonical URL Programmatically
[Centos] Delete All Files And Folders That Contain a String