While working on my DirectX engine lately, things have been going great. Everything is nice and encapsulated, the design is clean & consistent, and I have a Component/Component Manager / Entity system worked out that is very flexible, and overall things are running solid.
Well, I'm now working on the graphics pipeline, and I am having trouble figuring out how I want to design my Mesh, MeshInstance, and Mesh Rendering system, specifically when dealing with the loading or creating of a new mesh, and the way that its buffers are then initialized.
I don't feel like allowing the Mesh class to directly access the device is good design. I just can't really wrap my head around the way the initial Vertex buffers of a single mesh should be created. For instance, loading from a file I would call something like:
Where the resource manager would use a string hash to identify whether or not that particular file had been created, either creating new Buffers & then returning a new MeshInstance, or something along those lines... The other problem being say I wanted to procedurally create a mesh... once I create the vertex data, how would I then initialize the buffers for that?
Another issue with that method is I also don't think it makes sense for the ResourceManager to have a pointer to the D3D device either.
Can you please share any experiences or designs that you felt were elegant, or suggest a pattern that is well suited for this issue, This is a major design consideration that's really halting my progress because the same pattern will be implemented for probably all of my resources.
In my opinion, the Resource manager should create everything and store it in the Mesh/Material classes. So the resources can simply be a structure of pointers to buffers/textures, etc.
I think its preferable for the ResourceManager to have a pointer to the D3D Device than the Resource classes.
In my engine I have the following design (only regarding meshes):
- MeshDesc struct - contains pointers to the vertex/index data and other data needed to create the mesh. - Mesh* ResourceManager::createMesh(uint nameHash, const MeshDesc& desc) - creates the buffers (etc) puts them in a new Mesh object and returns it. - Mesh* ResourceManager::loadMesh(uint filenameHash) - check if already has been loaded, if not load the data into a MeshDesc objects and call createMesh().
With this design you can either load meshes or create them procedurally by filling in a MeshDesc and calling createMesh()
I use the same pattern as TiagoCosta, though inside my MeshDesc I have a VertexBufferDesc, IndexBufferDesc, and VertexDeclarationDesc. Those sub-descriptions can then be created outside the MeshDesc, and used either at the Mesh initialization point, passed in separately for dynamic vertex buffer generation, or just used outside a mesh entirely if you wanted. The pattern has worked out fairly well, though it is *very* initialization heavy.
Perception is when one imagination clashes with another