Okay, so if DirectX games render using the directX engine on thefly, then the DirectX engine is getting a mesh from the game. And if the game is sending the DirectX engine a mesh, there's a pipe with that data flowing from one app to the other sorta-app. So if there's a pipe with a mesh being pumped through it, there's a protocol to send that mesh. And a pipe can be 'wiretapped' for lack of a better term. It can be snooped. And if a pipe can be snooped, and a protocol listened for, because DirectX knows how to look for a mesh, then, in theory... it should be possible to snoop on the pipe to directX and grab meshes out of games. Right?

Yep! Bill

So how do you do it?

Um, remember that DirectX works in kernelspace / hardware. It's not a seperate program, per se. Therefore, in order to snoop the data flow, you will have to work at the kernel level. If I need to point out the problems that entails, understand that this will be a long project. Also, I'm not convinced that the DirectX implementation uses a pipe - I think it's more stongly coupled than that, involving many calls. However, there is an alternative to kenerl snooping - run the program in an emulator, and modify the emulator to dump all the DirectX calls (and arguments) to a log. This is, I think the optimal solution, becuase there exists a DirectX capable emulator. Wine, which can be run on a unix environment such as Linux, is such an emulator. It won't be too much work to stick loggin gcode around each DirectX (Strictly, you only need the Direct3D calls, the other parts of DirectX are not relevent here). Other options are to run a debugger, or other stepwise execution environment on the program, and extract the models before they are executed. Either way, it's not straightforward. If you are just looking for models for a specific game engine, you may find that they are held in seperate files, and that might be the best way to approach the problem, leaving DirectX out of it.

IIRC Direct3D (and DX) are in fact implemented as DLL imporable libraries which provide both hardware calls and software emulation of the functionality. However all calls that an executable makes to any external interface, whether its a dynamically loaded library or the kernel API (including DirectX), use the same mechanism. This is ulitimately dependent on a set of address arrays (the Import Address Table?) mapped into the calling program's virtal address space, which contain the (real) addresses of the kernel/DLL functions. These can be (and routinely are by system programmers) changed to redirect calls to spy programs. The Microsoft SDK provides information and software to do this as do other third parties. Another solution, would, of course, be to set up a "Trojan Horse" version of the DirectX libraries with the data call subsequently being passed on the real image of the modules after the "dirty work" has been carried out. The big question is, either of these ways the best to grab DirectX data. It certainly is an involved solution, as Syntax says, and it may well have to perform decisions on data processing and storage at frame rate. Plus many games are pushed so far to the limit in performance terms that keeping them stable while you peek at their data transfers could well be a major challenge in itself. The much more obvious (for me) solution would be to search the game data files for chunks that seem to resemble .x formatted meshes. There's a good long, tradition of game modding and file deformatting has always been a suucessful (if involved) and preferred technique. Naturally, of course, copyrights apply automatically, unless there is an explicit (ab)usage statement, but there's nothing to disallow this kind of thing for personal use. Bill

Wine, which can be run on a unix environment such as Linux, is such an emulator Strictly speaking, WinE isn't an emu. WinE only runs on Linux machines running on Intel architecture, and doesn't emulate the machine -- it runs them native on the processor. I'm not sure how it deals with DirectX though. Personal use is what I was thinking. Actually, I was thinking that if such a program could be built, it would sell in the marketplace quite well as plenty of people would find it entertaining to set up scenes with their favourite millenium folk battling critters from Final Fantasy as fan art and so on, even if the meshes are lower poly.