How would one go about reading / writing the contents of a surface without locking it? It must be possible, as the Blt function doesn''t seem to lock any surfaces, but I''m afraid that''s probably much dirtier work than I''m capable of at the moment... Do any of you know of a way around locking?

You could probably lock it once, and keep using that pointer over and over - but it''s not a safe thing to do.

If you lock buffer, be sure to use a triple buffer, and you should be fine. The performance issue comes into play if the buffer is locked, and Dx decides it''s time to flip.

Magmai Kai Holmlor
- Not For Rent

Your best bet for handling this without fear of losing the VRAM pointer is to do one lock/unlock each frame, if needed. For example, you might structure your code something like this:

do background blits
lock surface
draw alpha blended sprites/lines/circles/etc...
unlock surface
do foreground blits

Of course, this is a general case. There may be instances where
you need to lock two or three times based on z-order. The idea is to keep locks down to a minimum.

YMMV.

I was under the impression that using Blt implicitly locks the surface. Unless I''m mistaken, you can''t access memory in a surface unless you lock it, and Blt does this automatically. Locking a surface has little overhead; it''s the grabbing of pixels from video memory that slows your system to a crawl, like Ruval said. I''ve tested this myself with a homemade alpha blending algorithm.

Keep your stuff in system memory if you want to manipulate your image data directly. Slower performance is the price you pay for having that much control over your graphics. And if you have a chance to use Visual Basic, check out the function GetLockedArray, which gives you read-write memory access as though it''s an array of raw pixel data.

Oky.... guess i''ve to poke my nose into this.

I''ve found a way to skip that pesky lock/unlock.

In windowed mode.... itz as simple as anything cuz all u have to do is lock the backbuffer once while initializing DirectX and keep the pointer in some global varaible which may read like (g_pBackBufferPointer).

In fullscreen mode... things are a lil tricky. In FullScreen the surfaces are flipped, the address pointer of the backbuffer and frontbuffer are swapped rather than blitting ( Which is done by DirectX itself). So what i do is, I lock both frontbuffer and backbuffer once while DirectX loads and keep the pointer as global variables. Then whenever the surfaces are flipped , I swap the global variables as well. for example:

VOID * g_pBackBufferPointer;
VOID * g_pFrontBufferPointer;

HRESULT Present()
{

HRESULT hr;
hr = g_pDDFrontBuffer->Flip(NULL,DDFLIP_WAIT);
if(FAILED(hr)) return hr;
VOID *pTempPointer;
pTempPointer = g_pBackBufferPointer;
g_pBackBufferPointer = g_pFrontBufferPointer;
g_pFrontBufferPointer = pTempPointer;

}

This makes your g_pBackBufferPointer always pointing towards the CURRENT BACKBUFFER !!! Hence you dont have to lock your
surfaces everytime you want to write someting on it . Simple huh ..
And tell you what.... it really works .