Hi all,

I'm struggling a bit on design related thing in my new d3d11 engine.

Here's the situation:

- I have a low level renderer (d3d11)

- meshes are stored in a mesh class

- there's an IBuffer class (interface), which basically links api-independent mesh class to the d3d11 low level renderer

(IBuffer contains the D3D11 buffer, used for vertices or indices)

So far I've thought of two options how to brings this together:

1. Give the mesh class 2 IBuffer's as members, one for the vtx buffer and one for the indexbuffer

2. Let the low-level renderer have a meshbuffer manager, which stores all the IBuffers.

In this case, the manager returns an ID/handle for each buffer, which is stored in the mesh object (mVtxBufferId and mIndexBufferId)

But solutions come with advantages and disadvantages.

I'm leaning towards option 1, where I encounter something practical:

- the IBuffer class has a 'Create' function, which needs a template of const * data (can be either vertices or indices, uint's or some struct)

(because of the template I cannot create the buffer through the constructor, using a template)

- the Create function also takes the D3D11 device pointer (needed for creation)

I could solve this by one of these options:

1. Make the IBuffers in the Mesh public, so I can call the Create function from outside the mesh class

(keeping the mesh API independent, otherwise I would need to make a CreateBuffers function in the API independent mesh class, taking a D3D11 device ptr)

2. Accept that an API independent class (mesh), needs a D3D11 device ptr (to create buffers). I really don't like this option btw.

I'm curious how you would solve this and/or if you could give me some 'pointers' on how to continue.

Btw, option 2 works for sure (I've already implemented this), but it doesn't feel clean because I cannot create the buffer through the constructor (because of the template function). Also option 2 has the disadvantage that a mesh has to know the ID of the buffer(s) in the manager. Meaning that when you 'kill' a buffer in the manager, you cannot reshuffle the std::vector, otherwise the buffer ID's in the mesh object won't match up anymore. But I already figured out that I can use a 'freelist' for this, to be able to fill up the 'gaps' in the vector for released IBuffers.

Last but not least, I could also consider some sort of 'factory' pattern, where IBuffers are returned. This would be in line with option 2 above.

Any input is appreciated.

Thanks. Would that mean that I would pass the abstract device to the mesh class in the renderer system? And that the abstract device interface internally points to the API's (D3D11 in this case) device?

I'm still in doubt if this isn't a bridge too far for me, for the current stage I'm in (leaning, playing around).

I cannot imagine how this would look in (pseudo) code.

If this is the case, what would you think will be the best of the 2 options above? (or with some tweaking a option '3')

OK, I think I'm getting the point.

- in this case I would have a mesh and a device class, both API independent

- it's no problem to pass this device to the mesh creation function

- in the underlying implementation of the API independent/ abstract device class, the real ID3D11 device is used

-- CDevice has a member ptr to the D3D11 device

-- CDevice has a member function CreateBuffer, which underneath uses the D3D11 device ptr to create the D3D11 buffer (within the IBuffer)

-- In the constructor of the CDevice I can pass the D3DDevice ptr (make it a std::unique_ptr so I can 'manually' create the object with the constructor)

Basically enabling that when you need another API, you only have to change the abstract classes: in this case the device class and the IBuffer class.

Is this a good 'monkeyproof' explanation of what you mean?

When I do this, I could easily go for option 2 in the initial question, with the addition that the mesh class would need a public function to retrieve the 2 IBuffer (their ptr's), because I don't think I want to make the 2 IBuffer members of the mesh public.

One last question; where in the design would you place the abstract classes for the Device and the Device context?

(I would say within the renderer system, blue part of the system overview)

Am I thinking in the right direction?

Thanks.

Regarding this point: "instead allow your mesh to make the requests for buffers".

I can imagine doing this the following way:

- when creating a mesh (constructor) I pass a pointer to the abstract buffermanager

- this is stored in the mesh class object

- when a mesh is created (vertices, indices), I can directly call the buffermanager to create the buffers for this mesh

(meaning I won't forget it, compared to doing it manual, by the caller)

Is this what you mean?

If you, this would mean I will keep/ have a MeshBufferMgr in my low level renderer system (option 2 in the 1st post of the thread).

This would mean though, that in all mesh objects I have a pointer stored to the buffermanager.

It works like a charm :)

I've implemented the IGPUDevice already, next step is the context.

I aim that I don't have to include any d3d11 or d3d11 low renderer headers in my main application (on top/ frontend of the engine).

Abstraction is cool but I have to draw a line somewhere I guess.

- ConstantBuffer -> for sure, same as MeshBuffer

- RenderTarget -> perhaps, although the DXGI_FORMAT might be D3D11 only which makes the abstraction a bit different (I would need to pass a DXGI_FORMAT to the abstracted RT class)

- RenderStates and SamplerStates: I won't abstract them for now, perhaps later on when I manage them different (aka better). Now there's just globals within the main application (not that far yet).

Passing the D3D samplerDesc to a abstracted samplerstate doesn't sound usefull.

Here's some code snippets.

Thanks again for the advice and helping me in the right direction.

// IRenderer, will also have the IGPUContext when it's done

class IRenderer
{
public:
	IRenderer(ID3D11Device *pDevice);
	~IRenderer();

	IGPUDevice* GetIDevice()		const;

private:
	std::unique_ptr<IGPUDevice>		mDevice;
};

IRenderer::IRenderer(ID3D11Device *pDevice)
{	
	mDevice = std::make_unique<IGPUDevice>(pDevice);
}

IGPUDevice* IRenderer::GetIDevice() const
{
	return mDevice.get();
}

// IGPUDevice

class IGPUDevice
{
public:
	IGPUDevice(ID3D11Device *pDevice);
	~IGPUDevice();

	ID3D11Device*	GetDevicePtr()	const;

	bool CreateBuffer(const D3D11_BUFFER_DESC *pDesc, const D3D11_SUBRESOURCE_DATA *pInitialData, ID3D11Buffer **ppBuffer);
	bool CreateRasterizerState(const D3D11_RASTERIZER_DESC *pRasterizerDesc, ID3D11RasterizerState **ppRasterizerState);
	bool CreateSamplerState(const D3D11_SAMPLER_DESC *pSamplerDesc, ID3D11SamplerState **ppSamplerState);

private:
	CComPtr<ID3D11Device>	mD3DDevice;
};

IGPUDevice::IGPUDevice(ID3D11Device *pDevice) : mD3DDevice(pDevice)
{	
	// nothing to do, CComPtr = nullptr by construction
}

// and just one of the abstracted functions

bool IGPUDevice::CreateBuffer(const D3D11_BUFFER_DESC *pDesc, const D3D11_SUBRESOURCE_DATA *pInitialData, ID3D11Buffer **ppBuffer)
{
	if(FAILED(mD3DDevice->CreateBuffer(pDesc, pInitialData, ppBuffer))) return false;
	return true;
}

For now, the mesh class of the renderer system simply has 2 IBuffers, and creation of a simple box is done like this:

bool C3dMesh::CreateBox(IGPUDevice *pDevice, const float pWidth, const float pHeight, const float pDepth)
{
	CGeometryGenerator::MeshData box;

	CGeometryGenerator geoGen;
	geoGen.CreateBox(1.0f, 1.0f, 1.0f, box);

	std::vector<Vertex::PosNormTex> tVertices(box.Vertices.size());
	mVertexByteSize = sizeof(Vertex::PosNormTex);

	for(size_t i=0;i<box.Vertices.size();++i)
	{
		tVertices[i].Position	= box.Vertices[i].Position;
		tVertices[i].Normal		= box.Vertices[i].Normal;
		tVertices[i].Texcoord	= box.Vertices[i].Texcoord;
	}

	if(!mVtxBuffer.Create(pDevice->GetDevicePtr(), VERTEX_BUFFER, tVertices, false, false)) return false;
	if(!mIndexBuffer.Create(pDevice->GetDevicePtr(), INDEX_BUFFER, box.Indices, false, false)) return false;

	mNrVertices = box.Vertices.size();
	mNrIndices = box.Indices.size();
	mNrFaces = mNrIndices / 3;

	return true;
}

I might want to change the IBuffer creation, maybe through the constructor or have some function return the created IBuffer.

Don't know how to do that yet.

Ofcourse, any additional input is appreciated :cool: