.*.sw?
.scons*
-*.obj
*.dll
-*.lib
*.exp
+*.ilk
+*.lib
+*.obj
+*.pdb
+*.pyc
+*.pyo
*.xml
+d3d8.cpp
env.Append(CPPDEFINES = ['_DEBUG'])
else:
env.Append(CPPDEFINES = ['NDEBUG'])
-#env['PDB'] = '${TARGET.base}.pdb'
+env['PDB'] = '${TARGET.base}.pdb'
cflags = [
'/W3', # warning level
Export('env')
+
+
+env.Command(
+ target = 'd3d8.cpp',
+ source = ['d3d8.py', 'd3d8types.py', 'd3d8caps.py', 'windows.py', 'base.py'],
+ action = 'python $SOURCE > $TARGET',
+)
+
+
+env.SharedLibrary(
+ target = 'd3d8.dll',
+ source = [
+ 'd3d8.def',
+ 'd3d8.cpp',
+ ]
+)
+
SConscript([
- 'common/SConscript',
- 'd3d8/SConscript',
'd3d9/SConscript',
])
--- /dev/null
+"""C basic types"""
+
+class Type:
+
+ def __init__(self, name):
+ self.name = name
+
+ def __str__(self):
+ return self.name
+
+ def isoutput(self):
+ return False
+
+ def wrap_instance(self, instance):
+ pass
+
+
+class Void(Type):
+
+ def __init__(self):
+ Type.__init__(self, "void")
+
+Void = Void()
+
+
+class Intrinsic(Type):
+
+ def __init__(self, name, format):
+ Type.__init__(self, name)
+ self.format = format
+
+
+class Const(Type):
+
+ def __init__(self, type):
+ Type.__init__(self, 'C' + type.name)
+ self.type = type
+
+ def __str__(self):
+ return "const " + str(self.type)
+
+
+class Pointer(Type):
+
+ def __init__(self, type):
+ Type.__init__(self, 'P' + type.name)
+ self.type = type
+
+ def __str__(self):
+ return str(self.type) + " *"
+
+ def wrap_instance(self, instance):
+ self.type.wrap_instance("*" + instance)
+
+
+class Output(Type):
+
+ def __init__(self, type):
+ Type.__init__(self, type.name)
+ self.type = type
+
+ def __str__(self):
+ return str(self.type)
+
+ def isoutput(self):
+ return True
+
+ def wrap_instance(self, instance):
+ self.type.wrap_instance(instance)
+
+
+class Enum(Type):
+
+ def __init__(self, name, values):
+ Type.__init__(self, name)
+ self.values = values
+
+
+class Flags(Type):
+
+ def __init__(self, type, values):
+ Type.__init__(self, type.name)
+ self.values = values
+
+
+class Struct(Type):
+
+ def __init__(self, name, members):
+ Type.__init__(self, name)
+ self.members = members
+
+
+class Alias(Type):
+
+ def __init__(self, name, type):
+ Type.__init__(self, name)
+ self.type = type
+
+
+class Function:
+
+ def __init__(self, type, name, args, call = '__stdcall'):
+ self.type = type
+ self.name = name
+ self.args = args
+ self.call = call
+
+ def prototype(self, name=None):
+ if name is not None:
+ name = name.strip()
+ else:
+ name = self.name
+ s = name
+ if self.call:
+ s = self.call + ' ' + s
+ if name.startswith('*'):
+ s = '(' + s + ')'
+ s = str(self.type) + ' ' + s
+ s += "("
+ if self.args:
+ s += ", ".join(["%s %s" % (type, name) for type, name in self.args])
+ else:
+ s += "void"
+ s += ")"
+ return s
+
+
+class Interface(Type):
+
+ def __init__(self, name, base=None):
+ Type.__init__(self, name)
+ self.base = base
+ self.methods = []
+
+ def itermethods(self):
+ if self.base is not None:
+ for method in self.base.itermethods():
+ yield method
+ for method in self.methods:
+ yield method
+ raise StopIteration
+
+ def wrap_name(self):
+ return "Wrap" + self.name
+
+ def wrap_pre_decl(self):
+ print "class %s;" % self.wrap_name()
+
+ def wrap_decl(self):
+ print "class %s : public %s " % (self.wrap_name(), self.name)
+ print "{"
+ print "public:"
+ print " %s(%s * pInstance);" % (self.wrap_name(), self.name)
+ print " virtual ~%s();" % self.wrap_name()
+ print
+ for method in self.itermethods():
+ print " " + method.prototype() + ";"
+ print
+ print "private:"
+ print " Log *m_pLog;"
+ print " %s * m_pInstance;" % (self.name,)
+ print "};"
+ print
+
+ def wrap_impl(self):
+ print '%s::%s(%s * pInstance) {' % (self.wrap_name(), self.wrap_name(), self.name)
+ print ' m_pLog = new Log("d3d8trace");'
+ print ' m_pInstance = pInstance;'
+ print '}'
+ print
+ print '%s::~%s() {' % (self.wrap_name(), self.wrap_name())
+ print " delete m_pLog;"
+ print '}'
+ print
+ for method in self.itermethods():
+ print method.prototype(self.wrap_name() + '::' + method.name) + ' {'
+ if method.type is Void:
+ result = ''
+ else:
+ print ' %s result;' % method.type
+ result = 'result = '
+ print ' m_pLog->BeginCall("%s");' % (self.name + '::' + method.name)
+ print ' %sm_pInstance->%s(%s);' % (result, method.name, ', '.join([str(name) for type, name in method.args]))
+ for type, name in method.args:
+ if type.isoutput():
+ type.wrap_instance(name)
+ if method.type is not Void:
+ method.type.wrap_instance('result')
+ print ' m_pLog->EndCall();'
+ if method.name == 'QueryInterface':
+ print ' if(*ppvObj == m_pInstance)'
+ print ' *ppvObj = this;'
+ if method.name == 'Release':
+ assert method.type is not Void
+ print ' if(!result)'
+ print ' delete this;'
+ if method.type is not Void:
+ print ' return result;'
+ print '}'
+ print
+ print
+
+
+class Method(Function):
+
+ def __init__(self, type, name, args):
+ Function.__init__(self, type, name, args)
+
+
+towrap = []
+
+class WrapPointer(Pointer):
+
+ def __init__(self, type):
+ Pointer.__init__(self, type)
+ if type not in towrap:
+ towrap.append(type)
+
+ def wrap_instance(self, instance):
+ print " if(%s)" % instance
+ print " %s = new %s(%s);" % (instance, self.type.wrap_name(), instance)
+
+String = Intrinsic("char *", "%s")
+Int = Intrinsic("int", "%i")
+Long = Intrinsic("long", "%li")
+Float = Intrinsic("float", "%f")
+
+
+def wrap():
+ for type in towrap:
+ type.wrap_pre_decl()
+ print
+ for type in towrap:
+ type.wrap_decl()
+ print
+ for type in towrap:
+ type.wrap_impl()
+ print
+++ /dev/null
-Import('env')
-
+++ /dev/null
-
-#ifndef LOG_HPP_
-#define LOG_HPP_
-
-#include <windows.h>
-
-#include <d3d8.h>
-
-#include <stdio.h>
-
-
-class Log
-{
-public:
- Log(const char *filename) {
- file = fopen(filename, "wt");
- write("<?xml version='1.0' encoding='UTF-8'?>\n");
- write("<?xml-stylesheet type='text/xsl' href='d3dtrace.xsl'?>\n");
- write("<trace>\n");
- }
-
- ~Log() {
- write("</trace>\n");
- fclose(file);
- }
-
- void write(const char *s) {
- fputs(s, file);
- }
-
- void writef(const char *f, ...) {
- va_list ap;
- va_start(ap, f);
- vfprintf(file, f, ap);
- va_end(ap);
- }
-
- void eol(void) {
- fputs("\n", file);
- }
-
- void tag(const char *name) {
- write("<");
- write(name);
- write(">");
- }
-
- void tag_begin(const char *name) {
- write("<");
- write(name);
- }
-
- void tag_attr(const char *name, const char *value) {
- write(" ");
- write(name);
- write("=\"");
- write(value);
- write("\"");
- }
-
- void tag_end(void) {
- write(">");
- }
-
- void tag_close(const char *name) {
- write("</");
- write(name);
- write(">");
- }
-
- void call_begin(const char *function) {
- write("\t");
- tag_begin("call");
- tag_attr("name", function);
- tag_end();
- eol();
- }
-
- void call_end() {
- write("\t");
- tag_close("call");
- eol();
- }
-
- void param_begin(const char *type, const char *name) {
- write("\t\t");
- tag_begin("param");
- tag_attr("type", type);
- tag_attr("name", name);
- tag_end();
- }
-
- void param_end(void) {
- tag_close("param");
- eol();
- }
-
- void param_uint(const char *name, UINT value) {
- param_begin("UINT", name);
- writef("%u", value);
- param_end();
- }
-
- void param_dword(const char *name, DWORD value) {
- param_begin("DWORD", name);
- writef("0x%08lx", value);
- param_end();
- }
-
-protected:
- FILE *file;
-};
-
-
-#endif /* LOG_HPP_ */
--- /dev/null
+LIBRARY "d3d8"
+
+EXPORTS
+ Direct3DCreate8 @1
--- /dev/null
+"""d3d8.h"""
+
+from windows import *
+from d3d8types import *
+from d3d8caps import *
+
+IDirect3D8 = Interface("IDirect3D8", IUnknown)
+IDirect3DDevice8 = Interface("IDirect3DDevice8", IUnknown)
+IDirect3DSwapChain8 = Interface("IDirect3DSwapChain8", IUnknown)
+IDirect3DResource8 = Interface("IDirect3DResource8", IUnknown)
+IDirect3DBaseTexture8 = Interface("IDirect3DBaseTexture8", IDirect3DResource8)
+IDirect3DTexture8 = Interface("IDirect3DTexture8", IDirect3DBaseTexture8)
+IDirect3DVolumeTexture8 = Interface("IDirect3DVolumeTexture8", IDirect3DBaseTexture8)
+IDirect3DCubeTexture8 = Interface("IDirect3DCubeTexture8", IDirect3DBaseTexture8)
+IDirect3DVertexBuffer8 = Interface("IDirect3DVertexBuffer8", IDirect3DResource8)
+IDirect3DIndexBuffer8 = Interface("IDirect3DIndexBuffer8", IDirect3DResource8)
+IDirect3DSurface8 = Interface("IDirect3DSurface8", IUnknown)
+IDirect3DVolume8 = Interface("IDirect3DVolume8", IUnknown)
+
+PDIRECT3D8 = LPDIRECT3D8 = Pointer(IDirect3D8)
+PDIRECT3DDEVICE8 = LPDIRECT3DDEVICE8 = Pointer(IDirect3DDevice8)
+PDIRECT3DSWAPCHAIN8 = LPDIRECT3DSWAPCHAIN8 = Pointer(IDirect3DSwapChain8)
+PDIRECT3DRESOURCE8 = LPDIRECT3DRESOURCE8 = Pointer(IDirect3DResource8)
+PDIRECT3DBASETEXTURE8 = LPDIRECT3DBASETEXTURE8 = Pointer(IDirect3DBaseTexture8)
+PDIRECT3DTEXTURE8 = LPDIRECT3DTEXTURE8 = Pointer(IDirect3DTexture8)
+PDIRECT3DVOLUMETEXTURE8 = LPDIRECT3DVOLUMETEXTURE8 = Pointer(IDirect3DVolumeTexture8)
+PDIRECT3DCUBETEXTURE8 = LPDIRECT3DCUBETEXTURE8 = Pointer(IDirect3DCubeTexture8)
+PDIRECT3DVERTEXBUFFER8 = LPDIRECT3DVERTEXBUFFER8 = Pointer(IDirect3DVertexBuffer8)
+PDIRECT3DINDEXBUFFER8 = LPDIRECT3DINDEXBUFFER8 = Pointer(IDirect3DIndexBuffer8)
+PDIRECT3DSURFACE8 = LPDIRECT3DSURFACE8 = Pointer(IDirect3DSurface8)
+PDIRECT3DVOLUME8 = LPDIRECT3DVOLUME8 = Pointer(IDirect3DVolume8)
+
+IDirect3D8.methods += [
+ Method(HRESULT, "RegisterSoftwareDevice", [(Pointer(Void), "pInitializeFunction")]),
+ Method(UINT, "GetAdapterCount", []),
+ Method(HRESULT, "GetAdapterIdentifier", [(UINT, "Adapter"), (DWORD, "Flags"), (Pointer(D3DADAPTER_IDENTIFIER8), "pIdentifier")]),
+ Method(UINT, "GetAdapterModeCount", [(UINT, "Adapter")]),
+ Method(HRESULT, "EnumAdapterModes", [(UINT, "Adapter"), (UINT, "Mode"), (Pointer(D3DDISPLAYMODE), "pMode")]),
+ Method(HRESULT, "GetAdapterDisplayMode", [(UINT, "Adapter"), (Pointer(D3DDISPLAYMODE), "pMode")]),
+ Method(HRESULT, "CheckDeviceType", [(UINT, "Adapter"), (D3DDEVTYPE, "CheckType"), (D3DFORMAT, "DisplayFormat"), (D3DFORMAT, "BackBufferFormat"), (BOOL, "Windowed")]),
+ Method(HRESULT, "CheckDeviceFormat", [(UINT, "Adapter"), (D3DDEVTYPE, "DeviceType"), (D3DFORMAT, "AdapterFormat"), (DWORD, "Usage"), (D3DRESOURCETYPE, "RType"), (D3DFORMAT, "CheckFormat")]),
+ Method(HRESULT, "CheckDeviceMultiSampleType", [(UINT, "Adapter"), (D3DDEVTYPE, "DeviceType"), (D3DFORMAT, "SurfaceFormat"), (BOOL, "Windowed"), (D3DMULTISAMPLE_TYPE, "MultiSampleType")]),
+ Method(HRESULT, "CheckDepthStencilMatch", [(UINT, "Adapter"), (D3DDEVTYPE, "DeviceType"), (D3DFORMAT, "AdapterFormat"), (D3DFORMAT, "RenderTargetFormat"), (D3DFORMAT, "DepthStencilFormat")]),
+ Method(HRESULT, "GetDeviceCaps", [(UINT, "Adapter"), (D3DDEVTYPE, "DeviceType"), (Pointer(D3DCAPS8), "pCaps")]),
+ Method(HMONITOR, "GetAdapterMonitor", [(UINT, "Adapter")]),
+ Method(HRESULT, "CreateDevice", [(UINT, "Adapter"), (D3DDEVTYPE, "DeviceType"), (HWND, "hFocusWindow"), (DWORD, "BehaviorFlags"), (Pointer(D3DPRESENT_PARAMETERS), "pPresentationParameters"), (Output(Pointer(WrapPointer(IDirect3DDevice8))), "ppReturnedDeviceInterface")]),
+]
+
+IDirect3DDevice8.methods += [
+ Method(HRESULT, "TestCooperativeLevel", []),
+ Method(UINT, "GetAvailableTextureMem", []),
+ Method(HRESULT, "ResourceManagerDiscardBytes", [(DWORD, "Bytes")]),
+ Method(HRESULT, "GetDirect3D", [(Pointer(Pointer(IDirect3D8)), "ppD3D8")]),
+ Method(HRESULT, "GetDeviceCaps", [(Pointer(D3DCAPS8), "pCaps")]),
+ Method(HRESULT, "GetDisplayMode", [(Pointer(D3DDISPLAYMODE), "pMode")]),
+ Method(HRESULT, "GetCreationParameters", [(Pointer(D3DDEVICE_CREATION_PARAMETERS), "pParameters")]),
+ Method(HRESULT, "SetCursorProperties", [(UINT, "XHotSpot"), (UINT, "YHotSpot"), (Pointer(IDirect3DSurface8), "pCursorBitmap")]),
+ Method(Void, "SetCursorPosition", [(Int, "X"), (Int, "Y"), (DWORD, "Flags")]),
+ Method(BOOL, "ShowCursor", [(BOOL, "bShow")]),
+ Method(HRESULT, "CreateAdditionalSwapChain", [(Pointer(D3DPRESENT_PARAMETERS), "pPresentationParameters"), (Pointer(Pointer(IDirect3DSwapChain8)), "pSwapChain")]),
+ Method(HRESULT, "Reset", [(Pointer(D3DPRESENT_PARAMETERS), "pPresentationParameters")]),
+ Method(HRESULT, "Present", [(Pointer(Const(RECT)), "pSourceRect"), (Pointer(Const(RECT)), "pDestRect"), (HWND, "hDestWindowOverride"), (Const(Pointer(RGNDATA)), "pDirtyRegion")]),
+ Method(HRESULT, "GetBackBuffer", [(UINT, "BackBuffer"), (D3DBACKBUFFER_TYPE, "Type"), (Pointer(Pointer(IDirect3DSurface8)), "ppBackBuffer")]),
+ Method(HRESULT, "GetRasterStatus", [(Pointer(D3DRASTER_STATUS), "pRasterStatus")]),
+ Method(Void, "SetGammaRamp", [(DWORD, "Flags"), (Pointer(Const(D3DGAMMARAMP)), "pRamp")]),
+ Method(Void, "GetGammaRamp", [(Pointer(D3DGAMMARAMP), "pRamp")]),
+ Method(HRESULT, "CreateTexture", [(UINT, "Width"), (UINT, "Height"), (UINT, "Levels"), (DWORD, "Usage"), (D3DFORMAT, "Format"), (D3DPOOL, "Pool"), (Pointer(WrapPointer(IDirect3DTexture8)), "ppTexture")]),
+ Method(HRESULT, "CreateVolumeTexture", [(UINT, "Width"), (UINT, "Height"), (UINT, "Depth"), (UINT, "Levels"), (DWORD, "Usage"), (D3DFORMAT, "Format"), (D3DPOOL, "Pool"), (Pointer(WrapPointer(IDirect3DVolumeTexture8)), "ppVolumeTexture")]),
+ Method(HRESULT, "CreateCubeTexture", [(UINT, "EdgeLength"), (UINT, "Levels"), (DWORD, "Usage"), (D3DFORMAT, "Format"), (D3DPOOL, "Pool"), (Pointer(Pointer(IDirect3DCubeTexture8)), "ppCubeTexture")]),
+ Method(HRESULT, "CreateVertexBuffer", [(UINT, "Length"), (DWORD, "Usage"), (DWORD, "FVF"), (D3DPOOL, "Pool"), (Pointer(WrapPointer(IDirect3DVertexBuffer8)), "ppVertexBuffer")]),
+ Method(HRESULT, "CreateIndexBuffer", [(UINT, "Length"), (DWORD, "Usage"), (D3DFORMAT, "Format"), (D3DPOOL, "Pool"), (Pointer(WrapPointer(IDirect3DIndexBuffer8)), "ppIndexBuffer")]),
+ Method(HRESULT, "CreateRenderTarget", [(UINT, "Width"), (UINT, "Height"), (D3DFORMAT, "Format"), (D3DMULTISAMPLE_TYPE, "MultiSample"), (BOOL, "Lockable"), (Pointer(WrapPointer(IDirect3DSurface8)), "ppSurface")]),
+ Method(HRESULT, "CreateDepthStencilSurface", [(UINT, "Width"), (UINT, "Height"), (D3DFORMAT, "Format"), (D3DMULTISAMPLE_TYPE, "MultiSample"), (Pointer(WrapPointer(IDirect3DSurface8)), "ppSurface")]),
+ Method(HRESULT, "CreateImageSurface", [(UINT, "Width"), (UINT, "Height"), (D3DFORMAT, "Format"), (Pointer(WrapPointer(IDirect3DSurface8)), "ppSurface")]),
+ Method(HRESULT, "CopyRects", [(Pointer(IDirect3DSurface8), "pSourceSurface"), (Pointer(Const(RECT)), "pSourceRectsArray"), (UINT, "cRects"), (Pointer(IDirect3DSurface8), "pDestinationSurface"), (Pointer(Const(POINT)), "pDestPointsArray")]),
+ Method(HRESULT, "UpdateTexture", [(Pointer(IDirect3DBaseTexture8), "pSourceTexture"), (Pointer(IDirect3DBaseTexture8), "pDestinationTexture")]),
+ Method(HRESULT, "GetFrontBuffer", [(Pointer(IDirect3DSurface8), "pDestSurface")]),
+ Method(HRESULT, "SetRenderTarget", [(Pointer(IDirect3DSurface8), "pRenderTarget"), (Pointer(IDirect3DSurface8), "pNewZStencil")]),
+ Method(HRESULT, "GetRenderTarget", [(Pointer(Pointer(IDirect3DSurface8)), "ppRenderTarget")]),
+ Method(HRESULT, "GetDepthStencilSurface", [(Pointer(Pointer(IDirect3DSurface8)), "ppZStencilSurface")]),
+ Method(HRESULT, "BeginScene", []),
+ Method(HRESULT, "EndScene", []),
+ Method(HRESULT, "Clear", [(DWORD, "Count"), (Pointer(Const(D3DRECT)), "pRects"), (DWORD, "Flags"), (D3DCOLOR, "Color"), (Float, "Z"), (DWORD, "Stencil")]),
+ Method(HRESULT, "SetTransform", [(D3DTRANSFORMSTATETYPE, "State"), (Pointer(Const(D3DMATRIX)), "pMatrix")]),
+ Method(HRESULT, "GetTransform", [(D3DTRANSFORMSTATETYPE, "State"), (Pointer(D3DMATRIX), "pMatrix")]),
+ Method(HRESULT, "MultiplyTransform", [(D3DTRANSFORMSTATETYPE, "State"), (Pointer(Const(D3DMATRIX)), "pMatrix")]),
+ Method(HRESULT, "SetViewport", [(Pointer(Const(D3DVIEWPORT8)), "pViewport")]),
+ Method(HRESULT, "GetViewport", [(Pointer(D3DVIEWPORT8), "pViewport")]),
+ Method(HRESULT, "SetMaterial", [(Pointer(Const(D3DMATERIAL8)), "pMaterial")]),
+ Method(HRESULT, "GetMaterial", [(Pointer(D3DMATERIAL8), "pMaterial")]),
+ Method(HRESULT, "SetLight", [(DWORD, "Index"), (Pointer(Const(D3DLIGHT8)), "pLight")]),
+ Method(HRESULT, "GetLight", [(DWORD, "Index"), (Pointer(D3DLIGHT8), "pLight")]),
+ Method(HRESULT, "LightEnable", [(DWORD, "Index"), (BOOL, "Enable")]),
+ Method(HRESULT, "GetLightEnable", [(DWORD, "Index"), (Pointer(BOOL), "pEnable")]),
+ Method(HRESULT, "SetClipPlane", [(DWORD, "Index"), (Pointer(Const(Float)), "pPlane")]),
+ Method(HRESULT, "GetClipPlane", [(DWORD, "Index"), (Pointer(Float), "pPlane")]),
+ Method(HRESULT, "SetRenderState", [(D3DRENDERSTATETYPE, "State"), (DWORD, "Value")]),
+ Method(HRESULT, "GetRenderState", [(D3DRENDERSTATETYPE, "State"), (Pointer(DWORD), "pValue")]),
+ Method(HRESULT, "BeginStateBlock", []),
+ Method(HRESULT, "EndStateBlock", [(Pointer(DWORD), "pToken")]),
+ Method(HRESULT, "ApplyStateBlock", [(DWORD, "Token")]),
+ Method(HRESULT, "CaptureStateBlock", [(DWORD, "Token")]),
+ Method(HRESULT, "DeleteStateBlock", [(DWORD, "Token")]),
+ Method(HRESULT, "CreateStateBlock", [(D3DSTATEBLOCKTYPE, "Type"), (Pointer(DWORD), "pToken")]),
+ Method(HRESULT, "SetClipStatus", [(Pointer(Const(D3DCLIPSTATUS8)), "pClipStatus")]),
+ Method(HRESULT, "GetClipStatus", [(Pointer(D3DCLIPSTATUS8), "pClipStatus")]),
+ Method(HRESULT, "GetTexture", [(DWORD, "Stage"), (Pointer(Pointer(IDirect3DBaseTexture8)), "ppTexture")]),
+ Method(HRESULT, "SetTexture", [(DWORD, "Stage"), (Pointer(IDirect3DBaseTexture8), "pTexture")]),
+ Method(HRESULT, "GetTextureStageState", [(DWORD, "Stage"), (D3DTEXTURESTAGESTATETYPE, "Type"), (Pointer(DWORD), "pValue")]),
+ Method(HRESULT, "SetTextureStageState", [(DWORD, "Stage"), (D3DTEXTURESTAGESTATETYPE, "Type"), (DWORD, "Value")]),
+ Method(HRESULT, "ValidateDevice", [(Pointer(DWORD), "pNumPasses")]),
+ Method(HRESULT, "GetInfo", [(DWORD, "DevInfoID"), (Pointer(Void), "pDevInfoStruct"), (DWORD, "DevInfoStructSize")]),
+ Method(HRESULT, "SetPaletteEntries", [(UINT, "PaletteNumber"), (Pointer(Const(PALETTEENTRY)), "pEntries")]),
+ Method(HRESULT, "GetPaletteEntries", [(UINT, "PaletteNumber"), (Pointer(PALETTEENTRY), "pEntries")]),
+ Method(HRESULT, "SetCurrentTexturePalette", [(UINT, "PaletteNumber")]),
+ Method(HRESULT, "GetCurrentTexturePalette", [(Pointer(UINT), "PaletteNumber")]),
+ Method(HRESULT, "DrawPrimitive", [(D3DPRIMITIVETYPE, "PrimitiveType"), (UINT, "StartVertex"), (UINT, "PrimitiveCount")]),
+ Method(HRESULT, "DrawIndexedPrimitive", [(D3DPRIMITIVETYPE, "PrimitiveType"), (UINT, "minIndex"), (UINT, "NumVertices"), (UINT, "startIndex"), (UINT, "primCount")]),
+ Method(HRESULT, "DrawPrimitiveUP", [(D3DPRIMITIVETYPE, "PrimitiveType"), (UINT, "PrimitiveCount"), (Const(Pointer(Void)), "pVertexStreamZeroData"), (UINT, "VertexStreamZeroStride")]),
+ Method(HRESULT, "DrawIndexedPrimitiveUP", [(D3DPRIMITIVETYPE, "PrimitiveType"), (UINT, "MinVertexIndex"), (UINT, "NumVertexIndices"), (UINT, "PrimitiveCount"), (Const(Pointer(Void)), "pIndexData"), (D3DFORMAT, "IndexDataFormat"), (Const(Pointer(Void)), "pVertexStreamZeroData"), (UINT, "VertexStreamZeroStride")]),
+ Method(HRESULT, "ProcessVertices", [(UINT, "SrcStartIndex"), (UINT, "DestIndex"), (UINT, "VertexCount"), (Pointer(IDirect3DVertexBuffer8), "pDestBuffer"), (DWORD, "Flags")]),
+ Method(HRESULT, "CreateVertexShader", [(Pointer(Const(DWORD)), "pDeclaration"), (Pointer(Const(DWORD)), "pFunction"), (Pointer(DWORD), "pHandle"), (DWORD, "Usage")]),
+ Method(HRESULT, "SetVertexShader", [(DWORD, "Handle")]),
+ Method(HRESULT, "GetVertexShader", [(Pointer(DWORD), "pHandle")]),
+ Method(HRESULT, "DeleteVertexShader", [(DWORD, "Handle")]),
+ Method(HRESULT, "SetVertexShaderConstant", [(DWORD, "Register"), (Const(Pointer(Void)), "pConstantData"), (DWORD, "ConstantCount")]),
+ Method(HRESULT, "GetVertexShaderConstant", [(DWORD, "Register"), (Pointer(Void), "pConstantData"), (DWORD, "ConstantCount")]),
+ Method(HRESULT, "GetVertexShaderDeclaration", [(DWORD, "Handle"), (Pointer(Void), "pData"), (Pointer(DWORD), "pSizeOfData")]),
+ Method(HRESULT, "GetVertexShaderFunction", [(DWORD, "Handle"), (Pointer(Void), "pData"), (Pointer(DWORD), "pSizeOfData")]),
+ Method(HRESULT, "SetStreamSource", [(UINT, "StreamNumber"), (Pointer(IDirect3DVertexBuffer8), "pStreamData"), (UINT, "Stride")]),
+ Method(HRESULT, "GetStreamSource", [(UINT, "StreamNumber"), (Pointer(Pointer(IDirect3DVertexBuffer8)), "ppStreamData"), (Pointer(UINT), "pStride")]),
+ Method(HRESULT, "SetIndices", [(Pointer(IDirect3DIndexBuffer8), "pIndexData"), (UINT, "BaseVertexIndex")]),
+ Method(HRESULT, "GetIndices", [(Pointer(Pointer(IDirect3DIndexBuffer8)), "ppIndexData"), (Pointer(UINT), "pBaseVertexIndex")]),
+ Method(HRESULT, "CreatePixelShader", [(Pointer(Const(DWORD)), "pFunction"), (Pointer(DWORD), "pHandle")]),
+ Method(HRESULT, "SetPixelShader", [(DWORD, "Handle")]),
+ Method(HRESULT, "GetPixelShader", [(Pointer(DWORD), "pHandle")]),
+ Method(HRESULT, "DeletePixelShader", [(DWORD, "Handle")]),
+ Method(HRESULT, "SetPixelShaderConstant", [(DWORD, "Register"), (Const(Pointer(Void)), "pConstantData"), (DWORD, "ConstantCount")]),
+ Method(HRESULT, "GetPixelShaderConstant", [(DWORD, "Register"), (Pointer(Void), "pConstantData"), (DWORD, "ConstantCount")]),
+ Method(HRESULT, "GetPixelShaderFunction", [(DWORD, "Handle"), (Pointer(Void), "pData"), (Pointer(DWORD), "pSizeOfData")]),
+ Method(HRESULT, "DrawRectPatch", [(UINT, "Handle"), (Pointer(Const(Float)), "pNumSegs"), (Pointer(Const(D3DRECTPATCH_INFO)), "pRectPatchInfo")]),
+ Method(HRESULT, "DrawTriPatch", [(UINT, "Handle"), (Pointer(Const(Float)), "pNumSegs"), (Pointer(Const(D3DTRIPATCH_INFO)), "pTriPatchInfo")]),
+ Method(HRESULT, "DeletePatch", [(UINT, "Handle")]),
+]
+
+IDirect3DSwapChain8.methods += [
+ Method(HRESULT, "Present", [(Pointer(Const(RECT)), "pSourceRect"), (Pointer(Const(RECT)), "pDestRect"), (HWND, "hDestWindowOverride"), (Const(Pointer(RGNDATA)), "pDirtyRegion")]),
+ Method(HRESULT, "GetBackBuffer", [(UINT, "BackBuffer"), (D3DBACKBUFFER_TYPE, "Type"), (Pointer(Pointer(IDirect3DSurface8)), "ppBackBuffer")]),
+]
+
+IDirect3DResource8.methods += [
+ Method(HRESULT, "GetDevice", [(Pointer(Pointer(IDirect3DDevice8)), "ppDevice")]),
+ Method(HRESULT, "SetPrivateData", [(REFGUID, "refguid"), (Const(Pointer(Void)), "pData"), (DWORD, "SizeOfData"), (DWORD, "Flags")]),
+ Method(HRESULT, "GetPrivateData", [(REFGUID, "refguid"), (Pointer(Void), "pData"), (Pointer(DWORD), "pSizeOfData")]),
+ Method(HRESULT, "FreePrivateData", [(REFGUID, "refguid")]),
+ Method(DWORD, "SetPriority", [(DWORD, "PriorityNew")]),
+ Method(DWORD, "GetPriority", []),
+ Method(Void, "PreLoad", []),
+ Method(D3DRESOURCETYPE, "GetType", []),
+]
+
+IDirect3DBaseTexture8.methods += [
+ Method(DWORD, "SetLOD", [(DWORD, "LODNew")]),
+ Method(DWORD, "GetLOD", []),
+ Method(DWORD, "GetLevelCount", []),
+]
+
+IDirect3DTexture8.methods += [
+ Method(HRESULT, "GetLevelDesc", [(UINT, "Level"), (Pointer(D3DSURFACE_DESC), "pDesc")]),
+ Method(HRESULT, "GetSurfaceLevel", [(UINT, "Level"), (Pointer(Pointer(IDirect3DSurface8)), "ppSurfaceLevel")]),
+ Method(HRESULT, "LockRect", [(UINT, "Level"), (Pointer(D3DLOCKED_RECT), "pLockedRect"), (Pointer(Const(RECT)), "pRect"), (DWORD, "Flags")]),
+ Method(HRESULT, "UnlockRect", [(UINT, "Level")]),
+ Method(HRESULT, "AddDirtyRect", [(Pointer(Const(RECT)), "pDirtyRect")]),
+]
+
+IDirect3DVolumeTexture8.methods += [
+ Method(HRESULT, "GetLevelDesc", [(UINT, "Level"), (Pointer(D3DVOLUME_DESC), "pDesc")]),
+ Method(HRESULT, "GetVolumeLevel", [(UINT, "Level"), (Pointer(Pointer(IDirect3DVolume8)), "ppVolumeLevel")]),
+ Method(HRESULT, "LockBox", [(UINT, "Level"), (Pointer(D3DLOCKED_BOX), "pLockedVolume"), (Pointer(Const(D3DBOX)), "pBox"), (DWORD, "Flags")]),
+ Method(HRESULT, "UnlockBox", [(UINT, "Level")]),
+ Method(HRESULT, "AddDirtyBox", [(Pointer(Const(D3DBOX)), "pDirtyBox")]),
+]
+
+IDirect3DCubeTexture8.methods += [
+ Method(HRESULT, "GetLevelDesc", [(UINT, "Level"), (Pointer(D3DSURFACE_DESC), "pDesc")]),
+ Method(HRESULT, "GetCubeMapSurface", [(D3DCUBEMAP_FACES, "FaceType"), (UINT, "Level"), (Pointer(Pointer(IDirect3DSurface8)), "ppCubeMapSurface")]),
+ Method(HRESULT, "LockRect", [(D3DCUBEMAP_FACES, "FaceType"), (UINT, "Level"), (Pointer(D3DLOCKED_RECT), "pLockedRect"), (Pointer(Const(RECT)), "pRect"), (DWORD, "Flags")]),
+ Method(HRESULT, "UnlockRect", [(D3DCUBEMAP_FACES, "FaceType"), (UINT, "Level")]),
+ Method(HRESULT, "AddDirtyRect", [(D3DCUBEMAP_FACES, "FaceType"), (Pointer(Const(RECT)), "pDirtyRect")]),
+]
+
+IDirect3DVertexBuffer8.methods += [
+ Method(HRESULT, "Lock", [(UINT, "OffsetToLock"), (UINT, "SizeToLock"), (Pointer(Pointer(BYTE)), "ppbData"), (DWORD, "Flags")]),
+ Method(HRESULT, "Unlock", []),
+ Method(HRESULT, "GetDesc", [(Pointer(D3DVERTEXBUFFER_DESC), "pDesc")]),
+]
+
+IDirect3DIndexBuffer8.methods += [
+ Method(HRESULT, "Lock", [(UINT, "OffsetToLock"), (UINT, "SizeToLock"), (Pointer(Pointer(BYTE)), "ppbData"), (DWORD, "Flags")]),
+ Method(HRESULT, "Unlock", []),
+ Method(HRESULT, "GetDesc", [(Pointer(D3DINDEXBUFFER_DESC), "pDesc")]),
+]
+
+IDirect3DSurface8.methods += [
+ Method(HRESULT, "GetDevice", [(Pointer(Pointer(IDirect3DDevice8)), "ppDevice")]),
+ Method(HRESULT, "SetPrivateData", [(REFGUID, "refguid"), (Const(Pointer(Void)), "pData"), (DWORD, "SizeOfData"), (DWORD, "Flags")]),
+ Method(HRESULT, "GetPrivateData", [(REFGUID, "refguid"), (Pointer(Void), "pData"), (Pointer(DWORD), "pSizeOfData")]),
+ Method(HRESULT, "FreePrivateData", [(REFGUID, "refguid")]),
+ Method(HRESULT, "GetContainer", [(REFIID, "riid"), (Pointer(Pointer(Void)), "ppContainer")]),
+ Method(HRESULT, "GetDesc", [(Pointer(D3DSURFACE_DESC), "pDesc")]),
+ Method(HRESULT, "LockRect", [(Pointer(D3DLOCKED_RECT), "pLockedRect"), (Pointer(Const(RECT)), "pRect"), (DWORD, "Flags")]),
+ Method(HRESULT, "UnlockRect", []),
+]
+
+IDirect3DVolume8.methods += [
+ Method(HRESULT, "GetDevice", [(Pointer(Pointer(IDirect3DDevice8)), "ppDevice")]),
+ Method(HRESULT, "SetPrivateData", [(REFGUID, "refguid"), (Const(Pointer(Void)), "pData"), (DWORD, "SizeOfData"), (DWORD, "Flags")]),
+ Method(HRESULT, "GetPrivateData", [(REFGUID, "refguid"), (Pointer(Void), "pData"), (Pointer(DWORD), "pSizeOfData")]),
+ Method(HRESULT, "FreePrivateData", [(REFGUID, "refguid")]),
+ Method(HRESULT, "GetContainer", [(REFIID, "riid"), (Pointer(Pointer(Void)), "ppContainer")]),
+ Method(HRESULT, "GetDesc", [(Pointer(D3DVOLUME_DESC), "pDesc")]),
+ Method(HRESULT, "LockBox", [(Pointer(D3DLOCKED_BOX), "pLockedVolume"), (Pointer(Const(D3DBOX)), "pBox"), (DWORD, "Flags")]),
+ Method(HRESULT, "UnlockBox", []),
+]
+
+d3d8 = Dll("d3d8")
+d3d8.functions += [
+ Function(WrapPointer(IDirect3D8), "Direct3DCreate8", [(UINT, "SDKVersion")]),
+]
+
+if __name__ == '__main__':
+ print '#include <windows.h>'
+ print '#include <tchar.h>'
+ print '#include <d3d8.h>'
+ print
+ print '#include "log.hpp"'
+ print
+ wrap()
+
+++ /dev/null
-Import('env')
-
-env.SharedLibrary(
- target = 'd3d8.dll',
- source = [
- 'd3d8.def',
- 'dllmain.cpp',
- 'idirect3d8.cpp',
- 'idirect3d_device8.cpp',
- ]
-)
+++ /dev/null
-LIBRARY "d3d8"
-
-EXPORTS
- Direct3DCreate8 @1
+++ /dev/null
-// proxydll.cpp
-#include "stdafx.h"
-
-// global variables
-#pragma data_seg (".d3d8_shared")
-static HINSTANCE gl_hOriginalDll;
-static HINSTANCE gl_hThisInstance;
-#pragma data_seg ()
-
-static void InitInstance(HANDLE hModule) {
- OutputDebugString(_T("PROXYDLL: InitInstance called.\r\n"));
-
- // Initialisation
- gl_hOriginalDll = NULL;
- gl_hThisInstance = NULL;
-
- // Storing Instance handle into global var
- gl_hThisInstance = (HINSTANCE) hModule;
-}
-
-static void LoadOriginalDll(void) {
- TCHAR buffer[MAX_PATH];
-
- // Getting path to system dir and to d3d8.dll
- ::GetSystemDirectory(buffer, MAX_PATH);
-
- // Append dll name
- _tcscat(buffer, _T("\\d3d8.dll"));
-
- // try to load the system's d3d8.dll, if pointer empty
- if (!gl_hOriginalDll)
- gl_hOriginalDll = ::LoadLibrary(buffer);
-
- // Debug
- if (!gl_hOriginalDll) {
- OutputDebugString(_T("PROXYDLL: Original d3d8.dll not loaded ERROR ****\r\n"));
- ::ExitProcess(0); // exit the hard way
- }
-}
-
-static void ExitInstance() {
- OutputDebugString(_T("PROXYDLL: ExitInstance called.\r\n"));
-
- // Release the system's d3d8.dll
- if (gl_hOriginalDll) {
- ::FreeLibrary(gl_hOriginalDll);
- gl_hOriginalDll = NULL;
- }
-}
-
-BOOL APIENTRY DllMain( HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved)
-{
- // to avoid compiler lvl4 warnings
- LPVOID lpDummy = lpReserved;
- lpDummy = NULL;
-
- switch (ul_reason_for_call)
- {
- case DLL_PROCESS_ATTACH: InitInstance(hModule); break;
- case DLL_PROCESS_DETACH: ExitInstance(); break;
-
- case DLL_THREAD_ATTACH: break;
- case DLL_THREAD_DETACH: break;
- }
- return TRUE;
-}
-
-// Exported function (faking d3d8.dll's one-and-only export)
-IDirect3D8* WINAPI Direct3DCreate8(UINT SDKVersion)
-{
- if (!gl_hOriginalDll) LoadOriginalDll(); // looking for the "right d3d8.dll"
-
- // Hooking IDirect3D Object from Original Library
- typedef IDirect3D8 *(WINAPI* D3D8_Type)(UINT SDKVersion);
- D3D8_Type D3DCreate8_fn = (D3D8_Type) GetProcAddress( gl_hOriginalDll, "Direct3DCreate8");
-
- // Debug
- if (!D3DCreate8_fn)
- {
- OutputDebugString(_T("PROXYDLL: Pointer to original D3DCreate8 function not received ERROR ****\r\n"));
- ::ExitProcess(0); // exit the hard way
- }
-
- // Request pointer from Original Dll.
- IDirect3D8 *pIDirect3D8_orig = D3DCreate8_fn(SDKVersion);
-
- // Create my IDirect3D8 object and store pointer to original object there.
- // note: the object will delete itself once Ref count is zero (similar to COM objects)
- return new TraceDirect3D8(pIDirect3D8_orig);
-}
+++ /dev/null
-// TraceDirect3D8.cpp
-#include "stdafx.h"
-
-TraceDirect3D8::TraceDirect3D8(IDirect3D8 *pOriginal) {
- m_pIDirect3D8 = pOriginal; // store the pointer to original object
-}
-
-TraceDirect3D8::~TraceDirect3D8() {
-
-}
-
-HRESULT __stdcall TraceDirect3D8::QueryInterface(REFIID riid, void** ppvObj) {
- *ppvObj = NULL;
-
- // call this to increase AddRef at original object
- // and to check if such an interface is there
-
- HRESULT hRes = m_pIDirect3D8->QueryInterface(riid, ppvObj);
-
- if (hRes == NOERROR) // if OK, send our "fake" address
- {
- *ppvObj = this;
- }
-
- return hRes;
-}
-
-ULONG __stdcall TraceDirect3D8::AddRef() {
- return (m_pIDirect3D8->AddRef());
-}
-
-ULONG __stdcall TraceDirect3D8::Release() {
- // call original routine
- ULONG count = m_pIDirect3D8->Release();
-
- // in case no further Ref is there, the Original Object has deleted itself
- // so do we here
- if (count == 0) {
- delete (this);
- }
-
- return (count);
-}
-
-HRESULT __stdcall TraceDirect3D8::RegisterSoftwareDevice(void* pInitializeFunction) {
- return (m_pIDirect3D8->RegisterSoftwareDevice(pInitializeFunction));
-}
-
-UINT __stdcall TraceDirect3D8::GetAdapterCount() {
- return (m_pIDirect3D8->GetAdapterCount());
-}
-
-HRESULT __stdcall TraceDirect3D8::GetAdapterIdentifier(UINT Adapter, DWORD Flags, D3DADAPTER_IDENTIFIER8* pIdentifier) {
- return (m_pIDirect3D8->GetAdapterIdentifier(Adapter, Flags, pIdentifier));
-}
-
-UINT __stdcall TraceDirect3D8::GetAdapterModeCount(UINT Adapter) {
- return (m_pIDirect3D8->GetAdapterModeCount(Adapter));
-}
-
-HRESULT __stdcall TraceDirect3D8::EnumAdapterModes(UINT Adapter, UINT Mode, D3DDISPLAYMODE* pMode) {
- return (m_pIDirect3D8->EnumAdapterModes(Adapter, Mode, pMode));
-}
-
-HRESULT __stdcall TraceDirect3D8::GetAdapterDisplayMode(UINT Adapter, D3DDISPLAYMODE* pMode) {
- return (m_pIDirect3D8->GetAdapterDisplayMode(Adapter, pMode));
-}
-
-HRESULT __stdcall TraceDirect3D8::CheckDeviceType(UINT Adapter, D3DDEVTYPE CheckType, D3DFORMAT DisplayFormat, D3DFORMAT BackBufferFormat, BOOL Windowed) {
- return (m_pIDirect3D8->CheckDeviceType(Adapter, CheckType, DisplayFormat, BackBufferFormat, Windowed));
-}
-
-HRESULT __stdcall TraceDirect3D8::CheckDeviceFormat(UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT AdapterFormat, DWORD Usage, D3DRESOURCETYPE RType, D3DFORMAT CheckFormat) {
- return (m_pIDirect3D8->CheckDeviceFormat(Adapter, DeviceType, AdapterFormat, Usage, RType, CheckFormat));
-}
-
-HRESULT __stdcall TraceDirect3D8::CheckDeviceMultiSampleType(UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT SurfaceFormat, BOOL Windowed, D3DMULTISAMPLE_TYPE MultiSampleType) {
- return (m_pIDirect3D8->CheckDeviceMultiSampleType(Adapter, DeviceType, SurfaceFormat, Windowed, MultiSampleType));
-}
-
-HRESULT __stdcall TraceDirect3D8::CheckDepthStencilMatch(UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT AdapterFormat, D3DFORMAT RenderTargetFormat, D3DFORMAT DepthStencilFormat) {
- return (m_pIDirect3D8->CheckDepthStencilMatch(Adapter, DeviceType, AdapterFormat, RenderTargetFormat, DepthStencilFormat));
-}
-
-HRESULT __stdcall TraceDirect3D8::GetDeviceCaps(UINT Adapter, D3DDEVTYPE DeviceType, D3DCAPS8* pCaps) {
- return (m_pIDirect3D8->GetDeviceCaps(Adapter, DeviceType, pCaps));
-}
-
-HMONITOR __stdcall TraceDirect3D8::GetAdapterMonitor(UINT Adapter) {
- return (m_pIDirect3D8->GetAdapterMonitor(Adapter));
-}
-
-HRESULT __stdcall TraceDirect3D8::CreateDevice(UINT Adapter, D3DDEVTYPE DeviceType, HWND hFocusWindow, DWORD BehaviorFlags, D3DPRESENT_PARAMETERS* pPresentationParameters, IDirect3DDevice8** ppReturnedDeviceInterface) {
- // we intercept this call and provide our own "fake" Device Object
- HRESULT hres = m_pIDirect3D8->CreateDevice(Adapter, DeviceType, hFocusWindow, BehaviorFlags, pPresentationParameters, ppReturnedDeviceInterface);
-
- // Create our own Device object and strore it in global pointer
- // note: the object will delete itself once Ref count is zero (similar to COM objects)
- *ppReturnedDeviceInterface = new TraceDirect3DDevice8(*ppReturnedDeviceInterface);
-
- return (hres);
-}
+++ /dev/null
-// TraceDirect3D8.h
-#pragma once
-
-class TraceDirect3D8 : public IDirect3D8
-{
-public:
-
- TraceDirect3D8(IDirect3D8 *pOriginal);
- virtual ~TraceDirect3D8();
-
- // START: The original DX8.1a function definitions
- HRESULT __stdcall QueryInterface(REFIID riid, void** ppvObj);
- ULONG __stdcall AddRef(void);
- ULONG __stdcall Release(void);
- HRESULT __stdcall RegisterSoftwareDevice(void* pInitializeFunction);
- UINT __stdcall GetAdapterCount(void);
- HRESULT __stdcall GetAdapterIdentifier(UINT Adapter,DWORD Flags,D3DADAPTER_IDENTIFIER8* pIdentifier);
- UINT __stdcall GetAdapterModeCount(UINT Adapter);
- HRESULT __stdcall EnumAdapterModes(UINT Adapter,UINT Mode,D3DDISPLAYMODE* pMode);
- HRESULT __stdcall GetAdapterDisplayMode( UINT Adapter,D3DDISPLAYMODE* pMode);
- HRESULT __stdcall CheckDeviceType(UINT Adapter,D3DDEVTYPE CheckType,D3DFORMAT DisplayFormat,D3DFORMAT BackBufferFormat,BOOL Windowed);
- HRESULT __stdcall CheckDeviceFormat(UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT AdapterFormat,DWORD Usage,D3DRESOURCETYPE RType,D3DFORMAT CheckFormat);
- HRESULT __stdcall CheckDeviceMultiSampleType(UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT SurfaceFormat,BOOL Windowed,D3DMULTISAMPLE_TYPE MultiSampleType);
- HRESULT __stdcall CheckDepthStencilMatch(UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT AdapterFormat,D3DFORMAT RenderTargetFormat,D3DFORMAT DepthStencilFormat);
- HRESULT __stdcall GetDeviceCaps(UINT Adapter,D3DDEVTYPE DeviceType,D3DCAPS8* pCaps);
- HMONITOR __stdcall GetAdapterMonitor(UINT Adapter);
- HRESULT __stdcall CreateDevice(UINT Adapter,D3DDEVTYPE DeviceType,HWND hFocusWindow,DWORD BehaviorFlags,D3DPRESENT_PARAMETERS* pPresentationParameters,IDirect3DDevice8** ppReturnedDeviceInterface);
- // END: The original DX8,1a functions definitions
-
-private:
-
- IDirect3D8 * m_pIDirect3D8;
-};
-
+++ /dev/null
-// TraceDirect3DDevice8.cpp
-#include "stdafx.h"
-#include "log.hpp"
-
-TraceDirect3DDevice8::TraceDirect3DDevice8(IDirect3DDevice8* pOriginal) {
- m_pIDirect3DDevice8 = pOriginal; // store the pointer to original object
- log = new Log("d3d8trace.xml");
-}
-
-TraceDirect3DDevice8::~TraceDirect3DDevice8() {
- delete log;
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::QueryInterface(REFIID riid, void** ppvObj) {
- // check if original dll can provide an interface. then send *our* address
- *ppvObj = NULL;
-
- HRESULT hRes = m_pIDirect3DDevice8->QueryInterface(riid, ppvObj);
-
- if (hRes == NOERROR) {
- *ppvObj = this;
- }
-
- return hRes;
-}
-
-ULONG __stdcall TraceDirect3DDevice8::AddRef(void) {
- return (m_pIDirect3DDevice8->AddRef());
-}
-
-ULONG __stdcall TraceDirect3DDevice8::Release(void) {
- // ATTENTION: This is a booby-trap ! Watch out !
- // If we create our own sprites, surfaces, etc. (thus increasing the ref counter
- // by external action), we need to delete that objects before calling the original
- // Release function
-
- // release/delete own objects
- // ... here if any ...
-
- // Calling original function now
- ULONG count = m_pIDirect3DDevice8->Release();
-
- // now, the Original Object has deleted itself, so do we here
- delete (this); // destructor will be called automatically
-
- return (count);
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::TestCooperativeLevel(void) {
- return (m_pIDirect3DDevice8->TestCooperativeLevel());
-}
-
-UINT __stdcall TraceDirect3DDevice8::GetAvailableTextureMem(void) {
- return (m_pIDirect3DDevice8->GetAvailableTextureMem());
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::ResourceManagerDiscardBytes(DWORD Bytes) {
- return (m_pIDirect3DDevice8->ResourceManagerDiscardBytes(Bytes));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::GetDirect3D(IDirect3D8** ppD3D8) {
- return (m_pIDirect3DDevice8->GetDirect3D(ppD3D8));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::GetDeviceCaps(D3DCAPS8* pCaps) {
- return (m_pIDirect3DDevice8->GetDeviceCaps(pCaps));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::GetDisplayMode(D3DDISPLAYMODE* pMode) {
- return (m_pIDirect3DDevice8->GetDisplayMode(pMode));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::GetCreationParameters(D3DDEVICE_CREATION_PARAMETERS *pParameters) {
- return (m_pIDirect3DDevice8->GetCreationParameters(pParameters));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::SetCursorProperties(UINT XHotSpot, UINT YHotSpot, IDirect3DSurface8* pCursorBitmap) {
- return (m_pIDirect3DDevice8->SetCursorProperties(XHotSpot, YHotSpot, pCursorBitmap));
-}
-
-void __stdcall TraceDirect3DDevice8::SetCursorPosition(int XScreenSpace, int YScreenSpace, DWORD Flags) {
- m_pIDirect3DDevice8->SetCursorPosition(XScreenSpace, YScreenSpace, Flags);
-}
-
-BOOL __stdcall TraceDirect3DDevice8::ShowCursor(BOOL bShow) {
- return (m_pIDirect3DDevice8->ShowCursor(bShow));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::CreateAdditionalSwapChain(D3DPRESENT_PARAMETERS* pPresentationParameters, IDirect3DSwapChain8** pSwapChain) {
- return (m_pIDirect3DDevice8->CreateAdditionalSwapChain(pPresentationParameters, pSwapChain));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::Reset(D3DPRESENT_PARAMETERS* pPresentationParameters) {
- return (m_pIDirect3DDevice8->Reset(pPresentationParameters));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::Present(CONST RECT* pSourceRect,CONST RECT* pDestRect,HWND hDestWindowOverride,CONST RGNDATA* pDirtyRegion)
-{
- // we may want to draw own things here before flipping surfaces
- // ... draw own stuff ...
- this->ShowWeAreHere();
-
- // call original routine
- HRESULT hres = m_pIDirect3DDevice8->Present( pSourceRect, pDestRect, hDestWindowOverride, pDirtyRegion);
-
- return (hres);
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::GetBackBuffer(UINT BackBuffer, D3DBACKBUFFER_TYPE Type, IDirect3DSurface8** ppBackBuffer) {
- return (m_pIDirect3DDevice8->GetBackBuffer(BackBuffer, Type, ppBackBuffer));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::GetRasterStatus(D3DRASTER_STATUS* pRasterStatus) {
- return (m_pIDirect3DDevice8->GetRasterStatus(pRasterStatus));
-}
-
-void __stdcall TraceDirect3DDevice8::SetGammaRamp(DWORD Flags,CONST D3DGAMMARAMP* pRamp)
-{ m_pIDirect3DDevice8->SetGammaRamp( Flags, pRamp);}
-
-void __stdcall TraceDirect3DDevice8::GetGammaRamp(D3DGAMMARAMP* pRamp) {
- m_pIDirect3DDevice8->GetGammaRamp(pRamp);
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::CreateTexture(UINT Width, UINT Height, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, IDirect3DTexture8** ppTexture) {
- HRESULT hr;
- log->call_begin("IDirect3DDevice9::CreateTexture");
- log->param_uint("Width", Width);
- log->param_uint("Height", Height);
- log->param_uint("Levels", Levels);
- log->param_dword("Usage", Usage);
- log->param_dword("Format", Format);
- log->param_dword("Pool", Pool);
- hr = m_pIDirect3DDevice8->CreateTexture(Width, Height, Levels, Usage, Format, Pool, ppTexture);
- log->call_end();
- return hr;
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::CreateVolumeTexture(UINT Width, UINT Height, UINT Depth, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, IDirect3DVolumeTexture8** ppVolumeTexture) {
- return (m_pIDirect3DDevice8->CreateVolumeTexture(Width, Height, Depth, Levels, Usage, Format, Pool, ppVolumeTexture));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::CreateCubeTexture(UINT EdgeLength, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, IDirect3DCubeTexture8** ppCubeTexture) {
- return (m_pIDirect3DDevice8->CreateCubeTexture(EdgeLength, Levels, Usage, Format, Pool, ppCubeTexture));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::CreateVertexBuffer(UINT Length, DWORD Usage, DWORD FVF, D3DPOOL Pool, IDirect3DVertexBuffer8** ppVertexBuffer) {
- return (m_pIDirect3DDevice8->CreateVertexBuffer(Length, Usage, FVF, Pool, ppVertexBuffer));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::CreateIndexBuffer(UINT Length, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, IDirect3DIndexBuffer8** ppIndexBuffer) {
- return (m_pIDirect3DDevice8->CreateIndexBuffer(Length, Usage, Format, Pool, ppIndexBuffer));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::CreateRenderTarget(UINT Width, UINT Height, D3DFORMAT Format, D3DMULTISAMPLE_TYPE MultiSample, BOOL Lockable, IDirect3DSurface8** ppSurface) {
- return (m_pIDirect3DDevice8->CreateRenderTarget(Width, Height, Format, MultiSample, Lockable, ppSurface));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::CreateDepthStencilSurface(UINT Width, UINT Height, D3DFORMAT Format, D3DMULTISAMPLE_TYPE MultiSample, IDirect3DSurface8** ppSurface) {
- return (m_pIDirect3DDevice8->CreateDepthStencilSurface(Width, Height, Format, MultiSample, ppSurface));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::CreateImageSurface(UINT Width, UINT Height, D3DFORMAT Format, IDirect3DSurface8** ppSurface) {
- return (m_pIDirect3DDevice8->CreateImageSurface(Width, Height, Format, ppSurface));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::CopyRects( IDirect3DSurface8* pSourceSurface,CONST RECT* pSourceRectsArray,UINT cRects,IDirect3DSurface8* pDestinationSurface,CONST POINT* pDestPointsArray)
-{ return (m_pIDirect3DDevice8->CopyRects(pSourceSurface, pSourceRectsArray, cRects, pDestinationSurface, pDestPointsArray) );}
-
-HRESULT __stdcall TraceDirect3DDevice8::UpdateTexture(IDirect3DBaseTexture8* pSourceTexture, IDirect3DBaseTexture8* pDestinationTexture) {
- return (m_pIDirect3DDevice8->UpdateTexture(pSourceTexture, pDestinationTexture));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::GetFrontBuffer(IDirect3DSurface8* pDestSurface) {
- return (m_pIDirect3DDevice8->GetFrontBuffer(pDestSurface));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::SetRenderTarget(IDirect3DSurface8* pRenderTarget, IDirect3DSurface8* pNewZStencil) {
- return (m_pIDirect3DDevice8->SetRenderTarget(pRenderTarget, pNewZStencil));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::GetRenderTarget(IDirect3DSurface8** ppRenderTarget) {
- return (m_pIDirect3DDevice8->GetRenderTarget(ppRenderTarget));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::GetDepthStencilSurface(IDirect3DSurface8** ppZStencilSurface) {
- return (m_pIDirect3DDevice8->GetDepthStencilSurface(ppZStencilSurface));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::BeginScene(void) {
- return (m_pIDirect3DDevice8->BeginScene());
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::EndScene(void) {
- return (m_pIDirect3DDevice8->EndScene());
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::Clear( DWORD Count,CONST D3DRECT* pRects,DWORD Flags,D3DCOLOR Color,float Z,DWORD Stencil)
-{ return (m_pIDirect3DDevice8->Clear(Count, pRects, Flags, Color, Z, Stencil) );}
-
-HRESULT __stdcall TraceDirect3DDevice8::SetTransform( D3DTRANSFORMSTATETYPE State,CONST D3DMATRIX* pMatrix)
-{ return (m_pIDirect3DDevice8->SetTransform(State, pMatrix) );}
-
-HRESULT __stdcall TraceDirect3DDevice8::GetTransform(D3DTRANSFORMSTATETYPE State, D3DMATRIX* pMatrix) {
- return (m_pIDirect3DDevice8->GetTransform(State, pMatrix));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::MultiplyTransform( D3DTRANSFORMSTATETYPE State,CONST D3DMATRIX* pMatrix)
-{ return (m_pIDirect3DDevice8->MultiplyTransform( State,pMatrix) );}
-
-HRESULT __stdcall TraceDirect3DDevice8::SetViewport( CONST D3DVIEWPORT8* pViewport)
-{ return (m_pIDirect3DDevice8->SetViewport( pViewport) );}
-
-HRESULT __stdcall TraceDirect3DDevice8::GetViewport(D3DVIEWPORT8* pViewport) {
- return (m_pIDirect3DDevice8->GetViewport(pViewport));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::SetMaterial( CONST D3DMATERIAL8* pMaterial)
-{ return (m_pIDirect3DDevice8->SetMaterial( pMaterial) );}
-
-HRESULT __stdcall TraceDirect3DDevice8::GetMaterial(D3DMATERIAL8* pMaterial) {
- return (m_pIDirect3DDevice8->GetMaterial(pMaterial));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::SetLight( DWORD Index,CONST D3DLIGHT8* pLight)
-{ return (m_pIDirect3DDevice8->SetLight(Index, pLight) );}
-
-HRESULT __stdcall TraceDirect3DDevice8::GetLight(DWORD Index, D3DLIGHT8* pLight) {
- return (m_pIDirect3DDevice8->GetLight(Index, pLight));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::LightEnable(DWORD Index, BOOL Enable) {
- return (m_pIDirect3DDevice8->LightEnable(Index, Enable));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::GetLightEnable(DWORD Index, BOOL* pEnable) {
- return (m_pIDirect3DDevice8->GetLightEnable(Index, pEnable));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::SetClipPlane(DWORD Index, CONST float* pPlane) {
- return (m_pIDirect3DDevice8->SetClipPlane(Index, pPlane));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::GetClipPlane(DWORD Index, float* pPlane) {
- return (m_pIDirect3DDevice8->GetClipPlane(Index, pPlane));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::SetRenderState(D3DRENDERSTATETYPE State, DWORD Value) {
- return (m_pIDirect3DDevice8->SetRenderState(State, Value));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::GetRenderState(D3DRENDERSTATETYPE State, DWORD* pValue) {
- return (m_pIDirect3DDevice8->GetRenderState(State, pValue));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::BeginStateBlock(void) {
- return (m_pIDirect3DDevice8->BeginStateBlock());
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::EndStateBlock(DWORD* pToken) {
- return (m_pIDirect3DDevice8->EndStateBlock(pToken));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::ApplyStateBlock(DWORD Token) {
- return (m_pIDirect3DDevice8->ApplyStateBlock(Token));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::CaptureStateBlock(DWORD Token) {
- return (m_pIDirect3DDevice8->CaptureStateBlock(Token));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::DeleteStateBlock(DWORD Token) {
- return (m_pIDirect3DDevice8->DeleteStateBlock(Token));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::CreateStateBlock(D3DSTATEBLOCKTYPE Type, DWORD* pToken) {
- return (m_pIDirect3DDevice8->CreateStateBlock(Type, pToken));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::SetClipStatus( CONST D3DCLIPSTATUS8* pClipStatus)
-{ return (m_pIDirect3DDevice8->SetClipStatus( pClipStatus) );}
-
-HRESULT __stdcall TraceDirect3DDevice8::GetClipStatus(D3DCLIPSTATUS8* pClipStatus) {
- return (m_pIDirect3DDevice8->GetClipStatus(pClipStatus));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::GetTexture(DWORD Stage, IDirect3DBaseTexture8** ppTexture) {
- return (m_pIDirect3DDevice8->GetTexture(Stage, ppTexture));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::SetTexture(DWORD Stage, IDirect3DBaseTexture8* pTexture) {
- return (m_pIDirect3DDevice8->SetTexture(Stage, pTexture));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::GetTextureStageState(DWORD Stage, D3DTEXTURESTAGESTATETYPE Type, DWORD* pValue) {
- return (m_pIDirect3DDevice8->GetTextureStageState(Stage, Type, pValue));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::SetTextureStageState(DWORD Stage, D3DTEXTURESTAGESTATETYPE Type, DWORD Value) {
- return (m_pIDirect3DDevice8->SetTextureStageState(Stage, Type, Value));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::ValidateDevice(DWORD* pNumPasses) {
- return (m_pIDirect3DDevice8->ValidateDevice(pNumPasses));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::GetInfo(DWORD DevInfoID, void* pDevInfoStruct, DWORD DevInfoStructSize) {
- return (m_pIDirect3DDevice8->GetInfo(DevInfoID, pDevInfoStruct, DevInfoStructSize));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::SetPaletteEntries( UINT PaletteNumber,CONST PALETTEENTRY* pEntries)
-{ return (m_pIDirect3DDevice8->SetPaletteEntries(PaletteNumber, pEntries) );}
-
-HRESULT __stdcall TraceDirect3DDevice8::GetPaletteEntries(UINT PaletteNumber, PALETTEENTRY* pEntries) {
- return (m_pIDirect3DDevice8->GetPaletteEntries(PaletteNumber, pEntries));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::SetCurrentTexturePalette(UINT PaletteNumber) {
- return (m_pIDirect3DDevice8->SetCurrentTexturePalette(PaletteNumber));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::GetCurrentTexturePalette(UINT *PaletteNumber) {
- return (m_pIDirect3DDevice8->GetCurrentTexturePalette(PaletteNumber));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::DrawPrimitive(D3DPRIMITIVETYPE PrimitiveType, UINT StartVertex, UINT PrimitiveCount) {
- return (m_pIDirect3DDevice8->DrawPrimitive(PrimitiveType, StartVertex, PrimitiveCount));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::DrawIndexedPrimitive(D3DPRIMITIVETYPE Type, UINT minIndex, UINT NumVertices, UINT startIndex, UINT primCount) {
- return (m_pIDirect3DDevice8->DrawIndexedPrimitive(Type, minIndex, NumVertices, startIndex, primCount));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::DrawPrimitiveUP(D3DPRIMITIVETYPE PrimitiveType, UINT PrimitiveCount, CONST void* pVertexStreamZeroData, UINT VertexStreamZeroStride) {
- return (m_pIDirect3DDevice8->DrawPrimitiveUP(PrimitiveType, PrimitiveCount, pVertexStreamZeroData, VertexStreamZeroStride));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::DrawIndexedPrimitiveUP(D3DPRIMITIVETYPE PrimitiveType, UINT MinVertexIndex, UINT NumVertexIndices, UINT PrimitiveCount, CONST void* pIndexData, D3DFORMAT IndexDataFormat, CONST void* pVertexStreamZeroData, UINT VertexStreamZeroStride) {
- return (m_pIDirect3DDevice8->DrawIndexedPrimitiveUP(PrimitiveType, MinVertexIndex, NumVertexIndices, PrimitiveCount, pIndexData, IndexDataFormat, pVertexStreamZeroData, VertexStreamZeroStride));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::ProcessVertices(UINT SrcStartIndex, UINT DestIndex, UINT VertexCount, IDirect3DVertexBuffer8* pDestBuffer, DWORD Flags) {
- return (m_pIDirect3DDevice8->ProcessVertices(SrcStartIndex, DestIndex, VertexCount, pDestBuffer, Flags));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::CreateVertexShader( CONST DWORD* pDeclaration,CONST DWORD* pFunction,DWORD* pHandle,DWORD Usage)
-{ return (m_pIDirect3DDevice8->CreateVertexShader( pDeclaration, pFunction, pHandle, Usage));}
-
-HRESULT __stdcall TraceDirect3DDevice8::SetVertexShader(DWORD Handle) {
- return (m_pIDirect3DDevice8->SetVertexShader(Handle));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::GetVertexShader(DWORD* pHandle) {
- return (m_pIDirect3DDevice8->GetVertexShader(pHandle));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::DeleteVertexShader(DWORD Handle) {
- return (m_pIDirect3DDevice8->DeleteVertexShader(Handle));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::SetVertexShaderConstant(DWORD Register, CONST void* pConstantData, DWORD ConstantCount) {
- return (m_pIDirect3DDevice8->SetVertexShaderConstant(Register, pConstantData, ConstantCount));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::GetVertexShaderConstant(DWORD Register, void* pConstantData, DWORD ConstantCount) {
- return (m_pIDirect3DDevice8->GetVertexShaderConstant(Register, pConstantData, ConstantCount));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::GetVertexShaderDeclaration(DWORD Handle, void* pData, DWORD* pSizeOfData) {
- return (m_pIDirect3DDevice8->GetVertexShaderDeclaration(Handle, pData, pSizeOfData));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::GetVertexShaderFunction(DWORD Handle, void* pData, DWORD* pSizeOfData) {
- return (m_pIDirect3DDevice8->GetVertexShaderFunction(Handle, pData, pSizeOfData));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::SetStreamSource(UINT StreamNumber, IDirect3DVertexBuffer8* pStreamData, UINT Stride) {
- return (m_pIDirect3DDevice8->SetStreamSource(StreamNumber, pStreamData, Stride));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::GetStreamSource(UINT StreamNumber, IDirect3DVertexBuffer8** ppStreamData, UINT* pStride) {
- return (m_pIDirect3DDevice8->GetStreamSource(StreamNumber, ppStreamData, pStride));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::SetIndices(IDirect3DIndexBuffer8* pIndexData, UINT BaseVertexIndex) {
- return (m_pIDirect3DDevice8->SetIndices(pIndexData, BaseVertexIndex));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::GetIndices(IDirect3DIndexBuffer8** ppIndexData, UINT* pBaseVertexIndex) {
- return (m_pIDirect3DDevice8->GetIndices(ppIndexData, pBaseVertexIndex));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::CreatePixelShader( CONST DWORD* pFunction,DWORD* pHandle)
-{ return (m_pIDirect3DDevice8->CreatePixelShader( pFunction, pHandle));}
-
-HRESULT __stdcall TraceDirect3DDevice8::SetPixelShader(DWORD Handle) {
- return (m_pIDirect3DDevice8->SetPixelShader(Handle));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::GetPixelShader(DWORD* pHandle) {
- return (m_pIDirect3DDevice8->GetPixelShader(pHandle));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::DeletePixelShader(DWORD Handle) {
- return (m_pIDirect3DDevice8->DeletePixelShader(Handle));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::SetPixelShaderConstant(DWORD Register, CONST void* pConstantData, DWORD ConstantCount) {
- return (m_pIDirect3DDevice8->SetPixelShaderConstant(Register, pConstantData, ConstantCount));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::GetPixelShaderConstant(DWORD Register, void* pConstantData, DWORD ConstantCount) {
- return (m_pIDirect3DDevice8->GetPixelShaderConstant(Register, pConstantData, ConstantCount));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::GetPixelShaderFunction(DWORD Handle, void* pData, DWORD* pSizeOfData) {
- return (m_pIDirect3DDevice8->GetPixelShaderFunction(Handle, pData, pSizeOfData));
-}
-
-HRESULT __stdcall TraceDirect3DDevice8::DrawRectPatch( UINT Handle, CONST float* pNumSegs,CONST D3DRECTPATCH_INFO* pRectPatchInfo)
-{ return (m_pIDirect3DDevice8->DrawRectPatch(Handle, pNumSegs, pRectPatchInfo) );}
-
-HRESULT __stdcall TraceDirect3DDevice8::DrawTriPatch( UINT Handle, CONST float* pNumSegs,CONST D3DTRIPATCH_INFO* pTriPatchInfo)
-{ return (m_pIDirect3DDevice8->DrawTriPatch(Handle, pNumSegs, pTriPatchInfo) );}
-
-HRESULT __stdcall TraceDirect3DDevice8::DeletePatch(UINT Handle) {
- return (m_pIDirect3DDevice8->DeletePatch(Handle));
-}
-
-// This is our test function
-void TraceDirect3DDevice8::ShowWeAreHere(void) {
- D3DRECT rec = { 1, 1, 50, 50 };
- m_pIDirect3DDevice8->Clear(1, &rec, D3DCLEAR_TARGET, D3DCOLOR_ARGB(255,255,255,0), 0, 0);
-}
+++ /dev/null
-// TraceDirect3DDevice8.h
-#pragma once
-
-class Log;
-
-class TraceDirect3DDevice8: public IDirect3DDevice8 {
-public:
-
- TraceDirect3DDevice8(IDirect3DDevice8* pOriginal);
- virtual ~TraceDirect3DDevice8();
-
- // START: The original DX8.1a function definitions
- HRESULT __stdcall QueryInterface(REFIID riid, void** ppvObj);
- ULONG __stdcall AddRef(void);
- ULONG __stdcall Release(void);
- HRESULT __stdcall TestCooperativeLevel(void);
- UINT __stdcall GetAvailableTextureMem(void);
- HRESULT __stdcall ResourceManagerDiscardBytes(DWORD Bytes);
- HRESULT __stdcall GetDirect3D(IDirect3D8** ppD3D8);
- HRESULT __stdcall GetDeviceCaps(D3DCAPS8* pCaps);
- HRESULT __stdcall GetDisplayMode(D3DDISPLAYMODE* pMode);
- HRESULT __stdcall GetCreationParameters(D3DDEVICE_CREATION_PARAMETERS *pParameters);
- HRESULT __stdcall SetCursorProperties(UINT XHotSpot, UINT YHotSpot, IDirect3DSurface8* pCursorBitmap);
- void __stdcall SetCursorPosition(int XScreenSpace, int YScreenSpace, DWORD Flags);
- BOOL __stdcall ShowCursor(BOOL bShow);
- HRESULT __stdcall CreateAdditionalSwapChain(D3DPRESENT_PARAMETERS* pPresentationParameters, IDirect3DSwapChain8** pSwapChain);
- HRESULT __stdcall Reset(D3DPRESENT_PARAMETERS* pPresentationParameters);
- HRESULT __stdcall Present(CONST RECT* pSourceRect,CONST RECT* pDestRect,HWND hDestWindowOverride,CONST RGNDATA* pDirtyRegion);
- HRESULT __stdcall GetBackBuffer(UINT BackBuffer,D3DBACKBUFFER_TYPE Type,IDirect3DSurface8** ppBackBuffer);
- HRESULT __stdcall GetRasterStatus(D3DRASTER_STATUS* pRasterStatus);
- void __stdcall SetGammaRamp(DWORD Flags,CONST D3DGAMMARAMP* pRamp);
- void __stdcall GetGammaRamp(D3DGAMMARAMP* pRamp);
- HRESULT __stdcall CreateTexture(UINT Width,UINT Height,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DTexture8** ppTexture);
- HRESULT __stdcall CreateVolumeTexture(UINT Width,UINT Height,UINT Depth,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DVolumeTexture8** ppVolumeTexture);
- HRESULT __stdcall CreateCubeTexture(UINT EdgeLength,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DCubeTexture8** ppCubeTexture);
- HRESULT __stdcall CreateVertexBuffer(UINT Length,DWORD Usage,DWORD FVF,D3DPOOL Pool,IDirect3DVertexBuffer8** ppVertexBuffer);
- HRESULT __stdcall CreateIndexBuffer(UINT Length,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DIndexBuffer8** ppIndexBuffer);
- HRESULT __stdcall CreateRenderTarget(UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,BOOL Lockable,IDirect3DSurface8** ppSurface);
- HRESULT __stdcall CreateDepthStencilSurface(UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,IDirect3DSurface8** ppSurface);
- HRESULT __stdcall CreateImageSurface(UINT Width,UINT Height,D3DFORMAT Format,IDirect3DSurface8** ppSurface);
- HRESULT __stdcall CopyRects(IDirect3DSurface8* pSourceSurface,CONST RECT* pSourceRectsArray,UINT cRects,IDirect3DSurface8* pDestinationSurface,CONST POINT* pDestPointsArray);
- HRESULT __stdcall UpdateTexture(IDirect3DBaseTexture8* pSourceTexture,IDirect3DBaseTexture8* pDestinationTexture);
- HRESULT __stdcall GetFrontBuffer(IDirect3DSurface8* pDestSurface);
- HRESULT __stdcall SetRenderTarget(IDirect3DSurface8* pRenderTarget,IDirect3DSurface8* pNewZStencil);
- HRESULT __stdcall GetRenderTarget(IDirect3DSurface8** ppRenderTarget);
- HRESULT __stdcall GetDepthStencilSurface(IDirect3DSurface8** ppZStencilSurface);
- HRESULT __stdcall BeginScene(THIS);
- HRESULT __stdcall EndScene(THIS);
- HRESULT __stdcall Clear(DWORD Count,CONST D3DRECT* pRects,DWORD Flags,D3DCOLOR Color,float Z,DWORD Stencil);
- HRESULT __stdcall SetTransform(D3DTRANSFORMSTATETYPE State,CONST D3DMATRIX* pMatrix);
- HRESULT __stdcall GetTransform(D3DTRANSFORMSTATETYPE State,D3DMATRIX* pMatrix);
- HRESULT __stdcall MultiplyTransform(D3DTRANSFORMSTATETYPE State,CONST D3DMATRIX* pMatrix);
- HRESULT __stdcall SetViewport(CONST D3DVIEWPORT8* pViewport);
- HRESULT __stdcall GetViewport(D3DVIEWPORT8* pViewport);
- HRESULT __stdcall SetMaterial(CONST D3DMATERIAL8* pMaterial);
- HRESULT __stdcall GetMaterial(D3DMATERIAL8* pMaterial);
- HRESULT __stdcall SetLight(DWORD Index,CONST D3DLIGHT8* pLight);
- HRESULT __stdcall GetLight(DWORD Index,D3DLIGHT8* pLight);
- HRESULT __stdcall LightEnable(DWORD Index,BOOL Enable);
- HRESULT __stdcall GetLightEnable(DWORD Index,BOOL* pEnable);
- HRESULT __stdcall SetClipPlane(DWORD Index,CONST float* pPlane);
- HRESULT __stdcall GetClipPlane(DWORD Index,float* pPlane);
- HRESULT __stdcall SetRenderState(D3DRENDERSTATETYPE State,DWORD Value);
- HRESULT __stdcall GetRenderState(D3DRENDERSTATETYPE State,DWORD* pValue);
- HRESULT __stdcall BeginStateBlock(THIS);
- HRESULT __stdcall EndStateBlock(DWORD* pToken);
- HRESULT __stdcall ApplyStateBlock(DWORD Token);
- HRESULT __stdcall CaptureStateBlock(DWORD Token);
- HRESULT __stdcall DeleteStateBlock(DWORD Token);
- HRESULT __stdcall CreateStateBlock(D3DSTATEBLOCKTYPE Type,DWORD* pToken);
- HRESULT __stdcall SetClipStatus(CONST D3DCLIPSTATUS8* pClipStatus);
- HRESULT __stdcall GetClipStatus(D3DCLIPSTATUS8* pClipStatus);
- HRESULT __stdcall GetTexture(DWORD Stage,IDirect3DBaseTexture8** ppTexture);
- HRESULT __stdcall SetTexture(DWORD Stage,IDirect3DBaseTexture8* pTexture);
- HRESULT __stdcall GetTextureStageState(DWORD Stage,D3DTEXTURESTAGESTATETYPE Type,DWORD* pValue);
- HRESULT __stdcall SetTextureStageState(DWORD Stage,D3DTEXTURESTAGESTATETYPE Type,DWORD Value);
- HRESULT __stdcall ValidateDevice(DWORD* pNumPasses);
- HRESULT __stdcall GetInfo(DWORD DevInfoID,void* pDevInfoStruct,DWORD DevInfoStructSize);
- HRESULT __stdcall SetPaletteEntries(UINT PaletteNumber,CONST PALETTEENTRY* pEntries);
- HRESULT __stdcall GetPaletteEntries(UINT PaletteNumber,PALETTEENTRY* pEntries);
- HRESULT __stdcall SetCurrentTexturePalette(UINT PaletteNumber);
- HRESULT __stdcall GetCurrentTexturePalette(UINT *PaletteNumber);
- HRESULT __stdcall DrawPrimitive(D3DPRIMITIVETYPE PrimitiveType,UINT StartVertex,UINT PrimitiveCount);
- HRESULT __stdcall DrawIndexedPrimitive(D3DPRIMITIVETYPE Type,UINT minIndex,UINT NumVertices,UINT startIndex,UINT primCount);
- HRESULT __stdcall DrawPrimitiveUP(D3DPRIMITIVETYPE PrimitiveType,UINT PrimitiveCount,CONST void* pVertexStreamZeroData,UINT VertexStreamZeroStride);
- HRESULT __stdcall DrawIndexedPrimitiveUP(D3DPRIMITIVETYPE PrimitiveType,UINT MinVertexIndex,UINT NumVertexIndices,UINT PrimitiveCount,CONST void* pIndexData,D3DFORMAT IndexDataFormat,CONST void* pVertexStreamZeroData,UINT VertexStreamZeroStride);
- HRESULT __stdcall ProcessVertices(UINT SrcStartIndex,UINT DestIndex,UINT VertexCount,IDirect3DVertexBuffer8* pDestBuffer,DWORD Flags);
- HRESULT __stdcall CreateVertexShader(CONST DWORD* pDeclaration,CONST DWORD* pFunction,DWORD* pHandle,DWORD Usage);
- HRESULT __stdcall SetVertexShader(DWORD Handle);
- HRESULT __stdcall GetVertexShader(DWORD* pHandle);
- HRESULT __stdcall DeleteVertexShader(DWORD Handle);
- HRESULT __stdcall SetVertexShaderConstant(DWORD Register,CONST void* pConstantData,DWORD ConstantCount);
- HRESULT __stdcall GetVertexShaderConstant(DWORD Register,void* pConstantData,DWORD ConstantCount);
- HRESULT __stdcall GetVertexShaderDeclaration(DWORD Handle,void* pData,DWORD* pSizeOfData);
- HRESULT __stdcall GetVertexShaderFunction(DWORD Handle,void* pData,DWORD* pSizeOfData);
- HRESULT __stdcall SetStreamSource(UINT StreamNumber,IDirect3DVertexBuffer8* pStreamData,UINT Stride);
- HRESULT __stdcall GetStreamSource(UINT StreamNumber,IDirect3DVertexBuffer8** ppStreamData,UINT* pStride);
- HRESULT __stdcall SetIndices(IDirect3DIndexBuffer8* pIndexData,UINT BaseVertexIndex);
- HRESULT __stdcall GetIndices(IDirect3DIndexBuffer8** ppIndexData,UINT* pBaseVertexIndex);
- HRESULT __stdcall CreatePixelShader(CONST DWORD* pFunction,DWORD* pHandle);
- HRESULT __stdcall SetPixelShader(DWORD Handle);
- HRESULT __stdcall GetPixelShader(DWORD* pHandle);
- HRESULT __stdcall DeletePixelShader(DWORD Handle);
- HRESULT __stdcall SetPixelShaderConstant(DWORD Register,CONST void* pConstantData,DWORD ConstantCount);
- HRESULT __stdcall GetPixelShaderConstant(DWORD Register,void* pConstantData,DWORD ConstantCount);
- HRESULT __stdcall GetPixelShaderFunction(DWORD Handle,void* pData,DWORD* pSizeOfData);
- HRESULT __stdcall DrawRectPatch(UINT Handle,CONST float* pNumSegs,CONST D3DRECTPATCH_INFO* pRectPatchInfo);
- HRESULT __stdcall DrawTriPatch(UINT Handle,CONST float* pNumSegs,CONST D3DTRIPATCH_INFO* pTriPatchInfo);
- HRESULT __stdcall DeletePatch(UINT Handle);
- // END: The original DX8.1a function definitions
-
-private:
-
- IDirect3DDevice8 *m_pIDirect3DDevice8;
- Log *log;
-
- // This is our test function
- void ShowWeAreHere(void);
-
-};
-
+++ /dev/null
-// stdafx.h
-#pragma once
-
-
-#include <windows.h>
-#include <tchar.h>
-
-#include <d3d8.h>
-
-#include "idirect3d8.hpp"
-#include "idirect3d_device8.hpp"
--- /dev/null
+"""d3d8caps.h"""
+
+from windows import *
+from d3d8types import *
+
+D3DCAPS = Flags(DWORD, (
+ "D3DCAPS_READ_SCANLINE",
+))
+
+D3DCAPS2 = Flags(DWORD, (
+ "D3DCAPS2_NO2DDURING3DSCENE",
+ "D3DCAPS2_FULLSCREENGAMMA",
+ "D3DCAPS2_CANRENDERWINDOWED",
+ "D3DCAPS2_CANCALIBRATEGAMMA",
+ "D3DCAPS2_RESERVED",
+ "D3DCAPS2_CANMANAGERESOURCE",
+ "D3DCAPS2_DYNAMICTEXTURES",
+))
+
+D3DCAPS3 = Flags(DWORD, (
+ "D3DCAPS3_RESERVED",
+
+ "D3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARD",
+))
+
+D3DPRESENT_INTERVAL = Flags(DWORD, (
+ "D3DPRESENT_INTERVAL_DEFAULT",
+ "D3DPRESENT_INTERVAL_ONE",
+ "D3DPRESENT_INTERVAL_TWO",
+ "D3DPRESENT_INTERVAL_THREE",
+ "D3DPRESENT_INTERVAL_FOUR",
+ "D3DPRESENT_INTERVAL_IMMEDIATE",
+))
+
+D3DCURSORCAPS = Flags(DWORD, (
+ "D3DCURSORCAPS_COLOR",
+ "D3DCURSORCAPS_LOWRES",
+))
+
+D3DDEVCAPS = Flags(DWORD, (
+ "D3DDEVCAPS_EXECUTESYSTEMMEMORY",
+ "D3DDEVCAPS_EXECUTEVIDEOMEMORY",
+ "D3DDEVCAPS_TLVERTEXSYSTEMMEMORY",
+ "D3DDEVCAPS_TLVERTEXVIDEOMEMORY",
+ "D3DDEVCAPS_TEXTURESYSTEMMEMORY",
+ "D3DDEVCAPS_TEXTUREVIDEOMEMORY",
+ "D3DDEVCAPS_DRAWPRIMTLVERTEX",
+ "D3DDEVCAPS_CANRENDERAFTERFLIP",
+ "D3DDEVCAPS_TEXTURENONLOCALVIDMEM",
+ "D3DDEVCAPS_DRAWPRIMITIVES2",
+ "D3DDEVCAPS_SEPARATETEXTUREMEMORIES",
+ "D3DDEVCAPS_DRAWPRIMITIVES2EX",
+ "D3DDEVCAPS_HWTRANSFORMANDLIGHT",
+ "D3DDEVCAPS_CANBLTSYSTONONLOCAL",
+ "D3DDEVCAPS_HWRASTERIZATION",
+ "D3DDEVCAPS_PUREDEVICE",
+ "D3DDEVCAPS_QUINTICRTPATCHES",
+ "D3DDEVCAPS_RTPATCHES",
+ "D3DDEVCAPS_RTPATCHHANDLEZERO",
+ "D3DDEVCAPS_NPATCHES",
+))
+
+D3DPMISCCAPS = Flags(DWORD, (
+ "D3DPMISCCAPS_MASKZ",
+ "D3DPMISCCAPS_LINEPATTERNREP",
+ "D3DPMISCCAPS_CULLNONE",
+ "D3DPMISCCAPS_CULLCW",
+ "D3DPMISCCAPS_CULLCCW",
+ "D3DPMISCCAPS_COLORWRITEENABLE",
+ "D3DPMISCCAPS_CLIPPLANESCALEDPOINTS",
+ "D3DPMISCCAPS_CLIPTLVERTS",
+ "D3DPMISCCAPS_TSSARGTEMP",
+ "D3DPMISCCAPS_BLENDOP",
+ "D3DPMISCCAPS_NULLREFERENCE",
+))
+
+D3DLINECAPS = Flags(DWORD, (
+ "D3DLINECAPS_TEXTURE",
+ "D3DLINECAPS_ZTEST",
+ "D3DLINECAPS_BLEND",
+ "D3DLINECAPS_ALPHACMP",
+ "D3DLINECAPS_FOG",
+))
+
+D3DPRASTERCAPS = Flags(DWORD, (
+ "D3DPRASTERCAPS_DITHER",
+ "D3DPRASTERCAPS_PAT",
+ "D3DPRASTERCAPS_ZTEST",
+ "D3DPRASTERCAPS_FOGVERTEX",
+ "D3DPRASTERCAPS_FOGTABLE",
+ "D3DPRASTERCAPS_ANTIALIASEDGES",
+ "D3DPRASTERCAPS_MIPMAPLODBIAS",
+ "D3DPRASTERCAPS_ZBIAS",
+ "D3DPRASTERCAPS_ZBUFFERLESSHSR",
+ "D3DPRASTERCAPS_FOGRANGE",
+ "D3DPRASTERCAPS_ANISOTROPY",
+ "D3DPRASTERCAPS_WBUFFER",
+ "D3DPRASTERCAPS_WFOG",
+ "D3DPRASTERCAPS_ZFOG",
+ "D3DPRASTERCAPS_COLORPERSPECTIVE",
+ "D3DPRASTERCAPS_STRETCHBLTMULTISAMPLE",
+))
+
+D3DPCMPCAPS = Flags(DWORD, (
+ "D3DPCMPCAPS_NEVER",
+ "D3DPCMPCAPS_LESS",
+ "D3DPCMPCAPS_EQUAL",
+ "D3DPCMPCAPS_LESSEQUAL",
+ "D3DPCMPCAPS_GREATER",
+ "D3DPCMPCAPS_NOTEQUAL",
+ "D3DPCMPCAPS_GREATEREQUAL",
+ "D3DPCMPCAPS_ALWAYS",
+))
+
+D3DPBLENDCAPS = Flags(DWORD, (
+ "D3DPBLENDCAPS_ZERO",
+ "D3DPBLENDCAPS_ONE",
+ "D3DPBLENDCAPS_SRCCOLOR",
+ "D3DPBLENDCAPS_INVSRCCOLOR",
+ "D3DPBLENDCAPS_SRCALPHA",
+ "D3DPBLENDCAPS_INVSRCALPHA",
+ "D3DPBLENDCAPS_DESTALPHA",
+ "D3DPBLENDCAPS_INVDESTALPHA",
+ "D3DPBLENDCAPS_DESTCOLOR",
+ "D3DPBLENDCAPS_INVDESTCOLOR",
+ "D3DPBLENDCAPS_SRCALPHASAT",
+ "D3DPBLENDCAPS_BOTHSRCALPHA",
+ "D3DPBLENDCAPS_BOTHINVSRCALPHA",
+
+ "D3DPSHADECAPS_COLORGOURAUDRGB",
+ "D3DPSHADECAPS_SPECULARGOURAUDRGB",
+ "D3DPSHADECAPS_ALPHAGOURAUDBLEND",
+ "D3DPSHADECAPS_FOGGOURAUD",
+))
+
+D3DPTEXTURECAPS = Flags(DWORD, (
+ "D3DPTEXTURECAPS_PERSPECTIVE",
+ "D3DPTEXTURECAPS_POW2",
+ "D3DPTEXTURECAPS_ALPHA",
+ "D3DPTEXTURECAPS_SQUAREONLY",
+ "D3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZE",
+ "D3DPTEXTURECAPS_ALPHAPALETTE",
+ "D3DPTEXTURECAPS_NONPOW2CONDITIONAL",
+ "D3DPTEXTURECAPS_PROJECTED",
+ "D3DPTEXTURECAPS_CUBEMAP",
+ "D3DPTEXTURECAPS_VOLUMEMAP",
+ "D3DPTEXTURECAPS_MIPMAP",
+ "D3DPTEXTURECAPS_MIPVOLUMEMAP",
+ "D3DPTEXTURECAPS_MIPCUBEMAP",
+ "D3DPTEXTURECAPS_CUBEMAP_POW2",
+ "D3DPTEXTURECAPS_VOLUMEMAP_POW2",
+))
+
+D3DPTFILTERCAPS = Flags(DWORD, (
+ "D3DPTFILTERCAPS_MINFPOINT",
+ "D3DPTFILTERCAPS_MINFLINEAR",
+ "D3DPTFILTERCAPS_MINFANISOTROPIC",
+ "D3DPTFILTERCAPS_MIPFPOINT",
+ "D3DPTFILTERCAPS_MIPFLINEAR",
+ "D3DPTFILTERCAPS_MAGFPOINT",
+ "D3DPTFILTERCAPS_MAGFLINEAR",
+ "D3DPTFILTERCAPS_MAGFANISOTROPIC",
+ "D3DPTFILTERCAPS_MAGFAFLATCUBIC",
+ "D3DPTFILTERCAPS_MAGFGAUSSIANCUBIC",
+))
+
+D3DPTADDRESSCAPS = Flags(DWORD, (
+ "D3DPTADDRESSCAPS_WRAP",
+ "D3DPTADDRESSCAPS_MIRROR",
+ "D3DPTADDRESSCAPS_CLAMP",
+ "D3DPTADDRESSCAPS_BORDER",
+ "D3DPTADDRESSCAPS_INDEPENDENTUV",
+ "D3DPTADDRESSCAPS_MIRRORONCE",
+))
+
+D3DSTENCILCAPS = Flags(DWORD, (
+ "D3DSTENCILCAPS_KEEP",
+ "D3DSTENCILCAPS_ZERO",
+ "D3DSTENCILCAPS_REPLACE",
+ "D3DSTENCILCAPS_INCRSAT",
+ "D3DSTENCILCAPS_DECRSAT",
+ "D3DSTENCILCAPS_INVERT",
+ "D3DSTENCILCAPS_INCR",
+ "D3DSTENCILCAPS_DECR",
+))
+
+D3DTEXOPCAPS = Flags(DWORD, (
+ "D3DTEXOPCAPS_DISABLE",
+ "D3DTEXOPCAPS_SELECTARG1",
+ "D3DTEXOPCAPS_SELECTARG2",
+ "D3DTEXOPCAPS_MODULATE",
+ "D3DTEXOPCAPS_MODULATE2X",
+ "D3DTEXOPCAPS_MODULATE4X",
+ "D3DTEXOPCAPS_ADD",
+ "D3DTEXOPCAPS_ADDSIGNED",
+ "D3DTEXOPCAPS_ADDSIGNED2X",
+ "D3DTEXOPCAPS_SUBTRACT",
+ "D3DTEXOPCAPS_ADDSMOOTH",
+ "D3DTEXOPCAPS_BLENDDIFFUSEALPHA",
+ "D3DTEXOPCAPS_BLENDTEXTUREALPHA",
+ "D3DTEXOPCAPS_BLENDFACTORALPHA",
+ "D3DTEXOPCAPS_BLENDTEXTUREALPHAPM",
+ "D3DTEXOPCAPS_BLENDCURRENTALPHA",
+ "D3DTEXOPCAPS_PREMODULATE",
+ "D3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR",
+ "D3DTEXOPCAPS_MODULATECOLOR_ADDALPHA",
+ "D3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR",
+ "D3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA",
+ "D3DTEXOPCAPS_BUMPENVMAP",
+ "D3DTEXOPCAPS_BUMPENVMAPLUMINANCE",
+ "D3DTEXOPCAPS_DOTPRODUCT3",
+ "D3DTEXOPCAPS_MULTIPLYADD",
+ "D3DTEXOPCAPS_LERP",
+))
+
+D3DFVFCAPS = Flags(DWORD, (
+ "D3DFVFCAPS_TEXCOORDCOUNTMASK",
+ "D3DFVFCAPS_DONOTSTRIPELEMENTS",
+ "D3DFVFCAPS_PSIZE",
+))
+
+D3DVTXPCAPS = Flags(DWORD, (
+ "D3DVTXPCAPS_TEXGEN",
+ "D3DVTXPCAPS_MATERIALSOURCE7",
+ "D3DVTXPCAPS_DIRECTIONALLIGHTS",
+ "D3DVTXPCAPS_POSITIONALLIGHTS",
+ "D3DVTXPCAPS_LOCALVIEWER",
+ "D3DVTXPCAPS_TWEENING",
+ "D3DVTXPCAPS_NO_VSDT_UBYTE4",
+))
+
+D3DCAPS8 = Struct("D3DCAPS8", (
+ (D3DDEVTYPE, "DeviceType"),
+ (UINT, "AdapterOrdinal"),
+ (DWORD, "Caps"),
+ (DWORD, "Caps2"),
+ (DWORD, "Caps3"),
+ (DWORD, "PresentationIntervals"),
+ (DWORD, "CursorCaps"),
+ (DWORD, "DevCaps"),
+ (DWORD, "PrimitiveMiscCaps"),
+ (DWORD, "RasterCaps"),
+ (DWORD, "ZCmpCaps"),
+ (DWORD, "SrcBlendCaps"),
+ (DWORD, "DestBlendCaps"),
+ (DWORD, "AlphaCmpCaps"),
+ (DWORD, "ShadeCaps"),
+ (DWORD, "TextureCaps"),
+ (DWORD, "TextureFilterCaps"),
+ (DWORD, "CubeTextureFilterCaps"),
+ (DWORD, "VolumeTextureFilterCaps"),
+ (DWORD, "TextureAddressCaps"),
+ (DWORD, "VolumeTextureAddressCaps"),
+ (DWORD, "LineCaps"),
+ (DWORD, "MaxTextureWidth"),
+ (DWORD, "MaxTextureHeight"),
+ (DWORD, "MaxVolumeExtent"),
+ (DWORD, "MaxTextureRepeat"),
+ (DWORD, "MaxTextureAspectRatio"),
+ (DWORD, "MaxAnisotropy"),
+ (Float, "MaxVertexW"),
+ (Float, "GuardBandLeft"),
+ (Float, "GuardBandTop"),
+ (Float, "GuardBandRight"),
+ (Float, "GuardBandBottom"),
+ (Float, "ExtentsAdjust"),
+ (DWORD, "StencilCaps"),
+ (DWORD, "FVFCaps"),
+ (DWORD, "TextureOpCaps"),
+ (DWORD, "MaxTextureBlendStages"),
+ (DWORD, "MaxSimultaneousTextures"),
+ (DWORD, "VertexProcessingCaps"),
+ (DWORD, "MaxActiveLights"),
+ (DWORD, "MaxUserClipPlanes"),
+ (DWORD, "MaxVertexBlendMatrices"),
+ (DWORD, "MaxVertexBlendMatrixIndex"),
+ (Float, "MaxPointSize"),
+ (DWORD, "MaxPrimitiveCount"),
+ (DWORD, "MaxVertexIndex"),
+ (DWORD, "MaxStreams"),
+ (DWORD, "MaxStreamStride"),
+ (DWORD, "VertexShaderVersion"),
+ (DWORD, "MaxVertexShaderConst"),
+ (DWORD, "PixelShaderVersion"),
+ (Float, "MaxPixelShaderValue"),
+))
+
--- /dev/null
+"""d3d8types.h"""
+
+from windows import *
+
+D3DCOLOR = Alias("D3DCOLOR", DWORD)
+
+D3DVECTOR = Struct("D3DVECTOR", (
+ (Float, "x"),
+ (Float, "y"),
+ (Float, "z"),
+))
+
+D3DCOLORVALUE = Struct("D3DCOLORVALUE", (
+ (Float, "r"),
+ (Float, "g"),
+ (Float, "b"),
+ (Float, "a"),
+))
+
+D3DRECT = Struct("D3DRECT", (
+ (LONG, "x1"),
+ (LONG, "y1"),
+ (LONG, "x2"),
+ (LONG, "y2"),
+))
+
+D3DMATRIX = Struct("D3DMATRIX", (
+ (Float, "m[4][4]"),
+))
+
+D3DVIEWPORT8 = Struct("D3DVIEWPORT8", (
+ (DWORD, "X"),
+ (DWORD, "Y"),
+ (DWORD, "Width"),
+ (DWORD, "Height"),
+ (Float, "MinZ"),
+ (Float, "MaxZ"),
+))
+
+D3DCLIP = Flags(DWORD, (
+ "D3DCLIPPLANE0",
+ "D3DCLIPPLANE1",
+ "D3DCLIPPLANE2",
+ "D3DCLIPPLANE3",
+ "D3DCLIPPLANE4",
+ "D3DCLIPPLANE5",
+))
+
+D3DCS = Flags(DWORD, (
+ "D3DCS_ALL",
+ "D3DCS_LEFT",
+ "D3DCS_RIGHT",
+ "D3DCS_TOP",
+ "D3DCS_BOTTOM",
+ "D3DCS_FRONT",
+ "D3DCS_BACK",
+ "D3DCS_PLANE0",
+ "D3DCS_PLANE1",
+ "D3DCS_PLANE2",
+ "D3DCS_PLANE3",
+ "D3DCS_PLANE4",
+ "D3DCS_PLANE5",
+))
+
+D3DCLIPSTATUS8 = Struct("D3DCLIPSTATUS8", (
+ (DWORD, "ClipUnion"),
+ (DWORD, "ClipIntersection"),
+))
+
+D3DMATERIAL8 = Struct("D3DMATERIAL8", (
+ (D3DCOLORVALUE, "Diffuse"),
+ (D3DCOLORVALUE, "Ambient"),
+ (D3DCOLORVALUE, "Specular"),
+ (D3DCOLORVALUE, "Emissive"),
+ (Float, "Power"),
+))
+
+D3DLIGHTTYPE = Enum("D3DLIGHTTYPE", (
+ "D3DLIGHT_POINT",
+ "D3DLIGHT_SPOT",
+ "D3DLIGHT_DIRECTIONAL",
+ "D3DLIGHT_FORCE_DWORD",
+))
+
+D3DLIGHT8 = Struct("D3DLIGHT8", (
+ (D3DLIGHTTYPE, "Type"),
+ (D3DCOLORVALUE, "Diffuse"),
+ (D3DCOLORVALUE, "Specular"),
+ (D3DCOLORVALUE, "Ambient"),
+ (D3DVECTOR, "Position"),
+ (D3DVECTOR, "Direction"),
+ (Float, "Range"),
+ (Float, "Falloff"),
+ (Float, "Attenuation0"),
+ (Float, "Attenuation1"),
+ (Float, "Attenuation2"),
+ (Float, "Theta"),
+ (Float, "Phi"),
+))
+
+D3DCS = Flags(DWORD, (
+ "D3DCLEAR_TARGET",
+ "D3DCLEAR_ZBUFFER",
+ "D3DCLEAR_STENCIL",
+))
+
+D3DSHADEMODE = Enum("D3DSHADEMODE", (
+ "D3DSHADE_FLAT",
+ "D3DSHADE_GOURAUD",
+ "D3DSHADE_PHONG",
+ "D3DSHADE_FORCE_DWORD",
+))
+
+D3DFILLMODE = Enum("D3DFILLMODE", (
+ "D3DFILL_POINT",
+ "D3DFILL_WIREFRAME",
+ "D3DFILL_SOLID",
+ "D3DFILL_FORCE_DWORD",
+))
+
+D3DLINEPATTERN = Struct("D3DLINEPATTERN", (
+ (WORD, "wRepeatFactor"),
+ (WORD, "wLinePattern"),
+))
+
+D3DBLEND = Enum("D3DBLEND", (
+ "D3DBLEND_ZERO",
+ "D3DBLEND_ONE",
+ "D3DBLEND_SRCCOLOR",
+ "D3DBLEND_INVSRCCOLOR",
+ "D3DBLEND_SRCALPHA",
+ "D3DBLEND_INVSRCALPHA",
+ "D3DBLEND_DESTALPHA",
+ "D3DBLEND_INVDESTALPHA",
+ "D3DBLEND_DESTCOLOR",
+ "D3DBLEND_INVDESTCOLOR",
+ "D3DBLEND_SRCALPHASAT",
+ "D3DBLEND_BOTHSRCALPHA",
+ "D3DBLEND_BOTHINVSRCALPHA",
+ "D3DBLEND_FORCE_DWORD",
+))
+
+D3DBLENDOP = Enum("D3DBLENDOP", (
+ "D3DBLENDOP_ADD",
+ "D3DBLENDOP_SUBTRACT",
+ "D3DBLENDOP_REVSUBTRACT",
+ "D3DBLENDOP_MIN",
+ "D3DBLENDOP_MAX",
+ "D3DBLENDOP_FORCE_DWORD",
+))
+
+D3DTEXTUREADDRESS = Enum("D3DTEXTUREADDRESS", (
+ "D3DTADDRESS_WRAP",
+ "D3DTADDRESS_MIRROR",
+ "D3DTADDRESS_CLAMP",
+ "D3DTADDRESS_BORDER",
+ "D3DTADDRESS_MIRRORONCE",
+ "D3DTADDRESS_FORCE_DWORD",
+))
+
+D3DCULL = Enum("D3DCULL", (
+ "D3DCULL_NONE",
+ "D3DCULL_CW",
+ "D3DCULL_CCW",
+ "D3DCULL_FORCE_DWORD",
+))
+
+D3DCMPFUNC = Enum("D3DCMPFUNC", (
+ "D3DCMP_NEVER",
+ "D3DCMP_LESS",
+ "D3DCMP_EQUAL",
+ "D3DCMP_LESSEQUAL",
+ "D3DCMP_GREATER",
+ "D3DCMP_NOTEQUAL",
+ "D3DCMP_GREATEREQUAL",
+ "D3DCMP_ALWAYS",
+ "D3DCMP_FORCE_DWORD",
+))
+
+D3DSTENCILOP = Enum("D3DSTENCILOP", (
+ "D3DSTENCILOP_KEEP",
+ "D3DSTENCILOP_ZERO",
+ "D3DSTENCILOP_REPLACE",
+ "D3DSTENCILOP_INCRSAT",
+ "D3DSTENCILOP_DECRSAT",
+ "D3DSTENCILOP_INVERT",
+ "D3DSTENCILOP_INCR",
+ "D3DSTENCILOP_DECR",
+ "D3DSTENCILOP_FORCE_DWORD",
+))
+
+D3DFOGMODE = Enum("D3DFOGMODE", (
+ "D3DFOG_NONE",
+ "D3DFOG_EXP",
+ "D3DFOG_EXP2",
+ "D3DFOG_LINEAR",
+ "D3DFOG_FORCE_DWORD",
+))
+
+D3DZBUFFERTYPE = Enum("D3DZBUFFERTYPE", (
+ "D3DZB_FALSE",
+ "D3DZB_TRUE",
+ "D3DZB_USEW",
+ "D3DZB_FORCE_DWORD",
+))
+
+
+D3DPRIMITIVETYPE = Enum("D3DPRIMITIVETYPE", (
+ "D3DPT_POINTLIST",
+ "D3DPT_LINELIST",
+ "D3DPT_LINESTRIP",
+ "D3DPT_TRIANGLELIST",
+ "D3DPT_TRIANGLESTRIP",
+ "D3DPT_TRIANGLEFAN",
+ "D3DPT_FORCE_DWORD",
+))
+
+D3DTRANSFORMSTATETYPE = Enum("D3DTRANSFORMSTATETYPE", (
+ "D3DTS_VIEW",
+ "D3DTS_PROJECTION",
+ "D3DTS_TEXTURE0",
+ "D3DTS_TEXTURE1",
+ "D3DTS_TEXTURE2",
+ "D3DTS_TEXTURE3",
+ "D3DTS_TEXTURE4",
+ "D3DTS_TEXTURE5",
+ "D3DTS_TEXTURE6",
+ "D3DTS_TEXTURE7",
+ "D3DTS_FORCE_DWORD",
+))
+
+D3DTS = Flags(DWORD, (
+ "D3DTS_WORLDMATRIX(index)",
+ "D3DTS_WORLD",
+ "D3DTS_WORLD1",
+ "D3DTS_WORLD2",
+ "D3DTS_WORLD3",
+))
+
+D3DRENDERSTATETYPE = Enum("D3DRENDERSTATETYPE", (
+ "D3DRS_ZENABLE",
+ "D3DRS_FILLMODE",
+ "D3DRS_SHADEMODE",
+ "D3DRS_LINEPATTERN",
+ "D3DRS_ZWRITEENABLE",
+ "D3DRS_ALPHATESTENABLE",
+ "D3DRS_LASTPIXEL",
+ "D3DRS_SRCBLEND",
+ "D3DRS_DESTBLEND",
+ "D3DRS_CULLMODE",
+ "D3DRS_ZFUNC",
+ "D3DRS_ALPHAREF",
+ "D3DRS_ALPHAFUNC",
+ "D3DRS_DITHERENABLE",
+ "D3DRS_ALPHABLENDENABLE",
+ "D3DRS_FOGENABLE",
+ "D3DRS_SPECULARENABLE",
+ "D3DRS_ZVISIBLE",
+ "D3DRS_FOGCOLOR",
+ "D3DRS_FOGTABLEMODE",
+ "D3DRS_FOGSTART",
+ "D3DRS_FOGEND",
+ "D3DRS_FOGDENSITY",
+ "D3DRS_EDGEANTIALIAS",
+ "D3DRS_ZBIAS",
+ "D3DRS_RANGEFOGENABLE",
+ "D3DRS_STENCILENABLE",
+ "D3DRS_STENCILFAIL",
+ "D3DRS_STENCILZFAIL",
+ "D3DRS_STENCILPASS",
+ "D3DRS_STENCILFUNC",
+ "D3DRS_STENCILREF",
+ "D3DRS_STENCILMASK",
+ "D3DRS_STENCILWRITEMASK",
+ "D3DRS_TEXTUREFACTOR",
+ "D3DRS_WRAP0",
+ "D3DRS_WRAP1",
+ "D3DRS_WRAP2",
+ "D3DRS_WRAP3",
+ "D3DRS_WRAP4",
+ "D3DRS_WRAP5",
+ "D3DRS_WRAP6",
+ "D3DRS_WRAP7",
+ "D3DRS_CLIPPING",
+ "D3DRS_LIGHTING",
+ "D3DRS_AMBIENT",
+ "D3DRS_FOGVERTEXMODE",
+ "D3DRS_COLORVERTEX",
+ "D3DRS_LOCALVIEWER",
+ "D3DRS_NORMALIZENORMALS",
+ "D3DRS_DIFFUSEMATERIALSOURCE",
+ "D3DRS_SPECULARMATERIALSOURCE",
+ "D3DRS_AMBIENTMATERIALSOURCE",
+ "D3DRS_EMISSIVEMATERIALSOURCE",
+ "D3DRS_VERTEXBLEND",
+ "D3DRS_CLIPPLANEENABLE",
+ "D3DRS_SOFTWAREVERTEXPROCESSING",
+ "D3DRS_POINTSIZE",
+ "D3DRS_POINTSIZE_MIN",
+ "D3DRS_POINTSPRITEENABLE",
+ "D3DRS_POINTSCALEENABLE",
+ "D3DRS_POINTSCALE_A",
+ "D3DRS_POINTSCALE_B",
+ "D3DRS_POINTSCALE_C",
+ "D3DRS_MULTISAMPLEANTIALIAS",
+ "D3DRS_MULTISAMPLEMASK",
+ "D3DRS_PATCHEDGESTYLE",
+ "D3DRS_PATCHSEGMENTS",
+ "D3DRS_DEBUGMONITORTOKEN",
+ "D3DRS_POINTSIZE_MAX",
+ "D3DRS_INDEXEDVERTEXBLENDENABLE",
+ "D3DRS_COLORWRITEENABLE",
+ "D3DRS_TWEENFACTOR",
+ "D3DRS_BLENDOP",
+ "D3DRS_POSITIONORDER",
+ "D3DRS_NORMALORDER",
+ "D3DRS_FORCE_DWORD",
+))
+
+
+D3DMATERIALCOLORSOURCE = Enum("D3DMATERIALCOLORSOURCE", (
+ "D3DMCS_MATERIAL",
+ "D3DMCS_COLOR1",
+ "D3DMCS_COLOR2",
+ "D3DMCS_FORCE_DWORD",
+))
+
+D3DWRAP = Flags(DWORD, (
+ "D3DWRAP_U",
+ "D3DWRAP_V",
+ "D3DWRAP_W",
+))
+
+D3DWRAPCOORD = Flags(DWORD, (
+ "D3DWRAPCOORD_0",
+ "D3DWRAPCOORD_1",
+ "D3DWRAPCOORD_2",
+ "D3DWRAPCOORD_3",
+))
+
+D3DCOLORWRITEENABLE = Flags(DWORD, (
+ "D3DCOLORWRITEENABLE_RED",
+ "D3DCOLORWRITEENABLE_GREEN",
+ "D3DCOLORWRITEENABLE_BLUE",
+ "D3DCOLORWRITEENABLE_ALPHA",
+))
+
+D3DTEXTURESTAGESTATETYPE = Enum("D3DTEXTURESTAGESTATETYPE", (
+ "D3DTSS_COLOROP",
+ "D3DTSS_COLORARG1",
+ "D3DTSS_COLORARG2",
+ "D3DTSS_ALPHAOP",
+ "D3DTSS_ALPHAARG1",
+ "D3DTSS_ALPHAARG2",
+ "D3DTSS_BUMPENVMAT00",
+ "D3DTSS_BUMPENVMAT01",
+ "D3DTSS_BUMPENVMAT10",
+ "D3DTSS_BUMPENVMAT11",
+ "D3DTSS_TEXCOORDINDEX",
+ "D3DTSS_ADDRESSU",
+ "D3DTSS_ADDRESSV",
+ "D3DTSS_BORDERCOLOR",
+ "D3DTSS_MAGFILTER",
+ "D3DTSS_MINFILTER",
+ "D3DTSS_MIPFILTER",
+ "D3DTSS_MIPMAPLODBIAS",
+ "D3DTSS_MAXMIPLEVEL",
+ "D3DTSS_MAXANISOTROPY",
+ "D3DTSS_BUMPENVLSCALE",
+ "D3DTSS_BUMPENVLOFFSET",
+ "D3DTSS_TEXTURETRANSFORMFLAGS",
+ "D3DTSS_ADDRESSW",
+ "D3DTSS_COLORARG0",
+ "D3DTSS_ALPHAARG0",
+ "D3DTSS_RESULTARG",
+ "D3DTSS_FORCE_DWORD",
+))
+
+D3DTSS = Flags(DWORD, (
+ "D3DTSS_TCI_PASSTHRU",
+ "D3DTSS_TCI_CAMERASPACENORMAL",
+ "D3DTSS_TCI_CAMERASPACEPOSITION",
+ "D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR",
+))
+
+D3DTEXTUREOP = Enum("D3DTEXTUREOP", (
+ "D3DTOP_DISABLE",
+ "D3DTOP_SELECTARG1",
+ "D3DTOP_SELECTARG2",
+ "D3DTOP_MODULATE",
+ "D3DTOP_MODULATE2X",
+ "D3DTOP_MODULATE4X",
+ "D3DTOP_ADD",
+ "D3DTOP_ADDSIGNED",
+ "D3DTOP_ADDSIGNED2X",
+ "D3DTOP_SUBTRACT",
+ "D3DTOP_ADDSMOOTH",
+ "D3DTOP_BLENDDIFFUSEALPHA",
+ "D3DTOP_BLENDTEXTUREALPHA",
+ "D3DTOP_BLENDFACTORALPHA",
+ "D3DTOP_BLENDTEXTUREALPHAPM",
+ "D3DTOP_BLENDCURRENTALPHA",
+ "D3DTOP_PREMODULATE",
+ "D3DTOP_MODULATEALPHA_ADDCOLOR",
+ "D3DTOP_MODULATECOLOR_ADDALPHA",
+ "D3DTOP_MODULATEINVALPHA_ADDCOLOR",
+ "D3DTOP_MODULATEINVCOLOR_ADDALPHA",
+ "D3DTOP_BUMPENVMAP",
+ "D3DTOP_BUMPENVMAPLUMINANCE",
+ "D3DTOP_DOTPRODUCT3",
+ "D3DTOP_MULTIPLYADD",
+ "D3DTOP_LERP",
+ "D3DTOP_FORCE_DWORD",
+))
+
+D3DTA = Flags(DWORD, (
+ "D3DTA_SELECTMASK",
+ "D3DTA_DIFFUSE",
+ "D3DTA_CURRENT",
+ "D3DTA_TEXTURE",
+ "D3DTA_TFACTOR",
+ "D3DTA_SPECULAR",
+ "D3DTA_TEMP",
+ "D3DTA_COMPLEMENT",
+ "D3DTA_ALPHAREPLICATE",
+))
+
+D3DTEXTUREFILTERTYPE = Enum("D3DTEXTUREFILTERTYPE", (
+ "D3DTEXF_NONE",
+ "D3DTEXF_POINT",
+ "D3DTEXF_LINEAR",
+ "D3DTEXF_ANISOTROPIC",
+ "D3DTEXF_FLATCUBIC",
+ "D3DTEXF_GAUSSIANCUBIC",
+ "D3DTEXF_FORCE_DWORD",
+))
+
+D3DPV = Flags(DWORD, (
+ "D3DPV_DONOTCOPYDATA",
+))
+
+D3DFVF = Flags(DWORD, (
+ "D3DFVF_RESERVED0",
+ "D3DFVF_POSITION_MASK",
+ "D3DFVF_XYZ",
+ "D3DFVF_XYZRHW",
+ "D3DFVF_XYZB1",
+ "D3DFVF_XYZB2",
+ "D3DFVF_XYZB3",
+ "D3DFVF_XYZB4",
+ "D3DFVF_XYZB5",
+ "D3DFVF_NORMAL",
+ "D3DFVF_PSIZE",
+ "D3DFVF_DIFFUSE",
+ "D3DFVF_SPECULAR",
+ "D3DFVF_TEXCOUNT_MASK",
+ "D3DFVF_TEXCOUNT_SHIFT",
+ "D3DFVF_TEX0",
+ "D3DFVF_TEX1",
+ "D3DFVF_TEX2",
+ "D3DFVF_TEX3",
+ "D3DFVF_TEX4",
+ "D3DFVF_TEX5",
+ "D3DFVF_TEX6",
+ "D3DFVF_TEX7",
+ "D3DFVF_TEX8",
+ "D3DFVF_LASTBETA_UBYTE4",
+ "D3DFVF_RESERVED2",
+ "D3DFVF_TEXCOORDSIZE3(0)",
+ "D3DFVF_TEXCOORDSIZE2(0)",
+ "D3DFVF_TEXCOORDSIZE4(0)",
+ "D3DFVF_TEXCOORDSIZE1(0)",
+ "D3DFVF_TEXCOORDSIZE3(1)",
+ "D3DFVF_TEXCOORDSIZE2(1)",
+ "D3DFVF_TEXCOORDSIZE4(1)",
+ "D3DFVF_TEXCOORDSIZE1(1)",
+ "D3DFVF_TEXCOORDSIZE3(2)",
+ "D3DFVF_TEXCOORDSIZE2(2)",
+ "D3DFVF_TEXCOORDSIZE4(2)",
+ "D3DFVF_TEXCOORDSIZE1(2)",
+ "D3DFVF_TEXCOORDSIZE3(3)",
+ "D3DFVF_TEXCOORDSIZE2(3)",
+ "D3DFVF_TEXCOORDSIZE4(3)",
+ "D3DFVF_TEXCOORDSIZE1(3)",
+))
+
+D3DVSD_TOKENTYPE = Enum("D3DVSD_TOKENTYPE", (
+ "D3DVSD_TOKEN_NOP",
+ "D3DVSD_TOKEN_STREAM",
+ "D3DVSD_TOKEN_STREAMDATA",
+ "D3DVSD_TOKEN_TESSELLATOR",
+ "D3DVSD_TOKEN_CONSTMEM",
+ "D3DVSD_TOKEN_EXT",
+ "D3DVSD_TOKEN_END",
+ "D3DVSD_FORCE_DWORD",
+))
+
+D3DVSDT = Flags(DWORD, (
+ "D3DVSDT_FLOAT1",
+ "D3DVSDT_FLOAT2",
+ "D3DVSDT_FLOAT3",
+ "D3DVSDT_FLOAT4",
+ "D3DVSDT_D3DCOLOR",
+ "D3DVSDT_UBYTE4",
+ "D3DVSDT_SHORT2",
+ "D3DVSDT_SHORT4",
+ "D3DVSDE_POSITION",
+ "D3DVSDE_BLENDWEIGHT",
+ "D3DVSDE_BLENDINDICES",
+ "D3DVSDE_NORMAL",
+ "D3DVSDE_PSIZE",
+ "D3DVSDE_DIFFUSE",
+ "D3DVSDE_SPECULAR",
+ "D3DVSDE_TEXCOORD0",
+ "D3DVSDE_TEXCOORD1",
+ "D3DVSDE_TEXCOORD2",
+ "D3DVSDE_TEXCOORD3",
+ "D3DVSDE_TEXCOORD4",
+ "D3DVSDE_TEXCOORD5",
+ "D3DVSDE_TEXCOORD6",
+ "D3DVSDE_TEXCOORD7",
+ "D3DVSDE_POSITION2",
+ "D3DVSDE_NORMAL2",
+ "D3DDP_MAXTEXCOORD",
+ "D3DSI_OPCODE_MASK",
+))
+
+D3DSHADER_INSTRUCTION_OPCODE_TYPE = Enum("D3DSHADER_INSTRUCTION_OPCODE_TYPE", (
+ "D3DSIO_NOP",
+ "D3DSIO_MOV",
+ "D3DSIO_ADD",
+ "D3DSIO_SUB",
+ "D3DSIO_MAD",
+ "D3DSIO_MUL",
+ "D3DSIO_RCP",
+ "D3DSIO_RSQ",
+ "D3DSIO_DP3",
+ "D3DSIO_DP4",
+ "D3DSIO_MIN",
+ "D3DSIO_MAX",
+ "D3DSIO_SLT",
+ "D3DSIO_SGE",
+ "D3DSIO_EXP",
+ "D3DSIO_LOG",
+ "D3DSIO_LIT",
+ "D3DSIO_DST",
+ "D3DSIO_LRP",
+ "D3DSIO_FRC",
+ "D3DSIO_M4x4",
+ "D3DSIO_M4x3",
+ "D3DSIO_M3x4",
+ "D3DSIO_M3x3",
+ "D3DSIO_M3x2",
+ "D3DSIO_TEXCOORD",
+ "D3DSIO_TEXKILL",
+ "D3DSIO_TEX",
+ "D3DSIO_TEXBEM",
+ "D3DSIO_TEXBEML",
+ "D3DSIO_TEXREG2AR",
+ "D3DSIO_TEXREG2GB",
+ "D3DSIO_TEXM3x2PAD",
+ "D3DSIO_TEXM3x2TEX",
+ "D3DSIO_TEXM3x3PAD",
+ "D3DSIO_TEXM3x3TEX",
+ "D3DSIO_TEXM3x3DIFF",
+ "D3DSIO_TEXM3x3SPEC",
+ "D3DSIO_TEXM3x3VSPEC",
+ "D3DSIO_EXPP",
+ "D3DSIO_LOGP",
+ "D3DSIO_CND",
+ "D3DSIO_DEF",
+ "D3DSIO_TEXREG2RGB",
+ "D3DSIO_TEXDP3TEX",
+ "D3DSIO_TEXM3x2DEPTH",
+ "D3DSIO_TEXDP3",
+ "D3DSIO_TEXM3x3",
+ "D3DSIO_TEXDEPTH",
+ "D3DSIO_CMP",
+ "D3DSIO_BEM",
+ "D3DSIO_PHASE",
+ "D3DSIO_COMMENT",
+ "D3DSIO_END",
+ "D3DSIO_FORCE_DWORD",
+))
+
+D3DSP = Flags(DWORD, (
+ "D3DSP_WRITEMASK_0",
+ "D3DSP_WRITEMASK_1",
+ "D3DSP_WRITEMASK_2",
+ "D3DSP_WRITEMASK_3",
+ "D3DSP_WRITEMASK_ALL",
+))
+
+D3DSHADER_PARAM_DSTMOD_TYPE = Enum("D3DSHADER_PARAM_DSTMOD_TYPE", (
+ "D3DSPDM_NONE",
+ "D3DSPDM_SATURATE",
+ "D3DSPDM_FORCE_DWORD",
+))
+
+D3DSHADER_PARAM_REGISTER_TYPE = Enum("D3DSHADER_PARAM_REGISTER_TYPE", (
+ "D3DSPR_TEMP",
+ "D3DSPR_INPUT",
+ "D3DSPR_CONST",
+ "D3DSPR_ADDR",
+ "D3DSPR_TEXTURE",
+ "D3DSPR_RASTOUT",
+ "D3DSPR_ATTROUT",
+ "D3DSPR_TEXCRDOUT",
+ "D3DSPR_FORCE_DWORD",
+))
+
+D3DVS_RASTOUT_OFFSETS = Enum("D3DVS_RASTOUT_OFFSETS", (
+ "D3DSRO_POSITION",
+ "D3DSRO_FOG",
+ "D3DSRO_POINT_SIZE",
+ "D3DSRO_FORCE_DWORD",
+))
+
+D3DVS_ADDRESSMODE_TYPE = Enum("D3DVS_ADDRESSMODE_TYPE", (
+ "D3DVS_ADDRMODE_ABSOLUTE",
+ "D3DVS_ADDRMODE_RELATIVE",
+ "D3DVS_ADDRMODE_FORCE_DWORD",
+))
+
+D3DVS = Flags(DWORD, (
+ "D3DVS_X_X",
+ "D3DVS_X_Y",
+ "D3DVS_X_Z",
+ "D3DVS_X_W",
+ "D3DVS_Y_X",
+ "D3DVS_Y_Y",
+ "D3DVS_Y_Z",
+ "D3DVS_Y_W",
+ "D3DVS_Z_X",
+ "D3DVS_Z_Y",
+ "D3DVS_Z_Z",
+ "D3DVS_Z_W",
+ "D3DVS_W_X",
+ "D3DVS_W_Y",
+ "D3DVS_W_Z",
+ "D3DVS_W_W",
+ "D3DVS_NOSWIZZLE",
+))
+
+D3DSP = Flags(DWORD, (
+ "D3DSP_NOSWIZZLE",
+ "D3DSP_REPLICATERED",
+ "D3DSP_REPLICATEGREEN",
+ "D3DSP_REPLICATEBLUE",
+ "D3DSP_REPLICATEALPHA",
+))
+
+D3DSHADER_PARAM_SRCMOD_TYPE = Enum("D3DSHADER_PARAM_SRCMOD_TYPE", (
+ "D3DSPSM_NONE",
+ "D3DSPSM_NEG",
+ "D3DSPSM_BIAS",
+ "D3DSPSM_BIASNEG",
+ "D3DSPSM_SIGN",
+ "D3DSPSM_SIGNNEG",
+ "D3DSPSM_COMP",
+ "D3DSPSM_X2",
+ "D3DSPSM_X2NEG",
+ "D3DSPSM_DZ",
+ "D3DSPSM_DW",
+ "D3DSPSM_FORCE_DWORD",
+))
+
+D3DBASISTYPE = Enum("D3DBASISTYPE", (
+ "D3DBASIS_BEZIER",
+ "D3DBASIS_BSPLINE",
+ "D3DBASIS_INTERPOLATE",
+ "D3DBASIS_FORCE_DWORD",
+))
+
+D3DORDERTYPE = Enum("D3DORDERTYPE", (
+ "D3DORDER_LINEAR",
+ "D3DORDER_QUADRATIC",
+ "D3DORDER_CUBIC",
+ "D3DORDER_QUINTIC",
+ "D3DORDER_FORCE_DWORD",
+))
+
+D3DPATCHEDGESTYLE = Enum("D3DPATCHEDGESTYLE", (
+ "D3DPATCHEDGE_DISCRETE",
+ "D3DPATCHEDGE_CONTINUOUS",
+ "D3DPATCHEDGE_FORCE_DWORD",
+))
+
+D3DSTATEBLOCKTYPE = Enum("D3DSTATEBLOCKTYPE", (
+ "D3DSBT_ALL",
+ "D3DSBT_PIXELSTATE",
+ "D3DSBT_VERTEXSTATE",
+ "D3DSBT_FORCE_DWORD",
+))
+
+D3DVERTEXBLENDFLAGS = Enum("D3DVERTEXBLENDFLAGS", (
+ "D3DVBF_DISABLE",
+ "D3DVBF_1WEIGHTS",
+ "D3DVBF_2WEIGHTS",
+ "D3DVBF_3WEIGHTS",
+ "D3DVBF_TWEENING",
+ "D3DVBF_0WEIGHTS",
+ "D3DVBF_FORCE_DWORD",
+))
+
+D3DTEXTURETRANSFORMFLAGS = Enum("D3DTEXTURETRANSFORMFLAGS", (
+ "D3DTTFF_DISABLE",
+ "D3DTTFF_COUNT1",
+ "D3DTTFF_COUNT2",
+ "D3DTTFF_COUNT3",
+ "D3DTTFF_COUNT4",
+ "D3DTTFF_PROJECTED",
+ "D3DTTFF_FORCE_DWORD",
+))
+
+D3DDEVTYPE = Enum("D3DDEVTYPE", (
+ "D3DDEVTYPE_HAL",
+ "D3DDEVTYPE_REF",
+ "D3DDEVTYPE_SW",
+ "D3DDEVTYPE_FORCE_DWORD",
+))
+
+D3DMULTISAMPLE_TYPE = Enum("D3DMULTISAMPLE_TYPE", (
+ "D3DMULTISAMPLE_NONE",
+ "D3DMULTISAMPLE_2_SAMPLES",
+ "D3DMULTISAMPLE_3_SAMPLES",
+ "D3DMULTISAMPLE_4_SAMPLES",
+ "D3DMULTISAMPLE_5_SAMPLES",
+ "D3DMULTISAMPLE_6_SAMPLES",
+ "D3DMULTISAMPLE_7_SAMPLES",
+ "D3DMULTISAMPLE_8_SAMPLES",
+ "D3DMULTISAMPLE_9_SAMPLES",
+ "D3DMULTISAMPLE_10_SAMPLES",
+ "D3DMULTISAMPLE_11_SAMPLES",
+ "D3DMULTISAMPLE_12_SAMPLES",
+ "D3DMULTISAMPLE_13_SAMPLES",
+ "D3DMULTISAMPLE_14_SAMPLES",
+ "D3DMULTISAMPLE_15_SAMPLES",
+ "D3DMULTISAMPLE_16_SAMPLES",
+ "D3DMULTISAMPLE_FORCE_DWORD",
+))
+
+D3DFORMAT = Enum("D3DFORMAT", (
+ "D3DFMT_UNKNOWN",
+ "D3DFMT_R8G8B8",
+ "D3DFMT_A8R8G8B8",
+ "D3DFMT_X8R8G8B8",
+ "D3DFMT_R5G6B5",
+ "D3DFMT_X1R5G5B5",
+ "D3DFMT_A1R5G5B5",
+ "D3DFMT_A4R4G4B4",
+ "D3DFMT_R3G3B2",
+ "D3DFMT_A8",
+ "D3DFMT_A8R3G3B2",
+ "D3DFMT_X4R4G4B4",
+ "D3DFMT_A2B10G10R10",
+ "D3DFMT_G16R16",
+ "D3DFMT_A8P8",
+ "D3DFMT_P8",
+ "D3DFMT_L8",
+ "D3DFMT_A8L8",
+ "D3DFMT_A4L4",
+ "D3DFMT_V8U8",
+ "D3DFMT_L6V5U5",
+ "D3DFMT_X8L8V8U8",
+ "D3DFMT_Q8W8V8U8",
+ "D3DFMT_V16U16",
+ "D3DFMT_W11V11U10",
+ "D3DFMT_A2W10V10U10",
+ "D3DFMT_UYVY",
+ "D3DFMT_YUY2",
+ "D3DFMT_DXT1",
+ "D3DFMT_DXT2",
+ "D3DFMT_DXT3",
+ "D3DFMT_DXT4",
+ "D3DFMT_DXT5",
+ "D3DFMT_D16_LOCKABLE",
+ "D3DFMT_D32",
+ "D3DFMT_D15S1",
+ "D3DFMT_D24S8",
+ "D3DFMT_D16",
+ "D3DFMT_D24X8",
+ "D3DFMT_D24X4S4",
+ "D3DFMT_VERTEXDATA",
+ "D3DFMT_INDEX16",
+ "D3DFMT_INDEX32",
+ "D3DFMT_FORCE_DWORD",
+))
+
+D3DDISPLAYMODE = Struct("D3DDISPLAYMODE", (
+ (UINT, "Width"),
+ (UINT, "Height"),
+ (UINT, "RefreshRate"),
+ (D3DFORMAT, "Format"),
+))
+
+D3DDEVICE_CREATION_PARAMETERS = Struct("D3DDEVICE_CREATION_PARAMETERS", (
+ (UINT, "AdapterOrdinal"),
+ (D3DDEVTYPE, "DeviceType"),
+ (HWND, "hFocusWindow"),
+ (DWORD, "BehaviorFlags"),
+))
+
+D3DSWAPEFFECT = Enum("D3DSWAPEFFECT", (
+ "D3DSWAPEFFECT_DISCARD",
+ "D3DSWAPEFFECT_FLIP",
+ "D3DSWAPEFFECT_COPY",
+ "D3DSWAPEFFECT_COPY_VSYNC",
+ "D3DSWAPEFFECT_FORCE_DWORD",
+))
+
+D3DPOOL = Enum("D3DPOOL", (
+ "D3DPOOL_DEFAULT",
+ "D3DPOOL_MANAGED",
+ "D3DPOOL_SYSTEMMEM",
+ "D3DPOOL_SCRATCH",
+ "D3DPOOL_FORCE_DWORD",
+))
+
+D3DPRESENT = Flags(DWORD, (
+ "D3DPRESENT_RATE_DEFAULT",
+ "D3DPRESENT_RATE_UNLIMITED",
+))
+
+D3DPRESENT_PARAMETERS = Struct("D3DPRESENT_PARAMETERS", (
+ (UINT, "BackBufferWidth"),
+ (UINT, "BackBufferHeight"),
+ (D3DFORMAT, "BackBufferFormat"),
+ (UINT, "BackBufferCount"),
+ (D3DMULTISAMPLE_TYPE, "MultiSampleType"),
+ (D3DSWAPEFFECT, "SwapEffect"),
+ (HWND, "hDeviceWindow"),
+ (BOOL, "Windowed"),
+ (BOOL, "EnableAutoDepthStencil"),
+ (D3DFORMAT, "AutoDepthStencilFormat"),
+ (DWORD, "Flags"),
+ (UINT, "FullScreen_RefreshRateInHz"),
+ (UINT, "FullScreen_PresentationInterval"),
+
+))
+
+D3DPRESENTFLAG = Flags(DWORD, (
+ "D3DPRESENTFLAG_LOCKABLE_BACKBUFFER",
+))
+
+D3DGAMMARAMP = Struct("D3DGAMMARAMP", (
+ (WORD, "red[256]"),
+ (WORD, "green[256]"),
+ (WORD, "blue[256]"),
+))
+
+D3DBACKBUFFER_TYPE = Enum("D3DBACKBUFFER_TYPE", (
+ "D3DBACKBUFFER_TYPE_MONO",
+ "D3DBACKBUFFER_TYPE_LEFT",
+ "D3DBACKBUFFER_TYPE_RIGHT",
+
+ "D3DBACKBUFFER_TYPE_FORCE_DWORD",
+))
+
+D3DRESOURCETYPE = Enum("D3DRESOURCETYPE", (
+ "D3DRTYPE_SURFACE",
+ "D3DRTYPE_VOLUME",
+ "D3DRTYPE_TEXTURE",
+ "D3DRTYPE_VOLUMETEXTURE",
+ "D3DRTYPE_CUBETEXTURE",
+ "D3DRTYPE_VERTEXBUFFER",
+ "D3DRTYPE_INDEXBUFFER",
+ "D3DRTYPE_FORCE_DWORD",
+))
+
+D3DUSAGE = Flags(DWORD, (
+ "D3DUSAGE_RENDERTARGET",
+ "D3DUSAGE_DEPTHSTENCIL",
+ "D3DUSAGE_WRITEONLY",
+ "D3DUSAGE_SOFTWAREPROCESSING",
+ "D3DUSAGE_DONOTCLIP",
+ "D3DUSAGE_POINTS",
+ "D3DUSAGE_RTPATCHES",
+ "D3DUSAGE_NPATCHES",
+ "D3DUSAGE_DYNAMIC",
+))
+
+D3DCUBEMAP_FACES = Enum("D3DCUBEMAP_FACES", (
+ "D3DCUBEMAP_FACE_POSITIVE_X",
+ "D3DCUBEMAP_FACE_NEGATIVE_X",
+ "D3DCUBEMAP_FACE_POSITIVE_Y",
+ "D3DCUBEMAP_FACE_NEGATIVE_Y",
+ "D3DCUBEMAP_FACE_POSITIVE_Z",
+ "D3DCUBEMAP_FACE_NEGATIVE_Z",
+ "D3DCUBEMAP_FACE_FORCE_DWORD",
+))
+
+D3DLOCK = Flags(DWORD, (
+ "D3DLOCK_READONLY",
+ "D3DLOCK_DISCARD",
+ "D3DLOCK_NOOVERWRITE",
+ "D3DLOCK_NOSYSLOCK",
+ "D3DLOCK_NO_DIRTY_UPDATE",
+))
+
+D3DVERTEXBUFFER_DESC = Struct("D3DVERTEXBUFFER_DESC", (
+ (D3DFORMAT, "Format"),
+ (D3DRESOURCETYPE, "Type"),
+ (DWORD, "Usage"),
+ (D3DPOOL, "Pool"),
+ (UINT, "Size"),
+ (DWORD, "FVF"),
+))
+
+D3DINDEXBUFFER_DESC = Struct("D3DINDEXBUFFER_DESC", (
+ (D3DFORMAT, "Format"),
+ (D3DRESOURCETYPE, "Type"),
+ (DWORD, "Usage"),
+ (D3DPOOL, "Pool"),
+ (UINT, "Size"),
+))
+
+D3DSURFACE_DESC = Struct("D3DSURFACE_DESC", (
+ (D3DFORMAT, "Format"),
+ (D3DRESOURCETYPE, "Type"),
+ (DWORD, "Usage"),
+ (D3DPOOL, "Pool"),
+ (UINT, "Size"),
+ (D3DMULTISAMPLE_TYPE, "MultiSampleType"),
+ (UINT, "Width"),
+ (UINT, "Height"),
+))
+
+D3DVOLUME_DESC = Struct("D3DVOLUME_DESC", (
+ (D3DFORMAT, "Format"),
+ (D3DRESOURCETYPE, "Type"),
+ (DWORD, "Usage"),
+ (D3DPOOL, "Pool"),
+ (UINT, "Size"),
+ (UINT, "Width"),
+ (UINT, "Height"),
+ (UINT, "Depth"),
+))
+
+D3DLOCKED_RECT = Struct("D3DLOCKED_RECT", (
+ (INT, "Pitch"),
+ (PVOID, "pBits"),
+))
+
+D3DBOX = Struct("D3DBOX", (
+ (UINT, "Left"),
+ (UINT, "Top"),
+ (UINT, "Right"),
+ (UINT, "Bottom"),
+ (UINT, "Front"),
+ (UINT, "Back"),
+))
+
+D3DLOCKED_BOX = Struct("D3DLOCKED_BOX", (
+ (INT, "RowPitch"),
+ (INT, "SlicePitch"),
+ (PVOID, "pBits"),
+))
+
+D3DRANGE = Struct("D3DRANGE", (
+ (UINT, "Offset"),
+ (UINT, "Size"),
+))
+
+D3DRECTPATCH_INFO = Struct("D3DRECTPATCH_INFO", (
+ (UINT, "StartVertexOffsetWidth"),
+ (UINT, "StartVertexOffsetHeight"),
+ (UINT, "Width"),
+ (UINT, "Height"),
+ (UINT, "Stride"),
+ (D3DBASISTYPE, "Basis"),
+ (D3DORDERTYPE, "Order"),
+))
+
+D3DTRIPATCH_INFO = Struct("D3DTRIPATCH_INFO", (
+ (UINT, "StartVertexOffset"),
+ (UINT, "NumVertices"),
+ (D3DBASISTYPE, "Basis"),
+ (D3DORDERTYPE, "Order"),
+))
+
+D3DADAPTER_IDENTIFIER8 = Struct("D3DADAPTER_IDENTIFIER8", (
+ (String, "Driver"),
+ (String, "Description"),
+ (LARGE_INTEGER, "DriverVersion"),
+ (DWORD, "DriverVersionLowPart"),
+ (DWORD, "DriverVersionHighPart"),
+ (DWORD, "VendorId"),
+ (DWORD, "DeviceId"),
+ (DWORD, "SubSysId"),
+ (DWORD, "Revision"),
+ (GUID, "DeviceIdentifier"),
+ (DWORD, "WHQLLevel"),
+))
+
+D3DRASTER_STATUS = Struct("D3DRASTER_STATUS", (
+ (BOOL, "InVBlank"),
+ (UINT, "ScanLine"),
+))
+
+D3DDEBUGMONITORTOKENS = Enum("D3DDEBUGMONITORTOKENS", (
+ "D3DDMT_ENABLE",
+ "D3DDMT_DISABLE",
+ "D3DDMT_FORCE_DWORD",
+))
+
+D3DDEVINFOID = Flags(DWORD, (
+ "D3DDEVINFOID_RESOURCEMANAGER",
+ "D3DDEVINFOID_VERTEXSTATS",
+))
+
+D3DRESOURCESTATS = Struct("D3DRESOURCESTATS", (
+ (BOOL, "bThrashing"),
+ (DWORD, "ApproxBytesDownloaded"),
+ (DWORD, "NumEvicts"),
+ (DWORD, "NumVidCreates"),
+ (DWORD, "LastPri"),
+ (DWORD, "NumUsed"),
+ (DWORD, "NumUsedInVidMem"),
+ (DWORD, "WorkingSet"),
+ (DWORD, "WorkingSetBytes"),
+ (DWORD, "TotalManaged"),
+ (DWORD, "TotalBytes"),
+))
+
+D3DDEVINFO_RESOURCEMANAGER = Struct("D3DDEVINFO_RESOURCEMANAGER", (
+ (D3DRESOURCESTATS, "stats[D3DRTYPECOUNT]"),
+))
+
+D3DDEVINFO_D3DVERTEXSTATS = Struct("D3DDEVINFO_D3DVERTEXSTATS", (
+ (DWORD, "NumRenderedTriangles"),
+ (DWORD, "NumExtraClippingTriangles"),
+))
+
--- /dev/null
+
+#ifndef _LOG_HPP_
+#define _LOG_HPP_
+
+#include <stdio.h>
+#include <stdlib.h>
+
+
+class Log
+{
+public:
+ Log(const char *name) {
+ char fileName[_MAX_PATH];
+ _snprintf(fileName, _MAX_PATH, "%s.%u.xml", name, rand());
+ file = fopen(fileName, "wt");
+ Write("<?xml version='1.0' encoding='UTF-8'?>\n");
+ Write("<?xml-stylesheet type='text/xsl' href='d3dtrace.xsl'?>\n");
+ Write("<trace>\n");
+ }
+
+ ~Log() {
+ Write("</trace>\n");
+ fclose(file);
+ }
+
+ void NewLine(void) {
+ Write("\n");
+ }
+
+ void Tag(const char *name) {
+ Write("<");
+ Write(name);
+ Write("/>");
+ }
+
+ void BeginTag(const char *name) {
+ Write("<");
+ Write(name);
+ Write(">");
+ }
+
+ void BeginTag(const char *name,
+ const char *attr1, const char *value1) {
+ Write("<");
+ Write(name);
+ Write(" ");
+ Write(attr1);
+ Write("=\"");
+ Escape(value1);
+ Write("\">");
+ }
+
+ void BeginTag(const char *name,
+ const char *attr1, const char *value1,
+ const char *attr2, const char *value2) {
+ Write("<");
+ Write(name);
+ Write(" ");
+ Write(attr1);
+ Write("=\"");
+ Escape(value1);
+ Write("\" ");
+ Write(attr2);
+ Write("=\"");
+ Escape(value2);
+ Write("\">");
+ }
+
+ void EndTag(const char *name) {
+ Write("</");
+ Write(name);
+ Write(">");
+ }
+
+ void Text(const char *text) {
+ Escape(text);
+ }
+
+ void TextF(const char *format, ...) {
+ va_list ap;
+ va_start(ap, format);
+ vfprintf(file, format, ap);
+ va_end(ap);
+ }
+
+ void BeginCall(const char *function) {
+ Write("\t");
+ BeginTag("call", "name", function);
+ NewLine();
+ }
+
+ void EndCall(void) {
+ Write("\t");
+ EndTag("call");
+ NewLine();
+ }
+
+ void BeginParam(const char *type, const char *name) {
+ Write("\t\t");
+ BeginTag("param", "type", type, "name", name);
+ }
+
+ void EndParam(void) {
+ EndTag("param");
+ NewLine();
+ }
+
+ void BeginReturn(const char *type, const char *name) {
+ Write("\t\t");
+ BeginTag("return", "type", type);
+ }
+
+ void EndReturn(void) {
+ EndTag("return");
+ NewLine();
+ }
+
+protected:
+ void Escape(const char *s) {
+ /* FIXME */
+ Write(s);
+ }
+
+ void Write(const char *s) {
+ fputs(s, file);
+ }
+
+ void WriteF(const char *f, ...) {
+ va_list ap;
+ va_start(ap, f);
+ vfprintf(file, f, ap);
+ va_end(ap);
+ }
+
+private:
+ FILE *file;
+};
+
+
+#endif /* _LOG_HPP_ */
--- /dev/null
+"""windows.h"""
+
+from base import *
+
+INT = Intrinsic("INT", "%u")
+UINT = Intrinsic("UINT", "%u")
+LONG = Intrinsic("LONG", "%li")
+ULONG = Intrinsic("ULONG", "%lu")
+
+BYTE = Intrinsic("BYTE", "0x%02lu")
+WORD = Intrinsic("WORD", "0x%04lu")
+DWORD = Intrinsic("DWORD", "0x%08lu")
+
+BOOL = Intrinsic("BOOL", "%i")
+
+LARGE_INTEGER = Intrinsic("LARGE_INTEGER", "0x%x")
+
+HRESULT = Alias("HRESULT", Int)
+
+PVOID = Intrinsic("PVOID", "%p")
+HWND = Intrinsic("HWND", "%p")
+HMONITOR = Intrinsic("HMONITOR", "%p")
+
+REFIID = Alias("REFIID", PVOID)
+GUID = Alias("GUID", PVOID)
+
+POINT = Struct("POINT", (
+ (LONG, "x"),
+ (LONG, "y"),
+))
+
+RECT = Struct("RECT", (
+ (LONG, "left"),
+ (LONG, "top"),
+ (LONG, "right"),
+ (LONG, "bottom"),
+))
+
+PALETTEENTRY = Struct("PALETTEENTRY", (
+ (BYTE, "peRed"),
+ (BYTE, "peGreen"),
+ (BYTE, "peBlue"),
+ (BYTE, "peFlags"),
+))
+
+RGNDATA = Struct("RGNDATA", ())
+REFGUID = Alias("REFGUID", PVOID)
+
+
+IUnknown = Interface("IUnknown")
+
+IUnknown.methods = (
+ Method(HRESULT, "QueryInterface", ((REFIID, "riid"), (Pointer(Pointer(Void)), "ppvObj"))),
+ Method(ULONG, "AddRef", ()),
+ Method(ULONG, "Release", ()),
+)
+
+
+class Dll:
+
+ def __init__(self, name):
+ self.name = name
+ self.functions = []
+ if self not in towrap:
+ towrap.append(self)
+
+ def wrap_name(self):
+ return "Wrap" + self.name
+
+ def wrap_pre_decl(self):
+ pass
+
+ def wrap_decl(self):
+ print '#pragma data_seg (".%s_shared")' % self.name
+ print 'static HINSTANCE g_hDll = NULL;'
+ print 'static Log * g_pLog = NULL;'
+ print '#pragma data_seg ()'
+ print
+ print 'BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved);'
+ print
+
+ def wrap_impl(self):
+ print r'BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) {'
+ print r' TCHAR fileName[MAX_PATH];'
+ print r' switch(fdwReason) {'
+ print r' case DLL_PROCESS_ATTACH:'
+ print r' if(!GetSystemDirectory(fileName, MAX_PATH))'
+ print r' return FALSE;'
+ print r' _tcscat(fileName, TEXT("\\%s.dll"));' % self.name
+ print r' if(!g_hDll)'
+ print r' g_hDll = LoadLibrary(fileName);'
+ print r' if(!g_hDll)'
+ print r' return FALSE;'
+ print r' if(!g_pLog)'
+ print r' g_pLog = new Log("%s");' % self.name
+ print r' return TRUE;'
+ print r' case DLL_PROCESS_DETACH:'
+ print r' if(g_pLog)'
+ print r' delete g_pLog;'
+ print r' if(g_hDll)'
+ print r' FreeLibrary(g_hDll);'
+ print r' return TRUE;'
+ print r' case DLL_THREAD_ATTACH:'
+ print r' return TRUE;'
+ print r' case DLL_THREAD_DETACH:'
+ print r' return TRUE;'
+ print r' }'
+ print r' (void)lpvReserved;'
+ print r' return TRUE;'
+ print r'}'
+ print
+ for function in self.functions:
+ type = 'P' + function.name
+ print function.prototype() + ' {'
+ print ' typedef ' + function.prototype('* %s' % type) + ';'
+ print ' %s pFunction;' % type
+ if function.type is Void:
+ result = ''
+ else:
+ print ' %s result;' % function.type
+ result = 'result = '
+ print ' pFunction = (%s)GetProcAddress( g_hDll, "%s");' % (type, function.name)
+ print ' if(!pFunction)'
+ print ' ExitProcess(0);'
+ print ' g_pLog->BeginCall("%s");' % (function.name)
+ print ' %spFunction(%s);' % (result, ', '.join([str(name) for type, name in function.args]))
+ for type, name in function.args:
+ if type.isoutput():
+ type.wrap_instance(name)
+ if function.type is not Void:
+ function.type.wrap_instance('result')
+ print ' g_pLog->EndCall();'
+ if function.type is not Void:
+ print ' return result;'
+ print '}'
+ print
+ print
+
projects / apitrace / commitdiff