From: José Fonseca Date: Thu, 7 Jul 2011 09:16:57 +0000 (+0100) Subject: More complete D310 API spec. X-Git-Url: https://git.cworth.org/git?a=commitdiff_plain;h=af7d231ddf7f7fef342782932e85479044de1757;p=apitrace More complete D310 API spec. --- diff --git a/CMakeLists.txt b/CMakeLists.txt index e840f21..82a4a31 100755 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -261,17 +261,17 @@ if (WIN32) endif (DirectX_D3DX9_INCLUDE_DIR) # d3d10.dll - #if (DirectX_D3D10_INCLUDE_DIR) - # include_directories (SYSTEM ${DirectX_D3D10_INCLUDE_DIR}) - # add_custom_command ( - # OUTPUT d3d10.cpp - # COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/d3d10misc.py > ${CMAKE_CURRENT_BINARY_DIR}/d3d10.cpp - # DEPENDS d3d10misc.py winapi.py stdapi.py - # ) - # add_library (d3d10 MODULE d3d10.def d3d10.cpp) - # set_target_properties (d3d10 PROPERTIES PREFIX "") - # install (TARGETS d3d10 LIBRARY DESTINATION wrappers) - #endif (DirectX_D3D10_INCLUDE_DIR) + if (DirectX_D3D10_INCLUDE_DIR) + include_directories (SYSTEM ${DirectX_D3D10_INCLUDE_DIR}) + add_custom_command ( + OUTPUT d3d10.cpp + COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/d3d10misc.py > ${CMAKE_CURRENT_BINARY_DIR}/d3d10.cpp + DEPENDS d3d10misc.py d3d10.py winapi.py stdapi.py + ) + add_library (d3d10 MODULE d3d10.def d3d10.cpp) + set_target_properties (d3d10 PROPERTIES PREFIX "") + install (TARGETS d3d10 LIBRARY DESTINATION wrappers) + endif (DirectX_D3D10_INCLUDE_DIR) # opengl32.dll add_custom_command ( diff --git a/apigen/cdecl.py b/apigen/cdecl.py index 0ef10d3..3cecaec 100755 --- a/apigen/cdecl.py +++ b/apigen/cdecl.py @@ -47,16 +47,13 @@ class Parser: def has_side_effects(self, name): return True - def parse(self, s): + + def tokenize(self, s): s = self.multi_comment_re.sub('', s) s = self.single_comment_re.sub('', s) self.tokens = self.token_re.split(s) self.tokens = [token for token in self.tokens if self.filter_token(token)] - while self.tokens: - #print self.tokens[0:10] - self.parse_declaration() - def filter_token(self, token): if not token or token.isspace(): return False @@ -66,102 +63,214 @@ class Parser: return False return True + def lookahead(self, index = 0): + try: + return self.tokens[index] + except KeyError: + return None + + def match(self, *ref_tokens): + return self.lookahead() in ref_tokens + + def consume(self, *ref_tokens): + if not self.tokens: + raise Exception('unexpected EOF') + token = self.tokens.pop(0) + if ref_tokens and token not in ref_tokens: + raise Exception('token mismatch', token, ref_tokens) + return token + + def eof(self): + return not self.tokens + + + def parse(self, s): + self.tokenize(s) + + while not self.eof(): + #print self.tokens[0:10] + self.parse_declaration() + def parse_declaration(self): - if self.tokens[0] == 'mask': + self.parse_tags() + if self.match('enum'): + self.parse_enum() + elif self.match('interface'): + self.parse_interface() + elif self.match('mask'): self.parse_value('mask', 'Flags') - elif self.tokens[0] == 'value': + elif self.match('struct'): + self.parse_struct() + elif self.match('value'): self.parse_value('value', 'FakeEnum') - elif self.tokens[0] == 'interface': - self.parse_interface() + elif self.match('typedef'): + self.parse_typedef() else: self.parse_prototype() + if not self.eof() and self.match(';'): + self.consume(';') + + def parse_typedef(self): + self.consume('typedef') + if self.lookahead(2) in (';', ','): + base_type = self.consume() + while True: + type = base_type + if self.match('*'): + self.consume() + type = 'Pointer(%s)' % type + name = self.consume() + print '%s = Alias("%s", %s)' % (name, name, type) + if self.match(','): + self.consume() + else: + break + else: + self.parse_declaration() + self.consume() + + def parse_enum(self): + self.consume('enum') + name = self.consume() + self.consume('{') + + print '%s = Enum("%s", [' % (name, name) + + #value = 0 + while self.lookahead() != '}': + name = self.consume() + if self.match('='): + self.consume('=') + value = self.consume() + if self.match(','): + self.consume(',') + tags = self.parse_tags() + #print ' "%s",\t# %s' % (name, value) + print ' "%s",' % (name,) + #value += 1 + self.consume('}') + + print '])' + print def parse_value(self, ref_token, constructor): - self.match(ref_token) - type = self.tokens.pop(0) - name = self.tokens.pop(0) - self.match('{') + self.consume(ref_token) + type = self.consume() + name = self.consume() + self.consume('{') print '%s = %s(%s, [' % (name, constructor, type) - while self.tokens[0] != '}': - self.match('#') - self.match('define') - name = self.tokens.pop(0) - value = self.tokens.pop(0) - tag = self.parse_tag() + while self.lookahead() != '}': + self.consume('#') + self.consume('define') + name = self.consume() + value = self.consume() #print ' "%s",\t# %s' % (name, value) print ' "%s",' % (name,) - self.match('}') - self.match(';') + self.consume('}') + + print '])' + print + + def parse_struct(self): + self.consume('struct') + name = self.consume() + self.consume('{') + + print '%s = Struct("%s", [' % (name, name) + + value = 0 + while self.lookahead() != '}': + type, name = self.parse_named_type() + if self.match(','): + self.consume(',') + self.consume(';') + print ' (%s, "%s"),' % (type, name) + value += 1 + self.consume('}') print '])' print def parse_interface(self): - self.match('interface') - name = self.tokens.pop(0) - self.match(':') - base = self.tokens.pop(0) - self.match('{') + self.consume('interface') + name = self.consume() + if self.match(';'): + return + self.consume(':') + base = self.consume() + self.consume('{') print '%s = Interface("%s", %s)' % (name, name, base) print '%s.methods += [' % (name,) - while self.tokens[0] != '}': + while self.lookahead() != '}': self.parse_prototype('Method') - self.match('}') - self.match(';') + self.consume(';') + self.consume('}') print ']' print def parse_prototype(self, creator = 'Function'): - if self.tokens[0] == 'extern': - self.tokens.pop(0) + if self.match('extern'): + self.consume() ret = self.parse_type() - name = self.tokens.pop(0) + if self.match('__stdcall'): + self.consume() + creator = 'StdFunction' + + name = self.consume() extra = '' if not self.has_side_effects(name): extra += ', sideeffects=False' name = name - self.match('(') + self.consume('(') args = [] - if self.tokens[0] == 'void' and self.tokens[1] == ')': - self.tokens.pop(0) - while self.tokens[0] != ')': + if self.match('void') and self.tokens[1] == ')': + self.consume() + while self.lookahead() != ')': arg = self.parse_arg() args.append(arg) - if self.tokens[0] == ',': - self.tokens.pop(0) - self.tokens.pop(0) == ')' + if self.match(','): + self.consume() + self.consume() == ')' - if self.tokens and self.tokens[0] == ';': - self.tokens.pop(0) - print ' %s(%s, "%s", [%s]%s),' % (creator, ret, name, ', '.join(args), extra) def parse_arg(self): - tag = self.parse_tag() + tags = self.parse_tags() - type = self.parse_type() - name = self.tokens.pop(0) + type, name = self.parse_named_type() arg = '(%s, "%s")' % (type, name) - if tag == 'out': + if 'out' in tags: arg = 'Out' + arg return arg - def parse_tag(self): - tag = None - if self.tokens[0] == '[': - self.tokens.pop(0) - tag = self.tokens.pop(0) - self.match(']') - return tag + def parse_tags(self): + tags = [] + if self.match('['): + self.consume() + while not self.match(']'): + tag = self.consume() + tags.append(tag) + self.consume(']') + return tags + + def parse_named_type(self): + type = self.parse_type() + name = self.consume() + if self.match('['): + self.consume() + length = self.consume() + self.consume(']') + type = 'Array(%s, "%s")' % (type, length) + return type, name int_tokens = ('unsigned', 'signed', 'int', 'long', 'short', 'char') @@ -179,7 +288,7 @@ class Parser: } def parse_type(self): - token = self.tokens.pop(0) + token = self.consume() if token == 'const': return 'Const(%s)' % self.parse_type() if token == 'void': @@ -201,8 +310,8 @@ class Parser: short += 1 if token == 'char': char = False - if self.tokens[0] in self.int_tokens: - token = self.tokens.pop(0) + if self.lookahead() in self.int_tokens: + token = self.consume() else: token = None if char: @@ -219,17 +328,17 @@ class Parser: type = 'U' + type else: type = self.type_table.get(token, token) - while self.tokens[0] == '*': - type = 'OpaquePointer(%s)' % type - self.tokens.pop(0) + while True: + if self.match('*'): + self.consume('*') + type = 'OpaquePointer(%s)' % type + elif self.match('const'): + self.consume('const') + type = 'Const(%s)' % type + else: + break return type - def match(self, ref_token): - if not self.tokens: - raise Exception('unexpected EOF') - token = self.tokens.pop(0) - if token != ref_token: - raise Exception('token mismatch', token, ref_token) diff --git a/d3d10.py b/d3d10.py new file mode 100644 index 0000000..6728abe --- /dev/null +++ b/d3d10.py @@ -0,0 +1,903 @@ +########################################################################## +# +# Copyright 2011 Jose Fonseca +# All Rights Reserved. +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +##########################################################################/ + +from dxgi import * + +D3D10_BLEND = Enum("D3D10_BLEND", [ + "D3D10_BLEND_ZERO", + "D3D10_BLEND_ONE", + "D3D10_BLEND_SRC_COLOR", + "D3D10_BLEND_INV_SRC_COLOR", + "D3D10_BLEND_SRC_ALPHA", + "D3D10_BLEND_INV_SRC_ALPHA", + "D3D10_BLEND_DEST_ALPHA", + "D3D10_BLEND_INV_DEST_ALPHA", + "D3D10_BLEND_DEST_COLOR", + "D3D10_BLEND_INV_DEST_COLOR", + "D3D10_BLEND_SRC_ALPHA_SAT", + "D3D10_BLEND_BLEND_FACTOR", + "D3D10_BLEND_INV_BLEND_FACTOR", + "D3D10_BLEND_SRC1_COLOR", + "D3D10_BLEND_INV_SRC1_COLOR", + "D3D10_BLEND_SRC1_ALPHA", + "D3D10_BLEND_INV_SRC1_ALPHA", +]) + +D3D10_BLEND_OP = Enum("D3D10_BLEND_OP", [ + "D3D10_BLEND_OP_ADD", + "D3D10_BLEND_OP_SUBTRACT", + "D3D10_BLEND_OP_REV_SUBTRACT", + "D3D10_BLEND_OP_MIN", + "D3D10_BLEND_OP_MAX", +]) + +D3D10_BLEND_DESC = Struct("D3D10_BLEND_DESC", [ + (BOOL, "AlphaToCoverageEnable"), + (Array(BOOL, "8"), "BlendEnable"), + (D3D10_BLEND, "SrcBlend"), + (D3D10_BLEND, "DestBlend"), + (D3D10_BLEND_OP, "BlendOp"), + (D3D10_BLEND, "SrcBlendAlpha"), + (D3D10_BLEND, "DestBlendAlpha"), + (D3D10_BLEND_OP, "BlendOpAlpha"), + (Array(UINT8, "8"), "RenderTargetWriteMask"), +]) + +D3D10_DEPTH_WRITE_MASK = Enum("D3D10_DEPTH_WRITE_MASK", [ + "D3D10_DEPTH_WRITE_MASK_ZERO", + "D3D10_DEPTH_WRITE_MASK_ALL", +]) + +D3D10_COMPARISON_FUNC = Enum("D3D10_COMPARISON_FUNC", [ + "D3D10_COMPARISON_NEVER", + "D3D10_COMPARISON_LESS", + "D3D10_COMPARISON_EQUAL", + "D3D10_COMPARISON_LESS_EQUAL", + "D3D10_COMPARISON_GREATER", + "D3D10_COMPARISON_NOT_EQUAL", + "D3D10_COMPARISON_GREATER_EQUAL", + "D3D10_COMPARISON_ALWAYS", +]) + +D3D10_STENCIL_OP = Enum("D3D10_STENCIL_OP", [ + "D3D10_STENCIL_OP_KEEP", + "D3D10_STENCIL_OP_ZERO", + "D3D10_STENCIL_OP_REPLACE", + "D3D10_STENCIL_OP_INCR_SAT", + "D3D10_STENCIL_OP_DECR_SAT", + "D3D10_STENCIL_OP_INVERT", + "D3D10_STENCIL_OP_INCR", + "D3D10_STENCIL_OP_DECR", +]) + +D3D10_DEPTH_STENCILOP_DESC = Struct("D3D10_DEPTH_STENCILOP_DESC", [ + (D3D10_STENCIL_OP, "StencilFailOp"), + (D3D10_STENCIL_OP, "StencilDepthFailOp"), + (D3D10_STENCIL_OP, "StencilPassOp"), + (D3D10_COMPARISON_FUNC, "StencilFunc"), +]) + +D3D10_DEPTH_STENCIL_DESC = Struct("D3D10_DEPTH_STENCIL_DESC", [ + (BOOL, "DepthEnable"), + (D3D10_DEPTH_WRITE_MASK, "DepthWriteMask"), + (D3D10_COMPARISON_FUNC, "DepthFunc"), + (BOOL, "StencilEnable"), + (UINT8, "StencilReadMask"), + (UINT8, "StencilWriteMask"), + (D3D10_DEPTH_STENCILOP_DESC, "FrontFace"), + (D3D10_DEPTH_STENCILOP_DESC, "BackFace"), +]) + +D3D10_FILL_MODE = Enum("D3D10_FILL_MODE", [ + "D3D10_FILL_WIREFRAME", + "D3D10_FILL_SOLID", +]) + +D3D10_CULL_MODE = Enum("D3D10_CULL_MODE", [ + "D3D10_CULL_NONE", + "D3D10_CULL_FRONT", + "D3D10_CULL_BACK", +]) + +D3D10_RASTERIZER_DESC = Struct("D3D10_RASTERIZER_DESC", [ + (D3D10_FILL_MODE, "FillMode"), + (D3D10_CULL_MODE, "CullMode"), + (BOOL, "FrontCounterClockwise"), + (INT, "DepthBias"), + (FLOAT, "DepthBiasClamp"), + (FLOAT, "SlopeScaledDepthBias"), + (BOOL, "DepthClipEnable"), + (BOOL, "ScissorEnable"), + (BOOL, "MultisampleEnable"), + (BOOL, "AntialiasedLineEnable"), +]) + +D3D10_FILTER = Enum("D3D10_FILTER", [ + "D3D10_FILTER_MIN_MAG_MIP_POINT", + "D3D10_FILTER_MIN_MAG_POINT_MIP_LINEAR", + "D3D10_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT", + "D3D10_FILTER_MIN_POINT_MAG_MIP_LINEAR", + "D3D10_FILTER_MIN_LINEAR_MAG_MIP_POINT", + "D3D10_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR", + "D3D10_FILTER_MIN_MAG_LINEAR_MIP_POINT", + "D3D10_FILTER_MIN_MAG_MIP_LINEAR", + "D3D10_FILTER_ANISOTROPIC", + "D3D10_FILTER_COMPARISON_MIN_MAG_MIP_POINT", + "D3D10_FILTER_COMPARISON_MIN_MAG_POINT_MIP_LINEAR", + "D3D10_FILTER_COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT", + "D3D10_FILTER_COMPARISON_MIN_POINT_MAG_MIP_LINEAR", + "D3D10_FILTER_COMPARISON_MIN_LINEAR_MAG_MIP_POINT", + "D3D10_FILTER_COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR", + "D3D10_FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT", + "D3D10_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR", + "D3D10_FILTER_COMPARISON_ANISOTROPIC", + "D3D10_FILTER_TEXT_1BIT", +]) + +D3D10_TEXTURE_ADDRESS_MODE = Enum("D3D10_TEXTURE_ADDRESS_MODE", [ + "D3D10_TEXTURE_ADDRESS_WRAP", + "D3D10_TEXTURE_ADDRESS_MIRROR", + "D3D10_TEXTURE_ADDRESS_CLAMP", + "D3D10_TEXTURE_ADDRESS_BORDER", + "D3D10_TEXTURE_ADDRESS_MIRROR_ONCE", +]) + +D3D10_SAMPLER_DESC = Struct("D3D10_SAMPLER_DESC", [ + (D3D10_FILTER, "Filter"), + (D3D10_TEXTURE_ADDRESS_MODE, "AddressU"), + (D3D10_TEXTURE_ADDRESS_MODE, "AddressV"), + (D3D10_TEXTURE_ADDRESS_MODE, "AddressW"), + (FLOAT, "MipLODBias"), + (UINT, "MaxAnisotropy"), + (D3D10_COMPARISON_FUNC, "ComparisonFunc"), + (Array(FLOAT, "4"), "BorderColor"), + (FLOAT, "MinLOD"), + (FLOAT, "MaxLOD"), +]) + +D3D10_COUNTER = Enum("D3D10_COUNTER", [ + "D3D10_COUNTER_GPU_IDLE", + "D3D10_COUNTER_VERTEX_PROCESSING", + "D3D10_COUNTER_GEOMETRY_PROCESSING", + "D3D10_COUNTER_PIXEL_PROCESSING", + "D3D10_COUNTER_OTHER_GPU_PROCESSING", + "D3D10_COUNTER_HOST_ADAPTER_BANDWIDTH_UTILIZATION", + "D3D10_COUNTER_LOCAL_VIDMEM_BANDWIDTH_UTILIZATION", + "D3D10_COUNTER_VERTEX_THROUGHPUT_UTILIZATION", + "D3D10_COUNTER_TRIANGLE_SETUP_THROUGHPUT_UTILIZATION", + "D3D10_COUNTER_FILLRATE_THROUGHPUT_UTILIZATION", + "D3D10_COUNTER_VS_MEMORY_LIMITED", + "D3D10_COUNTER_VS_COMPUTATION_LIMITED", + "D3D10_COUNTER_GS_MEMORY_LIMITED", + "D3D10_COUNTER_GS_COMPUTATION_LIMITED", + "D3D10_COUNTER_PS_MEMORY_LIMITED", + "D3D10_COUNTER_PS_COMPUTATION_LIMITED", + "D3D10_COUNTER_POST_TRANSFORM_CACHE_HIT_RATE", + "D3D10_COUNTER_TEXTURE_CACHE_HIT_RATE", + "D3D10_COUNTER_DEVICE_DEPENDENT_0", +]) + +D3D10_COUNTER_DESC = Struct("D3D10_COUNTER_DESC", [ + (D3D10_COUNTER, "Counter"), + (UINT, "MiscFlags"), +]) + +D3D10_COUNTER_TYPE = Enum("D3D10_COUNTER_TYPE", [ + "D3D10_COUNTER_TYPE_FLOAT32", + "D3D10_COUNTER_TYPE_UINT16", + "D3D10_COUNTER_TYPE_UINT32", + "D3D10_COUNTER_TYPE_UINT64", +]) + +D3D10_COUNTER_INFO = Struct("D3D10_COUNTER_INFO", [ + (D3D10_COUNTER, "LastDeviceDependentCounter"), + (UINT, "NumSimultaneousCounters"), + (UINT8, "NumDetectableParallelUnits"), +]) + +D3D10_RESOURCE_DIMENSION = Enum("D3D10_RESOURCE_DIMENSION", [ + "D3D10_RESOURCE_DIMENSION_UNKNOWN", + "D3D10_RESOURCE_DIMENSION_BUFFER", + "D3D10_RESOURCE_DIMENSION_TEXTURE1D", + "D3D10_RESOURCE_DIMENSION_TEXTURE2D", + "D3D10_RESOURCE_DIMENSION_TEXTURE3D", +]) + +D3D10_USAGE = Enum("D3D10_USAGE", [ + "D3D10_USAGE_DEFAULT", + "D3D10_USAGE_IMMUTABLE", + "D3D10_USAGE_DYNAMIC", + "D3D10_USAGE_STAGING", +]) + +D3D10_BIND_FLAG = Enum("D3D10_BIND_FLAG", [ + "D3D10_BIND_VERTEX_BUFFER", + "D3D10_BIND_INDEX_BUFFER", + "D3D10_BIND_CONSTANT_BUFFER", + "D3D10_BIND_SHADER_RESOURCE", + "D3D10_BIND_STREAM_OUTPUT", + "D3D10_BIND_RENDER_TARGET", + "D3D10_BIND_DEPTH_STENCIL", +]) + +D3D10_BUFFER_DESC = Struct("D3D10_BUFFER_DESC", [ + (UINT, "ByteWidth"), + (D3D10_USAGE, "Usage"), + (UINT, "BindFlags"), + (UINT, "CPUAccessFlags"), + (UINT, "MiscFlags"), +]) + +D3D10_MAP = Enum("D3D10_MAP", [ + "D3D10_MAP_READ", + "D3D10_MAP_WRITE", + "D3D10_MAP_READ_WRITE", + "D3D10_MAP_WRITE_DISCARD", + "D3D10_MAP_WRITE_NO_OVERWRITE", +]) + +D3D10_TEXTURE1D_DESC = Struct("D3D10_TEXTURE1D_DESC", [ + (UINT, "Width"), + (UINT, "MipLevels"), + (UINT, "ArraySize"), + (DXGI_FORMAT, "Format"), + (D3D10_USAGE, "Usage"), + (UINT, "BindFlags"), + (UINT, "CPUAccessFlags"), + (UINT, "MiscFlags"), +]) + +D3D10_TEXTURE2D_DESC = Struct("D3D10_TEXTURE2D_DESC", [ + (UINT, "Width"), + (UINT, "Height"), + (UINT, "MipLevels"), + (UINT, "ArraySize"), + (DXGI_FORMAT, "Format"), + (DXGI_SAMPLE_DESC, "SampleDesc"), + (D3D10_USAGE, "Usage"), + (UINT, "BindFlags"), + (UINT, "CPUAccessFlags"), + (UINT, "MiscFlags"), +]) + +D3D10_TEXTURE3D_DESC = Struct("D3D10_TEXTURE3D_DESC", [ + (UINT, "Width"), + (UINT, "Height"), + (UINT, "Depth"), + (UINT, "MipLevels"), + (DXGI_FORMAT, "Format"), + (D3D10_USAGE, "Usage"), + (UINT, "BindFlags"), + (UINT, "CPUAccessFlags"), + (UINT, "MiscFlags"), +]) + +D3D10_DSV_DIMENSION = Enum("D3D10_DSV_DIMENSION", [ + "D3D10_DSV_DIMENSION_UNKNOWN", + "D3D10_DSV_DIMENSION_TEXTURE1D", + "D3D10_DSV_DIMENSION_TEXTURE1DARRAY", + "D3D10_DSV_DIMENSION_TEXTURE2D", + "D3D10_DSV_DIMENSION_TEXTURE2DARRAY", + "D3D10_DSV_DIMENSION_TEXTURE2DMS", + "D3D10_DSV_DIMENSION_TEXTURE2DMSARRAY", +]) + +D3D10_TEX1D_DSV = Struct("D3D10_TEX1D_DSV", [ + (UINT, "MipSlice"), +]) + +D3D10_TEX1D_ARRAY_DSV = Struct("D3D10_TEX1D_ARRAY_DSV", [ + (UINT, "MipSlice"), + (UINT, "FirstArraySlice"), + (UINT, "ArraySize"), +]) + +D3D10_TEX2D_DSV = Struct("D3D10_TEX2D_DSV", [ + (UINT, "MipSlice"), +]) + +D3D10_TEX2D_ARRAY_DSV = Struct("D3D10_TEX2D_ARRAY_DSV", [ + (UINT, "MipSlice"), + (UINT, "FirstArraySlice"), + (UINT, "ArraySize"), +]) + +D3D10_TEX2DMS_DSV = Struct("D3D10_TEX2DMS_DSV", [ + (UINT, "UnusedField_NothingToDefine"), +]) + +D3D10_TEX2DMS_ARRAY_DSV = Struct("D3D10_TEX2DMS_ARRAY_DSV", [ + (UINT, "FirstArraySlice"), + (UINT, "ArraySize"), +]) + +D3D10_DEPTH_STENCIL_VIEW_DESC = Struct("D3D10_DEPTH_STENCIL_VIEW_DESC", [ + (DXGI_FORMAT, "Format"), + (D3D10_DSV_DIMENSION, "ViewDimension"), + (D3D10_TEX1D_DSV, "Texture1D"), + (D3D10_TEX1D_ARRAY_DSV, "Texture1DArray"), + (D3D10_TEX2D_DSV, "Texture2D"), + (D3D10_TEX2D_ARRAY_DSV, "Texture2DArray"), + (D3D10_TEX2DMS_DSV, "Texture2DMS"), + (D3D10_TEX2DMS_ARRAY_DSV, "Texture2DMSArray"), +]) + +D3D10_RTV_DIMENSION = Enum("D3D10_RTV_DIMENSION", [ + "D3D10_RTV_DIMENSION_UNKNOWN", + "D3D10_RTV_DIMENSION_BUFFER", + "D3D10_RTV_DIMENSION_TEXTURE1D", + "D3D10_RTV_DIMENSION_TEXTURE1DARRAY", + "D3D10_RTV_DIMENSION_TEXTURE2D", + "D3D10_RTV_DIMENSION_TEXTURE2DARRAY", + "D3D10_RTV_DIMENSION_TEXTURE2DMS", + "D3D10_RTV_DIMENSION_TEXTURE2DMSARRAY", + "D3D10_RTV_DIMENSION_TEXTURE3D", +]) + +D3D10_BUFFER_RTV = Struct("D3D10_BUFFER_RTV", [ + (UINT, "ElementOffset"), + (UINT, "ElementWidth"), +]) + +D3D10_TEX1D_RTV = Struct("D3D10_TEX1D_RTV", [ + (UINT, "MipSlice"), +]) + +D3D10_TEX1D_ARRAY_RTV = Struct("D3D10_TEX1D_ARRAY_RTV", [ + (UINT, "MipSlice"), + (UINT, "FirstArraySlice"), + (UINT, "ArraySize"), +]) + +D3D10_TEX2D_RTV = Struct("D3D10_TEX2D_RTV", [ + (UINT, "MipSlice"), +]) + +D3D10_TEX2D_ARRAY_RTV = Struct("D3D10_TEX2D_ARRAY_RTV", [ + (UINT, "MipSlice"), + (UINT, "FirstArraySlice"), + (UINT, "ArraySize"), +]) + +D3D10_TEX2DMS_RTV = Struct("D3D10_TEX2DMS_RTV", [ + (UINT, "UnusedField_NothingToDefine"), +]) + +D3D10_TEX2DMS_ARRAY_RTV = Struct("D3D10_TEX2DMS_ARRAY_RTV", [ + (UINT, "FirstArraySlice"), + (UINT, "ArraySize"), +]) + +D3D10_TEX3D_RTV = Struct("D3D10_TEX3D_RTV", [ + (UINT, "MipSlice"), + (UINT, "FirstWSlice"), + (UINT, "WSize"), +]) + +D3D10_RENDER_TARGET_VIEW_DESC = Struct("D3D10_RENDER_TARGET_VIEW_DESC", [ + (DXGI_FORMAT, "Format"), + (D3D10_RTV_DIMENSION, "ViewDimension"), + (D3D10_BUFFER_RTV, "Buffer"), + (D3D10_TEX1D_RTV, "Texture1D"), + (D3D10_TEX1D_ARRAY_RTV, "Texture1DArray"), + (D3D10_TEX2D_RTV, "Texture2D"), + (D3D10_TEX2D_ARRAY_RTV, "Texture2DArray"), + (D3D10_TEX2DMS_RTV, "Texture2DMS"), + (D3D10_TEX2DMS_ARRAY_RTV, "Texture2DMSArray"), + (D3D10_TEX3D_RTV, "Texture3D"), +]) + +D3D10_SRV_DIMENSION = Enum("D3D10_SRV_DIMENSION", [ + "D3D10_SRV_DIMENSION_UNKNOWN", + "D3D10_SRV_DIMENSION_BUFFER", + "D3D10_SRV_DIMENSION_TEXTURE1D", + "D3D10_SRV_DIMENSION_TEXTURE1DARRAY", + "D3D10_SRV_DIMENSION_TEXTURE2D", + "D3D10_SRV_DIMENSION_TEXTURE2DARRAY", + "D3D10_SRV_DIMENSION_TEXTURE2DMS", + "D3D10_SRV_DIMENSION_TEXTURE2DMSARRAY", + "D3D10_SRV_DIMENSION_TEXTURE3D", + "D3D10_SRV_DIMENSION_TEXTURECUBE", +]) + +D3D10_BUFFER_SRV = Struct("D3D10_BUFFER_SRV", [ + (UINT, "ElementOffset"), + (UINT, "ElementWidth"), +]) + +D3D10_TEX1D_SRV = Struct("D3D10_TEX1D_SRV", [ + (UINT, "MostDetailedMip"), + (UINT, "MipLevels"), +]) + +D3D10_TEX1D_ARRAY_SRV = Struct("D3D10_TEX1D_ARRAY_SRV", [ + (UINT, "MostDetailedMip"), + (UINT, "MipLevels"), + (UINT, "FirstArraySlice"), + (UINT, "ArraySize"), +]) + +D3D10_TEX2D_SRV = Struct("D3D10_TEX2D_SRV", [ + (UINT, "MostDetailedMip"), + (UINT, "MipLevels"), +]) + +D3D10_TEX2D_ARRAY_SRV = Struct("D3D10_TEX2D_ARRAY_SRV", [ + (UINT, "MostDetailedMip"), + (UINT, "MipLevels"), + (UINT, "FirstArraySlice"), + (UINT, "ArraySize"), +]) + +D3D10_TEX2DMS_SRV = Struct("D3D10_TEX2DMS_SRV", [ + (UINT, "UnusedField_NothingToDefine"), +]) + +D3D10_TEX2DMS_ARRAY_SRV = Struct("D3D10_TEX2DMS_ARRAY_SRV", [ + (UINT, "FirstArraySlice"), + (UINT, "ArraySize"), +]) + +D3D10_TEX3D_SRV = Struct("D3D10_TEX3D_SRV", [ + (UINT, "MostDetailedMip"), + (UINT, "MipLevels"), +]) + +D3D10_TEXCUBE_SRV = Struct("D3D10_TEXCUBE_SRV", [ + (UINT, "MostDetailedMip"), + (UINT, "MipLevels"), +]) + +D3D10_SHADER_RESOURCE_VIEW_DESC = Struct("D3D10_SHADER_RESOURCE_VIEW_DESC", [ + (DXGI_FORMAT, "Format"), + (D3D10_SRV_DIMENSION, "ViewDimension"), + (D3D10_BUFFER_SRV, "Buffer"), + (D3D10_TEX1D_SRV, "Texture1D"), + (D3D10_TEX1D_ARRAY_SRV, "Texture1DArray"), + (D3D10_TEX2D_SRV, "Texture2D"), + (D3D10_TEX2D_ARRAY_SRV, "Texture2DArray"), + (D3D10_TEX2DMS_SRV, "Texture2DMS"), + (D3D10_TEX2DMS_ARRAY_SRV, "Texture2DMSArray"), + (D3D10_TEX3D_SRV, "Texture3D"), + (D3D10_TEXCUBE_SRV, "TextureCube"), +]) + +D3D10_BOX = Struct("D3D10_BOX", [ + (UINT, "left"), + (UINT, "top"), + (UINT, "front"), + (UINT, "right"), + (UINT, "bottom"), + (UINT, "back"), +]) + +D3D10_SUBRESOURCE_DATA = Struct("D3D10_SUBRESOURCE_DATA", [ + (Const(OpaquePointer(Void)), "pSysMem"), + (UINT, "SysMemPitch"), + (UINT, "SysMemSlicePitch"), +]) + +D3D10_SO_DECLARATION_ENTRY = Struct("D3D10_SO_DECLARATION_ENTRY", [ + (LPCSTR, "SemanticName"), + (UINT, "SemanticIndex"), + (BYTE, "StartComponent"), + (BYTE, "ComponentCount"), + (BYTE, "OutputSlot"), +]) + +D3D10_INPUT_CLASSIFICATION = Enum("D3D10_INPUT_CLASSIFICATION", [ + "D3D10_INPUT_PER_VERTEX_DATA", + "D3D10_INPUT_PER_INSTANCE_DATA", +]) + +D3D10_INPUT_ELEMENT_DESC = Struct("D3D10_INPUT_ELEMENT_DESC", [ + (LPCSTR, "SemanticName"), + (UINT, "SemanticIndex"), + (DXGI_FORMAT, "Format"), + (UINT, "InputSlot"), + (UINT, "AlignedByteOffset"), + (D3D10_INPUT_CLASSIFICATION, "InputSlotClass"), + (UINT, "InstanceDataStepRate"), +]) + +D3D10_QUERY = Enum("D3D10_QUERY", [ + "D3D10_QUERY_EVENT", + "D3D10_QUERY_OCCLUSION", + "D3D10_QUERY_TIMESTAMP", + "D3D10_QUERY_TIMESTAMP_DISJOINT", + "D3D10_QUERY_PIPELINE_STATISTICS", + "D3D10_QUERY_OCCLUSION_PREDICATE", + "D3D10_QUERY_SO_STATISTICS", + "D3D10_QUERY_SO_OVERFLOW_PREDICATE", +]) + +D3D10_QUERY_DESC = Struct("D3D10_QUERY_DESC", [ + (D3D10_QUERY, "Query"), + (UINT, "MiscFlags"), +]) + +D3D10_PRIMITIVE_TOPOLOGY = Enum("D3D10_PRIMITIVE_TOPOLOGY", [ + "D3D10_PRIMITIVE_TOPOLOGY_UNDEFINED", + "D3D10_PRIMITIVE_TOPOLOGY_POINTLIST", + "D3D10_PRIMITIVE_TOPOLOGY_LINELIST", + "D3D10_PRIMITIVE_TOPOLOGY_LINESTRIP", + "D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST", + "D3D10_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP", + "D3D10_PRIMITIVE_TOPOLOGY_LINELIST_ADJ", + "D3D10_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ", + "D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ", + "D3D10_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ", +]) + +D3D10_PRIMITIVE = Enum("D3D10_PRIMITIVE", [ + "D3D10_PRIMITIVE_UNDEFINED", + "D3D10_PRIMITIVE_POINT", + "D3D10_PRIMITIVE_LINE", + "D3D10_PRIMITIVE_TRIANGLE", + "D3D10_PRIMITIVE_LINE_ADJ", + "D3D10_PRIMITIVE_TRIANGLE_ADJ", +]) + +D3D10_RECT = Alias("D3D10_RECT", RECT) +D3D10_VIEWPORT = Struct("D3D10_VIEWPORT", [ + (INT, "TopLeftX"), + (INT, "TopLeftY"), + (UINT, "Width"), + (UINT, "Height"), + (FLOAT, "MinDepth"), + (FLOAT, "MaxDepth"), +]) + +D3D10_MAPPED_TEXTURE2D = Struct("D3D10_MAPPED_TEXTURE2D", [ + (OpaquePointer(Void), "pData"), + (UINT, "RowPitch"), +]) + +D3D10_MAPPED_TEXTURE3D = Struct("D3D10_MAPPED_TEXTURE3D", [ + (OpaquePointer(Void), "pData"), + (UINT, "RowPitch"), + (UINT, "DepthPitch"), +]) + +D3D10_CPU_ACCESS_FLAG = Enum("D3D10_CPU_ACCESS_FLAG", [ + "D3D10_CPU_ACCESS_WRITE", + "D3D10_CPU_ACCESS_READ", +]) + +D3D10_RESOURCE_MISC_FLAG = Enum("D3D10_RESOURCE_MISC_FLAG", [ + "D3D10_RESOURCE_MISC_GENERATE_MIPS", + "D3D10_RESOURCE_MISC_SHARED", + "D3D10_RESOURCE_MISC_TEXTURECUBE", + "D3D10_RESOURCE_MISC_SHARED_KEYEDMUTEX", + "D3D10_RESOURCE_MISC_GDI_COMPATIBLE", +]) + +D3D10_MAP_FLAG = Enum("D3D10_MAP_FLAG", [ + "D3D10_MAP_FLAG_DO_NOT_WAIT", +]) + +D3D10_CLEAR_FLAG = Enum("D3D10_CLEAR_FLAG", [ + "D3D10_CLEAR_DEPTH", + "D3D10_CLEAR_STENCIL", +]) + +D3D10_COLOR_WRITE_ENABLE = Enum("D3D10_COLOR_WRITE_ENABLE", [ + "D3D10_COLOR_WRITE_ENABLE_RED", + "D3D10_COLOR_WRITE_ENABLE_GREEN", + "D3D10_COLOR_WRITE_ENABLE_BLUE", + "D3D10_COLOR_WRITE_ENABLE_ALPHA", + "D3D10_COLOR_WRITE_ENABLE_ALL", + "D3D10_COLOR_WRITE_ENABLE_RED", + "|", + "D3D10_COLOR_WRITE_ENABLE_GREEN", + "|", + "D3D10_COLOR_WRITE_ENABLE_BLUE", + "|", + "D3D10_COLOR_WRITE_ENABLE_ALPHA", + ")", +]) + +D3D10_TEXTURECUBE_FACE = Enum("D3D10_TEXTURECUBE_FACE", [ + "D3D10_TEXTURECUBE_FACE_POSITIVE_X", + "D3D10_TEXTURECUBE_FACE_NEGATIVE_X", + "D3D10_TEXTURECUBE_FACE_POSITIVE_Y", + "D3D10_TEXTURECUBE_FACE_NEGATIVE_Y", + "D3D10_TEXTURECUBE_FACE_POSITIVE_Z", + "D3D10_TEXTURECUBE_FACE_NEGATIVE_Z", +]) + +D3D10_ASYNC_GETDATA_FLAG = Enum("D3D10_ASYNC_GETDATA_FLAG", [ + "D3D10_ASYNC_GETDATA_DONOTFLUSH", +]) + +D3D10_FILTER_TYPE = Enum("D3D10_FILTER_TYPE", [ + "D3D10_FILTER_TYPE_POINT", + "D3D10_FILTER_TYPE_LINEAR", +]) + +D3D10_QUERY_MISC_FLAG = Enum("D3D10_QUERY_MISC_FLAG", [ + "D3D10_QUERY_MISC_PREDICATEHINT", +]) + +D3D10_QUERY_DATA_TIMESTAMP_DISJOINT = Struct("D3D10_QUERY_DATA_TIMESTAMP_DISJOINT", [ + (UINT64, "Frequency"), + (BOOL, "Disjoint"), +]) + +D3D10_QUERY_DATA_PIPELINE_STATISTICS = Struct("D3D10_QUERY_DATA_PIPELINE_STATISTICS", [ + (UINT64, "IAVertices"), + (UINT64, "IAPrimitives"), + (UINT64, "VSInvocations"), + (UINT64, "GSInvocations"), + (UINT64, "GSPrimitives"), + (UINT64, "CInvocations"), + (UINT64, "CPrimitives"), + (UINT64, "PSInvocations"), +]) + +D3D10_QUERY_DATA_SO_STATISTICS = Struct("D3D10_QUERY_DATA_SO_STATISTICS", [ + (UINT64, "NumPrimitivesWritten"), + (UINT64, "PrimitivesStorageNeeded"), +]) + +D3D10_CREATE_DEVICE_FLAG = Enum("D3D10_CREATE_DEVICE_FLAG", [ + "D3D10_CREATE_DEVICE_SINGLETHREADED", + "D3D10_CREATE_DEVICE_DEBUG", + "D3D10_CREATE_DEVICE_SWITCH_TO_REF", + "D3D10_CREATE_DEVICE_PREVENT_INTERNAL_THREADING_OPTIMIZATIONS", + "D3D10_CREATE_DEVICE_ALLOW_NULL_FROM_MAP", + "D3D10_CREATE_DEVICE_BGRA_SUPPORT", + "D3D10_CREATE_DEVICE_STRICT_VALIDATION", +]) + +ID3D10DeviceChild = Interface("ID3D10DeviceChild", IUnknown) +ID3D10Resource = Interface("ID3D10Resource", ID3D10DeviceChild) +ID3D10Buffer = Interface("ID3D10Buffer", ID3D10Resource) +ID3D10Texture1D = Interface("ID3D10Texture1D", ID3D10Resource) +ID3D10Texture2D = Interface("ID3D10Texture2D", ID3D10Resource) +ID3D10Texture3D = Interface("ID3D10Texture3D", ID3D10Resource) +ID3D10View = Interface("ID3D10View", ID3D10DeviceChild) +ID3D10DepthStencilView = Interface("ID3D10DepthStencilView", ID3D10View) +ID3D10RenderTargetView = Interface("ID3D10RenderTargetView", ID3D10View) +ID3D10ShaderResourceView = Interface("ID3D10ShaderResourceView", ID3D10View) +ID3D10BlendState = Interface("ID3D10BlendState", ID3D10DeviceChild) +ID3D10DepthStencilState = Interface("ID3D10DepthStencilState", ID3D10DeviceChild) +ID3D10GeometryShader = Interface("ID3D10GeometryShader", ID3D10DeviceChild) +ID3D10InputLayout = Interface("ID3D10InputLayout", ID3D10DeviceChild) +ID3D10PixelShader = Interface("ID3D10PixelShader", ID3D10DeviceChild) +ID3D10RasterizerState = Interface("ID3D10RasterizerState", ID3D10DeviceChild) +ID3D10SamplerState = Interface("ID3D10SamplerState", ID3D10DeviceChild) +ID3D10VertexShader = Interface("ID3D10VertexShader", ID3D10DeviceChild) +ID3D10Asynchronous = Interface("ID3D10Asynchronous", ID3D10DeviceChild) +ID3D10Counter = Interface("ID3D10Counter", ID3D10Asynchronous) +ID3D10Query = Interface("ID3D10Query", ID3D10Asynchronous) +ID3D10Predicate = Interface("ID3D10Predicate", ID3D10Query) +ID3D10Device = Interface("ID3D10Device", IUnknown) +ID3D10Multithread = Interface("ID3D10Multithread", IUnknown) + +ID3D10DeviceChild.methods += [ + Method(Void, "GetDevice", [Out(OpaquePointer(OpaquePointer(ID3D10Device)), "ppDevice")]), + Method(HRESULT, "GetPrivateData", [(REFGUID, "guid"), Out(OpaquePointer(UINT), "pDataSize"), Out(OpaquePointer(Void), "pData")]), + Method(HRESULT, "SetPrivateData", [(REFGUID, "guid"), (UINT, "DataSize"), (Const(OpaquePointer(Void)), "pData")]), + Method(HRESULT, "SetPrivateDataInterface", [(REFGUID, "guid"), (Const(OpaquePointer(IUnknown)), "pData")]), +] + +ID3D10Resource.methods += [ + Method(Void, "GetType", [Out(OpaquePointer(D3D10_RESOURCE_DIMENSION), "rType")]), + Method(Void, "SetEvictionPriority", [(UINT, "EvictionPriority")]), + Method(UINT, "GetEvictionPriority", []), +] + +ID3D10Buffer.methods += [ + Method(HRESULT, "Map", [(D3D10_MAP, "MapType"), (UINT, "MapFlags"), Out(OpaquePointer(OpaquePointer(Void)), "ppData")]), + Method(Void, "Unmap", []), + Method(Void, "GetDesc", [Out(OpaquePointer(D3D10_BUFFER_DESC), "pDesc")]), +] + +ID3D10Texture1D.methods += [ + Method(HRESULT, "Map", [(UINT, "Subresource"), (D3D10_MAP, "MapType"), (UINT, "MapFlags"), Out(OpaquePointer(OpaquePointer(Void)), "ppData")]), + Method(Void, "Unmap", [(UINT, "Subresource")]), + Method(Void, "GetDesc", [Out(OpaquePointer(D3D10_TEXTURE1D_DESC), "pDesc")]), +] + +ID3D10Texture2D.methods += [ + Method(HRESULT, "Map", [(UINT, "Subresource"), (D3D10_MAP, "MapType"), (UINT, "MapFlags"), Out(OpaquePointer(D3D10_MAPPED_TEXTURE2D), "pMappedTex2D")]), + Method(Void, "Unmap", [(UINT, "Subresource")]), + Method(Void, "GetDesc", [Out(OpaquePointer(D3D10_TEXTURE2D_DESC), "pDesc")]), +] + +ID3D10Texture3D.methods += [ + Method(HRESULT, "Map", [(UINT, "Subresource"), (D3D10_MAP, "MapType"), (UINT, "MapFlags"), Out(OpaquePointer(D3D10_MAPPED_TEXTURE3D), "pMappedTex3D")]), + Method(Void, "Unmap", [(UINT, "Subresource")]), + Method(Void, "GetDesc", [Out(OpaquePointer(D3D10_TEXTURE3D_DESC), "pDesc")]), +] + +ID3D10View.methods += [ + Method(Void, "GetResource", [Out(OpaquePointer(OpaquePointer(ID3D10Resource)), "ppResource")]), +] + +ID3D10DepthStencilView.methods += [ + Method(Void, "GetDesc", [Out(OpaquePointer(D3D10_DEPTH_STENCIL_VIEW_DESC), "pDesc")]), +] + +ID3D10RenderTargetView.methods += [ + Method(Void, "GetDesc", [Out(OpaquePointer(D3D10_RENDER_TARGET_VIEW_DESC), "pDesc")]), +] + +ID3D10ShaderResourceView.methods += [ + Method(Void, "GetDesc", [Out(OpaquePointer(D3D10_SHADER_RESOURCE_VIEW_DESC), "pDesc")]), +] + +ID3D10BlendState.methods += [ + Method(Void, "GetDesc", [Out(OpaquePointer(D3D10_BLEND_DESC), "pDesc")]), +] + +ID3D10DepthStencilState.methods += [ + Method(Void, "GetDesc", [Out(OpaquePointer(D3D10_DEPTH_STENCIL_DESC), "pDesc")]), +] + +ID3D10GeometryShader.methods += [ +] + +ID3D10InputLayout.methods += [ +] + +ID3D10PixelShader.methods += [ +] + +ID3D10RasterizerState.methods += [ + Method(Void, "GetDesc", [Out(OpaquePointer(D3D10_RASTERIZER_DESC), "pDesc")]), +] + +ID3D10SamplerState.methods += [ + Method(Void, "GetDesc", [Out(OpaquePointer(D3D10_SAMPLER_DESC), "pDesc")]), +] + +ID3D10VertexShader.methods += [ +] + +ID3D10Asynchronous.methods += [ + Method(Void, "Begin", []), + Method(Void, "End", []), + Method(HRESULT, "GetData", [Out(OpaquePointer(Void), "pData"), (UINT, "DataSize"), (UINT, "GetDataFlags")]), + Method(UINT, "GetDataSize", []), +] + +ID3D10Counter.methods += [ + Method(Void, "GetDesc", [Out(OpaquePointer(D3D10_COUNTER_DESC), "pDesc")]), +] + +ID3D10Query.methods += [ + Method(Void, "GetDesc", [Out(OpaquePointer(D3D10_QUERY_DESC), "pDesc")]), +] + +ID3D10Predicate.methods += [ +] + +ID3D10Device.methods += [ + Method(Void, "VSSetConstantBuffers", [(UINT, "StartSlot"), (UINT, "NumBuffers"), (Array(Const(OpaquePointer(ID3D10Buffer)), "NumBuffers"), "ppConstantBuffers")]), + Method(Void, "PSSetShaderResources", [(UINT, "StartSlot"), (UINT, "NumViews"), (Array(Const(OpaquePointer(ID3D10ShaderResourceView)), "NumViews"), "ppShaderResourceViews")]), + Method(Void, "PSSetShader", [(OpaquePointer(ID3D10PixelShader), "pPixelShader")]), + Method(Void, "PSSetSamplers", [(UINT, "StartSlot"), (UINT, "NumSamplers"), (Array(Const(OpaquePointer(ID3D10SamplerState)), "NumSamplers"), "ppSamplers")]), + Method(Void, "VSSetShader", [(OpaquePointer(ID3D10VertexShader), "pVertexShader")]), + Method(Void, "DrawIndexed", [(UINT, "IndexCount"), (UINT, "StartIndexLocation"), (INT, "BaseVertexLocation")]), + Method(Void, "Draw", [(UINT, "VertexCount"), (UINT, "StartVertexLocation")]), + Method(Void, "PSSetConstantBuffers", [(UINT, "StartSlot"), (UINT, "NumBuffers"), (OpaquePointer(Const(OpaquePointer(ID3D10Buffer))), "ppConstantBuffers")]), + Method(Void, "IASetInputLayout", [(OpaquePointer(ID3D10InputLayout), "pInputLayout")]), + Method(Void, "IASetVertexBuffers", [(UINT, "StartSlot"), (UINT, "NumBuffers"), (OpaquePointer(Const(OpaquePointer(ID3D10Buffer))), "ppVertexBuffers"), (Const(OpaquePointer(UINT)), "pStrides"), (Const(OpaquePointer(UINT)), "pOffsets")]), + Method(Void, "IASetIndexBuffer", [(OpaquePointer(ID3D10Buffer), "pIndexBuffer"), (DXGI_FORMAT, "Format"), (UINT, "Offset")]), + Method(Void, "DrawIndexedInstanced", [(UINT, "IndexCountPerInstance"), (UINT, "InstanceCount"), (UINT, "StartIndexLocation"), (INT, "BaseVertexLocation"), (UINT, "StartInstanceLocation")]), + Method(Void, "DrawInstanced", [(UINT, "VertexCountPerInstance"), (UINT, "InstanceCount"), (UINT, "StartVertexLocation"), (UINT, "StartInstanceLocation")]), + Method(Void, "GSSetConstantBuffers", [(UINT, "StartSlot"), (UINT, "NumBuffers"), (OpaquePointer(Const(OpaquePointer(ID3D10Buffer))), "ppConstantBuffers")]), + Method(Void, "GSSetShader", [(OpaquePointer(ID3D10GeometryShader), "pShader")]), + Method(Void, "IASetPrimitiveTopology", [(D3D10_PRIMITIVE_TOPOLOGY, "Topology")]), + Method(Void, "VSSetShaderResources", [(UINT, "StartSlot"), (UINT, "NumViews"), (OpaquePointer(Const(OpaquePointer(ID3D10ShaderResourceView))), "ppShaderResourceViews")]), + Method(Void, "VSSetSamplers", [(UINT, "StartSlot"), (UINT, "NumSamplers"), (OpaquePointer(Const(OpaquePointer(ID3D10SamplerState))), "ppSamplers")]), + Method(Void, "SetPredication", [(OpaquePointer(ID3D10Predicate), "pPredicate"), (BOOL, "PredicateValue")]), + Method(Void, "GSSetShaderResources", [(UINT, "StartSlot"), (UINT, "NumViews"), (OpaquePointer(Const(OpaquePointer(ID3D10ShaderResourceView))), "ppShaderResourceViews")]), + Method(Void, "GSSetSamplers", [(UINT, "StartSlot"), (UINT, "NumSamplers"), (OpaquePointer(Const(OpaquePointer(ID3D10SamplerState))), "ppSamplers")]), + Method(Void, "OMSetRenderTargets", [(UINT, "NumViews"), (OpaquePointer(Const(OpaquePointer(ID3D10RenderTargetView))), "ppRenderTargetViews"), (OpaquePointer(ID3D10DepthStencilView), "pDepthStencilView")]), + Method(Void, "OMSetBlendState", [(OpaquePointer(ID3D10BlendState), "pBlendState"), (Array(Const(FLOAT), "4"), "BlendFactor"), (UINT, "SampleMask")]), + Method(Void, "OMSetDepthStencilState", [(OpaquePointer(ID3D10DepthStencilState), "pDepthStencilState"), (UINT, "StencilRef")]), + Method(Void, "SOSetTargets", [(UINT, "NumBuffers"), (OpaquePointer(Const(OpaquePointer(ID3D10Buffer))), "ppSOTargets"), (Const(OpaquePointer(UINT)), "pOffsets")]), + Method(Void, "DrawAuto", []), + Method(Void, "RSSetState", [(OpaquePointer(ID3D10RasterizerState), "pRasterizerState")]), + Method(Void, "RSSetViewports", [(UINT, "NumViewports"), (Const(OpaquePointer(D3D10_VIEWPORT)), "pViewports")]), + Method(Void, "RSSetScissorRects", [(UINT, "NumRects"), (Const(OpaquePointer(D3D10_RECT)), "pRects")]), + Method(Void, "CopySubresourceRegion", [(OpaquePointer(ID3D10Resource), "pDstResource"), (UINT, "DstSubresource"), (UINT, "DstX"), (UINT, "DstY"), (UINT, "DstZ"), (OpaquePointer(ID3D10Resource), "pSrcResource"), (UINT, "SrcSubresource"), (Const(OpaquePointer(D3D10_BOX)), "pSrcBox")]), + Method(Void, "CopyResource", [(OpaquePointer(ID3D10Resource), "pDstResource"), (OpaquePointer(ID3D10Resource), "pSrcResource")]), + Method(Void, "UpdateSubresource", [(OpaquePointer(ID3D10Resource), "pDstResource"), (UINT, "DstSubresource"), (Const(OpaquePointer(D3D10_BOX)), "pDstBox"), (Const(OpaquePointer(Void)), "pSrcData"), (UINT, "SrcRowPitch"), (UINT, "SrcDepthPitch")]), + Method(Void, "ClearRenderTargetView", [(OpaquePointer(ID3D10RenderTargetView), "pRenderTargetView"), (Array(Const(FLOAT), "4"), "ColorRGBA")]), + Method(Void, "ClearDepthStencilView", [(OpaquePointer(ID3D10DepthStencilView), "pDepthStencilView"), (UINT, "ClearFlags"), (FLOAT, "Depth"), (UINT8, "Stencil")]), + Method(Void, "GenerateMips", [(OpaquePointer(ID3D10ShaderResourceView), "pShaderResourceView")]), + Method(Void, "ResolveSubresource", [(OpaquePointer(ID3D10Resource), "pDstResource"), (UINT, "DstSubresource"), (OpaquePointer(ID3D10Resource), "pSrcResource"), (UINT, "SrcSubresource"), (DXGI_FORMAT, "Format")]), + Method(Void, "VSGetConstantBuffers", [(UINT, "StartSlot"), (UINT, "NumBuffers"), Out(OpaquePointer(OpaquePointer(ID3D10Buffer)), "ppConstantBuffers")]), + Method(Void, "PSGetShaderResources", [(UINT, "StartSlot"), (UINT, "NumViews"), Out(OpaquePointer(OpaquePointer(ID3D10ShaderResourceView)), "ppShaderResourceViews")]), + Method(Void, "PSGetShader", [Out(OpaquePointer(OpaquePointer(ID3D10PixelShader)), "ppPixelShader")]), + Method(Void, "PSGetSamplers", [(UINT, "StartSlot"), (UINT, "NumSamplers"), Out(OpaquePointer(OpaquePointer(ID3D10SamplerState)), "ppSamplers")]), + Method(Void, "VSGetShader", [Out(OpaquePointer(OpaquePointer(ID3D10VertexShader)), "ppVertexShader")]), + Method(Void, "PSGetConstantBuffers", [(UINT, "StartSlot"), (UINT, "NumBuffers"), Out(OpaquePointer(OpaquePointer(ID3D10Buffer)), "ppConstantBuffers")]), + Method(Void, "IAGetInputLayout", [Out(OpaquePointer(OpaquePointer(ID3D10InputLayout)), "ppInputLayout")]), + Method(Void, "IAGetVertexBuffers", [(UINT, "StartSlot"), (UINT, "NumBuffers"), Out(OpaquePointer(OpaquePointer(ID3D10Buffer)), "ppVertexBuffers"), Out(OpaquePointer(UINT), "pStrides"), Out(OpaquePointer(UINT), "pOffsets")]), + Method(Void, "IAGetIndexBuffer", [Out(OpaquePointer(OpaquePointer(ID3D10Buffer)), "pIndexBuffer"), Out(OpaquePointer(DXGI_FORMAT), "Format"), Out(OpaquePointer(UINT), "Offset")]), + Method(Void, "GSGetConstantBuffers", [(UINT, "StartSlot"), (UINT, "NumBuffers"), Out(OpaquePointer(OpaquePointer(ID3D10Buffer)), "ppConstantBuffers")]), + Method(Void, "GSGetShader", [Out(OpaquePointer(OpaquePointer(ID3D10GeometryShader)), "ppGeometryShader")]), + Method(Void, "IAGetPrimitiveTopology", [Out(OpaquePointer(D3D10_PRIMITIVE_TOPOLOGY), "pTopology")]), + Method(Void, "VSGetShaderResources", [(UINT, "StartSlot"), (UINT, "NumViews"), Out(OpaquePointer(OpaquePointer(ID3D10ShaderResourceView)), "ppShaderResourceViews")]), + Method(Void, "VSGetSamplers", [(UINT, "StartSlot"), (UINT, "NumSamplers"), Out(OpaquePointer(OpaquePointer(ID3D10SamplerState)), "ppSamplers")]), + Method(Void, "GetPredication", [Out(OpaquePointer(OpaquePointer(ID3D10Predicate)), "ppPredicate"), Out(OpaquePointer(BOOL), "pPredicateValue")]), + Method(Void, "GSGetShaderResources", [(UINT, "StartSlot"), (UINT, "NumViews"), Out(OpaquePointer(OpaquePointer(ID3D10ShaderResourceView)), "ppShaderResourceViews")]), + Method(Void, "GSGetSamplers", [(UINT, "StartSlot"), (UINT, "NumSamplers"), Out(OpaquePointer(OpaquePointer(ID3D10SamplerState)), "ppSamplers")]), + Method(Void, "OMGetRenderTargets", [(UINT, "NumViews"), Out(OpaquePointer(OpaquePointer(ID3D10RenderTargetView)), "ppRenderTargetViews"), Out(OpaquePointer(OpaquePointer(ID3D10DepthStencilView)), "ppDepthStencilView")]), + Method(Void, "OMGetBlendState", [Out(OpaquePointer(OpaquePointer(ID3D10BlendState)), "ppBlendState"), Out(Array(FLOAT, "4"), "BlendFactor"), Out(OpaquePointer(UINT), "pSampleMask")]), + Method(Void, "OMGetDepthStencilState", [Out(OpaquePointer(OpaquePointer(ID3D10DepthStencilState)), "ppDepthStencilState"), Out(OpaquePointer(UINT), "pStencilRef")]), + Method(Void, "SOGetTargets", [(UINT, "NumBuffers"), Out(OpaquePointer(OpaquePointer(ID3D10Buffer)), "ppSOTargets"), Out(OpaquePointer(UINT), "pOffsets")]), + Method(Void, "RSGetState", [Out(OpaquePointer(OpaquePointer(ID3D10RasterizerState)), "ppRasterizerState")]), + Method(Void, "RSGetViewports", [Out(OpaquePointer(UINT), "NumViewports"), Out(OpaquePointer(D3D10_VIEWPORT), "pViewports")]), + Method(Void, "RSGetScissorRects", [Out(OpaquePointer(UINT), "NumRects"), Out(OpaquePointer(D3D10_RECT), "pRects")]), + Method(HRESULT, "GetDeviceRemovedReason", []), + Method(HRESULT, "SetExceptionMode", [(UINT, "RaiseFlags")]), + Method(UINT, "GetExceptionMode", []), + Method(HRESULT, "GetPrivateData", [(REFGUID, "guid"), Out(OpaquePointer(UINT), "pDataSize"), Out(OpaquePointer(Void), "pData")]), + Method(HRESULT, "SetPrivateData", [(REFGUID, "guid"), (UINT, "DataSize"), (Const(OpaquePointer(Void)), "pData")]), + Method(HRESULT, "SetPrivateDataInterface", [(REFGUID, "guid"), (Const(OpaquePointer(IUnknown)), "pData")]), + Method(Void, "ClearState", []), + Method(Void, "Flush", []), + Method(HRESULT, "CreateBuffer", [(Const(OpaquePointer(D3D10_BUFFER_DESC)), "pDesc"), (Const(OpaquePointer(D3D10_SUBRESOURCE_DATA)), "pInitialData"), Out(OpaquePointer(OpaquePointer(ID3D10Buffer)), "ppBuffer")]), + Method(HRESULT, "CreateTexture1D", [(Const(OpaquePointer(D3D10_TEXTURE1D_DESC)), "pDesc"), (Const(OpaquePointer(D3D10_SUBRESOURCE_DATA)), "pInitialData"), Out(OpaquePointer(OpaquePointer(ID3D10Texture1D)), "ppTexture1D")]), + Method(HRESULT, "CreateTexture2D", [(Const(OpaquePointer(D3D10_TEXTURE2D_DESC)), "pDesc"), (Const(OpaquePointer(D3D10_SUBRESOURCE_DATA)), "pInitialData"), Out(OpaquePointer(OpaquePointer(ID3D10Texture2D)), "ppTexture2D")]), + Method(HRESULT, "CreateTexture3D", [(Const(OpaquePointer(D3D10_TEXTURE3D_DESC)), "pDesc"), (Const(OpaquePointer(D3D10_SUBRESOURCE_DATA)), "pInitialData"), Out(OpaquePointer(OpaquePointer(ID3D10Texture3D)), "ppTexture3D")]), + Method(HRESULT, "CreateShaderResourceView", [(OpaquePointer(ID3D10Resource), "pResource"), (Const(OpaquePointer(D3D10_SHADER_RESOURCE_VIEW_DESC)), "pDesc"), Out(OpaquePointer(OpaquePointer(ID3D10ShaderResourceView)), "ppSRView")]), + Method(HRESULT, "CreateRenderTargetView", [(OpaquePointer(ID3D10Resource), "pResource"), (Const(OpaquePointer(D3D10_RENDER_TARGET_VIEW_DESC)), "pDesc"), Out(OpaquePointer(OpaquePointer(ID3D10RenderTargetView)), "ppRTView")]), + Method(HRESULT, "CreateDepthStencilView", [(OpaquePointer(ID3D10Resource), "pResource"), (Const(OpaquePointer(D3D10_DEPTH_STENCIL_VIEW_DESC)), "pDesc"), Out(OpaquePointer(OpaquePointer(ID3D10DepthStencilView)), "ppDepthStencilView")]), + Method(HRESULT, "CreateInputLayout", [(Const(OpaquePointer(D3D10_INPUT_ELEMENT_DESC)), "pInputElementDescs"), (UINT, "NumElements"), (Const(OpaquePointer(Void)), "pShaderBytecodeWithInputSignature"), (SIZE_T, "BytecodeLength"), Out(OpaquePointer(OpaquePointer(ID3D10InputLayout)), "ppInputLayout")]), + Method(HRESULT, "CreateVertexShader", [(Const(OpaquePointer(Void)), "pShaderBytecode"), (SIZE_T, "BytecodeLength"), Out(OpaquePointer(OpaquePointer(ID3D10VertexShader)), "ppVertexShader")]), + Method(HRESULT, "CreateGeometryShader", [(Const(OpaquePointer(Void)), "pShaderBytecode"), (SIZE_T, "BytecodeLength"), Out(OpaquePointer(OpaquePointer(ID3D10GeometryShader)), "ppGeometryShader")]), + Method(HRESULT, "CreateGeometryShaderWithStreamOutput", [(Const(OpaquePointer(Void)), "pShaderBytecode"), (SIZE_T, "BytecodeLength"), (Const(OpaquePointer(D3D10_SO_DECLARATION_ENTRY)), "pSODeclaration"), (UINT, "NumEntries"), (UINT, "OutputStreamStride"), Out(OpaquePointer(OpaquePointer(ID3D10GeometryShader)), "ppGeometryShader")]), + Method(HRESULT, "CreatePixelShader", [(Const(OpaquePointer(Void)), "pShaderBytecode"), (SIZE_T, "BytecodeLength"), Out(OpaquePointer(OpaquePointer(ID3D10PixelShader)), "ppPixelShader")]), + Method(HRESULT, "CreateBlendState", [(Const(OpaquePointer(D3D10_BLEND_DESC)), "pBlendStateDesc"), Out(OpaquePointer(OpaquePointer(ID3D10BlendState)), "ppBlendState")]), + Method(HRESULT, "CreateDepthStencilState", [(Const(OpaquePointer(D3D10_DEPTH_STENCIL_DESC)), "pDepthStencilDesc"), Out(OpaquePointer(OpaquePointer(ID3D10DepthStencilState)), "ppDepthStencilState")]), + Method(HRESULT, "CreateRasterizerState", [(Const(OpaquePointer(D3D10_RASTERIZER_DESC)), "pRasterizerDesc"), Out(OpaquePointer(OpaquePointer(ID3D10RasterizerState)), "ppRasterizerState")]), + Method(HRESULT, "CreateSamplerState", [(Const(OpaquePointer(D3D10_SAMPLER_DESC)), "pSamplerDesc"), Out(OpaquePointer(OpaquePointer(ID3D10SamplerState)), "ppSamplerState")]), + Method(HRESULT, "CreateQuery", [(Const(OpaquePointer(D3D10_QUERY_DESC)), "pQueryDesc"), Out(OpaquePointer(OpaquePointer(ID3D10Query)), "ppQuery")]), + Method(HRESULT, "CreatePredicate", [(Const(OpaquePointer(D3D10_QUERY_DESC)), "pPredicateDesc"), Out(OpaquePointer(OpaquePointer(ID3D10Predicate)), "ppPredicate")]), + Method(HRESULT, "CreateCounter", [(Const(OpaquePointer(D3D10_COUNTER_DESC)), "pCounterDesc"), Out(OpaquePointer(OpaquePointer(ID3D10Counter)), "ppCounter")]), + Method(HRESULT, "CheckFormatSupport", [(DXGI_FORMAT, "Format"), Out(OpaquePointer(UINT), "pFormatSupport")]), + Method(HRESULT, "CheckMultisampleQualityLevels", [(DXGI_FORMAT, "Format"), (UINT, "SampleCount"), Out(OpaquePointer(UINT), "pNumQualityLevels")]), + Method(Void, "CheckCounterInfo", [Out(OpaquePointer(D3D10_COUNTER_INFO), "pCounterInfo")]), + Method(HRESULT, "CheckCounter", [(Const(OpaquePointer(D3D10_COUNTER_DESC)), "pDesc"), Out(OpaquePointer(D3D10_COUNTER_TYPE), "pType"), Out(OpaquePointer(UINT), "pActiveCounters"), Out(LPSTR, "szName"), Out(OpaquePointer(UINT), "pNameLength"), Out(LPSTR, "szUnits"), Out(OpaquePointer(UINT), "pUnitsLength"), Out(LPSTR, "szDescription"), Out(OpaquePointer(UINT), "pDescriptionLength")]), + Method(UINT, "GetCreationFlags", []), + Method(HRESULT, "OpenSharedResource", [(HANDLE, "hResource"), (REFIID, "ReturnedInterface"), Out(OpaquePointer(OpaquePointer(Void)), "ppResource")]), + Method(Void, "SetTextFilterSize", [(UINT, "Width"), (UINT, "Height")]), + Method(Void, "GetTextFilterSize", [Out(OpaquePointer(UINT), "pWidth"), Out(OpaquePointer(UINT), "pHeight")]), +] + +ID3D10Multithread.methods += [ + Method(Void, "Enter", []), + Method(Void, "Leave", []), + Method(BOOL, "SetMultithreadProtected", [(BOOL, "bMTProtect")]), + Method(BOOL, "GetMultithreadProtected", []), +] + diff --git a/d3d10misc.py b/d3d10misc.py index 4553f19..fdb485d 100644 --- a/d3d10misc.py +++ b/d3d10misc.py @@ -26,6 +26,8 @@ """d3d10misc.h""" from winapi import * +from d3d10 import * +from trace import DllTracer ID3D10Blob = Interface("ID3D10Blob", IUnknown) LPD3D10BLOB = Pointer(ID3D10Blob) @@ -43,20 +45,19 @@ D3D10_DRIVER_TYPE = Enum("D3D10_DRIVER_TYPE", [ "D3D10_DRIVER_TYPE_WARP", ]) -# TODO -IDXGIAdapter = Alias("IDXGIAdapter", Void) -ID3D10Device = Alias("ID3D10Device", Void) -IDXGISwapChain = Alias("IDXGISwapChain", Void) -DXGI_SWAP_CHAIN_DESC = Alias("DXGI_SWAP_CHAIN_DESC", Void) -d3d10 = Dll("d3d10") -d3d10.functions += [ +d3d10 = API("d3d10") +d3d10.add_functions([ StdFunction(HRESULT, "D3D10CreateDevice", [(Pointer(IDXGIAdapter), "pAdapter"), (D3D10_DRIVER_TYPE, "DriverType"), (HMODULE, "Software"), (UINT, "Flags"), (UINT, "SDKVersion"), Out(Pointer(Pointer(ID3D10Device)), "ppDevice")]), StdFunction(HRESULT, "D3D10CreateDeviceAndSwapChain", [(Pointer(IDXGIAdapter), "pAdapter"), (D3D10_DRIVER_TYPE, "DriverType"), (HMODULE, "Software"), (UINT, "Flags"), (UINT, "SDKVersion"), (Pointer(DXGI_SWAP_CHAIN_DESC), "pSwapChainDesc"), Out(Pointer(Pointer(IDXGISwapChain)), "ppSwapChain"), Out(Pointer(Pointer(ID3D10Device)), "ppDevice")]), StdFunction(HRESULT, "D3D10CreateBlob", [(SIZE_T, "NumBytes"), Out(Pointer(LPD3D10BLOB), "ppBuffer")]), -] +]) + if __name__ == '__main__': + print '#include "trace_writer.hpp"' + print '#include "os.hpp"' + print print '#include ' print '#include ' print @@ -64,6 +65,5 @@ if __name__ == '__main__': print print '#include ' print - print '#include "trace_writer.hpp"' - print - wrap() + tracer = DllTracer('d3d10.dll') + tracer.trace_api(d3d10) diff --git a/dxgi.py b/dxgi.py new file mode 100644 index 0000000..17cc316 --- /dev/null +++ b/dxgi.py @@ -0,0 +1,183 @@ +########################################################################## +# +# Copyright 2011 Jose Fonseca +# All Rights Reserved. +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +##########################################################################/ + +from dxgitype import * + +HMONITOR = Alias("HMONITOR", HANDLE) +_LUID = Struct("_LUID", [ + (DWORD, "LowPart"), + (LONG, "HighPart"), +]) + +DXGI_USAGE = Alias("DXGI_USAGE", UINT) +DXGI_SWAP_EFFECT = Enum("DXGI_SWAP_EFFECT", [ + "DXGI_SWAP_EFFECT_DISCARD", + "DXGI_SWAP_EFFECT_SEQUENTIAL", +]) + +DXGI_RESIDENCY = Enum("DXGI_RESIDENCY", [ + "DXGI_RESIDENCY_FULLY_RESIDENT", + "DXGI_RESIDENCY_RESIDENT_IN_SHARED_MEMORY", + "DXGI_RESIDENCY_EVICTED_TO_DISK", +]) + +DXGI_SURFACE_DESC = Struct("DXGI_SURFACE_DESC", [ + (UINT, "Width"), + (UINT, "Height"), + (DXGI_FORMAT, "Format"), + (DXGI_SAMPLE_DESC, "SampleDesc"), +]) + +DXGI_MAPPED_RECT = Struct("DXGI_MAPPED_RECT", [ + (INT, "Pitch"), + (OpaquePointer(BYTE), "pBits"), +]) + +DXGI_OUTPUT_DESC = Struct("DXGI_OUTPUT_DESC", [ + (Array(WCHAR, "32"), "DeviceName"), + (RECT, "DesktopCoordinates"), + (BOOL, "AttachedToDesktop"), + (DXGI_MODE_ROTATION, "Rotation"), + (HMONITOR, "Monitor"), +]) + +DXGI_FRAME_STATISTICS = Struct("DXGI_FRAME_STATISTICS", [ + (UINT, "PresentCount"), + (UINT, "PresentRefreshCount"), + (UINT, "SyncRefreshCount"), + (LARGE_INTEGER, "SyncQPCTime"), + (LARGE_INTEGER, "SyncGPUTime"), +]) + +DXGI_ADAPTER_DESC = Struct("DXGI_ADAPTER_DESC", [ + (Array(WCHAR, "128"), "Description"), + (UINT, "VendorId"), + (UINT, "DeviceId"), + (UINT, "SubSysId"), + (UINT, "Revision"), + (SIZE_T, "DedicatedVideoMemory"), + (SIZE_T, "DedicatedSystemMemory"), + (SIZE_T, "SharedSystemMemory"), + (LUID, "AdapterLuid"), +]) + +DXGI_SWAP_CHAIN_FLAG = Enum("DXGI_SWAP_CHAIN_FLAG", [ + "DXGI_SWAP_CHAIN_FLAG_NONPREROTATED", + "DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH", + "DXGI_SWAP_CHAIN_FLAG_GDI_COMPATIBLE", +]) + +DXGI_SWAP_CHAIN_DESC = Struct("DXGI_SWAP_CHAIN_DESC", [ + (DXGI_MODE_DESC, "BufferDesc"), + (DXGI_SAMPLE_DESC, "SampleDesc"), + (DXGI_USAGE, "BufferUsage"), + (UINT, "BufferCount"), + (HWND, "OutputWindow"), + (BOOL, "Windowed"), + (DXGI_SWAP_EFFECT, "SwapEffect"), + (UINT, "Flags"), +]) + +DXGI_SHARED_RESOURCE = Struct("DXGI_SHARED_RESOURCE", [ + (HANDLE, "Handle"), +]) + +IDXGIObject = Interface("IDXGIObject", IUnknown) +IDXGIObject.methods += [ + Method(HRESULT, "SetPrivateData", [(REFGUID, "guid"), (UINT, "data_size"), (Const(OpaquePointer(Void)), "data")]), + Method(HRESULT, "SetPrivateDataInterface", [(REFGUID, "guid"), (Const(OpaquePointer(IUnknown)), "object")]), + Method(HRESULT, "GetPrivateData", [(REFGUID, "guid"), Out(OpaquePointer(UINT), "data_size"), Out(OpaquePointer(Void), "data")]), + Method(HRESULT, "GetParent", [(REFIID, "riid"), Out(OpaquePointer(OpaquePointer(Void)), "parent")]), +] + +IDXGIDeviceSubObject = Interface("IDXGIDeviceSubObject", IDXGIObject) +IDXGIDeviceSubObject.methods += [ + Method(HRESULT, "GetDevice", [(REFIID, "riid"), Out(OpaquePointer(OpaquePointer(Void)), "device")]), +] + +IDXGISurface = Interface("IDXGISurface", IDXGIDeviceSubObject) +IDXGISurface.methods += [ + Method(HRESULT, "GetDesc", [Out(OpaquePointer(DXGI_SURFACE_DESC), "desc")]), + Method(HRESULT, "Map", [Out(OpaquePointer(DXGI_MAPPED_RECT), "mapped_rect"), (UINT, "flags")]), + Method(HRESULT, "Unmap", []), +] + +IDXGIOutput = Interface("IDXGIOutput", IDXGIObject) +IDXGIOutput.methods += [ + Method(HRESULT, "GetDesc", [Out(OpaquePointer(DXGI_OUTPUT_DESC), "desc")]), + Method(HRESULT, "GetDisplayModeList", [(DXGI_FORMAT, "format"), (UINT, "flags"), Out(OpaquePointer(UINT), "mode_count"), Out(OpaquePointer(DXGI_MODE_DESC), "desc")]), + Method(HRESULT, "FindClosestMatchingMode", [(Const(OpaquePointer(DXGI_MODE_DESC)), "mode"), Out(OpaquePointer(DXGI_MODE_DESC), "closest_match"), (OpaquePointer(IUnknown), "device")]), + Method(HRESULT, "WaitForVBlank", []), + Method(HRESULT, "TakeOwnership", [(OpaquePointer(IUnknown), "device"), (BOOL, "exclusive")]), + Method(Void, "ReleaseOwnership", []), + Method(HRESULT, "GetGammaControlCapabilities", [Out(OpaquePointer(DXGI_GAMMA_CONTROL_CAPABILITIES), "gamma_caps")]), + Method(HRESULT, "SetGammaControl", [(Const(OpaquePointer(DXGI_GAMMA_CONTROL)), "gamma_control")]), + Method(HRESULT, "GetGammaControl", [Out(OpaquePointer(DXGI_GAMMA_CONTROL), "gamma_control")]), + Method(HRESULT, "SetDisplaySurface", [(OpaquePointer(IDXGISurface), "surface")]), + Method(HRESULT, "GetDisplaySurfaceData", [(OpaquePointer(IDXGISurface), "surface")]), + Method(HRESULT, "GetFrameStatistics", [Out(OpaquePointer(DXGI_FRAME_STATISTICS), "stats")]), +] + +IDXGIAdapter = Interface("IDXGIAdapter", IDXGIObject) +IDXGIAdapter.methods += [ + Method(HRESULT, "EnumOutputs", [(UINT, "output_idx"), Out(OpaquePointer(OpaquePointer(IDXGIOutput)), "output")]), + Method(HRESULT, "GetDesc", [Out(OpaquePointer(DXGI_ADAPTER_DESC), "desc")]), + Method(HRESULT, "CheckInterfaceSupport", [(REFGUID, "guid"), Out(OpaquePointer(LARGE_INTEGER), "umd_version")]), +] + +IDXGISwapChain = Interface("IDXGISwapChain", IDXGIDeviceSubObject) +IDXGISwapChain.methods += [ + Method(HRESULT, "Present", [(UINT, "sync_interval"), (UINT, "flags")]), + Method(HRESULT, "GetBuffer", [(UINT, "buffer_idx"), (REFIID, "riid"), Out(OpaquePointer(OpaquePointer(Void)), "surface")]), + Method(HRESULT, "SetFullscreenState", [(BOOL, "fullscreen"), (OpaquePointer(IDXGIOutput), "target")]), + Method(HRESULT, "GetFullscreenState", [Out(OpaquePointer(BOOL), "fullscreen"), Out(OpaquePointer(OpaquePointer(IDXGIOutput)), "target")]), + Method(HRESULT, "GetDesc", [Out(OpaquePointer(DXGI_SWAP_CHAIN_DESC), "desc")]), + Method(HRESULT, "ResizeBuffers", [(UINT, "buffer_count"), (UINT, "width"), (UINT, "height"), (DXGI_FORMAT, "format"), (UINT, "flags")]), + Method(HRESULT, "ResizeTarget", [(Const(OpaquePointer(DXGI_MODE_DESC)), "target_mode_desc")]), + Method(HRESULT, "GetContainingOutput", [Out(OpaquePointer(OpaquePointer(IDXGIOutput)), "output")]), + Method(HRESULT, "GetFrameStatistics", [Out(OpaquePointer(DXGI_FRAME_STATISTICS), "stats")]), + Method(HRESULT, "GetLastPresentCount", [Out(OpaquePointer(UINT), "last_present_count")]), +] + +IDXGIFactory = Interface("IDXGIFactory", IDXGIObject) +IDXGIFactory.methods += [ + Method(HRESULT, "EnumAdapters", [(UINT, "adapter_idx"), Out(OpaquePointer(OpaquePointer(IDXGIAdapter)), "adapter")]), + Method(HRESULT, "MakeWindowAssociation", [(HWND, "window"), (UINT, "flags")]), + Method(HRESULT, "GetWindowAssociation", [(OpaquePointer(HWND), "window")]), + Method(HRESULT, "CreateSwapChain", [(OpaquePointer(IUnknown), "device"), (OpaquePointer(DXGI_SWAP_CHAIN_DESC), "desc"), Out(OpaquePointer(OpaquePointer(IDXGISwapChain)), "swapchain")]), + Method(HRESULT, "CreateSoftwareAdapter", [(HMODULE, "swrast"), Out(OpaquePointer(OpaquePointer(IDXGIAdapter)), "adapter")]), +] + +#StdFunction(HRESULT, "CreateDXGIFactory", [(REFIID, "riid"), (OpaquePointer(OpaquePointer(Void)), "factory")]), + +IDXGIDevice = Interface("IDXGIDevice", IDXGIObject) +IDXGIDevice.methods += [ + Method(HRESULT, "GetAdapter", [Out(OpaquePointer(OpaquePointer(IDXGIAdapter)), "adapter")]), + Method(HRESULT, "CreateSurface", [(Const(OpaquePointer(DXGI_SURFACE_DESC)), "desc"), (UINT, "surface_count"), (DXGI_USAGE, "usage"), (Const(OpaquePointer(DXGI_SHARED_RESOURCE)), "shared_resource"), Out(OpaquePointer(OpaquePointer(IDXGISurface)), "surface")]), + Method(HRESULT, "QueryResourceResidency", [(OpaquePointer(Const(OpaquePointer(IUnknown))), "resources"), Out(OpaquePointer(DXGI_RESIDENCY), "residency"), (UINT, "resource_count")]), + Method(HRESULT, "SetGPUThreadPriority", [(INT, "priority")]), + Method(HRESULT, "GetGPUThreadPriority", [Out(OpaquePointer(INT), "priority")]), +] + diff --git a/dxgiformat.py b/dxgiformat.py new file mode 100644 index 0000000..1d00f64 --- /dev/null +++ b/dxgiformat.py @@ -0,0 +1,107 @@ + +from winapi import * + +DXGI_FORMAT = Enum("DXGI_FORMAT", [ + "DXGI_FORMAT_UNKNOWN", + "DXGI_FORMAT_R32G32B32A32_TYPELESS", + "DXGI_FORMAT_R32G32B32A32_FLOAT", + "DXGI_FORMAT_R32G32B32A32_UINT", + "DXGI_FORMAT_R32G32B32A32_SINT", + "DXGI_FORMAT_R32G32B32_TYPELESS", + "DXGI_FORMAT_R32G32B32_FLOAT", + "DXGI_FORMAT_R32G32B32_UINT", + "DXGI_FORMAT_R32G32B32_SINT", + "DXGI_FORMAT_R16G16B16A16_TYPELESS", + "DXGI_FORMAT_R16G16B16A16_FLOAT", + "DXGI_FORMAT_R16G16B16A16_UNORM", + "DXGI_FORMAT_R16G16B16A16_UINT", + "DXGI_FORMAT_R16G16B16A16_SNORM", + "DXGI_FORMAT_R16G16B16A16_SINT", + "DXGI_FORMAT_R32G32_TYPELESS", + "DXGI_FORMAT_R32G32_FLOAT", + "DXGI_FORMAT_R32G32_UINT", + "DXGI_FORMAT_R32G32_SINT", + "DXGI_FORMAT_R32G8X24_TYPELESS", + "DXGI_FORMAT_D32_FLOAT_S8X24_UINT", + "DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS", + "DXGI_FORMAT_X32_TYPELESS_G8X24_UINT", + "DXGI_FORMAT_R10G10B10A2_TYPELESS", + "DXGI_FORMAT_R10G10B10A2_UNORM", + "DXGI_FORMAT_R10G10B10A2_UINT", + "DXGI_FORMAT_R11G11B10_FLOAT", + "DXGI_FORMAT_R8G8B8A8_TYPELESS", + "DXGI_FORMAT_R8G8B8A8_UNORM", + "DXGI_FORMAT_R8G8B8A8_UNORM_SRGB", + "DXGI_FORMAT_R8G8B8A8_UINT", + "DXGI_FORMAT_R8G8B8A8_SNORM", + "DXGI_FORMAT_R8G8B8A8_SINT", + "DXGI_FORMAT_R16G16_TYPELESS", + "DXGI_FORMAT_R16G16_FLOAT", + "DXGI_FORMAT_R16G16_UNORM", + "DXGI_FORMAT_R16G16_UINT", + "DXGI_FORMAT_R16G16_SNORM", + "DXGI_FORMAT_R16G16_SINT", + "DXGI_FORMAT_R32_TYPELESS", + "DXGI_FORMAT_D32_FLOAT", + "DXGI_FORMAT_R32_FLOAT", + "DXGI_FORMAT_R32_UINT", + "DXGI_FORMAT_R32_SINT", + "DXGI_FORMAT_R24G8_TYPELESS", + "DXGI_FORMAT_D24_UNORM_S8_UINT", + "DXGI_FORMAT_R24_UNORM_X8_TYPELESS", + "DXGI_FORMAT_X24_TYPELESS_G8_UINT", + "DXGI_FORMAT_R8G8_TYPELESS", + "DXGI_FORMAT_R8G8_UNORM", + "DXGI_FORMAT_R8G8_UINT", + "DXGI_FORMAT_R8G8_SNORM", + "DXGI_FORMAT_R8G8_SINT", + "DXGI_FORMAT_R16_TYPELESS", + "DXGI_FORMAT_R16_FLOAT", + "DXGI_FORMAT_D16_UNORM", + "DXGI_FORMAT_R16_UNORM", + "DXGI_FORMAT_R16_UINT", + "DXGI_FORMAT_R16_SNORM", + "DXGI_FORMAT_R16_SINT", + "DXGI_FORMAT_R8_TYPELESS", + "DXGI_FORMAT_R8_UNORM", + "DXGI_FORMAT_R8_UINT", + "DXGI_FORMAT_R8_SNORM", + "DXGI_FORMAT_R8_SINT", + "DXGI_FORMAT_A8_UNORM", + "DXGI_FORMAT_R1_UNORM", + "DXGI_FORMAT_R9G9B9E5_SHAREDEXP", + "DXGI_FORMAT_R8G8_B8G8_UNORM", + "DXGI_FORMAT_G8R8_G8B8_UNORM", + "DXGI_FORMAT_BC1_TYPELESS", + "DXGI_FORMAT_BC1_UNORM", + "DXGI_FORMAT_BC1_UNORM_SRGB", + "DXGI_FORMAT_BC2_TYPELESS", + "DXGI_FORMAT_BC2_UNORM", + "DXGI_FORMAT_BC2_UNORM_SRGB", + "DXGI_FORMAT_BC3_TYPELESS", + "DXGI_FORMAT_BC3_UNORM", + "DXGI_FORMAT_BC3_UNORM_SRGB", + "DXGI_FORMAT_BC4_TYPELESS", + "DXGI_FORMAT_BC4_UNORM", + "DXGI_FORMAT_BC4_SNORM", + "DXGI_FORMAT_BC5_TYPELESS", + "DXGI_FORMAT_BC5_UNORM", + "DXGI_FORMAT_BC5_SNORM", + "DXGI_FORMAT_B5G6R5_UNORM", + "DXGI_FORMAT_B5G5R5A1_UNORM", + "DXGI_FORMAT_B8G8R8A8_UNORM", + "DXGI_FORMAT_B8G8R8X8_UNORM", + "DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM", + "DXGI_FORMAT_B8G8R8A8_TYPELESS", + "DXGI_FORMAT_B8G8R8A8_UNORM_SRGB", + "DXGI_FORMAT_B8G8R8X8_TYPELESS", + "DXGI_FORMAT_B8G8R8X8_UNORM_SRGB", + "DXGI_FORMAT_BC6H_TYPELESS", + "DXGI_FORMAT_BC6H_UF16", + "DXGI_FORMAT_BC6H_SF16", + "DXGI_FORMAT_BC7_TYPELESS", + "DXGI_FORMAT_BC7_UNORM", + "DXGI_FORMAT_BC7_UNORM_SRGB", + "DXGI_FORMAT_FORCE_UINT", +]) + diff --git a/dxgitype.py b/dxgitype.py new file mode 100644 index 0000000..31cadde --- /dev/null +++ b/dxgitype.py @@ -0,0 +1,87 @@ +########################################################################## +# +# Copyright 2011 Jose Fonseca +# All Rights Reserved. +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +##########################################################################/ + +from dxgiformat import * + +DXGI_RGB = Struct("DXGI_RGB", [ + (Float, "Red"), + (Float, "Green"), + (Float, "Blue"), +]) + +DXGI_GAMMA_CONTROL = Struct("DXGI_GAMMA_CONTROL", [ + (DXGI_RGB, "Scale"), + (DXGI_RGB, "Offset"), + (Array(DXGI_RGB, "1025"), "GammaCurve"), +]) + +DXGI_GAMMA_CONTROL_CAPABILITIES = Struct("DXGI_GAMMA_CONTROL_CAPABILITIES", [ + (BOOL, "ScaleAndOffsetSupported"), + (Float, "MaxConvertedValue"), + (Float, "MinConvertedValue"), + (UINT, "NumGammaControlPoints"), + (Array(Float, "1025"), "ControlPointPositions"), +]) + +DXGI_RATIONAL = Struct("DXGI_RATIONAL", [ + (UINT, "Numerator"), + (UINT, "Denominator"), +]) + +DXGI_MODE_SCANLINE_ORDER = Enum("DXGI_MODE_SCANLINE_ORDER", [ + "DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED", + "DXGI_MODE_SCANLINE_ORDER_PROGRESSIVE", + "DXGI_MODE_SCANLINE_ORDER_UPPER_FIELD_FIRST", + "DXGI_MODE_SCANLINE_ORDER_LOWER_FIELD_FIRST", +]) + +DXGI_MODE_SCALING = Enum("DXGI_MODE_SCALING", [ + "DXGI_MODE_SCALING_UNSPECIFIED", + "DXGI_MODE_SCALING_CENTERED", + "DXGI_MODE_SCALING_STRETCHED", +]) + +DXGI_MODE_ROTATION = Enum("DXGI_MODE_ROTATION", [ + "DXGI_MODE_ROTATION_UNSPECIFIED", + "DXGI_MODE_ROTATION_IDENTITY", + "DXGI_MODE_ROTATION_ROTATE90", + "DXGI_MODE_ROTATION_ROTATE180", + "DXGI_MODE_ROTATION_ROTATE270", +]) + +DXGI_MODE_DESC = Struct("DXGI_MODE_DESC", [ + (UINT, "Width"), + (UINT, "Height"), + (DXGI_RATIONAL, "RefreshRate"), + (DXGI_FORMAT, "Format"), + (DXGI_MODE_SCANLINE_ORDER, "ScanlineOrdering"), + (DXGI_MODE_SCALING, "Scaling"), +]) + +DXGI_SAMPLE_DESC = Struct("DXGI_SAMPLE_DESC", [ + (UINT, "Count"), + (UINT, "Quality"), +]) + diff --git a/winapi.py b/winapi.py index ee9c91f..17256aa 100644 --- a/winapi.py +++ b/winapi.py @@ -36,13 +36,20 @@ ULONG = Alias("ULONG", ULong) LONGLONG = Alias("LONGLONG", LongLong) FLOAT = Alias("FLOAT", Float) -INT32 = Literal("INT32", "SInt") -UINT32 = Literal("UINT32", "UInt") +INT8 = Alias("INT8", Int8) +UINT8 = Alias("UINT8", UInt8) +INT16 = Alias("INT16", Int16) +UINT16 = Alias("UINT16", UInt16) +INT32 = Alias("INT32", Int32) +UINT32 = Alias("UINT32", UInt32) +INT64 = Alias("INT64", Int64) +UINT64 = Alias("UINT64", UInt64) BYTE = Literal("BYTE", "UInt", base=16) WORD = Literal("WORD", "UInt", base=16) DWORD = Literal("DWORD", "UInt", base=16) +WCHAR = Literal("WCHAR", "SInt") BOOL = Alias("BOOL", Bool)