I'm trying to design a cross-platform 2D API for gaming, and the main problem I'm running into is the locking and unlocking of surfaces on different systems. Certain platforms require these calls to be made at different places. For instance, if all my graphical routines (blitting, etc) were done in software, I'd only have to lock all the surfaces I had to use once before the rendering loop and unlock all of them at the end of it. And if everything were done in hardware, there'd obviously be no need for lock and unlock. However, if there's a mixture of routines in hardware and software, it'd be easiest to just manually perform a lock/unlock during each method that worked in software, and make locking/unlocking transparent to the application using my API. The reason this would have to be done is because different platforms require locking and unlocking in different circumstances (for instance, one platform or driver might require that video bitmaps be locked before blitting, but not system bitmaps), so the platform independent code that uses my API can't optimize the order in which surfaces are locked and unlocked, because it might be beneficial on some systems but detrimental (or even fatal) on others. But this would mean, for instance, that if a software alpha-blend blit had to be performed on a sprite which was rendered to 100 different places on the screen during a rendering loop, lock/unlock would have to be called 100 times on the sprite surface, and 100 times on the backbuffer surface (that's a total of 400 function/method calls).
Would this be totally unfeasible and slow down my code a lot? It's not like I'm calling lock/unlock between each pixel write or anything, but I imagine that this could still slow it down some. I know that lock/unlock on DirectX will actually temporarly halt the connection between GDI and USER in Windows, but I have no idea how long it takes Windows to make that connection halt and start up again; if it's simply the toggling of a flag, then I suppose it shouldn't be too bad. All the rendering will occur in one place in the application that uses my API, so the total length of time that GDI and USER are disconnected won't be long; what I'm concerned about is how long it takes to execute Lock() and Unlock().
If anyone has had any experience with these methods, advice would be very appreciated. I've heard that there's a DirectX utility that comes with the SDK which times the methods, but I haven't been able to find it, and some actual opinions from people who have experimented with Lock/Unlock in their own works would be extremely helpful. Thanks!