Merge branch 'master' into d3d10

Conflicts:
	CMakeLists.txt

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 32f1498342d91932016c41d0c2b8a65c8c46dbc1..c9b740ccac465767ad1aeaded0b200a8e29ea0cf 100755 (executable)
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -265,17 +265,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}/d3d10trace.cpp
-    #        DEPENDS d3d10misc.py winapi.py stdapi.py
-    #    )
-    #    add_library (d3d10 MODULE d3d10.def d3d10trace.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 d3d10trace.cpp
+            COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/d3d10misc.py > ${CMAKE_CURRENT_BINARY_DIR}/d3d10trace.cpp
+            DEPENDS d3d10misc.py d3d10.py winapi.py stdapi.py
+        )
+        add_library (d3d10 MODULE d3d10.def d3d10trace.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 0ef10d34431e90da84f255b02fc369317b99b4bc..3cecaecfa5b786a0893a30897a1e3cced770f39a 100755 (executable)
--- 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 (file)
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 4553f190a820a6061cc9f22f89be5e9426b68c44..fdb485d3b3f8e59ff4244f02b30f79aed1c74653 100644 (file)
--- 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 <windows.h>'
     print '#include <tchar.h>'
     print
@@ -64,6 +65,5 @@ if __name__ == '__main__':
     print
     print '#include <d3d10.h>'
     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 (file)
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 (file)
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 (file)
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 ee9c91f94b0ecbcc96d925eecd3d44eee6f3e9f0..17256aaec759c7eeabad190e46735ef0503ff1f1 100644 (file)
--- 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)