It is very simple.
As I said, make wrappers for all of those functions.
An appropriate class name might be CDirectX11.

This class keeps local copies of the last values sent to every DirectX 11 function (or at least a lot of them).
For example.


/** Textures ready to be sent to the shaders (public). */
static ID3D11ShaderResourceView * m_psrvActiveTextures[LSG_MAX_TEXTURE_UNITS];

/** Last textures (private). */
static ID3D11ShaderResourceView * m_psrvLastActiveTextures[LSG_MAX_TEXTURE_UNITS];


When your CTexture class wants to be activated into a slot (you do have a wrapper for your DirectX 11 textures, right? It is standard practice), it simply does this:

/**
* Activate this texture in a given slot.
*
* \param _ui32Slot Slot in which to place this texture.
* \return Returns true if the texture is activated successfully.
*/
LSBOOL LSE_CALL CDirectX11StandardTexture::Activate( LSUINT32 _ui32Slot ) {
CDirectX11::m_psrvActiveTextures[_ui32Slot] = m_psrvShaderView;
return true;
}


Notice how nothing has been sent to DirectX 11 yet.
Textures, constant buffers, samplers, etc. only need to be sent when it is actually time to draw.
So there should be another function that is called just before an actual render:

/**
* Called just before rendering to allow performing of any final tasks.
*/
LSVOID LSE_CALL CDirectX11::PreRender() {
LSUINT32 ui32Index = 0UL, ui32Total = 0UL;
LSUINT32 ui32Max = CStd::Min<LSUINT32>( LSG_MAX_TEXTURE_UNITS, CFndBase::m_mMetrics.ui32MaxTexSlot );
for ( LSUINT32 I = 0UL; I < ui32Max; ++I ) {
if ( m_psrvActiveTextures != m_psrvLastActiveTextures ) {
++ui32Total;
m_psrvLastActiveTextures = m_psrvActiveTextures;
}
else {
if ( ui32Total ) {
m_pdDevice->PSSetShaderResources( ui32Index, ui32Total, &m_psrvActiveTextures[ui32Index] );
}
ui32Index = I + 1UL;
ui32Total = 0UL;
}
}
if ( ui32Total ) {
m_pdDevice->PSSetShaderResources( ui32Index, ui32Total, &m_psrvActiveTextures[ui32Index] );
}
}

It is really not that complicated. All it is doing is checking for the fewest possible calls it can make to PSSetShaderResources() on each render call by comparing the currently active textures with the textures active on the last render. This is the only location where it is valid to call PSSetShaderResources(), so the local record of the last textures sent to DirectX 11 is accurate.

You basically need a similar system in place for everything. Samplers, textures, constant buffers, etc.
And then you need to make this actually useful by implementing a render queue to maximize the number of times the same texture, shader, etc. are used in repeated render calls.


L. Spiro

Wrappers are only the next step up so it is nothing you can’t handle.

But Erik Rufelt is also correct. These redundancy optimizations are important, especially for the long run, but right now it seems clear that you have bigger issues at hand.

Put all of those chunks into one buffer and draw with one call. If the FPS remains mostly similar, it means you have a bandwidth problem, and the 16-bit vertex data optimization should be a large help.

Also, draw your terrain normally, but move the camera out so that it is only a small part of the screen.
If the FPS increases dramatically, you have a fill-rate problem related to your pixel shader. You could then start examining that.


L. Spiro

To be clear, are you saying that zooming out so far that the terrain occupies only about 100-500 total pixels on the screen results in a similar framerate?
And you are sure that the rest of whatever you are drawing is not causing this slow framerate?

If so, you definitely have a bus-transfer problem, and the 2 main optimizations would be to use 16-bit vertices and a second stream for the Y, and compressed textures.
Compressed textures are the easiest to implement so start there.

When my site talks about padding, yes, it is as in your example. Add some fake bytes so that the next element in the buffer is 32 bytes after the previous element.
But while this will help, it is not going to give you results you will find acceptable.
This and redundancy checks should be put on hold while you address your most major issue: bandwidth.


L. Spiro

Bandwidth = the transfer from the CPU to the GPU.
It means the total amount you send to the GPU is too large. This includes textures, index buffers, vertex buffers, etc.
That is why using compressed textures can help.

How many elements are in your vertex buffer?
How many bits in your index buffer?


L. Spiro