3 replies to this topic

[neonic]

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:

rm->LoadAsset(filename);

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.

Thanks in advance

[TiagoCosta]

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()

Edited by TiagoCosta, 07 August 2012 - 05:08 AM.

[Seabolt]

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.

[neonic]

Alright, this helps a lot, and I like the pattern you laid out. I started my implementation, and so far things are going pretty well.

Thinking that it was not proper that the Resource Manager had a pointer to the D3DDevice, I was very confused, but apparently this is common practice... So yeah, this helped very much, thanks all.