From d626cf4a3e36132332a94ddf2e5762bd29ed6553 Mon Sep 17 00:00:00 2001 From: =?utf8?q?Jos=C3=A9=20Fonseca?= Date: Mon, 7 Jul 2008 07:43:16 +0900 Subject: [PATCH] Autogenerate d3d8.dll wrapper. --- .gitignore | 9 +- SConstruct | 21 +- base.py | 238 +++++++++ common/SConscript | 2 - common/log.hpp | 115 ---- d3d8/d3d8.def => d3d8.def | 0 d3d8.py | 239 +++++++++ d3d8/SConscript | 11 - d3d8/dllmain.cpp | 90 ---- d3d8/idirect3d8.cpp | 102 ---- d3d8/idirect3d8.hpp | 34 -- d3d8/idirect3d_device8.cpp | 433 --------------- d3d8/idirect3d_device8.hpp | 121 ----- d3d8/stdafx.h | 11 - d3d8caps.py | 287 ++++++++++ d3d8types.py | 1034 ++++++++++++++++++++++++++++++++++++ log.hpp | 140 +++++ windows.py | 138 +++++ 18 files changed, 2101 insertions(+), 924 deletions(-) create mode 100644 base.py delete mode 100644 common/SConscript delete mode 100644 common/log.hpp rename d3d8/d3d8.def => d3d8.def (100%) create mode 100755 d3d8.py delete mode 100644 d3d8/SConscript delete mode 100644 d3d8/dllmain.cpp delete mode 100644 d3d8/idirect3d8.cpp delete mode 100644 d3d8/idirect3d8.hpp delete mode 100644 d3d8/idirect3d_device8.cpp delete mode 100644 d3d8/idirect3d_device8.hpp delete mode 100644 d3d8/stdafx.h create mode 100644 d3d8caps.py create mode 100644 d3d8types.py create mode 100644 log.hpp create mode 100644 windows.py diff --git a/.gitignore b/.gitignore index 55aae42..1a01d5b 100644 --- a/.gitignore +++ b/.gitignore @@ -1,7 +1,12 @@ .*.sw? .scons* -*.obj *.dll -*.lib *.exp +*.ilk +*.lib +*.obj +*.pdb +*.pyc +*.pyo *.xml +d3d8.cpp diff --git a/SConstruct b/SConstruct index 45585b2..52c6f32 100644 --- a/SConstruct +++ b/SConstruct @@ -46,7 +46,7 @@ if env['debug']: env.Append(CPPDEFINES = ['_DEBUG']) else: env.Append(CPPDEFINES = ['NDEBUG']) -#env['PDB'] = '${TARGET.base}.pdb' +env['PDB'] = '${TARGET.base}.pdb' cflags = [ '/W3', # warning level @@ -82,8 +82,23 @@ env.Append(CPPPATH = [ 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', ]) diff --git a/base.py b/base.py new file mode 100644 index 0000000..dc0be29 --- /dev/null +++ b/base.py @@ -0,0 +1,238 @@ +"""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 diff --git a/common/SConscript b/common/SConscript deleted file mode 100644 index 34525ce..0000000 --- a/common/SConscript +++ /dev/null @@ -1,2 +0,0 @@ -Import('env') - diff --git a/common/log.hpp b/common/log.hpp deleted file mode 100644 index e150072..0000000 --- a/common/log.hpp +++ /dev/null @@ -1,115 +0,0 @@ - -#ifndef LOG_HPP_ -#define LOG_HPP_ - -#include - -#include - -#include - - -class Log -{ -public: - Log(const char *filename) { - file = fopen(filename, "wt"); - write("\n"); - write("\n"); - write("\n"); - } - - ~Log() { - write("\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(""); - } - - 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_ */ diff --git a/d3d8/d3d8.def b/d3d8.def similarity index 100% rename from d3d8/d3d8.def rename to d3d8.def diff --git a/d3d8.py b/d3d8.py new file mode 100755 index 0000000..a125ad4 --- /dev/null +++ b/d3d8.py @@ -0,0 +1,239 @@ +"""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 ' + print '#include ' + print '#include ' + print + print '#include "log.hpp"' + print + wrap() + diff --git a/d3d8/SConscript b/d3d8/SConscript deleted file mode 100644 index b011c37..0000000 --- a/d3d8/SConscript +++ /dev/null @@ -1,11 +0,0 @@ -Import('env') - -env.SharedLibrary( - target = 'd3d8.dll', - source = [ - 'd3d8.def', - 'dllmain.cpp', - 'idirect3d8.cpp', - 'idirect3d_device8.cpp', - ] -) diff --git a/d3d8/dllmain.cpp b/d3d8/dllmain.cpp deleted file mode 100644 index d1c2efb..0000000 --- a/d3d8/dllmain.cpp +++ /dev/null @@ -1,90 +0,0 @@ -// 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); -} diff --git a/d3d8/idirect3d8.cpp b/d3d8/idirect3d8.cpp deleted file mode 100644 index ceaef09..0000000 --- a/d3d8/idirect3d8.cpp +++ /dev/null @@ -1,102 +0,0 @@ -// 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); -} diff --git a/d3d8/idirect3d8.hpp b/d3d8/idirect3d8.hpp deleted file mode 100644 index 4c5c2e7..0000000 --- a/d3d8/idirect3d8.hpp +++ /dev/null @@ -1,34 +0,0 @@ -// 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; -}; - diff --git a/d3d8/idirect3d_device8.cpp b/d3d8/idirect3d_device8.cpp deleted file mode 100644 index 9783c0d..0000000 --- a/d3d8/idirect3d_device8.cpp +++ /dev/null @@ -1,433 +0,0 @@ -// 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); -} diff --git a/d3d8/idirect3d_device8.hpp b/d3d8/idirect3d_device8.hpp deleted file mode 100644 index 6708460..0000000 --- a/d3d8/idirect3d_device8.hpp +++ /dev/null @@ -1,121 +0,0 @@ -// 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); - -}; - diff --git a/d3d8/stdafx.h b/d3d8/stdafx.h deleted file mode 100644 index b0ddaea..0000000 --- a/d3d8/stdafx.h +++ /dev/null @@ -1,11 +0,0 @@ -// stdafx.h -#pragma once - - -#include -#include - -#include - -#include "idirect3d8.hpp" -#include "idirect3d_device8.hpp" diff --git a/d3d8caps.py b/d3d8caps.py new file mode 100644 index 0000000..454ae0f --- /dev/null +++ b/d3d8caps.py @@ -0,0 +1,287 @@ +"""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"), +)) + diff --git a/d3d8types.py b/d3d8types.py new file mode 100644 index 0000000..8e6d1fa --- /dev/null +++ b/d3d8types.py @@ -0,0 +1,1034 @@ +"""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"), +)) + diff --git a/log.hpp b/log.hpp new file mode 100644 index 0000000..2982a9f --- /dev/null +++ b/log.hpp @@ -0,0 +1,140 @@ + +#ifndef _LOG_HPP_ +#define _LOG_HPP_ + +#include +#include + + +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("\n"); + Write("\n"); + Write("\n"); + } + + ~Log() { + Write("\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(""); + } + + 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_ */ diff --git a/windows.py b/windows.py new file mode 100644 index 0000000..8c7e3a0 --- /dev/null +++ b/windows.py @@ -0,0 +1,138 @@ +"""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 + -- 2.45.2