It's more the case that if you have depth and stencil, and if you're clearing depth, then you should clear stencil at the same time. This is because we typically see depth and stencil interleaved in a D24S8 format, so they're not separate buffers: they're a single buffer that contains the data for both, and clearing both at the same time allows the hardware to do a fast clear (which may be as fast as just awapping out a pointer or setting a flag).

Yea, that's probably it. And it makes perfect sense. I somehow confused it in my memory.

for(texture in textures)

for(sprite in sprites)

if(sprite.texture == texture)

list.append(sprite)

if(list.size > 0)

list.draw()

thats the basics. implementation is up to you

void *pVertexBuffer=NULL;
LPDIRECT3DVERTEXBUFFER9 pVertexObject=NULL;
LPDIRECT3DINDEXBUFFER9 pIndexBuffer=NULL; // the pointer to the index buffer

struct D3DVERTEX{float x,y,z,rhw;DWORD color;float u;float v;};

D3DVERTEX vertices[8]={ 0,256,0,1.0f,0xffffff,0.0,1.0,
0,0,0,1.0f,0xffffff,0.0,0.0,
256,256,0,1.0f,0xffffff,1.0,1.0,
256,0,0,1.0f,0xffffff,1.0,0.0,

512,256,0,1.0f,0xffffff,0.0,1.0,
512,0,0,1.0f,0xffffff,0.0,0.0,
768,256,0,1.0f,0xffffff,1.0,1.0,
768,0,0,1.0f,0xffffff,1.0,0.0};

// 2nd param was D3DUSAGE_WRITEONLY
//8 = 2x quads
if(FAILED(mRenderer->getDevice()->CreateVertexBuffer(8*sizeof(D3DVERTEX),NULL,D3DFVF_XYZRHW|D3DFVF_DIFFUSE|D3DFVF_TEX1,D3DPOOL_MANAGED,&pVertexObject,NULL)))
return(0);

if(FAILED(pVertexObject->Lock(0,8*sizeof(D3DVERTEX),&pVertexBuffer,0)))
return(0);

memcpy(pVertexBuffer,vertices,8*sizeof(D3DVERTEX));
pVertexObject->Unlock();

mRenderer->getDevice()->SetStreamSource(0,pVertexObject,0,sizeof(D3DVERTEX));
mRenderer->getDevice()->SetFVF(D3DFVF_XYZRHW|D3DFVF_DIFFUSE|D3DFVF_TEX1);

mRenderer->getDevice()->SetTexture(0,mRenderer->pTexture);

// Do the indicies
void *pVoid;

short indices[]={ 0,1,2,
2,1,3,

4,5,6,
6,5,7,};

mRenderer->getDevice()->CreateIndexBuffer(12*sizeof(short),0,D3DFMT_INDEX16,D3DPOOL_MANAGED,&pIndexBuffer,NULL);
pIndexBuffer->Lock(0,0,(void**)&pVoid,0);
memcpy(pVoid, indices, sizeof(indices));
pIndexBuffer->Unlock();

mRenderer->getDevice()->SetIndices(pIndexBuffer);

mRenderer->getDevice()->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, 8, 0, 4);

mRenderer->getDevice()->DrawIndexedPrimitive(D3DPT_TRIANGLELIST,0,0,sprites*4,0,sprites*2);

When you are writing the sprites to the vertex buffer, are you locking & unlocking it once, or for every sprite seperately? I found that locking multiple times can have a very bad impact on performance. Also:

if(FAILED(pVertexObject->Lock(0,8*sizeof(D3DVERTEX),&pVertexBuffer,0)))

You shouldn't lock with "0" as flag (last parameter). Since it does not appear you are double-buffering like suggested from L.Spiro, you should lock once with "D3DLOCK_DISCARD | D3DLOCK_NOOVERWRITE" after rendering, and then with "D3DLOCK_NOOVERWRITE", optimally only once for all sprites.