Overview
| SHA1 Hash: | f66eeaeeda02ff0e61a97d14b91d88bfb70c53a3 |
|---|---|
| Date: | 2015-05-05 07:16:23 |
| User: | kinaba |
| Comment: | Remove Unnecessary directx headers. |
| Timelines: | family | ancestors | descendants | both | trunk |
| Downloads: | Tarball | ZIP archive |
| Other Links: | files | file ages | manifest |
Tags And Properties
- branch=trunk inherited from [29cd5b1dde]
- sym-trunk inherited from [29cd5b1dde]
Changes
Deleted src/win32/directx/d3d10.d version [440959a663efe1fe]
1 /***********************************************************************\ < 2 * d3d10.d * < 3 * * < 4 * Windows API header module * < 5 * * < 6 * Placed into public domain * < 7 \***********************************************************************/ < 8 module win32.directx.d3d10; < 9 < 10 private import win32.windows; < 11 < 12 public import win32.directx.dxgitype; < 13 public import win32.directx.dxgi; < 14 public import win32.directx.d3d10misc; < 15 < 16 pragma(lib, "d3d10.lib"); < 17 < 18 const D3D10_16BIT_INDEX_STRIP_CUT_VALUE = 0xffff; < 19 const D3D10_32BIT_INDEX_STRIP_CUT_VALUE = 0xffffffff; < 20 const D3D10_8BIT_INDEX_STRIP_CUT_VALUE = 0xff; < 21 const D3D10_ARRAY_AXIS_ADDRESS_RANGE_BIT_COUNT = 9; < 22 const D3D10_CLIP_OR_CULL_DISTANCE_COUNT = 8; < 23 const D3D10_CLIP_OR_CULL_DISTANCE_ELEMENT_COUNT = 2; < 24 const D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT = 14; < 25 const D3D10_COMMONSHADER_CONSTANT_BUFFER_COMPONENTS = 4; < 26 const D3D10_COMMONSHADER_CONSTANT_BUFFER_COMPONENT_BIT_COUNT = 32; < 27 const D3D10_COMMONSHADER_CONSTANT_BUFFER_HW_SLOT_COUNT = 15; < 28 const D3D10_COMMONSHADER_CONSTANT_BUFFER_REGISTER_COMPONENTS = 4; < 29 const D3D10_COMMONSHADER_CONSTANT_BUFFER_REGISTER_COUNT = 15; < 30 const D3D10_COMMONSHADER_CONSTANT_BUFFER_REGISTER_READS_PER_INST = 1; < 31 const D3D10_COMMONSHADER_CONSTANT_BUFFER_REGISTER_READ_PORTS = 1; < 32 const D3D10_COMMONSHADER_FLOWCONTROL_NESTING_LIMIT = 64; < 33 const D3D10_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_COMPONENTS = 4; < 34 const D3D10_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_COUNT = 1; < 35 const D3D10_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_READS_PER_INST = 1; < 36 const D3D10_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_READ_PORTS = 1; < 37 const D3D10_COMMONSHADER_IMMEDIATE_VALUE_COMPONENT_BIT_COUNT = 32; < 38 const D3D10_COMMONSHADER_INPUT_RESOURCE_REGISTER_COMPONENTS = 1; < 39 const D3D10_COMMONSHADER_INPUT_RESOURCE_REGISTER_COUNT = 128; < 40 const D3D10_COMMONSHADER_INPUT_RESOURCE_REGISTER_READS_PER_INST = 1; < 41 const D3D10_COMMONSHADER_INPUT_RESOURCE_REGISTER_READ_PORTS = 1; < 42 const D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT = 128; < 43 const D3D10_COMMONSHADER_SAMPLER_REGISTER_COMPONENTS = 1; < 44 const D3D10_COMMONSHADER_SAMPLER_REGISTER_COUNT = 16; < 45 const D3D10_COMMONSHADER_SAMPLER_REGISTER_READS_PER_INST = 1; < 46 const D3D10_COMMONSHADER_SAMPLER_REGISTER_READ_PORTS = 1; < 47 const D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT = 16; < 48 const D3D10_COMMONSHADER_SUBROUTINE_NESTING_LIMIT = 32; < 49 const D3D10_COMMONSHADER_TEMP_REGISTER_COMPONENTS = 4; < 50 const D3D10_COMMONSHADER_TEMP_REGISTER_COMPONENT_BIT_COUNT = 32; < 51 const D3D10_COMMONSHADER_TEMP_REGISTER_COUNT = 4096; < 52 const D3D10_COMMONSHADER_TEMP_REGISTER_READS_PER_INST = 3; < 53 const D3D10_COMMONSHADER_TEMP_REGISTER_READ_PORTS = 3; < 54 const D3D10_COMMONSHADER_TEXCOORD_RANGE_REDUCTION_MAX = 10; < 55 const D3D10_COMMONSHADER_TEXCOORD_RANGE_REDUCTION_MIN = -10; < 56 const D3D10_COMMONSHADER_TEXEL_OFFSET_MAX_NEGATIVE = -8; < 57 const D3D10_COMMONSHADER_TEXEL_OFFSET_MAX_POSITIVE = 7; < 58 const D3D10_DEFAULT_BLEND_FACTOR_ALPHA = 1.0f; < 59 const D3D10_DEFAULT_BLEND_FACTOR_BLUE = 1.0f; < 60 const D3D10_DEFAULT_BLEND_FACTOR_GREEN = 1.0f; < 61 const D3D10_DEFAULT_BLEND_FACTOR_RED = 1.0f; < 62 const D3D10_DEFAULT_BORDER_COLOR_COMPONENT = 0.0f; < 63 const D3D10_DEFAULT_DEPTH_BIAS = 0; < 64 const D3D10_DEFAULT_DEPTH_BIAS_CLAMP = 0.0f; < 65 const D3D10_DEFAULT_MAX_ANISOTROPY = 16.0f; < 66 const D3D10_DEFAULT_MIP_LOD_BIAS = 0.0f; < 67 const D3D10_DEFAULT_RENDER_TARGET_ARRAY_INDEX = 0; < 68 const D3D10_DEFAULT_SAMPLE_MASK = 0xffffffff; < 69 const D3D10_DEFAULT_SCISSOR_ENDX = 0; < 70 const D3D10_DEFAULT_SCISSOR_ENDY = 0; < 71 const D3D10_DEFAULT_SCISSOR_STARTX = 0; < 72 const D3D10_DEFAULT_SCISSOR_STARTY = 0; < 73 const D3D10_DEFAULT_SLOPE_SCALED_DEPTH_BIAS = 0.0f; < 74 const D3D10_DEFAULT_STENCIL_READ_MASK = 0xff; < 75 const D3D10_DEFAULT_STENCIL_REFERENCE = 0; < 76 const D3D10_DEFAULT_STENCIL_WRITE_MASK = 0xff; < 77 const D3D10_DEFAULT_VIEWPORT_AND_SCISSORRECT_INDEX = 0; < 78 const D3D10_DEFAULT_VIEWPORT_HEIGHT = 0; < 79 const D3D10_DEFAULT_VIEWPORT_MAX_DEPTH = 0.0f; < 80 const D3D10_DEFAULT_VIEWPORT_MIN_DEPTH = 0.0f; < 81 const D3D10_DEFAULT_VIEWPORT_TOPLEFTX = 0; < 82 const D3D10_DEFAULT_VIEWPORT_TOPLEFTY = 0; < 83 const D3D10_DEFAULT_VIEWPORT_WIDTH = 0; < 84 const D3D10_FLOAT16_FUSED_TOLERANCE_IN_ULP = 0.6; < 85 const D3D10_FLOAT32_MAX = 3.402823466e+38f; < 86 const D3D10_FLOAT32_TO_INTEGER_TOLERANCE_IN_ULP = 0.6f; < 87 const D3D10_FLOAT_TO_SRGB_EXPONENT_DENOMINATOR = 2.4f; < 88 const D3D10_FLOAT_TO_SRGB_EXPONENT_NUMERATOR = 1.0f; < 89 const D3D10_FLOAT_TO_SRGB_OFFSET = 0.055f; < 90 const D3D10_FLOAT_TO_SRGB_SCALE_1 = 12.92f; < 91 const D3D10_FLOAT_TO_SRGB_SCALE_2 = 1.055f; < 92 const D3D10_FLOAT_TO_SRGB_THRESHOLD = 0.0031308f; < 93 const D3D10_FTOI_INSTRUCTION_MAX_INPUT = 2147483647.999f; < 94 const D3D10_FTOI_INSTRUCTION_MIN_INPUT = -2147483648.999f; < 95 const D3D10_FTOU_INSTRUCTION_MAX_INPUT = 4294967295.999f; < 96 const D3D10_FTOU_INSTRUCTION_MIN_INPUT = 0.0f; < 97 const D3D10_GS_INPUT_PRIM_CONST_REGISTER_COMPONENTS = 1; < 98 const D3D10_GS_INPUT_PRIM_CONST_REGISTER_COMPONENT_BIT_COUNT = 32; < 99 const D3D10_GS_INPUT_PRIM_CONST_REGISTER_COUNT = 1; < 100 const D3D10_GS_INPUT_PRIM_CONST_REGISTER_READS_PER_INST = 2; < 101 const D3D10_GS_INPUT_PRIM_CONST_REGISTER_READ_PORTS = 1; < 102 const D3D10_GS_INPUT_REGISTER_COMPONENTS = 4; < 103 const D3D10_GS_INPUT_REGISTER_COMPONENT_BIT_COUNT = 32; < 104 const D3D10_GS_INPUT_REGISTER_COUNT = 16; < 105 const D3D10_GS_INPUT_REGISTER_READS_PER_INST = 2; < 106 const D3D10_GS_INPUT_REGISTER_READ_PORTS = 1; < 107 const D3D10_GS_INPUT_REGISTER_VERTICES = 6; < 108 const D3D10_GS_OUTPUT_ELEMENTS = 32; < 109 const D3D10_GS_OUTPUT_REGISTER_COMPONENTS = 4; < 110 const D3D10_GS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT = 32; < 111 const D3D10_GS_OUTPUT_REGISTER_COUNT = 32; < 112 const D3D10_IA_DEFAULT_INDEX_BUFFER_OFFSET_IN_BYTES = 0; < 113 const D3D10_IA_DEFAULT_PRIMITIVE_TOPOLOGY = 0; < 114 const D3D10_IA_DEFAULT_VERTEX_BUFFER_OFFSET_IN_BYTES = 0; < 115 const D3D10_IA_INDEX_INPUT_RESOURCE_SLOT_COUNT = 1; < 116 const D3D10_IA_INSTANCE_ID_BIT_COUNT = 32; < 117 const D3D10_IA_INTEGER_ARITHMETIC_BIT_COUNT = 32; < 118 const D3D10_IA_PRIMITIVE_ID_BIT_COUNT = 32; < 119 const D3D10_IA_VERTEX_ID_BIT_COUNT = 32; < 120 const D3D10_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT = 16; < 121 const D3D10_IA_VERTEX_INPUT_STRUCTURE_ELEMENTS_COMPONENTS = 64; < 122 const D3D10_IA_VERTEX_INPUT_STRUCTURE_ELEMENT_COUNT = 16; < 123 const D3D10_INTEGER_DIVIDE_BY_ZERO_QUOTIENT = 0xffffffff; < 124 const D3D10_INTEGER_DIVIDE_BY_ZERO_REMAINDER = 0xffffffff; < 125 const D3D10_LINEAR_GAMMA = 1.0f; < 126 const D3D10_MAX_BORDER_COLOR_COMPONENT = 1.0f; < 127 const D3D10_MAX_DEPTH = 1.0f; < 128 const D3D10_MAX_MAXANISOTROPY = 16; < 129 const D3D10_MAX_MULTISAMPLE_SAMPLE_COUNT = 32; < 130 const D3D10_MAX_POSITION_VALUE = 3.402823466e+34f; < 131 const D3D10_MAX_TEXTURE_DIMENSION_2_TO_EXP = 17; < 132 const D3D10_MIN_BORDER_COLOR_COMPONENT = 0.0f; < 133 const D3D10_MIN_DEPTH = 0.0f; < 134 const D3D10_MIN_MAXANISOTROPY = 0; < 135 const D3D10_MIP_LOD_BIAS_MAX = 15.99f; < 136 const D3D10_MIP_LOD_BIAS_MIN = -16.0f; < 137 const D3D10_MIP_LOD_FRACTIONAL_BIT_COUNT = 6; < 138 const D3D10_MIP_LOD_RANGE_BIT_COUNT = 8; < 139 const D3D10_MULTISAMPLE_ANTIALIAS_LINE_WIDTH = 1.4f; < 140 const D3D10_NONSAMPLE_FETCH_OUT_OF_RANGE_ACCESS_RESULT = 0; < 141 const D3D10_PIXEL_ADDRESS_RANGE_BIT_COUNT = 13; < 142 const D3D10_PRE_SCISSOR_PIXEL_ADDRESS_RANGE_BIT_COUNT = 15; < 143 const D3D10_PS_FRONTFACING_DEFAULT_VALUE = 0xffffffff; < 144 const D3D10_PS_FRONTFACING_FALSE_VALUE = 0; < 145 const D3D10_PS_FRONTFACING_TRUE_VALUE = 0xffffffff; < 146 const D3D10_PS_INPUT_REGISTER_COMPONENTS = 4; < 147 const D3D10_PS_INPUT_REGISTER_COMPONENT_BIT_COUNT = 32; < 148 const D3D10_PS_INPUT_REGISTER_COUNT = 32; < 149 const D3D10_PS_INPUT_REGISTER_READS_PER_INST = 2; < 150 const D3D10_PS_INPUT_REGISTER_READ_PORTS = 1; < 151 const D3D10_PS_LEGACY_PIXEL_CENTER_FRACTIONAL_COMPONENT = 0.0f; < 152 const D3D10_PS_OUTPUT_DEPTH_REGISTER_COMPONENTS = 1; < 153 const D3D10_PS_OUTPUT_DEPTH_REGISTER_COMPONENT_BIT_COUNT = 32; < 154 const D3D10_PS_OUTPUT_DEPTH_REGISTER_COUNT = 1; < 155 const D3D10_PS_OUTPUT_REGISTER_COMPONENTS = 4; < 156 const D3D10_PS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT = 32; < 157 const D3D10_PS_OUTPUT_REGISTER_COUNT = 8; < 158 const D3D10_PS_PIXEL_CENTER_FRACTIONAL_COMPONENT = 0.5f; < 159 const D3D10_REQ_BLEND_OBJECT_COUNT_PER_CONTEXT = 4096; < 160 const D3D10_REQ_BUFFER_RESOURCE_TEXEL_COUNT_2_TO_EXP = 27; < 161 const D3D10_REQ_CONSTANT_BUFFER_ELEMENT_COUNT = 4096; < 162 const D3D10_REQ_DEPTH_STENCIL_OBJECT_COUNT_PER_CONTEXT = 4096; < 163 const D3D10_REQ_DRAWINDEXED_INDEX_COUNT_2_TO_EXP = 32; < 164 const D3D10_REQ_DRAW_VERTEX_COUNT_2_TO_EXP = 32; < 165 const D3D10_REQ_FILTERING_HW_ADDRESSABLE_RESOURCE_DIMENSION = 8192; < 166 const D3D10_REQ_GS_INVOCATION_32BIT_OUTPUT_COMPONENT_LIMIT = 1024; < 167 const D3D10_REQ_IMMEDIATE_CONSTANT_BUFFER_ELEMENT_COUNT = 4096; < 168 const D3D10_REQ_MAXANISOTROPY = 16; < 169 const D3D10_REQ_MIP_LEVELS = 14; < 170 const D3D10_REQ_MULTI_ELEMENT_STRUCTURE_SIZE_IN_BYTES = 2048; < 171 const D3D10_REQ_RASTERIZER_OBJECT_COUNT_PER_CONTEXT = 4096; < 172 const D3D10_REQ_RENDER_TO_BUFFER_WINDOW_WIDTH = 8192; < 173 const D3D10_REQ_RESOURCE_SIZE_IN_MEGABYTES = 128; < 174 const D3D10_REQ_RESOURCE_VIEW_COUNT_PER_CONTEXT_2_TO_EXP = 20; < 175 const D3D10_REQ_SAMPLER_OBJECT_COUNT_PER_CONTEXT = 4096; < 176 const D3D10_REQ_TEXTURE1D_ARRAY_AXIS_DIMENSION = 512; < 177 const D3D10_REQ_TEXTURE1D_U_DIMENSION = 8192; < 178 const D3D10_REQ_TEXTURE2D_ARRAY_AXIS_DIMENSION = 512; < 179 const D3D10_REQ_TEXTURE2D_U_OR_V_DIMENSION = 8192; < 180 const D3D10_REQ_TEXTURE3D_U_V_OR_W_DIMENSION = 2048; < 181 const D3D10_REQ_TEXTURECUBE_DIMENSION = 8192; < 182 const D3D10_RESINFO_INSTRUCTION_MISSING_COMPONENT_RETVAL = 0; < 183 const D3D10_SHADER_MAJOR_VERSION = 4; < 184 const D3D10_SHADER_MINOR_VERSION = 0; < 185 const D3D10_SHIFT_INSTRUCTION_PAD_VALUE = 0; < 186 const D3D10_SHIFT_INSTRUCTION_SHIFT_VALUE_BIT_COUNT = 5; < 187 const D3D10_SIMULTANEOUS_RENDER_TARGET_COUNT = 8; < 188 const D3D10_SO_BUFFER_MAX_STRIDE_IN_BYTES = 2048; < 189 const D3D10_SO_BUFFER_MAX_WRITE_WINDOW_IN_BYTES = 256; < 190 const D3D10_SO_BUFFER_SLOT_COUNT = 4; < 191 const D3D10_SO_DDI_REGISTER_INDEX_DENOTING_GAP = 0xffffffff; < 192 const D3D10_SO_MULTIPLE_BUFFER_ELEMENTS_PER_BUFFER = 1; < 193 const D3D10_SO_SINGLE_BUFFER_COMPONENT_LIMIT = 64; < 194 const D3D10_SRGB_GAMMA = 2.2f; < 195 const D3D10_SRGB_TO_FLOAT_DENOMINATOR_1 = 12.92f; < 196 const D3D10_SRGB_TO_FLOAT_DENOMINATOR_2 = 1.055f; < 197 const D3D10_SRGB_TO_FLOAT_EXPONENT = 2.4f; < 198 const D3D10_SRGB_TO_FLOAT_OFFSET = 0.055f; < 199 const D3D10_SRGB_TO_FLOAT_THRESHOLD = 0.04045f; < 200 const D3D10_SRGB_TO_FLOAT_TOLERANCE_IN_ULP = 0.5f; < 201 const D3D10_STANDARD_COMPONENT_BIT_COUNT = 32; < 202 const D3D10_STANDARD_COMPONENT_BIT_COUNT_DOUBLED = 64; < 203 const D3D10_STANDARD_MAXIMUM_ELEMENT_ALIGNMENT_BYTE_MULTIPLE = 4; < 204 const D3D10_STANDARD_PIXEL_COMPONENT_COUNT = 128; < 205 const D3D10_STANDARD_PIXEL_ELEMENT_COUNT = 32; < 206 const D3D10_STANDARD_VECTOR_SIZE = 4; < 207 const D3D10_STANDARD_VERTEX_ELEMENT_COUNT = 16; < 208 const D3D10_STANDARD_VERTEX_TOTAL_COMPONENT_COUNT = 64; < 209 const D3D10_SUBPIXEL_FRACTIONAL_BIT_COUNT = 8; < 210 const D3D10_SUBTEXEL_FRACTIONAL_BIT_COUNT = 6; < 211 const D3D10_TEXEL_ADDRESS_RANGE_BIT_COUNT = 18; < 212 const D3D10_UNBOUND_MEMORY_ACCESS_RESULT = 0; < 213 const D3D10_VIEWPORT_AND_SCISSORRECT_MAX_INDEX = 15; < 214 const D3D10_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE = 16; < 215 const D3D10_VIEWPORT_BOUNDS_MAX = 16383; < 216 const D3D10_VIEWPORT_BOUNDS_MIN = -16384; < 217 const D3D10_VS_INPUT_REGISTER_COMPONENTS = 4; < 218 const D3D10_VS_INPUT_REGISTER_COMPONENT_BIT_COUNT = 32; < 219 const D3D10_VS_INPUT_REGISTER_COUNT = 16; < 220 const D3D10_VS_INPUT_REGISTER_READS_PER_INST = 2; < 221 const D3D10_VS_INPUT_REGISTER_READ_PORTS = 1; < 222 const D3D10_VS_OUTPUT_REGISTER_COMPONENTS = 4; < 223 const D3D10_VS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT = 32; < 224 const D3D10_VS_OUTPUT_REGISTER_COUNT = 16; < 225 const D3D10_WHQL_CONTEXT_COUNT_FOR_RESOURCE_LIMIT = 10; < 226 const D3D10_WHQL_DRAWINDEXED_INDEX_COUNT_2_TO_EXP = 25; < 227 const D3D10_WHQL_DRAW_VERTEX_COUNT_2_TO_EXP = 25; < 228 const D3D_MAJOR_VERSION = 10; < 229 const D3D_MINOR_VERSION = 0; < 230 const D3D_SPEC_DATE_DAY = 8; < 231 const D3D_SPEC_DATE_MONTH = 8; < 232 const D3D_SPEC_DATE_YEAR = 2006; < 233 const D3D_SPEC_VERSION = 1.050005; < 234 < 235 const _FACD3D10 = 0x879; < 236 const _FACD3D10DEBUG = _FACD3D10 + 1; < 237 < 238 HRESULT MAKE_D3D10_HRESULT(T)(T code) { < 239 return MAKE_HRESULT(1, _FACD3D10, code); < 240 } < 241 < 242 HRESULT MAKE_D3D10_STATUS(T)(T code) { < 243 return MAKE_HRESULT(0, _FACD3D10, code); < 244 } < 245 < 246 const D3D10_ERROR_TOO_MANY_UNIQUE_STATE_OBJECTS = MAKE_D3D10_HRESULT(1); < 247 const D3D10_ERROR_FILE_NOT_FOUND = MAKE_D3D10_HRESULT(2); < 248 < 249 enum D3D10_INPUT_CLASSIFICATION { < 250 D3D10_INPUT_PER_VERTEX_DATA = 0, < 251 D3D10_INPUT_PER_INSTANCE_DATA = 1 < 252 } < 253 < 254 const D3D10_APPEND_ALIGNED_ELEMENT = 0xffffffff; < 255 < 256 struct D3D10_INPUT_ELEMENT_DESC { < 257 LPCSTR SemanticName; < 258 UINT SemanticIndex; < 259 DXGI_FORMAT Format; < 260 UINT InputSlot; < 261 UINT AlignedByteOffset; < 262 D3D10_INPUT_CLASSIFICATION InputSlotClass; < 263 UINT InstanceDataStepRate; < 264 } < 265 < 266 enum D3D10_FILL_MODE { < 267 D3D10_FILL_WIREFRAME = 2, < 268 D3D10_FILL_SOLID = 3 < 269 } < 270 < 271 enum D3D10_PRIMITIVE_TOPOLOGY { < 272 D3D10_PRIMITIVE_TOPOLOGY_UNDEFINED = 0, < 273 D3D10_PRIMITIVE_TOPOLOGY_POINTLIST = 1, < 274 D3D10_PRIMITIVE_TOPOLOGY_LINELIST = 2, < 275 D3D10_PRIMITIVE_TOPOLOGY_LINESTRIP = 3, < 276 D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST = 4, < 277 D3D10_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP = 5, < 278 D3D10_PRIMITIVE_TOPOLOGY_LINELIST_ADJ = 10, < 279 D3D10_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ = 11, < 280 D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ = 12, < 281 D3D10_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ = 13 < 282 } < 283 < 284 enum D3D10_PRIMITIVE { < 285 D3D10_PRIMITIVE_UNDEFINED = 0, < 286 D3D10_PRIMITIVE_POINT = 1, < 287 D3D10_PRIMITIVE_LINE = 2, < 288 D3D10_PRIMITIVE_TRIANGLE = 3, < 289 D3D10_PRIMITIVE_LINE_ADJ = 6, < 290 D3D10_PRIMITIVE_TRIANGLE_ADJ = 7 < 291 } < 292 < 293 enum D3D10_CULL_MODE { < 294 D3D10_CULL_NONE = 1, < 295 D3D10_CULL_FRONT, < 296 D3D10_CULL_BACK < 297 } < 298 < 299 struct D3D10_SO_DECLARATION_ENTRY { < 300 LPCSTR SemanticName; < 301 UINT SemanticIndex; < 302 BYTE StartComponent; < 303 BYTE ComponentCount; < 304 BYTE OutputSlot; < 305 } < 306 < 307 struct D3D10_VIEWPORT { < 308 INT TopLeftX; < 309 INT TopLeftY; < 310 UINT Width; < 311 UINT Height; < 312 FLOAT MinDepth; < 313 FLOAT MaxDepth; < 314 } < 315 < 316 enum D3D10_RESOURCE_DIMENSION { < 317 D3D10_RESOURCE_DIMENSION_UNKNOWN = 0, < 318 D3D10_RESOURCE_DIMENSION_BUFFER, < 319 D3D10_RESOURCE_DIMENSION_TEXTURE1D, < 320 D3D10_RESOURCE_DIMENSION_TEXTURE2D, < 321 D3D10_RESOURCE_DIMENSION_TEXTURE3D < 322 } < 323 < 324 enum D3D10_SRV_DIMENSION { < 325 D3D10_SRV_DIMENSION_UNKNOWN = 0, < 326 D3D10_SRV_DIMENSION_BUFFER, < 327 D3D10_SRV_DIMENSION_TEXTURE1D, < 328 D3D10_SRV_DIMENSION_TEXTURE1DARRAY, < 329 D3D10_SRV_DIMENSION_TEXTURE2D, < 330 D3D10_SRV_DIMENSION_TEXTURE2DARRAY, < 331 D3D10_SRV_DIMENSION_TEXTURE2DMS, < 332 D3D10_SRV_DIMENSION_TEXTURE2DMSARRAY, < 333 D3D10_SRV_DIMENSION_TEXTURE3D, < 334 D3D10_SRV_DIMENSION_TEXTURECUBE < 335 } < 336 < 337 enum D3D10_DSV_DIMENSION { < 338 D3D10_DSV_DIMENSION_UNKNOWN = 0, < 339 D3D10_DSV_DIMENSION_TEXTURE1D, < 340 D3D10_DSV_DIMENSION_TEXTURE1DARRAY, < 341 D3D10_DSV_DIMENSION_TEXTURE2D, < 342 D3D10_DSV_DIMENSION_TEXTURE2DARRAY, < 343 D3D10_DSV_DIMENSION_TEXTURE2DMS, < 344 D3D10_DSV_DIMENSION_TEXTURE2DMSARRAY6 < 345 } < 346 < 347 enum D3D10_RTV_DIMENSION { < 348 D3D10_RTV_DIMENSION_UNKNOWN = 0, < 349 D3D10_RTV_DIMENSION_BUFFER, < 350 D3D10_RTV_DIMENSION_TEXTURE1D, < 351 D3D10_RTV_DIMENSION_TEXTURE1DARRAY, < 352 D3D10_RTV_DIMENSION_TEXTURE2D, < 353 D3D10_RTV_DIMENSION_TEXTURE2DARRAY, < 354 D3D10_RTV_DIMENSION_TEXTURE2DMS, < 355 D3D10_RTV_DIMENSION_TEXTURE2DMSARRAY, < 356 D3D10_RTV_DIMENSION_TEXTURE3D < 357 } < 358 < 359 enum D3D10_USAGE { < 360 D3D10_USAGE_DEFAULT = 0, < 361 D3D10_USAGE_IMMUTABLE, < 362 D3D10_USAGE_DYNAMIC, < 363 D3D10_USAGE_STAGING < 364 } < 365 < 366 enum D3D10_BIND_FLAG { < 367 D3D10_BIND_VERTEX_BUFFER = 0x01, < 368 D3D10_BIND_INDEX_BUFFER = 0x02, < 369 D3D10_BIND_CONSTANT_BUFFER = 0x04, < 370 D3D10_BIND_SHADER_RESOURCE = 0x08, < 371 D3D10_BIND_STREAM_OUTPUT = 0x10, < 372 D3D10_BIND_RENDER_TARGET = 0x20, < 373 D3D10_BIND_DEPTH_STENCIL = 0x40 < 374 } < 375 < 376 enum D3D10_CPU_ACCESS_FLAG { < 377 D3D10_CPU_ACCESS_WRITE = 0x10000, < 378 D3D10_CPU_ACCESS_READ = 0x20000 < 379 } < 380 < 381 enum D3D10_RESOURCE_MISC_FLAG { < 382 D3D10_RESOURCE_MISC_GENERATE_MIPS = 0x01, < 383 D3D10_RESOURCE_MISC_SHARED = 0x02, < 384 D3D10_RESOURCE_MISC_TEXTURECUBE = 0x04 < 385 } < 386 < 387 enum D3D10_MAP { < 388 D3D10_MAP_READ = 1, < 389 D3D10_MAP_WRITE, < 390 D3D10_MAP_READ_WRITE, < 391 D3D10_MAP_WRITE_DISCARD, < 392 D3D10_MAP_WRITE_NO_OVERWRITE < 393 } < 394 < 395 enum D3D10_MAP_FLAG { < 396 D3D10_MAP_FLAG_DO_NOT_WAIT = 0x100000 < 397 } < 398 < 399 enum D3D10_RAISE_FLAG { < 400 D3D10_RAISE_FLAG_DRIVER_INTERNAL_ERROR = 0x01 < 401 } < 402 < 403 enum D3D10_CLEAR_FLAG { < 404 D3D10_CLEAR_DEPTH = 0x01, < 405 D3D10_CLEAR_STENCIL = 0x02 < 406 } < 407 < 408 alias RECT D3D10_RECT; < 409 < 410 struct D3D10_BOX { < 411 UINT left; < 412 UINT top; < 413 UINT front; < 414 UINT right; < 415 UINT bottom; < 416 UINT back; < 417 } < 418 < 419 extern (Windows) interface ID3D10DeviceChild : IUnknown { < 420 //extern(Windows) : < 421 void GetDevice(ID3D10Device* ppDevice); < 422 HRESULT GetPrivateData(REFGUID guid, UINT *pDataSize, void *pData); < 423 HRESULT SetPrivateData(REFGUID guid, UINT DataSize, void *pData); < 424 HRESULT SetPrivateDataInterface(REFGUID guid, IUnknown pData); < 425 } < 426 < 427 enum D3D10_COMPARISON_FUNC { < 428 D3D10_COMPARISON_NEVER = 1, < 429 D3D10_COMPARISON_LESS, < 430 D3D10_COMPARISON_EQUAL, < 431 D3D10_COMPARISON_LESS_EQUAL, < 432 D3D10_COMPARISON_GREATER, < 433 D3D10_COMPARISON_NOT_EQUAL, < 434 D3D10_COMPARISON_GREATER_EQUAL, < 435 D3D10_COMPARISON_ALWAYS < 436 } < 437 < 438 enum D3D10_DEPTH_WRITE_MASK { < 439 D3D10_DEPTH_WRITE_MASK_ZERO = 0, < 440 D3D10_DEPTH_WRITE_MASK_ALL < 441 } < 442 < 443 enum D3D10_STENCIL_OP { < 444 D3D10_STENCIL_OP_KEEP = 1, < 445 D3D10_STENCIL_OP_ZERO, < 446 D3D10_STENCIL_OP_REPLACE, < 447 D3D10_STENCIL_OP_INCR_SAT, < 448 D3D10_STENCIL_OP_DECR_SAT, < 449 D3D10_STENCIL_OP_INVERT, < 450 D3D10_STENCIL_OP_INCR, < 451 D3D10_STENCIL_OP_DECR < 452 } < 453 < 454 struct D3D10_DEPTH_STENCILOP_DESC { < 455 D3D10_STENCIL_OP StencilFailOp; < 456 D3D10_STENCIL_OP StencilDepthFailOp; < 457 D3D10_STENCIL_OP StencilPassOp; < 458 D3D10_COMPARISON_FUNC StencilFunc; < 459 } < 460 < 461 struct D3D10_DEPTH_STENCIL_DESC { < 462 BOOL DepthEnable; < 463 D3D10_DEPTH_WRITE_MASK DepthWriteMask; < 464 D3D10_COMPARISON_FUNC DepthFunc; < 465 BOOL StencilEnable; < 466 UINT8 StencilReadMask; < 467 UINT8 StencilWriteMask; < 468 D3D10_DEPTH_STENCILOP_DESC FrontFace; < 469 D3D10_DEPTH_STENCILOP_DESC BackFace; < 470 } < 471 < 472 interface ID3D10DepthStencilState : ID3D10DeviceChild { < 473 extern(Windows) : < 474 void GetDesc(D3D10_DEPTH_STENCIL_DESC *pDesc); < 475 } < 476 < 477 enum D3D10_BLEND { < 478 D3D10_BLEND_ZERO = 1, < 479 D3D10_BLEND_ONE = 2, < 480 D3D10_BLEND_SRC_COLOR = 3, < 481 D3D10_BLEND_INV_SRC_COLOR = 4, < 482 D3D10_BLEND_SRC_ALPHA = 5, < 483 D3D10_BLEND_INV_SRC_ALPHA = 6, < 484 D3D10_BLEND_DEST_ALPHA = 7, < 485 D3D10_BLEND_INV_DEST_ALPHA = 8, < 486 D3D10_BLEND_DEST_COLOR = 9, < 487 D3D10_BLEND_INV_DEST_COLOR = 10, < 488 D3D10_BLEND_SRC_ALPHA_SAT = 11, < 489 D3D10_BLEND_BLEND_FACTOR = 14, < 490 D3D10_BLEND_INV_BLEND_FACTOR = 15, < 491 D3D10_BLEND_SRC1_COLOR = 16, < 492 D3D10_BLEND_INV_SRC1_COLOR = 17, < 493 D3D10_BLEND_SRC1_ALPHA = 18, < 494 D3D10_BLEND_INV_SRC1_ALPHA = 19 < 495 } < 496 < 497 enum D3D10_BLEND_OP { < 498 D3D10_BLEND_OP_ADD = 1, < 499 D3D10_BLEND_OP_SUBTRACT, < 500 D3D10_BLEND_OP_REV_SUBTRACT, < 501 D3D10_BLEND_OP_MIN, < 502 D3D10_BLEND_OP_MAX < 503 } < 504 < 505 enum D3D10_COLOR_WRITE_ENABLE { < 506 D3D10_COLOR_WRITE_ENABLE_RED = 1, < 507 D3D10_COLOR_WRITE_ENABLE_GREEN = 2, < 508 D3D10_COLOR_WRITE_ENABLE_BLUE = 4, < 509 D3D10_COLOR_WRITE_ENABLE_ALPHA = 8, < 510 D3D10_COLOR_WRITE_ENABLE_ALL = (((D3D10_COLOR_WRITE_ENABLE_RED | D3D1 < 511 } < 512 < 513 struct D3D10_BLEND_DESC { < 514 BOOL AlphaToCoverageEnable; < 515 BOOL[8] BlendEnable; < 516 D3D10_BLEND SrcBlend; < 517 D3D10_BLEND DestBlend; < 518 D3D10_BLEND_OP BlendOp; < 519 D3D10_BLEND SrcBlendAlpha; < 520 D3D10_BLEND DestBlendAlpha; < 521 D3D10_BLEND_OP BlendOpAlpha; < 522 UINT8[8] RenderTargetWriteMask; < 523 } < 524 < 525 interface ID3D10BlendState : ID3D10DeviceChild { < 526 extern(Windows) : < 527 void GetDesc(D3D10_BLEND_DESC *pDesc); < 528 } < 529 < 530 struct D3D10_RASTERIZER_DESC { < 531 D3D10_FILL_MODE FillMode; < 532 D3D10_CULL_MODE CullMode; < 533 BOOL FrontCounterClockwise; < 534 INT DepthBias; < 535 FLOAT DepthBiasClamp; < 536 FLOAT SlopeScaledDepthBias; < 537 BOOL DepthClipEnable; < 538 BOOL ScissorEnable; < 539 BOOL MultisampleEnable; < 540 BOOL AntialiasedLineEnable; < 541 } < 542 < 543 interface ID3D10RasterizerState : ID3D10DeviceChild { < 544 extern(Windows) : < 545 void GetDesc(D3D10_RASTERIZER_DESC *pDesc); < 546 } < 547 < 548 UINT D3D10CalcSubresource(UINT MipSlice, UINT ArraySlice, UINT MipLevels) { < 549 return MipSlice + ArraySlice * MipLevels; < 550 } < 551 < 552 struct D3D10_SUBRESOURCE_DATA { < 553 void *pSysMem; < 554 UINT SysMemPitch; < 555 UINT SysMemSlicePitch; < 556 } < 557 < 558 interface ID3D10Resource : ID3D10DeviceChild { < 559 extern(Windows) : < 560 void GetType(D3D10_RESOURCE_DIMENSION *rType); < 561 void SetEvictionPriority(UINT EvictionPriority); < 562 UINT GetEvictionPriority(); < 563 } < 564 < 565 struct D3D10_BUFFER_DESC { < 566 UINT ByteWidth; < 567 D3D10_USAGE Usage; < 568 UINT BindFlags; < 569 UINT CPUAccessFlags; < 570 UINT MiscFlags; < 571 } < 572 < 573 interface ID3D10Buffer : ID3D10Resource { < 574 extern(Windows) : < 575 HRESULT Map(D3D10_MAP MapType, UINT MapFlags, void **ppData); < 576 void Unmap(); < 577 void GetDesc(D3D10_BUFFER_DESC *pDesc); < 578 } < 579 < 580 struct D3D10_TEXTURE1D_DESC { < 581 UINT Width; < 582 UINT MipLevels; < 583 UINT ArraySize; < 584 DXGI_FORMAT Format; < 585 D3D10_USAGE Usage; < 586 UINT BindFlags; < 587 UINT CPUAccessFlags; < 588 UINT MiscFlags; < 589 } < 590 < 591 interface ID3D10Texture1D : ID3D10Resource { < 592 extern(Windows) : < 593 HRESULT Map(UINT Subresource, D3D10_MAP MapType, UINT MapFlags, void **p < 594 void Unmap(UINT Subresource); < 595 void GetDesc(D3D10_TEXTURE1D_DESC *pDesc); < 596 } < 597 < 598 struct D3D10_TEXTURE2D_DESC { < 599 UINT Width; < 600 UINT Height; < 601 UINT MipLevels; < 602 UINT ArraySize; < 603 DXGI_FORMAT Format; < 604 DXGI_SAMPLE_DESC SampleDesc; < 605 D3D10_USAGE Usage; < 606 UINT BindFlags; < 607 UINT CPUAccessFlags; < 608 UINT MiscFlags; < 609 } < 610 < 611 struct D3D10_MAPPED_TEXTURE2D { < 612 void *pData; < 613 UINT RowPitch; < 614 } < 615 < 616 interface ID3D10Texture2D : ID3D10Resource { < 617 extern(Windows) : < 618 HRESULT Map(UINT Subresource, D3D10_MAP MapType, UINT MapFlags, D3D10_MA < 619 void Unmap(UINT Subresource); < 620 void GetDesc(D3D10_TEXTURE2D_DESC *pDesc); < 621 } < 622 < 623 struct D3D10_TEXTURE3D_DESC { < 624 UINT Width; < 625 UINT Height; < 626 UINT Depth; < 627 UINT MipLevels; < 628 DXGI_FORMAT Format; < 629 D3D10_USAGE Usage; < 630 UINT BindFlags; < 631 UINT CPUAccessFlags; < 632 UINT MiscFlags; < 633 } < 634 < 635 struct D3D10_MAPPED_TEXTURE3D { < 636 void *pData; < 637 UINT RowPitch; < 638 UINT DepthPitch; < 639 } < 640 < 641 interface ID3D10Texture3D : ID3D10Resource { < 642 extern(Windows) : < 643 HRESULT Map(UINT Subresource, D3D10_MAP MapType, UINT MapFlags, D3D10_MA < 644 void Unmap(UINT Subresource); < 645 void GetDesc(D3D10_TEXTURE3D_DESC *pDesc); < 646 } < 647 < 648 enum D3D10_TEXTURECUBE_FACE { < 649 D3D10_TEXTURECUBE_FACE_POSITIVE_X = 0, < 650 D3D10_TEXTURECUBE_FACE_NEGATIVE_X, < 651 D3D10_TEXTURECUBE_FACE_POSITIVE_Y, < 652 D3D10_TEXTURECUBE_FACE_NEGATIVE_Y, < 653 D3D10_TEXTURECUBE_FACE_POSITIVE_Z, < 654 D3D10_TEXTURECUBE_FACE_NEGATIVE_Z < 655 } < 656 < 657 interface ID3D10View : ID3D10DeviceChild { < 658 extern(Windows) : < 659 void GetResource(ID3D10Resource *ppResource); < 660 } < 661 < 662 struct D3D10_BUFFER_SRV { < 663 UINT ElementOffset; < 664 UINT ElementWidth; < 665 } < 666 < 667 struct D3D10_TEX1D_SRV { < 668 UINT MostDetailedMip; < 669 UINT MipLevels; < 670 } < 671 < 672 struct D3D10_TEX1D_ARRAY_SRV { < 673 UINT MostDetailedMip; < 674 UINT MipLevels; < 675 UINT FirstArraySlice; < 676 UINT ArraySize; < 677 } < 678 < 679 struct D3D10_TEX2D_SRV { < 680 UINT MostDetailedMip; < 681 UINT MipLevels; < 682 } < 683 < 684 struct D3D10_TEX2D_ARRAY_SRV { < 685 UINT MostDetailedMip; < 686 UINT MipLevels; < 687 UINT FirstArraySlice; < 688 UINT ArraySize; < 689 } < 690 < 691 struct D3D10_TEX3D_SRV { < 692 UINT MostDetailedMip; < 693 UINT MipLevels; < 694 } < 695 < 696 struct D3D10_TEXCUBE_SRV { < 697 UINT MostDetailedMip; < 698 UINT MipLevels; < 699 } < 700 < 701 struct D3D10_TEX2DMS_SRV { < 702 UINT UnusedField_NothingToDefine; < 703 } < 704 < 705 struct D3D10_TEX2DMS_ARRAY_SRV { < 706 UINT FirstArraySlice; < 707 UINT ArraySize; < 708 } < 709 < 710 struct D3D10_SHADER_RESOURCE_VIEW_DESC { < 711 DXGI_FORMAT Format; < 712 D3D10_SRV_DIMENSION ViewDimension; < 713 union { < 714 D3D10_BUFFER_SRV Buffer; < 715 D3D10_TEX1D_SRV Texture1D; < 716 D3D10_TEX1D_ARRAY_SRV Texture1DArray; < 717 D3D10_TEX2D_SRV Texture2D; < 718 D3D10_TEX2D_ARRAY_SRV Texture2DArray; < 719 D3D10_TEX2DMS_SRV Texture2DMS; < 720 D3D10_TEX2DMS_ARRAY_SRV Texture2DMSArray; < 721 D3D10_TEX3D_SRV Texture3D; < 722 D3D10_TEXCUBE_SRV TextureCube; < 723 } < 724 } < 725 < 726 interface ID3D10ShaderResourceView : ID3D10View { < 727 extern(Windows) : < 728 void GetDesc(D3D10_SHADER_RESOURCE_VIEW_DESC *pDesc); < 729 } < 730 < 731 struct D3D10_BUFFER_RTV { < 732 UINT ElementOffset; < 733 UINT ElementWidth; < 734 } < 735 < 736 struct D3D10_TEX1D_RTV { < 737 UINT MipSlice; < 738 } < 739 < 740 struct D3D10_TEX1D_ARRAY_RTV { < 741 UINT MipSlice; < 742 UINT FirstArraySlice; < 743 UINT ArraySize; < 744 } < 745 < 746 struct D3D10_TEX2D_RTV { < 747 UINT MipSlice; < 748 } < 749 < 750 struct D3D10_TEX2DMS_RTV { < 751 UINT UnusedField_NothingToDefine; < 752 } < 753 < 754 struct D3D10_TEX2D_ARRAY_RTV { < 755 UINT MipSlice; < 756 UINT FirstArraySlice; < 757 UINT ArraySize; < 758 } < 759 < 760 struct D3D10_TEX2DMS_ARRAY_RTV { < 761 UINT FirstArraySlice; < 762 UINT ArraySize; < 763 } < 764 < 765 struct D3D10_TEX3D_RTV { < 766 UINT MipSlice; < 767 UINT FirstWSlice; < 768 UINT WSize; < 769 } < 770 < 771 struct D3D10_RENDER_TARGET_VIEW_DESC { < 772 DXGI_FORMAT Format; < 773 D3D10_RTV_DIMENSION ViewDimension; < 774 union { < 775 D3D10_BUFFER_RTV Buffer; < 776 D3D10_TEX1D_RTV Texture1D; < 777 D3D10_TEX1D_ARRAY_RTV Texture1DArray; < 778 D3D10_TEX2D_RTV Texture2D; < 779 D3D10_TEX2D_ARRAY_RTV Texture2DArray; < 780 D3D10_TEX2DMS_RTV Texture2DMS; < 781 D3D10_TEX2DMS_ARRAY_RTV Texture2DMSArray; < 782 D3D10_TEX3D_RTV Texture3D; < 783 } < 784 } < 785 < 786 interface ID3D10RenderTargetView : ID3D10View { < 787 extern(Windows) : < 788 void GetDesc(D3D10_RENDER_TARGET_VIEW_DESC *pDesc); < 789 } < 790 < 791 struct D3D10_TEX1D_DSV { < 792 UINT MipSlice; < 793 } < 794 < 795 struct D3D10_TEX1D_ARRAY_DSV { < 796 UINT MipSlice; < 797 UINT FirstArraySlice; < 798 UINT ArraySize; < 799 } < 800 < 801 struct D3D10_TEX2D_DSV { < 802 UINT MipSlice; < 803 } < 804 < 805 struct D3D10_TEX2D_ARRAY_DSV { < 806 UINT MipSlice; < 807 UINT FirstArraySlice; < 808 UINT ArraySize; < 809 } < 810 < 811 struct D3D10_TEX2DMS_DSV { < 812 UINT UnusedField_NothingToDefine; < 813 } < 814 < 815 struct D3D10_TEX2DMS_ARRAY_DSV { < 816 UINT FirstArraySlice; < 817 UINT ArraySize; < 818 } < 819 < 820 struct D3D10_DEPTH_STENCIL_VIEW_DESC { < 821 DXGI_FORMAT Format; < 822 D3D10_DSV_DIMENSION ViewDimension; < 823 union { < 824 D3D10_TEX1D_DSV Texture1D; < 825 D3D10_TEX1D_ARRAY_DSV Texture1DArray; < 826 D3D10_TEX2D_DSV Texture2D; < 827 D3D10_TEX2D_ARRAY_DSV Texture2DArray; < 828 D3D10_TEX2DMS_DSV Texture2DMS; < 829 D3D10_TEX2DMS_ARRAY_DSV Texture2DMSArray; < 830 } < 831 } < 832 < 833 interface ID3D10DepthStencilView : ID3D10View { < 834 extern(Windows) : < 835 void GetDesc(D3D10_DEPTH_STENCIL_VIEW_DESC *pDesc); < 836 } < 837 < 838 interface ID3D10VertexShader : ID3D10DeviceChild { } < 839 < 840 interface ID3D10GeometryShader : ID3D10DeviceChild { } < 841 < 842 interface ID3D10PixelShader : ID3D10DeviceChild { } < 843 < 844 interface ID3D10InputLayout : ID3D10DeviceChild { } < 845 < 846 enum D3D10_FILTER { < 847 D3D10_FILTER_MIN_MAG_MIP_POINT < 848 D3D10_FILTER_MIN_MAG_POINT_MIP_LINEAR < 849 D3D10_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT < 850 D3D10_FILTER_MIN_POINT_MAG_MIP_LINEAR < 851 D3D10_FILTER_MIN_LINEAR_MAG_MIP_POINT < 852 D3D10_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x11, < 853 D3D10_FILTER_MIN_MAG_LINEAR_MIP_POINT < 854 D3D10_FILTER_MIN_MAG_MIP_LINEAR < 855 D3D10_FILTER_ANISOTROPIC < 856 D3D10_FILTER_COMPARISON_MIN_MAG_MIP_POINT < 857 D3D10_FILTER_COMPARISON_MIN_MAG_POINT_MIP_LINEAR = 0x81, < 858 D3D10_FILTER_COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x84, < 859 D3D10_FILTER_COMPARISON_MIN_POINT_MAG_MIP_LINEAR = 0x85, < 860 D3D10_FILTER_COMPARISON_MIN_LINEAR_MAG_MIP_POINT = 0x90, < 861 D3D10_FILTER_COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x91, < 862 D3D10_FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT = 0x94, < 863 D3D10_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR < 864 D3D10_FILTER_COMPARISON_ANISOTROPIC < 865 D3D10_FILTER_TEXT_1BIT < 866 } < 867 < 868 < 869 enum D3D10_FILTER_TYPE { < 870 D3D10_FILTER_TYPE_POINT = 0, < 871 D3D10_FILTER_TYPE_LINEAR < 872 } < 873 < 874 const D3D10_FILTER_TYPE_MASK = 0x03; < 875 < 876 const D3D10_MIN_FILTER_SHIFT = 4; < 877 < 878 const D3D10_MAG_FILTER_SHIFT = 2; < 879 < 880 const D3D10_MIP_FILTER_SHIFT = 0; < 881 < 882 const D3D10_COMPARISON_FILTERING_BIT = 0x80; < 883 < 884 const D3D10_ANISOTROPIC_FILTERING_BIT = 0x40; < 885 < 886 const D3D10_TEXT_1BIT_BIT = 0x80000000; < 887 < 888 D3D10_FILTER D3D10_ENCODE_BASIC_FILTER(int min, int mag, int mip, bool bComparis < 889 return cast(D3D10_FILTER)(((bComparison) ? D3D10_COMPARISON_FILTERING_BI < 890 ((min & D3D10_FILTER_TYPE_MASK) << D3D10_MIN_FILTER_SHIFT) | < 891 ((mag & D3D10_FILTER_TYPE_MASK) << D3D10_MAG_FILTER_SHIFT) | < 892 ((mip & D3D10_FILTER_TYPE_MASK) << D3D10_MIP_FILTER_SHIFT)); < 893 } < 894 < 895 D3D10_FILTER D3D10_ENCODE_ANISOTROPIC_FILTER(bool bComparison) { < 896 return cast(D3D10_FILTER)(D3D10_ANISOTROPIC_FILTERING_BIT | < 897 D3D10_ENCODE_BASIC_FILTER(D3D10_FILTER_TYPE.D3D10_FILTER_TYPE_LI < 898 D3D10_FILTER_TYPE.D3D10_FILTER_TYPE_LINEAR, D3D10_FILTER < 899 bComparison)); < 900 } < 901 < 902 D3D10_FILTER_TYPE D3D10_DECODE_MIN_FILTER(D3D10_FILTER d3d10Filter) { < 903 return cast(D3D10_FILTER_TYPE)((d3d10Filter >> D3D10_MIN_FILTER_SHIFT) & < 904 } < 905 < 906 D3D10_FILTER_TYPE D3D10_DECODE_MAG_FILTER(D3D10_FILTER d3d10Filter) { < 907 return cast(D3D10_FILTER_TYPE)((d3d10Filter >> D3D10_MAG_FILTER_SHIFT) & < 908 } < 909 < 910 D3D10_FILTER_TYPE D3D10_DECODE_MIP_FILTER(D3D10_FILTER d3d10Filter) { < 911 return cast(D3D10_FILTER_TYPE)((d3d10Filter >> D3D10_MIP_FILTER_SHIFT) & < 912 } < 913 < 914 bool D3D10_DECODE_IS_COMPARISON_FILTER(D3D10_FILTER d3d10Filter) { < 915 return (d3d10Filter & D3D10_COMPARISON_FILTERING_BIT) == D3D10_COMPARISO < 916 } < 917 < 918 bool D3D10_DECODE_IS_ANISOTROPIC_FILTER(D3D10_FILTER d3d10Filter) { < 919 return ((d3d10Filter & D3D10_ANISOTROPIC_FILTERING_BIT) && < 920 (D3D10_FILTER_TYPE.D3D10_FILTER_TYPE_LINEAR == D3D10_DECODE_MIN_F < 921 (D3D10_FILTER_TYPE.D3D10_FILTER_TYPE_LINEAR == D3D10_DECODE_MAG_F < 922 (D3D10_FILTER_TYPE.D3D10_FILTER_TYPE_LINEAR == D3D10_DECODE_MIP_F < 923 } < 924 < 925 bool D3D10_DECODE_IS_TEXT_1BIT_FILTER(D3D10_FILTER d3d10Filter) { < 926 return d3d10Filter == D3D10_TEXT_1BIT_BIT; < 927 } < 928 < 929 enum D3D10_TEXTURE_ADDRESS_MODE { < 930 D3D10_TEXTURE_ADDRESS_WRAP = 1, < 931 D3D10_TEXTURE_ADDRESS_MIRROR, < 932 D3D10_TEXTURE_ADDRESS_CLAMP, < 933 D3D10_TEXTURE_ADDRESS_BORDER, < 934 D3D10_TEXTURE_ADDRESS_MIRROR_ONCE < 935 } < 936 < 937 struct D3D10_SAMPLER_DESC { < 938 D3D10_FILTER Filter; < 939 D3D10_TEXTURE_ADDRESS_MODE AddressU; < 940 D3D10_TEXTURE_ADDRESS_MODE AddressV; < 941 D3D10_TEXTURE_ADDRESS_MODE AddressW; < 942 FLOAT MipLODBias; < 943 UINT MaxAnisotropy; < 944 D3D10_COMPARISON_FUNC ComparisonFunc; < 945 FLOAT[4] BorderColor; < 946 FLOAT MinLOD; < 947 FLOAT MaxLOD; < 948 } < 949 < 950 interface ID3D10SamplerState : ID3D10DeviceChild { < 951 extern(Windows) : < 952 void GetDesc(D3D10_SAMPLER_DESC *pDesc); < 953 } < 954 < 955 enum D3D10_FORMAT_SUPPORT { < 956 D3D10_FORMAT_SUPPORT_BUFFER < 957 D3D10_FORMAT_SUPPORT_IA_VERTEX_BUFFER = 0x000002, < 958 D3D10_FORMAT_SUPPORT_IA_INDEX_BUFFER = 0x000004, < 959 D3D10_FORMAT_SUPPORT_SO_BUFFER = 0x0000 < 960 D3D10_FORMAT_SUPPORT_TEXTURE1D = 0x0000 < 961 D3D10_FORMAT_SUPPORT_TEXTURE2D = 0x0000 < 962 D3D10_FORMAT_SUPPORT_TEXTURE3D = 0x0000 < 963 D3D10_FORMAT_SUPPORT_TEXTURECUBE = 0x0000 < 964 D3D10_FORMAT_SUPPORT_SHADER_LOAD = 0x0001 < 965 D3D10_FORMAT_SUPPORT_SHADER_SAMPLE = 0x0002 < 966 D3D10_FORMAT_SUPPORT_SHADER_SAMPLE_COMPARISON = 0x000400, < 967 D3D10_FORMAT_SUPPORT_SHADER_SAMPLE_MONO_TEXT = 0x000800, < 968 D3D10_FORMAT_SUPPORT_MIP < 969 D3D10_FORMAT_SUPPORT_MIP_AUTOGEN = 0x0020 < 970 D3D10_FORMAT_SUPPORT_RENDER_TARGET = 0x0040 < 971 D3D10_FORMAT_SUPPORT_BLENDABLE = 0x0080 < 972 D3D10_FORMAT_SUPPORT_DEPTH_STENCIL = 0x0100 < 973 D3D10_FORMAT_SUPPORT_CPU_LOCKABLE = 0x0200 < 974 D3D10_FORMAT_SUPPORT_MULTISAMPLE_RESOLVE = 0x040000, < 975 D3D10_FORMAT_SUPPORT_DISPLAY = 0x0800 < 976 D3D10_FORMAT_SUPPORT_CAST_WITHIN_BIT_LAYOUT = 0x100000, < 977 D3D10_FORMAT_SUPPORT_MULTISAMPLE_RENDERTARGET = 0x200000, < 978 D3D10_FORMAT_SUPPORT_MULTISAMPLE_LOAD = 0x400000, < 979 D3D10_FORMAT_SUPPORT_SHADER_GATHER = 0x8000 < 980 } < 981 < 982 interface ID3D10Asynchronous : ID3D10DeviceChild { < 983 extern(Windows) : < 984 void Begin(); < 985 void End(); < 986 HRESULT GetData(void *pData, UINT DataSize, UINT GetDataFlags); < 987 UINT GetDataSize(); < 988 } < 989 < 990 enum D3D10_ASYNC_GETDATA_FLAG { < 991 D3D10_ASYNC_GETDATA_DONOTFLUSH = 0x1 < 992 } < 993 < 994 enum D3D10_QUERY { < 995 D3D10_QUERY_EVENT = 0, < 996 D3D10_QUERY_OCCLUSION = (D3D10_QUERY_EVENT + 1 < 997 D3D10_QUERY_TIMESTAMP = (D3D10_QUERY_OCCLUSION < 998 D3D10_QUERY_TIMESTAMP_DISJOINT = (D3D10_QUERY_TIMESTAMP + 1), < 999 D3D10_QUERY_PIPELINE_STATISTICS = (D3D10_QUERY_TIMESTAMP_DISJOIN < 1000 D3D10_QUERY_OCCLUSION_PREDICATE = (D3D10_QUERY_PIPELINE_STATISTI < 1001 D3D10_QUERY_SO_STATISTICS = (D3D10_QUERY_OCCLUSION < 1002 D3D10_QUERY_SO_OVERFLOW_PREDICATE = (D3D10_QUERY_SO_STATISTICS + 1 < 1003 } < 1004 < 1005 enum D3D10_QUERY_MISC_FLAG { < 1006 D3D10_QUERY_MISC_PREDICATEHINT = 0x01 < 1007 } < 1008 < 1009 struct D3D10_QUERY_DESC { < 1010 D3D10_QUERY Query; < 1011 UINT MiscFlags; < 1012 } < 1013 < 1014 interface ID3D10Query : ID3D10Asynchronous { < 1015 extern(Windows) : < 1016 void GetDesc(D3D10_QUERY_DESC *pDesc); < 1017 } < 1018 < 1019 interface ID3D10Predicate : ID3D10Query { } < 1020 < 1021 struct D3D10_QUERY_DATA_TIMESTAMP_DISJOINT { < 1022 UINT64 Frequency; < 1023 BOOL Disjoint; < 1024 } < 1025 < 1026 struct D3D10_QUERY_DATA_PIPELINE_STATISTICS { < 1027 UINT64 IAVertices; < 1028 UINT64 IAPrimitives; < 1029 UINT64 VSInvocations; < 1030 UINT64 GSInvocations; < 1031 UINT64 GSPrimitives; < 1032 UINT64 CInvocations; < 1033 UINT64 CPrimitives; < 1034 UINT64 PSInvocations; < 1035 } < 1036 < 1037 struct D3D10_QUERY_DATA_SO_STATISTICS { < 1038 UINT64 NumPrimitivesWritten; < 1039 UINT64 PrimitivesStorageNeeded; < 1040 } < 1041 < 1042 enum D3D10_COUNTER { < 1043 D3D10_COUNTER_GPU_IDLE < 1044 D3D10_COUNTER_VERTEX_PROCESSING < 1045 D3D10_COUNTER_GEOMETRY_PROCESSING < 1046 D3D10_COUNTER_PIXEL_PROCESSING < 1047 D3D10_COUNTER_OTHER_GPU_PROCESSING < 1048 D3D10_COUNTER_HOST_ADAPTER_BANDWIDTH_UTILIZATION = (D3D10_COUNTER < 1049 D3D10_COUNTER_LOCAL_VIDMEM_BANDWIDTH_UTILIZATION = (D3D10_COUNTER < 1050 D3D10_COUNTER_VERTEX_THROUGHPUT_UTILIZATION = (D3D10 < 1051 D3D10_COUNTER_TRIANGLE_SETUP_THROUGHPUT_UTILIZATION = (D3D10_COUNTER < 1052 D3D10_COUNTER_FILLRATE_THROUGHPUT_UTILIZATION = (D3D10_COUNTER < 1053 D3D10_COUNTER_VS_MEMORY_LIMITED < 1054 D3D10_COUNTER_VS_COMPUTATION_LIMITED = (D3D10 < 1055 D3D10_COUNTER_GS_MEMORY_LIMITED < 1056 D3D10_COUNTER_GS_COMPUTATION_LIMITED = (D3D10 < 1057 D3D10_COUNTER_PS_MEMORY_LIMITED < 1058 D3D10_COUNTER_PS_COMPUTATION_LIMITED = (D3D10 < 1059 D3D10_COUNTER_POST_TRANSFORM_CACHE_HIT_RATE = (D3D10 < 1060 D3D10_COUNTER_TEXTURE_CACHE_HIT_RATE = (D3D10 < 1061 D3D10_COUNTER_DEVICE_DEPENDENT_0 < 1062 } < 1063 < 1064 enum D3D10_COUNTER_TYPE { < 1065 D3D10_COUNTER_TYPE_FLOAT32 = 0, < 1066 D3D10_COUNTER_TYPE_UINT16 = (D3D10_COUNTER_TYPE_FLOAT32 + 1), < 1067 D3D10_COUNTER_TYPE_UINT32 = (D3D10_COUNTER_TYPE_UINT16 + 1), < 1068 D3D10_COUNTER_TYPE_UINT64 = (D3D10_COUNTER_TYPE_UINT32 + 1) < 1069 } < 1070 < 1071 struct D3D10_COUNTER_DESC { < 1072 D3D10_COUNTER Counter; < 1073 UINT MiscFlags; < 1074 } < 1075 < 1076 struct D3D10_COUNTER_INFO { < 1077 D3D10_COUNTER LastDeviceDependentCounter; < 1078 UINT NumSimultaneousCounters; < 1079 UINT8 NumDetectableParallelUnits; < 1080 } < 1081 < 1082 interface ID3D10Counter : ID3D10Asynchronous { < 1083 extern(Windows) : < 1084 void GetDesc(D3D10_COUNTER_DESC *pDesc); < 1085 } < 1086 < 1087 interface ID3D10Device : IUnknown { < 1088 extern(Windows) : < 1089 void VSSetConstantBuffers(UINT StartSlot, UINT NumBuffers, ID3D10Buffer* < 1090 void PSSetShaderResources(UINT StartSlot, UINT NumViews, ID3D10ShaderRes < 1091 void PSSetShader(ID3D10PixelShader pPixelShader); < 1092 void PSSetSamplers(UINT StartSlot, UINT NumSamplers, ID3D10SamplerState* < 1093 void VSSetShader(ID3D10VertexShader pVertexShader); < 1094 void DrawIndexed(UINT IndexCount, UINT StartIndexLocation, INT BaseVerte < 1095 void Draw(UINT VertexCount, UINT StartVertexLocation); < 1096 void PSSetConstantBuffers(UINT StartSlot, UINT NumBuffers, ID3D10Buffer* < 1097 void IASetInputLayout(ID3D10InputLayout pInputLayout); < 1098 void IASetVertexBuffers(UINT StartSlot, UINT NumBuffers, ID3D10Buffer* p < 1099 void IASetIndexBuffer(ID3D10Buffer pIndexBuffer, DXGI_FORMAT Format, UIN < 1100 void DrawIndexedInstanced(UINT IndexCountPerInstance, UINT InstanceCount < 1101 void DrawInstanced(UINT VertexCountPerInstance, UINT InstanceCount, UINT < 1102 void GSSetConstantBuffers(UINT StartSlot, UINT NumBuffers, ID3D10Buffer* < 1103 void GSSetShader(ID3D10GeometryShader pShader); < 1104 void IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY Topology); < 1105 void VSSetShaderResources(UINT StartSlot, UINT NumViews, ID3D10ShaderRes < 1106 void VSSetSamplers(UINT StartSlot, UINT NumSamplers, ID3D10SamplerState* < 1107 void SetPredication(ID3D10Predicate pPredicate, BOOL PredicateValue); < 1108 void GSSetShaderResources(UINT StartSlot, UINT NumViews, ID3D10ShaderRes < 1109 void GSSetSamplers(UINT StartSlot, UINT NumSamplers, ID3D10SamplerState* < 1110 void OMSetRenderTargets(UINT NumViews, ID3D10RenderTargetView* ppRenderT < 1111 void OMSetBlendState(ID3D10BlendState pBlendState, FLOAT[4] BlendFactor, < 1112 void OMSetDepthStencilState(ID3D10DepthStencilState pDepthStencilState, < 1113 void SOSetTargets(UINT NumBuffers, ID3D10Buffer* ppSOTargets, UINT* pOff < 1114 void DrawAuto(); < 1115 void RSSetState(ID3D10RasterizerState pRasterizerState); < 1116 void RSSetViewports(UINT NumViewports, D3D10_VIEWPORT* pViewports); < 1117 void RSSetScissorRects(UINT NumRects, D3D10_RECT* pRects); < 1118 void CopySubresourceRegion(ID3D10Resource pDstResource, UINT DstSubresou < 1119 void CopyResource(ID3D10Resource pDstResource, ID3D10Resource pSrcResour < 1120 void UpdateSubresource(ID3D10Resource pDstResource, UINT DstSubresource, < 1121 void ClearRenderTargetView(ID3D10RenderTargetView pRenderTargetView, FLO < 1122 void ClearDepthStencilView(ID3D10DepthStencilView pDepthStencilView, UIN < 1123 void GenerateMips(ID3D10ShaderResourceView pShaderResourceView); < 1124 void ResolveSubresource(ID3D10Resource pDstResource, UINT DstSubresource < 1125 void VSGetConstantBuffers(UINT StartSlot, UINT NumBuffers, ID3D10Buffer* < 1126 void PSGetShaderResources(UINT StartSlot, UINT NumViews, ID3D10ShaderRes < 1127 void PSGetShader(ID3D10PixelShader* ppPixelShader); < 1128 void PSGetSamplers(UINT StartSlot, UINT NumSamplers, ID3D10SamplerState* < 1129 void VSGetShader(ID3D10VertexShader* ppVertexShader); < 1130 void PSGetConstantBuffers(UINT StartSlot, UINT NumBuffers, ID3D10Buffer* < 1131 void IAGetInputLayout(ID3D10InputLayout* ppInputLayout); < 1132 void IAGetVertexBuffers(UINT StartSlot, UINT NumBuffers, ID3D10Buffer* p < 1133 void IAGetIndexBuffer(ID3D10Buffer* pIndexBuffer, DXGI_FORMAT* Format, U < 1134 void GSGetConstantBuffers(UINT StartSlot, UINT NumBuffers, ID3D10Buffer* < 1135 void GSGetShader(ID3D10GeometryShader* ppGeometryShader); < 1136 void IAGetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY* pTopology); < 1137 void VSGetShaderResources(UINT StartSlot, UINT NumViews, ID3D10ShaderRes < 1138 void VSGetSamplers(UINT StartSlot, UINT NumSamplers, ID3D10SamplerState* < 1139 void GetPredication(ID3D10Predicate* ppPredicate, BOOL* pPredicateValue) < 1140 void GSGetShaderResources(UINT StartSlot, UINT NumViews, ID3D10ShaderRes < 1141 void GSGetSamplers(UINT StartSlot, UINT NumSamplers, ID3D10SamplerState* < 1142 void OMGetRenderTargets(UINT NumViews, ID3D10RenderTargetView* ppRenderT < 1143 void OMGetBlendState(ID3D10BlendState* ppBlendState, FLOAT[ 4 ] BlendFac < 1144 void OMGetDepthStencilState(ID3D10DepthStencilState* ppDepthStencilState < 1145 void SOGetTargets(UINT NumBuffers, ID3D10Buffer* ppSOTargets, UINT* pOff < 1146 void RSGetState(ID3D10RasterizerState* ppRasterizerState); < 1147 void RSGetViewports(UINT* NumViewports, D3D10_VIEWPORT* pViewports); < 1148 void RSGetScissorRects(UINT* NumRects, D3D10_RECT* pRects); < 1149 HRESULT GetDeviceRemovedReason(); < 1150 HRESULT SetExceptionMode(UINT RaiseFlags); < 1151 UINT GetExceptionMode(); < 1152 HRESULT GetPrivateData(REFGUID guid, UINT* pDataSize, void* pData); < 1153 HRESULT SetPrivateData(REFGUID guid, UINT DataSize, void* pData); < 1154 HRESULT SetPrivateDataInterface(REFGUID guid, IUnknown pData); < 1155 void ClearState(); < 1156 void Flush(); < 1157 HRESULT CreateBuffer(D3D10_BUFFER_DESC* pDesc, D3D10_SUBRESOURCE_DATA* p < 1158 HRESULT CreateTexture1D(D3D10_TEXTURE1D_DESC* pDesc, D3D10_SUBRESOURCE_D < 1159 HRESULT CreateTexture2D(D3D10_TEXTURE2D_DESC* pDesc, D3D10_SUBRESOURCE_D < 1160 HRESULT CreateTexture3D(D3D10_TEXTURE3D_DESC* pDesc, D3D10_SUBRESOURCE_D < 1161 HRESULT CreateShaderResourceView(ID3D10Resource pResource, D3D10_SHADER_ < 1162 HRESULT CreateRenderTargetView(ID3D10Resource pResource, D3D10_RENDER_TA < 1163 HRESULT CreateDepthStencilView(ID3D10Resource pResource, D3D10_DEPTH_STE < 1164 HRESULT CreateInputLayout(D3D10_INPUT_ELEMENT_DESC* pInputElementDescs, < 1165 HRESULT CreateVertexShader(void* pShaderBytecode, SIZE_T BytecodeLength, < 1166 HRESULT CreateGeometryShader(void* pShaderBytecode, SIZE_T BytecodeLengt < 1167 HRESULT CreateGeometryShaderWithStreamOutput(void* pShaderBytecode, SIZE < 1168 HRESULT CreatePixelShader(void* pShaderBytecode, SIZE_T BytecodeLength, < 1169 HRESULT CreateBlendState(D3D10_BLEND_DESC* pBlendStateDesc, ID3D10BlendS < 1170 HRESULT CreateDepthStencilState(D3D10_DEPTH_STENCIL_DESC* pDepthStencilD < 1171 HRESULT CreateRasterizerState(D3D10_RASTERIZER_DESC* pRasterizerDesc, ID < 1172 HRESULT CreateSamplerState(D3D10_SAMPLER_DESC* pSamplerDesc, ID3D10Sampl < 1173 HRESULT CreateQuery(D3D10_QUERY_DESC* pQueryDesc, ID3D10Query* ppQuery); < 1174 HRESULT CreatePredicate(D3D10_QUERY_DESC* pPredicateDesc, ID3D10Predicat < 1175 HRESULT CreateCounter(D3D10_COUNTER_DESC* pCounterDesc, ID3D10Counter* p < 1176 HRESULT CheckFormatSupport(DXGI_FORMAT Format, UINT* pFormatSupport); < 1177 HRESULT CheckMultisampleQualityLevels(DXGI_FORMAT Format, UINT SampleCou < 1178 void CheckCounterInfo(D3D10_COUNTER_INFO* pCounterInfo); < 1179 HRESULT CheckCounter(D3D10_COUNTER_DESC* pDesc, D3D10_COUNTER_TYPE* pTyp < 1180 UINT GetCreationFlags(); < 1181 HRESULT OpenSharedResource(HANDLE hResource, REFIID ReturnedInterface, v < 1182 void SetTextFilterSize(UINT Width, UINT Height); < 1183 void GetTextFilterSize(UINT* pWidth, UINT* pHeight); < 1184 } < 1185 < 1186 interface ID3D10Multithread : IUnknown { < 1187 extern(Windows) : < 1188 void Enter(); < 1189 void Leave(); < 1190 BOOL SetMultithreadProtected(BOOL bMTProtect); < 1191 BOOL GetMultithreadProtected(); < 1192 } < 1193 < 1194 enum D3D10_CREATE_DEVICE_FLAG { < 1195 D3D10_CREATE_DEVICE_SINGLETHREADED < 1196 D3D10_CREATE_DEVICE_DEBUG < 1197 D3D10_CREATE_DEVICE_SWITCH_TO_REF < 1198 D3D10_CREATE_DEVICE_PREVENT_INTERNAL_THREADING_OPTIMIZATIONS = 0x08 < 1199 } < 1200 < 1201 const D3D10_SDK_VERSION = 29; < 1202 < 1203 extern(C) const GUID IID_ID3D10DeviceChild = {0x9B7E4C00, 0 < 1204 extern(C) const GUID IID_ID3D10DepthStencilState = {0x2B4B1CC8, 0xA4AD, 0 < 1205 extern(C) const GUID IID_ID3D10BlendState = {0xEDAD8D19, 0 < 1206 extern(C) const GUID IID_ID3D10RasterizerState = {0xA2A07292, 0x89AF, 0 < 1207 extern(C) const GUID IID_ID3D10Resource = {0x9B7E4C01, 0 < 1208 extern(C) const GUID IID_ID3D10Buffer = {0x9B7E4C02, 0 < 1209 extern(C) const GUID IID_ID3D10Texture1D = {0x9B7E4C03, 0 < 1210 extern(C) const GUID IID_ID3D10Texture2D = {0x9B7E4C04, 0 < 1211 extern(C) const GUID IID_ID3D10Texture3D = {0x9B7E4C05, 0 < 1212 extern(C) const GUID IID_ID3D10View = {0xC90 < 1213 extern(C) const GUID IID_ID3D10ShaderResourceView = {0x9B7E4C07, 0x342C, 0 < 1214 extern(C) const GUID IID_ID3D10RenderTargetView = {0x9B7E4C08, 0x342C, 0 < 1215 extern(C) const GUID IID_ID3D10DepthStencilView = {0x9B7E4C09, 0x342C, 0 < 1216 extern(C) const GUID IID_ID3D10VertexShader = {0x9B7E4C0A, 0 < 1217 extern(C) const GUID IID_ID3D10GeometryShader = {0x6316BE88, 0x54CD, 0 < 1218 extern(C) const GUID IID_ID3D10PixelShader = {0x4968B601, 0 < 1219 extern(C) const GUID IID_ID3D10InputLayout = {0x9B7E4C0B, 0 < 1220 extern(C) const GUID IID_ID3D10SamplerState = {0x9B7E4C0C, 0 < 1221 extern(C) const GUID IID_ID3D10Asynchronous = {0x9B7E4C0D, 0 < 1222 extern(C) const GUID IID_ID3D10Query = {0x9B7E4C0E, 0 < 1223 extern(C) const GUID IID_ID3D10Predicate = {0x9B7E4C10, 0 < 1224 extern(C) const GUID IID_ID3D10Counter = {0x9B7E4C11, 0 < 1225 extern(C) const GUID IID_ID3D10Device = {0x9B7E4C0F, 0 < 1226 extern(C) const GUID IID_ID3D10Multithread = {0x9B7E4E00, 0 < 1227 < 1228 public import win32.directx.d3d10shader; < 1229 public import win32.directx.d3d10effect; <
Deleted src/win32/directx/d3d10effect.d version [496784a5813cdffa]
1 /***********************************************************************\ < 2 * d3d10effect.d * < 3 * * < 4 * Windows API header module * < 5 * * < 6 * Placed into public domain * < 7 \***********************************************************************/ < 8 module win32.directx.d3d10effect; < 9 < 10 private import win32.windows; < 11 private import win32.directx.d3d10; < 12 < 13 < 14 enum D3D10_DEVICE_STATE_TYPES { < 15 D3D10_DST_SO_BUFFERS = 1, < 16 D3D10_DST_OM_RENDER_TARGETS, < 17 D3D10_DST_OM_DEPTH_STENCIL_STATE, < 18 D3D10_DST_OM_BLEND_STATE, < 19 D3D10_DST_VS, < 20 D3D10_DST_VS_SAMPLERS, < 21 D3D10_DST_VS_SHADER_RESOURCES, < 22 D3D10_DST_VS_CONSTANT_BUFFERS, < 23 D3D10_DST_GS, < 24 D3D10_DST_GS_SAMPLERS, < 25 D3D10_DST_GS_SHADER_RESOURCES, < 26 D3D10_DST_GS_CONSTANT_BUFFERS, < 27 D3D10_DST_PS, < 28 D3D10_DST_PS_SAMPLERS, < 29 D3D10_DST_PS_SHADER_RESOURCES, < 30 D3D10_DST_PS_CONSTANT_BUFFERS, < 31 D3D10_DST_IA_VERTEX_BUFFERS, < 32 D3D10_DST_IA_INDEX_BUFFER, < 33 D3D10_DST_IA_INPUT_LAYOUT, < 34 D3D10_DST_IA_PRIMITIVE_TOPOLOGY, < 35 D3D10_DST_RS_VIEWPORTS, < 36 D3D10_DST_RS_SCISSOR_RECTS, < 37 D3D10_DST_RS_RASTERIZER_STATE, < 38 D3D10_DST_PREDICATION < 39 } < 40 < 41 struct D3D10_STATE_BLOCK_MASK { < 42 BYTE VS; < 43 BYTE[2] VSSamplers; < 44 BYTE[16] VSShaderResources; < 45 BYTE[2] VSConstantBuffers; < 46 BYTE GS; < 47 BYTE[2] GSSamplers; < 48 BYTE[16] GSShaderResources; < 49 BYTE[2] GSConstantBuffers; < 50 BYTE PS; < 51 BYTE[2] PSSamplers; < 52 BYTE[16] PSShaderResources; < 53 BYTE[2] PSConstantBuffers; < 54 BYTE[2] IAVertexBuffers; < 55 BYTE IAIndexBuffer; < 56 BYTE IAInputLayout; < 57 BYTE IAPrimitiveTopology; < 58 BYTE OMRenderTargets; < 59 BYTE OMDepthStencilState; < 60 BYTE OMBlendState; < 61 BYTE RSViewports; < 62 BYTE RSScissorRects; < 63 BYTE RSRasterizerState; < 64 BYTE SOBuffers; < 65 BYTE Predication; < 66 } < 67 < 68 extern (C) const GUID IID_ID3D10StateBlock = {0x803425a, 0x57f5, 0x4dd6, [0x94, < 69 < 70 interface ID3D10StateBlock : IUnknown { < 71 extern(Windows) : < 72 HRESULT Capture(); < 73 HRESULT Apply(); < 74 HRESULT ReleaseAllDeviceObjects(); < 75 HRESULT GetDevice(ID3D10Device ppDevice); < 76 } < 77 < 78 HRESULT D3D10StateBlockMaskUnion(D3D10_STATE_BLOCK_MASK* pA, D3D10_STATE_BLOCK_M < 79 HRESULT D3D10StateBlockMaskIntersect(D3D10_STATE_BLOCK_MASK* pA, D3D10_STATE_BLO < 80 HRESULT D3D10StateBlockMaskDifference(D3D10_STATE_BLOCK_MASK* pA, D3D10_STATE_BL < 81 HRESULT D3D10StateBlockMaskEnableCapture(D3D10_STATE_BLOCK_MASK* pMask, D3D10_DE < 82 HRESULT D3D10StateBlockMaskDisableCapture(D3D10_STATE_BLOCK_MASK* pMask, D3D10_D < 83 HRESULT D3D10StateBlockMaskEnableAll(D3D10_STATE_BLOCK_MASK* pMask); < 84 HRESULT D3D10StateBlockMaskDisableAll(D3D10_STATE_BLOCK_MASK* pMask); < 85 BOOL D3D10StateBlockMaskGetSetting(D3D10_STATE_BLOCK_MASK* pMask, D3D10_DEVICE_S < 86 HRESULT D3D10CreateStateBlock(ID3D10Device pDevice, D3D10_STATE_BLOCK_MASK* pSta < 87 < 88 const D3D10_EFFECT_COMPILE_CHILD_EFFECT = 1 << 0; < 89 const D3D10_EFFECT_COMPILE_ALLOW_SLOW_OPS = 1 << 1; < 90 const D3D10_EFFECT_SINGLE_THREADED = 1 << 3; < 91 const D3D10_EFFECT_VARIABLE_POOLED = 1 << 0; < 92 const D3D10_EFFECT_VARIABLE_ANNOTATION = 1 << 1; < 93 const D3D10_EFFECT_VARIABLE_EXPLICIT_BIND_POINT = 1 << 2; < 94 < 95 struct D3D10_EFFECT_TYPE_DESC { < 96 LPCSTR TypeName; < 97 D3D10_SHADER_VARIABLE_CLASS Class; < 98 D3D10_SHADER_VARIABLE_TYPE Type; < 99 UINT Elements; < 100 UINT Members; < 101 UINT Rows; < 102 UINT Columns; < 103 UINT PackedSize; < 104 UINT UnpackedSize; < 105 UINT Stride; < 106 } < 107 < 108 extern (C) const GUID IID_ID3D10EffectType = {0x4e9e1ddc, 0xcd9d, 0x4772, [0xa8, < 109 < 110 interface ID3D10EffectType { < 111 /* TODO: fix vtbl[0] bug < 112 extern(Windows) : < 113 BOOL IsValid(); < 114 HRESULT GetDesc(D3D10_EFFECT_TYPE_DESC* pDesc); < 115 ID3D10EffectType GetMemberTypeByIndex(UINT Index); < 116 ID3D10EffectType GetMemberTypeByName(LPCSTR Name); < 117 ID3D10EffectType GetMemberTypeBySemantic(LPCSTR Semantic); < 118 LPCSTR GetMemberName(UINT Index); < 119 LPCSTR GetMemberSemantic(UINT Index); < 120 */ < 121 } < 122 < 123 struct D3D10_EFFECT_VARIABLE_DESC { < 124 LPCSTR Name; < 125 LPCSTR Semantic; < 126 UINT Flags; < 127 UINT Annotations; < 128 UINT BufferOffset; < 129 UINT ExplicitBindPoint; < 130 } < 131 < 132 extern (C) const GUID IID_ID3D10EffectVariable = {0xae897105, 0x00e6, 0x45bf, [0 < 133 < 134 interface ID3D10EffectVariable { < 135 /* TODO: fix vtbl[0] bug < 136 extern(Windows) : < 137 BOOL IsValid(); < 138 ID3D10EffectType GetType(); < 139 HRESULT GetDesc(D3D10_EFFECT_VARIABLE_DESC* pDesc); < 140 ID3D10EffectVariable GetAnnotationByIndex(UINT Index); < 141 ID3D10EffectVariable GetAnnotationByName(LPCSTR Name); < 142 ID3D10EffectVariable GetMemberByIndex(UINT Index); < 143 ID3D10EffectVariable GetMemberByName(LPCSTR Name); < 144 ID3D10EffectVariable GetMemberBySemantic(LPCSTR Semantic); < 145 ID3D10EffectVariable GetElement(UINT Index); < 146 ID3D10EffectConstantBuffer GetParentConstantBuffer(); < 147 ID3D10EffectScalarVariable AsScalar(); < 148 ID3D10EffectVectorVariable AsVector(); < 149 ID3D10EffectMatrixVariable AsMatrix(); < 150 ID3D10EffectStringVariable AsString(); < 151 ID3D10EffectShaderResourceVariable AsShaderResource(); < 152 ID3D10EffectRenderTargetViewVariable AsRenderTargetView(); < 153 ID3D10EffectDepthStencilViewVariable AsDepthStencilView(); < 154 ID3D10EffectConstantBuffer AsConstantBuffer(); < 155 ID3D10EffectShaderVariable AsShader(); < 156 ID3D10EffectBlendVariable AsBlend(); < 157 ID3D10EffectDepthStencilVariable AsDepthStencil(); < 158 ID3D10EffectRasterizerVariable AsRasterizer(); < 159 ID3D10EffectSamplerVariable AsSampler(); < 160 HRESULT SetRawValue(void* pData, UINT Offset, UINT Count); < 161 HRESULT GetRawValue(void* pData, UINT Offset, UINT Count); < 162 */ < 163 } < 164 < 165 extern (C) const GUID IID_ID3D10EffectScalarVariable = {0xe48f7b, 0xd2c8, 0x49e8 < 166 < 167 interface ID3D10EffectScalarVariable : ID3D10EffectVariable { < 168 /* TODO: fix vtbl[0] bug < 169 extern(Windows) : < 170 BOOL IsValid(); < 171 ID3D10EffectType GetType(); < 172 HRESULT GetDesc(D3D10_EFFECT_VARIABLE_DESC* pDesc); < 173 ID3D10EffectVariable GetAnnotationByIndex(UINT Index); < 174 ID3D10EffectVariable GetAnnotationByName(LPCSTR Name); < 175 ID3D10EffectVariable GetMemberByIndex(UINT Index); < 176 ID3D10EffectVariable GetMemberByName(LPCSTR Name); < 177 ID3D10EffectVariable GetMemberBySemantic(LPCSTR Semantic); < 178 ID3D10EffectVariable GetElement(UINT Index); < 179 ID3D10EffectConstantBuffer GetParentConstantBuffer(); < 180 ID3D10EffectScalarVariable AsScalar(); < 181 ID3D10EffectVectorVariable AsVector(); < 182 ID3D10EffectMatrixVariable AsMatrix(); < 183 ID3D10EffectStringVariable AsString(); < 184 ID3D10EffectShaderResourceVariable AsShaderResource(); < 185 ID3D10EffectRenderTargetViewVariable AsRenderTargetView(); < 186 ID3D10EffectDepthStencilViewVariable AsDepthStencilView(); < 187 ID3D10EffectConstantBuffer AsConstantBuffer(); < 188 ID3D10EffectShaderVariable AsShader(); < 189 ID3D10EffectBlendVariable AsBlend(); < 190 ID3D10EffectDepthStencilVariable AsDepthStencil(); < 191 ID3D10EffectRasterizerVariable AsRasterizer(); < 192 ID3D10EffectSamplerVariable AsSampler(); < 193 HRESULT SetRawValue(void* pData, UINT ByteOffset, UINT ByteCount); < 194 HRESULT GetRawValue(void* pData, UINT ByteOffset, UINT ByteCount); < 195 HRESULT SetFloat(float Value); < 196 HRESULT GetFloat(float* pValue); < 197 HRESULT SetFloatArray(float* pData, UINT Offset, UINT Count); < 198 HRESULT GetFloatArray(float* pData, UINT Offset, UINT Count); < 199 HRESULT SetInt(int Value); < 200 HRESULT GetInt(int* pValue); < 201 HRESULT SetIntArray(int* pData, UINT Offset, UINT Count); < 202 HRESULT GetIntArray(int* pData, UINT Offset, UINT Count); < 203 HRESULT SetBool(BOOL Value); < 204 HRESULT GetBool(BOOL* pValue); < 205 HRESULT SetBoolArray(BOOL* pData, UINT Offset, UINT Count); < 206 HRESULT GetBoolArray(BOOL* pData, UINT Offset, UINT Count); < 207 */ < 208 } < 209 < 210 extern (C) const GUID IID_ID3D10EffectVectorVariable = {0x62b98c44, 0x1f82, 0x4c < 211 < 212 interface ID3D10EffectVectorVariable : ID3D10EffectVariable { < 213 /* TODO: fix vtbl[0] bug < 214 extern(Windows) : < 215 BOOL IsValid(); < 216 ID3D10EffectType GetType(); < 217 HRESULT GetDesc(D3D10_EFFECT_VARIABLE_DESC* pDesc); < 218 ID3D10EffectVariable GetAnnotationByIndex(UINT Index); < 219 ID3D10EffectVariable GetAnnotationByName(LPCSTR Name); < 220 ID3D10EffectVariable GetMemberByIndex(UINT Index); < 221 ID3D10EffectVariable GetMemberByName(LPCSTR Name); < 222 ID3D10EffectVariable GetMemberBySemantic(LPCSTR Semantic); < 223 ID3D10EffectVariable GetElement(UINT Index); < 224 ID3D10EffectConstantBuffer GetParentConstantBuffer(); < 225 ID3D10EffectScalarVariable AsScalar(); < 226 ID3D10EffectVectorVariable AsVector(); < 227 ID3D10EffectMatrixVariable AsMatrix(); < 228 ID3D10EffectStringVariable AsString(); < 229 ID3D10EffectShaderResourceVariable AsShaderResource(); < 230 ID3D10EffectRenderTargetViewVariable AsRenderTargetView(); < 231 ID3D10EffectDepthStencilViewVariable AsDepthStencilView(); < 232 ID3D10EffectConstantBuffer AsConstantBuffer(); < 233 ID3D10EffectShaderVariable AsShader(); < 234 ID3D10EffectBlendVariable AsBlend(); < 235 ID3D10EffectDepthStencilVariable AsDepthStencil(); < 236 ID3D10EffectRasterizerVariable AsRasterizer(); < 237 ID3D10EffectSamplerVariable AsSampler(); < 238 HRESULT SetRawValue(void* pData, UINT ByteOffset, UINT ByteCount); < 239 HRESULT GetRawValue(void* pData, UINT ByteOffset, UINT ByteCount); < 240 HRESULT SetBoolVector (BOOL* pData); < 241 HRESULT SetIntVector (int* pData); < 242 HRESULT SetFloatVector(float* pData); < 243 HRESULT GetBoolVector (BOOL* pData); < 244 HRESULT GetIntVector (int* pData); < 245 HRESULT GetFloatVector(float* pData); < 246 HRESULT SetBoolVectorArray (BOOL* pData, UINT Offset, UINT Count); < 247 HRESULT SetIntVectorArray (int* pData, UINT Offset, UINT Count); < 248 HRESULT SetFloatVectorArray(float* pData, UINT Offset, UINT Count); < 249 HRESULT GetBoolVectorArray (BOOL* pData, UINT Offset, UINT Count); < 250 HRESULT GetIntVectorArray (int* pData, UINT Offset, UINT Count); < 251 HRESULT GetFloatVectorArray(float* pData, UINT Offset, UINT Count); < 252 */ < 253 } < 254 < 255 extern (C) const GUID IID_ID3D10EffectMatrixVariable = {0x50666c24, 0xb82f, 0x4e < 256 < 257 interface ID3D10EffectMatrixVariable : ID3D10EffectVariable { < 258 /* TODO: fix vtbl[0] bug < 259 extern(Windows) : < 260 BOOL IsValid(); < 261 ID3D10EffectType GetType(); < 262 HRESULT GetDesc(D3D10_EFFECT_VARIABLE_DESC* pDesc); < 263 ID3D10EffectVariable GetAnnotationByIndex(UINT Index); < 264 ID3D10EffectVariable GetAnnotationByName(LPCSTR Name); < 265 ID3D10EffectVariable GetMemberByIndex(UINT Index); < 266 ID3D10EffectVariable GetMemberByName(LPCSTR Name); < 267 ID3D10EffectVariable GetMemberBySemantic(LPCSTR Semantic); < 268 ID3D10EffectVariable GetElement(UINT Index); < 269 ID3D10EffectConstantBuffer GetParentConstantBuffer(); < 270 ID3D10EffectScalarVariable AsScalar(); < 271 ID3D10EffectVectorVariable AsVector(); < 272 ID3D10EffectMatrixVariable AsMatrix(); < 273 ID3D10EffectStringVariable AsString(); < 274 ID3D10EffectShaderResourceVariable AsShaderResource(); < 275 ID3D10EffectRenderTargetViewVariable AsRenderTargetView(); < 276 ID3D10EffectDepthStencilViewVariable AsDepthStencilView(); < 277 ID3D10EffectConstantBuffer AsConstantBuffer(); < 278 ID3D10EffectShaderVariable AsShader(); < 279 ID3D10EffectBlendVariable AsBlend(); < 280 ID3D10EffectDepthStencilVariable AsDepthStencil(); < 281 ID3D10EffectRasterizerVariable AsRasterizer(); < 282 ID3D10EffectSamplerVariable AsSampler(); < 283 HRESULT SetRawValue(void* pData, UINT ByteOffset, UINT ByteCount); < 284 HRESULT GetRawValue(void* pData, UINT ByteOffset, UINT ByteCount); < 285 HRESULT SetMatrix(float* pData); < 286 HRESULT GetMatrix(float* pData); < 287 HRESULT SetMatrixArray(float* pData, UINT Offset, UINT Count); < 288 HRESULT GetMatrixArray(float* pData, UINT Offset, UINT Count); < 289 HRESULT SetMatrixTranspose(float* pData); < 290 HRESULT GetMatrixTranspose(float* pData); < 291 HRESULT SetMatrixTransposeArray(float* pData, UINT Offset, UINT Count); < 292 HRESULT GetMatrixTransposeArray(float* pData, UINT Offset, UINT Count); < 293 */ < 294 } < 295 < 296 extern (C) const GUID IID_ID3D10EffectStringVariable = {0x71417501, 0x8df9, 0x4e < 297 < 298 interface ID3D10EffectStringVariable : ID3D10EffectVariable { < 299 /* TODO: fix vtbl[0] bug < 300 extern(Windows) : < 301 BOOL IsValid(); < 302 ID3D10EffectType GetType(); < 303 HRESULT GetDesc(D3D10_EFFECT_VARIABLE_DESC* pDesc); < 304 ID3D10EffectVariable GetAnnotationByIndex(UINT Index); < 305 ID3D10EffectVariable GetAnnotationByName(LPCSTR Name); < 306 ID3D10EffectVariable GetMemberByIndex(UINT Index); < 307 ID3D10EffectVariable GetMemberByName(LPCSTR Name); < 308 ID3D10EffectVariable GetMemberBySemantic(LPCSTR Semantic); < 309 ID3D10EffectVariable GetElement(UINT Index); < 310 ID3D10EffectConstantBuffer GetParentConstantBuffer(); < 311 ID3D10EffectScalarVariable AsScalar(); < 312 ID3D10EffectVectorVariable AsVector(); < 313 ID3D10EffectMatrixVariable AsMatrix(); < 314 ID3D10EffectStringVariable AsString(); < 315 ID3D10EffectShaderResourceVariable AsShaderResource(); < 316 ID3D10EffectRenderTargetViewVariable AsRenderTargetView(); < 317 ID3D10EffectDepthStencilViewVariable AsDepthStencilView(); < 318 ID3D10EffectConstantBuffer AsConstantBuffer(); < 319 ID3D10EffectShaderVariable AsShader(); < 320 ID3D10EffectBlendVariable AsBlend(); < 321 ID3D10EffectDepthStencilVariable AsDepthStencil(); < 322 ID3D10EffectRasterizerVariable AsRasterizer(); < 323 ID3D10EffectSamplerVariable AsSampler(); < 324 HRESULT SetRawValue(void* pData, UINT Offset, UINT Count); < 325 HRESULT GetRawValue(void* pData, UINT Offset, UINT Count); < 326 HRESULT GetString(LPCSTR* ppString); < 327 HRESULT GetStringArray(LPCSTR* ppStrings, UINT Offset, UINT Count); < 328 */ < 329 } < 330 < 331 extern (C) const GUID IID_ID3D10EffectShaderResourceVariable = {0xc0a7157b, 0xd8 < 332 < 333 interface ID3D10EffectShaderResourceVariable : ID3D10EffectVariable { < 334 /* TODO: fix vtbl[0] bug < 335 extern(Windows) : < 336 BOOL IsValid(); < 337 ID3D10EffectType GetType(); < 338 HRESULT GetDesc(D3D10_EFFECT_VARIABLE_DESC* pDesc); < 339 ID3D10EffectVariable GetAnnotationByIndex(UINT Index); < 340 ID3D10EffectVariable GetAnnotationByName(LPCSTR Name); < 341 ID3D10EffectVariable GetMemberByIndex(UINT Index); < 342 ID3D10EffectVariable GetMemberByName(LPCSTR Name); < 343 ID3D10EffectVariable GetMemberBySemantic(LPCSTR Semantic); < 344 ID3D10EffectVariable GetElement(UINT Index); < 345 ID3D10EffectConstantBuffer GetParentConstantBuffer(); < 346 ID3D10EffectScalarVariable AsScalar(); < 347 ID3D10EffectVectorVariable AsVector(); < 348 ID3D10EffectMatrixVariable AsMatrix(); < 349 ID3D10EffectStringVariable AsString(); < 350 ID3D10EffectShaderResourceVariable AsShaderResource(); < 351 ID3D10EffectRenderTargetViewVariable AsRenderTargetView(); < 352 ID3D10EffectDepthStencilViewVariable AsDepthStencilView(); < 353 ID3D10EffectConstantBuffer AsConstantBuffer(); < 354 ID3D10EffectShaderVariable AsShader(); < 355 ID3D10EffectBlendVariable AsBlend(); < 356 ID3D10EffectDepthStencilVariable AsDepthStencil(); < 357 ID3D10EffectRasterizerVariable AsRasterizer(); < 358 ID3D10EffectSamplerVariable AsSampler(); < 359 HRESULT SetRawValue(void* pData, UINT Offset, UINT Count); < 360 HRESULT GetRawValue(void* pData, UINT Offset, UINT Count); < 361 HRESULT SetResource(ID3D10ShaderResourceView pResource); < 362 HRESULT GetResource(ID3D10ShaderResourceView* ppResource); < 363 HRESULT SetResourceArray(ID3D10ShaderResourceView* ppResources, UINT Off < 364 HRESULT GetResourceArray(ID3D10ShaderResourceView* ppResources, UINT Off < 365 */ < 366 } < 367 < 368 extern (C) const GUID IID_ID3D10EffectRenderTargetViewVariable = {0x28ca0cc3, 0x < 369 < 370 interface ID3D10EffectRenderTargetViewVariable : ID3D10EffectVariable { < 371 /* TODO: fix vtbl[0] bug < 372 extern(Windows) : < 373 BOOL IsValid(); < 374 ID3D10EffectType GetType(); < 375 HRESULT GetDesc(D3D10_EFFECT_VARIABLE_DESC* pDesc); < 376 ID3D10EffectVariable GetAnnotationByIndex(UINT Index); < 377 ID3D10EffectVariable GetAnnotationByName(LPCSTR Name); < 378 ID3D10EffectVariable GetMemberByIndex(UINT Index); < 379 ID3D10EffectVariable GetMemberByName(LPCSTR Name); < 380 ID3D10EffectVariable GetMemberBySemantic(LPCSTR Semantic); < 381 ID3D10EffectVariable GetElement(UINT Index); < 382 ID3D10EffectConstantBuffer GetParentConstantBuffer(); < 383 ID3D10EffectScalarVariable AsScalar(); < 384 ID3D10EffectVectorVariable AsVector(); < 385 ID3D10EffectMatrixVariable AsMatrix(); < 386 ID3D10EffectStringVariable AsString(); < 387 ID3D10EffectShaderResourceVariable AsShaderResource(); < 388 ID3D10EffectRenderTargetViewVariable AsRenderTargetView(); < 389 ID3D10EffectDepthStencilViewVariable AsDepthStencilView(); < 390 ID3D10EffectConstantBuffer AsConstantBuffer(); < 391 ID3D10EffectShaderVariable AsShader(); < 392 ID3D10EffectBlendVariable AsBlend(); < 393 ID3D10EffectDepthStencilVariable AsDepthStencil(); < 394 ID3D10EffectRasterizerVariable AsRasterizer(); < 395 ID3D10EffectSamplerVariable AsSampler(); < 396 HRESULT SetRawValue(void* pData, UINT Offset, UINT Count); < 397 HRESULT GetRawValue(void* pData, UINT Offset, UINT Count); < 398 HRESULT SetRenderTarget(ID3D10RenderTargetView pResource); < 399 HRESULT GetRenderTarget(ID3D10RenderTargetView* ppResource); < 400 HRESULT SetRenderTargetArray(ID3D10RenderTargetView* ppResources, UINT O < 401 HRESULT GetRenderTargetArray(ID3D10RenderTargetView* ppResources, UINT O < 402 */ < 403 } < 404 < 405 extern (C) const GUID IID_ID3D10EffectDepthStencilViewVariable = {0x3e02c918, 0x < 406 < 407 interface ID3D10EffectDepthStencilViewVariable : ID3D10EffectVariable { < 408 /* TODO: fix vtbl[0] bug < 409 extern(Windows) : < 410 BOOL IsValid(); < 411 ID3D10EffectType GetType(); < 412 HRESULT GetDesc(D3D10_EFFECT_VARIABLE_DESC* pDesc); < 413 ID3D10EffectVariable GetAnnotationByIndex(UINT Index); < 414 ID3D10EffectVariable GetAnnotationByName(LPCSTR Name); < 415 ID3D10EffectVariable GetMemberByIndex(UINT Index); < 416 ID3D10EffectVariable GetMemberByName(LPCSTR Name); < 417 ID3D10EffectVariable GetMemberBySemantic(LPCSTR Semantic); < 418 ID3D10EffectVariable GetElement(UINT Index); < 419 ID3D10EffectConstantBuffer GetParentConstantBuffer(); < 420 ID3D10EffectScalarVariable AsScalar(); < 421 ID3D10EffectVectorVariable AsVector(); < 422 ID3D10EffectMatrixVariable AsMatrix(); < 423 ID3D10EffectStringVariable AsString(); < 424 ID3D10EffectShaderResourceVariable AsShaderResource(); < 425 ID3D10EffectRenderTargetViewVariable AsRenderTargetView(); < 426 ID3D10EffectDepthStencilViewVariable AsDepthStencilView(); < 427 ID3D10EffectConstantBuffer AsConstantBuffer(); < 428 ID3D10EffectShaderVariable AsShader(); < 429 ID3D10EffectBlendVariable AsBlend(); < 430 ID3D10EffectDepthStencilVariable AsDepthStencil(); < 431 ID3D10EffectRasterizerVariable AsRasterizer(); < 432 ID3D10EffectSamplerVariable AsSampler(); < 433 HRESULT SetRawValue(void* pData, UINT Offset, UINT Count); < 434 HRESULT GetRawValue(void* pData, UINT Offset, UINT Count); < 435 HRESULT SetDepthStencil(ID3D10DepthStencilView pResource); < 436 HRESULT GetDepthStencil(ID3D10DepthStencilView* ppResource); < 437 HRESULT SetDepthStencilArray(ID3D10DepthStencilView* ppResources, UINT O < 438 HRESULT GetDepthStencilArray(ID3D10DepthStencilView* ppResources, UINT O < 439 */ < 440 } < 441 < 442 extern (C) const GUID IID_ID3D10EffectConstantBuffer = {0x56648f4d, 0xcc8b, 0x44 < 443 < 444 interface ID3D10EffectConstantBuffer : ID3D10EffectVariable { < 445 /* TODO: fix vtbl[0] bug < 446 extern(Windows) : < 447 ID3D10EffectType GetType(); < 448 HRESULT GetDesc(D3D10_EFFECT_VARIABLE_DESC* pDesc); < 449 ID3D10EffectVariable GetAnnotationByIndex(UINT Index); < 450 ID3D10EffectVariable GetAnnotationByName(LPCSTR Name); < 451 ID3D10EffectVariable GetMemberByIndex(UINT Index); < 452 ID3D10EffectVariable GetMemberByName(LPCSTR Name); < 453 ID3D10EffectVariable GetMemberBySemantic(LPCSTR Semantic); < 454 ID3D10EffectVariable GetElement(UINT Index); < 455 ID3D10EffectConstantBuffer GetParentConstantBuffer(); < 456 ID3D10EffectScalarVariable AsScalar(); < 457 ID3D10EffectVectorVariable AsVector(); < 458 ID3D10EffectMatrixVariable AsMatrix(); < 459 ID3D10EffectStringVariable AsString(); < 460 ID3D10EffectShaderResourceVariable AsShaderResource(); < 461 ID3D10EffectRenderTargetViewVariable AsRenderTargetView(); < 462 ID3D10EffectDepthStencilViewVariable AsDepthStencilView(); < 463 ID3D10EffectConstantBuffer AsConstantBuffer(); < 464 ID3D10EffectShaderVariable AsShader(); < 465 ID3D10EffectBlendVariable AsBlend(); < 466 ID3D10EffectDepthStencilVariable AsDepthStencil(); < 467 ID3D10EffectRasterizerVariable AsRasterizer(); < 468 ID3D10EffectSamplerVariable AsSampler(); < 469 HRESULT SetRawValue(void* pData, UINT Offset, UINT Count); < 470 HRESULT GetRawValue(void* pData, UINT Offset, UINT Count); < 471 HRESULT SetConstantBuffer(ID3D10Buffer pConstantBuffer); < 472 HRESULT GetConstantBuffer(ID3D10Buffer* ppConstantBuffer); < 473 HRESULT SetTextureBuffer(ID3D10ShaderResourceView pTextureBuffer); < 474 HRESULT GetTextureBuffer(ID3D10ShaderResourceView* ppTextureBuffer); < 475 */ < 476 } < 477 < 478 struct D3D10_EFFECT_SHADER_DESC { < 479 BYTE* pInputSignature; < 480 BOOL IsInline; < 481 BYTE* pBytecode; < 482 UINT BytecodeLength; < 483 LPCSTR SODecl; < 484 UINT NumInputSignatureEntries; < 485 UINT NumOutputSignatureEntries; < 486 } < 487 < 488 extern (C) const GUID IID_ID3D10EffectShaderVariable = {0x80849279, 0xc799, 0x47 < 489 < 490 interface ID3D10EffectShaderVariable : ID3D10EffectVariable { < 491 /* TODO: fix vtbl[0] bug < 492 extern(Windows) : < 493 ID3D10EffectType GetType(); < 494 HRESULT GetDesc(D3D10_EFFECT_VARIABLE_DESC* pDesc); < 495 ID3D10EffectVariable GetAnnotationByIndex(UINT Index); < 496 ID3D10EffectVariable GetAnnotationByName(LPCSTR Name); < 497 ID3D10EffectVariable GetMemberByIndex(UINT Index); < 498 ID3D10EffectVariable GetMemberByName(LPCSTR Name); < 499 ID3D10EffectVariable GetMemberBySemantic(LPCSTR Semantic); < 500 ID3D10EffectVariable GetElement(UINT Index); < 501 ID3D10EffectConstantBuffer GetParentConstantBuffer(); < 502 ID3D10EffectScalarVariable AsScalar(); < 503 ID3D10EffectVectorVariable AsVector(); < 504 ID3D10EffectMatrixVariable AsMatrix(); < 505 ID3D10EffectStringVariable AsString(); < 506 ID3D10EffectShaderResourceVariable AsShaderResource(); < 507 ID3D10EffectRenderTargetViewVariable AsRenderTargetView(); < 508 ID3D10EffectDepthStencilViewVariable AsDepthStencilView(); < 509 ID3D10EffectConstantBuffer AsConstantBuffer(); < 510 ID3D10EffectShaderVariable AsShader(); < 511 ID3D10EffectBlendVariable AsBlend(); < 512 ID3D10EffectDepthStencilVariable AsDepthStencil(); < 513 ID3D10EffectRasterizerVariable AsRasterizer(); < 514 ID3D10EffectSamplerVariable AsSampler(); < 515 HRESULT SetRawValue(void* pData, UINT Offset, UINT Count); < 516 HRESULT GetRawValue(void* pData, UINT Offset, UINT Count); < 517 HRESULT GetShaderDesc(UINT ShaderIndex, D3D10_EFFECT_SHADER_DESC* pDesc) < 518 HRESULT GetVertexShader(UINT ShaderIndex, ID3D10VertexShader* ppVS); < 519 HRESULT GetGeometryShader(UINT ShaderIndex, ID3D10GeometryShader* ppGS); < 520 HRESULT GetPixelShader(UINT ShaderIndex, ID3D10PixelShader* ppPS); < 521 HRESULT GetInputSignatureElementDesc(UINT ShaderIndex, UINT Element, D3D < 522 HRESULT GetOutputSignatureElementDesc(UINT ShaderIndex, UINT Element, D3 < 523 */ < 524 } < 525 < 526 extern (C) const GUID IID_ID3D10EffectBlendVariable = {0x1fcd2294, 0xdf6d, 0x4ea < 527 < 528 interface ID3D10EffectBlendVariable : ID3D10EffectVariable { < 529 /* TODO: fix vtbl[0] bug < 530 extern(Windows) : < 531 ID3D10EffectType GetType(); < 532 HRESULT GetDesc(D3D10_EFFECT_VARIABLE_DESC* pDesc); < 533 ID3D10EffectVariable GetAnnotationByIndex(UINT Index); < 534 ID3D10EffectVariable GetAnnotationByName(LPCSTR Name); < 535 ID3D10EffectVariable GetMemberByIndex(UINT Index); < 536 ID3D10EffectVariable GetMemberByName(LPCSTR Name); < 537 ID3D10EffectVariable GetMemberBySemantic(LPCSTR Semantic); < 538 ID3D10EffectVariable GetElement(UINT Index); < 539 ID3D10EffectConstantBuffer GetParentConstantBuffer(); < 540 ID3D10EffectScalarVariable AsScalar(); < 541 ID3D10EffectVectorVariable AsVector(); < 542 ID3D10EffectMatrixVariable AsMatrix(); < 543 ID3D10EffectStringVariable AsString(); < 544 ID3D10EffectShaderResourceVariable AsShaderResource(); < 545 ID3D10EffectRenderTargetViewVariable AsRenderTargetView(); < 546 ID3D10EffectDepthStencilViewVariable AsDepthStencilView(); < 547 ID3D10EffectConstantBuffer AsConstantBuffer(); < 548 ID3D10EffectShaderVariable AsShader(); < 549 ID3D10EffectBlendVariable AsBlend(); < 550 ID3D10EffectDepthStencilVariable AsDepthStencil(); < 551 ID3D10EffectRasterizerVariable AsRasterizer(); < 552 ID3D10EffectSamplerVariable AsSampler(); < 553 HRESULT SetRawValue(void* pData, UINT Offset, UINT Count); < 554 HRESULT GetRawValue(void* pData, UINT Offset, UINT Count); < 555 HRESULT GetBlendState(UINT Index, ID3D10BlendState* ppBlendState); < 556 HRESULT GetBackingStore(UINT Index, D3D10_BLEND_DESC* pBlendDesc); < 557 */ < 558 } < 559 < 560 extern (C) const GUID IID_ID3D10EffectDepthStencilVariable = {0xaf482368, 0x330a < 561 < 562 interface ID3D10EffectDepthStencilVariable : ID3D10EffectVariable { < 563 /* TODO: fix vtbl[0] bug < 564 extern(Windows) : < 565 ID3D10EffectType GetType(); < 566 HRESULT GetDesc(D3D10_EFFECT_VARIABLE_DESC* pDesc); < 567 ID3D10EffectVariable GetAnnotationByIndex(UINT Index); < 568 ID3D10EffectVariable GetAnnotationByName(LPCSTR Name); < 569 ID3D10EffectVariable GetMemberByIndex(UINT Index); < 570 ID3D10EffectVariable GetMemberByName(LPCSTR Name); < 571 ID3D10EffectVariable GetMemberBySemantic(LPCSTR Semantic); < 572 ID3D10EffectVariable GetElement(UINT Index); < 573 ID3D10EffectConstantBuffer GetParentConstantBuffer(); < 574 ID3D10EffectScalarVariable AsScalar(); < 575 ID3D10EffectVectorVariable AsVector(); < 576 ID3D10EffectMatrixVariable AsMatrix(); < 577 ID3D10EffectStringVariable AsString(); < 578 ID3D10EffectShaderResourceVariable AsShaderResource(); < 579 ID3D10EffectRenderTargetViewVariable AsRenderTargetView(); < 580 ID3D10EffectDepthStencilViewVariable AsDepthStencilView(); < 581 ID3D10EffectConstantBuffer AsConstantBuffer(); < 582 ID3D10EffectShaderVariable AsShader(); < 583 ID3D10EffectBlendVariable AsBlend(); < 584 ID3D10EffectDepthStencilVariable AsDepthStencil(); < 585 ID3D10EffectRasterizerVariable AsRasterizer(); < 586 ID3D10EffectSamplerVariable AsSampler(); < 587 HRESULT SetRawValue(void* pData, UINT Offset, UINT Count); < 588 HRESULT GetRawValue(void* pData, UINT Offset, UINT Count); < 589 HRESULT GetDepthStencilState(UINT Index, ID3D10DepthStencilState* ppDept < 590 HRESULT GetBackingStore(UINT Index, D3D10_DEPTH_STENCIL_DESC* pDepthSten < 591 */ < 592 } < 593 < 594 extern (C) const GUID IID_ID3D10EffectRasterizerVariable = {0x21af9f0e, 0x4d94, < 595 < 596 interface ID3D10EffectRasterizerVariable : ID3D10EffectVariable { < 597 /* TODO: fix vtbl[0] bug < 598 extern(Windows) : < 599 ID3D10EffectType GetType(); < 600 HRESULT GetDesc(D3D10_EFFECT_VARIABLE_DESC* pDesc); < 601 ID3D10EffectVariable GetAnnotationByIndex(UINT Index); < 602 ID3D10EffectVariable GetAnnotationByName(LPCSTR Name); < 603 ID3D10EffectVariable GetMemberByIndex(UINT Index); < 604 ID3D10EffectVariable GetMemberByName(LPCSTR Name); < 605 ID3D10EffectVariable GetMemberBySemantic(LPCSTR Semantic); < 606 ID3D10EffectVariable GetElement(UINT Index); < 607 ID3D10EffectConstantBuffer GetParentConstantBuffer(); < 608 ID3D10EffectScalarVariable AsScalar(); < 609 ID3D10EffectVectorVariable AsVector(); < 610 ID3D10EffectMatrixVariable AsMatrix(); < 611 ID3D10EffectStringVariable AsString(); < 612 ID3D10EffectShaderResourceVariable AsShaderResource(); < 613 ID3D10EffectRenderTargetViewVariable AsRenderTargetView(); < 614 ID3D10EffectDepthStencilViewVariable AsDepthStencilView(); < 615 ID3D10EffectConstantBuffer AsConstantBuffer(); < 616 ID3D10EffectShaderVariable AsShader(); < 617 ID3D10EffectBlendVariable AsBlend(); < 618 ID3D10EffectDepthStencilVariable AsDepthStencil(); < 619 ID3D10EffectRasterizerVariable AsRasterizer(); < 620 ID3D10EffectSamplerVariable AsSampler(); < 621 HRESULT SetRawValue(void* pData, UINT Offset, UINT Count); < 622 HRESULT GetRawValue(void* pData, UINT Offset, UINT Count); < 623 HRESULT GetRasterizerState(UINT Index, ID3D10RasterizerState* ppRasteriz < 624 HRESULT GetBackingStore(UINT Index, D3D10_RASTERIZER_DESC* pRasterizerDe < 625 */ < 626 } < 627 < 628 extern (C) const GUID IID_ID3D10EffectSamplerVariable = {0x6530d5c7, 0x07e9, 0x4 < 629 < 630 interface ID3D10EffectSamplerVariable : ID3D10EffectVariable { < 631 /* TODO: fix vtbl[0] bug < 632 extern(Windows) : < 633 ID3D10EffectType GetType(); < 634 HRESULT GetDesc(D3D10_EFFECT_VARIABLE_DESC* pDesc); < 635 ID3D10EffectVariable GetAnnotationByIndex(UINT Index); < 636 ID3D10EffectVariable GetAnnotationByName(LPCSTR Name); < 637 ID3D10EffectVariable GetMemberByIndex(UINT Index); < 638 ID3D10EffectVariable GetMemberByName(LPCSTR Name); < 639 ID3D10EffectVariable GetMemberBySemantic(LPCSTR Semantic); < 640 ID3D10EffectVariable GetElement(UINT Index); < 641 ID3D10EffectConstantBuffer GetParentConstantBuffer(); < 642 ID3D10EffectScalarVariable AsScalar(); < 643 ID3D10EffectVectorVariable AsVector(); < 644 ID3D10EffectMatrixVariable AsMatrix(); < 645 ID3D10EffectStringVariable AsString(); < 646 ID3D10EffectShaderResourceVariable AsShaderResource(); < 647 ID3D10EffectRenderTargetViewVariable AsRenderTargetView(); < 648 ID3D10EffectDepthStencilViewVariable AsDepthStencilView(); < 649 ID3D10EffectConstantBuffer AsConstantBuffer(); < 650 ID3D10EffectShaderVariable AsShader(); < 651 ID3D10EffectBlendVariable AsBlend(); < 652 ID3D10EffectDepthStencilVariable AsDepthStencil(); < 653 ID3D10EffectRasterizerVariable AsRasterizer(); < 654 ID3D10EffectSamplerVariable AsSampler(); < 655 HRESULT SetRawValue(void* pData, UINT Offset, UINT Count); < 656 HRESULT GetRawValue(void* pData, UINT Offset, UINT Count); < 657 HRESULT GetSampler(UINT Index, ID3D10SamplerState* ppSampler); < 658 HRESULT GetBackingStore(UINT Index, D3D10_SAMPLER_DESC* pSamplerDesc); < 659 */ < 660 } < 661 < 662 struct D3D10_PASS_DESC { < 663 LPCSTR Name; < 664 UINT Annotations; < 665 BYTE* pIAInputSignature; < 666 SIZE_T IAInputSignatureSize; < 667 UINT StencilRef; < 668 UINT SampleMask; < 669 FLOAT[4] BlendFactor; < 670 } < 671 < 672 struct D3D10_PASS_SHADER_DESC { < 673 ID3D10EffectShaderVariable pShaderVariable; < 674 UINT ShaderIndex; < 675 } < 676 < 677 extern (C) const GUID IID_ID3D10EffectPass = {0x5cfbeb89, 0x1a06, 0x46e0, [0xb2, < 678 < 679 /+interface ID3D10EffectPass { < 680 /* TODO: fix vtbl[0] bug < 681 extern(Windows) : < 682 BOOL IsValid(); < 683 HRESULT GetDesc(D3D10_PASS_DESC* pDesc); < 684 HRESULT GetVertexShaderDesc(D3D10_PASS_SHADER_DESC* pDesc); < 685 HRESULT GetGeometryShaderDesc(D3D10_PASS_SHADER_DESC* pDesc); < 686 HRESULT GetPixelShaderDesc(D3D10_PASS_SHADER_DESC* pDesc); < 687 ID3D10EffectVariable GetAnnotationByIndex(UINT Index); < 688 ID3D10EffectVariable GetAnnotationByName(LPCSTR Name); < 689 HRESULT Apply(UINT Flags); < 690 HRESULT ComputeStateBlockMask(D3D10_STATE_BLOCK_MASK* pStateBlockMask); < 691 */ < 692 }+/ < 693 /** < 694 * HACK to FIX vtbl[0] bug: < 695 * This is an example HACK how to fix all interfaces which are NOT derived from < 696 * IUnknown. They need the first entry in their vtbl[] point to the first < 697 * virtual function. < 698 * See: < 699 * http://www.digitalmars.com/d/cpp_interface.html < 700 * http://d.puremagic.com/issues/show_bug.cgi?id=1687 < 701 */ < 702 struct ID3D10EffectPassVtbl { < 703 extern(Windows) : < 704 BOOL function(ID3D10EffectPass) IsValid; < 705 HRESULT function(ID3D10EffectPass, D3D10_PASS_DESC* pDesc) GetDesc; < 706 HRESULT function(ID3D10EffectPass, D3D10_PASS_SHADER_DESC* pDesc) GetVer < 707 HRESULT function(ID3D10EffectPass, D3D10_PASS_SHADER_DESC* pDesc) GetGeo < 708 HRESULT function(ID3D10EffectPass, D3D10_PASS_SHADER_DESC* pDesc) GetPix < 709 ID3D10EffectVariable function(ID3D10EffectPass, UINT Index) GetAnnotatio < 710 ID3D10EffectVariable function(ID3D10EffectPass, LPCSTR Name) GetAnnotati < 711 HRESULT function(ID3D10EffectPass, UINT Flags) Apply; < 712 HRESULT function(ID3D10EffectPass, D3D10_STATE_BLOCK_MASK* pStateBlockMa < 713 } < 714 alias ID3D10EffectPassVtbl** ID3D10EffectPass; < 715 < 716 struct D3D10_TECHNIQUE_DESC { < 717 LPCSTR Name; < 718 UINT Passes; < 719 UINT Annotations; < 720 } < 721 < 722 extern (C) const GUID IID_ID3D10EffectTechnique = {0xdb122ce8, 0xd1c9, 0x4292, [ < 723 < 724 /+interface ID3D10EffectTechnique { < 725 /* TODO: fix vtbl[0] bug < 726 extern(Windows) : < 727 BOOL IsValid(); < 728 HRESULT GetDesc(D3D10_TECHNIQUE_DESC* pDesc); < 729 ID3D10EffectVariable GetAnnotationByIndex(UINT Index); < 730 ID3D10EffectVariable GetAnnotationByName(LPCSTR Name); < 731 ID3D10EffectPass GetPassByIndex(UINT Index); < 732 ID3D10EffectPass GetPassByName(LPCSTR Name); < 733 HRESULT ComputeStateBlockMask(D3D10_STATE_BLOCK_MASK* pStateBlockMask); < 734 */ < 735 }+/ < 736 /** < 737 * HACK to FIX vtbl[0] bug: < 738 * This is an example HACK how to fix all interfaces which are NOT derived from < 739 * IUnknown. They need the first entry in their vtbl[] point to the first < 740 * virtual function. < 741 * See: < 742 * http://www.digitalmars.com/d/cpp_interface.html < 743 * http://d.puremagic.com/issues/show_bug.cgi?id=1687 < 744 */ < 745 struct ID3D10EffectTechniqueVtbl { < 746 extern(Windows) : < 747 BOOL function(ID3D10EffectTechnique) IsValid; < 748 HRESULT function(ID3D10EffectTechnique, D3D10_TECHNIQUE_DESC* pDesc) Get < 749 ID3D10EffectVariable function(ID3D10EffectTechnique, UINT Index) GetAnno < 750 ID3D10EffectVariable function(ID3D10EffectTechnique, LPCSTR Name) GetAnn < 751 ID3D10EffectPass function(ID3D10EffectTechnique, UINT Index) GetPassByIn < 752 ID3D10EffectPass function(ID3D10EffectTechnique, LPCSTR Name) GetPassByN < 753 HRESULT function(ID3D10EffectTechnique, D3D10_STATE_BLOCK_MASK* pStateBl < 754 } < 755 alias ID3D10EffectTechniqueVtbl** ID3D10EffectTechnique; < 756 < 757 struct D3D10_EFFECT_DESC { < 758 BOOL IsChildEffect; < 759 UINT ConstantBuffers; < 760 UINT SharedConstantBuffers; < 761 UINT GlobalVariables; < 762 UINT SharedGlobalVariables; < 763 UINT Techniques; < 764 } < 765 < 766 extern (C) const GUID IID_ID3D10Effect = {0x51b0ca8b, 0xec0b, 0x4519, [0x87, 0xd < 767 < 768 interface ID3D10Effect : IUnknown { < 769 extern(Windows) : < 770 BOOL IsValid(); < 771 BOOL IsPool(); < 772 HRESULT GetDevice(ID3D10Device* ppDevice); < 773 HRESULT GetDesc(D3D10_EFFECT_DESC* pDesc); < 774 ID3D10EffectConstantBuffer GetConstantBufferByIndex(UINT Index); < 775 ID3D10EffectConstantBuffer GetConstantBufferByName(LPCSTR Name); < 776 ID3D10EffectVariable GetVariableByIndex(UINT Index); < 777 ID3D10EffectVariable GetVariableByName(LPCSTR Name); < 778 ID3D10EffectVariable GetVariableBySemantic(LPCSTR Semantic); < 779 ID3D10EffectTechnique GetTechniqueByIndex(UINT Index); < 780 ID3D10EffectTechnique GetTechniqueByName(LPCSTR Name); < 781 HRESULT Optimize(); < 782 BOOL IsOptimized(); < 783 } < 784 < 785 extern (C) const GUID IID_ID3D10EffectPool = {0x9537ab04, 0x3250, 0x412e, [0x82, < 786 < 787 interface ID3D10EffectPool : IUnknown { < 788 extern(Windows) : < 789 ID3D10Effect AsEffect(); < 790 } < 791 < 792 HRESULT D3D10CompileEffectFromMemory(void* pData, SIZE_T DataLength, LPCSTR pSrc < 793 HRESULT D3D10CreateEffectFromMemory(void* pData, SIZE_T DataLength, UINT FXFlags < 794 HRESULT D3D10CreateEffectPoolFromMemory(void* pData, SIZE_T DataLength, UINT FXF < 795 HRESULT D3D10DisassembleEffect(ID3D10Effect pEffect, BOOL EnableColorCode, ID3D1 <
Deleted src/win32/directx/d3d10misc.d version [371321ee8dae0650]
1 /***********************************************************************\ < 2 * d3d10misc.d * < 3 * * < 4 * Windows API header module * < 5 * * < 6 * Placed into public domain * < 7 \***********************************************************************/ < 8 module win32.directx.d3d10misc; < 9 < 10 private import win32.windows; < 11 < 12 private import win32.directx.dxgi; < 13 private import win32.directx.d3d10; < 14 < 15 extern (C) const GUID IID_ID3D10Blob = { < 16 0x8BA5FB08, 0x5195, 0x40E2, [0xAC, 0x58, 0x0D, 0x98, 0x9C, 0x3A, 0x01, 0 < 17 }; < 18 < 19 interface ID3D10Blob : IUnknown { < 20 extern(Windows) : < 21 LPVOID GetBufferPointer(); < 22 SIZE_T GetBufferSize(); < 23 } < 24 < 25 enum D3D10_DRIVER_TYPE { < 26 D3D10_DRIVER_TYPE_HARDWARE = 0, < 27 D3D10_DRIVER_TYPE_REFERENCE = 1, < 28 D3D10_DRIVER_TYPE_NULL = 2, < 29 D3D10_DRIVER_TYPE_SOFTWARE = 3 < 30 } < 31 < 32 extern (C) const GUID GUID_DeviceType = { < 33 0xD722FB4D, 0x7A68, 0x437A, [0xB2, 0x0C, 0x58, 0x04, 0xEE, 0x24, 0x94, 0 < 34 }; < 35 < 36 extern(Windows) { < 37 HRESULT D3D10CreateDevice(IDXGIAdapter pAdapter, < 38 D3D10_DRIVER_TYPE DriverType, HMODULE Software, UINT Flags, < 39 UINT SDKVersion, ID3D10Device* ppDevice); < 40 HRESULT D3D10CreateDeviceAndSwapChain(IDXGIAdapter pAdapter, < 41 D3D10_DRIVER_TYPE DriverType, HMODULE Software, UINT Flags, < 42 UINT SDKVersion, DXGI_SWAP_CHAIN_DESC* pSwapChainDesc, < 43 IDXGISwapChain* ppSwapChain, ID3D10Device* ppDevice); < 44 HRESULT D3D10CreateBlob(SIZE_T NumBytes, ID3D10Blob* ppBuffer); < 45 } <
Deleted src/win32/directx/d3d10shader.d version [154438c25ca9a643]
1 /***********************************************************************\ < 2 * d3d10shader.d * < 3 * * < 4 * Windows API header module * < 5 * * < 6 * Placed into public domain * < 7 \***********************************************************************/ < 8 module win32.directx.d3d10shader; < 9 < 10 private import win32.windows; < 11 private import win32.directx.d3d10; < 12 < 13 < 14 uint D3D10_TX_VERSION(uint _Major, uint _Minor) { < 15 return ('T' << 24) | ('X' << 16) | (_Major << 8) | _Minor; < 16 } < 17 < 18 const D3D10_SHADER_DEBUG < 19 const D3D10_SHADER_SKIP_VALIDATION = 1 << 1 < 20 const D3D10_SHADER_SKIP_OPTIMIZATION = 1 << 2; < 21 const D3D10_SHADER_PACK_MATRIX_ROW_MAJOR = 1 << 3; < 22 const D3D10_SHADER_PACK_MATRIX_COLUMN_MAJOR = 1 << 4; < 23 const D3D10_SHADER_PARTIAL_PRECISION = 1 << 5; < 24 const D3D10_SHADER_FORCE_VS_SOFTWARE_NO_OPT = 1 << 6; < 25 const D3D10_SHADER_FORCE_PS_SOFTWARE_NO_OPT = 1 << 7; < 26 const D3D10_SHADER_NO_PRESHADER = 1 << 8 < 27 const D3D10_SHADER_AVOID_FLOW_CONTROL = 1 << 9; < 28 const D3D10_SHADER_PREFER_FLOW_CONTROL = 1 << 10; < 29 const D3D10_SHADER_ENABLE_STRICTNESS = 1 << 11; < 30 const D3D10_SHADER_ENABLE_BACKWARDS_COMPATIBILITY = 1 << 12; < 31 const D3D10_SHADER_IEEE_STRICTNESS = 1 << 1 < 32 const D3D10_SHADER_OPTIMIZATION_LEVEL0 = 1 << 14; < 33 const D3D10_SHADER_OPTIMIZATION_LEVEL1 = 0; < 34 const D3D10_SHADER_OPTIMIZATION_LEVEL2 = (1 << 14) | (1 < 35 const D3D10_SHADER_OPTIMIZATION_LEVEL3 = 1 << 15; < 36 < 37 struct D3D10_SHADER_MACRO { < 38 LPCSTR Name; < 39 LPCSTR Definition; < 40 } < 41 < 42 enum D3D10_SHADER_VARIABLE_CLASS { < 43 D3D10_SVC_SCALAR, < 44 D3D10_SVC_VECTOR, < 45 D3D10_SVC_MATRIX_ROWS, < 46 D3D10_SVC_MATRIX_COLUMNS, < 47 D3D10_SVC_OBJECT, < 48 D3D10_SVC_STRUCT, < 49 D3D10_SVC_FORCE_DWORD = 0x7fffffff < 50 } < 51 < 52 enum D3D10_SHADER_VARIABLE_FLAGS { < 53 D3D10_SVF_USERPACKED = 1, < 54 D3D10_SVF_USED = 2, < 55 D3D10_SVF_FORCE_DWORD = 0x7fffffff < 56 } < 57 < 58 enum D3D10_SHADER_VARIABLE_TYPE { < 59 D3D10_SVT_VOID = 0, < 60 D3D10_SVT_BOOL = 1, < 61 D3D10_SVT_INT = 2, < 62 D3D10_SVT_FLOAT = 3, < 63 D3D10_SVT_STRING = 4, < 64 D3D10_SVT_TEXTURE = 5, < 65 D3D10_SVT_TEXTURE1D = 6, < 66 D3D10_SVT_TEXTURE2D = 7, < 67 D3D10_SVT_TEXTURE3D = 8, < 68 D3D10_SVT_TEXTURECUBE = 9, < 69 D3D10_SVT_SAMPLER = 10, < 70 D3D10_SVT_PIXELSHADER = 15, < 71 D3D10_SVT_VERTEXSHADER = 16, < 72 D3D10_SVT_UINT = 19, < 73 D3D10_SVT_UINT8 = 20, < 74 D3D10_SVT_GEOMETRYSHADER = 21, < 75 D3D10_SVT_RASTERIZER = 22, < 76 D3D10_SVT_DEPTHSTENCIL = 23, < 77 D3D10_SVT_BLEND = 24, < 78 D3D10_SVT_BUFFER = 25, < 79 D3D10_SVT_CBUFFER = 26, < 80 D3D10_SVT_TBUFFER = 27, < 81 D3D10_SVT_TEXTURE1DARRAY = 28, < 82 D3D10_SVT_TEXTURE2DARRAY = 29, < 83 D3D10_SVT_RENDERTARGETVIEW = 30, < 84 D3D10_SVT_DEPTHSTENCILVIEW = 31, < 85 D3D10_SVT_TEXTURE2DMS = 32, < 86 D3D10_SVT_TEXTURE2DMSARRAY = 33, < 87 D3D10_SVT_TEXTURECUBEARRAY = 34, < 88 D3D10_SVT_FORCE_DWORD = 0x7fffffff < 89 } < 90 < 91 enum D3D10_SHADER_INPUT_FLAGS { < 92 D3D10_SIF_USERPACKED = 1, < 93 D3D10_SIF_COMPARISON_SAMPLER = 2, < 94 D3D10_SIF_TEXTURE_COMPONENT_0 = 4, < 95 D3D10_SIF_TEXTURE_COMPONENT_1 = 8, < 96 D3D10_SIF_TEXTURE_COMPONENTS = 12, < 97 D3D10_SIF_FORCE_DWORD = 0x7fffffff < 98 } < 99 < 100 enum D3D10_SHADER_INPUT_TYPE { < 101 D3D10_SIT_CBUFFER, < 102 D3D10_SIT_TBUFFER, < 103 D3D10_SIT_TEXTURE, < 104 D3D10_SIT_SAMPLER < 105 } < 106 < 107 enum D3D10_SHADER_CBUFFER_FLAGS { < 108 D3D10_CBF_USERPACKED = 1, < 109 D3D10_CBF_FORCE_DWORD = 0x7fffffff < 110 } < 111 < 112 enum D3D10_CBUFFER_TYPE { < 113 D3D10_CT_CBUFFER, < 114 D3D10_CT_TBUFFER < 115 } < 116 < 117 enum D3D10_NAME { < 118 D3D10_NAME_UNDEFINED = 0, < 119 D3D10_NAME_POSITION = 1, < 120 D3D10_NAME_CLIP_DISTANCE = 2, < 121 D3D10_NAME_CULL_DISTANCE = 3, < 122 D3D10_NAME_RENDER_TARGET_ARRAY_INDEX = 4, < 123 D3D10_NAME_VIEWPORT_ARRAY_INDEX = 5, < 124 D3D10_NAME_VERTEX_ID = 6, < 125 D3D10_NAME_PRIMITIVE_ID = 7, < 126 D3D10_NAME_INSTANCE_ID = 8, < 127 D3D10_NAME_IS_FRONT_FACE = 9, < 128 D3D10_NAME_SAMPLE_INDEX = 10, < 129 D3D10_NAME_TARGET = 64, < 130 D3D10_NAME_DEPTH = 65, < 131 D3D10_NAME_COVERAGE = 66 < 132 } < 133 < 134 enum D3D10_RESOURCE_RETURN_TYPE { < 135 D3D10_RETURN_TYPE_UNORM = 1, < 136 D3D10_RETURN_TYPE_SNORM, < 137 D3D10_RETURN_TYPE_SINT, < 138 D3D10_RETURN_TYPE_UINT, < 139 D3D10_RETURN_TYPE_FLOAT, < 140 D3D10_RETURN_TYPE_MIXED < 141 } < 142 < 143 enum D3D10_REGISTER_COMPONENT_TYPE { < 144 D3D10_REGISTER_COMPONENT_UNKNOWN = 0, < 145 D3D10_REGISTER_COMPONENT_UINT32, < 146 D3D10_REGISTER_COMPONENT_SINT32, < 147 D3D10_REGISTER_COMPONENT_FLOAT32 < 148 } < 149 < 150 enum D3D10_INCLUDE_TYPE { < 151 D3D10_INCLUDE_LOCAL, < 152 D3D10_INCLUDE_SYSTEM, < 153 D3D10_INCLUDE_FORCE_DWORD = 0x7fffffff < 154 } < 155 < 156 interface ID3D10Include { < 157 /* TODO: fix vtbl[0] bug < 158 extern(Windows) : < 159 HRESULT Open(D3D10_INCLUDE_TYPE IncludeType, LPCSTR pFileName, LPCVOID p < 160 HRESULT Close(LPCVOID pData); < 161 */ < 162 } < 163 < 164 struct D3D10_SHADER_DESC { < 165 UINT Version; < 166 LPCSTR Creator; < 167 UINT Flags; < 168 UINT ConstantBuffers; < 169 UINT BoundResources; < 170 UINT InputParameters; < 171 UINT OutputParameters; < 172 UINT InstructionCount; < 173 UINT TempRegisterCount; < 174 UINT TempArrayCount; < 175 UINT DefCount; < 176 UINT DclCount; < 177 UINT TextureNormalInstructions; < 178 UINT TextureLoadInstructions; < 179 UINT TextureCompInstructions; < 180 UINT TextureBiasInstructions; < 181 UINT TextureGradientInstructions; < 182 UINT FloatInstructionCount; < 183 UINT IntInstructionCount; < 184 UINT UintInstructionCount; < 185 UINT StaticFlowControlCount; < 186 UINT DynamicFlowControlCount; < 187 UINT MacroInstructionCount; < 188 UINT ArrayInstructionCount; < 189 UINT CutInstructionCount; < 190 UINT EmitInstructionCount; < 191 D3D10_PRIMITIVE_TOPOLOGY GSOutputTopology; < 192 UINT GSMaxOutputVertexCount; < 193 } < 194 < 195 struct D3D10_SHADER_BUFFER_DESC { < 196 LPCSTR Name; < 197 D3D10_CBUFFER_TYPE Type; < 198 UINT Variables; < 199 UINT Size; < 200 UINT uFlags; < 201 } < 202 < 203 struct D3D10_SHADER_VARIABLE_DESC { < 204 LPCSTR Name; < 205 UINT StartOffset; < 206 UINT Size; < 207 UINT uFlags; < 208 LPVOID DefaultValue; < 209 } < 210 < 211 struct D3D10_SHADER_TYPE_DESC { < 212 D3D10_SHADER_VARIABLE_CLASS Class; < 213 D3D10_SHADER_VARIABLE_TYPE Type; < 214 UINT Rows; < 215 UINT Columns; < 216 UINT Elements; < 217 UINT Members; < 218 UINT Offset; < 219 } < 220 < 221 struct D3D10_SHADER_INPUT_BIND_DESC { < 222 LPCSTR Name; < 223 D3D10_SHADER_INPUT_TYPE Type; < 224 UINT BindPoint; < 225 UINT BindCount; < 226 UINT uFlags; < 227 D3D10_RESOURCE_RETURN_TYPE ReturnType; < 228 D3D10_SRV_DIMENSION Dimension; < 229 UINT NumSamples; < 230 } < 231 < 232 struct D3D10_SIGNATURE_PARAMETER_DESC { < 233 LPCSTR SemanticName; < 234 UINT SemanticIndex; < 235 UINT Register; < 236 D3D10_NAME SystemValueType; < 237 D3D10_REGISTER_COMPONENT_TYPE ComponentType; < 238 BYTE Mask; < 239 BYTE ReadWriteMask; < 240 } < 241 < 242 extern(C) const GUID IID_ID3D10ShaderReflectionType = {0xc530ad7d, 0x9b16, 0x439 < 243 < 244 interface ID3D10ShaderReflectionType { < 245 /* TODO: fix vtbl[0] bug < 246 extern(Windows) : < 247 HRESULT GetDesc(D3D10_SHADER_TYPE_DESC* pDesc); < 248 ID3D10ShaderReflectionType* GetMemberTypeByIndex(UINT Index); < 249 ID3D10ShaderReflectionType* GetMemberTypeByName(LPCSTR Name); < 250 LPCSTR GetMemberTypeName(UINT Index); < 251 */ < 252 } < 253 < 254 extern(C) const GUID IID_ID3D10ShaderReflectionVariable = {0x1bf63c95, 0x2650, 0 < 255 < 256 interface ID3D10ShaderReflectionVariable { < 257 /* TODO: fix vtbl[0] bug < 258 extern(Windows) : < 259 HRESULT GetDesc(D3D10_SHADER_VARIABLE_DESC* pDesc); < 260 ID3D10ShaderReflectionType* GetType(); < 261 */ < 262 } < 263 < 264 extern(C) const GUID IID_ID3D10ShaderReflectionConstantBuffer = {0x66c66a94, 0xd < 265 < 266 interface ID3D10ShaderReflectionConstantBuffer { < 267 /* TODO: fix vtbl[0] bug < 268 extern(Windows) : < 269 HRESULT GetDesc(D3D10_SHADER_BUFFER_DESC* pDesc); < 270 ID3D10ShaderReflectionVariable* GetVariableByIndex(UINT Index); < 271 ID3D10ShaderReflectionVariable* GetVariableByName(LPCSTR Name); < 272 */ < 273 } < 274 < 275 extern(C) const GUID IID_ID3D10ShaderReflection = {0xd40e20b6, 0xf8f7, 0x42ad, [ < 276 < 277 interface ID3D10ShaderReflection : IUnknown { < 278 extern(Windows) : < 279 HRESULT QueryInterface(REFIID iid, LPVOID* ppv); < 280 ULONG AddRef(); < 281 ULONG Release(); < 282 HRESULT GetDesc(D3D10_SHADER_DESC* pDesc); < 283 ID3D10ShaderReflectionConstantBuffer* GetConstantBufferByIndex(UINT Inde < 284 ID3D10ShaderReflectionConstantBuffer* GetConstantBufferByName(LPCSTR Nam < 285 HRESULT GetResourceBindingDesc(UINT ResourceIndex, D3D10_SHADER_INPUT_BI < 286 HRESULT GetInputParameterDesc(UINT ParameterIndex, D3D10_SIGNATURE_PARAM < 287 HRESULT GetOutputParameterDesc(UINT ParameterIndex, D3D10_SIGNATURE_PARA < 288 } < 289 < 290 HRESULT D3D10CompileShader(LPCSTR pSrcData, SIZE_T SrcDataLen, LPCSTR pFileName, < 291 HRESULT D3D10DisassembleShader(void* pShader, SIZE_T BytecodeLength, BOOL Enable < 292 LPCSTR D3D10GetPixelShaderProfile(ID3D10Device pDevice); < 293 LPCSTR D3D10GetVertexShaderProfile(ID3D10Device pDevice); < 294 LPCSTR D3D10GetGeometryShaderProfile(ID3D10Device pDevice); < 295 HRESULT D3D10ReflectShader(void* pShaderBytecode, SIZE_T BytecodeLength, ID3D10S < 296 HRESULT D3D10PreprocessShader(LPCSTR pSrcData, SIZE_T SrcDataSize, LPCSTR pFileN < 297 HRESULT D3D10GetInputSignatureBlob(void* pShaderBytecode, SIZE_T BytecodeLength, < 298 HRESULT D3D10GetOutputSignatureBlob(void* pShaderBytecode, SIZE_T BytecodeLength < 299 HRESULT D3D10GetInputAndOutputSignatureBlob(void* pShaderBytecode, SIZE_T Byteco < 300 HRESULT D3D10GetShaderDebugInfo(void* pShaderBytecode, SIZE_T BytecodeLength, ID < 301 <
Deleted src/win32/directx/d3d9.d version [31c199e5b62e320d]
1 /*==========================================================================; < 2 * < 3 * Copyright (C) Microsoft Corporation. All Rights Reserved. < 4 * < 5 * File: d3d9.h < 6 * Content: Direct3D include file < 7 * < 8 ****************************************************************************/ < 9 module win32.directx.d3d9; < 10 < 11 import win32.windows; < 12 public import win32.directx.d3d9types; < 13 public import win32.directx.d3d9caps; < 14 < 15 const DIRECT3D_VERSION = 0x0900; < 16 < 17 /**This identifier is passed to Direct3DCreate9 in order to ensure that an < 18 * application was built against the correct header files. This number is < 19 * incremented whenever a header (or other) change would require applications < 20 * to be rebuilt. If the version doesn't match, Direct3DCreate9 will fail. < 21 * (The number itself has no meaning.)*/ < 22 < 23 debug { < 24 const D3D_SDK_VERSION = (32 | 0x80000000); < 25 const D3D9b_SDK_VERSION = (31 | 0x80000000); < 26 } < 27 else { < 28 const D3D_SDK_VERSION = 32; < 29 const D3D9b_SDK_VERSION = 31; < 30 } < 31 < 32 /* IID_IDirect3D9 */ < 33 /* {81BDCBCA-64D4-426d-AE8D-AD0147F4275C} */ < 34 extern (C) const GUID IID_IDirect3D9 = { 0x81bdcbca, 0x64d4, 0x426d, [0xae, 0x8d < 35 < 36 /* IID_IDirect3DDevice9 */ < 37 // {D0223B96-BF7A-43fd-92BD-A43B0D82B9EB} */ < 38 extern (C) const GUID IID_IDirect3DDevice9 = { 0xd0223b96, 0xbf7a, 0x43fd, [0x92 < 39 < 40 /* IID_IDirect3DResource9 */ < 41 // {05EEC05D-8F7D-4362-B999-D1BAF357C704} < 42 extern (C) const GUID IID_IDirect3DResource9 = { 0x05eec05d, 0x8f7d, 0x4362, [0x < 43 < 44 /* IID_IDirect3DBaseTexture9 */ < 45 /* {580CA87E-1D3C-4d54-991D-B7D3E3C298CE} */ < 46 extern (C) const GUID IID_IDirect3DBaseTexture9 = { 0x580ca87e, 0x1d3c, 0x4d54, < 47 < 48 /* IID_IDirect3DTexture9 */ < 49 /* {85C31227-3DE5-4f00-9B3A-F11AC38C18B5} */ < 50 extern (C) const GUID IID_IDirect3DTexture9 = { 0x85c31227, 0x3de5, 0x4f00, [0x9 < 51 < 52 /* IID_IDirect3DCubeTexture9 */ < 53 /* {FFF32F81-D953-473a-9223-93D652ABA93F} */ < 54 extern (C) const GUID IID_IDirect3DCubeTexture9 = { 0xfff32f81, 0xd953, 0x473a, < 55 < 56 /* IID_IDirect3DVolumeTexture9 */ < 57 /* {2518526C-E789-4111-A7B9-47EF328D13E6} */ < 58 extern (C) const GUID IID_IDirect3DVolumeTexture9 = { 0x2518526c, 0xe789, 0x4111 < 59 < 60 /* IID_IDirect3DVertexBuffer9 */ < 61 /* {B64BB1B5-FD70-4df6-BF91-19D0A12455E3} */ < 62 extern (C) const GUID IID_IDirect3DVertexBuffer9 = { 0xb64bb1b5, 0xfd70, 0x4df6, < 63 < 64 /* IID_IDirect3DIndexBuffer9 */ < 65 /* {7C9DD65E-D3F7-4529-ACEE-785830ACDE35} */ < 66 extern (C) const GUID IID_IDirect3DIndexBuffer9 = { 0x7c9dd65e, 0xd3f7, 0x4529, < 67 < 68 /* IID_IDirect3DSurface9 */ < 69 /* {0CFBAF3A-9FF6-429a-99B3-A2796AF8B89B} */ < 70 extern (C) const GUID IID_IDirect3DSurface9 = { 0xcfbaf3a, 0x9ff6, 0x429a, [0x99 < 71 < 72 /* IID_IDirect3DVolume9 */ < 73 /* {24F416E6-1F67-4aa7-B88E-D33F6F3128A1} */ < 74 extern (C) const GUID IID_IDirect3DVolume9 = { 0x24f416e6, 0x1f67, 0x4aa7, [0xb8 < 75 < 76 /* IID_IDirect3DSwapChain9 */ < 77 /* {794950F2-ADFC-458a-905E-10A10B0B503B} */ < 78 extern (C) const GUID IID_IDirect3DSwapChain9 = { 0x794950f2, 0xadfc, 0x458a, [0 < 79 < 80 /* IID_IDirect3DVertexDeclaration9 */ < 81 /* {DD13C59C-36FA-4098-A8FB-C7ED39DC8546} */ < 82 extern (C) const GUID IID_IDirect3DVertexDeclaration9 = { 0xdd13c59c, 0x36fa, 0x < 83 < 84 /* IID_IDirect3DVertexShader9 */ < 85 /* {EFC5557E-6265-4613-8A94-43857889EB36} */ < 86 extern (C) const GUID IID_IDirect3DVertexShader9 = { 0xefc5557e, 0x6265, 0x4613, < 87 < 88 /* IID_IDirect3DPixelShader9 */ < 89 /* {6D3BDBDC-5B02-4415-B852-CE5E8BCCB289} */ < 90 extern (C) const GUID IID_IDirect3DPixelShader9 = { 0x6d3bdbdc, 0x5b02, 0x4415, < 91 < 92 /* IID_IDirect3DStateBlock9 */ < 93 /* {B07C4FE5-310D-4ba8-A23C-4F0F206F218B} */ < 94 extern (C) const GUID IID_IDirect3DStateBlock9 = { 0xb07c4fe5, 0x310d, 0x4ba8, [ < 95 < 96 /* IID_IDirect3DQuery9 */ < 97 /* {d9771460-a695-4f26-bbd3-27b840b541cc} */ < 98 extern (C) const GUID IID_IDirect3DQuery9 = { 0xd9771460, 0xa695, 0x4f26, [0xbb, < 99 < 100 < 101 /* IID_HelperName */ < 102 /* {E4A36723-FDFE-4b22-B146-3C04C07F4CC8} */ < 103 extern (C) const GUID IID_HelperName = { 0xe4a36723, 0xfdfe, 0x4b22, [0xb1, 0x46 < 104 < 105 /* IID_IDirect3D9Ex */ < 106 /* {02177241-69FC-400C-8FF1-93A44DF6861D} */ < 107 extern (C) const GUID IID_IDirect3D9Ex = { 0x02177241, 0x69FC, 0x400C, [0x8F, 0x < 108 < 109 /* IID_IDirect3DDevice9Ex */ < 110 // {B18B10CE-2649-405a-870F-95F777D4313A} < 111 extern (C) const GUID IID_IDirect3DDevice9Ex = { 0xb18b10ce, 0x2649, 0x405a, [0x < 112 < 113 /* IID_IDirect3DSwapChain9Ex */ < 114 /* {91886CAF-1C3D-4d2e-A0AB-3E4C7D8D3303} */ < 115 extern (C) const GUID IID_IDirect3DSwapChain9Ex = { 0x91886caf, 0x1c3d, 0x4d2e, < 116 < 117 < 118 < 119 extern (C): < 120 /** < 121 * DLL Function for creating a Direct3D9 object. This object supports < 122 * enumeration and allows the creation of Direct3DDevice9 objects. < 123 * Pass the value of the constant D3D_SDK_VERSION to this function, so < 124 * that the run-time can validate that your application was compiled < 125 * against the right headers. < 126 */ < 127 < 128 extern (Windows) LPDIRECT3D9 Direct3DCreate9(UINT SDKVersion); < 129 < 130 /** < 131 * Stubs for graphics profiling. < 132 */ < 133 extern (Windows) int D3DPERF_BeginEvent( D3DCOLOR col, LPCWSTR wszName ); < 134 extern (Windows) int D3DPERF_EndEvent(); < 135 extern (Windows) void D3DPERF_SetMarker( D3DCOLOR col, LPCWSTR wszName ); < 136 extern (Windows) void D3DPERF_SetRegion( D3DCOLOR col, LPCWSTR wszName ); < 137 extern (Windows) BOOL D3DPERF_QueryRepeatFrame(); < 138 < 139 extern (Windows) void D3DPERF_SetOptions( DWORD dwOptions ); < 140 extern (Windows) DWORD D3DPERF_GetStatus(); < 141 < 142 < 143 interface LPDIRECT3D9 : IUnknown < 144 { < 145 HRESULT RegisterSoftwareDevice(void* pInitializeFunction); < 146 UINT GetAdapterCount(); < 147 HRESULT GetAdapterIdentifier( UINT Adapter,DWORD Flags,D3DADAPTER_IDENTIFIER < 148 UINT GetAdapterModeCount(UINT Adapter,D3DFORMAT Format); < 149 HRESULT EnumAdapterModes( UINT Adapter,D3DFORMAT Format,UINT Mode,D3DDISPLAY < 150 HRESULT GetAdapterDisplayMode( UINT Adapter,D3DDISPLAYMODE* pMode); < 151 HRESULT CheckDeviceType( UINT Adapter,D3DDEVTYPE DevType,D3DFORMAT AdapterFo < 152 HRESULT CheckDeviceFormat( UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT Adap < 153 HRESULT CheckDeviceMultiSampleType( UINT Adapter,D3DDEVTYPE DeviceType,D3DFO < 154 HRESULT CheckDepthStencilMatch( UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT < 155 HRESULT CheckDeviceFormatConversion( UINT Adapter,D3DDEVTYPE DeviceType,D3DF < 156 HRESULT GetDeviceCaps( UINT Adapter,D3DDEVTYPE DeviceType,D3DCAPS9* pCaps); < 157 HMONITOR GetAdapterMonitor(UINT Adapter); < 158 HRESULT CreateDevice( UINT Adapter,D3DDEVTYPE DeviceType,HWND hFocusWindow,D < 159 /* < 160 debug { < 161 LPCWSTR Version; < 162 } < 163 */ < 164 } < 165 alias LPDIRECT3D9 IDirect3D9; < 166 < 167 interface LPDIRECT3DDEVICE9 : IUnknown < 168 { < 169 HRESULT TestCooperativeLevel(); < 170 UINT GetAvailableTextureMem(); < 171 HRESULT EvictManagedResources(); < 172 HRESULT GetDirect3D( LPDIRECT3D9* ppD3D9); < 173 HRESULT GetDeviceCaps( D3DCAPS9* pCaps); < 174 HRESULT GetDisplayMode( UINT iSwapChain,D3DDISPLAYMODE* pMode); < 175 HRESULT GetCreationParameters( D3DDEVICE_CREATION_PARAMETERS *pParameters); < 176 HRESULT SetCursorProperties( UINT XHotSpot,UINT YHotSpot,LPDIRECT3DSURFACE9 < 177 void SetCursorPosition(int X,int Y,DWORD Flags); < 178 BOOL ShowCursor(BOOL bShow); < 179 HRESULT CreateAdditionalSwapChain( D3DPRESENT_PARAMETERS* pPresentationParam < 180 HRESULT GetSwapChain( UINT iSwapChain,LPDIRECT3DSWAPCHAIN9* pSwapChain); < 181 UINT GetNumberOfSwapChains(); < 182 HRESULT Reset( D3DPRESENT_PARAMETERS* pPresentationParameters); < 183 HRESULT Present(RECT* pSourceRect,RECT* pDestRect,HWND hDestWindowOverride, < 184 HRESULT GetBackBuffer( UINT iSwapChain,UINT iBackBuffer,D3DBACKBUFFER_TYPE T < 185 HRESULT GetRasterStatus( UINT iSwapChain,D3DRASTER_STATUS* pRasterStatus); < 186 HRESULT SetDialogBoxMode( BOOL bEnableDialogs); < 187 void SetGammaRamp(UINT iSwapChain,DWORD Flags, D3DGAMMARAMP* pRamp); < 188 void GetGammaRamp(UINT iSwapChain,D3DGAMMARAMP* pRamp); < 189 HRESULT CreateTexture( UINT Width,UINT Height,UINT Levels,DWORD Usage,D3DFOR < 190 HRESULT CreateVolumeTexture( UINT Width,UINT Height,UINT Depth,UINT Levels,D < 191 HRESULT CreateCubeTexture( UINT EdgeLength,UINT Levels,DWORD Usage,D3DFORMAT < 192 HRESULT CreateVertexBuffer( UINT Length,DWORD Usage,DWORD FVF,D3DPOOL Pool,L < 193 HRESULT CreateIndexBuffer( UINT Length,DWORD Usage,D3DFORMAT Format,D3DPOOL < 194 HRESULT CreateRenderTarget( UINT Width,UINT Height,D3DFORMAT Format,D3DMULTI < 195 HRESULT CreateDepthStencilSurface( UINT Width,UINT Height,D3DFORMAT Format,D < 196 HRESULT UpdateSurface( LPDIRECT3DSURFACE9 pSourceSurface, RECT* pSourceRect, < 197 HRESULT UpdateTexture( LPDIRECT3DBASETEXTURE9 pSourceTexture,LPDIRECT3DBASET < 198 HRESULT GetRenderTargetData( LPDIRECT3DSURFACE9 pRenderTarget,LPDIRECT3DSURF < 199 HRESULT GetFrontBufferData( UINT iSwapChain,LPDIRECT3DSURFACE9 pDestSurface) < 200 HRESULT StretchRect( LPDIRECT3DSURFACE9 pSourceSurface, RECT* pSourceRect,LP < 201 HRESULT ColorFill( LPDIRECT3DSURFACE9 pSurface, RECT* pRect,D3DCOLOR color); < 202 HRESULT CreateOffscreenPlainSurface( UINT Width,UINT Height,D3DFORMAT Format < 203 HRESULT SetRenderTarget( DWORD RenderTargetIndex,LPDIRECT3DSURFACE9 pRenderT < 204 HRESULT GetRenderTarget( DWORD RenderTargetIndex,LPDIRECT3DSURFACE9* ppRende < 205 HRESULT SetDepthStencilSurface( LPDIRECT3DSURFACE9 pNewZStencil); < 206 HRESULT GetDepthStencilSurface( LPDIRECT3DSURFACE9* ppZStencilSurface); < 207 HRESULT BeginScene(); < 208 HRESULT EndScene(); < 209 HRESULT Clear( DWORD Count, D3DRECT* pRects,DWORD Flags,D3DCOLOR Color,float < 210 HRESULT SetTransform( D3DTRANSFORMSTATETYPE State, D3DMATRIX* pMatrix); < 211 HRESULT GetTransform( D3DTRANSFORMSTATETYPE State,D3DMATRIX* pMatrix); < 212 HRESULT MultiplyTransform( D3DTRANSFORMSTATETYPE, D3DMATRIX*); < 213 HRESULT SetViewport( D3DVIEWPORT9* pViewport); < 214 HRESULT GetViewport( D3DVIEWPORT9* pViewport); < 215 HRESULT SetMaterial( D3DMATERIAL9* pMaterial); < 216 HRESULT GetMaterial( D3DMATERIAL9* pMaterial); < 217 HRESULT SetLight( DWORD Index, D3DLIGHT9*); < 218 HRESULT GetLight( DWORD Index,D3DLIGHT9*); < 219 HRESULT LightEnable( DWORD Index,BOOL Enable); < 220 HRESULT GetLightEnable( DWORD Index,BOOL* pEnable); < 221 HRESULT SetClipPlane( DWORD Index, float* pPlane); < 222 HRESULT GetClipPlane( DWORD Index,float* pPlane); < 223 HRESULT SetRenderState( D3DRENDERSTATETYPE State,DWORD Value); < 224 HRESULT GetRenderState( D3DRENDERSTATETYPE State,DWORD* pValue); < 225 HRESULT CreateStateBlock( D3DSTATEBLOCKTYPE Type,LPDIRECT3DSTATEBLOCK9* ppSB < 226 HRESULT BeginStateBlock(); < 227 HRESULT EndStateBlock( LPDIRECT3DSTATEBLOCK9* ppSB); < 228 HRESULT SetClipStatus( D3DCLIPSTATUS9* pClipStatus); < 229 HRESULT GetClipStatus( D3DCLIPSTATUS9* pClipStatus); < 230 HRESULT GetTexture( DWORD Stage,LPDIRECT3DBASETEXTURE9* ppTexture); < 231 HRESULT SetTexture( DWORD Stage,LPDIRECT3DBASETEXTURE9 pTexture); < 232 HRESULT GetTextureStageState( DWORD Stage,D3DTEXTURESTAGESTATETYPE Type,DWOR < 233 HRESULT SetTextureStageState( DWORD Stage,D3DTEXTURESTAGESTATETYPE Type,DWOR < 234 HRESULT GetSamplerState( DWORD Sampler,D3DSAMPLERSTATETYPE Type,DWORD* pValu < 235 HRESULT SetSamplerState( DWORD Sampler,D3DSAMPLERSTATETYPE Type,DWORD Value) < 236 HRESULT ValidateDevice( DWORD* pNumPasses); < 237 HRESULT SetPaletteEntries( UINT PaletteNumber, PALETTEENTRY* pEntries); < 238 HRESULT GetPaletteEntries( UINT PaletteNumber,PALETTEENTRY* pEntries); < 239 HRESULT SetCurrentTexturePalette( UINT PaletteNumber); < 240 HRESULT GetCurrentTexturePalette( UINT *PaletteNumber); < 241 HRESULT SetScissorRect( RECT* pRect); < 242 HRESULT GetScissorRect( RECT* pRect); < 243 HRESULT SetSoftwareVertexProcessing( BOOL bSoftware); < 244 BOOL GetSoftwareVertexProcessing(); < 245 HRESULT SetNPatchMode( float nSegments); < 246 float GetNPatchMode(); < 247 HRESULT DrawPrimitive( D3DPRIMITIVETYPE PrimitiveType,UINT StartVertex,UINT < 248 HRESULT DrawIndexedPrimitive( D3DPRIMITIVETYPE,INT BaseVertexIndex,UINT MinV < 249 HRESULT DrawPrimitiveUP( D3DPRIMITIVETYPE PrimitiveType,UINT PrimitiveCount, < 250 HRESULT DrawIndexedPrimitiveUP( D3DPRIMITIVETYPE PrimitiveType,UINT MinVerte < 251 HRESULT ProcessVertices( UINT SrcStartIndex,UINT DestIndex,UINT VertexCount, < 252 HRESULT CreateVertexDeclaration( D3DVERTEXELEMENT9* pVertexElements,LPDIRECT < 253 HRESULT SetVertexDeclaration(LPDIRECT3DVERTEXDECLARATION9 pDecl); < 254 HRESULT GetVertexDeclaration(LPDIRECT3DVERTEXDECLARATION9* ppDecl); < 255 HRESULT SetFVF( DWORD FVF); < 256 HRESULT GetFVF( DWORD* pFVF); < 257 HRESULT CreateVertexShader( DWORD* pFunction,LPDIRECT3DVERTEXSHADER9* ppShad < 258 HRESULT SetVertexShader( LPDIRECT3DVERTEXSHADER9 pShader); < 259 HRESULT GetVertexShader( LPDIRECT3DVERTEXSHADER9* ppShader); < 260 HRESULT SetVertexShaderConstantF( UINT StartRegister, float* pConstantData,U < 261 HRESULT GetVertexShaderConstantF( UINT StartRegister,float* pConstantData,UI < 262 HRESULT SetVertexShaderConstantI( UINT StartRegister, int* pConstantData,UIN < 263 HRESULT GetVertexShaderConstantI( UINT StartRegister,int* pConstantData,UINT < 264 HRESULT SetVertexShaderConstantB( UINT StartRegister, BOOL* pConstantData,UI < 265 HRESULT GetVertexShaderConstantB( UINT StartRegister,BOOL* pConstantData,UIN < 266 HRESULT SetStreamSource( UINT StreamNumber,LPDIRECT3DVERTEXBUFFER9 pStreamDa < 267 HRESULT GetStreamSource( UINT StreamNumber,LPDIRECT3DVERTEXBUFFER9* ppStream < 268 HRESULT SetStreamSourceFreq( UINT StreamNumber,UINT Setting); < 269 HRESULT GetStreamSourceFreq( UINT StreamNumber,UINT* pSetting); < 270 HRESULT SetIndices( LPDIRECT3DINDEXBUFFER9 pIndexData); < 271 HRESULT GetIndices( LPDIRECT3DINDEXBUFFER9* ppIndexData); < 272 HRESULT CreatePixelShader( DWORD* pFunction,LPDIRECT3DPIXELSHADER9* ppShader < 273 HRESULT SetPixelShader(LPDIRECT3DPIXELSHADER9 pShader); < 274 HRESULT GetPixelShader(LPDIRECT3DPIXELSHADER9* ppShader); < 275 HRESULT SetPixelShaderConstantF( UINT StartRegister, float* pConstantData,UI < 276 HRESULT GetPixelShaderConstantF( UINT StartRegister,float* pConstantData,UIN < 277 HRESULT SetPixelShaderConstantI( UINT StartRegister, int* pConstantData,UINT < 278 HRESULT GetPixelShaderConstantI( UINT StartRegister,int* pConstantData,UINT < 279 HRESULT SetPixelShaderConstantB( UINT StartRegister, BOOL* pConstantData,UIN < 280 HRESULT GetPixelShaderConstantB( UINT StartRegister,BOOL* pConstantData,UINT < 281 HRESULT DrawRectPatch( UINT Handle, float* pNumSegs, D3DRECTPATCH_INFO* pRec < 282 HRESULT DrawTriPatch( UINT Handle, float* pNumSegs, D3DTRIPATCH_INFO* pTriPa < 283 HRESULT DeletePatch( UINT Handle); < 284 HRESULT CreateQuery( D3DQUERYTYPE Type,LPDIRECT3DQUERY9* ppQuery); < 285 /* < 286 debug { < 287 D3DDEVICE_CREATION_PARAMETERS CreationParameters; < 288 D3DPRESENT_PARAMETERS PresentParameters; < 289 D3DDISPLAYMODE DisplayMode; < 290 D3DCAPS9 Caps; < 291 < 292 UINT AvailableTextureMem; < 293 UINT SwapChains; < 294 UINT Textures; < 295 UINT VertexBuffers; < 296 UINT IndexBuffers; < 297 UINT VertexShaders; < 298 UINT PixelShaders; < 299 < 300 D3DVIEWPORT9 Viewport; < 301 D3DMATRIX ProjectionMatrix; < 302 D3DMATRIX ViewMatrix; < 303 D3DMATRIX WorldMatrix; < 304 D3DMATRIX[8] TextureMatrices; < 305 < 306 DWORD FVF; < 307 UINT VertexSize; < 308 DWORD VertexShaderVersion; < 309 DWORD PixelShaderVersion; < 310 BOOL SoftwareVertexProcessing; < 311 < 312 D3DMATERIAL9 Material; < 313 D3DLIGHT9[16] Lights; < 314 BOOL[16] LightsEnabled; < 315 < 316 D3DGAMMARAMP GammaRamp; < 317 RECT ScissorRect; < 318 BOOL DialogBoxMode; < 319 } < 320 */ < 321 } < 322 < 323 alias LPDIRECT3DDEVICE9 IDirect3DDevice9; < 324 < 325 < 326 interface LPDIRECT3DSTATEBLOCK9 : IUnknown < 327 { < 328 HRESULT GetDevice(LPDIRECT3DDEVICE9* ppDevice); < 329 HRESULT Capture(); < 330 HRESULT Apply(); < 331 /* < 332 debug { < 333 LPCWSTR CreationCallStack; < 334 } < 335 */ < 336 } < 337 < 338 alias LPDIRECT3DSTATEBLOCK9 IDirect3DStateBlock9; < 339 < 340 interface LPDIRECT3DSWAPCHAIN9 : IUnknown < 341 { < 342 HRESULT Present( RECT* pSourceRect, RECT* pDestRect,HWND hDestWindowOverride < 343 HRESULT GetFrontBufferData( LPDIRECT3DSURFACE9 pDestSurface); < 344 HRESULT GetBackBuffer( UINT iBackBuffer,D3DBACKBUFFER_TYPE Type,LPDIRECT3DSU < 345 HRESULT GetRasterStatus( D3DRASTER_STATUS* pRasterStatus); < 346 HRESULT GetDisplayMode( D3DDISPLAYMODE* pMode); < 347 HRESULT GetDevice( LPDIRECT3DDEVICE9 * ppDevice); < 348 HRESULT GetPresentParameters( D3DPRESENT_PARAMETERS* pPresentationParameters < 349 /* < 350 debug { < 351 D3DPRESENT_PARAMETERS PresentParameters; < 352 D3DDISPLAYMODE DisplayMode; < 353 LPCWSTR CreationCallStack; < 354 } < 355 */ < 356 } < 357 < 358 alias LPDIRECT3DSWAPCHAIN9 IDirect3DSwapChain9; < 359 < 360 interface LPDIRECT3DRESOURCE9 : IUnknown < 361 { < 362 HRESULT GetDevice( LPDIRECT3DDEVICE9* ppDevice); < 363 HRESULT SetPrivateData( REFGUID refguid, void* pData,DWORD SizeOfData,DWORD < 364 HRESULT GetPrivateData( REFGUID refguid,void* pData,DWORD* pSizeOfData); < 365 HRESULT FreePrivateData( REFGUID refguid); < 366 DWORD SetPriority(DWORD PriorityNew); < 367 DWORD GetPriority(); < 368 void PreLoad(); < 369 D3DRESOURCETYPE GetType(); < 370 } < 371 < 372 alias LPDIRECT3DRESOURCE9 IDirect3DResource9; < 373 < 374 interface LPDIRECT3DVERTEXDECLARATION9 : IUnknown < 375 { < 376 HRESULT GetDevice( LPDIRECT3DDEVICE9* ppDevice); < 377 HRESULT GetDeclaration( D3DVERTEXELEMENT9* pElement,UINT* pNumElements); < 378 /* < 379 debug { < 380 LPCWSTR CreationCallStack; < 381 } < 382 */ < 383 } < 384 < 385 alias LPDIRECT3DVERTEXDECLARATION9 IDirect3DVertexDeclaration9; < 386 < 387 interface LPDIRECT3DVERTEXSHADER9 : IUnknown < 388 { < 389 HRESULT GetDevice( LPDIRECT3DDEVICE9 * ppDevice); < 390 HRESULT GetFunction( void*,UINT* pSizeOfData); < 391 /* < 392 debug { < 393 DWORD Version; < 394 LPCWSTR CreationCallStack; < 395 } < 396 */ < 397 } < 398 < 399 alias LPDIRECT3DVERTEXSHADER9 IDirect3DVertexShader9; < 400 < 401 interface LPDIRECT3DPIXELSHADER9 : IUnknown < 402 { < 403 HRESULT GetDevice( LPDIRECT3DDEVICE9 * ppDevice); < 404 HRESULT GetFunction( void*,UINT* pSizeOfData); < 405 /* < 406 debug { < 407 DWORD Version; < 408 LPCWSTR CreationCallStack; < 409 } < 410 */ < 411 } < 412 < 413 alias LPDIRECT3DPIXELSHADER9 IDirect3DPixelShader9; < 414 < 415 interface LPDIRECT3DBASETEXTURE9 : LPDIRECT3DRESOURCE9 < 416 { < 417 DWORD SetLOD(DWORD LODNew); < 418 DWORD GetLOD(); < 419 DWORD GetLevelCount(); < 420 HRESULT SetAutoGenFilterType( D3DTEXTUREFILTERTYPE FilterType); < 421 D3DTEXTUREFILTERTYPE GetAutoGenFilterType(); < 422 void GenerateMipSubLevels(); < 423 } < 424 < 425 alias LPDIRECT3DBASETEXTURE9 IDirect3DBaseTexture9; < 426 < 427 interface LPDIRECT3DTEXTURE9 : LPDIRECT3DBASETEXTURE9 < 428 { < 429 HRESULT GetLevelDesc( UINT Level,D3DSURFACE_DESC *pDesc); < 430 HRESULT GetSurfaceLevel( UINT Level,LPDIRECT3DSURFACE9* ppSurfaceLevel); < 431 HRESULT LockRect( UINT Level,D3DLOCKED_RECT* pLockedRect,RECT* pRect,DWORD F < 432 HRESULT UnlockRect( UINT Level); < 433 HRESULT AddDirtyRect(RECT* pDirtyRect); < 434 /* < 435 debug { < 436 LPCWSTR Name; < 437 UINT Width; < 438 UINT Height; < 439 UINT Levels; < 440 DWORD Usage; < 441 D3DFORMAT Format; < 442 D3DPOOL Pool; < 443 DWORD Priority; < 444 DWORD LOD; < 445 D3DTEXTUREFILTERTYPE FilterType; < 446 UINT LockCount; < 447 LPCWSTR CreationCallStack; < 448 } < 449 */ < 450 } < 451 < 452 alias LPDIRECT3DTEXTURE9 IDirect3DTexture9; < 453 < 454 interface LPDIRECT3DVOLUMETEXTURE9 : LPDIRECT3DBASETEXTURE9 < 455 { < 456 HRESULT GetLevelDesc( UINT Level,D3DVOLUME_DESC *pDesc); < 457 HRESULT GetVolumeLevel( UINT Level,LPDIRECT3DVOLUME9* ppVolumeLevel); < 458 HRESULT LockBox( UINT Level,D3DLOCKED_BOX* pLockedVolume, D3DBOX* pBox,DWORD < 459 HRESULT UnlockBox( UINT Level); < 460 HRESULT AddDirtyBox( D3DBOX* pDirtyBox); < 461 /* < 462 debug { < 463 LPCWSTR Name; < 464 UINT Width; < 465 UINT Height; < 466 UINT Depth; < 467 UINT Levels; < 468 DWORD Usage; < 469 D3DFORMAT Format; < 470 D3DPOOL Pool; < 471 DWORD Priority; < 472 DWORD LOD; < 473 D3DTEXTUREFILTERTYPE FilterType; < 474 UINT LockCount; < 475 LPCWSTR CreationCallStack; < 476 } < 477 */ < 478 } < 479 < 480 alias LPDIRECT3DVOLUMETEXTURE9 IDirect3DVolumeTexture9; < 481 < 482 interface LPDIRECT3DCUBETEXTURE9 : LPDIRECT3DBASETEXTURE9 < 483 { < 484 HRESULT GetLevelDesc( UINT Level,D3DSURFACE_DESC *pDesc); < 485 HRESULT GetCubeMapSurface( D3DCUBEMAP_FACES FaceType,UINT Level,LPDIRECT3DSU < 486 HRESULT LockRect( D3DCUBEMAP_FACES FaceType,UINT Level,D3DLOCKED_RECT* pLock < 487 HRESULT UnlockRect( D3DCUBEMAP_FACES FaceType,UINT Level); < 488 HRESULT AddDirtyRect( D3DCUBEMAP_FACES FaceType, RECT* pDirtyRect); < 489 /* < 490 debug { < 491 LPCWSTR Name; < 492 UINT Width; < 493 UINT Height; < 494 UINT Levels; < 495 DWORD Usage; < 496 D3DFORMAT Format; < 497 D3DPOOL Pool; < 498 DWORD Priority; < 499 DWORD LOD; < 500 D3DTEXTUREFILTERTYPE FilterType; < 501 UINT LockCount; < 502 LPCWSTR CreationCallStack; < 503 } < 504 */ < 505 } < 506 < 507 alias LPDIRECT3DCUBETEXTURE9 IDirect3DCubeTexture9; < 508 < 509 interface LPDIRECT3DVERTEXBUFFER9 : LPDIRECT3DRESOURCE9 < 510 { < 511 HRESULT Lock( UINT OffsetToLock,UINT SizeToLock,void** ppbData,DWORD Flags); < 512 HRESULT Unlock(); < 513 HRESULT GetDesc( D3DVERTEXBUFFER_DESC *pDesc); < 514 /* < 515 debug { < 516 LPCWSTR Name; < 517 UINT Length; < 518 DWORD Usage; < 519 DWORD FVF; < 520 D3DPOOL Pool; < 521 DWORD Priority; < 522 UINT LockCount; < 523 LPCWSTR CreationCallStack; < 524 } < 525 */ < 526 } < 527 < 528 alias LPDIRECT3DVERTEXBUFFER9 IDirect3DVertexBuffer9; < 529 < 530 interface LPDIRECT3DINDEXBUFFER9 : LPDIRECT3DRESOURCE9 < 531 { < 532 HRESULT Lock( UINT OffsetToLock,UINT SizeToLock,void** ppbData,DWORD Flags); < 533 HRESULT Unlock(); < 534 HRESULT GetDesc( D3DINDEXBUFFER_DESC *pDesc); < 535 /* < 536 debug { < 537 LPCWSTR Name; < 538 UINT Length; < 539 DWORD Usage; < 540 D3DFORMAT Format; < 541 D3DPOOL Pool; < 542 DWORD Priority; < 543 UINT LockCount; < 544 LPCWSTR CreationCallStack; < 545 } < 546 */ < 547 } < 548 < 549 alias LPDIRECT3DINDEXBUFFER9 IDirect3DIndexBuffer9; < 550 < 551 interface LPDIRECT3DSURFACE9 : LPDIRECT3DRESOURCE9 < 552 { < 553 HRESULT GetContainer( REFIID riid,void** ppContainer); < 554 HRESULT GetDesc( D3DSURFACE_DESC *pDesc); < 555 HRESULT LockRect( D3DLOCKED_RECT* pLockedRect, RECT* pRect,DWORD Flags); < 556 HRESULT UnlockRect(); < 557 HRESULT GetDC( HDC *phdc); < 558 HRESULT ReleaseDC( HDC hdc); < 559 /* < 560 debug { < 561 LPCWSTR Name; < 562 UINT Width; < 563 UINT Height; < 564 DWORD Usage; < 565 D3DFORMAT Format; < 566 D3DPOOL Pool; < 567 D3DMULTISAMPLE_TYPE MultiSampleType; < 568 DWORD MultiSampleQuality; < 569 DWORD Priority; < 570 UINT LockCount; < 571 UINT DCCount; < 572 LPCWSTR CreationCallStack; < 573 } < 574 */ < 575 } < 576 < 577 alias LPDIRECT3DSURFACE9 IDirect3DSurface9; < 578 < 579 interface LPDIRECT3DVOLUME9 : IUnknown < 580 { < 581 HRESULT GetDevice( LPDIRECT3DDEVICE9 * ppDevice); < 582 HRESULT SetPrivateData( REFGUID refguid, void* pData,DWORD SizeOfData,DWORD < 583 HRESULT GetPrivateData( REFGUID refguid,void* pData,DWORD* pSizeOfData); < 584 HRESULT FreePrivateData( REFGUID refguid); < 585 HRESULT GetContainer( REFIID riid,void** ppContainer); < 586 HRESULT GetDesc( D3DVOLUME_DESC *pDesc); < 587 HRESULT LockBox( D3DLOCKED_BOX * pLockedVolume, D3DBOX* pBox,DWORD Flags); < 588 HRESULT UnlockBox(); < 589 /* < 590 debug { < 591 LPCWSTR Name; < 592 UINT Width; < 593 UINT Height; < 594 UINT Depth; < 595 DWORD Usage; < 596 D3DFORMAT Format; < 597 D3DPOOL Pool; < 598 UINT LockCount; < 599 LPCWSTR CreationCallStack; < 600 } < 601 */ < 602 } < 603 < 604 alias LPDIRECT3DVOLUME9 IDirect3DVolume9; < 605 < 606 interface LPDIRECT3DQUERY9 : IUnknown < 607 { < 608 HRESULT GetDevice( LPDIRECT3DDEVICE9* ppDevice); < 609 D3DQUERYTYPE GetType(); < 610 DWORD GetDataSize(); < 611 HRESULT Issue( DWORD dwIssueFlags); < 612 HRESULT GetData( void* pData,DWORD dwSize,DWORD dwGetDataFlags); < 613 /* < 614 debug { < 615 D3DQUERYTYPE Type; < 616 DWORD DataSize; < 617 LPCWSTR CreationCallStack; < 618 } < 619 */ < 620 } < 621 < 622 alias LPDIRECT3DQUERY9 IDirect3DQuery9; < 623 < 624 /**************************************************************************** < 625 * Flags for SetPrivateData method on all D3D9 interfaces < 626 * < 627 * The passed pointer is an IUnknown ptr. The SizeOfData argument to SetPrivateD < 628 * must be set to sizeof(IUnknown*). Direct3D will call AddRef through this < 629 * pointer and Release when the private data is destroyed. The data will be < 630 * destroyed when another SetPrivateData with the same GUID is set, when < 631 * FreePrivateData is called, or when the D3D9 object is freed. < 632 ****************************************************************************/ < 633 const D3DSPD_IUNKNOWN = 0x00000001L; < 634 < 635 /**************************************************************************** < 636 * < 637 * Flags for IDirect3D9::CreateDevice's BehaviorFlags < 638 * < 639 ****************************************************************************/ < 640 < 641 const D3DCREATE_FPU_PRESERVE = 0x00000002L; < 642 const D3DCREATE_MULTITHREADED = 0x00000004L; < 643 < 644 const D3DCREATE_PUREDEVICE = 0x00000010L; < 645 const D3DCREATE_SOFTWARE_VERTEXPROCESSING = 0x00000020L; < 646 const D3DCREATE_HARDWARE_VERTEXPROCESSING = 0x00000040L; < 647 const D3DCREATE_MIXED_VERTEXPROCESSING = 0x00000080L; < 648 < 649 const D3DCREATE_DISABLE_DRIVER_MANAGEMENT = 0x00000100L; < 650 const D3DCREATE_ADAPTERGROUP_DEVICE = 0x00000200L; < 651 const D3DCREATE_DISABLE_DRIVER_MANAGEMENT_EX = 0x00000400L; < 652 < 653 // This flag causes the D3D runtime not to alter the focus < 654 // window in any way. Use with caution- the burden of supporting < 655 // focus management events (alt-tab, etc.) falls on the < 656 // application, and appropriate responses (switching display < 657 // mode, etc.) should be coded. < 658 const D3DCREATE_NOWINDOWCHANGES = 0x00000800L; < 659 < 660 // Disable multithreading for software vertex processing < 661 const D3DCREATE_DISABLE_PSGP_THREADING = 0x00002000L; < 662 // This flag enables present statistics on device. < 663 const D3DCREATE_ENABLE_PRESENTSTATS = 0x00004000L; < 664 // This flag disables printscreen support in the runtime for this device < 665 const D3DCREATE_DISABLE_PRINTSCREEN = 0x00008000L; < 666 < 667 const D3DCREATE_SCREENSAVER = 0x10000000L; < 668 < 669 < 670 /**************************************************************************** < 671 * < 672 * Parameter for IDirect3D9::CreateDevice's Adapter argument < 673 * < 674 ****************************************************************************/ < 675 < 676 const D3DADAPTER_DEFAULT = 0; < 677 < 678 /**************************************************************************** < 679 * < 680 * Flags for IDirect3D9::EnumAdapters < 681 * < 682 ****************************************************************************/ < 683 < 684 /* < 685 * The D3DENUM_WHQL_LEVEL value has been retired for 9Ex and future versions, < 686 * but it needs to be defined here for compatibility with DX9 and earlier versio < 687 * See the DirectX SDK for sample code on discovering driver signatures. < 688 */ < 689 const D3DENUM_WHQL_LEVEL = 0x00000002L; < 690 < 691 /* NO_DRIVERVERSION will not fill out the DriverVersion field, nor will the < 692 DriverVersion be incorporated into the DeviceIdentifier GUID. WINNT only */ < 693 const D3DENUM_NO_DRIVERVERSION = 0x00000004L; < 694 < 695 < 696 /**************************************************************************** < 697 * < 698 * Maximum number of back-buffers supported in DX9 < 699 * < 700 ****************************************************************************/ < 701 < 702 const D3DPRESENT_BACK_BUFFERS_MAX = 3L; < 703 < 704 /**************************************************************************** < 705 * < 706 * Maximum number of back-buffers supported when apps use CreateDeviceEx < 707 * < 708 ****************************************************************************/ < 709 const D3DPRESENT_BACK_BUFFERS_MAX_EX = 30L; < 710 < 711 /**************************************************************************** < 712 * < 713 * Flags for IDirect3DDevice9::SetGammaRamp < 714 * < 715 ****************************************************************************/ < 716 < 717 const D3DSGR_NO_CALIBRATION = 0x00000000L; < 718 const D3DSGR_CALIBRATE = 0x00000001L; < 719 < 720 /**************************************************************************** < 721 * < 722 * Flags for IDirect3DDevice9::SetCursorPosition < 723 * < 724 ****************************************************************************/ < 725 < 726 const D3DCURSOR_IMMEDIATE_UPDATE = 0x00000001L; < 727 < 728 /**************************************************************************** < 729 * < 730 * Flags for IDirect3DSwapChain9::Present < 731 * < 732 ****************************************************************************/ < 733 < 734 const D3DPRESENT_DONOTWAIT = 0x00000001L; < 735 const D3DPRESENT_LINEAR_CONTENT = 0x00000002L; < 736 const D3DPRESENT_DONOTFLIP = 0x00000004L; < 737 const D3DPRESENT_FLIPRESTART = 0x00000008L; < 738 const D3DPRESENT_VIDEO_RESTRICT_TO_MONITOR = 0x00000010L; < 739 < 740 /**************************************************************************** < 741 * < 742 * Flags for DrawPrimitive/DrawIndexedPrimitive < 743 * Also valid for Begin/BeginIndexed < 744 * Also valid for VertexBuffer::CreateVertexBuffer < 745 ****************************************************************************/ < 746 < 747 < 748 /* < 749 * DirectDraw error codes < 750 */ < 751 const _FACD3D = 0x876; < 752 HRESULT MAKE_D3DHRESULT(T)(T code) { return MAKE_HRESULT( 1, _FACD3D, code ); } < 753 HRESULT MAKE_D3DSTATUS(T)(T code) { return MAKE_HRESULT( 0, _FACD3D, code ); } < 754 < 755 /* < 756 * Direct3D Errors < 757 */ < 758 const HRESULT D3D_OK = S_OK; < 759 < 760 const HRESULT D3DERR_WRONGTEXTUREFORMAT = MAKE_D3DHRESULT(2072); < 761 const HRESULT D3DERR_UNSUPPORTEDCOLOROPERATION = MAKE_D3DHRESULT(2073); < 762 const HRESULT D3DERR_UNSUPPORTEDCOLORARG = MAKE_D3DHRESULT(2074); < 763 const HRESULT D3DERR_UNSUPPORTEDALPHAOPERATION = MAKE_D3DHRESULT(2075); < 764 const HRESULT D3DERR_UNSUPPORTEDALPHAARG = MAKE_D3DHRESULT(2076); < 765 const HRESULT D3DERR_TOOMANYOPERATIONS = MAKE_D3DHRESULT(2077); < 766 const HRESULT D3DERR_CONFLICTINGTEXTUREFILTER = MAKE_D3DHRESULT(2078); < 767 const HRESULT D3DERR_UNSUPPORTEDFACTORVALUE = MAKE_D3DHRESULT(2079); < 768 const HRESULT D3DERR_CONFLICTINGRENDERSTATE = MAKE_D3DHRESULT(2081); < 769 const HRESULT D3DERR_UNSUPPORTEDTEXTUREFILTER = MAKE_D3DHRESULT(2082); < 770 const HRESULT D3DERR_CONFLICTINGTEXTUREPALETTE = MAKE_D3DHRESULT(2086); < 771 const HRESULT D3DERR_DRIVERINTERNALERROR = MAKE_D3DHRESULT(2087); < 772 < 773 const HRESULT D3DERR_NOTFOUND = MAKE_D3DHRESULT(2150); < 774 const HRESULT D3DERR_MOREDATA = MAKE_D3DHRESULT(2151); < 775 const HRESULT D3DERR_DEVICELOST = MAKE_D3DHRESULT(2152); < 776 const HRESULT D3DERR_DEVICENOTRESET = MAKE_D3DHRESULT(2153); < 777 const HRESULT D3DERR_NOTAVAILABLE = MAKE_D3DHRESULT(2154); < 778 const HRESULT D3DERR_OUTOFVIDEOMEMORY = MAKE_D3DHRESULT(380); < 779 const HRESULT D3DERR_INVALIDDEVICE = MAKE_D3DHRESULT(2155); < 780 const HRESULT D3DERR_INVALIDCALL = MAKE_D3DHRESULT(2156); < 781 const HRESULT D3DERR_DRIVERINVALIDCALL = MAKE_D3DHRESULT(2157); < 782 const HRESULT D3DERR_WASSTILLDRAWING = MAKE_D3DHRESULT(540); < 783 const HRESULT D3DOK_NOAUTOGEN = MAKE_D3DSTATUS(2159); < 784 const HRESULT D3DERR_DEVICEREMOVED = MAKE_D3DHRESULT(2160); < 785 const HRESULT S_NOT_RESIDENT = MAKE_D3DSTATUS(2165); < 786 const HRESULT S_RESIDENT_IN_SHARED_MEMORY = MAKE_D3DSTATUS(2166); < 787 const HRESULT S_PRESENT_MODE_CHANGED = MAKE_D3DSTATUS(2167); < 788 const HRESULT S_PRESENT_OCCLUDED = MAKE_D3DSTATUS(2168); < 789 const HRESULT D3DERR_DEVICEHUNG = MAKE_D3DHRESULT(2164); < 790 < 791 < 792 /********************* < 793 /* D3D9Ex interfaces < 794 /*********************/ < 795 < 796 extern (Windows) HRESULT Direct3DCreate9Ex(UINT SDKVersion, LPDIRECT3D9EX*); < 797 < 798 interface LPDIRECT3D9EX : LPDIRECT3D9 < 799 { < 800 UINT GetAdapterModeCountEx(UINT Adapter, D3DDISPLAYMODEFILTER* pFilter ); < 801 HRESULT EnumAdapterModesEx( UINT Adapter, D3DDISPLAYMODEFILTER* pFilter,UINT < 802 HRESULT GetAdapterDisplayModeEx( UINT Adapter,D3DDISPLAYMODEEX* pMode,D3DDIS < 803 HRESULT CreateDeviceEx( UINT Adapter,D3DDEVTYPE DeviceType,HWND hFocusWindow < 804 HRESULT GetAdapterLUID( UINT Adapter,LUID * pLUID); < 805 } < 806 < 807 alias LPDIRECT3D9EX IDirect3D9Ex; < 808 < 809 interface LPDIRECT3DDEVICE9EX : LPDIRECT3DDEVICE9 < 810 { < 811 HRESULT SetConvolutionMonoKernel( UINT width,UINT height,float* rows,float* < 812 HRESULT ComposeRects( LPDIRECT3DSURFACE9 pSrc,LPDIRECT3DSURFACE9 pDst,LPDIRE < 813 HRESULT PresentEx( RECT* pSourceRect, RECT* pDestRect,HWND hDestWindowOverri < 814 HRESULT GetGPUThreadPriority( INT* pPriority); < 815 HRESULT SetGPUThreadPriority( INT Priority); < 816 HRESULT WaitForVBlank( UINT iSwapChain); < 817 HRESULT CheckResourceResidency( LPDIRECT3DRESOURCE9* pResourceArray,UINT32 N < 818 HRESULT SetMaximumFrameLatency( UINT MaxLatency); < 819 HRESULT GetMaximumFrameLatency( UINT* pMaxLatency); < 820 HRESULT CheckDeviceState( HWND hDestinationWindow); < 821 HRESULT CreateRenderTargetEx( UINT Width,UINT Height,D3DFORMAT Format,D3DMUL < 822 HRESULT CreateOffscreenPlainSurfaceEx( UINT Width,UINT Height,D3DFORMAT Form < 823 HRESULT CreateDepthStencilSurfaceEx( UINT Width,UINT Height,D3DFORMAT Format < 824 HRESULT ResetEx( D3DPRESENT_PARAMETERS* pPresentationParameters,D3DDISPLAYMO < 825 HRESULT GetDisplayModeEx( UINT iSwapChain,D3DDISPLAYMODEEX* pMode,D3DDISPLAY < 826 } < 827 < 828 alias LPDIRECT3DDEVICE9EX IDirect3DDevice9Ex; < 829 < 830 interface LPDIRECT3DSWAPCHAIN9EX : LPDIRECT3DSWAPCHAIN9 < 831 { < 832 HRESULT GetLastPresentCount( UINT* pLastPresentCount); < 833 HRESULT GetPresentStats( D3DPRESENTSTATS* pPresentationStatistics); < 834 HRESULT GetDisplayModeEx( D3DDISPLAYMODEEX* pMode,D3DDISPLAYROTATION* pRotat < 835 } < 836 < 837 alias LPDIRECT3DSWAPCHAIN9EX IDirect3DSwapChain9Ex; <
Deleted src/win32/directx/d3d9.def version [9bc07a56e4129974]
Deleted src/win32/directx/d3d9caps.d version [8267c3a32638d8fa]
1 /*==========================================================================; < 2 * < 3 * Copyright (C) Microsoft Corporation. All Rights Reserved. < 4 * < 5 * File: d3d9caps.h < 6 * Content: Direct3D capabilities include file < 7 * < 8 ***************************************************************************/ < 9 < 10 module win32.directx.d3d9caps; < 11 < 12 private import win32.windows, < 13 win32.directx.d3d9types; < 14 < 15 align(4): < 16 < 17 struct D3DVSHADERCAPS2_0 < 18 { < 19 DWORD Caps; < 20 INT DynamicFlowControlDepth; < 21 INT NumTemps; < 22 INT StaticFlowControlDepth; < 23 } < 24 < 25 const D3DVS20CAPS_PREDICATION = (1<<0); < 26 < 27 const D3DVS20_MAX_DYNAMICFLOWCONTROLDEPTH = 24; < 28 const D3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH = 0; < 29 const D3DVS20_MAX_NUMTEMPS = 32; < 30 const D3DVS20_MIN_NUMTEMPS = 12; < 31 const D3DVS20_MAX_STATICFLOWCONTROLDEPTH = 4; < 32 const D3DVS20_MIN_STATICFLOWCONTROLDEPTH = 1; < 33 < 34 struct D3DPSHADERCAPS2_0 < 35 { < 36 DWORD Caps; < 37 INT DynamicFlowControlDepth; < 38 INT NumTemps; < 39 INT StaticFlowControlDepth; < 40 INT NumInstructionSlots; < 41 } < 42 < 43 const D3DPS20CAPS_ARBITRARYSWIZZLE = (1<<0); < 44 const D3DPS20CAPS_GRADIENTINSTRUCTIONS = (1<<1); < 45 const D3DPS20CAPS_PREDICATION = (1<<2); < 46 const D3DPS20CAPS_NODEPENDENTREADLIMIT = (1<<3); < 47 const D3DPS20CAPS_NOTEXINSTRUCTIONLIMIT = (1<<4); < 48 < 49 const D3DPS20_MAX_DYNAMICFLOWCONTROLDEPTH = 24; < 50 const D3DPS20_MIN_DYNAMICFLOWCONTROLDEPTH = 0; < 51 const D3DPS20_MAX_NUMTEMPS = 32; < 52 const D3DPS20_MIN_NUMTEMPS = 12; < 53 const D3DPS20_MAX_STATICFLOWCONTROLDEPTH = 4; < 54 const D3DPS20_MIN_STATICFLOWCONTROLDEPTH = 0; < 55 const D3DPS20_MAX_NUMINSTRUCTIONSLOTS = 512; < 56 const D3DPS20_MIN_NUMINSTRUCTIONSLOTS = 96; < 57 < 58 const D3DMIN30SHADERINSTRUCTIONS = 512; < 59 const D3DMAX30SHADERINSTRUCTIONS = 32768; < 60 < 61 struct D3DCAPS9 < 62 { < 63 /* Device Info */ < 64 D3DDEVTYPE DeviceType; < 65 UINT AdapterOrdinal; < 66 < 67 /* Caps from DX7 Draw */ < 68 DWORD Caps; < 69 DWORD Caps2; < 70 DWORD Caps3; < 71 DWORD PresentationIntervals; < 72 < 73 /* Cursor Caps */ < 74 DWORD CursorCaps; < 75 < 76 /* 3D Device Caps */ < 77 DWORD DevCaps; < 78 < 79 DWORD PrimitiveMiscCaps; < 80 DWORD RasterCaps; < 81 DWORD ZCmpCaps; < 82 DWORD SrcBlendCaps; < 83 DWORD DestBlendCaps; < 84 DWORD AlphaCmpCaps; < 85 DWORD ShadeCaps; < 86 DWORD TextureCaps; < 87 DWORD TextureFilterCaps; // D3DPTFILTERCAPS for IDirect3DTexture9 < 88 DWORD CubeTextureFilterCaps; // D3DPTFILTERCAPS for IDirect3DCubeText < 89 DWORD VolumeTextureFilterCaps; // D3DPTFILTERCAPS for IDirect3DVolumeTe < 90 DWORD TextureAddressCaps; // D3DPTADDRESSCAPS for IDirect3DTexture < 91 DWORD VolumeTextureAddressCaps; // D3DPTADDRESSCAPS for IDirect3DVolumeT < 92 < 93 DWORD LineCaps; // D3DLINECAPS < 94 < 95 DWORD MaxTextureWidth, MaxTextureHeight; < 96 DWORD MaxVolumeExtent; < 97 < 98 DWORD MaxTextureRepeat; < 99 DWORD MaxTextureAspectRatio; < 100 DWORD MaxAnisotropy; < 101 float MaxVertexW; < 102 < 103 float GuardBandLeft; < 104 float GuardBandTop; < 105 float GuardBandRight; < 106 float GuardBandBottom; < 107 < 108 float ExtentsAdjust; < 109 DWORD StencilCaps; < 110 < 111 DWORD FVFCaps; < 112 DWORD TextureOpCaps; < 113 DWORD MaxTextureBlendStages; < 114 DWORD MaxSimultaneousTextures; < 115 < 116 DWORD VertexProcessingCaps; < 117 DWORD MaxActiveLights; < 118 DWORD MaxUserClipPlanes; < 119 DWORD MaxVertexBlendMatrices; < 120 DWORD MaxVertexBlendMatrixIndex; < 121 < 122 float MaxPointSize; < 123 < 124 DWORD MaxPrimitiveCount; // max number of primitives per DrawPrim < 125 DWORD MaxVertexIndex; < 126 DWORD MaxStreams; < 127 DWORD MaxStreamStride; // max stride for SetStreamSource < 128 < 129 DWORD VertexShaderVersion; < 130 DWORD MaxVertexShaderConst; // number of vertex shader constant regi < 131 < 132 DWORD PixelShaderVersion; < 133 float PixelShader1xMaxValue; // max value storable in registers of ps < 134 < 135 // Here are the DX9 specific ones < 136 DWORD DevCaps2; < 137 < 138 float MaxNpatchTessellationLevel; < 139 DWORD Reserved5; < 140 < 141 UINT MasterAdapterOrdinal; // ordinal of master adaptor for adapter < 142 UINT AdapterOrdinalInGroup; // ordinal inside the adapter group < 143 UINT NumberOfAdaptersInGroup; // number of adapters in this adapter gr < 144 DWORD DeclTypes; // Data types, supported in vertex decla < 145 DWORD NumSimultaneousRTs; // Will be at least 1 < 146 DWORD StretchRectFilterCaps; // Filter caps supported by StretchRect < 147 D3DVSHADERCAPS2_0 VS20Caps; < 148 D3DPSHADERCAPS2_0 PS20Caps; < 149 DWORD VertexTextureFilterCaps; // D3DPTFILTERCAPS for IDirect3DTexture9 < 150 DWORD MaxVShaderInstructionsExecuted; // maximum number of vertex shader i < 151 DWORD MaxPShaderInstructionsExecuted; // maximum number of pixel shader in < 152 DWORD MaxVertexShader30InstructionSlots; < 153 DWORD MaxPixelShader30InstructionSlots; < 154 } < 155 < 156 // < 157 // BIT DEFINES FOR D3DCAPS9 DWORD MEMBERS < 158 // < 159 < 160 // < 161 // Caps < 162 // < 163 const D3DCAPS_READ_SCANLINE = 0x00020000L; < 164 < 165 // < 166 // Caps2 < 167 // < 168 const D3DCAPS2_FULLSCREENGAMMA = 0x00020000L; < 169 const D3DCAPS2_CANCALIBRATEGAMMA = 0x00100000L; < 170 const D3DCAPS2_RESERVED = 0x02000000L; < 171 const D3DCAPS2_CANMANAGERESOURCE = 0x10000000L; < 172 const D3DCAPS2_DYNAMICTEXTURES = 0x20000000L; < 173 const D3DCAPS2_CANAUTOGENMIPMAP = 0x40000000L; < 174 < 175 const D3DCAPS2_CANSHARERESOURCE = 0x80000000L; < 176 < 177 // < 178 // Caps3 < 179 // < 180 const D3DCAPS3_RESERVED = 0x8000001fL; < 181 < 182 // Indicates that the device can respect the ALPHABLENDENABLE render state < 183 // when fullscreen while using the FLIP or DISCARD swap effect. < 184 // COPY and COPYVSYNC swap effects work whether or not this flag is set. < 185 const D3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARD = 0x00000020L; < 186 < 187 // Indicates that the device can perform a gamma correction from < 188 // a windowed back buffer containing linear content to the sRGB desktop. < 189 const D3DCAPS3_LINEAR_TO_SRGB_PRESENTATION = 0x00000080L; < 190 < 191 const D3DCAPS3_COPY_TO_VIDMEM = 0x00000100L; /* Device can acclerate copies from < 192 const D3DCAPS3_COPY_TO_SYSTEMMEM = 0x00000200L; /* Device can acclerate copies f < 193 < 194 < 195 // < 196 // PresentationIntervals < 197 // < 198 const D3DPRESENT_INTERVAL_DEFAULT = 0x00000000L; < 199 const D3DPRESENT_INTERVAL_ONE = 0x00000001L; < 200 const D3DPRESENT_INTERVAL_TWO = 0x00000002L; < 201 const D3DPRESENT_INTERVAL_THREE = 0x00000004L; < 202 const D3DPRESENT_INTERVAL_FOUR = 0x00000008L; < 203 const D3DPRESENT_INTERVAL_IMMEDIATE = 0x80000000L; < 204 < 205 // < 206 // CursorCaps < 207 // < 208 // Driver supports HW color cursor in at least hi-res modes(height >=400) < 209 const D3DCURSORCAPS_COLOR = 0x00000001L; < 210 // Driver supports HW cursor also in low-res modes(height < 400) < 211 const D3DCURSORCAPS_LOWRES = 0x00000002L; < 212 < 213 // < 214 // DevCaps < 215 // < 216 const D3DDEVCAPS_EXECUTESYSTEMMEMORY = 0x00000010L; /* Device can use execute bu < 217 const D3DDEVCAPS_EXECUTEVIDEOMEMORY = 0x00000020L; /* Device can use execute buf < 218 const D3DDEVCAPS_TLVERTEXSYSTEMMEMORY = 0x00000040L; /* Device can use TL buffer < 219 const D3DDEVCAPS_TLVERTEXVIDEOMEMORY = 0x00000080L; /* Device can use TL buffers < 220 const D3DDEVCAPS_TEXTURESYSTEMMEMORY = 0x00000100L; /* Device can texture from s < 221 const D3DDEVCAPS_TEXTUREVIDEOMEMORY = 0x00000200L; /* Device can texture from de < 222 const D3DDEVCAPS_DRAWPRIMTLVERTEX = 0x00000400L; /* Device can draw TLVERTEX pri < 223 const D3DDEVCAPS_CANRENDERAFTERFLIP = 0x00000800L; /* Device can render without < 224 const D3DDEVCAPS_TEXTURENONLOCALVIDMEM = 0x00001000L; /* Device can texture from < 225 const D3DDEVCAPS_DRAWPRIMITIVES2 = 0x00002000L; /* Device can support DrawPrimit < 226 const D3DDEVCAPS_SEPARATETEXTUREMEMORIES = 0x00004000L; /* Device is texturing f < 227 const D3DDEVCAPS_DRAWPRIMITIVES2EX = 0x00008000L; /* Device can support Extended < 228 const D3DDEVCAPS_HWTRANSFORMANDLIGHT = 0x00010000L; /* Device can support transf < 229 const D3DDEVCAPS_CANBLTSYSTONONLOCAL = 0x00020000L; /* Device supports a Tex Blt < 230 const D3DDEVCAPS_HWRASTERIZATION = 0x00080000L; /* Device has HW acceleration fo < 231 const D3DDEVCAPS_PUREDEVICE = 0x00100000L; /* Device supports D3DCREATE_PUREDEVI < 232 const D3DDEVCAPS_QUINTICRTPATCHES = 0x00200000L; /* Device supports quintic Bezi < 233 const D3DDEVCAPS_RTPATCHES = 0x00400000L; /* Device supports Rect and Tri patche < 234 const D3DDEVCAPS_RTPATCHHANDLEZERO = 0x00800000L; /* Indicates that RT Patches m < 235 const D3DDEVCAPS_NPATCHES = 0x01000000L; /* Device supports N-Patches */ < 236 < 237 // < 238 // PrimitiveMiscCaps < 239 // < 240 const D3DPMISCCAPS_MASKZ = 0x00000002L; < 241 const D3DPMISCCAPS_CULLNONE = 0x00000010L; < 242 const D3DPMISCCAPS_CULLCW = 0x00000020L; < 243 const D3DPMISCCAPS_CULLCCW = 0x00000040L; < 244 const D3DPMISCCAPS_COLORWRITEENABLE = 0x00000080L; < 245 const D3DPMISCCAPS_CLIPPLANESCALEDPOINTS = 0x00000100L; /* Device correctly clip < 246 const D3DPMISCCAPS_CLIPTLVERTS = 0x00000200L; /* device will clip post-transform < 247 const D3DPMISCCAPS_TSSARGTEMP = 0x00000400L; /* device supports D3DTA_TEMP for t < 248 const D3DPMISCCAPS_BLENDOP = 0x00000800L; /* device supports D3DRS_BLENDOP */ < 249 const D3DPMISCCAPS_NULLREFERENCE = 0x00001000L; /* Reference Device that doesnt < 250 const D3DPMISCCAPS_INDEPENDENTWRITEMASKS = 0x00004000L; /* Device supports indep < 251 const D3DPMISCCAPS_PERSTAGECONSTANT = 0x00008000L; /* Device supports per-stage < 252 const D3DPMISCCAPS_FOGANDSPECULARALPHA = 0x00010000L; /* Device supports separat < 253 use the specular alpha < 254 const D3DPMISCCAPS_SEPARATEALPHABLEND = 0x00020000L; /* Device supports separate < 255 const D3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS = 0x00040000L; /* Device supports dif < 256 const D3DPMISCCAPS_MRTPOSTPIXELSHADERBLENDING = 0x00080000L; /* Device supports < 257 const D3DPMISCCAPS_FOGVERTEXCLAMPED = 0x00100000L; /* Device clamps fog blend fa < 258 < 259 const D3DPMISCCAPS_POSTBLENDSRGBCONVERT = 0x00200000L; /* Indicates device can p < 260 < 261 // < 262 // LineCaps < 263 // < 264 const D3DLINECAPS_TEXTURE = 0x00000001L; < 265 const D3DLINECAPS_ZTEST = 0x00000002L; < 266 const D3DLINECAPS_BLEND = 0x00000004L; < 267 const D3DLINECAPS_ALPHACMP = 0x00000008L; < 268 const D3DLINECAPS_FOG = 0x00000010L; < 269 const D3DLINECAPS_ANTIALIAS = 0x00000020L; < 270 < 271 // < 272 // RasterCaps < 273 // < 274 const D3DPRASTERCAPS_DITHER = 0x00000001L; < 275 const D3DPRASTERCAPS_ZTEST = 0x00000010L; < 276 const D3DPRASTERCAPS_FOGVERTEX = 0x00000080L; < 277 const D3DPRASTERCAPS_FOGTABLE = 0x00000100L; < 278 const D3DPRASTERCAPS_MIPMAPLODBIAS = 0x00002000L; < 279 const D3DPRASTERCAPS_ZBUFFERLESSHSR = 0x00008000L; < 280 const D3DPRASTERCAPS_FOGRANGE = 0x00010000L; < 281 const D3DPRASTERCAPS_ANISOTROPY = 0x00020000L; < 282 const D3DPRASTERCAPS_WBUFFER = 0x00040000L; < 283 const D3DPRASTERCAPS_WFOG = 0x00100000L; < 284 const D3DPRASTERCAPS_ZFOG = 0x00200000L; < 285 const D3DPRASTERCAPS_COLORPERSPECTIVE = 0x00400000L; /* Device iterates colors p < 286 const D3DPRASTERCAPS_SCISSORTEST = 0x01000000L; < 287 const D3DPRASTERCAPS_SLOPESCALEDEPTHBIAS = 0x02000000L; < 288 const D3DPRASTERCAPS_DEPTHBIAS = 0x04000000L; < 289 const D3DPRASTERCAPS_MULTISAMPLE_TOGGLE = 0x08000000L; < 290 < 291 // < 292 // ZCmpCaps, AlphaCmpCaps < 293 // < 294 const D3DPCMPCAPS_NEVER = 0x00000001L; < 295 const D3DPCMPCAPS_LESS = 0x00000002L; < 296 const D3DPCMPCAPS_EQUAL = 0x00000004L; < 297 const D3DPCMPCAPS_LESSEQUAL = 0x00000008L; < 298 const D3DPCMPCAPS_GREATER = 0x00000010L; < 299 const D3DPCMPCAPS_NOTEQUAL = 0x00000020L; < 300 const D3DPCMPCAPS_GREATEREQUAL = 0x00000040L; < 301 const D3DPCMPCAPS_ALWAYS = 0x00000080L; < 302 < 303 // < 304 // SourceBlendCaps, DestBlendCaps < 305 // < 306 const D3DPBLENDCAPS_ZERO = 0x00000001L; < 307 const D3DPBLENDCAPS_ONE = 0x00000002L; < 308 const D3DPBLENDCAPS_SRCCOLOR = 0x00000004L; < 309 const D3DPBLENDCAPS_INVSRCCOLOR = 0x00000008L; < 310 const D3DPBLENDCAPS_SRCALPHA = 0x00000010L; < 311 const D3DPBLENDCAPS_INVSRCALPHA = 0x00000020L; < 312 const D3DPBLENDCAPS_DESTALPHA = 0x00000040L; < 313 const D3DPBLENDCAPS_INVDESTALPHA = 0x00000080L; < 314 const D3DPBLENDCAPS_DESTCOLOR = 0x00000100L; < 315 const D3DPBLENDCAPS_INVDESTCOLOR = 0x00000200L; < 316 const D3DPBLENDCAPS_SRCALPHASAT = 0x00000400L; < 317 const D3DPBLENDCAPS_BOTHSRCALPHA = 0x00000800L; < 318 const D3DPBLENDCAPS_BOTHINVSRCALPHA = 0x00001000L; < 319 const D3DPBLENDCAPS_BLENDFACTOR = 0x00002000L; /* Supports both D3DBLEND_BLENDFA < 320 < 321 const D3DPBLENDCAPS_SRCCOLOR2 = 0x00004000L; < 322 const D3DPBLENDCAPS_INVSRCCOLOR2 = 0x00008000L; < 323 < 324 // < 325 // ShadeCaps < 326 // < 327 const D3DPSHADECAPS_COLORGOURAUDRGB = 0x00000008L; < 328 const D3DPSHADECAPS_SPECULARGOURAUDRGB = 0x00000200L; < 329 const D3DPSHADECAPS_ALPHAGOURAUDBLEND = 0x00004000L; < 330 const D3DPSHADECAPS_FOGGOURAUD = 0x00080000L; < 331 < 332 // < 333 // TextureCaps < 334 // < 335 const D3DPTEXTURECAPS_PERSPECTIVE = 0x00000001L; /* Perspective-correct texturin < 336 const D3DPTEXTURECAPS_POW2 = 0x00000002L; /* Power-of-2 texture dimensions are r < 337 const D3DPTEXTURECAPS_ALPHA = 0x00000004L; /* Alpha in texture pixels is support < 338 const D3DPTEXTURECAPS_SQUAREONLY = 0x00000020L; /* Only square textures are supp < 339 const D3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZE = 0x00000040L; /* Texture indices < 340 const D3DPTEXTURECAPS_ALPHAPALETTE = 0x00000080L; /* Device can draw alpha from < 341 // Device can use non-POW2 textures if: < 342 // 1) D3DTEXTURE_ADDRESS is set to CLAMP for this texture's stage < 343 // 2) D3DRS_WRAP(N) is zero for this texture's coordinates < 344 // 3) mip mapping is not enabled (use magnification filter only) < 345 const D3DPTEXTURECAPS_NONPOW2CONDITIONAL = 0x00000100L; < 346 const D3DPTEXTURECAPS_PROJECTED = 0x00000400L; /* Device can do D3DTTFF_PROJECTE < 347 const D3DPTEXTURECAPS_CUBEMAP = 0x00000800L; /* Device can do cubemap textures * < 348 const D3DPTEXTURECAPS_VOLUMEMAP = 0x00002000L; /* Device can do volume textures < 349 const D3DPTEXTURECAPS_MIPMAP = 0x00004000L; /* Device can do mipmapped textures < 350 const D3DPTEXTURECAPS_MIPVOLUMEMAP = 0x00008000L; /* Device can do mipmapped vol < 351 const D3DPTEXTURECAPS_MIPCUBEMAP = 0x00010000L; /* Device can do mipmapped cube < 352 const D3DPTEXTURECAPS_CUBEMAP_POW2 = 0x00020000L; /* Device requires that cubema < 353 const D3DPTEXTURECAPS_VOLUMEMAP_POW2 = 0x00040000L; /* Device requires that volu < 354 const D3DPTEXTURECAPS_NOPROJECTEDBUMPENV = 0x00200000L; /* Device does not suppo < 355 in programmable and f < 356 < 357 // < 358 // TextureFilterCaps, StretchRectFilterCaps < 359 // < 360 const D3DPTFILTERCAPS_MINFPOINT = 0x00000100L; /* Min Filter */ < 361 const D3DPTFILTERCAPS_MINFLINEAR = 0x00000200L; < 362 const D3DPTFILTERCAPS_MINFANISOTROPIC = 0x00000400L; < 363 const D3DPTFILTERCAPS_MINFPYRAMIDALQUAD = 0x00000800L; < 364 const D3DPTFILTERCAPS_MINFGAUSSIANQUAD = 0x00001000L; < 365 const D3DPTFILTERCAPS_MIPFPOINT = 0x00010000L; /* Mip Filter */ < 366 const D3DPTFILTERCAPS_MIPFLINEAR = 0x00020000L; < 367 < 368 const D3DPTFILTERCAPS_CONVOLUTIONMONO = 0x00040000L; /* Min and Mag for the conv < 369 < 370 const D3DPTFILTERCAPS_MAGFPOINT = 0x01000000L; /* Mag Filter */ < 371 const D3DPTFILTERCAPS_MAGFLINEAR = 0x02000000L; < 372 const D3DPTFILTERCAPS_MAGFANISOTROPIC = 0x04000000L; < 373 const D3DPTFILTERCAPS_MAGFPYRAMIDALQUAD = 0x08000000L; < 374 const D3DPTFILTERCAPS_MAGFGAUSSIANQUAD = 0x10000000L; < 375 < 376 // < 377 // TextureAddressCaps < 378 // < 379 const D3DPTADDRESSCAPS_WRAP = 0x00000001L; < 380 const D3DPTADDRESSCAPS_MIRROR = 0x00000002L; < 381 const D3DPTADDRESSCAPS_CLAMP = 0x00000004L; < 382 const D3DPTADDRESSCAPS_BORDER = 0x00000008L; < 383 const D3DPTADDRESSCAPS_INDEPENDENTUV = 0x00000010L; < 384 const D3DPTADDRESSCAPS_MIRRORONCE = 0x00000020L; < 385 < 386 // < 387 // StencilCaps < 388 // < 389 const D3DSTENCILCAPS_KEEP = 0x00000001L; < 390 const D3DSTENCILCAPS_ZERO = 0x00000002L; < 391 const D3DSTENCILCAPS_REPLACE = 0x00000004L; < 392 const D3DSTENCILCAPS_INCRSAT = 0x00000008L; < 393 const D3DSTENCILCAPS_DECRSAT = 0x00000010L; < 394 const D3DSTENCILCAPS_INVERT = 0x00000020L; < 395 const D3DSTENCILCAPS_INCR = 0x00000040L; < 396 const D3DSTENCILCAPS_DECR = 0x00000080L; < 397 const D3DSTENCILCAPS_TWOSIDED = 0x00000100L; < 398 < 399 // < 400 // TextureOpCaps < 401 // < 402 const D3DTEXOPCAPS_DISABLE = 0x00000001L; < 403 const D3DTEXOPCAPS_SELECTARG1 = 0x00000002L; < 404 const D3DTEXOPCAPS_SELECTARG2 = 0x00000004L; < 405 const D3DTEXOPCAPS_MODULATE = 0x00000008L; < 406 const D3DTEXOPCAPS_MODULATE2X = 0x00000010L; < 407 const D3DTEXOPCAPS_MODULATE4X = 0x00000020L; < 408 const D3DTEXOPCAPS_ADD = 0x00000040L; < 409 const D3DTEXOPCAPS_ADDSIGNED = 0x00000080L; < 410 const D3DTEXOPCAPS_ADDSIGNED2X = 0x00000100L; < 411 const D3DTEXOPCAPS_SUBTRACT = 0x00000200L; < 412 const D3DTEXOPCAPS_ADDSMOOTH = 0x00000400L; < 413 const D3DTEXOPCAPS_BLENDDIFFUSEALPHA = 0x00000800L; < 414 const D3DTEXOPCAPS_BLENDTEXTUREALPHA = 0x00001000L; < 415 const D3DTEXOPCAPS_BLENDFACTORALPHA = 0x00002000L; < 416 const D3DTEXOPCAPS_BLENDTEXTUREALPHAPM = 0x00004000L; < 417 const D3DTEXOPCAPS_BLENDCURRENTALPHA = 0x00008000L; < 418 const D3DTEXOPCAPS_PREMODULATE = 0x00010000L; < 419 const D3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR = 0x00020000L; < 420 const D3DTEXOPCAPS_MODULATECOLOR_ADDALPHA = 0x00040000L; < 421 const D3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR = 0x00080000L; < 422 const D3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA = 0x00100000L; < 423 const D3DTEXOPCAPS_BUMPENVMAP = 0x00200000L; < 424 const D3DTEXOPCAPS_BUMPENVMAPLUMINANCE = 0x00400000L; < 425 const D3DTEXOPCAPS_DOTPRODUCT3 = 0x00800000L; < 426 const D3DTEXOPCAPS_MULTIPLYADD = 0x01000000L; < 427 const D3DTEXOPCAPS_LERP = 0x02000000L; < 428 < 429 // < 430 // FVFCaps < 431 // < 432 const D3DFVFCAPS_TEXCOORDCOUNTMASK = 0x0000ffffL; /* mask for texture coordinate < 433 const D3DFVFCAPS_DONOTSTRIPELEMENTS = 0x00080000L; /* Device prefers that vertex < 434 const D3DFVFCAPS_PSIZE = 0x00100000L; /* Device can receive point size */ < 435 < 436 // < 437 // VertexProcessingCaps < 438 // < 439 const D3DVTXPCAPS_TEXGEN = 0x00000001L; /* device can do texgen */ < 440 const D3DVTXPCAPS_MATERIALSOURCE7 = 0x00000002L; /* device can do DX7-level colo < 441 const D3DVTXPCAPS_DIRECTIONALLIGHTS = 0x00000008L; /* device can do directional < 442 const D3DVTXPCAPS_POSITIONALLIGHTS = 0x00000010L; /* device can do positional li < 443 const D3DVTXPCAPS_LOCALVIEWER = 0x00000020L; /* device can do local viewer */ < 444 const D3DVTXPCAPS_TWEENING = 0x00000040L; /* device can do vertex tweening */ < 445 const D3DVTXPCAPS_TEXGEN_SPHEREMAP = 0x00000100L; /* device supports D3DTSS_TCI_ < 446 const D3DVTXPCAPS_NO_TEXGEN_NONLOCALVIEWER = 0x00000200L; /* device does not sup < 447 viewer mode */ < 448 < 449 // < 450 // DevCaps2 < 451 // < 452 const D3DDEVCAPS2_STREAMOFFSET = 0x00000001L; /* Device supports offsets in stre < 453 const D3DDEVCAPS2_DMAPNPATCH = 0x00000002L; /* Device supports displacement maps < 454 const D3DDEVCAPS2_ADAPTIVETESSRTPATCH = 0x00000004L; /* Device supports adaptive < 455 const D3DDEVCAPS2_ADAPTIVETESSNPATCH = 0x00000008L; /* Device supports adaptive < 456 const D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES = 0x00000010L; /* Device support < 457 const D3DDEVCAPS2_PRESAMPLEDDMAPNPATCH = 0x00000020L; /* Device supports presamp < 458 const D3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET = 0x00000040L; /* Vertex el < 459 < 460 // < 461 // DeclTypes < 462 // < 463 const D3DDTCAPS_UBYTE4 = 0x00000001L; < 464 const D3DDTCAPS_UBYTE4N = 0x00000002L; < 465 const D3DDTCAPS_SHORT2N = 0x00000004L; < 466 const D3DDTCAPS_SHORT4N = 0x00000008L; < 467 const D3DDTCAPS_USHORT2N = 0x00000010L; < 468 const D3DDTCAPS_USHORT4N = 0x00000020L; < 469 const D3DDTCAPS_UDEC3 = 0x00000040L; < 470 const D3DDTCAPS_DEC3N = 0x00000080L; < 471 const D3DDTCAPS_FLOAT16_2 = 0x00000100L; < 472 const D3DDTCAPS_FLOAT16_4 = 0x00000200L; <
Deleted src/win32/directx/d3d9types.d version [2c1af0c933539827]
1 /*==========================================================================; < 2 * < 3 * Copyright (C) Microsoft Corporation. All Rights Reserved. < 4 * < 5 * File: d3d9types.h < 6 * Content: Direct3D capabilities include file < 7 * < 8 ***************************************************************************/ < 9 < 10 module win32.directx.d3d9types; < 11 < 12 private import win32.windows; < 13 < 14 // Alignment compatibility < 15 align(4): < 16 < 17 // D3DCOLOR is equivalent to D3DFMT_A8R8G8B8 < 18 alias TypeDef!(uint) D3DCOLOR; < 19 < 20 // maps unsigned 8 bits/channel to D3DCOLOR < 21 D3DCOLOR D3DCOLOR_ARGB(ubyte a,ubyte r,ubyte g,ubyte b) { return cast(D3DCOLOR)( < 22 D3DCOLOR D3DCOLOR_RGBA(ubyte r,ubyte g,ubyte b,ubyte a) { return D3DCOLOR_ARGB(a < 23 D3DCOLOR D3DCOLOR_XRGB(ubyte r,ubyte g,ubyte b) { return D3DCOLOR_ARGB(0xff,r,g, < 24 < 25 D3DCOLOR D3DCOLOR_XYUV(ubyte y, ubyte u, ubyte v) { return D3DCOLOR_ARGB(0xff,y, < 26 D3DCOLOR D3DCOLOR_AYUV( ubyte a, ubyte y, ubyte u, ubyte v) { return D3DCOLOR_AR < 27 < 28 // maps floating point channels (0.f to 1.f range) to D3DCOLOR < 29 D3DCOLOR D3DCOLOR_COLORVALUE(float r, float g, float b, float a) { return D3DCOL < 30 < 31 struct D3DVECTOR { < 32 float x; < 33 float y; < 34 float z; < 35 } < 36 < 37 struct D3DCOLORVALUE { < 38 float r; < 39 float g; < 40 float b; < 41 float a; < 42 } < 43 < 44 struct D3DRECT { < 45 LONG x1; < 46 LONG y1; < 47 LONG x2; < 48 LONG y2; < 49 } < 50 < 51 struct D3DMATRIX { < 52 union { < 53 struct { < 54 float _11, _12, _13, _14; < 55 float _21, _22, _23, _24; < 56 float _31, _32, _33, _34; < 57 float _41, _42, _43, _44; < 58 } < 59 float[4][4] m; < 60 } < 61 } < 62 < 63 struct D3DVIEWPORT9 { < 64 uint X; < 65 uint Y; /* Viewport Top left */ < 66 uint Width; < 67 uint Height; /* Viewport Dimensions */ < 68 float MinZ; /* Min/max of clip Volume */ < 69 float MaxZ; < 70 } < 71 < 72 /* < 73 * Values for clip fields. < 74 */ < 75 < 76 // Max number of user clipping planes, supported in D3D. < 77 const D3DMAXUSERCLIPPLANES = 32; < 78 < 79 // These bits could be ORed together to use with D3DRS_CLIPPLANEENABLE < 80 // < 81 const D3DCLIPPLANE0 = (1<<0); < 82 const D3DCLIPPLANE1 = (1<<1); < 83 const D3DCLIPPLANE2 = (1<<2); < 84 const D3DCLIPPLANE3 = (1<<3); < 85 const D3DCLIPPLANE4 = (1<<4); < 86 const D3DCLIPPLANE5 = (1<<5); < 87 < 88 // The following bits are used in the ClipUnion and ClipIntersection < 89 // members of the D3DCLIPSTATUS9 < 90 // < 91 < 92 const D3DCS_LEFT = 0x00000001L; < 93 const D3DCS_RIGHT = 0x00000002L; < 94 const D3DCS_TOP = 0x00000004L; < 95 const D3DCS_BOTTOM = 0x00000008L; < 96 const D3DCS_FRONT = 0x00000010L; < 97 const D3DCS_BACK = 0x00000020L; < 98 const D3DCS_PLANE0 = 0x00000040L; < 99 const D3DCS_PLANE1 = 0x00000080L; < 100 const D3DCS_PLANE2 = 0x00000100L; < 101 const D3DCS_PLANE3 = 0x00000200L; < 102 const D3DCS_PLANE4 = 0x00000400L; < 103 const D3DCS_PLANE5 = 0x00000800L; < 104 < 105 const D3DCS_ALL = D3DCS_LEFT | < 106 D3DCS_RIGHT | < 107 D3DCS_TOP | < 108 D3DCS_BOTTOM | < 109 D3DCS_FRONT | < 110 D3DCS_BACK | < 111 D3DCS_PLANE0 | < 112 D3DCS_PLANE1 | < 113 D3DCS_PLANE2 | < 114 D3DCS_PLANE3 | < 115 D3DCS_PLANE4 | < 116 D3DCS_PLANE5; < 117 < 118 struct D3DCLIPSTATUS9 { < 119 uint ClipUnion; < 120 uint ClipIntersection; < 121 } < 122 < 123 struct D3DMATERIAL9 { < 124 D3DCOLORVALUE Diffuse; /* Diffuse color RGBA */ < 125 D3DCOLORVALUE Ambient; /* Ambient color RGB */ < 126 D3DCOLORVALUE Specular; /* Specular 'shininess' */ < 127 D3DCOLORVALUE Emissive; /* Emissive color RGB */ < 128 float Power; /* Sharpness if specular highlight */ < 129 } < 130 < 131 enum : uint { < 132 D3DLIGHT_POINT = 1, < 133 D3DLIGHT_SPOT = 2, < 134 D3DLIGHT_DIRECTIONAL = 3 < 135 } < 136 alias TypeDef!(uint) D3DLIGHTTYPE; < 137 < 138 struct D3DLIGHT9 { < 139 D3DLIGHTTYPE Type; /* Type of light source */ < 140 D3DCOLORVALUE Diffuse; /* Diffuse color of light */ < 141 D3DCOLORVALUE Specular; /* Specular color of light */ < 142 D3DCOLORVALUE Ambient; /* Ambient color of light */ < 143 D3DVECTOR Position; /* Position in world space */ < 144 D3DVECTOR Direction; /* Direction in world space */ < 145 float Range; /* Cutoff range */ < 146 float Falloff; /* Falloff */ < 147 float Attenuation0; /* Constant attenuation */ < 148 float Attenuation1; /* Linear attenuation */ < 149 float Attenuation2; /* Quadratic attenuation */ < 150 float Theta; /* Inner angle of spotlight cone */ < 151 float Phi; /* Outer angle of spotlight cone */ < 152 } < 153 < 154 /* < 155 * Options for clearing < 156 */ < 157 const D3DCLEAR_TARGET = 0x00000001L; /* Clear target surface */ < 158 const D3DCLEAR_ZBUFFER = 0x00000002L; /* Clear target z buffer */ < 159 const D3DCLEAR_STENCIL = 0x00000004L; /* Clear stencil planes */ < 160 < 161 /* < 162 * The following defines the rendering states < 163 */ < 164 < 165 enum : D3DSHADEMODE { < 166 D3DSHADE_FLAT = 1, < 167 D3DSHADE_GOURAUD = 2, < 168 D3DSHADE_PHONG = 3 < 169 } < 170 alias TypeDef!(uint) D3DSHADEMODE; < 171 < 172 enum : D3DFILLMODE { < 173 D3DFILL_POINT = 1, < 174 D3DFILL_WIREFRAME = 2, < 175 D3DFILL_SOLID = 3 < 176 } < 177 alias TypeDef!(uint) D3DFILLMODE; < 178 < 179 enum : D3DBLEND { < 180 D3DBLEND_ZERO = 1, < 181 D3DBLEND_ONE = 2, < 182 D3DBLEND_SRCCOLOR = 3, < 183 D3DBLEND_INVSRCCOLOR = 4, < 184 D3DBLEND_SRCALPHA = 5, < 185 D3DBLEND_INVSRCALPHA = 6, < 186 D3DBLEND_DESTALPHA = 7, < 187 D3DBLEND_INVDESTALPHA = 8, < 188 D3DBLEND_DESTCOLOR = 9, < 189 D3DBLEND_INVDESTCOLOR = 10, < 190 D3DBLEND_SRCALPHASAT = 11, < 191 D3DBLEND_BOTHSRCALPHA = 12, < 192 D3DBLEND_BOTHINVSRCALPHA = 13, < 193 D3DBLEND_BLENDFACTOR = 14, /* Only supported if D3DPBLENDCAPS_BLENDFA < 194 D3DBLEND_INVBLENDFACTOR = 15, /* Only supported if D3DPBLENDCAPS_BLENDFA < 195 D3DBLEND_SRCCOLOR2 = 16, < 196 D3DBLEND_INVSRCCOLOR2 = 17 < 197 } < 198 alias TypeDef!(uint) D3DBLEND; < 199 < 200 enum : D3DBLENDOP { < 201 D3DBLENDOP_ADD = 1, < 202 D3DBLENDOP_SUBTRACT = 2, < 203 D3DBLENDOP_REVSUBTRACT = 3, < 204 D3DBLENDOP_MIN = 4, < 205 D3DBLENDOP_MAX = 5 < 206 } < 207 alias TypeDef!(uint) D3DBLENDOP; < 208 < 209 enum : D3DTEXTUREADDRESS { < 210 D3DTADDRESS_WRAP = 1, < 211 D3DTADDRESS_MIRROR = 2, < 212 D3DTADDRESS_CLAMP = 3, < 213 D3DTADDRESS_BORDER = 4, < 214 D3DTADDRESS_MIRRORONCE = 5 < 215 } < 216 alias TypeDef!(uint) D3DTEXTUREADDRESS; < 217 < 218 enum : D3DCULL { < 219 D3DCULL_NONE = 1, < 220 D3DCULL_CW = 2, < 221 D3DCULL_CCW = 3 < 222 } < 223 alias TypeDef!(uint) D3DCULL; < 224 < 225 enum : D3DCMPFUNC { < 226 D3DCMP_NEVER = 1, < 227 D3DCMP_LESS = 2, < 228 D3DCMP_EQUAL = 3, < 229 D3DCMP_LESSEQUAL = 4, < 230 D3DCMP_GREATER = 5, < 231 D3DCMP_NOTEQUAL = 6, < 232 D3DCMP_GREATEREQUAL = 7, < 233 D3DCMP_ALWAYS = 8 < 234 } < 235 alias TypeDef!(uint) D3DCMPFUNC; < 236 < 237 enum : D3DSTENCILOP { < 238 D3DSTENCILOP_KEEP = 1, < 239 D3DSTENCILOP_ZERO = 2, < 240 D3DSTENCILOP_REPLACE = 3, < 241 D3DSTENCILOP_INCRSAT = 4, < 242 D3DSTENCILOP_DECRSAT = 5, < 243 D3DSTENCILOP_INVERT = 6, < 244 D3DSTENCILOP_INCR = 7, < 245 D3DSTENCILOP_DECR = 8 < 246 } < 247 alias TypeDef!(uint) D3DSTENCILOP; < 248 < 249 enum : D3DFOGMODE { < 250 D3DFOG_NONE = 0, < 251 D3DFOG_EXP = 1, < 252 D3DFOG_EXP2 = 2, < 253 D3DFOG_LINEAR = 3 < 254 } < 255 alias TypeDef!(uint) D3DFOGMODE; < 256 < 257 enum : D3DZBUFFERTYPE { < 258 D3DZB_FALSE = 0, < 259 D3DZB_TRUE = 1, // Z buffering < 260 D3DZB_USEW = 2 // W buffering < 261 } < 262 alias TypeDef!(uint) D3DZBUFFERTYPE; < 263 < 264 // Primitives supported by draw-primitive API < 265 enum : D3DPRIMITIVETYPE { < 266 D3DPT_POINTLIST = 1, < 267 D3DPT_LINELIST = 2, < 268 D3DPT_LINESTRIP = 3, < 269 D3DPT_TRIANGLELIST = 4, < 270 D3DPT_TRIANGLESTRIP = 5, < 271 D3DPT_TRIANGLEFAN = 6 < 272 } < 273 alias TypeDef!(uint) D3DPRIMITIVETYPE; < 274 < 275 D3DTRANSFORMSTATETYPE D3DTS_WORLDMATRIX(uint index) { return cast(D3DTRANSFORMST < 276 template T_D3DTS_WORLDMATRIX(uint index) { < 277 const D3DTRANSFORMSTATETYPE T_D3DTS_WORLDMATRIX = index + 256; < 278 } < 279 < 280 enum : D3DTRANSFORMSTATETYPE { < 281 D3DTS_VIEW = 2, < 282 D3DTS_PROJECTION = 3, < 283 D3DTS_TEXTURE0 = 16, < 284 D3DTS_TEXTURE1 = 17, < 285 D3DTS_TEXTURE2 = 18, < 286 D3DTS_TEXTURE3 = 19, < 287 D3DTS_TEXTURE4 = 20, < 288 D3DTS_TEXTURE5 = 21, < 289 D3DTS_TEXTURE6 = 22, < 290 D3DTS_TEXTURE7 = 23, < 291 D3DTS_WORLD = T_D3DTS_WORLDMATRIX!(0), < 292 D3DTS_WORLD1 = T_D3DTS_WORLDMATRIX!(1), < 293 D3DTS_WORLD2 = T_D3DTS_WORLDMATRIX!(2), < 294 D3DTS_WORLD3 = T_D3DTS_WORLDMATRIX!(3) < 295 } < 296 alias TypeDef!(uint) D3DTRANSFORMSTATETYPE; < 297 < 298 enum : D3DRENDERSTATETYPE { < 299 D3DRS_ZENABLE = 7, /* D3DZBUFFERTYPE (or TRUE/FALSE for < 300 D3DRS_FILLMODE = 8, /* D3DFILLMODE */ < 301 D3DRS_SHADEMODE = 9, /* D3DSHADEMODE */ < 302 D3DRS_ZWRITEENABLE = 14, /* TRUE to enable z writes */ < 303 D3DRS_ALPHATESTENABLE = 15, /* TRUE to enable alpha tests */ < 304 D3DRS_LASTPIXEL = 16, /* TRUE for last-pixel on lines */ < 305 D3DRS_SRCBLEND = 19, /* D3DBLEND */ < 306 D3DRS_DESTBLEND = 20, /* D3DBLEND */ < 307 D3DRS_CULLMODE = 22, /* D3DCULL */ < 308 D3DRS_ZFUNC = 23, /* D3DCMPFUNC */ < 309 D3DRS_ALPHAREF = 24, /* D3DFIXED */ < 310 D3DRS_ALPHAFUNC = 25, /* D3DCMPFUNC */ < 311 D3DRS_DITHERENABLE = 26, /* TRUE to enable dithering */ < 312 D3DRS_ALPHABLENDENABLE = 27, /* TRUE to enable alpha blending */ < 313 D3DRS_FOGENABLE = 28, /* TRUE to enable fog blending */ < 314 D3DRS_SPECULARENABLE = 29, /* TRUE to enable specular */ < 315 D3DRS_FOGCOLOR = 34, /* D3DCOLOR */ < 316 D3DRS_FOGTABLEMODE = 35, /* D3DFOGMODE */ < 317 D3DRS_FOGSTART = 36, /* Fog start (for both vertex and pi < 318 D3DRS_FOGEND = 37, /* Fog end */ < 319 D3DRS_FOGDENSITY = 38, /* Fog density */ < 320 D3DRS_RANGEFOGENABLE = 48, /* Enables range-based fog */ < 321 D3DRS_STENCILENABLE = 52, /* BOOL enable/disable stenciling */ < 322 D3DRS_STENCILFAIL = 53, /* D3DSTENCILOP to do if stencil tes < 323 D3DRS_STENCILZFAIL = 54, /* D3DSTENCILOP to do if stencil tes < 324 D3DRS_STENCILPASS = 55, /* D3DSTENCILOP to do if both stenci < 325 D3DRS_STENCILFUNC = 56, /* D3DCMPFUNC fn. Stencil Test pass < 326 D3DRS_STENCILREF = 57, /* Reference value used in stencil t < 327 D3DRS_STENCILMASK = 58, /* Mask value used in stencil test * < 328 D3DRS_STENCILWRITEMASK = 59, /* Write mask applied to values writ < 329 D3DRS_TEXTUREFACTOR = 60, /* D3DCOLOR used for multi-texture b < 330 D3DRS_WRAP0 = 128, /* wrap for 1st texture coord. set * < 331 D3DRS_WRAP1 = 129, /* wrap for 2nd texture coord. set * < 332 D3DRS_WRAP2 = 130, /* wrap for 3rd texture coord. set * < 333 D3DRS_WRAP3 = 131, /* wrap for 4th texture coord. set * < 334 D3DRS_WRAP4 = 132, /* wrap for 5th texture coord. set * < 335 D3DRS_WRAP5 = 133, /* wrap for 6th texture coord. set * < 336 D3DRS_WRAP6 = 134, /* wrap for 7th texture coord. set * < 337 D3DRS_WRAP7 = 135, /* wrap for 8th texture coord. set * < 338 D3DRS_CLIPPING = 136, < 339 D3DRS_LIGHTING = 137, < 340 D3DRS_AMBIENT = 139, < 341 D3DRS_FOGVERTEXMODE = 140, < 342 D3DRS_COLORVERTEX = 141, < 343 D3DRS_LOCALVIEWER = 142, < 344 D3DRS_NORMALIZENORMALS = 143, < 345 D3DRS_DIFFUSEMATERIALSOURCE = 145, < 346 D3DRS_SPECULARMATERIALSOURCE = 146, < 347 D3DRS_AMBIENTMATERIALSOURCE = 147, < 348 D3DRS_EMISSIVEMATERIALSOURCE = 148, < 349 D3DRS_VERTEXBLEND = 151, < 350 D3DRS_CLIPPLANEENABLE = 152, < 351 D3DRS_POINTSIZE = 154, /* float point size */ < 352 D3DRS_POINTSIZE_MIN = 155, /* float point size min threshold * < 353 D3DRS_POINTSPRITEENABLE = 156, /* BOOL point texture coord control < 354 D3DRS_POINTSCALEENABLE = 157, /* BOOL point size scale enable */ < 355 D3DRS_POINTSCALE_A = 158, /* float point attenuation A value < 356 D3DRS_POINTSCALE_B = 159, /* float point attenuation B value < 357 D3DRS_POINTSCALE_C = 160, /* float point attenuation C value < 358 D3DRS_MULTISAMPLEANTIALIAS = 161, // BOOL - set to do FSAA with multis < 359 D3DRS_MULTISAMPLEMASK = 162, // DWORD - per-sample enable/disable < 360 D3DRS_PATCHEDGESTYLE = 163, // Sets whether patch edges will use < 361 D3DRS_DEBUGMONITORTOKEN = 165, // DEBUG ONLY - token to debug monit < 362 D3DRS_POINTSIZE_MAX = 166, /* float point size max threshold * < 363 D3DRS_INDEXEDVERTEXBLENDENABLE = 167, < 364 D3DRS_COLORWRITEENABLE = 168, // per-channel write enable < 365 D3DRS_TWEENFACTOR = 170, // float tween factor < 366 D3DRS_BLENDOP = 171, // D3DBLENDOP setting < 367 D3DRS_POSITIONDEGREE = 172, // NPatch position interpolation de < 368 D3DRS_NORMALDEGREE = 173, // NPatch normal interpolation degr < 369 D3DRS_SCISSORTESTENABLE = 174, < 370 D3DRS_SLOPESCALEDEPTHBIAS = 175, < 371 D3DRS_ANTIALIASEDLINEENABLE = 176, < 372 D3DRS_MINTESSELLATIONLEVEL = 178, < 373 D3DRS_MAXTESSELLATIONLEVEL = 179, < 374 D3DRS_ADAPTIVETESS_X = 180, < 375 D3DRS_ADAPTIVETESS_Y = 181, < 376 D3DRS_ADAPTIVETESS_Z = 182, < 377 D3DRS_ADAPTIVETESS_W = 183, < 378 D3DRS_ENABLEADAPTIVETESSELLATION = 184, < 379 D3DRS_TWOSIDEDSTENCILMODE = 185, /* BOOL enable/disable 2 sided sten < 380 D3DRS_CCW_STENCILFAIL = 186, /* D3DSTENCILOP to do if ccw stenci < 381 D3DRS_CCW_STENCILZFAIL = 187, /* D3DSTENCILOP to do if ccw stenci < 382 D3DRS_CCW_STENCILPASS = 188, /* D3DSTENCILOP to do if both ccw s < 383 D3DRS_CCW_STENCILFUNC = 189, /* D3DCMPFUNC fn. ccw Stencil Test < 384 D3DRS_COLORWRITEENABLE1 = 190, /* Additional ColorWriteEnables for < 385 D3DRS_COLORWRITEENABLE2 = 191, /* Additional ColorWriteEnables for < 386 D3DRS_COLORWRITEENABLE3 = 192, /* Additional ColorWriteEnables for < 387 D3DRS_BLENDFACTOR = 193, /* D3DCOLOR used for a constant ble < 388 D3DRS_SRGBWRITEENABLE = 194, /* Enable rendertarget writes to be < 389 D3DRS_DEPTHBIAS = 195, < 390 D3DRS_WRAP8 = 198, /* Additional wrap states for vs_3_ < 391 D3DRS_WRAP9 = 199, < 392 D3DRS_WRAP10 = 200, < 393 D3DRS_WRAP11 = 201, < 394 D3DRS_WRAP12 = 202, < 395 D3DRS_WRAP13 = 203, < 396 D3DRS_WRAP14 = 204, < 397 D3DRS_WRAP15 = 205, < 398 D3DRS_SEPARATEALPHABLENDENABLE = 206, /* TRUE to enable a separate blendin < 399 D3DRS_SRCBLENDALPHA = 207, /* SRC blend factor for the alpha ch < 400 D3DRS_DESTBLENDALPHA = 208, /* DST blend factor for the alpha ch < 401 D3DRS_BLENDOPALPHA = 209 /* Blending operation for the alpha < 402 } < 403 alias TypeDef!(uint) D3DRENDERSTATETYPE; < 404 < 405 // Maximum number of simultaneous render targets D3D supports < 406 const D3D_MAX_SIMULTANEOUS_RENDERTARGETS = 4; < 407 < 408 // Values for material source < 409 enum : D3DMATERIALCOLORSOURCE { < 410 D3DMCS_MATERIAL = 0, // Color from material is used < 411 D3DMCS_COLOR1 = 1, // Diffuse vertex color is used < 412 D3DMCS_COLOR2 = 2 // Specular vertex color is used < 413 } < 414 alias TypeDef!(uint) D3DMATERIALCOLORSOURCE; < 415 < 416 // Bias to apply to the texture coordinate set to apply a wrap to. < 417 const D3DRENDERSTATE_WRAPBIAS = 128UL; < 418 < 419 /* Flags to construct the WRAP render states */ < 420 const D3DWRAP_U = 0x00000001L; < 421 const D3DWRAP_V = 0x00000002L; < 422 const D3DWRAP_W = 0x00000004L; < 423 < 424 /* Flags to construct the WRAP render states for 1D thru 4D texture coordinates < 425 const D3DWRAPCOORD_0 = 0x00000001L; // same as D3DWRAP_U < 426 const D3DWRAPCOORD_1 = 0x00000002L; // same as D3DWRAP_V < 427 const D3DWRAPCOORD_2 = 0x00000004L; // same as D3DWRAP_W < 428 const D3DWRAPCOORD_3 = 0x00000008L; < 429 < 430 /* Flags to construct D3DRS_COLORWRITEENABLE */ < 431 const D3DCOLORWRITEENABLE_RED = (1L<<0); < 432 const D3DCOLORWRITEENABLE_GREEN = (1L<<1); < 433 const D3DCOLORWRITEENABLE_BLUE = (1L<<2); < 434 const D3DCOLORWRITEENABLE_ALPHA = (1L<<3); < 435 < 436 /* < 437 * State enumerants for per-stage processing of fixed function pixel processing < 438 * Two of these affect fixed function vertex processing as well: TEXTURETRANSFOR < 439 */ < 440 enum : D3DTEXTURESTAGESTATETYPE { < 441 D3DTSS_COLOROP = 1, /* D3DTEXTUREOP - per-stage blending controls fo < 442 D3DTSS_COLORARG1 = 2, /* D3DTA_* (texture arg) */ < 443 D3DTSS_COLORARG2 = 3, /* D3DTA_* (texture arg) */ < 444 D3DTSS_ALPHAOP = 4, /* D3DTEXTUREOP - per-stage blending controls fo < 445 D3DTSS_ALPHAARG1 = 5, /* D3DTA_* (texture arg) */ < 446 D3DTSS_ALPHAARG2 = 6, /* D3DTA_* (texture arg) */ < 447 D3DTSS_BUMPENVMAT00 = 7, /* float (bump mapping matrix) */ < 448 D3DTSS_BUMPENVMAT01 = 8, /* float (bump mapping matrix) */ < 449 D3DTSS_BUMPENVMAT10 = 9, /* float (bump mapping matrix) */ < 450 D3DTSS_BUMPENVMAT11 = 10, /* float (bump mapping matrix) */ < 451 D3DTSS_TEXCOORDINDEX = 11, /* identifies which set of texture coordinates i < 452 D3DTSS_BUMPENVLSCALE = 22, /* float scale for bump map luminance */ < 453 D3DTSS_BUMPENVLOFFSET = 23, /* float offset for bump map luminance */ < 454 D3DTSS_TEXTURETRANSFORMFLAGS = 24, /* D3DTEXTURETRANSFORMFLAGS controls text < 455 D3DTSS_COLORARG0 = 26, /* D3DTA_* third arg for triadic ops */ < 456 D3DTSS_ALPHAARG0 = 27, /* D3DTA_* third arg for triadic ops */ < 457 D3DTSS_RESULTARG = 28, /* D3DTA_* arg for result (CURRENT or TEMP) */ < 458 D3DTSS_CONSTANT = 32 /* Per-stage constant D3DTA_CONSTANT */ < 459 } < 460 alias TypeDef!(uint) D3DTEXTURESTAGESTATETYPE; < 461 < 462 /* < 463 * State enumerants for per-sampler texture processing. < 464 */ < 465 enum : D3DSAMPLERSTATETYPE { < 466 D3DSAMP_ADDRESSU = 1, /* D3DTEXTUREADDRESS for U coordinate */ < 467 D3DSAMP_ADDRESSV = 2, /* D3DTEXTUREADDRESS for V coordinate */ < 468 D3DSAMP_ADDRESSW = 3, /* D3DTEXTUREADDRESS for W coordinate */ < 469 D3DSAMP_BORDERCOLOR = 4, /* D3DCOLOR */ < 470 D3DSAMP_MAGFILTER = 5, /* D3DTEXTUREFILTER filter to use for magnifica < 471 D3DSAMP_MINFILTER = 6, /* D3DTEXTUREFILTER filter to use for minificat < 472 D3DSAMP_MIPFILTER = 7, /* D3DTEXTUREFILTER filter to use between mipma < 473 D3DSAMP_MIPMAPLODBIAS = 8, /* float Mipmap LOD bias */ < 474 D3DSAMP_MAXMIPLEVEL = 9, /* DWORD 0..(n-1) LOD index of largest map to u < 475 D3DSAMP_MAXANISOTROPY = 10, /* DWORD maximum anisotropy */ < 476 D3DSAMP_SRGBTEXTURE = 11, /* Default = 0 (which means Gamma 1.0, < 477 no correction required.) else correct for < 478 Gamma = 2.2 */ < 479 D3DSAMP_ELEMENTINDEX = 12, /* When multi-element texture is assigned to sa < 480 indicates which element index to use. Defau < 481 D3DSAMP_DMAPOFFSET = 13 /* Offset in vertices in the pre-sampled displa < 482 Only valid for D3DDMAPSAMPLER sampler */ < 483 } < 484 alias TypeDef!(uint) D3DSAMPLERSTATETYPE; < 485 < 486 /* Special sampler which is used in the tesselator */ < 487 const D3DDMAPSAMPLER = 256; < 488 < 489 // Samplers used in vertex shaders < 490 const D3DVERTEXTEXTURESAMPLER0 = (D3DDMAPSAMPLER+1); < 491 const D3DVERTEXTEXTURESAMPLER1 = (D3DDMAPSAMPLER+2); < 492 const D3DVERTEXTEXTURESAMPLER2 = (D3DDMAPSAMPLER+3); < 493 const D3DVERTEXTEXTURESAMPLER3 = (D3DDMAPSAMPLER+4); < 494 < 495 // Values, used with D3DTSS_TEXCOORDINDEX, to specify that the vertex data(posit < 496 // and normal in the camera space) should be taken as texture coordinates < 497 // Low 16 bits are used to specify texture coordinate index, to take the WRAP mo < 498 // < 499 const D3DTSS_TCI_PASSTHRU = 0x00000000; < 500 const D3DTSS_TCI_CAMERASPACENORMAL = 0x00010000; < 501 const D3DTSS_TCI_CAMERASPACEPOSITION = 0x00020000; < 502 const D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR = 0x00030000; < 503 const D3DTSS_TCI_SPHEREMAP = 0x00040000; < 504 < 505 /* < 506 * Enumerations for COLOROP and ALPHAOP texture blending operations set in < 507 * texture processing stage controls in D3DTSS. < 508 */ < 509 enum : D3DTEXTUREOP { < 510 // Control < 511 D3DTOP_DISABLE = 1, // disables stage < 512 D3DTOP_SELECTARG1 = 2, // the default < 513 D3DTOP_SELECTARG2 = 3, < 514 < 515 // Modulate < 516 D3DTOP_MODULATE = 4, // multiply args together < 517 D3DTOP_MODULATE2X = 5, // multiply and 1 bit < 518 D3DTOP_MODULATE4X = 6, // multiply and 2 bits < 519 < 520 // Add < 521 D3DTOP_ADD = 7, // add arguments together < 522 D3DTOP_ADDSIGNED = 8, // add with -0.5 bias < 523 D3DTOP_ADDSIGNED2X = 9, // as above but left 1 bit < 524 D3DTOP_SUBTRACT = 10, // Arg1 - Arg2, with no saturation < 525 D3DTOP_ADDSMOOTH = 11, // add 2 args, subtract product < 526 // Arg1 + Arg2 - Arg1*Arg2 < 527 // = Arg1 + (1-Arg1)*Arg2 < 528 < 529 // Linear alpha blend: Arg1*(Alpha) + Arg2*(1-Alpha) < 530 D3DTOP_BLENDDIFFUSEALPHA = 12, // iterated alpha < 531 D3DTOP_BLENDTEXTUREALPHA = 13, // texture alpha < 532 D3DTOP_BLENDFACTORALPHA = 14, // alpha from D3DRS_TEXTUREFACTOR < 533 < 534 // Linear alpha blend with pre-multiplied arg1 input: Arg1 + Arg2*(1-Alpha) < 535 D3DTOP_BLENDTEXTUREALPHAPM = 15, // texture alpha < 536 D3DTOP_BLENDCURRENTALPHA = 16, // by alpha of current color < 537 < 538 // Specular mapping < 539 D3DTOP_PREMODULATE = 17, // modulate with next texture before < 540 D3DTOP_MODULATEALPHA_ADDCOLOR = 18, // Arg1.RGB + Arg1.A*Arg2.RGB < 541 // COLOROP only < 542 D3DTOP_MODULATECOLOR_ADDALPHA = 19, // Arg1.RGB*Arg2.RGB + Arg1.A < 543 // COLOROP only < 544 D3DTOP_MODULATEINVALPHA_ADDCOLOR = 20, // (1-Arg1.A)*Arg2.RGB + Arg1.RGB < 545 // COLOROP only < 546 D3DTOP_MODULATEINVCOLOR_ADDALPHA = 21, // (1-Arg1.RGB)*Arg2.RGB + Arg1.A < 547 // COLOROP only < 548 < 549 // Bump mapping < 550 D3DTOP_BUMPENVMAP = 22, // per pixel env map perturbation < 551 D3DTOP_BUMPENVMAPLUMINANCE = 23, // with luminance channel < 552 < 553 // This can do either diffuse or specular bump mapping with correct input. < 554 // Performs the function (Arg1.R*Arg2.R + Arg1.G*Arg2.G + Arg1.B*Arg2.B) < 555 // where each component has been scaled and offset to make it signed. < 556 // The result is replicated into all four (including alpha) channels. < 557 // This is a valid COLOROP only. < 558 D3DTOP_DOTPRODUCT3 = 24, < 559 < 560 // Triadic ops < 561 D3DTOP_MULTIPLYADD = 25, // Arg0 + Arg1*Arg2 < 562 D3DTOP_LERP = 26 // (Arg0)*Arg1 + (1-Arg0)*Arg2 < 563 } < 564 alias TypeDef!(uint) D3DTEXTUREOP; < 565 < 566 /* < 567 * Values for COLORARG0,1,2, ALPHAARG0,1,2, and RESULTARG texture blending < 568 * operations set in texture processing stage controls in D3DRENDERSTATE. < 569 */ < 570 const D3DTA_SELECTMASK = 0x0000000f; // mask for arg selector < 571 const D3DTA_DIFFUSE = 0x00000000; // select diffuse color (read only) < 572 const D3DTA_CURRENT = 0x00000001; // select stage destination register (read/wr < 573 const D3DTA_TEXTURE = 0x00000002; // select texture color (read only) < 574 const D3DTA_TFACTOR = 0x00000003; // select D3DRS_TEXTUREFACTOR (read only) < 575 const D3DTA_SPECULAR = 0x00000004; // select specular color (read only) < 576 const D3DTA_TEMP = 0x00000005; // select temporary register color (read/write) < 577 const D3DTA_CONSTANT = 0x00000006; // select texture stage constant < 578 const D3DTA_COMPLEMENT = 0x00000010; // take 1.0 - x (read modifier) < 579 const D3DTA_ALPHAREPLICATE = 0x00000020; // replicate alpha to color components < 580 < 581 // < 582 // Values for D3DSAMP_***FILTER texture stage states < 583 // < 584 enum : D3DTEXTUREFILTERTYPE { < 585 D3DTEXF_NONE = 0, // filtering disabled (valid for mip filter < 586 D3DTEXF_POINT = 1, // nearest < 587 D3DTEXF_LINEAR = 2, // linear interpolation < 588 D3DTEXF_ANISOTROPIC = 3, // anisotropic < 589 D3DTEXF_PYRAMIDALQUAD = 6, // 4-sample tent < 590 D3DTEXF_GAUSSIANQUAD = 7, // 4-sample gaussian < 591 D3DTEXF_CONVOLUTIONMONO = 8 // Convolution filter for monochrome textures < 592 } < 593 alias TypeDef!(uint) D3DTEXTUREFILTERTYPE; < 594 < 595 /* Bits for Flags in ProcessVertices call */ < 596 < 597 const D3DPV_DONOTCOPYDATA = (1 << 0); < 598 < 599 //------------------------------------------------------------------- < 600 < 601 // Flexible vertex format bits < 602 // < 603 const D3DFVF_RESERVED0 = 0x001; < 604 const D3DFVF_POSITION_MASK = 0x400E; < 605 const D3DFVF_XYZ = 0x002; < 606 const D3DFVF_XYZRHW = 0x004; < 607 const D3DFVF_XYZB1 = 0x006; < 608 const D3DFVF_XYZB2 = 0x008; < 609 const D3DFVF_XYZB3 = 0x00a; < 610 const D3DFVF_XYZB4 = 0x00c; < 611 const D3DFVF_XYZB5 = 0x00e; < 612 const D3DFVF_XYZW = 0x4002; < 613 < 614 const D3DFVF_NORMAL = 0x010; < 615 const D3DFVF_PSIZE = 0x020; < 616 const D3DFVF_DIFFUSE = 0x040; < 617 const D3DFVF_SPECULAR = 0x080; < 618 < 619 const D3DFVF_TEXCOUNT_MASK = 0xf00; < 620 const D3DFVF_TEXCOUNT_SHIFT = 8; < 621 const D3DFVF_TEX0 = 0x000; < 622 const D3DFVF_TEX1 = 0x100; < 623 const D3DFVF_TEX2 = 0x200; < 624 const D3DFVF_TEX3 = 0x300; < 625 const D3DFVF_TEX4 = 0x400; < 626 const D3DFVF_TEX5 = 0x500; < 627 const D3DFVF_TEX6 = 0x600; < 628 const D3DFVF_TEX7 = 0x700; < 629 const D3DFVF_TEX8 = 0x800; < 630 < 631 const D3DFVF_LASTBETA_UBYTE4 = 0x1000; < 632 const D3DFVF_LASTBETA_D3DCOLOR = 0x8000; < 633 < 634 const D3DFVF_RESERVED2 = 0x6000; // 2 reserved bits < 635 < 636 //--------------------------------------------------------------------- < 637 // Vertex Shaders < 638 // < 639 < 640 // Vertex shader declaration < 641 < 642 // Vertex element semantics < 643 // < 644 enum : D3DDECLUSAGE { < 645 D3DDECLUSAGE_POSITION = 0, < 646 D3DDECLUSAGE_BLENDWEIGHT, // 1 < 647 D3DDECLUSAGE_BLENDINDICES, // 2 < 648 D3DDECLUSAGE_NORMAL, // 3 < 649 D3DDECLUSAGE_PSIZE, // 4 < 650 D3DDECLUSAGE_TEXCOORD, // 5 < 651 D3DDECLUSAGE_TANGENT, // 6 < 652 D3DDECLUSAGE_BINORMAL, // 7 < 653 D3DDECLUSAGE_TESSFACTOR, // 8 < 654 D3DDECLUSAGE_POSITIONT, // 9 < 655 D3DDECLUSAGE_COLOR, // 10 < 656 D3DDECLUSAGE_FOG, // 11 < 657 D3DDECLUSAGE_DEPTH, // 12 < 658 D3DDECLUSAGE_SAMPLE // 13 < 659 } < 660 alias TypeDef!(uint) D3DDECLUSAGE; < 661 < 662 const MAXD3DDECLUSAGE = D3DDECLUSAGE_SAMPLE; < 663 const MAXD3DDECLUSAGEINDEX = 15; < 664 const MAXD3DDECLLENGTH = 64; // does not include "end" marker vertex element < 665 < 666 enum : D3DDECLMETHOD { < 667 D3DDECLMETHOD_DEFAULT = 0, < 668 D3DDECLMETHOD_PARTIALU, < 669 D3DDECLMETHOD_PARTIALV, < 670 D3DDECLMETHOD_CROSSUV, // Normal < 671 D3DDECLMETHOD_UV, < 672 D3DDECLMETHOD_LOOKUP, // Lookup a displacement map < 673 D3DDECLMETHOD_LOOKUPPRESAMPLED // Lookup a pre-sampled displacement map < 674 } < 675 alias TypeDef!(uint) D3DDECLMETHOD; < 676 < 677 const MAXD3DDECLMETHOD = D3DDECLMETHOD_LOOKUPPRESAMPLED; < 678 < 679 // Declarations for _Type fields < 680 // < 681 enum : D3DDECLTYPE { < 682 D3DDECLTYPE_FLOAT1 = 0, // 1D float expanded to (value, 0., 0., 1.) < 683 D3DDECLTYPE_FLOAT2 = 1, // 2D float expanded to (value, value, 0., 1.) < 684 D3DDECLTYPE_FLOAT3 = 2, // 3D float expanded to (value, value, value, 1 < 685 D3DDECLTYPE_FLOAT4 = 3, // 4D float < 686 D3DDECLTYPE_D3DCOLOR = 4, // 4D packed unsigned bytes mapped to 0. to 1. < 687 // Input is in D3DCOLOR format (ARGB) expanded < 688 D3DDECLTYPE_UBYTE4 = 5, // 4D unsigned byte < 689 D3DDECLTYPE_SHORT2 = 6, // 2D signed short expanded to (value, value, 0 < 690 D3DDECLTYPE_SHORT4 = 7, // 4D signed short < 691 < 692 // The following types are valid only with vertex shaders >= 2.0 < 693 < 694 < 695 D3DDECLTYPE_UBYTE4N = 8, // Each of 4 bytes is normalized by dividing to < 696 D3DDECLTYPE_SHORT2N = 9, // 2D signed short normalized (v[0]/32767.0,v[1 < 697 D3DDECLTYPE_SHORT4N = 10, // 4D signed short normalized (v[0]/32767.0,v[1 < 698 D3DDECLTYPE_USHORT2N = 11, // 2D unsigned short normalized (v[0]/65535.0,v < 699 D3DDECLTYPE_USHORT4N = 12, // 4D unsigned short normalized (v[0]/65535.0,v < 700 D3DDECLTYPE_UDEC3 = 13, // 3D unsigned 10 10 10 format expanded to (val < 701 D3DDECLTYPE_DEC3N = 14, // 3D signed 10 10 10 format normalized and exp < 702 D3DDECLTYPE_FLOAT16_2 = 15, // Two 16-bit floating point values, expanded t < 703 D3DDECLTYPE_FLOAT16_4 = 16, // Four 16-bit floating point values < 704 D3DDECLTYPE_UNUSED = 17 // When the type field in a decl is unused. < 705 } < 706 alias TypeDef!(uint) D3DDECLTYPE; < 707 < 708 const MAXD3DDECLTYPE = D3DDECLTYPE_UNUSED; < 709 < 710 struct D3DVERTEXELEMENT9 < 711 { < 712 ushort Stream; // Stream index < 713 ushort Offset; // Offset in the stream in bytes < 714 ubyte Type; // Data type < 715 ubyte Method; // Processing method < 716 ubyte Usage; // Semantics < 717 ubyte UsageIndex; // Semantic index < 718 } < 719 alias D3DVERTEXELEMENT9 *LPD3DVERTEXELEMENT9; < 720 < 721 // This is used to initialize the last vertex element in a vertex declaration < 722 // array < 723 // < 724 template D3DDECL_END() { < 725 static const D3DVERTEXELEMENT9 D3DDECL_END = { 0xFF,0,D3DDECLTYPE_UNUSED,0,0 < 726 } < 727 < 728 // Maximum supported number of texture coordinate sets < 729 const D3DDP_MAXTEXCOORD = 8; < 730 < 731 //--------------------------------------------------------------------- < 732 // Values for IDirect3DDevice9::SetStreamSourceFreq's Setting parameter < 733 //--------------------------------------------------------------------- < 734 const D3DSTREAMSOURCE_INDEXEDDATA = (1<<30); < 735 const D3DSTREAMSOURCE_INSTANCEDATA = (2<<30); < 736 < 737 < 738 < 739 //--------------------------------------------------------------------- < 740 // < 741 // The internal format of Pixel Shader (PS) & Vertex Shader (VS) < 742 // Instruction Tokens is defined in the Direct3D Device Driver Kit < 743 // < 744 //--------------------------------------------------------------------- < 745 < 746 // < 747 // Instruction Token Bit Definitions < 748 // < 749 const D3DSI_OPCODE_MASK = 0x0000FFFF; < 750 < 751 const D3DSI_INSTLENGTH_MASK = 0x0F000000; < 752 const D3DSI_INSTLENGTH_SHIFT = 24; < 753 < 754 enum : D3DSHADER_INSTRUCTION_OPCODE_TYPE { < 755 D3DSIO_NOP = 0, < 756 D3DSIO_MOV , < 757 D3DSIO_ADD , < 758 D3DSIO_SUB , < 759 D3DSIO_MAD , < 760 D3DSIO_MUL , < 761 D3DSIO_RCP , < 762 D3DSIO_RSQ , < 763 D3DSIO_DP3 , < 764 D3DSIO_DP4 , < 765 D3DSIO_MIN , < 766 D3DSIO_MAX , < 767 D3DSIO_SLT , < 768 D3DSIO_SGE , < 769 D3DSIO_EXP , < 770 D3DSIO_LOG , < 771 D3DSIO_LIT , < 772 D3DSIO_DST , < 773 D3DSIO_LRP , < 774 D3DSIO_FRC , < 775 D3DSIO_M4x4 , < 776 D3DSIO_M4x3 , < 777 D3DSIO_M3x4 , < 778 D3DSIO_M3x3 , < 779 D3DSIO_M3x2 , < 780 D3DSIO_CALL , < 781 D3DSIO_CALLNZ , < 782 D3DSIO_LOOP , < 783 D3DSIO_RET , < 784 D3DSIO_ENDLOOP , < 785 D3DSIO_LABEL , < 786 D3DSIO_DCL , < 787 D3DSIO_POW , < 788 D3DSIO_CRS , < 789 D3DSIO_SGN , < 790 D3DSIO_ABS , < 791 D3DSIO_NRM , < 792 D3DSIO_SINCOS , < 793 D3DSIO_REP , < 794 D3DSIO_ENDREP , < 795 D3DSIO_IF , < 796 D3DSIO_IFC , < 797 D3DSIO_ELSE , < 798 D3DSIO_ENDIF , < 799 D3DSIO_BREAK , < 800 D3DSIO_BREAKC , < 801 D3DSIO_MOVA , < 802 D3DSIO_DEFB , < 803 D3DSIO_DEFI , < 804 < 805 D3DSIO_TEXCOORD = 64, < 806 D3DSIO_TEXKILL , < 807 D3DSIO_TEX , < 808 D3DSIO_TEXBEM , < 809 D3DSIO_TEXBEML , < 810 D3DSIO_TEXREG2AR , < 811 D3DSIO_TEXREG2GB , < 812 D3DSIO_TEXM3x2PAD , < 813 D3DSIO_TEXM3x2TEX , < 814 D3DSIO_TEXM3x3PAD , < 815 D3DSIO_TEXM3x3TEX , < 816 D3DSIO_RESERVED0 , < 817 D3DSIO_TEXM3x3SPEC , < 818 D3DSIO_TEXM3x3VSPEC , < 819 D3DSIO_EXPP , < 820 D3DSIO_LOGP , < 821 D3DSIO_CND , < 822 D3DSIO_DEF , < 823 D3DSIO_TEXREG2RGB , < 824 D3DSIO_TEXDP3TEX , < 825 D3DSIO_TEXM3x2DEPTH , < 826 D3DSIO_TEXDP3 , < 827 D3DSIO_TEXM3x3 , < 828 D3DSIO_TEXDEPTH , < 829 D3DSIO_CMP , < 830 D3DSIO_BEM , < 831 D3DSIO_DP2ADD , < 832 D3DSIO_DSX , < 833 D3DSIO_DSY , < 834 D3DSIO_TEXLDD , < 835 D3DSIO_SETP , < 836 D3DSIO_TEXLDL , < 837 D3DSIO_BREAKP , < 838 < 839 D3DSIO_PHASE = 0xFFFD, < 840 D3DSIO_COMMENT = 0xFFFE, < 841 D3DSIO_END = 0xFFFF < 842 } < 843 alias TypeDef!(uint) D3DSHADER_INSTRUCTION_OPCODE_TYPE; < 844 < 845 //--------------------------------------------------------------------- < 846 // Use these constants with D3DSIO_SINCOS macro as SRC2, SRC3 < 847 // < 848 const float[4] D3DSINCOSCONST1 = [-1.5500992e-006f, -2.1701389e-005f, 0.0026041 < 849 const float[4] D3DSINCOSCONST2 = [-0.020833334f, -0.12500000f, 1.0f, 0.50000000f < 850 < 851 //--------------------------------------------------------------------- < 852 // Co-Issue Instruction Modifier - if set then this instruction is to be < 853 // issued in parallel with the previous instruction(s) for which this bit < 854 // is not set. < 855 // < 856 const D3DSI_COISSUE = 0x40000000; < 857 < 858 //--------------------------------------------------------------------- < 859 // Opcode specific controls < 860 < 861 const D3DSP_OPCODESPECIFICCONTROL_MASK = 0x00ff0000; < 862 const D3DSP_OPCODESPECIFICCONTROL_SHIFT = 16; < 863 < 864 // ps_2_0 texld controls < 865 const D3DSI_TEXLD_PROJECT = (0x01 << D3DSP_OPCODESPECIFICCONTROL_SHIFT); < 866 const D3DSI_TEXLD_BIAS = (0x02 << D3DSP_OPCODESPECIFICCONTROL_SHIFT); < 867 < 868 // Comparison for dynamic conditional instruction opcodes (i.e. if, breakc) < 869 enum : D3DSHADER_COMPARISON { < 870 // < = > < 871 D3DSPC_RESERVED0= 0, // 0 0 0 < 872 D3DSPC_GT = 1, // 0 0 1 < 873 D3DSPC_EQ = 2, // 0 1 0 < 874 D3DSPC_GE = 3, // 0 1 1 < 875 D3DSPC_LT = 4, // 1 0 0 < 876 D3DSPC_NE = 5, // 1 0 1 < 877 D3DSPC_LE = 6, // 1 1 0 < 878 D3DSPC_RESERVED1= 7 // 1 1 1 < 879 } < 880 alias TypeDef!(uint) D3DSHADER_COMPARISON; < 881 < 882 // Comparison is part of instruction opcode token: < 883 const D3DSHADER_COMPARISON_SHIFT = D3DSP_OPCODESPECIFICCONTROL_SHIFT; < 884 const D3DSHADER_COMPARISON_MASK = (0x7<<D3DSHADER_COMPARISON_SHIFT); < 885 < 886 //--------------------------------------------------------------------- < 887 // Predication flags on instruction token < 888 const D3DSHADER_INSTRUCTION_PREDICATED = (0x1 << 28); < 889 < 890 //--------------------------------------------------------------------- < 891 // DCL Info Token Controls < 892 < 893 // For dcl info tokens requiring a semantic (usage + index) < 894 const D3DSP_DCL_USAGE_SHIFT = 0; < 895 const D3DSP_DCL_USAGE_MASK = 0x0000000f; < 896 < 897 const D3DSP_DCL_USAGEINDEX_SHIFT = 16; < 898 const D3DSP_DCL_USAGEINDEX_MASK = 0x000f0000; < 899 < 900 // DCL pixel shader sampler info token. < 901 const D3DSP_TEXTURETYPE_SHIFT = 27; < 902 const D3DSP_TEXTURETYPE_MASK = 0x78000000; < 903 < 904 enum : D3DSAMPLER_TEXTURE_TYPE { < 905 D3DSTT_UNKNOWN = 0<<D3DSP_TEXTURETYPE_SHIFT, // uninitialized value < 906 D3DSTT_2D = 2<<D3DSP_TEXTURETYPE_SHIFT, // dcl_2d s# (for declaring a 2 < 907 D3DSTT_CUBE = 3<<D3DSP_TEXTURETYPE_SHIFT, // dcl_cube s# (for declaring a < 908 D3DSTT_VOLUME = 4<<D3DSP_TEXTURETYPE_SHIFT // dcl_volume s# (for declaring < 909 } < 910 alias TypeDef!(uint) D3DSAMPLER_TEXTURE_TYPE; < 911 < 912 //--------------------------------------------------------------------- < 913 // Parameter Token Bit Definitions < 914 // < 915 const D3DSP_REGNUM_MASK = 0x000007FF; < 916 < 917 // destination parameter write mask < 918 const D3DSP_WRITEMASK_0 = 0x00010000; // Component 0 (X;Red) < 919 const D3DSP_WRITEMASK_1 = 0x00020000; // Component 1 (Y;Green) < 920 const D3DSP_WRITEMASK_2 = 0x00040000; // Component 2 (Z;Blue) < 921 const D3DSP_WRITEMASK_3 = 0x00080000; // Component 3 (W;Alpha) < 922 const D3DSP_WRITEMASK_ALL = 0x000F0000; // All Components < 923 < 924 // destination parameter modifiers < 925 const D3DSP_DSTMOD_SHIFT = 20; < 926 const D3DSP_DSTMOD_MASK = 0x00F00000; < 927 < 928 // Bit masks for destination parameter modifiers < 929 const D3DSPDM_NONE = (0<<D3DSP_DSTMOD_SHIFT); // nop < 930 const D3DSPDM_SATURATE = (1<<D3DSP_DSTMOD_SHIFT); // clamp to 0. to 1. range < 931 const D3DSPDM_PARTIALPRECISION = (2<<D3DSP_DSTMOD_SHIFT); // Partial precision h < 932 const D3DSPDM_MSAMPCENTROID = (4<<D3DSP_DSTMOD_SHIFT); // Relevant to multisampl < 933 // When the < 934 // attribut < 935 // using mu < 936 // "Centroi < 937 // region o < 938 < 939 // destination parameter < 940 const D3DSP_DSTSHIFT_SHIFT = 24; < 941 const D3DSP_DSTSHIFT_MASK = 0x0F000000; < 942 < 943 // destination/source parameter register type < 944 const D3DSP_REGTYPE_SHIFT = 28; < 945 const D3DSP_REGTYPE_SHIFT2 = 8; < 946 const D3DSP_REGTYPE_MASK = 0x70000000; < 947 const D3DSP_REGTYPE_MASK2 = 0x00001800; < 948 < 949 enum : D3DSHADER_PARAM_REGISTER_TYPE { < 950 D3DSPR_TEMP = 0, // Temporary Register File < 951 D3DSPR_INPUT = 1, // Input Register File < 952 D3DSPR_CONST = 2, // Constant Register File < 953 D3DSPR_ADDR = 3, // Address Register (VS) < 954 D3DSPR_TEXTURE = 3, // Texture Register File (PS) < 955 D3DSPR_RASTOUT = 4, // Rasterizer Register File < 956 D3DSPR_ATTROUT = 5, // Attribute Output Register File < 957 D3DSPR_TEXCRDOUT = 6, // Texture Coordinate Output Register File < 958 D3DSPR_OUTPUT = 6, // Output register file for VS3.0+ < 959 D3DSPR_CONSTINT = 7, // Constant Integer Vector Register File < 960 D3DSPR_COLOROUT = 8, // Color Output Register File < 961 D3DSPR_DEPTHOUT = 9, // Depth Output Register File < 962 D3DSPR_SAMPLER = 10, // Sampler State Register File < 963 D3DSPR_CONST2 = 11, // Constant Register File 2048 - 4095 < 964 D3DSPR_CONST3 = 12, // Constant Register File 4096 - 6143 < 965 D3DSPR_CONST4 = 13, // Constant Register File 6144 - 8191 < 966 D3DSPR_CONSTBOOL = 14, // Constant Boolean register file < 967 D3DSPR_LOOP = 15, // Loop counter register file < 968 D3DSPR_TEMPFLOAT16 = 16, // 16-bit float temp register file < 969 D3DSPR_MISCTYPE = 17, // Miscellaneous (single) registers. < 970 D3DSPR_LABEL = 18, // Label < 971 D3DSPR_PREDICATE = 19 // Predicate register < 972 } < 973 alias TypeDef!(uint) D3DSHADER_PARAM_REGISTER_TYPE; < 974 < 975 // The miscellaneous register file (D3DSPR_MISCTYPES) < 976 // contains register types for which there is only ever one < 977 // register (i.e. the register # is not needed). < 978 // Rather than use up additional register types for such < 979 // registers, they are defined < 980 // as particular offsets into the misc. register file: < 981 enum : D3DSHADER_MISCTYPE_OFFSETS { < 982 D3DSMO_POSITION = 0, // Input position x,y,z,rhw (PS) < 983 D3DSMO_FACE = 1, // Floating point primitive area (PS) < 984 } < 985 alias TypeDef!(uint) D3DSHADER_MISCTYPE_OFFSETS; < 986 < 987 // Register offsets in the Rasterizer Register File < 988 // < 989 enum : D3DVS_RASTOUT_OFFSETS { < 990 D3DSRO_POSITION = 0, < 991 D3DSRO_FOG, < 992 D3DSRO_POINT_SIZE < 993 } < 994 alias TypeDef!(uint) D3DVS_RASTOUT_OFFSETS; < 995 < 996 // Source operand addressing modes < 997 < 998 const D3DVS_ADDRESSMODE_SHIFT = 13; < 999 const D3DVS_ADDRESSMODE_MASK = (1 << D3DVS_ADDRESSMODE_SHIFT); < 1000 < 1001 enum : D3DVS_ADDRESSMODE_TYPE { < 1002 D3DVS_ADDRMODE_ABSOLUTE = (0 << D3DVS_ADDRESSMODE_SHIFT), < 1003 D3DVS_ADDRMODE_RELATIVE = (1 << D3DVS_ADDRESSMODE_SHIFT) < 1004 } < 1005 alias TypeDef!(uint) D3DVS_ADDRESSMODE_TYPE; < 1006 < 1007 const D3DSHADER_ADDRESSMODE_SHIFT = 13; < 1008 const D3DSHADER_ADDRESSMODE_MASK = (1 << D3DSHADER_ADDRESSMODE_SHIFT); < 1009 < 1010 enum : D3DSHADER_ADDRESSMODE_TYPE { < 1011 D3DSHADER_ADDRMODE_ABSOLUTE = (0 << D3DSHADER_ADDRESSMODE_SHIFT), < 1012 D3DSHADER_ADDRMODE_RELATIVE = (1 << D3DSHADER_ADDRESSMODE_SHIFT) < 1013 } < 1014 alias TypeDef!(uint) D3DSHADER_ADDRESSMODE_TYPE; < 1015 < 1016 // Source operand swizzle definitions < 1017 // < 1018 const D3DVS_SWIZZLE_SHIFT = 16; < 1019 const D3DVS_SWIZZLE_MASK = 0x00FF0000; < 1020 < 1021 // The following bits define where to take component X from: < 1022 < 1023 const D3DVS_X_X = (0<<D3DVS_SWIZZLE_SHIFT); < 1024 const D3DVS_X_Y = (1<<D3DVS_SWIZZLE_SHIFT); < 1025 const D3DVS_X_Z = (2<<D3DVS_SWIZZLE_SHIFT); < 1026 const D3DVS_X_W = (3<<D3DVS_SWIZZLE_SHIFT); < 1027 < 1028 // The following bits define where to take component Y from: < 1029 < 1030 const D3DVS_Y_X = (0<<(D3DVS_SWIZZLE_SHIFT+2)); < 1031 const D3DVS_Y_Y = (1<<(D3DVS_SWIZZLE_SHIFT+2)); < 1032 const D3DVS_Y_Z = (2<<(D3DVS_SWIZZLE_SHIFT+2)); < 1033 const D3DVS_Y_W = (3<<(D3DVS_SWIZZLE_SHIFT+2)); < 1034 < 1035 // The following bits define where to take component Z from: < 1036 < 1037 const D3DVS_Z_X = (0<<(D3DVS_SWIZZLE_SHIFT+4)); < 1038 const D3DVS_Z_Y = (1<<(D3DVS_SWIZZLE_SHIFT+4)); < 1039 const D3DVS_Z_Z = (2<<(D3DVS_SWIZZLE_SHIFT+4)); < 1040 const D3DVS_Z_W = (3<<(D3DVS_SWIZZLE_SHIFT+4)); < 1041 < 1042 // The following bits define where to take component W from: < 1043 < 1044 const D3DVS_W_X = (0<<(D3DVS_SWIZZLE_SHIFT+6)); < 1045 const D3DVS_W_Y = (1<<(D3DVS_SWIZZLE_SHIFT+6)); < 1046 const D3DVS_W_Z = (2<<(D3DVS_SWIZZLE_SHIFT+6)); < 1047 const D3DVS_W_W = (3<<(D3DVS_SWIZZLE_SHIFT+6)); < 1048 < 1049 // Value when there is no swizzle (X is taken from X, Y is taken from Y, < 1050 // Z is taken from Z, W is taken from W < 1051 // < 1052 const D3DVS_NOSWIZZLE = (D3DVS_X_X|D3DVS_Y_Y|D3DVS_Z_Z|D3DVS_W_W); < 1053 < 1054 // source parameter swizzle < 1055 const D3DSP_SWIZZLE_SHIFT = 16; < 1056 const D3DSP_SWIZZLE_MASK = 0x00FF0000; < 1057 < 1058 const D3DSP_NOSWIZZLE = ( (0 << (D3DSP_SWIZZLE_SHIFT + 0)) | < 1059 (1 << (D3DSP_SWIZZLE_SHIFT + 2)) | < 1060 (2 << (D3DSP_SWIZZLE_SHIFT + 4)) | < 1061 (3 << (D3DSP_SWIZZLE_SHIFT + 6)) ); < 1062 < 1063 // pixel-shader swizzle ops < 1064 const D3DSP_REPLICATERED = < 1065 ( (0 << (D3DSP_SWIZZLE_SHIFT + 0)) | < 1066 (0 << (D3DSP_SWIZZLE_SHIFT + 2)) | < 1067 (0 << (D3DSP_SWIZZLE_SHIFT + 4)) | < 1068 (0 << (D3DSP_SWIZZLE_SHIFT + 6)) ); < 1069 < 1070 const D3DSP_REPLICATEGREEN = < 1071 ( (1 << (D3DSP_SWIZZLE_SHIFT + 0)) | < 1072 (1 << (D3DSP_SWIZZLE_SHIFT + 2)) | < 1073 (1 << (D3DSP_SWIZZLE_SHIFT + 4)) | < 1074 (1 << (D3DSP_SWIZZLE_SHIFT + 6)) ); < 1075 < 1076 const D3DSP_REPLICATEBLUE = < 1077 ( (2 << (D3DSP_SWIZZLE_SHIFT + 0)) | < 1078 (2 << (D3DSP_SWIZZLE_SHIFT + 2)) | < 1079 (2 << (D3DSP_SWIZZLE_SHIFT + 4)) | < 1080 (2 << (D3DSP_SWIZZLE_SHIFT + 6)) ); < 1081 < 1082 const D3DSP_REPLICATEALPHA = < 1083 ( (3 << (D3DSP_SWIZZLE_SHIFT + 0)) | < 1084 (3 << (D3DSP_SWIZZLE_SHIFT + 2)) | < 1085 (3 << (D3DSP_SWIZZLE_SHIFT + 4)) | < 1086 (3 << (D3DSP_SWIZZLE_SHIFT + 6)) ); < 1087 < 1088 // source parameter modifiers < 1089 const D3DSP_SRCMOD_SHIFT = 24; < 1090 const D3DSP_SRCMOD_MASK = 0x0F000000; < 1091 < 1092 enum : D3DSHADER_PARAM_SRCMOD_TYPE { < 1093 D3DSPSM_NONE = 0<<D3DSP_SRCMOD_SHIFT, // nop < 1094 D3DSPSM_NEG = 1<<D3DSP_SRCMOD_SHIFT, // negate < 1095 D3DSPSM_BIAS = 2<<D3DSP_SRCMOD_SHIFT, // bias < 1096 D3DSPSM_BIASNEG = 3<<D3DSP_SRCMOD_SHIFT, // bias and negate < 1097 D3DSPSM_SIGN = 4<<D3DSP_SRCMOD_SHIFT, // sign < 1098 D3DSPSM_SIGNNEG = 5<<D3DSP_SRCMOD_SHIFT, // sign and negate < 1099 D3DSPSM_COMP = 6<<D3DSP_SRCMOD_SHIFT, // complement < 1100 D3DSPSM_X2 = 7<<D3DSP_SRCMOD_SHIFT, // *2 < 1101 D3DSPSM_X2NEG = 8<<D3DSP_SRCMOD_SHIFT, // *2 and negate < 1102 D3DSPSM_DZ = 9<<D3DSP_SRCMOD_SHIFT, // divide through by z component < 1103 D3DSPSM_DW = 10<<D3DSP_SRCMOD_SHIFT, // divide through by w component < 1104 D3DSPSM_ABS = 11<<D3DSP_SRCMOD_SHIFT, // abs() < 1105 D3DSPSM_ABSNEG = 12<<D3DSP_SRCMOD_SHIFT, // -abs() < 1106 D3DSPSM_NOT = 13<<D3DSP_SRCMOD_SHIFT // for predicate register: "!p0" < 1107 } < 1108 alias TypeDef!(uint) D3DSHADER_PARAM_SRCMOD_TYPE; < 1109 < 1110 // pixel shader version token < 1111 uint D3DPS_VERSION(ubyte _Major, ubyte _Minor) { return (0xFFFF0000|(_Major<<8)| < 1112 < 1113 // vertex shader version token < 1114 uint D3DVS_VERSION(ubyte _Major, ubyte _Minor) { return (0xFFFE0000|(_Major<<8)| < 1115 < 1116 // extract major/minor from version cap < 1117 ubyte D3DSHADER_VERSION_MAJOR(uint _Version) { return cast(ubyte)((_Version>>8)& < 1118 ubyte D3DSHADER_VERSION_MINOR(uint _Version) { return cast(ubyte)((_Version>>0)& < 1119 < 1120 // destination/source parameter register type < 1121 const D3DSI_COMMENTSIZE_SHIFT = 16; < 1122 const D3DSI_COMMENTSIZE_MASK = 0x7FFF0000; < 1123 uint D3DSHADER_COMMENT(ushort _DWordSize) { return (((_DWordSize<<D3DSI_COMMENTS < 1124 < 1125 // pixel/vertex shader end token < 1126 const D3DPS_END = 0x0000FFFF; < 1127 const D3DVS_END = 0x0000FFFF; < 1128 < 1129 < 1130 //--------------------------------------------------------------------- < 1131 < 1132 // High order surfaces < 1133 // < 1134 enum : D3DBASISTYPE { < 1135 D3DBASIS_BEZIER = 0, < 1136 D3DBASIS_BSPLINE = 1, < 1137 D3DBASIS_CATMULL_ROM = 2 /* In D3D8 this used to be D3DBASIS_INTERPOLATE */ < 1138 } < 1139 alias TypeDef!(uint) D3DBASISTYPE; < 1140 < 1141 enum : D3DDEGREETYPE { < 1142 D3DDEGREE_LINEAR = 1, < 1143 D3DDEGREE_QUADRATIC = 2, < 1144 D3DDEGREE_CUBIC = 3, < 1145 D3DDEGREE_QUINTIC = 5 < 1146 } < 1147 alias TypeDef!(uint) D3DDEGREETYPE; < 1148 < 1149 enum : D3DPATCHEDGESTYLE { < 1150 D3DPATCHEDGE_DISCRETE = 0, < 1151 D3DPATCHEDGE_CONTINUOUS = 1 < 1152 } < 1153 alias TypeDef!(uint) D3DPATCHEDGESTYLE; < 1154 < 1155 enum : D3DSTATEBLOCKTYPE { < 1156 D3DSBT_ALL = 1, // capture all state < 1157 D3DSBT_PIXELSTATE = 2, // capture pixel state < 1158 D3DSBT_VERTEXSTATE = 3 // capture vertex state < 1159 } < 1160 alias TypeDef!(uint) D3DSTATEBLOCKTYPE; < 1161 < 1162 // The D3DVERTEXBLENDFLAGS type is used with D3DRS_VERTEXBLEND state. < 1163 // < 1164 enum : D3DVERTEXBLENDFLAGS { < 1165 D3DVBF_DISABLE = 0, // Disable vertex blending < 1166 D3DVBF_1WEIGHTS = 1, // 2 matrix blending < 1167 D3DVBF_2WEIGHTS = 2, // 3 matrix blending < 1168 D3DVBF_3WEIGHTS = 3, // 4 matrix blending < 1169 D3DVBF_TWEENING = 255, // blending using D3DRS_TWEENFACTOR < 1170 D3DVBF_0WEIGHTS = 256 // one matrix is used with weight 1.0 < 1171 } < 1172 alias TypeDef!(uint) D3DVERTEXBLENDFLAGS; < 1173 < 1174 enum : D3DTEXTURETRANSFORMFLAGS { < 1175 D3DTTFF_DISABLE = 0, // texture coordinates are passed directly < 1176 D3DTTFF_COUNT1 = 1, // rasterizer should expect 1-D texture coor < 1177 D3DTTFF_COUNT2 = 2, // rasterizer should expect 2-D texture coor < 1178 D3DTTFF_COUNT3 = 3, // rasterizer should expect 3-D texture coor < 1179 D3DTTFF_COUNT4 = 4, // rasterizer should expect 4-D texture coor < 1180 D3DTTFF_PROJECTED = 256 // texcoords to be divided by COUNTth elemen < 1181 } < 1182 alias TypeDef!(uint) D3DTEXTURETRANSFORMFLAGS; < 1183 < 1184 // Macros to set texture coordinate format bits in the FVF id < 1185 < 1186 const D3DFVF_TEXTUREFORMAT2 = 0; // Two floating point values < 1187 const D3DFVF_TEXTUREFORMAT1 = 3; // One floating point value < 1188 const D3DFVF_TEXTUREFORMAT3 = 1; // Three floating point values < 1189 const D3DFVF_TEXTUREFORMAT4 = 2; // Four floating point values < 1190 < 1191 uint D3DFVF_TEXCOORDSIZE3(uint CoordIndex) { return (D3DFVF_TEXTUREFORMAT3 << (C < 1192 uint D3DFVF_TEXCOORDSIZE2(uint CoordIndex) { return (D3DFVF_TEXTUREFORMAT2); } < 1193 uint D3DFVF_TEXCOORDSIZE4(uint CoordIndex) { return (D3DFVF_TEXTUREFORMAT4 << (C < 1194 uint D3DFVF_TEXCOORDSIZE1(uint CoordIndex) { return (D3DFVF_TEXTUREFORMAT1 << (C < 1195 < 1196 < 1197 //--------------------------------------------------------------------- < 1198 < 1199 /* Direct3D9 Device types */ < 1200 enum : D3DDEVTYPE { < 1201 D3DDEVTYPE_HAL = 1, < 1202 D3DDEVTYPE_REF = 2, < 1203 D3DDEVTYPE_SW = 3, < 1204 < 1205 D3DDEVTYPE_NULLREF = 4 < 1206 } < 1207 alias TypeDef!(uint) D3DDEVTYPE; < 1208 < 1209 /* Multi-Sample buffer types */ < 1210 enum : D3DMULTISAMPLE_TYPE { < 1211 D3DMULTISAMPLE_NONE = 0, < 1212 D3DMULTISAMPLE_NONMASKABLE = 1, < 1213 D3DMULTISAMPLE_2_SAMPLES = 2, < 1214 D3DMULTISAMPLE_3_SAMPLES = 3, < 1215 D3DMULTISAMPLE_4_SAMPLES = 4, < 1216 D3DMULTISAMPLE_5_SAMPLES = 5, < 1217 D3DMULTISAMPLE_6_SAMPLES = 6, < 1218 D3DMULTISAMPLE_7_SAMPLES = 7, < 1219 D3DMULTISAMPLE_8_SAMPLES = 8, < 1220 D3DMULTISAMPLE_9_SAMPLES = 9, < 1221 D3DMULTISAMPLE_10_SAMPLES = 10, < 1222 D3DMULTISAMPLE_11_SAMPLES = 11, < 1223 D3DMULTISAMPLE_12_SAMPLES = 12, < 1224 D3DMULTISAMPLE_13_SAMPLES = 13, < 1225 D3DMULTISAMPLE_14_SAMPLES = 14, < 1226 D3DMULTISAMPLE_15_SAMPLES = 15, < 1227 D3DMULTISAMPLE_16_SAMPLES = 16 < 1228 } < 1229 alias TypeDef!(uint) D3DMULTISAMPLE_TYPE; < 1230 < 1231 /* Formats < 1232 * Most of these names have the following convention: < 1233 * A = Alpha < 1234 * R = Red < 1235 * G = Green < 1236 * B = Blue < 1237 * X = Unused Bits < 1238 * P = Palette < 1239 * L = Luminance < 1240 * U = dU coordinate for BumpMap < 1241 * V = dV coordinate for BumpMap < 1242 * S = Stencil < 1243 * D = Depth (e.g. Z or W buffer) < 1244 * C = Computed from other channels (typically on certain read operations) < 1245 * < 1246 * Further, the order of the pieces are from MSB first; hence < 1247 * D3DFMT_A8L8 indicates that the high byte of this two byte < 1248 * format is alpha. < 1249 * < 1250 * D3DFMT_D16_LOCKABLE indicates: < 1251 * - An integer 16-bit value. < 1252 * - An app-lockable surface. < 1253 * < 1254 * D3DFMT_D32F_LOCKABLE indicates: < 1255 * - An IEEE 754 floating-point value. < 1256 * - An app-lockable surface. < 1257 * < 1258 * All Depth/Stencil formats except D3DFMT_D16_LOCKABLE and D3DFMT_D32F_LOC < 1259 * - no particular bit ordering per pixel, and < 1260 * - are not app lockable, and < 1261 * - the driver is allowed to consume more than the indicated < 1262 * number of bits per Depth channel (but not Stencil channel). < 1263 */ < 1264 uint MAKEFOURCC(ubyte ch0, ubyte ch1, ubyte ch2, ubyte ch3) { < 1265 return cast(uint)ch0 | cast(uint)(ch1 << 8) | cast(uint)(ch2 << 16) | cast(u < 1266 } < 1267 template T_MAKEFOURCC(ubyte ch0, ubyte ch1, ubyte ch2, ubyte ch3) { < 1268 const T_MAKEFOURCC = cast(uint)ch0 | cast(uint)(ch1 << 8) | cast(uint)(ch2 < < 1269 } < 1270 < 1271 enum : D3DFORMAT { < 1272 D3DFMT_UNKNOWN = 0, < 1273 < 1274 D3DFMT_R8G8B8 = 20, < 1275 D3DFMT_A8R8G8B8 = 21, < 1276 D3DFMT_X8R8G8B8 = 22, < 1277 D3DFMT_R5G6B5 = 23, < 1278 D3DFMT_X1R5G5B5 = 24, < 1279 D3DFMT_A1R5G5B5 = 25, < 1280 D3DFMT_A4R4G4B4 = 26, < 1281 D3DFMT_R3G3B2 = 27, < 1282 D3DFMT_A8 = 28, < 1283 D3DFMT_A8R3G3B2 = 29, < 1284 D3DFMT_X4R4G4B4 = 30, < 1285 D3DFMT_A2B10G10R10 = 31, < 1286 D3DFMT_A8B8G8R8 = 32, < 1287 D3DFMT_X8B8G8R8 = 33, < 1288 D3DFMT_G16R16 = 34, < 1289 D3DFMT_A2R10G10B10 = 35, < 1290 D3DFMT_A16B16G16R16 = 36, < 1291 < 1292 D3DFMT_A8P8 = 40, < 1293 D3DFMT_P8 = 41, < 1294 < 1295 D3DFMT_L8 = 50, < 1296 D3DFMT_A8L8 = 51, < 1297 D3DFMT_A4L4 = 52, < 1298 < 1299 D3DFMT_V8U8 = 60, < 1300 D3DFMT_L6V5U5 = 61, < 1301 D3DFMT_X8L8V8U8 = 62, < 1302 D3DFMT_Q8W8V8U8 = 63, < 1303 D3DFMT_V16U16 = 64, < 1304 D3DFMT_A2W10V10U10 = 67, < 1305 < 1306 D3DFMT_UYVY = T_MAKEFOURCC!('U', 'Y', 'V', 'Y'), < 1307 D3DFMT_R8G8_B8G8 = T_MAKEFOURCC!('R', 'G', 'B', 'G'), < 1308 D3DFMT_YUY2 = T_MAKEFOURCC!('Y', 'U', 'Y', '2'), < 1309 D3DFMT_G8R8_G8B8 = T_MAKEFOURCC!('G', 'R', 'G', 'B'), < 1310 D3DFMT_DXT1 = T_MAKEFOURCC!('D', 'X', 'T', '1'), < 1311 D3DFMT_DXT2 = T_MAKEFOURCC!('D', 'X', 'T', '2'), < 1312 D3DFMT_DXT3 = T_MAKEFOURCC!('D', 'X', 'T', '3'), < 1313 D3DFMT_DXT4 = T_MAKEFOURCC!('D', 'X', 'T', '4'), < 1314 D3DFMT_DXT5 = T_MAKEFOURCC!('D', 'X', 'T', '5'), < 1315 < 1316 D3DFMT_D16_LOCKABLE = 70, < 1317 D3DFMT_D32 = 71, < 1318 D3DFMT_D15S1 = 73, < 1319 D3DFMT_D24S8 = 75, < 1320 D3DFMT_D24X8 = 77, < 1321 D3DFMT_D24X4S4 = 79, < 1322 D3DFMT_D16 = 80, < 1323 < 1324 D3DFMT_D32F_LOCKABLE = 82, < 1325 D3DFMT_D24FS8 = 83, < 1326 < 1327 /* Z-Stencil formats valid for CPU access */ < 1328 D3DFMT_D32_LOCKABLE = 84, < 1329 D3DFMT_S8_LOCKABLE = 85, < 1330 < 1331 D3DFMT_L16 = 81, < 1332 < 1333 D3DFMT_VERTEXDATA =100, < 1334 D3DFMT_INDEX16 =101, < 1335 D3DFMT_INDEX32 =102, < 1336 < 1337 D3DFMT_Q16W16V16U16 =110, < 1338 < 1339 D3DFMT_MULTI2_ARGB8 = T_MAKEFOURCC!('M','E','T','1'), < 1340 < 1341 // Floating point surface formats < 1342 < 1343 // s10e5 formats (16-bits per channel) < 1344 D3DFMT_R16F = 111, < 1345 D3DFMT_G16R16F = 112, < 1346 D3DFMT_A16B16G16R16F = 113, < 1347 < 1348 // IEEE s23e8 formats (32-bits per channel) < 1349 D3DFMT_R32F = 114, < 1350 D3DFMT_G32R32F = 115, < 1351 D3DFMT_A32B32G32R32F = 116, < 1352 < 1353 D3DFMT_CxV8U8 = 117, < 1354 < 1355 // Monochrome 1 bit per pixel format < 1356 D3DFMT_A1 = 118, < 1357 < 1358 < 1359 // Binary format indicating that the data has no inherent type < 1360 D3DFMT_BINARYBUFFER = 199 < 1361 } < 1362 alias TypeDef!(uint) D3DFORMAT; < 1363 < 1364 /* Display Modes */ < 1365 struct D3DDISPLAYMODE { < 1366 uint Width; < 1367 uint Height; < 1368 uint RefreshRate; < 1369 D3DFORMAT Format; < 1370 } < 1371 < 1372 /* Creation Parameters */ < 1373 struct D3DDEVICE_CREATION_PARAMETERS < 1374 { < 1375 UINT AdapterOrdinal; < 1376 D3DDEVTYPE DeviceType; < 1377 HWND hFocusWindow; < 1378 DWORD BehaviorFlags; < 1379 } < 1380 < 1381 < 1382 /* SwapEffects */ < 1383 enum : D3DSWAPEFFECT { < 1384 D3DSWAPEFFECT_DISCARD = 1, < 1385 D3DSWAPEFFECT_FLIP = 2, < 1386 D3DSWAPEFFECT_COPY = 3 < 1387 } < 1388 alias TypeDef!(uint) D3DSWAPEFFECT; < 1389 < 1390 /* Pool types */ < 1391 enum : D3DPOOL { < 1392 D3DPOOL_DEFAULT = 0, < 1393 D3DPOOL_MANAGED = 1, < 1394 D3DPOOL_SYSTEMMEM = 2, < 1395 D3DPOOL_SCRATCH = 3 < 1396 } < 1397 alias TypeDef!(uint) D3DPOOL; < 1398 < 1399 < 1400 /* RefreshRate pre-defines */ < 1401 const D3DPRESENT_RATE_DEFAULT = 0x00000000; < 1402 < 1403 < 1404 /* Resize Optional Parameters */ < 1405 struct D3DPRESENT_PARAMETERS < 1406 { < 1407 UINT BackBufferWidth; < 1408 UINT BackBufferHeight; < 1409 D3DFORMAT BackBufferFormat; < 1410 UINT BackBufferCount; < 1411 < 1412 D3DMULTISAMPLE_TYPE MultiSampleType; < 1413 DWORD MultiSampleQuality; < 1414 < 1415 D3DSWAPEFFECT SwapEffect; < 1416 HWND hDeviceWindow; < 1417 BOOL Windowed; < 1418 BOOL EnableAutoDepthStencil; < 1419 D3DFORMAT AutoDepthStencilFormat; < 1420 DWORD Flags; < 1421 < 1422 /* FullScreen_RefreshRateInHz must be zero for Windowed mode */ < 1423 UINT FullScreen_RefreshRateInHz; < 1424 UINT PresentationInterval; < 1425 } < 1426 < 1427 // Values for D3DPRESENT_PARAMETERS.Flags < 1428 < 1429 const D3DPRESENTFLAG_LOCKABLE_BACKBUFFER = 0x00000001; < 1430 const D3DPRESENTFLAG_DISCARD_DEPTHSTENCIL = 0x00000002; < 1431 const D3DPRESENTFLAG_DEVICECLIP = 0x00000004; < 1432 const D3DPRESENTFLAG_VIDEO = 0x00000010; < 1433 < 1434 const D3DPRESENTFLAG_NOAUTOROTATE = 0x00000020; < 1435 const D3DPRESENTFLAG_UNPRUNEDMODE = 0x00000040; < 1436 < 1437 /* Gamma Ramp: Same as DX7 */ < 1438 < 1439 struct D3DGAMMARAMP < 1440 { < 1441 ushort[256] red; < 1442 ushort[256] green; < 1443 ushort[256] blue; < 1444 } < 1445 < 1446 /* Back buffer types */ < 1447 enum : D3DBACKBUFFER_TYPE { < 1448 D3DBACKBUFFER_TYPE_MONO = 0, < 1449 D3DBACKBUFFER_TYPE_LEFT = 1, < 1450 D3DBACKBUFFER_TYPE_RIGHT = 2 < 1451 } < 1452 alias TypeDef!(uint) D3DBACKBUFFER_TYPE; < 1453 < 1454 /* Types */ < 1455 enum : D3DRESOURCETYPE { < 1456 D3DRTYPE_SURFACE = 1, < 1457 D3DRTYPE_VOLUME = 2, < 1458 D3DRTYPE_TEXTURE = 3, < 1459 D3DRTYPE_VOLUMETEXTURE = 4, < 1460 D3DRTYPE_CUBETEXTURE = 5, < 1461 D3DRTYPE_VERTEXBUFFER = 6, < 1462 D3DRTYPE_INDEXBUFFER = 7 //if this changes, change _D < 1463 } < 1464 alias TypeDef!(uint) D3DRESOURCETYPE; < 1465 < 1466 /* Usages */ < 1467 const D3DUSAGE_RENDERTARGET = 0x00000001L; < 1468 const D3DUSAGE_DEPTHSTENCIL = 0x00000002L; < 1469 const D3DUSAGE_DYNAMIC = 0x00000200L; < 1470 const D3DUSAGE_NONSECURE = 0x00800000L; < 1471 < 1472 // When passed to CheckDeviceFormat, D3DUSAGE_AUTOGENMIPMAP may return < 1473 // D3DOK_NOAUTOGEN if the device doesn't support autogeneration for that format. < 1474 // D3DOK_NOAUTOGEN is a success code, not a failure code... the SUCCEEDED and FA < 1475 // will return true and false respectively for this code. < 1476 const D3DUSAGE_AUTOGENMIPMAP = 0x00000400L; < 1477 const D3DUSAGE_DMAP = 0x00004000L; < 1478 < 1479 // The following usages are valid only for querying CheckDeviceFormat < 1480 const D3DUSAGE_QUERY_LEGACYBUMPMAP = 0x00008000L; < 1481 const D3DUSAGE_QUERY_SRGBREAD = 0x00010000L; < 1482 const D3DUSAGE_QUERY_FILTER = 0x00020000L; < 1483 const D3DUSAGE_QUERY_SRGBWRITE = 0x00040000L; < 1484 const D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING = 0x00080000L; < 1485 const D3DUSAGE_QUERY_VERTEXTEXTURE = 0x00100000L; < 1486 const D3DUSAGE_QUERY_WRAPANDMIP = 0x00200000L; < 1487 < 1488 /* Usages for Vertex/Index buffers */ < 1489 const D3DUSAGE_WRITEONLY = 0x00000008L; < 1490 const D3DUSAGE_SOFTWAREPROCESSING = 0x00000010L; < 1491 const D3DUSAGE_DONOTCLIP = 0x00000020L; < 1492 const D3DUSAGE_POINTS = 0x00000040L; < 1493 const D3DUSAGE_RTPATCHES = 0x00000080L; < 1494 const D3DUSAGE_NPATCHES = 0x00000100L; < 1495 const D3DUSAGE_TEXTAPI = 0x10000000L; < 1496 < 1497 /* CubeMap Face identifiers */ < 1498 enum : D3DCUBEMAP_FACES { < 1499 D3DCUBEMAP_FACE_POSITIVE_X = 0, < 1500 D3DCUBEMAP_FACE_NEGATIVE_X = 1, < 1501 D3DCUBEMAP_FACE_POSITIVE_Y = 2, < 1502 D3DCUBEMAP_FACE_NEGATIVE_Y = 3, < 1503 D3DCUBEMAP_FACE_POSITIVE_Z = 4, < 1504 D3DCUBEMAP_FACE_NEGATIVE_Z = 5 < 1505 } < 1506 alias TypeDef!(uint) D3DCUBEMAP_FACES; < 1507 < 1508 /* Lock flags */ < 1509 const D3DLOCK_READONLY = 0x00000010L; < 1510 const D3DLOCK_DISCARD = 0x00002000L; < 1511 const D3DLOCK_NOOVERWRITE = 0x00001000L; < 1512 const D3DLOCK_NOSYSLOCK = 0x00000800L; < 1513 const D3DLOCK_DONOTWAIT = 0x00004000L; < 1514 const D3DLOCK_NO_DIRTY_UPDATE = 0x00008000L; < 1515 < 1516 /* Vertex Buffer Description */ < 1517 struct D3DVERTEXBUFFER_DESC { < 1518 D3DFORMAT Format; < 1519 D3DRESOURCETYPE Type; < 1520 DWORD Usage; < 1521 D3DPOOL Pool; < 1522 UINT Size; < 1523 DWORD FVF; < 1524 } < 1525 < 1526 /* Index Buffer Description */ < 1527 struct D3DINDEXBUFFER_DESC { < 1528 D3DFORMAT Format; < 1529 D3DRESOURCETYPE Type; < 1530 DWORD Usage; < 1531 D3DPOOL Pool; < 1532 UINT Size; < 1533 } < 1534 < 1535 < 1536 /* Surface Description */ < 1537 struct D3DSURFACE_DESC { < 1538 D3DFORMAT Format; < 1539 D3DRESOURCETYPE Type; < 1540 DWORD Usage; < 1541 D3DPOOL Pool; < 1542 < 1543 D3DMULTISAMPLE_TYPE MultiSampleType; < 1544 DWORD MultiSampleQuality; < 1545 UINT Width; < 1546 UINT Height; < 1547 } < 1548 < 1549 struct D3DVOLUME_DESC { < 1550 D3DFORMAT Format; < 1551 D3DRESOURCETYPE Type; < 1552 DWORD Usage; < 1553 D3DPOOL Pool; < 1554 < 1555 UINT Width; < 1556 UINT Height; < 1557 UINT Depth; < 1558 } < 1559 < 1560 /* Structure for LockRect */ < 1561 struct D3DLOCKED_RECT { < 1562 INT Pitch; < 1563 void* pBits; < 1564 } < 1565 < 1566 /* Structures for LockBox */ < 1567 struct D3DBOX { < 1568 UINT Left; < 1569 UINT Top; < 1570 UINT Right; < 1571 UINT Bottom; < 1572 UINT Front; < 1573 UINT Back; < 1574 } < 1575 < 1576 struct D3DLOCKED_BOX < 1577 { < 1578 INT RowPitch; < 1579 INT SlicePitch; < 1580 void* pBits; < 1581 } < 1582 < 1583 /* Structures for LockRange */ < 1584 struct D3DRANGE < 1585 { < 1586 UINT Offset; < 1587 UINT Size; < 1588 } < 1589 < 1590 /* Structures for high order primitives */ < 1591 struct D3DRECTPATCH_INFO < 1592 { < 1593 UINT StartVertexOffsetWidth; < 1594 UINT StartVertexOffsetHeight; < 1595 UINT Width; < 1596 UINT Height; < 1597 UINT Stride; < 1598 D3DBASISTYPE Basis; < 1599 D3DDEGREETYPE Degree; < 1600 } < 1601 < 1602 struct D3DTRIPATCH_INFO < 1603 { < 1604 UINT StartVertexOffset; < 1605 UINT NumVertices; < 1606 D3DBASISTYPE Basis; < 1607 D3DDEGREETYPE Degree; < 1608 } < 1609 < 1610 /* Adapter Identifier */ < 1611 < 1612 const MAX_DEVICE_IDENTIFIER_STRING = 512; < 1613 struct D3DADAPTER_IDENTIFIER9 < 1614 { < 1615 char[MAX_DEVICE_IDENTIFIER_STRING] Driver; < 1616 char[MAX_DEVICE_IDENTIFIER_STRING] Description; < 1617 char[32] DeviceName; /* Device name for GDI (ex. \\.\DISPLAY1) */ < 1618 < 1619 LARGE_INTEGER DriverVersion; /* Defined for 32 bit components */ < 1620 < 1621 DWORD VendorId; < 1622 DWORD DeviceId; < 1623 DWORD SubSysId; < 1624 DWORD Revision; < 1625 < 1626 GUID DeviceIdentifier; < 1627 < 1628 DWORD WHQLLevel; < 1629 } < 1630 < 1631 < 1632 /* Raster Status structure returned by GetRasterStatus */ < 1633 struct D3DRASTER_STATUS < 1634 { < 1635 BOOL InVBlank; < 1636 UINT ScanLine; < 1637 } < 1638 < 1639 < 1640 < 1641 /* Debug monitor tokens (DEBUG only) < 1642 < 1643 Note that if D3DRS_DEBUGMONITORTOKEN is set, the call is treated as < 1644 passing a token to the debug monitor. For example, if, after passing < 1645 D3DDMT_ENABLE/DISABLE to D3DRS_DEBUGMONITORTOKEN other token values < 1646 are passed in, the enabled/disabled state of the debug < 1647 monitor will still persist. < 1648 < 1649 The debug monitor defaults to enabled. < 1650 < 1651 Calling GetRenderState on D3DRS_DEBUGMONITORTOKEN is not of any use. < 1652 */ < 1653 enum : D3DDEBUGMONITORTOKENS { < 1654 D3DDMT_ENABLE = 0, // enable debug monitor < 1655 D3DDMT_DISABLE = 1 // disable debug monitor < 1656 } < 1657 alias TypeDef!(uint) D3DDEBUGMONITORTOKENS; < 1658 < 1659 // Async feedback < 1660 < 1661 enum : D3DQUERYTYPE { < 1662 D3DQUERYTYPE_VCACHE = 4, /* D3DISSUE_END */ < 1663 D3DQUERYTYPE_RESOURCEMANAGER = 5, /* D3DISSUE_END */ < 1664 D3DQUERYTYPE_VERTEXSTATS = 6, /* D3DISSUE_END */ < 1665 D3DQUERYTYPE_EVENT = 8, /* D3DISSUE_END */ < 1666 D3DQUERYTYPE_OCCLUSION = 9, /* D3DISSUE_BEGIN, D3DISSUE_END */ < 1667 D3DQUERYTYPE_TIMESTAMP = 10, /* D3DISSUE_END */ < 1668 D3DQUERYTYPE_TIMESTAMPDISJOINT = 11, /* D3DISSUE_BEGIN, D3DISSUE_END */ < 1669 D3DQUERYTYPE_TIMESTAMPFREQ = 12, /* D3DISSUE_END */ < 1670 D3DQUERYTYPE_PIPELINETIMINGS = 13, /* D3DISSUE_BEGIN, D3DISSUE_END */ < 1671 D3DQUERYTYPE_INTERFACETIMINGS = 14, /* D3DISSUE_BEGIN, D3DISSUE_END */ < 1672 D3DQUERYTYPE_VERTEXTIMINGS = 15, /* D3DISSUE_BEGIN, D3DISSUE_END */ < 1673 D3DQUERYTYPE_PIXELTIMINGS = 16, /* D3DISSUE_BEGIN, D3DISSUE_END */ < 1674 D3DQUERYTYPE_BANDWIDTHTIMINGS = 17, /* D3DISSUE_BEGIN, D3DISSUE_END */ < 1675 D3DQUERYTYPE_CACHEUTILIZATION = 18, /* D3DISSUE_BEGIN, D3DISSUE_END */ < 1676 } < 1677 alias TypeDef!(uint) D3DQUERYTYPE; < 1678 < 1679 // Flags field for Issue < 1680 const D3DISSUE_END = (1 << 0); // Tells the runtime to issue the end of a query, < 1681 const D3DISSUE_BEGIN = (1 << 1); // Tells the runtime to issue the beginng of a < 1682 < 1683 < 1684 // Flags field for GetData < 1685 const D3DGETDATA_FLUSH = (1 << 0); // Tells the runtime to flush if the query is < 1686 < 1687 < 1688 struct D3DRESOURCESTATS < 1689 { < 1690 // Data collected since last Present() < 1691 BOOL bThrashing; /* indicates if thrashing */ < 1692 DWORD ApproxBytesDownloaded; /* Approximate number of bytes downloaded by < 1693 DWORD NumEvicts; /* number of objects evicted */ < 1694 DWORD NumVidCreates; /* number of objects created in video memory < 1695 DWORD LastPri; /* priority of last object evicted */ < 1696 DWORD NumUsed; /* number of objects set to the device */ < 1697 DWORD NumUsedInVidMem; /* number of objects set to the device, whic < 1698 // Persistent data < 1699 DWORD WorkingSet; /* number of objects in video memory */ < 1700 DWORD WorkingSetBytes; /* number of bytes in video memory */ < 1701 DWORD TotalManaged; /* total number of managed objects */ < 1702 DWORD TotalBytes; /* total number of bytes of managed objects < 1703 } < 1704 < 1705 const D3DRTYPECOUNT = D3DRTYPE_INDEXBUFFER+1; < 1706 < 1707 struct D3DDEVINFO_RESOURCEMANAGER < 1708 { < 1709 //#ifndef WOW64_ENUM_WORKAROUND < 1710 // D3DRESOURCESTATS stats[D3DRTYPECOUNT]; < 1711 D3DRESOURCESTATS[8] stats; < 1712 } < 1713 alias D3DDEVINFO_RESOURCEMANAGER* LPD3DDEVINFO_RESOURCEMANAGER; < 1714 < 1715 struct D3DDEVINFO_D3DVERTEXSTATS < 1716 { < 1717 DWORD NumRenderedTriangles; /* total number of triangles that are no < 1718 DWORD NumExtraClippingTriangles; /* Number of new triangles generated by < 1719 } < 1720 alias D3DDEVINFO_D3DVERTEXSTATS *LPD3DDEVINFO_D3DVERTEXSTATS; < 1721 < 1722 < 1723 struct D3DDEVINFO_VCACHE { < 1724 DWORD Pattern; /* bit pattern, return value must be FOU < 1725 DWORD OptMethod; /* optimization method 0 means longest s < 1726 DWORD CacheSize; /* cache size to optimize for (only req < 1727 DWORD MagicNumber; /* used to determine when to restart str < 1728 } < 1729 alias D3DDEVINFO_VCACHE *LPD3DDEVINFO_VCACHE; < 1730 < 1731 struct D3DDEVINFO_D3D9PIPELINETIMINGS < 1732 { < 1733 FLOAT VertexProcessingTimePercent; < 1734 FLOAT PixelProcessingTimePercent; < 1735 FLOAT OtherGPUProcessingTimePercent; < 1736 FLOAT GPUIdleTimePercent; < 1737 } < 1738 < 1739 struct D3DDEVINFO_D3D9INTERFACETIMINGS < 1740 { < 1741 FLOAT WaitingForGPUToUseApplicationResourceTimePercent; < 1742 FLOAT WaitingForGPUToAcceptMoreCommandsTimePercent; < 1743 FLOAT WaitingForGPUToStayWithinLatencyTimePercent; < 1744 FLOAT WaitingForGPUExclusiveResourceTimePercent; < 1745 FLOAT WaitingForGPUOtherTimePercent; < 1746 } < 1747 < 1748 struct D3DDEVINFO_D3D9STAGETIMINGS < 1749 { < 1750 FLOAT MemoryProcessingPercent; < 1751 FLOAT ComputationProcessingPercent; < 1752 } < 1753 < 1754 struct D3DDEVINFO_D3D9BANDWIDTHTIMINGS < 1755 { < 1756 FLOAT MaxBandwidthUtilized; < 1757 FLOAT FrontEndUploadMemoryUtilizedPercent; < 1758 FLOAT VertexRateUtilizedPercent; < 1759 FLOAT TriangleSetupRateUtilizedPercent; < 1760 FLOAT FillRateUtilizedPercent; < 1761 } < 1762 < 1763 struct D3DDEVINFO_D3D9CACHEUTILIZATION < 1764 { < 1765 FLOAT TextureCacheHitRate; // Percentage of cache hits < 1766 FLOAT PostTransformVertexCacheHitRate; < 1767 } < 1768 < 1769 enum : D3DCOMPOSERECTSOP { < 1770 D3DCOMPOSERECTS_COPY = 1, < 1771 D3DCOMPOSERECTS_OR = 2, < 1772 D3DCOMPOSERECTS_AND = 3, < 1773 D3DCOMPOSERECTS_NEG = 4 < 1774 } < 1775 alias TypeDef!(uint) D3DCOMPOSERECTSOP; < 1776 < 1777 struct D3DCOMPOSERECTDESC < 1778 { < 1779 USHORT X, Y; // Top-left coordinates of a rect in the source surf < 1780 USHORT Width, Height; // Dimensions of the rect < 1781 } < 1782 < 1783 struct D3DCOMPOSERECTDESTINATION < 1784 { < 1785 USHORT SrcRectIndex; // Index of D3DCOMPOSERECTDESC < 1786 USHORT Reserved; // For alignment < 1787 SHORT X, Y; // Top-left coordinates of the rect in the destinati < 1788 } < 1789 < 1790 const D3DCOMPOSERECTS_MAXNUMRECTS = 0xFFFF; < 1791 const D3DCONVOLUTIONMONO_MAXWIDTH = 7; < 1792 const D3DCONVOLUTIONMONO_MAXHEIGHT = D3DCONVOLUTIONMONO_MAXWIDTH; < 1793 const D3DFMT_A1_SURFACE_MAXWIDTH = 8192; < 1794 const D3DFMT_A1_SURFACE_MAXHEIGHT = 2048; < 1795 < 1796 < 1797 struct D3DPRESENTSTATS { < 1798 UINT PresentCount; < 1799 UINT PresentRefreshCount; < 1800 UINT SyncRefreshCount; < 1801 LARGE_INTEGER SyncQPCTime; < 1802 LARGE_INTEGER SyncGPUTime; < 1803 } < 1804 < 1805 enum : D3DSCANLINEORDERING < 1806 { < 1807 D3DSCANLINEORDERING_UNKNOWN = 0, < 1808 D3DSCANLINEORDERING_PROGRESSIVE = 1, < 1809 D3DSCANLINEORDERING_INTERLACED = 2 < 1810 } < 1811 alias TypeDef!(uint) D3DSCANLINEORDERING; < 1812 < 1813 < 1814 struct D3DDISPLAYMODEEX < 1815 { < 1816 UINT Size; < 1817 UINT Width; < 1818 UINT Height; < 1819 UINT RefreshRate; < 1820 D3DFORMAT Format; < 1821 D3DSCANLINEORDERING ScanLineOrdering; < 1822 } < 1823 < 1824 struct D3DDISPLAYMODEFILTER < 1825 { < 1826 UINT Size; < 1827 D3DFORMAT Format; < 1828 D3DSCANLINEORDERING ScanLineOrdering; < 1829 } < 1830 < 1831 < 1832 enum : D3DDISPLAYROTATION < 1833 { < 1834 D3DDISPLAYROTATION_IDENTITY = 1, // No rotation. < 1835 D3DDISPLAYROTATION_90 = 2, // Rotated 90 degrees. < 1836 D3DDISPLAYROTATION_180 = 3, // Rotated 180 degrees. < 1837 D3DDISPLAYROTATION_270 = 4 // Rotated 270 degrees. < 1838 } < 1839 alias TypeDef!(uint) D3DDISPLAYROTATION; < 1840 < 1841 /* For use in ID3DResource9::SetPriority calls */ < 1842 const D3D9_RESOURCE_PRIORITY_MINIMUM = 0x28000000; < 1843 const D3D9_RESOURCE_PRIORITY_LOW = 0x50000000; < 1844 const D3D9_RESOURCE_PRIORITY_NORMAL = 0x78000000; < 1845 const D3D9_RESOURCE_PRIORITY_HIGH = 0xa0000000; < 1846 const D3D9_RESOURCE_PRIORITY_MAXIMUM = 0xc8000000; <
Deleted src/win32/directx/d3dx10.d version [95a83671f36f06d6]
1 /***********************************************************************\ < 2 * d3dx10.d * < 3 * * < 4 * Windows API header module * < 5 * * < 6 * Placed into public domain * < 7 \***********************************************************************/ < 8 module win32.directx.d3dx10; < 9 < 10 private import win32.windows; < 11 < 12 public import win32.directx.d3d10; < 13 public import win32.directx.d3dx10math; < 14 public import win32.directx.d3dx10core; < 15 public import win32.directx.d3dx10tex; < 16 public import win32.directx.d3dx10mesh; < 17 public import win32.directx.d3dx10async; < 18 < 19 pragma(lib, "d3dx10.lib"); < 20 < 21 const UINT D3DX10_DEFAULT = -1; < 22 const UINT D3DX10_FROM_FILE = -3; < 23 const DXGI_FORMAT DXGI_FORMAT_FROM_FILE = cast(DXGI_FORMAT)-3; < 24 < 25 const _FACDD = 0x876; < 26 HRESULT MAKE_DDHRESULT(T)(T code) { < 27 return MAKE_HRESULT(1, _FACDD, code); < 28 } < 29 < 30 alias HRESULT _D3DX10_ERR; < 31 _D3DX10_ERR D3DX10_ERR_CANNOT_MODIFY_INDEX_BUFFER = MAKE_DDHRESULT(2900); < 32 _D3DX10_ERR D3DX10_ERR_INVALID_MESH = MAKE_D < 33 _D3DX10_ERR D3DX10_ERR_CANNOT_ATTR_SORT = MAKE_DDHRESULT < 34 _D3DX10_ERR D3DX10_ERR_SKINNING_NOT_SUPPORTED = MAKE_DDHRESULT(2903); < 35 _D3DX10_ERR D3DX10_ERR_TOO_MANY_INFLUENCES = MAKE_DDHRESULT < 36 _D3DX10_ERR D3DX10_ERR_INVALID_DATA = MAKE_D < 37 _D3DX10_ERR D3DX10_ERR_LOADED_MESH_HAS_NO_DATA = MAKE_DDHRESULT(2906); < 38 _D3DX10_ERR D3DX10_ERR_DUPLICATE_NAMED_FRAGMENT = MAKE_DDHRESULT(2907); < 39 _D3DX10_ERR D3DX10_ERR_CANNOT_REMOVE_LAST_ITEM = MAKE_DDHRESULT(2908); <
Deleted src/win32/directx/d3dx10async.d version [3663615d3892dfa7]
1 /***********************************************************************\ < 2 * d3dx10async.d * < 3 * * < 4 * Windows API header module * < 5 * * < 6 * Placed into public domain * < 7 \***********************************************************************/ < 8 module win32.directx.d3dx10async; < 9 < 10 private import win32.windows; < 11 private import win32.directx.d3d10; < 12 private import win32.directx.d3d10shader; < 13 private import win32.directx.d3d10effect; < 14 private import win32.directx.d3dx10; < 15 private import win32.directx.d3dx10async; < 16 < 17 extern(Windows) { < 18 HRESULT D3DX10CompileFromFileA(LPCSTR pSrcFile, D3D10_SHADER_MACRO* pDef < 19 HRESULT D3DX10CompileFromFileW(LPCWSTR pSrcFile, D3D10_SHADER_MACRO* pDe < 20 } < 21 < 22 version(Unicode) { < 23 alias D3DX10CompileFromFileW D3DX10CompileFromFile; < 24 } else { < 25 alias D3DX10CompileFromFileA D3DX10CompileFromFile; < 26 } < 27 < 28 extern(Windows) { < 29 HRESULT D3DX10CompileFromResourceA(HMODULE hSrcModule, LPCSTR pSrcResour < 30 HRESULT D3DX10CompileFromResourceW(HMODULE hSrcModule, LPCWSTR pSrcResou < 31 } < 32 < 33 version(Unicode) { < 34 alias D3DX10CompileFromResourceW D3DX10CompileFromResource; < 35 } else { < 36 alias D3DX10CompileFromResourceA D3DX10CompileFromResource; < 37 } < 38 < 39 extern(Windows) { < 40 HRESULT D3DX10CompileFromMemory(LPCSTR pSrcData, SIZE_T SrcDataLen, LPCS < 41 HRESULT D3DX10CreateEffectFromFileA(LPCSTR pFileName, D3D10_SHADER_MACRO < 42 HRESULT D3DX10CreateEffectFromFileW(LPCWSTR pFileName, D3D10_SHADER_MACR < 43 HRESULT D3DX10CreateEffectFromMemory(LPCVOID pData, SIZE_T DataLength, L < 44 HRESULT D3DX10CreateEffectFromResourceA(HMODULE hModule, LPCSTR pResourc < 45 HRESULT D3DX10CreateEffectFromResourceW(HMODULE hModule, LPCWSTR pResour < 46 } < 47 < 48 version(Unicode) { < 49 alias D3DX10CreateEffectFromFileW D3DX10CreateEffectFromFile; < 50 alias D3DX10CreateEffectFromResourceW D3DX10CreateEffectFromResource; < 51 } else { < 52 alias D3DX10CreateEffectFromFileA D3DX10CreateEffectFromFile; < 53 alias D3DX10CreateEffectFromResourceA D3DX10CreateEffectFromResource; < 54 } < 55 < 56 extern(Windows) { < 57 HRESULT D3DX10CreateEffectPoolFromFileA(LPCSTR pFileName, D3D10_SHADER_M < 58 HRESULT D3DX10CreateEffectPoolFromFileW(LPCWSTR pFileName, D3D10_SHADER_ < 59 HRESULT D3DX10CreateEffectPoolFromMemory(LPCVOID pData, SIZE_T DataLengt < 60 HRESULT D3DX10CreateEffectPoolFromResourceA(HMODULE hModule, LPCSTR pRes < 61 HRESULT D3DX10CreateEffectPoolFromResourceW(HMODULE hModule, LPCWSTR pRe < 62 } < 63 < 64 version(Unicode) { < 65 alias D3DX10CreateEffectPoolFromFileW D3DX10CreateEffectPoolFromFile; < 66 alias D3DX10CreateEffectPoolFromResourceW D3DX10CreateEffectPoolFromReso < 67 } else { < 68 alias D3DX10CreateEffectPoolFromFileA D3DX10CreateEffectPoolFromFile; < 69 alias D3DX10CreateEffectPoolFromResourceA D3DX10CreateEffectPoolFromReso < 70 } < 71 < 72 extern(Windows) { < 73 HRESULT D3DX10PreprocessShaderFromFileA(LPCSTR pFileName, D3D10_SHADER_M < 74 HRESULT D3DX10PreprocessShaderFromFileW(LPCWSTR pFileName, D3D10_SHADER_ < 75 HRESULT D3DX10PreprocessShaderFromMemory(LPCSTR pSrcData, SIZE_T SrcData < 76 HRESULT D3DX10PreprocessShaderFromResourceA(HMODULE hModule, LPCSTR pRes < 77 HRESULT D3DX10PreprocessShaderFromResourceW(HMODULE hModule, LPCWSTR pRe < 78 } < 79 < 80 version(Unicode) { < 81 alias D3DX10PreprocessShaderFromFileW D3DX10PreprocessShaderFromFile; < 82 alias D3DX10PreprocessShaderFromResourceW D3DX10PreprocessShaderFromReso < 83 } else { < 84 alias D3DX10PreprocessShaderFromFileA D3DX10PreprocessShaderFromFile; < 85 alias D3DX10PreprocessShaderFromResourceA D3DX10PreprocessShaderFromReso < 86 } < 87 < 88 extern(Windows) { < 89 HRESULT D3DX10CreateAsyncCompilerProcessor(LPCSTR pFileName, D3D10_SHADE < 90 HRESULT D3DX10CreateAsyncEffectCreateProcessor(LPCSTR pFileName, D3D10_S < 91 HRESULT D3DX10CreateAsyncEffectPoolCreateProcessor(LPCSTR pFileName, D3D < 92 HRESULT D3DX10CreateAsyncShaderPreprocessProcessor(LPCSTR pFileName, D3D < 93 HRESULT D3DX10CreateAsyncFileLoaderW(LPCWSTR pFileName, ID3DX10DataLoade < 94 HRESULT D3DX10CreateAsyncFileLoaderA(LPCSTR pFileName, ID3DX10DataLoader < 95 HRESULT D3DX10CreateAsyncMemoryLoader(LPCVOID pData, SIZE_T cbData, ID3D < 96 HRESULT D3DX10CreateAsyncResourceLoaderW(HMODULE hSrcModule, LPCWSTR pSr < 97 HRESULT D3DX10CreateAsyncResourceLoaderA(HMODULE hSrcModule, LPCSTR pSrc < 98 } < 99 < 100 version(Unicode) { < 101 alias D3DX10CreateAsyncFileLoaderW D3DX10CreateAsyncFileLoader; < 102 alias D3DX10CreateAsyncResourceLoaderW D3DX10CreateAsyncResourceLoader; < 103 } else { < 104 alias D3DX10CreateAsyncFileLoaderA D3DX10CreateAsyncFileLoader; < 105 alias D3DX10CreateAsyncResourceLoaderA D3DX10CreateAsyncResourceLoader; < 106 } < 107 < 108 extern(Windows) { < 109 HRESULT D3DX10CreateAsyncTextureProcessor(ID3D10Device pDevice, D3DX10_I < 110 HRESULT D3DX10CreateAsyncTextureInfoProcessor(D3DX10_IMAGE_INFO* pImageI < 111 HRESULT D3DX10CreateAsyncShaderResourceViewProcessor(ID3D10Device pDevic < 112 } <
Deleted src/win32/directx/d3dx10core.d version [63d7357057086331]
1 /***********************************************************************\ < 2 * d3dx10core.d * < 3 * * < 4 * Windows API header module * < 5 * * < 6 * Placed into public domain * < 7 \***********************************************************************/ < 8 module win32.directx.d3dx10core; < 9 < 10 private import win32.windows; < 11 < 12 private import win32.directx.d3d10; < 13 private import win32.directx.d3d10effect; < 14 private import win32.directx.d3dx10math; < 15 < 16 const D3DX10_DLL_W = "d3dx10_36.dll"; < 17 const D3DX10_DLL_A = "d3dx10_36.dll"; < 18 < 19 version(Unicode) { < 20 alias D3DX10_DLL_W D3DX10_DLL; < 21 } else { < 22 alias D3DX10_DLL_A D3DX10_DLL; < 23 } < 24 < 25 const D3DX10_SDK_VERSION = 36; < 26 < 27 extern(Windows) { < 28 HRESULT D3DX10CreateDevice(IDXGIAdapter pAdapter, D3D10_DRIVER_TYPE Driv < 29 HMODULE Software, UINT Flags, ID3D10Device* ppDevice); < 30 HRESULT D3DX10CreateDeviceAndSwapChain(IDXGIAdapter pAdapter, D3D10_DRIV < 31 HMODULE Software, UINT Flags, DXGI_SWAP_CHAIN_DESC* pSwapChainDe < 32 ID3D10Device* ppDevice); < 33 //TODO HRESULT D3DX10GetFeatureLevel1(ID3D10Device pDevice, ID3D10Device1* ppDe < 34 < 35 debug(D3D10_DEBUG) { < 36 BOOL D3DX10DebugMute(BOOL Mute); < 37 } < 38 < 39 HRESULT D3DX10CheckVersion(UINT D3DSdkVersion, UINT D3DX10SdkVersion); < 40 UINT D3DX10GetDriverLevel(ID3D10Device pDevice); < 41 } < 42 < 43 enum D3DX10_SPRITE_FLAG { < 44 D3DX10_SPRITE_SORT_TEXTURE = 0x01, < 45 D3DX10_SPRITE_SORT_DEPTH_BACK_TO_FRONT = 0x02, < 46 D3DX10_SPRITE_SORT_DEPTH_FRONT_TO_BACK = 0x04, < 47 D3DX10_SPRITE_SAVE_STATE = 0x08, < 48 D3DX10_SPRITE_ADDREF_TEXTURES = 0x10 < 49 } < 50 < 51 struct D3DX10_SPRITE { < 52 D3DXMATRIX matWorld; < 53 D3DXVECTOR2 TexCoord; < 54 D3DXVECTOR2 TexSize; < 55 D3DXCOLOR ColorModulate; < 56 ID3D10ShaderResourceView pTexture; < 57 UINT TextureIndex; < 58 } < 59 < 60 extern(C) const GUID IID_ID3DX10Sprite = {0xba0b762d, 0x8d28, 0x43ec, [0xb9, 0xd < 61 < 62 interface ID3DX10Sprite : IUnknown { < 63 extern(Windows) : < 64 HRESULT Begin(UINT flags); < 65 HRESULT DrawSpritesBuffered(D3DX10_SPRITE* pSprites, UINT cSprites); < 66 HRESULT Flush(); < 67 HRESULT DrawSpritesImmediate(D3DX10_SPRITE* pSprites, UINT cSprites, UIN < 68 HRESULT End(); < 69 HRESULT GetViewTransform(D3DXMATRIX* pViewTransform); < 70 HRESULT SetViewTransform(D3DXMATRIX* pViewTransform); < 71 HRESULT GetProjectionTransform(D3DXMATRIX* pProjectionTransform); < 72 HRESULT SetProjectionTransform(D3DXMATRIX* pProjectionTransform); < 73 HRESULT GetDevice(ID3D10Device* ppDevice); < 74 } < 75 < 76 extern(Windows) HRESULT D3DX10CreateSprite(ID3D10Device pDevice, UINT cDeviceBuf < 77 < 78 interface ID3DX10DataLoader { < 79 /* TODO: fix vtbl[0] bug < 80 extern(Windows) : < 81 HRESULT Load(); < 82 HRESULT Decompress(void** ppData, SIZE_T* pcBytes); < 83 HRESULT Destroy(); < 84 */ < 85 } < 86 < 87 interface ID3DX10DataProcessor { < 88 /* TODO: fix vtbl[0] bug < 89 extern(Windows) : < 90 HRESULT Process(void* pData, SIZE_T cBytes); < 91 HRESULT CreateDeviceObject(void** ppDataObject); < 92 HRESULT Destroy(); < 93 */ < 94 } < 95 < 96 extern(C) const GUID IID_ID3DX10ThreadPump = {0xc93fecfa, 0x6967, 0x478a, [0xab, < 97 < 98 interface ID3DX10ThreadPump : IUnknown { < 99 extern(Windows) : < 100 HRESULT AddWorkItem(ID3DX10DataLoader pDataLoader, ID3DX10DataProcessor < 101 UINT GetWorkItemCount(); < 102 HRESULT WaitForAllItems(); < 103 HRESULT ProcessDeviceWorkItems(UINT iWorkItemCount); < 104 HRESULT PurgeAllItems(); < 105 HRESULT GetQueueStatus(UINT* pIoQueue, UINT* pProcessQueue, UINT* pDevic < 106 } < 107 < 108 extern(Windows) HRESULT D3DX10CreateThreadPump(UINT cIoThreads, UINT cProcThread < 109 ID3DX10ThreadPump *ppThreadPump); < 110 < 111 struct D3DX10_FONT_DESCA { < 112 INT Height; < 113 UINT Width; < 114 UINT Weight; < 115 UINT MipLevels; < 116 BOOL Italic; < 117 BYTE CharSet; < 118 BYTE OutputPrecision; < 119 BYTE Quality; < 120 BYTE PitchAndFamily; < 121 CHAR[LF_FACESIZE] FaceName; < 122 } < 123 < 124 struct D3DX10_FONT_DESCW { < 125 INT Height; < 126 UINT Width; < 127 UINT Weight; < 128 UINT MipLevels; < 129 BOOL Italic; < 130 BYTE CharSet; < 131 BYTE OutputPrecision; < 132 BYTE Quality; < 133 BYTE PitchAndFamily; < 134 WCHAR[LF_FACESIZE] FaceName; < 135 } < 136 < 137 version(Unicode) { < 138 alias D3DX10_FONT_DESCW D3DX10_FONT_DESC; < 139 } else { < 140 alias D3DX10_FONT_DESCA D3DX10_FONT_DESC; < 141 } < 142 < 143 extern(C) const GUID IID_ID3DX10Font = {0xd79dbb70, 0x5f21, 0x4d36, [0xbb, 0xc2, < 144 < 145 interface ID3DX10Font : IUnknown { < 146 extern(Windows) : < 147 HRESULT GetDevice(ID3D10Device* ppDevice); < 148 HRESULT GetDescA(D3DX10_FONT_DESCA* pDesc); < 149 HRESULT GetDescW(D3DX10_FONT_DESCW* pDesc); < 150 BOOL GetTextMetricsA(TEXTMETRICA* pTextMetrics); < 151 BOOL GetTextMetricsW(TEXTMETRICW* pTextMetrics); < 152 HDC GetDC(); < 153 HRESULT GetGlyphData(UINT Glyph, ID3D10ShaderResourceView* ppTexture, RE < 154 HRESULT PreloadCharacters(UINT First, UINT Last); < 155 HRESULT PreloadGlyphs(UINT First, UINT Last); < 156 HRESULT PreloadTextA(LPCSTR pString, INT Count); < 157 HRESULT PreloadTextW(LPCWSTR pString, INT Count); < 158 INT DrawTextA(ID3DX10Sprite pSprite, LPCSTR pString, INT Count, LPRECT p < 159 INT DrawTextW(ID3DX10Sprite pSprite, LPCWSTR pString, INT Count, LPRECT < 160 version(Unicode) { < 161 alias GetTextMetricsW GetTextMetrics; < 162 alias DrawTextW DrawText; < 163 } else { < 164 alias GetTextMetricsA GetTextMetrics; < 165 alias DrawTextA DrawText; < 166 } < 167 } < 168 < 169 extern(Windows) { < 170 HRESULT D3DX10CreateFontA(ID3D10Device pDevice, INT Height, UINT Width, < 171 UINT MipLevels, BOOL Italic, UINT CharSet, UINT OutputPrecision, < 172 UINT PitchAndFamily, LPCSTR pFaceName, ID3DX10Font* ppFont); < 173 HRESULT D3DX10CreateFontW(ID3D10Device pDevice, INT Height, UINT Width, < 174 UINT MipLevels, BOOL Italic, UINT CharSet, UINT OutputPrecision, < 175 UINT PitchAndFamily, LPCWSTR pFaceName, ID3DX10Font* ppFont); < 176 } < 177 < 178 version(Unicode) { < 179 alias D3DX10CreateFontW D3DX10CreateFont; < 180 } else { < 181 alias D3DX10CreateFontA D3DX10CreateFont; < 182 } < 183 < 184 extern(Windows) { < 185 HRESULT D3DX10CreateFontIndirectA(ID3D10Device pDevice, D3DX10_FONT_DESC < 186 HRESULT D3DX10CreateFontIndirectW(ID3D10Device pDevice, D3DX10_FONT_DESC < 187 } < 188 < 189 version(Unicode) { < 190 alias D3DX10CreateFontIndirectW D3DX10CreateFontIndirect; < 191 } else { < 192 alias D3DX10CreateFontIndirectA D3DX10CreateFontIndirect; < 193 } < 194 < 195 extern(Windows) { < 196 HRESULT D3DX10UnsetAllDeviceObjects(ID3D10Device pDevice); < 197 //TODO HRESULT D3DX10ReflectShader(void *pShaderBytecode, SIZE_T BytecodeLength < 198 HRESULT D3DX10DisassembleShader(void *pShader, SIZE_T BytecodeLength, BO < 199 LPCSTR pComments, ID3D10Blob* ppDisassembly); < 200 HRESULT D3DX10DisassembleEffect(ID3D10Effect pEffect, BOOL EnableColorCo < 201 } < 202 < 203 const _FACD3D = 0x876; < 204 < 205 HRESULT MAKE_D3DHRESULT(T)(T code) { < 206 return MAKE_HRESULT(1, _FACD3D, code); < 207 } < 208 < 209 HRESULT MAKE_D3DSTATUS(T)(T code) { < 210 return MAKE_HRESULT(0, _FACD3D, code); < 211 } < 212 < 213 const D3DERR_INVALIDCALL = MAKE_D3DHRESULT(2156); < 214 const D3DERR_WASSTILLDRAWING = MAKE_D3DHRESULT(540); <
Deleted src/win32/directx/d3dx10math.d version [2818c66b17c430a2]
1 /***********************************************************************\ < 2 * d3dx10math.d * < 3 * * < 4 * Windows API header module * < 5 * * < 6 * Placed into public domain * < 7 \***********************************************************************/ < 8 module win32.directx.d3dx10math; < 9 < 10 version(Tango) { < 11 import tango.math.Math; < 12 alias sqrt sqrtf; < 13 } else { < 14 version (D_Version2) < 15 import core.stdc.math; < 16 else < 17 import std.c.math; < 18 } < 19 < 20 private import win32.windows; < 21 private import win32.directx.d3dx10; < 22 < 23 struct D3DVECTOR { < 24 float x; < 25 float y; < 26 float z; < 27 } < 28 < 29 struct D3DMATRIX { < 30 union { < 31 struct { < 32 float _11, _12, _13, _14; < 33 float _21, _22, _23, _24; < 34 float _31, _32, _33, _34; < 35 float _41, _42, _43, _44; < 36 } < 37 float[4][4] m; < 38 } < 39 } < 40 < 41 const D3DX_PI = 3.14159265358979323846; < 42 const D3DX_1BYPI = 1.0 / D3DX_PI; < 43 < 44 float D3DXToRadian(float degree) { < 45 return degree * (D3DX_PI / 180.0); < 46 } < 47 < 48 float D3DXToDegree(float radian) { < 49 return radian * (180.0 / D3DX_PI); < 50 } < 51 < 52 const D3DX_16F_DIG = 3; < 53 const D3DX_16F_EPSILON = 4.8875809e-4f; < 54 const D3DX_16F_MANT_DIG = 11; < 55 const D3DX_16F_MAX = 6.550400e+004; < 56 const D3DX_16F_MAX_10_EXP = 4; < 57 const D3DX_16F_MAX_EXP = 15; < 58 const D3DX_16F_MIN = 6.1035156e-5f; < 59 const D3DX_16F_MIN_10_EXP = -4; < 60 const D3DX_16F_MIN_EXP = -14; < 61 const D3DX_16F_RADIX = 2; < 62 const D3DX_16F_ROUNDS = 1; < 63 const D3DX_16F_SIGN_MASK = 0x8000; < 64 const D3DX_16F_EXP_MASK = 0x7C00; < 65 const D3DX_16F_FRAC_MASK = 0x03FF; < 66 < 67 struct D3DXFLOAT16 { < 68 //TODO < 69 protected: < 70 WORD value; < 71 } < 72 < 73 struct D3DXVECTOR2 { < 74 //TODO < 75 float x, y; < 76 } < 77 < 78 struct D3DXVECTOR2_16F { < 79 //TODO < 80 D3DXFLOAT16 x, y; < 81 } < 82 < 83 struct D3DXVECTOR3 { < 84 //TODO < 85 float x, y, z; < 86 } < 87 < 88 struct D3DXVECTOR3_16F { < 89 //TODO < 90 D3DXFLOAT16 x, y, z; < 91 } < 92 < 93 struct D3DXVECTOR4 { < 94 //TODO < 95 float x, y, z, w; < 96 } < 97 < 98 struct D3DXVECTOR4_16F { < 99 //TODO < 100 D3DXFLOAT16 x, y, z, w; < 101 } < 102 < 103 struct D3DXMATRIX { < 104 //TODO < 105 union { < 106 struct { < 107 float _11, _12, _13, _14; < 108 float _21, _22, _23, _24; < 109 float _31, _32, _33, _34; < 110 float _41, _42, _43, _44; < 111 } < 112 float[4][4] m; < 113 } < 114 } < 115 < 116 //TODO struct _D3DXMATRIXA16 : D3DXMATRIX < 117 < 118 struct D3DXQUATERNION { < 119 //TODO < 120 float x, y, z, w; < 121 } < 122 < 123 struct D3DXPLANE { < 124 //TODO < 125 float a, b, c, d; < 126 } < 127 < 128 struct D3DXCOLOR { < 129 //TODO < 130 float r, g, b, a; < 131 } < 132 < 133 extern(Windows) { < 134 D3DXFLOAT16* D3DXFloat32To16Array(D3DXFLOAT16* pOut, float* pIn, UINT n) < 135 float* D3DXFloat16To32Array(float* pOut, D3DXFLOAT16* pIn, UINT n); < 136 } < 137 < 138 float D3DXVec2Length(D3DXVECTOR2* pV) { < 139 debug(D3DX10_DEBUG) { < 140 if (pV is null) return 0.0; < 141 } < 142 return sqrtf((pV.x * pV.x) + (pV.y * pV.y)); < 143 } < 144 < 145 float D3DXVec2LengthSq(D3DXVECTOR2* pV) { < 146 debug(D3DX10_DEBUG) { < 147 if (pV is null) return 0.0; < 148 } < 149 return (pV.x * pV.x) + (pV.y * pV.y); < 150 } < 151 < 152 float D3DXVec2Dot(D3DXVECTOR2* pV1, D3DXVECTOR2* pV2) { < 153 debug(D3DX10_DEBUG) { < 154 if ((pV1 is null) || (pV2 is null)) return 0.0; < 155 } < 156 return (pV1.x * pV2.x) + (pV1.y * pV2.y); < 157 } < 158 < 159 float D3DXVec2CCW(D3DXVECTOR2* pV1, D3DXVECTOR2* pV2) { < 160 debug(D3DX10_DEBUG) { < 161 if ((pV1 is null) || (pV2 is null)) return 0.0; < 162 } < 163 return (pV1.x * pV2.y) + (pV1.y * pV2.x); < 164 } < 165 < 166 D3DXVECTOR2* D3DXVec2Add(D3DXVECTOR2* pOut, D3DXVECTOR2* pV1, D3DXVECTOR2* pV2) < 167 debug(D3DX10_DEBUG) { < 168 if ((pOut is null) || (pV1 is null) || (pV2 is null)) return nul < 169 } < 170 pOut.x = pV1.x + pV2.x; < 171 pOut.y = pV1.y + pV2.y; < 172 return pOut; < 173 } < 174 < 175 D3DXVECTOR2* D3DXVec2Subtract(D3DXVECTOR2* pOut, D3DXVECTOR2* pV1, D3DXVECTOR2* < 176 debug(D3DX10_DEBUG) { < 177 if ((pOut is null) || (pV1 is null) || (pV2 is null)) return nul < 178 } < 179 pOut.x = pV1.x - pV2.x; < 180 pOut.y = pV1.y - pV2.y; < 181 return pOut; < 182 } < 183 < 184 D3DXVECTOR2* D3DXVec2Minimize(D3DXVECTOR2* pOut, D3DXVECTOR2* pV1, D3DXVECTOR2* < 185 debug(D3DX10_DEBUG) { < 186 if ((pOut is null) || (pV1 is null) || (pV2 is null)) return nul < 187 } < 188 pOut.x = pV1.x < pV2.x ? pV1.x : pV2.x; < 189 pOut.y = pV1.y < pV2.y ? pV1.y : pV2.y; < 190 return pOut; < 191 } < 192 < 193 D3DXVECTOR2* D3DXVec2Maximize(D3DXVECTOR2* pOut, D3DXVECTOR2* pV1, D3DXVECTOR2* < 194 debug(D3DX10_DEBUG) { < 195 if ((pOut is null) || (pV1 is null) || (pV2 is null)) return nul < 196 } < 197 pOut.x = pV1.x > pV2.x ? pV1.x : pV2.x; < 198 pOut.y = pV1.y > pV2.y ? pV1.y : pV2.y; < 199 return pOut; < 200 } < 201 < 202 D3DXVECTOR2* D3DXVec2Scale(D3DXVECTOR2* pOut, D3DXVECTOR2* pV, float s) { < 203 debug(D3DX10_DEBUG) { < 204 if ((pOut is null) || (pV is null)) return null; < 205 } < 206 pOut.x = pV.x * s; < 207 pOut.y = pV.y * s; < 208 return pOut; < 209 } < 210 < 211 D3DXVECTOR2* D3DXVec2Lerp(D3DXVECTOR2* pOut, D3DXVECTOR2* pV1, D3DXVECTOR2* pV2, < 212 debug(D3DX10_DEBUG) { < 213 if ((pOut is null) || (pV1 is null) || (pV2 is null)) return nul < 214 } < 215 pOut.x = pV1.x + s * (pV2.x - pV1.x); < 216 pOut.y = pV1.y + s * (pV2.y - pV1.y); < 217 return pOut; < 218 } < 219 < 220 extern(Windows) { < 221 D3DXVECTOR2* D3DXVec2Normalize(D3DXVECTOR2* pOut, D3DXVECTOR2* pV); < 222 D3DXVECTOR2* D3DXVec2Hermite(D3DXVECTOR2* pOut, D3DXVECTOR2* pV1, D3DXVE < 223 D3DXVECTOR2* D3DXVec2CatmullRom(D3DXVECTOR2* pOut, D3DXVECTOR2* pV0, D3D < 224 D3DXVECTOR2* D3DXVec2BaryCentric(D3DXVECTOR2* pOut, D3DXVECTOR2* pV1, D3 < 225 D3DXVECTOR4* D3DXVec2Transform(D3DXVECTOR4* pOut, D3DXVECTOR2* pV, D3DXM < 226 D3DXVECTOR2* D3DXVec2TransformCoord(D3DXVECTOR2* pOut, D3DXVECTOR2* pV, < 227 D3DXVECTOR2* D3DXVec2TransformNormal(D3DXVECTOR2* pOut, D3DXVECTOR2* pV, < 228 D3DXVECTOR4* D3DXVec2TransformArray(D3DXVECTOR4* pOut, UINT OutStride, D < 229 D3DXVECTOR2* D3DXVec2TransformCoordArray(D3DXVECTOR2* pOut, UINT OutStri < 230 D3DXVECTOR2* D3DXVec2TransformNormalArray(D3DXVECTOR2* pOut, UINT OutStr < 231 } < 232 < 233 float D3DXVec3Length(D3DXVECTOR3* pV) { < 234 debug(D3DX10_DEBUG) { < 235 if (pV is null) return 0.0; < 236 } < 237 return sqrtf((pV.x * pV.x) + (pV.y * pV.y) + (pV.z * pV.z)); < 238 } < 239 < 240 float D3DXVec3LengthSq(D3DXVECTOR3* pV) { < 241 debug(D3DX10_DEBUG) { < 242 if (pV is null) return 0.0; < 243 } < 244 return (pV.x * pV.x) + (pV.y * pV.y) + (pV.z * pV.z); < 245 } < 246 < 247 float D3DXVec3Dot(D3DXVECTOR3* pV1, D3DXVECTOR3* pV2) { < 248 debug(D3DX10_DEBUG) { < 249 if ((pV1 is null) || (pV2 is null)) return 0.0; < 250 } < 251 return (pV1.x * pV2.x) + (pV1.y * pV2.y) + (pV1.z * pV2.z); < 252 } < 253 < 254 D3DXVECTOR3* D3DXVec3Cross(D3DXVECTOR3* pOut, D3DXVECTOR3* pV1, D3DXVECTOR3* pV2 < 255 debug(D3DX10_DEBUG) { < 256 if ((pOut is null) || (pV1 is null) || (pV2 is null)) return 0.0 < 257 } < 258 D3DXVECTOR3 v; < 259 v.x = (pV1.y * pV2.z) - (pV1.z * pV2.y); < 260 v.y = (pV1.z * pV2.x) - (pV1.x * pV2.z); < 261 v.z = (pV1.x * pV2.y) - (pV1.y * pV2.x); < 262 *pOut = v; < 263 return pOut; < 264 } < 265 < 266 D3DXVECTOR3* D3DXVec3Add(D3DXVECTOR3* pOut, D3DXVECTOR3* pV1, D3DXVECTOR3* pV2) < 267 debug(D3DX10_DEBUG) { < 268 if ((pOut is null) || (pV1 is null) || (pV2 is null)) return nul < 269 } < 270 pOut.x = pV1.x + pV2.x; < 271 pOut.y = pV1.y + pV2.y; < 272 pOut.z = pV1.z + pV2.z; < 273 return pOut; < 274 } < 275 < 276 D3DXVECTOR3* D3DXVec3Subtract(D3DXVECTOR3* pOut, D3DXVECTOR3* pV1, D3DXVECTOR3* < 277 debug(D3DX10_DEBUG) { < 278 if ((pOut is null) || (pV1 is null) || (pV2 is null)) return nul < 279 } < 280 pOut.x = pV1.x - pV2.x; < 281 pOut.y = pV1.y - pV2.y; < 282 pOut.z = pV1.z - pV2.z; < 283 return pOut; < 284 } < 285 < 286 D3DXVECTOR3* D3DXVec3Minimize(D3DXVECTOR3* pOut, D3DXVECTOR3* pV1, D3DXVECTOR3* < 287 debug(D3DX10_DEBUG) { < 288 if ((pOut is null) || (pV1 is null) || (pV2 is null)) return nul < 289 } < 290 pOut.x = pV1.x < pV2.x ? pV1.x : pV2.x; < 291 pOut.y = pV1.y < pV2.y ? pV1.y : pV2.y; < 292 pOut.z = pV1.z < pV2.z ? pV1.z : pV2.z; < 293 return pOut; < 294 } < 295 < 296 D3DXVECTOR3* D3DXVec3Maximize(D3DXVECTOR3* pOut, D3DXVECTOR3* pV1, D3DXVECTOR3* < 297 debug(D3DX10_DEBUG) { < 298 if ((pOut is null) || (pV1 is null) || (pV2 is null)) return nul < 299 } < 300 pOut.x = pV1.x > pV2.x ? pV1.x : pV2.x; < 301 pOut.y = pV1.y > pV2.y ? pV1.y : pV2.y; < 302 pOut.z = pV1.z > pV2.z ? pV1.z : pV2.z; < 303 return pOut; < 304 } < 305 < 306 D3DXVECTOR3* D3DXVec3Scale(D3DXVECTOR3* pOut, D3DXVECTOR3* pV, float s) { < 307 debug(D3DX10_DEBUG) { < 308 if ((pOut is null) || (pV is null)) return null; < 309 } < 310 pOut.x = pV.x * s; < 311 pOut.y = pV.y * s; < 312 pOut.z = pV.z * s; < 313 return pOut; < 314 } < 315 < 316 D3DXVECTOR3* D3DXVec3Lerp(D3DXVECTOR3* pOut, D3DXVECTOR3* pV1, D3DXVECTOR3* pV2, < 317 debug(D3DX10_DEBUG) { < 318 if ((pOut is null) || (pV1 is null) || (pV2 is null)) return nul < 319 } < 320 pOut.x = pV1.x + s * (pV2.x - pV1.x); < 321 pOut.y = pV1.y + s * (pV2.y - pV1.y); < 322 pOut.z = pV1.z + s * (pV2.z - pV1.z); < 323 return pOut; < 324 } < 325 < 326 extern(Windows) { < 327 D3DXVECTOR3* D3DXVec3Normalize(D3DXVECTOR3* pOut, D3DXVECTOR3* pV); < 328 D3DXVECTOR3* D3DXVec3Hermite(D3DXVECTOR3* pOut, D3DXVECTOR3* pV1, D3DXVE < 329 D3DXVECTOR3* D3DXVec3CatmullRom(D3DXVECTOR3* pOut, D3DXVECTOR3* pV0, D3D < 330 D3DXVECTOR3* D3DXVec3BaryCentric(D3DXVECTOR3* pOut, D3DXVECTOR3* pV1, D3 < 331 D3DXVECTOR4* D3DXVec3Transform(D3DXVECTOR4* pOut, D3DXVECTOR3* pV, D3DXM < 332 D3DXVECTOR3* D3DXVec3TransformCoord(D3DXVECTOR3* pOut, D3DXVECTOR3* pV, < 333 D3DXVECTOR3* D3DXVec3TransformNormal(D3DXVECTOR3* pOut, D3DXVECTOR3* pV, < 334 D3DXVECTOR4* D3DXVec3TransformArray(D3DXVECTOR4* pOut, UINT OutStride, D < 335 D3DXVECTOR3* D3DXVec3TransformCoordArray(D3DXVECTOR3* pOut, UINT OutStri < 336 D3DXVECTOR3* D3DXVec3TransformNormalArray(D3DXVECTOR3* pOut, UINT OutStr < 337 D3DXVECTOR3* D3DXVec3Project(D3DXVECTOR3* pOut, D3DXVECTOR3* pV, D3D10_V < 338 D3DXVECTOR3* D3DXVec3Unproject(D3DXVECTOR3* pOut, D3DXVECTOR3* pV, D3D10 < 339 D3DXVECTOR3* D3DXVec3ProjectArray(D3DXVECTOR3* pOut, UINT OutStride,D3DX < 340 D3DXVECTOR3* D3DXVec3UnprojectArray(D3DXVECTOR3* pOut, UINT OutStride, D < 341 } < 342 < 343 float D3DXVec4Length(D3DXVECTOR4* pV) { < 344 debug(D3DX10_DEBUG) { < 345 if (pV is null) return 0.0; < 346 } < 347 return sqrtf((pV.x * pV.x) + (pV.y * pV.y) + (pV.z * pV.z) + (pV.w * pV. < 348 } < 349 < 350 float D3DXVec4LengthSq(D3DXVECTOR4* pV) { < 351 debug(D3DX10_DEBUG) { < 352 if (pV is null) return 0.0; < 353 } < 354 return (pV.x * pV.x) + (pV.y * pV.y) + (pV.z * pV.z) + (pV.w * pV.w); < 355 } < 356 < 357 float D3DXVec4Dot(D3DXVECTOR4* pV1, D3DXVECTOR4* pV2) { < 358 debug(D3DX10_DEBUG) { < 359 if ((pV1 is null) || (pV2 is null)) return 0.0; < 360 } < 361 return (pV1.x * pV2.x) + (pV1.y * pV2.y) + (pV1.z * pV2.z) + (pV1.w * pV < 362 } < 363 < 364 D3DXVECTOR4* D3DXVec4Add(D3DXVECTOR4* pOut, D3DXVECTOR4* pV1, D3DXVECTOR4* pV2) < 365 debug(D3DX10_DEBUG) { < 366 if ((pOut is null) || (pV1 is null) || (pV2 is null)) return nul < 367 } < 368 pOut.x = pV1.x + pV2.x; < 369 pOut.y = pV1.y + pV2.y; < 370 pOut.z = pV1.z + pV2.z; < 371 pOut.w = pV1.w + pV2.w; < 372 return pOut; < 373 } < 374 < 375 D3DXVECTOR4* D3DXVec4Subtract(D3DXVECTOR4* pOut, D3DXVECTOR4* pV1, D3DXVECTOR4* < 376 debug(D3DX10_DEBUG) { < 377 if ((pOut is null) || (pV1 is null) || (pV2 is null)) return nul < 378 } < 379 pOut.x = pV1.x - pV2.x; < 380 pOut.y = pV1.y - pV2.y; < 381 pOut.z = pV1.z - pV2.z; < 382 pOut.w = pV1.w - pV2.w; < 383 return pOut; < 384 } < 385 < 386 D3DXVECTOR4* D3DXVec4Minimize(D3DXVECTOR4* pOut, D3DXVECTOR4* pV1, D3DXVECTOR4* < 387 debug(D3DX10_DEBUG) { < 388 if ((pOut is null) || (pV1 is null) || (pV2 is null)) return nul < 389 } < 390 pOut.x = pV1.x < pV2.x ? pV1.x : pV2.x; < 391 pOut.y = pV1.y < pV2.y ? pV1.y : pV2.y; < 392 pOut.z = pV1.z < pV2.z ? pV1.z : pV2.z; < 393 pOut.w = pV1.w < pV2.w ? pV1.w : pV2.w; < 394 return pOut; < 395 } < 396 < 397 D3DXVECTOR4* D3DXVec4Maximize(D3DXVECTOR4* pOut, D3DXVECTOR4* pV1, D3DXVECTOR4* < 398 debug(D3DX10_DEBUG) { < 399 if ((pOut is null) || (pV1 is null) || (pV2 is null)) return nul < 400 } < 401 pOut.x = pV1.x > pV2.x ? pV1.x : pV2.x; < 402 pOut.y = pV1.y > pV2.y ? pV1.y : pV2.y; < 403 pOut.z = pV1.z > pV2.z ? pV1.z : pV2.z; < 404 pOut.w = pV1.w > pV2.w ? pV1.w : pV2.w; < 405 return pOut; < 406 } < 407 < 408 D3DXVECTOR4* D3DXVec4Scale(D3DXVECTOR4* pOut, D3DXVECTOR4* pV, float s) { < 409 debug(D3DX10_DEBUG) { < 410 if ((pOut is null) || (pV is null)) return null; < 411 } < 412 pOut.x = pV.x * s; < 413 pOut.y = pV.y * s; < 414 pOut.z = pV.z * s; < 415 pOut.w = pV.w * s; < 416 return pOut; < 417 } < 418 < 419 D3DXVECTOR4* D3DXVec4Lerp(D3DXVECTOR4* pOut, D3DXVECTOR4* pV1, D3DXVECTOR4* pV2, < 420 debug(D3DX10_DEBUG) { < 421 if ((pOut is null) || (pV1 is null) || (pV2 is null)) return nul < 422 } < 423 pOut.x = pV1.x + s * (pV2.x - pV1.x); < 424 pOut.y = pV1.y + s * (pV2.y - pV1.y); < 425 pOut.z = pV1.z + s * (pV2.z - pV1.z); < 426 pOut.w = pV1.w + s * (pV2.w - pV1.w); < 427 return pOut; < 428 } < 429 < 430 extern(Windows) { < 431 D3DXVECTOR4* D3DXVec4Cross(D3DXVECTOR4* pOut, D3DXVECTOR4* pV1, D3DXVECT < 432 D3DXVECTOR4* D3DXVec4Normalize(D3DXVECTOR4* pOut, D3DXVECTOR4* pV); < 433 D3DXVECTOR4* D3DXVec4Hermite(D3DXVECTOR4* pOut, D3DXVECTOR4* pV1, D3DXVE < 434 D3DXVECTOR4* D3DXVec4CatmullRom(D3DXVECTOR4* pOut, D3DXVECTOR4* pV0, D3D < 435 D3DXVECTOR4* D3DXVec4BaryCentric(D3DXVECTOR4* pOut, D3DXVECTOR4* pV1, D3 < 436 D3DXVECTOR4* D3DXVec4Transform(D3DXVECTOR4* pOut, D3DXVECTOR4* pV, D3DXM < 437 D3DXVECTOR4* D3DXVec4TransformArray(D3DXVECTOR4* pOut, UINT OutStride, D < 438 } < 439 < 440 D3DXMATRIX* D3DXMatrixIdentity(D3DXMATRIX *pOut) { < 441 debug(D3DX10_DEBUG) { < 442 if (pOut is null) return NULL; < 443 } < 444 pOut.m[0][1] = pOut.m[0][2] = pOut.m[0][3] = < 445 pOut.m[1][0] = pOut.m[1][2] = pOut.m[1][3] = < 446 pOut.m[2][0] = pOut.m[2][1] = pOut.m[2][3] = < 447 pOut.m[3][0] = pOut.m[3][1] = pOut.m[3][2] = 0.0; < 448 pOut.m[0][0] = pOut.m[1][1] = pOut.m[2][2] = pOut.m[3][3] = 1.0; < 449 return pOut; < 450 } < 451 < 452 < 453 BOOL D3DXMatrixIsIdentity(D3DXMATRIX *pM) { < 454 debug(D3DX10_DEBUG) { < 455 if(pM is null) return FALSE; < 456 } < 457 return (pM.m[0][0] == 1.0f) && (pM.m[0][1] == 0.0f) && (pM.m[0][2] == 0. < 458 (pM.m[1][0] == 0.0f) && (pM.m[1][1] == 1.0f) && (pM.m[1][2] == 0. < 459 (pM.m[2][0] == 0.0f) && (pM.m[2][1] == 0.0f) && (pM.m[2][2] == 1. < 460 (pM.m[3][0] == 0.0f) && (pM.m[3][1] == 0.0f) && (pM.m[3][2] == 0. < 461 } < 462 < 463 extern(Windows) { < 464 FLOAT D3DXMatrixDeterminant(D3DXMATRIX* pM); < 465 HRESULT D3DXMatrixDecompose(D3DXVECTOR3* pOutScale, D3DXQUATERNION* pOut < 466 D3DXMATRIX* D3DXMatrixTranspose(D3DXMATRIX* pOut, D3DXMATRIX* pM); < 467 D3DXMATRIX* D3DXMatrixMultiply(D3DXMATRIX* pOut, D3DXMATRIX* pM1, D3DXMA < 468 D3DXMATRIX* D3DXMatrixMultiplyTranspose(D3DXMATRIX* pOut, D3DXMATRIX* pM < 469 D3DXMATRIX* D3DXMatrixInverse(D3DXMATRIX* pOut, FLOAT* pDeterminant, D3D < 470 D3DXMATRIX* D3DXMatrixScaling(D3DXMATRIX* pOut, FLOAT sx, FLOAT sy, FLOA < 471 D3DXMATRIX* D3DXMatrixTranslation(D3DXMATRIX* pOut, FLOAT x, FLOAT y, FL < 472 D3DXMATRIX* D3DXMatrixRotationX(D3DXMATRIX* pOut, FLOAT Angle); < 473 D3DXMATRIX* D3DXMatrixRotationY(D3DXMATRIX* pOut, FLOAT Angle); < 474 D3DXMATRIX* D3DXMatrixRotationZ(D3DXMATRIX* pOut, FLOAT Angle); < 475 D3DXMATRIX* D3DXMatrixRotationAxis(D3DXMATRIX* pOut, D3DXVECTOR3* pV, FL < 476 D3DXMATRIX* D3DXMatrixRotationQuaternion(D3DXMATRIX* pOut, D3DXQUATERNIO < 477 D3DXMATRIX* D3DXMatrixRotationYawPitchRoll(D3DXMATRIX* pOut, FLOAT Yaw, < 478 D3DXMATRIX* D3DXMatrixTransformation(D3DXMATRIX* pOut, D3DXVECTOR3* pSca < 479 D3DXMATRIX* D3DXMatrixTransformation2D(D3DXMATRIX* pOut, D3DXVECTOR2* pS < 480 D3DXMATRIX* D3DXMatrixAffineTransformation(D3DXMATRIX* pOut, FLOAT Scali < 481 D3DXMATRIX* D3DXMatrixAffineTransformation2D(D3DXMATRIX* pOut, FLOAT Sca < 482 D3DXMATRIX* D3DXMatrixLookAtRH(D3DXMATRIX* pOut, D3DXVECTOR3* pEye, D3DX < 483 D3DXMATRIX* D3DXMatrixLookAtLH(D3DXMATRIX* pOut, D3DXVECTOR3* pEye, D3DX < 484 D3DXMATRIX* D3DXMatrixPerspectiveRH(D3DXMATRIX* pOut, FLOAT w, FLOAT h, < 485 D3DXMATRIX* D3DXMatrixPerspectiveLH(D3DXMATRIX* pOut, FLOAT w, FLOAT h, < 486 D3DXMATRIX* D3DXMatrixPerspectiveFovRH(D3DXMATRIX* pOut, FLOAT fovy, FLO < 487 D3DXMATRIX* D3DXMatrixPerspectiveFovLH(D3DXMATRIX* pOut, FLOAT fovy, FLO < 488 D3DXMATRIX* D3DXMatrixPerspectiveOffCenterRH(D3DXMATRIX* pOut, FLOAT l, < 489 D3DXMATRIX* D3DXMatrixPerspectiveOffCenterLH(D3DXMATRIX* pOut, FLOAT l, < 490 D3DXMATRIX* D3DXMatrixOrthoRH(D3DXMATRIX* pOut, FLOAT w, FLOAT h, FLOAT < 491 D3DXMATRIX* D3DXMatrixOrthoLH(D3DXMATRIX* pOut, FLOAT w, FLOAT h, FLOAT < 492 D3DXMATRIX* D3DXMatrixOrthoOffCenterRH(D3DXMATRIX* pOut, FLOAT l, FLOAT < 493 D3DXMATRIX* D3DXMatrixOrthoOffCenterLH(D3DXMATRIX* pOut, FLOAT l, FLOAT < 494 D3DXMATRIX* D3DXMatrixShadow(D3DXMATRIX* pOut, D3DXVECTOR4* pLight, D3DX < 495 D3DXMATRIX* D3DXMatrixReflect(D3DXMATRIX* pOut, D3DXPLANE* pPlane); < 496 } < 497 < 498 float D3DXQuaternionLength(D3DXQUATERNION *pQ) { < 499 debug(D3DX10_DEBUG) { < 500 if (pQ is null) return 0.0f; < 501 } < 502 return sqrtf((pQ.x * pQ.x) + (pQ.y * pQ.y) + (pQ.z * pQ.z) + (pQ.w * pQ.w)); < 503 } < 504 < 505 float D3DXQuaternionLengthSq(D3DXQUATERNION *pQ) { < 506 debug(D3DX10_DEBUG) { < 507 if(pQ is null) return 0.0f; < 508 } < 509 return (pQ.x * pQ.x) + (pQ.y * pQ.y) + (pQ.z * pQ.z) + (pQ.w * pQ.w); < 510 } < 511 < 512 float D3DXQuaternionDot(D3DXQUATERNION *pQ1, D3DXQUATERNION *pQ2) { < 513 debug(D3DX10_DEBUG) { < 514 if((pQ1 is null) || (pQ2 is null)) return 0.0f; < 515 } < 516 return (pQ1.x * pQ2.x) + (pQ1.y * pQ2.y) + (pQ1.z * pQ2.z) + (pQ1.w * pQ2.w) < 517 } < 518 < 519 D3DXQUATERNION* D3DXQuaternionIdentity(D3DXQUATERNION *pOut) { < 520 debug(D3DX10_DEBUG) { < 521 if(pOut is null) return null; < 522 } < 523 pOut.x = pOut.y = pOut.z = 0.0f; < 524 pOut.w = 1.0f; < 525 return pOut; < 526 } < 527 < 528 bool D3DXQuaternionIsIdentity(D3DXQUATERNION *pQ) { < 529 debug(D3DX10_DEBUG) { < 530 if(pQ is null) return false; < 531 } < 532 return (pQ.x == 0.0f) && (pQ.y == 0.0f) && (pQ.z == 0.0f) && (pQ.w == 1.0f); < 533 } < 534 < 535 D3DXQUATERNION* D3DXQuaternionConjugate(D3DXQUATERNION *pOut, D3DXQUATERNION *pQ < 536 debug(D3DX10_DEBUG) { < 537 if((pOut is null) || (pQis is null)) return null; < 538 } < 539 pOut.x = -pQ.x; < 540 pOut.y = -pQ.y; < 541 pOut.z = -pQ.z; < 542 pOut.w = pQ.w; < 543 return pOut; < 544 } < 545 < 546 extern(Windows) { < 547 void D3DXQuaternionToAxisAngle(D3DXQUATERNION* pQ, D3DXVECTOR3* pAxis, F < 548 D3DXQUATERNION* D3DXQuaternionRotationMatrix(D3DXQUATERNION* pOut, D3DXM < 549 D3DXQUATERNION* D3DXQuaternionRotationAxis(D3DXQUATERNION* pOut, D3DXVEC < 550 D3DXQUATERNION* D3DXQuaternionRotationYawPitchRoll(D3DXQUATERNION* pOut, < 551 D3DXQUATERNION* D3DXQuaternionMultiply(D3DXQUATERNION* pOut, D3DXQUATERN < 552 D3DXQUATERNION* D3DXQuaternionNormalize(D3DXQUATERNION* pOut, D3DXQUATER < 553 D3DXQUATERNION* D3DXQuaternionInverse(D3DXQUATERNION* pOut, D3DXQUATERNI < 554 D3DXQUATERNION* D3DXQuaternionLn(D3DXQUATERNION* pOut, D3DXQUATERNION* p < 555 D3DXQUATERNION* D3DXQuaternionExp(D3DXQUATERNION* pOut, D3DXQUATERNION* < 556 D3DXQUATERNION* D3DXQuaternionSlerp(D3DXQUATERNION* pOut, D3DXQUATERNION < 557 D3DXQUATERNION* D3DXQuaternionSquad(D3DXQUATERNION* pOut, D3DXQUATERNION < 558 void D3DXQuaternionSquadSetup(D3DXQUATERNION* pAOut, D3DXQUATERNION* pBO < 559 D3DXQUATERNION* D3DXQuaternionBaryCentric(D3DXQUATERNION* pOut, D3DXQUAT < 560 } < 561 < 562 float D3DXPlaneDot(D3DXPLANE *pP, D3DXVECTOR4 *pV) { < 563 debug(D3DX10_DEBUG) { < 564 if((pP is null) || (pV is null)) return 0.0f; < 565 } < 566 return (pP.a * pV.x) + (pP.b * pV.y) + (pP.c * pV.z) + (pP.d * pV.w); < 567 } < 568 < 569 float D3DXPlaneDotCoord(D3DXPLANE *pP, D3DXVECTOR3 *pV) { < 570 debug(D3DX10_DEBUG) { < 571 if((pP is null) || (pV is null)) return 0.0f; < 572 } < 573 return (pP.a * pV.x) + (pP.b * pV.y) + (pP.c * pV.z) + pP.d; < 574 } < 575 < 576 float D3DXPlaneDotNormal(D3DXPLANE *pP, D3DXVECTOR3 *pV) { < 577 debug(D3DX10_DEBUG) { < 578 if((pP is null) || (pV is null)) return 0.0f; < 579 } < 580 return (pP.a * pV.x) + (pP.b * pV.y) + (pP.c * pV.z); < 581 } < 582 < 583 D3DXPLANE* D3DXPlaneScale(D3DXPLANE *pOut, D3DXPLANE *pP, float s) { < 584 debug(D3DX10_DEBUG) { < 585 if((pOut is null) || (pP is null)) return null; < 586 } < 587 pOut.a = pP.a * s; < 588 pOut.b = pP.b * s; < 589 pOut.c = pP.c * s; < 590 pOut.d = pP.d * s; < 591 return pOut; < 592 } < 593 < 594 extern(Windows) { < 595 D3DXPLANE* D3DXPlaneNormalize(D3DXPLANE* pOut, D3DXPLANE* pP); < 596 D3DXVECTOR3* D3DXPlaneIntersectLine(D3DXVECTOR3* pOut, D3DXPLANE* pP, D3 < 597 D3DXPLANE* D3DXPlaneFromPointNormal(D3DXPLANE* pOut, D3DXVECTOR3* pPoint < 598 D3DXPLANE* D3DXPlaneFromPoints(D3DXPLANE* pOut, D3DXVECTOR3* pV1, D3DXVE < 599 D3DXPLANE* D3DXPlaneTransform(D3DXPLANE* pOut, D3DXPLANE* pP, D3DXMATRIX < 600 D3DXPLANE* D3DXPlaneTransformArray(D3DXPLANE* pOut, UINT OutStride, D3DX < 601 } < 602 < 603 D3DXCOLOR* D3DXColorNegative(D3DXCOLOR* pOut, D3DXCOLOR* pC) { < 604 debug(D3DX10_DEBUG) { < 605 if((pOut is null) || (pC is null)) return null; < 606 } < 607 pOut.r = 1.0f - pC.r; < 608 pOut.g = 1.0f - pC.g; < 609 pOut.b = 1.0f - pC.b; < 610 pOut.a = pC.a; < 611 return pOut; < 612 } < 613 < 614 D3DXCOLOR* D3DXColorAdd(D3DXCOLOR* pOut, D3DXCOLOR* pC1, D3DXCOLOR* pC2) { < 615 debug(D3DX10_DEBUG) { < 616 if((pOut is null) || (pC1 is null) || (pC2 is null)) return null < 617 } < 618 pOut.r = pC1.r + pC2.r; < 619 pOut.g = pC1.g + pC2.g; < 620 pOut.b = pC1.b + pC2.b; < 621 pOut.a = pC1.a + pC2.a; < 622 return pOut; < 623 } < 624 < 625 D3DXCOLOR* D3DXColorSubtract(D3DXCOLOR* pOut, D3DXCOLOR* pC1, D3DXCOLOR* pC2) { < 626 debug(D3DX10_DEBUG) { < 627 if((pOut is null) || (pC1 is null) || (pC2 is null)) return null < 628 } < 629 pOut.r = pC1.r - pC2.r; < 630 pOut.g = pC1.g - pC2.g; < 631 pOut.b = pC1.b - pC2.b; < 632 pOut.a = pC1.a - pC2.a; < 633 return pOut; < 634 } < 635 < 636 D3DXCOLOR* D3DXColorScale(D3DXCOLOR* pOut, D3DXCOLOR* pC, float s) { < 637 debug(D3DX10_DEBUG) { < 638 if((pOut is null) || (pC is null)) return null; < 639 } < 640 pOut.r = pC.r * s; < 641 pOut.g = pC.g * s; < 642 pOut.b = pC.b * s; < 643 pOut.a = pC.a * s; < 644 return pOut; < 645 } < 646 < 647 D3DXCOLOR* D3DXColorModulate(D3DXCOLOR* pOut, D3DXCOLOR* pC1, D3DXCOLOR* pC2) { < 648 debug(D3DX10_DEBUG) { < 649 if((pOut is null) || (pC1 is null) || (pC2 is null)) return null < 650 } < 651 pOut.r = pC1.r * pC2.r; < 652 pOut.g = pC1.g * pC2.g; < 653 pOut.b = pC1.b * pC2.b; < 654 pOut.a = pC1.a * pC2.a; < 655 return pOut; < 656 } < 657 < 658 D3DXCOLOR* D3DXColorLerp(D3DXCOLOR* pOut, D3DXCOLOR* pC1, D3DXCOLOR* pC2, float < 659 debug(D3DX10_DEBUG) { < 660 if((pOut is null) || (pC1 is null) || (pC2 is null)) return null < 661 } < 662 pOut.r = pC1.r + s * (pC2.r - pC1.r); < 663 pOut.g = pC1.g + s * (pC2.g - pC1.g); < 664 pOut.b = pC1.b + s * (pC2.b - pC1.b); < 665 pOut.a = pC1.a + s * (pC2.a - pC1.a); < 666 return pOut; < 667 } < 668 < 669 extern(Windows) { < 670 D3DXCOLOR* D3DXColorAdjustSaturation(D3DXCOLOR* pOut, D3DXCOLOR* pC, flo < 671 D3DXCOLOR* D3DXColorAdjustContrast(D3DXCOLOR* pOut, D3DXCOLOR* pC, float < 672 FLOAT D3DXFresnelTerm(float CosTheta, float RefractionIndex); < 673 } < 674 < 675 extern (C) const GUID IID_ID3DXMatrixStack = {0xc7885ba7, 0xf990, 0x4fe7, [0x92, < 676 < 677 interface ID3DXMatrixStack : IUnknown { < 678 extern(Windows) : < 679 HRESULT Pop(); < 680 HRESULT Push(); < 681 HRESULT LoadIdentity(); < 682 HRESULT LoadMatrix(D3DXMATRIX* pM ); < 683 HRESULT MultMatrix(D3DXMATRIX* pM ); < 684 HRESULT MultMatrixLocal(D3DXMATRIX* pM ); < 685 HRESULT RotateAxis(D3DXVECTOR3* pV, float Angle); < 686 HRESULT RotateAxisLocal(D3DXVECTOR3* pV, float Angle); < 687 HRESULT RotateYawPitchRoll(float Yaw, float Pitch, float Roll); < 688 HRESULT RotateYawPitchRollLocal(float Yaw, float Pitch, float Roll); < 689 HRESULT Scale(float x, float y, float z); < 690 HRESULT ScaleLocal(float x, float y, float z); < 691 HRESULT Translate(float x, float y, float z ); < 692 HRESULT TranslateLocal(float x, float y, float z); < 693 D3DXMATRIX* GetTop(); < 694 } < 695 < 696 //TODO extern(Windows) HRESULT D3DXCreateMatrixStack(UINT Flags, D3DXMATRIXSTACK < 697 < 698 const D3DXSH_MINORDER = 2; < 699 const D3DXSH_MAXORDER = 6; < 700 < 701 extern(Windows) { < 702 float* D3DXSHEvalDirection(float* pOut, UINT Order, D3DXVECTOR3* pDir); < 703 float* D3DXSHRotate(float* pOut, UINT Order, D3DXMATRIX* pMatrix, float* < 704 float* D3DXSHRotateZ(float* pOut, UINT Order, float Angle, float* pIn); < 705 float* D3DXSHAdd(float* pOut, UINT Order, float* pA, float* pB); < 706 float* D3DXSHScale(float* pOut, UINT Order, float* pIn, float Scale); < 707 float D3DXSHDot(UINT Order, float* pA, float* pB); < 708 float* D3DXSHMultiply2(float* pOut, float* pF, float* pG); < 709 float* D3DXSHMultiply3(float* pOut, float* pF, float* pG); < 710 float* D3DXSHMultiply4(float* pOut, float* pF, float* pG); < 711 float* D3DXSHMultiply5(float* pOut, float* pF, float* pG); < 712 float* D3DXSHMultiply6(float* pOut, float* pF, float* pG); < 713 HRESULT D3DXSHEvalDirectionalLight(UINT Order, D3DXVECTOR3* pDir, float < 714 HRESULT D3DXSHEvalSphericalLight(UINT Order, D3DXVECTOR3* pPos, float Ra < 715 HRESULT D3DXSHEvalConeLight(UINT Order, D3DXVECTOR3* pDir, float Radius, < 716 HRESULT D3DXSHEvalHemisphereLight(UINT Order, D3DXVECTOR3* pDir, D3DXCOL < 717 BOOL D3DXIntersectTri(D3DXVECTOR3* p0, D3DXVECTOR3* p1, D3DXVECTOR3* p2, < 718 BOOL D3DXSphereBoundProbe(D3DXVECTOR3* pCenter, float Radius, D3DXVECTOR < 719 BOOL D3DXBoxBoundProbe(D3DXVECTOR3* pMin, D3DXVECTOR3* pMax, D3DXVECTOR3 < 720 HRESULT D3DXComputeBoundingSphere(D3DXVECTOR3* pFirstPosition, DWORD Num < 721 HRESULT D3DXComputeBoundingBox(D3DXVECTOR3* pFirstPosition, DWORD NumVer < 722 } < 723 < 724 enum D3DX_CPU_OPTIMIZATION { < 725 D3DX_NOT_OPTIMIZED = 0, < 726 D3DX_3DNOW_OPTIMIZED, < 727 D3DX_SSE2_OPTIMIZED, < 728 D3DX_SSE_OPTIMIZED < 729 } < 730 < 731 extern(Windows) D3DX_CPU_OPTIMIZATION D3DXCpuOptimizations(bool Enable); <
Deleted src/win32/directx/d3dx10mesh.d version [46de09d905522b50]
1 /***********************************************************************\ < 2 * d3dx10mesh.d * < 3 * * < 4 * Windows API header module * < 5 * * < 6 * Placed into public domain * < 7 \***********************************************************************/ < 8 module win32.directx.d3dx10mesh; < 9 < 10 private import win32.windows; < 11 private import win32.directx.d3d10; < 12 private import win32.directx.d3dx10; < 13 < 14 extern(C) const GUID IID_ID3DX10BaseMesh = {0x7ed943dd, 0x52e8, 0x40b5, [0xa8, 0 < 15 extern(C) const GUID IID_ID3DX10MeshBuffer = {0x4b0d117, 0x1041, 0x46b1, [0xaa, < 16 extern(C) const GUID IID_ID3DX10Mesh = {0x4020e5c2, 0x1403, 0x4929, [0x88, 0x3f, < 17 extern(C) const GUID IID_ID3DX10PMesh = {0x8875769a, 0xd579, 0x4088, [0xaa, 0xeb < 18 extern(C) const GUID IID_ID3DX10SPMesh = {0x667ea4c7, 0xf1cd, 0x4386, [0xb5, 0x2 < 19 extern(C) const GUID IID_ID3DX10PatchMesh = {0x3ce6cc22, 0xdbf2, 0x44f4, [0x89, < 20 < 21 enum D3DX10_MESH { < 22 D3DX10_MESH_32_BIT = 0x001, < 23 D3DX10_MESH_GS_ADJACENCY = 0x004 < 24 } < 25 < 26 struct D3DX10_ATTRIBUTE_RANGE { < 27 UINT AttribId; < 28 UINT FaceStart; < 29 UINT FaceCount; < 30 UINT VertexStart; < 31 UINT VertexCount; < 32 } < 33 < 34 enum D3DX10_MESH_DISCARD_FLAGS { < 35 D3DX10_MESH_DISCARD_ATTRIBUTE_BUFFER = 0x01, < 36 D3DX10_MESH_DISCARD_ATTRIBUTE_TABLE = 0x02, < 37 D3DX10_MESH_DISCARD_POINTREPS = 0x04, < 38 D3DX10_MESH_DISCARD_ADJACENCY = 0x08, < 39 D3DX10_MESH_DISCARD_DEVICE_BUFFERS = 0x10 < 40 } < 41 < 42 struct D3DX10_WELD_EPSILONS { < 43 FLOAT Position; < 44 FLOAT BlendWeights; < 45 FLOAT Normal; < 46 FLOAT PSize; < 47 FLOAT Specular; < 48 FLOAT Diffuse; < 49 FLOAT[8] Texcoord; < 50 FLOAT Tangent; < 51 FLOAT Binormal; < 52 FLOAT TessFactor; < 53 } < 54 < 55 struct D3DX10_INTERSECT_INFO { < 56 UINT FaceIndex; < 57 FLOAT U; < 58 FLOAT V; < 59 FLOAT Dist; < 60 } < 61 < 62 interface ID3DX10MeshBuffer : IUnknown { < 63 extern(Windows) : < 64 HRESULT Map(void** ppData, SIZE_T* pSize); < 65 HRESULT Unmap(); < 66 SIZE_T GetSize(); < 67 } < 68 < 69 interface ID3DX10Mesh : IUnknown { < 70 extern(Windows) : < 71 UINT GetFaceCount(); < 72 UINT GetVertexCount(); < 73 UINT GetVertexBufferCount(); < 74 UINT GetFlags(); < 75 HRESULT GetVertexDescription(D3D10_INPUT_ELEMENT_DESC** ppDesc, UINT* pDeclC < 76 HRESULT SetVertexData(UINT iBuffer, void* pData); < 77 HRESULT GetVertexBuffer(UINT iBuffer, ID3DX10MeshBuffer** ppVertexBuffer); < 78 HRESULT SetIndexData(void* pData, UINT cIndices); < 79 HRESULT GetIndexBuffer(ID3DX10MeshBuffer** ppIndexBuffer); < 80 HRESULT SetAttributeData(UINT* pData); < 81 HRESULT GetAttributeBuffer(ID3DX10MeshBuffer** ppAttributeBuffer); < 82 HRESULT SetAttributeTable(D3DX10_ATTRIBUTE_RANGE* pAttribTable, UINT cAttri < 83 HRESULT GetAttributeTable(D3DX10_ATTRIBUTE_RANGE* pAttribTable, UINT* pAttri < 84 HRESULT GenerateAdjacencyAndPointReps(FLOAT Epsilon); < 85 HRESULT GenerateGSAdjacency(); < 86 HRESULT SetAdjacencyData(UINT* pAdjacency); < 87 HRESULT GetAdjacencyBuffer(ID3DX10MeshBuffer** ppAdjacency); < 88 HRESULT SetPointRepData(UINT* pPointReps); < 89 HRESULT GetPointRepBuffer(ID3DX10MeshBuffer** ppPointReps); < 90 HRESULT Discard(D3DX10_MESH_DISCARD_FLAGS dwDiscard); < 91 HRESULT CloneMesh(UINT Flags, LPCSTR pPosSemantic, D3D10_INPUT_ELEMENT_DESC* < 92 HRESULT Optimize(UINT Flags, UINT * pFaceRemap, ID3D10Blob* ppVertexRemap); < 93 HRESULT GenerateAttributeBufferFromTable(); < 94 HRESULT Intersect(D3DXVECTOR3* pRayPos, D3DXVECTOR3* pRayDir, UINT* pHit < 95 HRESULT IntersectSubset(UINT AttribId, D3DXVECTOR3* pRayPos, D3DXVECTOR3 < 96 HRESULT CommitToDevice(); < 97 HRESULT DrawSubset(UINT AttribId); < 98 HRESULT DrawSubsetInstanced(UINT AttribId, UINT InstanceCount, UINT StartIns < 99 HRESULT GetDeviceVertexBuffer(UINT iBuffer, ID3D10Buffer** ppVertexBuffer); < 100 HRESULT GetDeviceIndexBuffer(ID3D10Buffer** ppIndexBuffer); < 101 } < 102 < 103 HRESULT D3DX10CreateMesh(ID3D10Device* pDevice, D3D10_INPUT_ELEMENT_DESC* pDecla < 104 < 105 enum D3DX10_MESHOPT { < 106 D3DX10_MESHOPT_COMPACT = 0x01000000, < 107 D3DX10_MESHOPT_ATTR_SORT = 0x02000000, < 108 D3DX10_MESHOPT_VERTEX_CACHE = 0x04000000, < 109 D3DX10_MESHOPT_STRIP_REORDER = 0x08000000, < 110 D3DX10_MESHOPT_IGNORE_VERTS = 0x10000000, < 111 D3DX10_MESHOPT_DO_NOT_SPLIT = 0x20000000, < 112 D3DX10_MESHOPT_DEVICE_INDEPENDENT = 0x00400000 < 113 } < 114 < 115 extern(C) const GUID IID_ID3DX10SkinInfo = {0x420bd604, 0x1c76, 0x4a34, [0xa4, 0 < 116 < 117 const D3DX10_SKININFO_NO_SCALING = 0; < 118 const D3DX10_SKININFO_SCALE_TO_1 = 1; < 119 const D3DX10_SKININFO_SCALE_TO_TOTAL = 2; < 120 < 121 struct D3DX10_SKINNING_CHANNEL { < 122 UINT SrcOffset; < 123 UINT DestOffset; < 124 BOOL IsNormal; < 125 } < 126 < 127 interface ID3DX10SkinInfo : IUnknown { < 128 extern(Windows) : < 129 HRESULT QueryInterface(REFIID iid, LPVOID* ppv); < 130 ULONG AddRef(); < 131 ULONG Release(); < 132 UINT GetNumVertices(); < 133 UINT GetNumBones(); < 134 UINT GetMaxBoneInfluences(); < 135 HRESULT AddVertices(UINT Count); < 136 HRESULT RemapVertices(UINT NewVertexCount, UINT* pVertexRemap); < 137 HRESULT AddBones(UINT Count); < 138 HRESULT RemoveBone(UINT Index); < 139 HRESULT RemapBones(UINT NewBoneCount, UINT* pBoneRemap); < 140 HRESULT AddBoneInfluences(UINT BoneIndex, UINT InfluenceCount, UINT* pIn < 141 HRESULT ClearBoneInfluences(UINT BoneIndex); < 142 UINT GetBoneInfluenceCount(UINT BoneIndex); < 143 HRESULT GetBoneInfluences(UINT BoneIndex, UINT Offset, UINT Count, UINT* < 144 HRESULT FindBoneInfluenceIndex(UINT BoneIndex, UINT VertexIndex, UINT* p < 145 HRESULT SetBoneInfluence(UINT BoneIndex, UINT InfluenceIndex, float Weig < 146 HRESULT GetBoneInfluence(UINT BoneIndex, UINT InfluenceIndex, float* pWe < 147 HRESULT Compact(UINT MaxPerVertexInfluences, UINT ScaleMode, float MinWe < 148 HRESULT DoSoftwareSkinning(UINT StartVertex, UINT VertexCount, void* pSr < 149 } < 150 < 151 HRESULT D3DX10CreateSkinInfo(ID3DX10SkinInfo* ppSkinInfo); < 152 < 153 struct D3DX10_ATTRIBUTE_WEIGHTS { < 154 FLOAT Position; < 155 FLOAT Boundary; < 156 FLOAT Normal; < 157 FLOAT Diffuse; < 158 FLOAT Specular; < 159 FLOAT[8] Texcoord; < 160 FLOAT Tangent; < 161 FLOAT Binormal; < 162 } < 163 <
Deleted src/win32/directx/d3dx10tex.d version [06a52066351ca0eb]
1 /***********************************************************************\ < 2 * d3dx10tex.d * < 3 * * < 4 * Windows API header module * < 5 * * < 6 * Placed into public domain * < 7 \***********************************************************************/ < 8 module win32.directx.d3dx10tex; < 9 < 10 private import win32.windows; < 11 private import win32.directx.d3d10; < 12 private import win32.directx.d3dx10core; < 13 < 14 enum D3DX10_FILTER_FLAG { < 15 D3DX10_FILTER_NONE = 0x000001, < 16 D3DX10_FILTER_POINT = 0x000002, < 17 D3DX10_FILTER_LINEAR = 0x000003, < 18 D3DX10_FILTER_TRIANGLE = 0x000004, < 19 D3DX10_FILTER_BOX = 0x000005, < 20 D3DX10_FILTER_MIRROR_U = 0x010000, < 21 D3DX10_FILTER_MIRROR_V = 0x020000, < 22 D3DX10_FILTER_MIRROR_W = 0x040000, < 23 D3DX10_FILTER_MIRROR = 0x070000, < 24 D3DX10_FILTER_DITHER = 0x080000, < 25 D3DX10_FILTER_DITHER_DIFFUSION = 0x100000, < 26 D3DX10_FILTER_SRGB_IN = 0x200000, < 27 D3DX10_FILTER_SRGB_OUT = 0x400000, < 28 D3DX10_FILTER_SRGB = 0x600000 < 29 } < 30 < 31 enum D3DX10_NORMALMAP_FLAG { < 32 D3DX10_NORMALMAP_MIRROR_U = 0x010000, < 33 D3DX10_NORMALMAP_MIRROR_V = 0x020000, < 34 D3DX10_NORMALMAP_MIRROR = 0x030000, < 35 D3DX10_NORMALMAP_INVERTSIGN = 0x080000, < 36 D3DX10_NORMALMAP_COMPUTE_OCCLUSION = 0x100000 < 37 } < 38 < 39 enum D3DX10_CHANNEL_FLAG { < 40 D3DX10_CHANNEL_RED = 1, < 41 D3DX10_CHANNEL_BLUE = 2, < 42 D3DX10_CHANNEL_GREEN = 4, < 43 D3DX10_CHANNEL_ALPHA = 8, < 44 D3DX10_CHANNEL_LUMINANCE = 16 < 45 } < 46 < 47 enum D3DX10_IMAGE_FILE_FORMAT { < 48 D3DX10_IFF_BMP = 0, < 49 D3DX10_IFF_JPG = 1, < 50 D3DX10_IFF_PNG = 3, < 51 D3DX10_IFF_DDS = 4, < 52 D3DX10_IFF_TIFF = 10, < 53 D3DX10_IFF_GIF = 11, < 54 D3DX10_IFF_WMP = 12, < 55 D3DX10_IFF_FORCE_DWORD = 0x7fffffff < 56 } < 57 < 58 enum D3DX10_SAVE_TEXTURE_FLAG { < 59 D3DX10_STF_USEINPUTBLOB = 1 < 60 } < 61 < 62 struct D3DX10_IMAGE_INFO { < 63 UINT Width; < 64 UINT Height; < 65 UINT Depth; < 66 UINT ArraySize; < 67 UINT MipLevels; < 68 UINT MiscFlags; < 69 DXGI_FORMAT Format; < 70 D3D10_RESOURCE_DIMENSION ResourceDimension; < 71 D3DX10_IMAGE_FILE_FORMAT ImageFileFormat; < 72 } < 73 < 74 struct D3DX10_IMAGE_LOAD_INFO { < 75 UINT Width; < 76 UINT Height; < 77 UINT Depth; < 78 UINT FirstMipLevel; < 79 UINT MipLevels; < 80 D3D10_USAGE Usage; < 81 UINT BindFlags; < 82 UINT CpuAccessFlags; < 83 UINT MiscFlags; < 84 DXGI_FORMAT Format; < 85 UINT Filter; < 86 UINT MipFilter; < 87 D3DX10_IMAGE_INFO* pSrcInfo; < 88 } < 89 < 90 HRESULT D3DX10GetImageInfoFromFileA(LPCSTR pSrcFile, ID3DX10ThreadPump pPump, < 91 D3DX10_IMAGE_INFO* pSrcInfo, HRESULT* pHResult); < 92 HRESULT D3DX10GetImageInfoFromFileW(LPCWSTR pSrcFile, ID3DX10ThreadPump pPump, < 93 D3DX10_IMAGE_INFO* pSrcInfo, HRESULT* pHResult); < 94 < 95 HRESULT D3DX10GetImageInfoFromResourceA(HMODULE hSrcModule, < 96 LPCSTR pSrcResource, ID3DX10ThreadPump pPump, D3DX10_IMAGE_INFO* pSrcInfo, < 97 HRESULT* pHResult); < 98 HRESULT D3DX10GetImageInfoFromResourceW(HMODULE hSrcModule, < 99 LPCWSTR pSrcResource, ID3DX10ThreadPump pPump, D3DX10_IMAGE_INFO* pSrcInfo, < 100 HRESULT* pHResult); < 101 < 102 HRESULT D3DX10GetImageInfoFromMemory(LPCVOID pSrcData, SIZE_T SrcDataSize, < 103 ID3DX10ThreadPump pPump, D3DX10_IMAGE_INFO* pSrcInfo, HRESULT* pHResult); < 104 < 105 HRESULT D3DX10CreateShaderResourceViewFromFileA(ID3D10Device pDevice, < 106 LPCSTR pSrcFile, D3DX10_IMAGE_LOAD_INFO* pLoadInfo, ID3DX10ThreadPump pPump, < 107 ID3D10ShaderResourceView* ppShaderResourceView, HRESULT* pHResult); < 108 HRESULT D3DX10CreateShaderResourceViewFromFileW(ID3D10Device pDevice, < 109 LPCWSTR pSrcFile, D3DX10_IMAGE_LOAD_INFO* pLoadInfo, ID3DX10ThreadPump pPump, < 110 ID3D10ShaderResourceView* ppShaderResourceView, HRESULT* pHResult); < 111 < 112 HRESULT D3DX10CreateTextureFromFileA(ID3D10Device pDevice, LPCSTR pSrcFile, < 113 D3DX10_IMAGE_LOAD_INFO* pLoadInfo, ID3DX10ThreadPump pPump, < 114 ID3D10Resource* ppTexture, HRESULT* pHResult); < 115 HRESULT D3DX10CreateTextureFromFileW(ID3D10Device pDevice, LPCWSTR pSrcFile, < 116 D3DX10_IMAGE_LOAD_INFO* pLoadInfo, ID3DX10ThreadPump pPump, < 117 ID3D10Resource* ppTexture, HRESULT* pHResult); < 118 < 119 HRESULT D3DX10CreateShaderResourceViewFromResourceA(ID3D10Device pDevice, < 120 HMODULE hSrcModule, LPCSTR pSrcResource, D3DX10_IMAGE_LOAD_INFO* pLoadInfo, < 121 ID3DX10ThreadPump pPump, ID3D10ShaderResourceView* ppShaderResourceView, < 122 HRESULT* pHResult); < 123 HRESULT D3DX10CreateShaderResourceViewFromResourceW(ID3D10Device pDevice, < 124 HMODULE hSrcModule, LPCWSTR pSrcResource, D3DX10_IMAGE_LOAD_INFO* pLoadInfo, < 125 ID3DX10ThreadPump pPump, ID3D10ShaderResourceView* ppShaderResourceView, < 126 HRESULT* pHResult); < 127 < 128 HRESULT D3DX10CreateTextureFromResourceA(ID3D10Device pDevice, < 129 HMODULE hSrcModule, LPCSTR pSrcResource, D3DX10_IMAGE_LOAD_INFO* pLoadInfo, < 130 ID3DX10ThreadPump pPump, ID3D10Resource* ppTexture, HRESULT* pHResult); < 131 HRESULT D3DX10CreateTextureFromResourceW(ID3D10Device pDevice, < 132 HMODULE hSrcModule, LPCWSTR pSrcResource, D3DX10_IMAGE_LOAD_INFO* pLoadInfo, < 133 ID3DX10ThreadPump pPump, ID3D10Resource* ppTexture, HRESULT* pHResult); < 134 < 135 HRESULT D3DX10CreateShaderResourceViewFromMemory(ID3D10Device pDevice, < 136 LPCVOID pSrcData, SIZE_T SrcDataSize, D3DX10_IMAGE_LOAD_INFO* pLoadInfo, < 137 ID3DX10ThreadPump pPump, ID3D10ShaderResourceView* ppShaderResourceView, < 138 HRESULT* pHResult); < 139 < 140 HRESULT D3DX10CreateTextureFromMemory(ID3D10Device pDevice, LPCVOID pSrcData, < 141 SIZE_T SrcDataSize, D3DX10_IMAGE_LOAD_INFO* pLoadInfo, < 142 ID3DX10ThreadPump pPump, ID3D10Resource* ppTexture, HRESULT* pHResult); < 143 < 144 struct D3DX10_TEXTURE_LOAD_INFO { < 145 D3D10_BOX* pSrcBox; < 146 D3D10_BOX* pDstBox; < 147 UINT SrcFirstMip; < 148 UINT DstFirstMip; < 149 UINT NumMips; < 150 UINT SrcFirstElement; < 151 UINT DstFirstElement; < 152 UINT NumElements; < 153 UINT Filter; < 154 UINT MipFilter; < 155 } < 156 < 157 HRESULT D3DX10LoadTextureFromTexture(ID3D10Resource pSrcTexture, < 158 D3DX10_TEXTURE_LOAD_INFO* pLoadInfo, ID3D10Resource pDstTexture); < 159 < 160 HRESULT D3DX10FilterTexture(ID3D10Resource pTexture, UINT SrcLevel, UINT MipFilt < 161 < 162 HRESULT D3DX10SaveTextureToFileA(ID3D10Resource pSrcTexture, < 163 D3DX10_IMAGE_FILE_FORMAT DestFormat, LPCSTR pDestFile); < 164 HRESULT D3DX10SaveTextureToFileW(ID3D10Resource pSrcTexture, < 165 D3DX10_IMAGE_FILE_FORMAT DestFormat, LPCWSTR pDestFile); < 166 < 167 HRESULT D3DX10SaveTextureToMemory(ID3D10Resource pSrcTexture, < 168 D3DX10_IMAGE_FILE_FORMAT DestFormat, ID3D10Blob* ppDestBuf, UINT Flags); < 169 < 170 HRESULT D3DX10ComputeNormalMap(ID3D10Texture2D pSrcTexture, UINT Flags, < 171 UINT Channel, FLOAT Amplitude, ID3D10Texture2D pDestTexture); < 172 < 173 HRESULT D3DX10SHProjectCubeMap(UINT Order, ID3D10Texture2D pCubeMap, < 174 FLOAT* pROut, FLOAT* pGOut, FLOAT* pBOut); < 175 < 176 version(Unicode) { < 177 alias D3DX10GetImageInfoFromFileW D3DX10GetImageInfoFromFile; < 178 alias D3DX10GetImageInfoFromResourceW D3DX10GetImageInfoFromResource; < 179 alias D3DX10CreateShaderResourceViewFromFileW D3DX10CreateShaderResource < 180 alias D3DX10CreateTextureFromFileW D3DX10CreateTextureFromFile; < 181 alias D3DX10CreateShaderResourceViewFromResourceW D3DX10CreateShaderReso < 182 alias D3DX10CreateTextureFromResourceW D3DX10CreateTextureFromResource; < 183 alias D3DX10SaveTextureToFileW D3DX10SaveTextureToFile; < 184 } else { < 185 alias D3DX10GetImageInfoFromFileA D3DX10GetImageInfoFromFile; < 186 alias D3DX10GetImageInfoFromResourceA D3DX10GetImageInfoFromResource; < 187 alias D3DX10CreateShaderResourceViewFromFileA D3DX10CreateShaderResource < 188 alias D3DX10CreateTextureFromFileA D3DX10CreateTextureFromFile; < 189 alias D3DX10CreateShaderResourceViewFromResourceA D3DX10CreateShaderReso < 190 alias D3DX10CreateTextureFromResourceA D3DX10CreateTextureFromResource; < 191 alias D3DX10SaveTextureToFileA D3DX10SaveTextureToFile; < 192 } <
Deleted src/win32/directx/d3dx9.d version [49794b578fca5d4e]
1 // D3DX Types and Constants ---------------------------------------------------- < 2 < 3 module win32.directx.d3dx9; < 4 < 5 public import win32.directx.d3d9; < 6 public import win32.windows; < 7 < 8 alias D3DMATRIX D3DXMATRIX; < 9 < 10 const uint MAXD3DDECLLENGTH = 64; < 11 const uint MAX_FVF_DECL_SIZE = MAXD3DDECLLENGTH + 1; < 12 < 13 align(4) struct D3DXATTRIBUTERANGE < 14 { < 15 DWORD AttribId; < 16 DWORD FaceStart; < 17 DWORD FaceCount; < 18 DWORD VertexStart; < 19 DWORD VertexCount; < 20 } < 21 < 22 align(4) struct D3DXVECTOR2 < 23 { < 24 float x = 0, y = 0; < 25 < 26 static D3DXVECTOR2 opCall(float x, float y) < 27 { < 28 D3DXVECTOR2 v; < 29 v.x = x; < 30 v.y = y; < 31 return v; < 32 } < 33 } < 34 < 35 alias D3DVECTOR D3DXVECTOR3; < 36 < 37 align(4) struct D3DXVECTOR4 < 38 { < 39 float x = 0, y = 0, z = 0, w = 0; < 40 < 41 static D3DXVECTOR4 opCall(float x, float y, float z, float w) < 42 { < 43 D3DXVECTOR4 v; < 44 v.x = x; < 45 v.y = y; < 46 v.z = z; < 47 v.w = w; < 48 return v; < 49 } < 50 } < 51 < 52 align(4) struct D3DXQUATERNION < 53 { < 54 float x = 0, y = 0, z = 0, w = 0; < 55 } < 56 < 57 align(4) struct D3DXFRAME < 58 { < 59 LPSTR Name; < 60 D3DXMATRIX TransformationMatrix; < 61 < 62 D3DXMESHCONTAINER* pMeshContainer; < 63 < 64 D3DXFRAME *pFrameSibling; < 65 D3DXFRAME *pFrameFirstChild; < 66 } < 67 < 68 align(4) struct D3DXMESHCONTAINER < 69 { < 70 LPSTR Name; < 71 < 72 D3DXMESHDATA MeshData; < 73 < 74 D3DXMATERIAL* pMaterials; < 75 D3DXEFFECTINSTANCE* pEffects; < 76 DWORD NumMaterials; < 77 DWORD *pAdjacency; < 78 < 79 ID3DXSkinInfo pSkinInfo; < 80 < 81 D3DXMESHCONTAINER* pNextMeshContainer; < 82 } < 83 < 84 align(4) struct D3DXMESHDATA < 85 { < 86 D3DXMESHDATATYPE Type; < 87 < 88 // current mesh data interface < 89 union < 90 { < 91 ID3DXMesh pMesh; < 92 ID3DXPMesh pPMesh; < 93 ID3DXPatchMesh pPatchMesh; < 94 } < 95 } < 96 < 97 alias uint D3DXMESHDATATYPE; < 98 enum : uint < 99 { < 100 D3DXMESHTYPE_MESH = 0x001, // Normal ID3DXMesh data < 101 D3DXMESHTYPE_PMESH = 0x002, // Progressive Mesh - ID3DXPMesh < 102 D3DXMESHTYPE_PATCHMESH = 0x003 // Patch Mesh - ID3DXPatchMesh < 103 } < 104 < 105 align(4) struct D3DXMATERIAL < 106 { < 107 D3DMATERIAL9 MatD3D; < 108 LPSTR pTextureFilename; < 109 } < 110 < 111 alias uint D3DXEFFECTDEFAULTTYPE; < 112 enum : uint < 113 { < 114 D3DXEDT_STRING = 0x1, // pValue points to a null terminated ASCII stri < 115 D3DXEDT_FLOATS = 0x2, // pValue points to an array of floats - number < 116 D3DXEDT_DWORD = 0x3 // pValue points to a DWORD < 117 } < 118 < 119 align(4) struct D3DXEFFECTDEFAULT < 120 { < 121 LPSTR pParamName; < 122 D3DXEFFECTDEFAULTTYPE Type; // type of the data pointed to by pVal < 123 DWORD NumBytes; // size in bytes of the data pointed t < 124 LPVOID pValue; // data for the default of the effect < 125 } < 126 < 127 align(4) struct D3DXEFFECTINSTANCE < 128 { < 129 LPSTR pEffectFilename; < 130 DWORD NumDefaults; < 131 D3DXEFFECTDEFAULT* pDefaults; < 132 } < 133 < 134 alias uint D3DXPATCHMESHTYPE; < 135 enum : uint < 136 { < 137 D3DXPATCHMESH_RECT = 0x001, < 138 D3DXPATCHMESH_TRI = 0x002, < 139 D3DXPATCHMESH_NPATCH = 0x003 < 140 } < 141 < 142 align(4) struct D3DXPATCHINFO < 143 { < 144 D3DXPATCHMESHTYPE PatchType; < 145 D3DDEGREETYPE Degree; < 146 D3DBASISTYPE Basis; < 147 } < 148 < 149 const uint LF_FACESIZE = 32; < 150 < 151 align(4) struct D3DXFONT_DESCA < 152 { < 153 INT Height; < 154 UINT Width; < 155 UINT Weight; < 156 UINT MipLevels; < 157 BOOL Italic; < 158 BYTE CharSet; < 159 BYTE OutputPrecision; < 160 BYTE Quality; < 161 BYTE PitchAndFamily; < 162 CHAR[LF_FACESIZE] FaceName; < 163 } < 164 < 165 align(4) struct D3DXFONT_DESCW < 166 { < 167 INT Height; < 168 UINT Width; < 169 UINT Weight; < 170 UINT MipLevels; < 171 BOOL Italic; < 172 BYTE CharSet; < 173 BYTE OutputPrecision; < 174 BYTE Quality; < 175 BYTE PitchAndFamily; < 176 WCHAR[LF_FACESIZE] FaceName; < 177 } < 178 < 179 align(4) struct TEXTMETRICA < 180 { < 181 LONG tmHeight; < 182 LONG tmAscent; < 183 LONG tmDescent; < 184 LONG tmInternalLeading; < 185 LONG tmExternalLeading; < 186 LONG tmAveCharWidth; < 187 LONG tmMaxCharWidth; < 188 LONG tmWeight; < 189 LONG tmOverhang; < 190 LONG tmDigitizedAspectX; < 191 LONG tmDigitizedAspectY; < 192 BYTE tmFirstChar; < 193 BYTE tmLastChar; < 194 BYTE tmDefaultChar; < 195 BYTE tmBreakChar; < 196 BYTE tmItalic; < 197 BYTE tmUnderlined; < 198 BYTE tmStruckOut; < 199 BYTE tmPitchAndFamily; < 200 BYTE tmCharSet; < 201 } < 202 < 203 align(4) struct TEXTMETRICW < 204 { < 205 LONG tmHeight; < 206 LONG tmAscent; < 207 LONG tmDescent; < 208 LONG tmInternalLeading; < 209 LONG tmExternalLeading; < 210 LONG tmAveCharWidth; < 211 LONG tmMaxCharWidth; < 212 LONG tmWeight; < 213 LONG tmOverhang; < 214 LONG tmDigitizedAspectX; < 215 LONG tmDigitizedAspectY; < 216 WCHAR tmFirstChar; < 217 WCHAR tmLastChar; < 218 WCHAR tmDefaultChar; < 219 WCHAR tmBreakChar; < 220 BYTE tmItalic; < 221 BYTE tmUnderlined; < 222 BYTE tmStruckOut; < 223 BYTE tmPitchAndFamily; < 224 BYTE tmCharSet; < 225 } < 226 < 227 align(4) struct D3DXEFFECT_DESC < 228 { < 229 LPCSTR Creator; // Creator string < 230 UINT Parameters; // Number of parameters < 231 UINT Techniques; // Number of techniques < 232 UINT Functions; // Number of function entrypoints < 233 } < 234 < 235 alias char* D3DXHANDLE; < 236 < 237 align(4) struct D3DXPARAMETER_DESC < 238 { < 239 LPCSTR Name; // Parameter name < 240 LPCSTR Semantic; // Parameter semantic < 241 D3DXPARAMETER_CLASS Class; // Class < 242 D3DXPARAMETER_TYPE Type; // Component type < 243 UINT Rows; // Number of rows < 244 UINT Columns; // Number of columns < 245 UINT Elements; // Number of array elements < 246 UINT Annotations; // Number of annotations < 247 UINT StructMembers; // Number of structure member sub-parame < 248 DWORD Flags; // D3DX_PARAMETER_* flags < 249 UINT Bytes; // Parameter size, in bytes < 250 } < 251 < 252 alias uint D3DXPARAMETER_CLASS; < 253 enum : uint < 254 { < 255 D3DXPC_SCALAR, < 256 D3DXPC_VECTOR, < 257 D3DXPC_MATRIX_ROWS, < 258 D3DXPC_MATRIX_COLUMNS, < 259 D3DXPC_OBJECT, < 260 D3DXPC_STRUCT < 261 } < 262 < 263 alias uint D3DXPARAMETER_TYPE; < 264 enum : uint < 265 { < 266 D3DXPT_VOID, < 267 D3DXPT_BOOL, < 268 D3DXPT_INT, < 269 D3DXPT_FLOAT, < 270 D3DXPT_STRING, < 271 D3DXPT_TEXTURE, < 272 D3DXPT_TEXTURE1D, < 273 D3DXPT_TEXTURE2D, < 274 D3DXPT_TEXTURE3D, < 275 D3DXPT_TEXTURECUBE, < 276 D3DXPT_SAMPLER, < 277 D3DXPT_SAMPLER1D, < 278 D3DXPT_SAMPLER2D, < 279 D3DXPT_SAMPLER3D, < 280 D3DXPT_SAMPLERCUBE, < 281 D3DXPT_PIXELSHADER, < 282 D3DXPT_VERTEXSHADER, < 283 D3DXPT_PIXELFRAGMENT, < 284 D3DXPT_VERTEXFRAGMENT < 285 } < 286 < 287 align(4) struct D3DXTECHNIQUE_DESC < 288 { < 289 LPCSTR Name; // Technique name < 290 UINT Passes; // Number of passes < 291 UINT Annotations; // Number of annotations < 292 } < 293 < 294 align(4) struct D3DXPASS_DESC < 295 { < 296 LPCSTR Name; // Pass name < 297 UINT Annotations; // Number of annotations < 298 < 299 DWORD *pVertexShaderFunction; // Vertex shader function < 300 DWORD *pPixelShaderFunction; // Pixel shader function < 301 } < 302 < 303 align(4) struct D3DXFUNCTION_DESC < 304 { < 305 LPCSTR Name; // Function name < 306 UINT Annotations; // Number of annotations < 307 } < 308 < 309 struct D3DXTRACK_DESC < 310 { < 311 DWORD Priority; < 312 FLOAT Weight = 0; < 313 FLOAT Speed = 0; < 314 double Position = 0; < 315 BOOL Enable; < 316 } < 317 < 318 align(4) struct D3DXEVENT_DESC < 319 { < 320 DWORD Type; < 321 UINT Track; < 322 double StartTime = 0; < 323 double Duration = 0; < 324 DWORD Transition; < 325 union < 326 { < 327 FLOAT Weight = 0; < 328 FLOAT Speed; < 329 double Position; < 330 BOOL Enable; < 331 }; < 332 } < 333 < 334 align(4) struct D3DXKEY_VECTOR3 < 335 { < 336 FLOAT Time = 0; < 337 D3DXVECTOR3 Value; < 338 } < 339 < 340 align(4) struct D3DXKEY_QUATERNION < 341 { < 342 FLOAT Time = 0; < 343 D3DXQUATERNION Value; < 344 } < 345 < 346 align(4) struct D3DXKEY_CALLBACK < 347 { < 348 FLOAT Time = 0; < 349 LPVOID pCallbackData; < 350 } < 351 < 352 align(4) struct D3DXIMAGE_INFO < 353 { < 354 UINT Width; < 355 UINT Height; < 356 UINT Depth; < 357 UINT MipLevels; < 358 D3DFORMAT Format; < 359 D3DRESOURCETYPE ResourceType; < 360 D3DXIMAGE_FILEFORMAT ImageFileFormat; < 361 } < 362 < 363 alias uint D3DXIMAGE_FILEFORMAT; < 364 enum : uint < 365 { < 366 D3DXIFF_BMP = 0, < 367 D3DXIFF_JPG = 1, < 368 D3DXIFF_TGA = 2, < 369 D3DXIFF_PNG = 3, < 370 D3DXIFF_DDS = 4, < 371 D3DXIFF_PPM = 5, < 372 D3DXIFF_DIB = 6, < 373 } < 374 < 375 align(4) struct D3DXATTRIBUTEWEIGHTS < 376 { < 377 FLOAT Position = 0; < 378 FLOAT Boundary = 0; < 379 FLOAT Normal = 0; < 380 FLOAT Diffuse = 0; < 381 FLOAT Specular = 0; < 382 FLOAT[8] Texcoord = 0; < 383 FLOAT Tangent = 0; < 384 FLOAT Binormal = 0; < 385 } < 386 < 387 align(4) struct D3DXPLANE < 388 { < 389 FLOAT a = 0, b = 0, c = 0, d = 0; < 390 } < 391 < 392 alias uint D3DXMESH; < 393 enum : uint < 394 { < 395 D3DXMESH_32BIT = 0x001, < 396 D3DXMESH_DONOTCLIP = 0x002, < 397 D3DXMESH_POINTS = 0x004, < 398 D3DXMESH_RTPATCHES = 0x008, < 399 D3DXMESH_NPATCHES = 0x4000, < 400 D3DXMESH_VB_SYSTEMMEM = 0x010, < 401 D3DXMESH_VB_MANAGED = 0x020, < 402 D3DXMESH_VB_WRITEONLY = 0x040, < 403 D3DXMESH_VB_DYNAMIC = 0x080, < 404 D3DXMESH_VB_SOFTWAREPROCESSING = 0x8000, < 405 D3DXMESH_IB_SYSTEMMEM = 0x100, < 406 D3DXMESH_IB_MANAGED = 0x200, < 407 D3DXMESH_IB_WRITEONLY = 0x400, < 408 D3DXMESH_IB_DYNAMIC = 0x800, < 409 D3DXMESH_IB_SOFTWAREPROCESSING= 0x10000, < 410 D3DXMESH_VB_SHARE = 0x1000, < 411 D3DXMESH_USEHWONLY = 0x2000, < 412 D3DXMESH_SYSTEMMEM = 0x110, < 413 D3DXMESH_MANAGED = 0x220, < 414 D3DXMESH_WRITEONLY = 0x440, < 415 D3DXMESH_DYNAMIC = 0x880, < 416 D3DXMESH_SOFTWAREPROCESSING = 0x18000, < 417 } < 418 < 419 align(4) struct D3DXMACRO < 420 { < 421 LPCSTR Name; < 422 LPCSTR Definition; < 423 } < 424 < 425 align(4) struct D3DXSEMANTIC < 426 { < 427 UINT Usage; < 428 UINT UsageIndex; < 429 } < 430 < 431 alias uint D3DXINCLUDE_TYPE; < 432 enum : uint < 433 { < 434 D3DXINC_LOCAL, < 435 D3DXINC_SYSTEM, < 436 } < 437 < 438 enum : uint < 439 { < 440 D3DXFX_DONOTSAVESTATE = (1 << 0), < 441 D3DXFX_DONOTSAVESHADERSTATE = (1 << 1), < 442 D3DXFX_DONOTSAVESAMPLERSTATE = (1 << 2), < 443 D3DXFX_NOT_CLONEABLE = (1 << 11) < 444 } < 445 < 446 alias uint D3DXMESHSIMP; < 447 enum : uint < 448 { < 449 D3DXMESHSIMP_VERTEX = 0x1, < 450 D3DXMESHSIMP_FACE = 0x2 < 451 } < 452 < 453 enum : uint < 454 { < 455 DT_TOP = 0x00000000, < 456 DT_LEFT = 0x00000000, < 457 DT_CENTER = 0x00000001, < 458 DT_RIGHT = 0x00000002, < 459 DT_VCENTER = 0x00000004, < 460 DT_BOTTOM = 0x00000008, < 461 DT_WORDBREAK = 0x00000010, < 462 DT_SINGLELINE = 0x00000020, < 463 DT_EXPANDTABS = 0x00000040, < 464 DT_TABSTOP = 0x00000080, < 465 DT_NOCLIP = 0x00000100, < 466 DT_EXTERNALLEADING = 0x00000200, < 467 DT_CALCRECT = 0x00000400, < 468 DT_NOPREFIX = 0x00000800, < 469 DT_INTERNAL = 0x00001000 < 470 } < 471 < 472 enum : uint < 473 { < 474 D3DXSPRITE_DONOTSAVESTATE = (1 << 0), < 475 D3DXSPRITE_DONOTMODIFY_RENDERSTATE = (1 << 1), < 476 D3DXSPRITE_OBJECTSPACE = (1 << 2), < 477 D3DXSPRITE_BILLBOARD = (1 << 3), < 478 D3DXSPRITE_ALPHABLEND = (1 << 4), < 479 D3DXSPRITE_SORT_TEXTURE = (1 << 5), < 480 D3DXSPRITE_SORT_DEPTH_FRONTTOBACK = (1 << 6), < 481 D3DXSPRITE_SORT_DEPTH_BACKTOFRONT = (1 << 7) < 482 } < 483 < 484 enum : uint < 485 { < 486 D3DX_FILTER_NONE = (1 << 0), < 487 D3DX_FILTER_POINT = (2 << 0), < 488 D3DX_FILTER_LINEAR = (3 << 0), < 489 D3DX_FILTER_TRIANGLE = (4 << 0), < 490 D3DX_FILTER_BOX = (5 << 0), < 491 D3DX_FILTER_MIRROR_U = (1 << 16), < 492 D3DX_FILTER_MIRROR_V = (2 << 16), < 493 D3DX_FILTER_MIRROR_W = (4 << 16), < 494 D3DX_FILTER_MIRROR = (7 << 16), < 495 D3DX_FILTER_DITHER = (1 << 19), < 496 D3DX_FILTER_DITHER_DIFFUSION = (2 << 19), < 497 D3DX_FILTER_SRGB_IN = (1 << 21), < 498 D3DX_FILTER_SRGB_OUT = (2 << 21), < 499 D3DX_FILTER_SRGB = (3 << 21) < 500 } < 501 < 502 const uint D3DX_DEFAULT = cast(UINT) -1; < 503 < 504 alias uint D3DXMESHOPT; < 505 enum : uint < 506 { < 507 D3DXMESHOPT_COMPACT = 0x01000000, < 508 D3DXMESHOPT_ATTRSORT = 0x02000000, < 509 D3DXMESHOPT_VERTEXCACHE = 0x04000000, < 510 D3DXMESHOPT_STRIPREORDER = 0x08000000, < 511 D3DXMESHOPT_IGNOREVERTS = 0x10000000, // optimize faces only, don't touch < 512 D3DXMESHOPT_DONOTSPLIT = 0x20000000, // do not split vertices shared bet < 513 D3DXMESHOPT_DEVICEINDEPENDENT = 0x00400000 // Only affects VCache. uses a < 514 } < 515 < 516 enum : uint < 517 { < 518 D3DXPLAY_LOOP = 0, < 519 D3DXPLAY_ONCE = 1, < 520 D3DXPLAY_PINGPONG = 2 < 521 } < 522 alias uint D3DXPLAYBACK_TYPE; < 523 < 524 < 525 // D3DX Interfaces ------------------------------------------------------------- < 526 < 527 interface ID3DXSkinInfo : IUnknown < 528 { < 529 extern(Windows): < 530 < 531 // Specify the which vertices do each bones influence and by how much < 532 HRESULT SetBoneInfluence(DWORD bone, DWORD numInfluences, DWORD* vertices, F < 533 HRESULT SetBoneVertexInfluence(DWORD boneNum, DWORD influenceNum, float < 534 DWORD GetNumBoneInfluences(DWORD bone); < 535 HRESULT GetBoneInfluence(DWORD bone, DWORD* vertices, FLOAT* weights); < 536 HRESULT GetBoneVertexInfluence(DWORD boneNum, DWORD influenceNum, float < 537 HRESULT GetMaxVertexInfluences(DWORD* maxVertexInfluences); < 538 DWORD GetNumBones(); < 539 HRESULT FindBoneVertexInfluenceIndex(DWORD boneNum, DWORD vertexNum, DWO < 540 < 541 // This gets the max face influences based on a triangle mesh with the speci < 542 HRESULT GetMaxFaceInfluences(IDirect3DIndexBuffer9 pIB, DWORD NumFaces, DWOR < 543 < 544 // Set min bone influence. Bone influences that are smaller than this are ig < 545 HRESULT SetMinBoneInfluence(FLOAT MinInfl); < 546 // Get min bone influence. < 547 FLOAT GetMinBoneInfluence(); < 548 < 549 // Bone names are returned by D3DXLoadSkinMeshFromXof. They are not used by < 550 HRESULT SetBoneName(DWORD Bone, LPCSTR pName); // pName is copied to an inte < 551 LPCSTR GetBoneName(DWORD Bone); // A pointer to an internal string buffer is < 552 < 553 // Bone offset matrices are returned by D3DXLoadSkinMeshFromXof. They are no < 554 HRESULT SetBoneOffsetMatrix(DWORD Bone, D3DXMATRIX *pBoneTransform); // pBon < 555 D3DXMATRIX* GetBoneOffsetMatrix(DWORD Bone); // A pointer to an internal mat < 556 < 557 // Clone a skin info object < 558 HRESULT Clone(ID3DXSkinInfo* ppSkinInfo); < 559 < 560 // Update bone influence information to match vertices after they are reorde < 561 // if the target vertex buffer has been reordered externally. < 562 HRESULT Remap(DWORD NumVertices, DWORD* pVertexRemap); < 563 < 564 // These methods enable the modification of the vertex layout of the vertice < 565 HRESULT SetFVF(DWORD FVF); < 566 HRESULT SetDeclaration(D3DVERTEXELEMENT9 *pDeclaration); < 567 DWORD GetFVF(); < 568 HRESULT GetDeclaration(D3DVERTEXELEMENT9[MAX_FVF_DECL_SIZE] Declaration); < 569 < 570 // Apply SW skinning based on current pose matrices to the target vertices. < 571 HRESULT UpdateSkinnedMesh( < 572 D3DXMATRIX* pBoneTransforms, < 573 D3DXMATRIX* pBoneInvTransposeTransforms, < 574 LPCVOID pVerticesSrc, < 575 PVOID pVerticesDst); < 576 < 577 // Takes a mesh and returns a new mesh with per vertex blend weights and a b < 578 // table that describes which bones affect which subsets of the mesh < 579 HRESULT ConvertToBlendedMesh( < 580 ID3DXMesh pMesh, < 581 DWORD Options, < 582 DWORD *pAdjacencyIn, < 583 LPDWORD pAdjacencyOut, < 584 DWORD* pFaceRemap, < 585 ID3DXBuffer* ppVertexRemap, < 586 DWORD* pMaxFaceInfl, < 587 DWORD* pNumBoneCombinations, < 588 ID3DXBuffer* ppBoneCombinationTable, < 589 ID3DXMesh* ppMesh); < 590 < 591 // Takes a mesh and returns a new mesh with per vertex blend weights and ind < 592 // and a bone combination table that describes which bones palettes affect w < 593 HRESULT ConvertToIndexedBlendedMesh( < 594 ID3DXMesh pMesh, < 595 DWORD Options, < 596 DWORD paletteSize, < 597 DWORD *pAdjacencyIn, < 598 LPDWORD pAdjacencyOut, < 599 DWORD* pFaceRemap, < 600 ID3DXBuffer* ppVertexRemap, < 601 DWORD* pMaxVertexInfl, < 602 DWORD *pNumBoneCombinations, < 603 ID3DXBuffer* ppBoneCombinationTable, < 604 ID3DXMesh* ppMesh); < 605 } < 606 < 607 interface ID3DXBaseMesh : IUnknown < 608 { < 609 extern(Windows): < 610 < 611 // ID3DXBaseMesh < 612 HRESULT DrawSubset( DWORD AttribId) ; < 613 DWORD GetNumFaces() ; < 614 DWORD GetNumVertices() ; < 615 DWORD GetFVF() ; < 616 HRESULT GetDeclaration( D3DVERTEXELEMENT9[MAX_FVF_DECL_SIZE] Declaration) ; < 617 DWORD GetNumBytesPerVertex() ; < 618 DWORD GetOptions() ; < 619 HRESULT GetDevice( IDirect3DDevice9* ppDevice) ; < 620 HRESULT CloneMeshFVF( DWORD Options, < 621 DWORD FVF, IDirect3DDevice9 pD3DDevice, ID3DXMesh* ppCloneMesh) < 622 HRESULT CloneMesh( DWORD Options, < 623 D3DVERTEXELEMENT9 *pDeclaration, IDirect3DDevice9 pD3DDevice, I < 624 HRESULT GetVertexBuffer( IDirect3DVertexBuffer9* ppVB) ; < 625 HRESULT GetIndexBuffer( IDirect3DIndexBuffer9* ppIB) ; < 626 HRESULT LockVertexBuffer( DWORD Flags, LPVOID *ppData) ; < 627 HRESULT UnlockVertexBuffer() ; < 628 HRESULT LockIndexBuffer( DWORD Flags, LPVOID *ppData) ; < 629 HRESULT UnlockIndexBuffer() ; < 630 HRESULT GetAttributeTable( < 631 D3DXATTRIBUTERANGE *pAttribTable, DWORD* pAttribTableSize) ; < 632 < 633 HRESULT ConvertPointRepsToAdjacency( DWORD* pPRep, DWORD* pAdjacency) ; < 634 HRESULT ConvertAdjacencyToPointReps( DWORD* pAdjacency, DWORD* pPRep) ; < 635 HRESULT GenerateAdjacency( FLOAT Epsilon, DWORD* pAdjacency) ; < 636 < 637 HRESULT UpdateSemantics( D3DVERTEXELEMENT9[MAX_FVF_DECL_SIZE] Declaration) ; < 638 } < 639 < 640 interface ID3DXMesh : ID3DXBaseMesh < 641 { < 642 extern(Windows): < 643 < 644 // ID3DXMesh < 645 HRESULT LockAttributeBuffer( DWORD Flags, DWORD** ppData) ; < 646 HRESULT UnlockAttributeBuffer() ; < 647 HRESULT Optimize( DWORD Flags, DWORD* pAdjacencyIn, DWORD* pAdjacencyOut, < 648 DWORD* pFaceRemap, ID3DXBuffer *ppVertexRemap, < 649 ID3DXMesh* ppOptMesh) ; < 650 HRESULT OptimizeInplace( DWORD Flags, DWORD* pAdjacencyIn, DWORD* pAdjacenc < 651 DWORD* pFaceRemap, ID3DXBuffer *ppVertexRemap) ; < 652 HRESULT SetAttributeTable( D3DXATTRIBUTERANGE *pAttribTable, DWORD cAttribT < 653 } < 654 < 655 interface ID3DXBuffer : IUnknown < 656 { < 657 extern(Windows): < 658 < 659 // ID3DXBuffer < 660 LPVOID GetBufferPointer(); < 661 DWORD GetBufferSize(); < 662 } < 663 < 664 interface ID3DXPMesh : ID3DXBaseMesh < 665 { < 666 extern(Windows): < 667 < 668 // ID3DXPMesh < 669 HRESULT ClonePMeshFVF( DWORD Options, < 670 DWORD FVF, IDirect3DDevice9 pD3DDevice, ID3DXPMesh* ppCloneMesh) < 671 HRESULT ClonePMesh( DWORD Options, < 672 D3DVERTEXELEMENT9 *pDeclaration, IDirect3DDevice9 pD3DDevice, I < 673 HRESULT SetNumFaces( DWORD Faces) ; < 674 HRESULT SetNumVertices( DWORD Vertices) ; < 675 DWORD GetMaxFaces() ; < 676 DWORD GetMinFaces() ; < 677 DWORD GetMaxVertices() ; < 678 DWORD GetMinVertices() ; < 679 HRESULT Save( void *pStream, D3DXMATERIAL* pMaterials, D3DXEFFECTINSTANCE* < 680 < 681 HRESULT Optimize( DWORD Flags, DWORD* pAdjacencyOut, < 682 DWORD* pFaceRemap, ID3DXBuffer *ppVertexRemap, < 683 ID3DXMesh* ppOptMesh) ; < 684 < 685 HRESULT OptimizeBaseLOD( DWORD Flags, DWORD* pFaceRemap) ; < 686 HRESULT TrimByFaces( DWORD NewFacesMin, DWORD NewFacesMax, DWORD *rgiFaceRem < 687 HRESULT TrimByVertices( DWORD NewVerticesMin, DWORD NewVerticesMax, DWORD *r < 688 < 689 HRESULT GetAdjacency( DWORD* pAdjacency) ; < 690 < 691 // Used to generate the immediate "ancestor" for each vertex when it is rem < 692 // Vertex buffer must be equal to or greater than the maximum number of < 693 HRESULT GenerateVertexHistory( DWORD* pVertexHistory) ; < 694 } < 695 < 696 interface ID3DXPatchMesh : IUnknown < 697 { < 698 extern(Windows): < 699 < 700 // ID3DXPatchMesh < 701 < 702 // Return creation parameters < 703 DWORD GetNumPatches() ; < 704 DWORD GetNumVertices() ; < 705 HRESULT GetDeclaration( D3DVERTEXELEMENT9[MAX_FVF_DECL_SIZE] Declaration) ; < 706 DWORD GetControlVerticesPerPatch() ; < 707 DWORD GetOptions() ; < 708 HRESULT GetDevice( IDirect3DDevice9 *ppDevice) ; < 709 HRESULT GetPatchInfo( D3DXPATCHINFO* PatchInfo) ; < 710 < 711 // Control mesh access < 712 HRESULT GetVertexBuffer( IDirect3DVertexBuffer9* ppVB) ; < 713 HRESULT GetIndexBuffer( IDirect3DIndexBuffer9* ppIB) ; < 714 HRESULT LockVertexBuffer( DWORD flags, LPVOID *ppData) ; < 715 HRESULT UnlockVertexBuffer() ; < 716 HRESULT LockIndexBuffer( DWORD flags, LPVOID *ppData) ; < 717 HRESULT UnlockIndexBuffer() ; < 718 HRESULT LockAttributeBuffer( DWORD flags, DWORD** ppData) ; < 719 HRESULT UnlockAttributeBuffer() ; < 720 < 721 // function returns the size of the tessellated mesh given a tessellation l < 722 // assumes uniform tessellation. For adaptive tessellation the Adaptive par < 723 // be set to TRUE and TessellationLevel should be the max tessellation. < 724 // will result in the max mesh size necessary for adaptive tessellation. < 725 HRESULT GetTessSize( FLOAT fTessLevel,DWORD Adaptive, DWORD *NumTriangles,DW < 726 < 727 //GenerateAdjacency determines which patches are adjacent with provided tole < 728 // information is used internally to optimize tessellation < 729 HRESULT GenerateAdjacency( FLOAT Tolerance) ; < 730 < 731 //CloneMesh Creates a new patchmesh with the specified decl, and converts th < 732 //to the new decl. Entries in the new decl which are new are set to 0. If th < 733 //has adjacency, the new mesh will also have adjacency < 734 HRESULT CloneMesh( DWORD Options, D3DVERTEXELEMENT9 *pDecl, ID3DXPatchMesh < 735 < 736 // Optimizes the patchmesh for efficient tessellation. function is designed < 737 // to perform one time optimization for patch meshes that need to be tessell < 738 // repeatedly by calling the Tessellate() method. The optimization performed < 739 // independent of the actual tessellation level used. < 740 // Currently Flags is unused. < 741 // If vertices are changed, Optimize must be called again < 742 HRESULT Optimize( DWORD flags) ; < 743 < 744 //gets and sets displacement parameters < 745 //displacement maps can only be 2D textures MIP-MAPPING is ignored for non a < 746 HRESULT SetDisplaceParam( IDirect3DBaseTexture9 Texture, < 747 D3DTEXTUREFILTERTYPE MinFilter, < 748 D3DTEXTUREFILTERTYPE MagFilter, < 749 D3DTEXTUREFILTERTYPE MipFilter, < 750 D3DTEXTUREADDRESS Wrap, < 751 DWORD dwLODBias) ; < 752 < 753 HRESULT GetDisplaceParam( IDirect3DBaseTexture9 *Texture, < 754 D3DTEXTUREFILTERTYPE *MinFilter, < 755 D3DTEXTUREFILTERTYPE *MagFilter, < 756 D3DTEXTUREFILTERTYPE *MipFilter, < 757 D3DTEXTUREADDRESS *Wrap, < 758 DWORD *dwLODBias) ; < 759 < 760 // Performs the uniform tessellation based on the tessellation level. < 761 // function will perform more efficiently if the patch mesh has been optimi < 762 HRESULT Tessellate( FLOAT fTessLevel,ID3DXMesh pMesh) ; < 763 < 764 // Performs adaptive tessellation based on the Z based adaptive tessellation < 765 // pTrans specifies a 4D vector that is dotted with the vertices to get the < 766 // adaptive tessellation amount. Each edge is tessellated to the average of < 767 // at the 2 vertices it connects. < 768 // MaxTessLevel specifies the upper limit for adaptive tesselation. < 769 // function will perform more efficiently if the patch mesh has been optimi < 770 HRESULT TessellateAdaptive( < 771 D3DXVECTOR4 *pTrans, < 772 DWORD dwMaxTessLevel, < 773 DWORD dwMinTessLevel, < 774 ID3DXMesh pMesh) ; < 775 < 776 } < 777 < 778 interface ID3DXFont : IUnknown < 779 { < 780 extern(Windows): < 781 < 782 // ID3DXFont < 783 HRESULT GetDevice( IDirect3DDevice9 *ppDevice) ; < 784 HRESULT GetDescA( D3DXFONT_DESCA *pDesc) ; < 785 HRESULT GetDescW( D3DXFONT_DESCW *pDesc) ; < 786 BOOL GetTextMetricsA( TEXTMETRICA *pTextMetrics) ; < 787 BOOL GetTextMetricsW( TEXTMETRICW *pTextMetrics) ; < 788 < 789 HDC GetDC() ; < 790 HRESULT GetGlyphData( UINT Glyph, IDirect3DTexture9 *ppTexture, RECT *pBlack < 791 < 792 HRESULT PreloadCharacters( UINT First, UINT Last) ; < 793 HRESULT PreloadGlyphs( UINT First, UINT Last) ; < 794 HRESULT PreloadTextA( LPCSTR pString, INT Count) ; < 795 HRESULT PreloadTextW( LPCWSTR pString, INT Count) ; < 796 < 797 INT DrawTextA( ID3DXSprite pSprite, LPCSTR pString, INT Count, LPRECT pRect, < 798 INT DrawTextW( ID3DXSprite pSprite, LPCWSTR pString, INT Count, LPRECT pRect < 799 < 800 HRESULT OnLostDevice() ; < 801 HRESULT OnResetDevice() ; < 802 } < 803 < 804 interface ID3DXSprite : IUnknown < 805 { < 806 extern(Windows): < 807 < 808 // ID3DXSprite < 809 HRESULT GetDevice( IDirect3DDevice9* ppDevice) ; < 810 < 811 HRESULT GetTransform( D3DXMATRIX *pTransform) ; < 812 HRESULT SetTransform( D3DXMATRIX *pTransform) ; < 813 < 814 HRESULT SetWorldViewRH( D3DXMATRIX *pWorld, D3DXMATRIX *pView) ; < 815 HRESULT SetWorldViewLH( D3DXMATRIX *pWorld, D3DXMATRIX *pView) ; < 816 < 817 HRESULT Begin( DWORD Flags) ; < 818 HRESULT Draw( IDirect3DTexture9 pTexture, RECT *pSrcRect, D3DXVECTOR3 *pCe < 819 HRESULT Flush() ; < 820 HRESULT End() ; < 821 < 822 HRESULT OnLostDevice() ; < 823 HRESULT OnResetDevice() ; < 824 } < 825 < 826 interface ID3DXBaseEffect : IUnknown < 827 { < 828 extern(Windows): < 829 < 830 // Descs < 831 HRESULT GetDesc( D3DXEFFECT_DESC* pDesc) ; < 832 HRESULT GetParameterDesc( D3DXHANDLE hParameter, D3DXPARAMETER_DESC* pDesc) < 833 HRESULT GetTechniqueDesc( D3DXHANDLE hTechnique, D3DXTECHNIQUE_DESC* pDesc) < 834 HRESULT GetPassDesc( D3DXHANDLE hPass, D3DXPASS_DESC* pDesc) ; < 835 HRESULT GetFunctionDesc( D3DXHANDLE hShader, D3DXFUNCTION_DESC* pDesc) ; < 836 < 837 // Handle operations < 838 D3DXHANDLE GetParameter( D3DXHANDLE hParameter, UINT Index) ; < 839 D3DXHANDLE GetParameterByName( D3DXHANDLE hParameter, LPCSTR pName) ; < 840 D3DXHANDLE GetParameterBySemantic( D3DXHANDLE hParameter, LPCSTR pSemantic) < 841 D3DXHANDLE GetParameterElement( D3DXHANDLE hParameter, UINT Index) ; < 842 D3DXHANDLE GetTechnique( UINT Index) ; < 843 D3DXHANDLE GetTechniqueByName( LPCSTR pName) ; < 844 D3DXHANDLE GetPass( D3DXHANDLE hTechnique, UINT Index) ; < 845 D3DXHANDLE GetPassByName( D3DXHANDLE hTechnique, LPCSTR pName) ; < 846 D3DXHANDLE GetFunction( UINT Index) ; < 847 D3DXHANDLE GetFunctionByName( LPCSTR pName) ; < 848 D3DXHANDLE GetAnnotation( D3DXHANDLE hObject, UINT Index) ; < 849 D3DXHANDLE GetAnnotationByName( D3DXHANDLE hObject, LPCSTR pName) ; < 850 < 851 // Get/Set Parameters < 852 HRESULT SetValue( D3DXHANDLE hParameter, LPCVOID pData, UINT Bytes) ; < 853 HRESULT GetValue( D3DXHANDLE hParameter, LPVOID pData, UINT Bytes) ; < 854 HRESULT SetBool( D3DXHANDLE hParameter, BOOL b) ; < 855 HRESULT GetBool( D3DXHANDLE hParameter, BOOL* pb) ; < 856 HRESULT SetBoolArray( D3DXHANDLE hParameter, BOOL* pb, UINT Count) ; < 857 HRESULT GetBoolArray( D3DXHANDLE hParameter, BOOL* pb, UINT Count) ; < 858 HRESULT SetInt( D3DXHANDLE hParameter, INT n) ; < 859 HRESULT GetInt( D3DXHANDLE hParameter, INT* pn) ; < 860 HRESULT SetIntArray( D3DXHANDLE hParameter, INT* pn, UINT Count) ; < 861 HRESULT GetIntArray( D3DXHANDLE hParameter, INT* pn, UINT Count) ; < 862 HRESULT SetFloat( D3DXHANDLE hParameter, FLOAT f) ; < 863 HRESULT GetFloat( D3DXHANDLE hParameter, FLOAT* pf) ; < 864 HRESULT SetFloatArray( D3DXHANDLE hParameter, FLOAT* pf, UINT Count) ; < 865 HRESULT GetFloatArray( D3DXHANDLE hParameter, FLOAT* pf, UINT Count) ; < 866 HRESULT SetVector( D3DXHANDLE hParameter, D3DXVECTOR4* pVector) ; < 867 HRESULT GetVector( D3DXHANDLE hParameter, D3DXVECTOR4* pVector) ; < 868 HRESULT SetVectorArray( D3DXHANDLE hParameter, D3DXVECTOR4* pVector, UINT C < 869 HRESULT GetVectorArray( D3DXHANDLE hParameter, D3DXVECTOR4* pVector, UINT Co < 870 HRESULT SetMatrix( D3DXHANDLE hParameter, D3DXMATRIX* pMatrix) ; < 871 HRESULT GetMatrix( D3DXHANDLE hParameter, D3DXMATRIX* pMatrix) ; < 872 HRESULT SetMatrixArray( D3DXHANDLE hParameter, D3DXMATRIX* pMatrix, UINT Co < 873 HRESULT GetMatrixArray( D3DXHANDLE hParameter, D3DXMATRIX* pMatrix, UINT Cou < 874 HRESULT SetMatrixPointerArray( D3DXHANDLE hParameter, D3DXMATRIX** ppMatrix < 875 HRESULT GetMatrixPointerArray( D3DXHANDLE hParameter, D3DXMATRIX** ppMatrix, < 876 HRESULT SetMatrixTranspose( D3DXHANDLE hParameter, D3DXMATRIX* pMatrix) ; < 877 HRESULT GetMatrixTranspose( D3DXHANDLE hParameter, D3DXMATRIX* pMatrix) ; < 878 HRESULT SetMatrixTransposeArray( D3DXHANDLE hParameter, D3DXMATRIX* pMatrix < 879 HRESULT GetMatrixTransposeArray( D3DXHANDLE hParameter, D3DXMATRIX* pMatrix, < 880 HRESULT SetMatrixTransposePointerArray( D3DXHANDLE hParameter, D3DXMATRIX** < 881 HRESULT GetMatrixTransposePointerArray( D3DXHANDLE hParameter, D3DXMATRIX** < 882 HRESULT SetString( D3DXHANDLE hParameter, LPCSTR pString) ; < 883 HRESULT GetString( D3DXHANDLE hParameter, LPCSTR* ppString) ; < 884 HRESULT SetTexture( D3DXHANDLE hParameter, IDirect3DBaseTexture9 pTexture) ; < 885 HRESULT GetTexture( D3DXHANDLE hParameter, IDirect3DBaseTexture9 *ppTexture) < 886 HRESULT GetPixelShader( D3DXHANDLE hParameter, IDirect3DPixelShader9 *ppPSha < 887 HRESULT GetVertexShader( D3DXHANDLE hParameter, IDirect3DVertexShader9 *ppVS < 888 < 889 //Set Range of an Array to pass to device < 890 //Useful for sending only a subrange of an array down to the device < 891 HRESULT SetArrayRange( D3DXHANDLE hParameter, UINT uStart, UINT uEnd) ; < 892 < 893 } < 894 < 895 interface ID3DXEffect : ID3DXBaseEffect < 896 { < 897 extern(Windows): < 898 < 899 // Pool < 900 HRESULT GetPool( ID3DXEffectPool* ppPool) ; < 901 < 902 // Selecting and setting a technique < 903 HRESULT SetTechnique( D3DXHANDLE hTechnique) ; < 904 D3DXHANDLE GetCurrentTechnique() ; < 905 HRESULT ValidateTechnique( D3DXHANDLE hTechnique) ; < 906 HRESULT FindNextValidTechnique( D3DXHANDLE hTechnique, D3DXHANDLE *pTechniqu < 907 BOOL IsParameterUsed( D3DXHANDLE hParameter, D3DXHANDLE hTechnique) ; < 908 < 909 // Using current technique < 910 // Begin starts active technique < 911 // BeginPass begins a pass < 912 // CommitChanges updates changes to any set calls in the pass. should be < 913 // any DrawPrimitive call to d3d < 914 // EndPass ends a pass < 915 // End ends active technique < 916 HRESULT Begin( UINT *pPasses, DWORD Flags) ; < 917 HRESULT BeginPass( UINT Pass) ; < 918 HRESULT CommitChanges() ; < 919 HRESULT EndPass() ; < 920 HRESULT End() ; < 921 < 922 // Managing D3D Device < 923 HRESULT GetDevice( IDirect3DDevice9* ppDevice) ; < 924 HRESULT OnLostDevice() ; < 925 HRESULT OnResetDevice() ; < 926 < 927 // Logging device calls < 928 HRESULT SetStateManager( ID3DXEffectStateManager pManager) ; < 929 HRESULT GetStateManager( ID3DXEffectStateManager *ppManager) ; < 930 < 931 // Parameter blocks < 932 HRESULT BeginParameterBlock() ; < 933 D3DXHANDLE EndParameterBlock() ; < 934 HRESULT ApplyParameterBlock( D3DXHANDLE hParameterBlock) ; < 935 HRESULT DeleteParameterBlock( D3DXHANDLE hParameterBlock) ; < 936 < 937 // Cloning < 938 HRESULT CloneEffect( IDirect3DDevice9 pDevice, ID3DXEffect* ppEffect) ; < 939 } < 940 < 941 interface ID3DXEffectPool : IUnknown < 942 { < 943 extern(Windows): < 944 < 945 // No public methods < 946 } < 947 < 948 interface ID3DXEffectStateManager : IUnknown < 949 { < 950 extern(Windows): < 951 < 952 // The following methods are called by the Effect when it wants to make < 953 // the corresponding device call. Note that: < 954 // 1. Users manage the state and are therefore responsible for making the < 955 // the corresponding device calls themselves inside their callbacks. < 956 // 2. Effects pay attention to the return values of the callbacks, and so < 957 // users must pay attention to what they return in their callbacks. < 958 < 959 HRESULT SetTransform( D3DTRANSFORMSTATETYPE State, D3DMATRIX *pMatrix) ; < 960 HRESULT SetMaterial( D3DMATERIAL9 *pMaterial) ; < 961 HRESULT SetLight( DWORD Index, D3DLIGHT9 *pLight) ; < 962 HRESULT LightEnable( DWORD Index, BOOL Enable) ; < 963 HRESULT SetRenderState( D3DRENDERSTATETYPE State, DWORD Value) ; < 964 HRESULT SetTexture( DWORD Stage, IDirect3DBaseTexture9 pTexture) ; < 965 HRESULT SetTextureStageState( DWORD Stage, D3DTEXTURESTAGESTATETYPE Type, DW < 966 HRESULT SetSamplerState( DWORD Sampler, D3DSAMPLERSTATETYPE Type, DWORD Valu < 967 HRESULT SetNPatchMode( FLOAT NumSegments) ; < 968 HRESULT SetFVF( DWORD FVF) ; < 969 HRESULT SetVertexShader( IDirect3DVertexShader9 pShader) ; < 970 HRESULT SetVertexShaderConstantF( UINT RegisterIndex, FLOAT *pConstantData, < 971 HRESULT SetVertexShaderConstantI( UINT RegisterIndex, INT *pConstantData, U < 972 HRESULT SetVertexShaderConstantB( UINT RegisterIndex, BOOL *pConstantData, < 973 HRESULT SetPixelShader( IDirect3DPixelShader9 pShader) ; < 974 HRESULT SetPixelShaderConstantF( UINT RegisterIndex, FLOAT *pConstantData, < 975 HRESULT SetPixelShaderConstantI( UINT RegisterIndex, INT *pConstantData, UI < 976 HRESULT SetPixelShaderConstantB( UINT RegisterIndex, BOOL *pConstantData, U < 977 } < 978 < 979 interface ID3DXInclude < 980 { < 981 HRESULT Open(D3DXINCLUDE_TYPE IncludeType, LPCSTR pFileName, LPCVOID pParent < 982 HRESULT Close(LPCVOID pData); < 983 } < 984 < 985 // D3DX Functions -------------------------------------------------------------- < 986 extern(Windows) < 987 { < 988 uint D3DXGetShaderVersion(uint* pFunction); < 989 < 990 HRESULT D3DXCheckTextureRequirements( < 991 IDirect3DDevice9 pDevice, < 992 UINT* pWidth, < 993 UINT* pHeight, < 994 UINT* pNumMipLevels, < 995 DWORD Usage, < 996 D3DFORMAT* pFormat, < 997 D3DPOOL Pool) ; < 998 < 999 HRESULT D3DXCreateTexture( < 1000 IDirect3DDevice9 pDevice, < 1001 UINT Width, < 1002 UINT Height, < 1003 UINT MipLevels, < 1004 DWORD Usage, < 1005 D3DFORMAT Format, < 1006 D3DPOOL Pool, < 1007 IDirect3DTexture9* ppTexture); < 1008 < 1009 HRESULT D3DXCreateCubeTexture( < 1010 IDirect3DDevice9 pDevice, < 1011 UINT Size, < 1012 UINT MipLevels, < 1013 DWORD Usage, < 1014 D3DFORMAT Format, < 1015 D3DPOOL Pool, < 1016 IDirect3DCubeTexture9* ppCubeTexture); < 1017 < 1018 HRESULT D3DXCreateTextureFromFileA( < 1019 LPDIRECT3DDEVICE9 pDevice, < 1020 LPCTSTR pSrcFile, < 1021 LPDIRECT3DTEXTURE9 * ppTexture); < 1022 < 1023 HRESULT D3DXCreateTextureFromFileExA( < 1024 IDirect3DDevice9 pDevice, < 1025 LPCSTR pSrcFile, < 1026 UINT Width, < 1027 UINT Height, < 1028 UINT MipLevels, < 1029 DWORD Usage, < 1030 D3DFORMAT Format, < 1031 D3DPOOL Pool, < 1032 DWORD Filter, < 1033 DWORD MipFilter, < 1034 D3DCOLOR ColorKey, < 1035 D3DXIMAGE_INFO* pSrcInfo, < 1036 PALETTEENTRY* pPalette, < 1037 IDirect3DTexture9* ppTexture); < 1038 < 1039 HRESULT D3DXCreateCubeTextureFromFileExA( < 1040 IDirect3DDevice9 pDevice, < 1041 LPCSTR pSrcFile, < 1042 UINT Size, < 1043 UINT MipLevels, < 1044 DWORD Usage, < 1045 D3DFORMAT Format, < 1046 D3DPOOL Pool, < 1047 DWORD Filter, < 1048 DWORD MipFilter, < 1049 D3DCOLOR ColorKey, < 1050 D3DXIMAGE_INFO* pSrcInfo, < 1051 PALETTEENTRY* pPalette, < 1052 IDirect3DCubeTexture9* ppCubeTexture); < 1053 < 1054 HRESULT D3DXSimplifyMesh( < 1055 ID3DXMesh pMesh, < 1056 DWORD* pAdjacency, < 1057 D3DXATTRIBUTEWEIGHTS *pVertexAttributeWeights, < 1058 FLOAT *pVertexWeights, < 1059 DWORD MinValue, < 1060 DWORD Options, < 1061 ID3DXMesh* ppMesh); < 1062 < 1063 HRESULT D3DXCreateSkinInfoFVF( < 1064 DWORD NumVertices, < 1065 DWORD FVF, < 1066 DWORD NumBones, < 1067 ID3DXSkinInfo* ppSkinInfo); < 1068 < 1069 D3DXVECTOR2* D3DXVec2TransformCoord( D3DXVECTOR2 *pOut, D3DXVECTOR2 *pV, < 1070 < 1071 D3DXVECTOR4* D3DXVec3Transform( D3DXVECTOR4 *pOut, D3DXVECTOR3 *pV, D3DX < 1072 < 1073 D3DXVECTOR3* D3DXVec3TransformCoord( D3DXVECTOR3 *pOut, D3DXVECTOR3 *pV, < 1074 < 1075 D3DXVECTOR4* D3DXVec4Transform( D3DXVECTOR4 *pOut, D3DXVECTOR4 *pV, D3DX < 1076 < 1077 D3DXMATRIX* D3DXMatrixTranspose( D3DXMATRIX *pOut, D3DXMATRIX *pM ); < 1078 < 1079 D3DXMATRIX* D3DXMatrixMultiply( D3DXMATRIX *pOut, D3DXMATRIX *pM1, D3DXM < 1080 < 1081 D3DXMATRIX* D3DXMatrixInverse( D3DXMATRIX *pOut, FLOAT *pDeterminant, D3 < 1082 < 1083 D3DXMATRIX* D3DXMatrixScaling( D3DXMATRIX *pOut, FLOAT sx, FLOAT sy, FLO < 1084 < 1085 D3DXMATRIX* D3DXMatrixTranslation( D3DXMATRIX *pOut, FLOAT x, FLOAT y, F < 1086 < 1087 D3DXMATRIX* D3DXMatrixRotationX( D3DXMATRIX *pOut, FLOAT Angle ); < 1088 < 1089 D3DXMATRIX* D3DXMatrixRotationY( D3DXMATRIX *pOut, FLOAT Angle ); < 1090 < 1091 D3DXMATRIX* D3DXMatrixRotationZ( D3DXMATRIX *pOut, FLOAT Angle ); < 1092 < 1093 D3DXMATRIX* D3DXMatrixRotationQuaternion( D3DXMATRIX *pOut, D3DXQUATERNI < 1094 < 1095 D3DXMATRIX* D3DXMatrixRotationYawPitchRoll( D3DXMATRIX *pOut, FLOAT Yaw, < 1096 < 1097 D3DXMATRIX* D3DXMatrixAffineTransformation2D( D3DXMATRIX *pOut, FLOAT Sc < 1098 float Rotation, D3DXVECTOR2 *pTranslation); < 1099 < 1100 D3DXMATRIX* D3DXMatrixPerspectiveFovLH( D3DXMATRIX *pOut, FLOAT fovy, FL < 1101 < 1102 D3DXMATRIX* D3DXMatrixOrthoLH( D3DXMATRIX *pOut, FLOAT w, FLOAT h, FLOAT < 1103 < 1104 D3DXMATRIX* D3DXMatrixOrthoOffCenterLH( D3DXMATRIX *pOut, FLOAT l, FLOAT < 1105 FLOAT zf ); < 1106 < 1107 void D3DXQuaternionToAxisAngle( D3DXQUATERNION *pQ, D3DXVECTOR3 *pAxis, < 1108 < 1109 D3DXQUATERNION* D3DXQuaternionRotationMatrix( D3DXQUATERNION *pOut, D3DX < 1110 < 1111 D3DXQUATERNION* D3DXQuaternionNormalize( D3DXQUATERNION *pOut, D3DXQUATE < 1112 < 1113 D3DXPLANE* D3DXPlaneNormalize( D3DXPLANE *pOut, D3DXPLANE *pP); < 1114 < 1115 char* DXGetErrorDescription9A(HRESULT hr); < 1116 < 1117 HRESULT D3DXCreateEffectFromFileA( < 1118 IDirect3DDevice9 pDevice, < 1119 LPCSTR pSrcFile, < 1120 D3DXMACRO* pDefines, < 1121 ID3DXInclude pInclude, < 1122 DWORD Flags, < 1123 ID3DXEffectPool pPool, < 1124 ID3DXEffect* ppEffect, < 1125 ID3DXBuffer* ppCompilationErrors); < 1126 < 1127 D3DXMATRIX* D3DXMatrixTransformation2D( D3DXMATRIX *pOut, D3DXVECTOR2 *p < 1128 float *pScalingRotation, D3DXVECTOR2 *pScaling, < 1129 D3DXVECTOR2 *pRotationCenter, float Rotation, < 1130 D3DXVECTOR2 *pTranslation); < 1131 < 1132 HRESULT D3DXLoadMeshFromXA( < 1133 LPCSTR pFilename, < 1134 DWORD Options, < 1135 IDirect3DDevice9 pD3D, < 1136 ID3DXBuffer *ppAdjacency, < 1137 ID3DXBuffer *ppMaterials, < 1138 ID3DXBuffer *ppEffectInstances, < 1139 DWORD *pNumMaterials, < 1140 ID3DXMesh *ppMesh); < 1141 < 1142 HRESULT D3DXCreatePolygon( < 1143 IDirect3DDevice9 pDevice, < 1144 FLOAT Length, < 1145 UINT Sides, < 1146 ID3DXMesh* ppMesh, < 1147 ID3DXBuffer* ppAdjacency); < 1148 < 1149 HRESULT D3DXCreateBox( < 1150 IDirect3DDevice9 pDevice, < 1151 FLOAT Width, < 1152 FLOAT Height, < 1153 FLOAT Depth, < 1154 ID3DXMesh* ppMesh, < 1155 ID3DXBuffer* ppAdjacency); < 1156 < 1157 HRESULT D3DXCreateCylinder( < 1158 IDirect3DDevice9 pDevice, < 1159 FLOAT Radius1, < 1160 FLOAT Radius2, < 1161 FLOAT Length, < 1162 UINT Slices, < 1163 UINT Stacks, < 1164 ID3DXMesh* ppMesh, < 1165 ID3DXBuffer* ppAdjacency); < 1166 < 1167 HRESULT D3DXCreateSphere( < 1168 IDirect3DDevice9 pDevice, < 1169 FLOAT Radius, < 1170 UINT Slices, < 1171 UINT Stacks, < 1172 ID3DXMesh* ppMesh, < 1173 ID3DXBuffer* ppAdjacency); < 1174 < 1175 HRESULT D3DXCreateTorus( < 1176 IDirect3DDevice9 pDevice, < 1177 FLOAT InnerRadius, < 1178 FLOAT OuterRadius, < 1179 UINT Sides, < 1180 UINT Rings, < 1181 ID3DXMesh* ppMesh, < 1182 ID3DXBuffer* ppAdjacency); < 1183 < 1184 HRESULT D3DXCreateTeapot( < 1185 IDirect3DDevice9 pDevice, < 1186 ID3DXMesh* ppMesh, < 1187 ID3DXBuffer* ppAdjacency); < 1188 < 1189 HRESULT D3DXCreateFontA( < 1190 IDirect3DDevice9 pDevice, < 1191 UINT Height, < 1192 UINT Width, < 1193 UINT Weight, < 1194 UINT MipLevels, < 1195 BOOL Italic, < 1196 DWORD CharSet, < 1197 DWORD OutputPrecision, < 1198 DWORD Quality, < 1199 DWORD PitchAndFamily, < 1200 LPCTSTR pFacename, < 1201 ID3DXFont *ppFont); < 1202 < 1203 HRESULT D3DXCreateSprite( < 1204 IDirect3DDevice9 pDevice, < 1205 ID3DXSprite* ppSprite) ; < 1206 < 1207 HRESULT D3DXCreateEffect( < 1208 IDirect3DDevice9 pDevice, < 1209 LPCVOID pSrcData, < 1210 UINT SrcDataLen, < 1211 D3DXMACRO* pDefines, < 1212 ID3DXInclude pInclude, < 1213 DWORD Flags, < 1214 ID3DXEffectPool pPool, < 1215 ID3DXEffect* ppEffect, < 1216 ID3DXBuffer* ppCompilationErrors); < 1217 < 1218 HRESULT D3DXCreateEffectPool( < 1219 ID3DXEffectPool* pEffectPool); < 1220 < 1221 HRESULT D3DXGetShaderInputSemantics( < 1222 DWORD* pFunction, < 1223 D3DXSEMANTIC* pSemantics, < 1224 UINT* pCount); < 1225 < 1226 HRESULT < 1227 D3DXCreateMeshFVF( < 1228 DWORD NumFaces, < 1229 DWORD NumVertices, < 1230 DWORD Options, < 1231 DWORD FVF, < 1232 IDirect3DDevice9 pD3DDevice, < 1233 ID3DXMesh* ppMesh); < 1234 < 1235 UINT D3DXGetFVFVertexSize(DWORD FVF); < 1236 < 1237 HRESULT D3DXFileCreate(ID3DXFile* lplpDirectXFile); < 1238 < 1239 HRESULT D3DXLoadMeshFromXof( < 1240 ID3DXFileData pxofMesh, < 1241 DWORD Options, < 1242 IDirect3DDevice9 pD3DDevice, < 1243 ID3DXBuffer *ppAdjacency, < 1244 ID3DXBuffer *ppMaterials, < 1245 ID3DXBuffer *ppEffectInstances, < 1246 DWORD *pNumMaterials, < 1247 ID3DXMesh *ppMesh); < 1248 < 1249 HRESULT D3DXConcatenateMeshes( < 1250 ID3DXMesh * ppMeshes, < 1251 UINT NumMeshes, < 1252 DWORD Options, < 1253 D3DXMATRIX * pGeomXForms, < 1254 D3DXMATRIX * pTextureXForms, < 1255 D3DVERTEXELEMENT9 * pDecl, < 1256 IDirect3DDevice9 pD3DDevice, < 1257 ID3DXMesh * ppMeshOut); < 1258 < 1259 HRESULT D3DXDeclaratorFromFVF(DWORD FVF, D3DVERTEXELEMENT9* Declaration) < 1260 < 1261 D3DXQUATERNION* D3DXQuaternionSlerp(D3DXQUATERNION* pOut, D3DXQUATERNION < 1262 < 1263 D3DXVECTOR3* D3DXVec3CatmullRom(D3DXVECTOR3 *pOut, D3DXVECTOR3 *pV0, D3D < 1264 < 1265 void D3DXQuaternionSquadSetup( D3DXQUATERNION *pAOut, < 1266 D3DXQUATERNI < 1267 D3DXQUATERNI < 1268 D3DXQUATERNI < 1269 D3DXQUATERNI < 1270 D3DXQUATERNI < 1271 D3DXQUATERNI < 1272 < 1273 D3DXQUATERNION* D3DXQuaternionSquad(D3DXQUATERNION *pOut, < 1274 D3DX < 1275 D3DX < 1276 D3DX < 1277 D3DX < 1278 floa < 1279 < 1280 HRESULT D3DXMatrixDecompose(D3DXVECTOR3 *pOutScale, < 1281 D3DXQUATERNION *pOut < 1282 D3DXVECTOR3 *pOutTra < 1283 D3DXMATRIX *pM < 1284 ); < 1285 < 1286 D3DXQUATERNION* D3DXQuaternionRotationYawPitchRoll(D3DXQUATERNION *pOut, < 1287 < 1288 < 1289 < 1290 < 1291 < 1292 UINT D3DXGetDeclVertexSize(D3DVERTEXELEMENT9 *pDecl, DWORD Stream ); < 1293 } // extern(Windows) < 1294 < 1295 D3DXMATRIX* D3DXMatrixIdentity( D3DXMATRIX *pOut ) < 1296 { < 1297 pOut.m[0][1] = pOut.m[0][2] = pOut.m[0][3] = < 1298 pOut.m[1][0] = pOut.m[1][2] = pOut.m[1][3] = < 1299 pOut.m[2][0] = pOut.m[2][1] = pOut.m[2][3] = < 1300 pOut.m[3][0] = pOut.m[3][1] = pOut.m[3][2] = 0.0f; < 1301 < 1302 pOut.m[0][0] = pOut.m[1][1] = pOut.m[2][2] = pOut.m[3][3] = 1.0f; < 1303 return pOut; < 1304 } < 1305 < 1306 FLOAT D3DXVec3LengthSq(D3DXVECTOR3* v) < 1307 { < 1308 return (v.x * v.x) + (v.y * v.y) + (v.z * v.z); < 1309 } < 1310 < 1311 template DEFINE_GUID(uint d1, ushort d2, ushort d3, ubyte d4, ubyte d5, ubyte d6 < 1312 { < 1313 const GUID DEFINE_GUID = {d1, d2, d3, [d4, d5, d6, d7, d8, d9, d10, d11] < 1314 } < 1315 < 1316 const GUID TID_D3DRMInfo = DEFINE_GUID!(0x2b957100, 0x9e9a, 0x11cf, 0xab, 0x39, < 1317 const GUID TID_D3DRMMesh = DEFINE_GUID!(0x3d82ab44, 0x62da, 0x11cf, 0xab, 0x39, < 1318 const GUID TID_D3DRMVector = DEFINE_GUID!(0x3d82ab5e, 0x62da, 0x11cf, 0xab, 0x39 < 1319 const GUID TID_D3DRMMeshFace = DEFINE_GUID!(0x3d82ab5f, 0x62da, 0x11cf, 0xab, 0x < 1320 const GUID TID_D3DRMMaterial = DEFINE_GUID!(0x3d82ab4d, 0x62da, 0x11cf, 0xab, 0x < 1321 const GUID TID_D3DRMMaterialArray = DEFINE_GUID!(0x35ff44e1, 0x6c7c, 0x11cf, 0x8 < 1322 const GUID TID_D3DRMFrame = DEFINE_GUID!(0x3d82ab46, 0x62da, 0x11cf, 0xab, 0x39, < 1323 const GUID TID_D3DRMFrameTransformMatrix = DEFINE_GUID!(0xf6f23f41, 0x7686, 0x11 < 1324 const GUID TID_D3DRMMeshMaterialList = DEFINE_GUID!(0xf6f23f42, 0x7686, 0x11cf, < 1325 const GUID TID_D3DRMMeshTextureCoords = DEFINE_GUID!(0xf6f23f40, 0x7686, 0x11cf, < 1326 const GUID TID_D3DRMMeshNormals = DEFINE_GUID!(0xf6f23f43, 0x7686, 0x11cf, 0x8f, < 1327 const GUID TID_D3DRMCoords2d = DEFINE_GUID!(0xf6f23f44, 0x7686, 0x11cf, 0x8f, 0x < 1328 const GUID TID_D3DRMMatrix4x4 = DEFINE_GUID!(0xf6f23f45, 0x7686, 0x11cf, 0x8f, 0 < 1329 const GUID TID_D3DRMAnimation = DEFINE_GUID!(0x3d82ab4f, 0x62da, 0x11cf, 0xab, 0 < 1330 const GUID TID_D3DRMAnimationSet = DEFINE_GUID!(0x3d82ab50, 0x62da, 0x11cf, 0xab < 1331 const GUID TID_D3DRMAnimationKey = DEFINE_GUID!(0x10dd46a8, 0x775b, 0x11cf, 0x8f < 1332 const GUID TID_D3DRMFloatKeys = DEFINE_GUID!(0x10dd46a9, 0x775b, 0x11cf, 0x8f, 0 < 1333 const GUID TID_D3DRMMaterialAmbientColor = DEFINE_GUID!(0x01411840, 0x7786, 0x11 < 1334 const GUID TID_D3DRMMaterialDiffuseColor = DEFINE_GUID!(0x01411841, 0x7786, 0x11 < 1335 const GUID TID_D3DRMMaterialSpecularColor = DEFINE_GUID!(0x01411842, 0x7786, 0x1 < 1336 const GUID TID_D3DRMMaterialEmissiveColor = DEFINE_GUID!(0xd3e16e80, 0x7835, 0x1 < 1337 const GUID TID_D3DRMMaterialPower = DEFINE_GUID!(0x01411843, 0x7786, 0x11cf, 0x8 < 1338 const GUID TID_D3DRMColorRGBA = DEFINE_GUID!(0x35ff44e0, 0x6c7c, 0x11cf, 0x8f, 0 < 1339 const GUID TID_D3DRMColorRGB = DEFINE_GUID!(0xd3e16e81, 0x7835, 0x11cf, 0x8f, 0x < 1340 const GUID TID_D3DRMGuid = DEFINE_GUID!(0xa42790e0, 0x7810, 0x11cf, 0x8f, 0x52, < 1341 const GUID TID_D3DRMTextureFilename = DEFINE_GUID!(0xa42790e1, 0x7810, 0x11cf, 0 < 1342 const GUID TID_D3DRMTextureReference = DEFINE_GUID!(0xa42790e2, 0x7810, 0x11cf, < 1343 const GUID TID_D3DRMIndexedColor = DEFINE_GUID!(0x1630b820, 0x7842, 0x11cf, 0x8f < 1344 const GUID TID_D3DRMMeshVertexColors = DEFINE_GUID!(0x1630b821, 0x7842, 0x11cf, < 1345 const GUID TID_D3DRMMaterialWrap = DEFINE_GUID!(0x4885ae60, 0x78e8, 0x11cf, 0x8f < 1346 const GUID TID_D3DRMBoolean = DEFINE_GUID!(0x537da6a0, 0xca37, 0x11d0, 0x94, 0x1 < 1347 const GUID TID_D3DRMMeshFaceWraps = DEFINE_GUID!(0xed1ec5c0, 0xc0a8, 0x11d0, 0x9 < 1348 const GUID TID_D3DRMBoolean2d = DEFINE_GUID!(0x4885ae63, 0x78e8, 0x11cf, 0x8f, 0 < 1349 const GUID TID_D3DRMTimedFloatKeys = DEFINE_GUID!(0xf406b180, 0x7b3b, 0x11cf, 0x < 1350 const GUID TID_D3DRMAnimationOptions = DEFINE_GUID!(0xe2bf56c0, 0x840f, 0x11cf, < 1351 const GUID TID_D3DRMFramePosition = DEFINE_GUID!(0xe2bf56c1, 0x840f, 0x11cf, 0x8 < 1352 const GUID TID_D3DRMFrameVelocity = DEFINE_GUID!(0xe2bf56c2, 0x840f, 0x11cf, 0x8 < 1353 const GUID TID_D3DRMFrameRotation = DEFINE_GUID!(0xe2bf56c3, 0x840f, 0x11cf, 0x8 < 1354 const GUID TID_D3DRMLight = DEFINE_GUID!(0x3d82ab4a, 0x62da, 0x11cf, 0xab, 0x39, < 1355 const GUID TID_D3DRMCamera = DEFINE_GUID!(0x3d82ab51, 0x62da, 0x11cf, 0xab, 0x39 < 1356 const GUID TID_D3DRMAppData = DEFINE_GUID!(0xe5745280, 0xb24f, 0x11cf, 0x9d, 0xd < 1357 const GUID TID_D3DRMLightUmbra = DEFINE_GUID!(0xaed22740, 0xb31f, 0x11cf, 0x9d, < 1358 const GUID TID_D3DRMLightRange = DEFINE_GUID!(0xaed22742, 0xb31f, 0x11cf, 0x9d, < 1359 const GUID TID_D3DRMLightPenumbra = DEFINE_GUID!(0xaed22741, 0xb31f, 0x11cf, 0x9 < 1360 const GUID TID_D3DRMLightAttenuation = DEFINE_GUID!(0xa8a98ba0, 0xc5e5, 0x11cf, < 1361 const GUID TID_D3DRMInlineData = DEFINE_GUID!(0x3a23eea0, 0x94b1, 0x11d0, 0xab, < 1362 const GUID TID_D3DRMUrl = DEFINE_GUID!(0x3a23eea1, 0x94b1, 0x11d0, 0xab, 0x39, 0 < 1363 const GUID TID_D3DRMProgressiveMesh = DEFINE_GUID!(0x8A63C360, 0x997D, 0x11d0, 0 < 1364 const GUID TID_D3DRMExternalVisual = DEFINE_GUID!(0x98116AA0, 0xBDBA, 0x11d1, 0x < 1365 const GUID TID_D3DRMStringProperty = DEFINE_GUID!(0x7f0f21e0, 0xbfe1, 0x11d1, 0x < 1366 const GUID TID_D3DRMPropertyBag = DEFINE_GUID!(0x7f0f21e1, 0xbfe1, 0x11d1, 0x82, < 1367 const GUID TID_D3DRMRightHanded = DEFINE_GUID!(0x7f5d5ea0, 0xd53a, 0x11d1, 0x82, < 1368 < 1369 ubyte[] D3DRM_XTEMPLATES = < 1370 [ < 1371 0x78, 0x6f, 0x66, 0x20, 0x30, 0x33, 0x30, 0x32, 0x62, < 1372 0x69, 0x6e, 0x20, 0x30, 0x30, 0x36, 0x34, 0x1f, 0, 0x1, < 1373 0, 0x6, 0, 0, 0, 0x48, 0x65, 0x61, 0x64, 0x65, < 1374 0x72, 0xa, 0, 0x5, 0, 0x43, 0xab, 0x82, 0x3d, 0xda, < 1375 0x62, 0xcf, 0x11, 0xab, 0x39, 0, 0x20, 0xaf, 0x71, 0xe4, < 1376 0x33, 0x28, 0, 0x1, 0, 0x5, 0, 0, 0, 0x6d, < 1377 0x61, 0x6a, 0x6f, 0x72, 0x14, 0, 0x28, 0, 0x1, 0, < 1378 0x5, 0, 0, 0, 0x6d, 0x69, 0x6e, 0x6f, 0x72, 0x14, < 1379 0, 0x29, 0, 0x1, 0, 0x5, 0, 0, 0, 0x66, < 1380 0x6c, 0x61, 0x67, 0x73, 0x14, 0, 0xb, 0, 0x1f, 0, < 1381 0x1, 0, 0x6, 0, 0, 0, 0x56, 0x65, 0x63, 0x74, < 1382 0x6f, 0x72, 0xa, 0, 0x5, 0, 0x5e, 0xab, 0x82, 0x3d, < 1383 0xda, 0x62, 0xcf, 0x11, 0xab, 0x39, 0, 0x20, 0xaf, 0x71, < 1384 0xe4, 0x33, 0x2a, 0, 0x1, 0, 0x1, 0, 0, 0, < 1385 0x78, 0x14, 0, 0x2a, 0, 0x1, 0, 0x1, 0, 0, < 1386 0, 0x79, 0x14, 0, 0x2a, 0, 0x1, 0, 0x1, 0, < 1387 0, 0, 0x7a, 0x14, 0, 0xb, 0, 0x1f, 0, 0x1, < 1388 0, 0x8, 0, 0, 0, 0x43, 0x6f, 0x6f, 0x72, 0x64, < 1389 0x73, 0x32, 0x64, 0xa, 0, 0x5, 0, 0x44, 0x3f, 0xf2, < 1390 0xf6, 0x86, 0x76, 0xcf, 0x11, 0x8f, 0x52, 0, 0x40, 0x33, < 1391 0x35, 0x94, 0xa3, 0x2a, 0, 0x1, 0, 0x1, 0, 0, < 1392 0, 0x75, 0x14, 0, 0x2a, 0, 0x1, 0, 0x1, 0, < 1393 0, 0, 0x76, 0x14, 0, 0xb, 0, 0x1f, 0, 0x1, < 1394 0, 0x9, 0, 0, 0, 0x4d, 0x61, 0x74, 0x72, 0x69, < 1395 0x78, 0x34, 0x78, 0x34, 0xa, 0, 0x5, 0, 0x45, 0x3f, < 1396 0xf2, 0xf6, 0x86, 0x76, 0xcf, 0x11, 0x8f, 0x52, 0, 0x40, < 1397 0x33, 0x35, 0x94, 0xa3, 0x34, 0, 0x2a, 0, 0x1, 0, < 1398 0x6, 0, 0, 0, 0x6d, 0x61, 0x74, 0x72, 0x69, 0x78, < 1399 0xe, 0, 0x3, 0, 0x10, 0, 0, 0, 0xf, 0, < 1400 0x14, 0, 0xb, 0, 0x1f, 0, 0x1, 0, 0x9, 0, < 1401 0, 0, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x52, 0x47, 0x42, < 1402 0x41, 0xa, 0, 0x5, 0, 0xe0, 0x44, 0xff, 0x35, 0x7c, < 1403 0x6c, 0xcf, 0x11, 0x8f, 0x52, 0, 0x40, 0x33, 0x35, 0x94, < 1404 0xa3, 0x2a, 0, 0x1, 0, 0x3, 0, 0, 0, 0x72, < 1405 0x65, 0x64, 0x14, 0, 0x2a, 0, 0x1, 0, 0x5, 0, < 1406 0, 0, 0x67, 0x72, 0x65, 0x65, 0x6e, 0x14, 0, 0x2a, < 1407 0, 0x1, 0, 0x4, 0, 0, 0, 0x62, 0x6c, 0x75, < 1408 0x65, 0x14, 0, 0x2a, 0, 0x1, 0, 0x5, 0, 0, < 1409 0, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x14, 0, 0xb, 0, < 1410 0x1f, 0, 0x1, 0, 0x8, 0, 0, 0, 0x43, 0x6f, < 1411 0x6c, 0x6f, 0x72, 0x52, 0x47, 0x42, 0xa, 0, 0x5, 0, < 1412 0x81, 0x6e, 0xe1, 0xd3, 0x35, 0x78, 0xcf, 0x11, 0x8f, 0x52, < 1413 0, 0x40, 0x33, 0x35, 0x94, 0xa3, 0x2a, 0, 0x1, 0, < 1414 0x3, 0, 0, 0, 0x72, 0x65, 0x64, 0x14, 0, 0x2a, < 1415 0, 0x1, 0, 0x5, 0, 0, 0, 0x67, 0x72, 0x65, < 1416 0x65, 0x6e, 0x14, 0, 0x2a, 0, 0x1, 0, 0x4, 0, < 1417 0, 0, 0x62, 0x6c, 0x75, 0x65, 0x14, 0, 0xb, 0, < 1418 0x1f, 0, 0x1, 0, 0xc, 0, 0, 0, 0x49, 0x6e, < 1419 0x64, 0x65, 0x78, 0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6f, 0x72, < 1420 0xa, 0, 0x5, 0, 0x20, 0xb8, 0x30, 0x16, 0x42, 0x78, < 1421 0xcf, 0x11, 0x8f, 0x52, 0, 0x40, 0x33, 0x35, 0x94, 0xa3, < 1422 0x29, 0, 0x1, 0, 0x5, 0, 0, 0, 0x69, 0x6e, < 1423 0x64, 0x65, 0x78, 0x14, 0, 0x1, 0, 0x9, 0, 0, < 1424 0, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x52, 0x47, 0x42, 0x41, < 1425 0x1, 0, 0xa, 0, 0, 0, 0x69, 0x6e, 0x64, 0x65, < 1426 0x78, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x14, 0, 0xb, 0, < 1427 0x1f, 0, 0x1, 0, 0x7, 0, 0, 0, 0x42, 0x6f, < 1428 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0xa, 0, 0x5, 0, 0xa0, < 1429 0xa6, 0x7d, 0x53, 0x37, 0xca, 0xd0, 0x11, 0x94, 0x1c, 0, < 1430 0x80, 0xc8, 0xc, 0xfa, 0x7b, 0x29, 0, 0x1, 0, 0x9, < 1431 0, 0, 0, 0x74, 0x72, 0x75, 0x65, 0x66, 0x61, 0x6c, < 1432 0x73, 0x65, 0x14, 0, 0xb, 0, 0x1f, 0, 0x1, 0, < 1433 0x9, 0, 0, 0, 0x42, 0x6f, 0x6f, 0x6c, 0x65, 0x61, < 1434 0x6e, 0x32, 0x64, 0xa, 0, 0x5, 0, 0x63, 0xae, 0x85, < 1435 0x48, 0xe8, 0x78, 0xcf, 0x11, 0x8f, 0x52, 0, 0x40, 0x33, < 1436 0x35, 0x94, 0xa3, 0x1, 0, 0x7, 0, 0, 0, 0x42, < 1437 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x1, 0, 0x1, 0, < 1438 0, 0, 0x75, 0x14, 0, 0x1, 0, 0x7, 0, 0, < 1439 0, 0x42, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x1, 0, < 1440 0x1, 0, 0, 0, 0x76, 0x14, 0, 0xb, 0, 0x1f, < 1441 0, 0x1, 0, 0xc, 0, 0, 0, 0x4d, 0x61, 0x74, < 1442 0x65, 0x72, 0x69, 0x61, 0x6c, 0x57, 0x72, 0x61, 0x70, 0xa, < 1443 0, 0x5, 0, 0x60, 0xae, 0x85, 0x48, 0xe8, 0x78, 0xcf, < 1444 0x11, 0x8f, 0x52, 0, 0x40, 0x33, 0x35, 0x94, 0xa3, 0x1, < 1445 0, 0x7, 0, 0, 0, 0x42, 0x6f, 0x6f, 0x6c, 0x65, < 1446 0x61, 0x6e, 0x1, 0, 0x1, 0, 0, 0, 0x75, 0x14, < 1447 0, 0x1, 0, 0x7, 0, 0, 0, 0x42, 0x6f, 0x6f, < 1448 0x6c, 0x65, 0x61, 0x6e, 0x1, 0, 0x1, 0, 0, 0, < 1449 0x76, 0x14, 0, 0xb, 0, 0x1f, 0, 0x1, 0, 0xf, < 1450 0, 0, 0, 0x54, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, < 1451 0x46, 0x69, 0x6c, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0xa, 0, < 1452 0x5, 0, 0xe1, 0x90, 0x27, 0xa4, 0x10, 0x78, 0xcf, 0x11, < 1453 0x8f, 0x52, 0, 0x40, 0x33, 0x35, 0x94, 0xa3, 0x31, 0, < 1454 0x1, 0, 0x8, 0, 0, 0, 0x66, 0x69, 0x6c, 0x65, < 1455 0x6e, 0x61, 0x6d, 0x65, 0x14, 0, 0xb, 0, 0x1f, 0, < 1456 0x1, 0, 0x8, 0, 0, 0, 0x4d, 0x61, 0x74, 0x65, < 1457 0x72, 0x69, 0x61, 0x6c, 0xa, 0, 0x5, 0, 0x4d, 0xab, < 1458 0x82, 0x3d, 0xda, 0x62, 0xcf, 0x11, 0xab, 0x39, 0, 0x20, < 1459 0xaf, 0x71, 0xe4, 0x33, 0x1, 0, 0x9, 0, 0, 0, < 1460 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x52, 0x47, 0x42, 0x41, 0x1, < 1461 0, 0x9, 0, 0, 0, 0x66, 0x61, 0x63, 0x65, 0x43, < 1462 0x6f, 0x6c, 0x6f, 0x72, 0x14, 0, 0x2a, 0, 0x1, 0, < 1463 0x5, 0, 0, 0, 0x70, 0x6f, 0x77, 0x65, 0x72, 0x14, < 1464 0, 0x1, 0, 0x8, 0, 0, 0, 0x43, 0x6f, 0x6c, < 1465 0x6f, 0x72, 0x52, 0x47, 0x42, 0x1, 0, 0xd, 0, 0, < 1466 0, 0x73, 0x70, 0x65, 0x63, 0x75, 0x6c, 0x61, 0x72, 0x43, < 1467 0x6f, 0x6c, 0x6f, 0x72, 0x14, 0, 0x1, 0, 0x8, 0, < 1468 0, 0, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x52, 0x47, 0x42, < 1469 0x1, 0, 0xd, 0, 0, 0, 0x65, 0x6d, 0x69, 0x73, < 1470 0x73, 0x69, 0x76, 0x65, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x14, < 1471 0, 0xe, 0, 0x12, 0, 0x12, 0, 0x12, 0, 0xf, < 1472 0, 0xb, 0, 0x1f, 0, 0x1, 0, 0x8, 0, 0, < 1473 0, 0x4d, 0x65, 0x73, 0x68, 0x46, 0x61, 0x63, 0x65, 0xa, < 1474 0, 0x5, 0, 0x5f, 0xab, 0x82, 0x3d, 0xda, 0x62, 0xcf, < 1475 0x11, 0xab, 0x39, 0, 0x20, 0xaf, 0x71, 0xe4, 0x33, 0x29, < 1476 0, 0x1, 0, 0x12, 0, 0, 0, 0x6e, 0x46, 0x61, < 1477 0x63, 0x65, 0x56, 0x65, 0x72, 0x74, 0x65, 0x78, 0x49, 0x6e, < 1478 0x64, 0x69, 0x63, 0x65, 0x73, 0x14, 0, 0x34, 0, 0x29, < 1479 0, 0x1, 0, 0x11, 0, 0, 0, 0x66, 0x61, 0x63, < 1480 0x65, 0x56, 0x65, 0x72, 0x74, 0x65, 0x78, 0x49, 0x6e, 0x64, < 1481 0x69, 0x63, 0x65, 0x73, 0xe, 0, 0x1, 0, 0x12, 0, < 1482 0, 0, 0x6e, 0x46, 0x61, 0x63, 0x65, 0x56, 0x65, 0x72, < 1483 0x74, 0x65, 0x78, 0x49, 0x6e, 0x64, 0x69, 0x63, 0x65, 0x73, < 1484 0xf, 0, 0x14, 0, 0xb, 0, 0x1f, 0, 0x1, 0, < 1485 0xd, 0, 0, 0, 0x4d, 0x65, 0x73, 0x68, 0x46, 0x61, < 1486 0x63, 0x65, 0x57, 0x72, 0x61, 0x70, 0x73, 0xa, 0, 0x5, < 1487 0, 0xc0, 0xc5, 0x1e, 0xed, 0xa8, 0xc0, 0xd0, 0x11, 0x94, < 1488 0x1c, 0, 0x80, 0xc8, 0xc, 0xfa, 0x7b, 0x29, 0, 0x1, < 1489 0, 0xf, 0, 0, 0, 0x6e, 0x46, 0x61, 0x63, 0x65, < 1490 0x57, 0x72, 0x61, 0x70, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x73, < 1491 0x14, 0, 0x34, 0, 0x1, 0, 0x9, 0, 0, 0, < 1492 0x42, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x32, 0x64, 0x1, < 1493 0, 0xe, 0, 0, 0, 0x66, 0x61, 0x63, 0x65, 0x57, < 1494 0x72, 0x61, 0x70, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x73, 0xe, < 1495 0, 0x1, 0, 0xf, 0, 0, 0, 0x6e, 0x46, 0x61, < 1496 0x63, 0x65, 0x57, 0x72, 0x61, 0x70, 0x56, 0x61, 0x6c, 0x75, < 1497 0x65, 0x73, 0xf, 0, 0x14, 0, 0xb, 0, 0x1f, 0, < 1498 0x1, 0, 0x11, 0, 0, 0, 0x4d, 0x65, 0x73, 0x68, < 1499 0x54, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x43, 0x6f, 0x6f, < 1500 0x72, 0x64, 0x73, 0xa, 0, 0x5, 0, 0x40, 0x3f, 0xf2, < 1501 0xf6, 0x86, 0x76, 0xcf, 0x11, 0x8f, 0x52, 0, 0x40, 0x33, < 1502 0x35, 0x94, 0xa3, 0x29, 0, 0x1, 0, 0xe, 0, 0, < 1503 0, 0x6e, 0x54, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x43, < 1504 0x6f, 0x6f, 0x72, 0x64, 0x73, 0x14, 0, 0x34, 0, 0x1, < 1505 0, 0x8, 0, 0, 0, 0x43, 0x6f, 0x6f, 0x72, 0x64, < 1506 0x73, 0x32, 0x64, 0x1, 0, 0xd, 0, 0, 0, 0x74, < 1507 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x43, 0x6f, 0x6f, 0x72, < 1508 0x64, 0x73, 0xe, 0, 0x1, 0, 0xe, 0, 0, 0, < 1509 0x6e, 0x54, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x43, 0x6f, < 1510 0x6f, 0x72, 0x64, 0x73, 0xf, 0, 0x14, 0, 0xb, 0, < 1511 0x1f, 0, 0x1, 0, 0x10, 0, 0, 0, 0x4d, 0x65, < 1512 0x73, 0x68, 0x4d, 0x61, 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c, < 1513 0x4c, 0x69, 0x73, 0x74, 0xa, 0, 0x5, 0, 0x42, 0x3f, < 1514 0xf2, 0xf6, 0x86, 0x76, 0xcf, 0x11, 0x8f, 0x52, 0, 0x40, < 1515 0x33, 0x35, 0x94, 0xa3, 0x29, 0, 0x1, 0, 0xa, 0, < 1516 0, 0, 0x6e, 0x4d, 0x61, 0x74, 0x65, 0x72, 0x69, 0x61, < 1517 0x6c, 0x73, 0x14, 0, 0x29, 0, 0x1, 0, 0xc, 0, < 1518 0, 0, 0x6e, 0x46, 0x61, 0x63, 0x65, 0x49, 0x6e, 0x64, < 1519 0x65, 0x78, 0x65, 0x73, 0x14, 0, 0x34, 0, 0x29, 0, < 1520 0x1, 0, 0xb, 0, 0, 0, 0x66, 0x61, 0x63, 0x65, < 1521 0x49, 0x6e, 0x64, 0x65, 0x78, 0x65, 0x73, 0xe, 0, 0x1, < 1522 0, 0xc, 0, 0, 0, 0x6e, 0x46, 0x61, 0x63, 0x65, < 1523 0x49, 0x6e, 0x64, 0x65, 0x78, 0x65, 0x73, 0xf, 0, 0x14, < 1524 0, 0xe, 0, 0x1, 0, 0x8, 0, 0, 0, 0x4d, < 1525 0x61, 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c, 0xf, 0, 0xb, < 1526 0, 0x1f, 0, 0x1, 0, 0xb, 0, 0, 0, 0x4d, < 1527 0x65, 0x73, 0x68, 0x4e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x73, < 1528 0xa, 0, 0x5, 0, 0x43, 0x3f, 0xf2, 0xf6, 0x86, 0x76, < 1529 0xcf, 0x11, 0x8f, 0x52, 0, 0x40, 0x33, 0x35, 0x94, 0xa3, < 1530 0x29, 0, 0x1, 0, 0x8, 0, 0, 0, 0x6e, 0x4e, < 1531 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x73, 0x14, 0, 0x34, 0, < 1532 0x1, 0, 0x6, 0, 0, 0, 0x56, 0x65, 0x63, 0x74, < 1533 0x6f, 0x72, 0x1, 0, 0x7, 0, 0, 0, 0x6e, 0x6f, < 1534 0x72, 0x6d, 0x61, 0x6c, 0x73, 0xe, 0, 0x1, 0, 0x8, < 1535 0, 0, 0, 0x6e, 0x4e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, < 1536 0x73, 0xf, 0, 0x14, 0, 0x29, 0, 0x1, 0, 0xc, < 1537 0, 0, 0, 0x6e, 0x46, 0x61, 0x63, 0x65, 0x4e, 0x6f, < 1538 0x72, 0x6d, 0x61, 0x6c, 0x73, 0x14, 0, 0x34, 0, 0x1, < 1539 0, 0x8, 0, 0, 0, 0x4d, 0x65, 0x73, 0x68, 0x46, < 1540 0x61, 0x63, 0x65, 0x1, 0, 0xb, 0, 0, 0, 0x66, < 1541 0x61, 0x63, 0x65, 0x4e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x73, < 1542 0xe, 0, 0x1, 0, 0xc, 0, 0, 0, 0x6e, 0x46, < 1543 0x61, 0x63, 0x65, 0x4e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x73, < 1544 0xf, 0, 0x14, 0, 0xb, 0, 0x1f, 0, 0x1, 0, < 1545 0x10, 0, 0, 0, 0x4d, 0x65, 0x73, 0x68, 0x56, 0x65, < 1546 0x72, 0x74, 0x65, 0x78, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x73, < 1547 0xa, 0, 0x5, 0, 0x21, 0xb8, 0x30, 0x16, 0x42, 0x78, < 1548 0xcf, 0x11, 0x8f, 0x52, 0, 0x40, 0x33, 0x35, 0x94, 0xa3, < 1549 0x29, 0, 0x1, 0, 0xd, 0, 0, 0, 0x6e, 0x56, < 1550 0x65, 0x72, 0x74, 0x65, 0x78, 0x43, 0x6f, 0x6c, 0x6f, 0x72, < 1551 0x73, 0x14, 0, 0x34, 0, 0x1, 0, 0xc, 0, 0, < 1552 0, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x65, 0x64, 0x43, 0x6f, < 1553 0x6c, 0x6f, 0x72, 0x1, 0, 0xc, 0, 0, 0, 0x76, < 1554 0x65, 0x72, 0x74, 0x65, 0x78, 0x43, 0x6f, 0x6c, 0x6f, 0x72, < 1555 0x73, 0xe, 0, 0x1, 0, 0xd, 0, 0, 0, 0x6e, < 1556 0x56, 0x65, 0x72, 0x74, 0x65, 0x78, 0x43, 0x6f, 0x6c, 0x6f, < 1557 0x72, 0x73, 0xf, 0, 0x14, 0, 0xb, 0, 0x1f, 0, < 1558 0x1, 0, 0x4, 0, 0, 0, 0x4d, 0x65, 0x73, 0x68, < 1559 0xa, 0, 0x5, 0, 0x44, 0xab, 0x82, 0x3d, 0xda, 0x62, < 1560 0xcf, 0x11, 0xab, 0x39, 0, 0x20, 0xaf, 0x71, 0xe4, 0x33, < 1561 0x29, 0, 0x1, 0, 0x9, 0, 0, 0, 0x6e, 0x56, < 1562 0x65, 0x72, 0x74, 0x69, 0x63, 0x65, 0x73, 0x14, 0, 0x34, < 1563 0, 0x1, 0, 0x6, 0, 0, 0, 0x56, 0x65, 0x63, < 1564 0x74, 0x6f, 0x72, 0x1, 0, 0x8, 0, 0, 0, 0x76, < 1565 0x65, 0x72, 0x74, 0x69, 0x63, 0x65, 0x73, 0xe, 0, 0x1, < 1566 0, 0x9, 0, 0, 0, 0x6e, 0x56, 0x65, 0x72, 0x74, < 1567 0x69, 0x63, 0x65, 0x73, 0xf, 0, 0x14, 0, 0x29, 0, < 1568 0x1, 0, 0x6, 0, 0, 0, 0x6e, 0x46, 0x61, 0x63, < 1569 0x65, 0x73, 0x14, 0, 0x34, 0, 0x1, 0, 0x8, 0, < 1570 0, 0, 0x4d, 0x65, 0x73, 0x68, 0x46, 0x61, 0x63, 0x65, < 1571 0x1, 0, 0x5, 0, 0, 0, 0x66, 0x61, 0x63, 0x65, < 1572 0x73, 0xe, 0, 0x1, 0, 0x6, 0, 0, 0, 0x6e, < 1573 0x46, 0x61, 0x63, 0x65, 0x73, 0xf, 0, 0x14, 0, 0xe, < 1574 0, 0x12, 0, 0x12, 0, 0x12, 0, 0xf, 0, 0xb, < 1575 0, 0x1f, 0, 0x1, 0, 0x14, 0, 0, 0, 0x46, < 1576 0x72, 0x61, 0x6d, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, < 1577 0x6f, 0x72, 0x6d, 0x4d, 0x61, 0x74, 0x72, 0x69, 0x78, 0xa, < 1578 0, 0x5, 0, 0x41, 0x3f, 0xf2, 0xf6, 0x86, 0x76, 0xcf, < 1579 0x11, 0x8f, 0x52, 0, 0x40, 0x33, 0x35, 0x94, 0xa3, 0x1, < 1580 0, 0x9, 0, 0, 0, 0x4d, 0x61, 0x74, 0x72, 0x69, < 1581 0x78, 0x34, 0x78, 0x34, 0x1, 0, 0xb, 0, 0, 0, < 1582 0x66, 0x72, 0x61, 0x6d, 0x65, 0x4d, 0x61, 0x74, 0x72, 0x69, < 1583 0x78, 0x14, 0, 0xb, 0, 0x1f, 0, 0x1, 0, 0x5, < 1584 0, 0, 0, 0x46, 0x72, 0x61, 0x6d, 0x65, 0xa, 0, < 1585 0x5, 0, 0x46, 0xab, 0x82, 0x3d, 0xda, 0x62, 0xcf, 0x11, < 1586 0xab, 0x39, 0, 0x20, 0xaf, 0x71, 0xe4, 0x33, 0xe, 0, < 1587 0x12, 0, 0x12, 0, 0x12, 0, 0xf, 0, 0xb, 0, < 1588 0x1f, 0, 0x1, 0, 0x9, 0, 0, 0, 0x46, 0x6c, < 1589 0x6f, 0x61, 0x74, 0x4b, 0x65, 0x79, 0x73, 0xa, 0, 0x5, < 1590 0, 0xa9, 0x46, 0xdd, 0x10, 0x5b, 0x77, 0xcf, 0x11, 0x8f, < 1591 0x52, 0, 0x40, 0x33, 0x35, 0x94, 0xa3, 0x29, 0, 0x1, < 1592 0, 0x7, 0, 0, 0, 0x6e, 0x56, 0x61, 0x6c, 0x75, < 1593 0x65, 0x73, 0x14, 0, 0x34, 0, 0x2a, 0, 0x1, 0, < 1594 0x6, 0, 0, 0, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, < 1595 0xe, 0, 0x1, 0, 0x7, 0, 0, 0, 0x6e, 0x56, < 1596 0x61, 0x6c, 0x75, 0x65, 0x73, 0xf, 0, 0x14, 0, 0xb, < 1597 0, 0x1f, 0, 0x1, 0, 0xe, 0, 0, 0, 0x54, < 1598 0x69, 0x6d, 0x65, 0x64, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x4b, < 1599 0x65, 0x79, 0x73, 0xa, 0, 0x5, 0, 0x80, 0xb1, 0x6, < 1600 0xf4, 0x3b, 0x7b, 0xcf, 0x11, 0x8f, 0x52, 0, 0x40, 0x33, < 1601 0x35, 0x94, 0xa3, 0x29, 0, 0x1, 0, 0x4, 0, 0, < 1602 0, 0x74, 0x69, 0x6d, 0x65, 0x14, 0, 0x1, 0, 0x9, < 1603 0, 0, 0, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x4b, 0x65, < 1604 0x79, 0x73, 0x1, 0, 0x6, 0, 0, 0, 0x74, 0x66, < 1605 0x6b, 0x65, 0x79, 0x73, 0x14, 0, 0xb, 0, 0x1f, 0, < 1606 0x1, 0, 0xc, 0, 0, 0, 0x41, 0x6e, 0x69, 0x6d, < 1607 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4b, 0x65, 0x79, 0xa, 0, < 1608 0x5, 0, 0xa8, 0x46, 0xdd, 0x10, 0x5b, 0x77, 0xcf, 0x11, < 1609 0x8f, 0x52, 0, 0x40, 0x33, 0x35, 0x94, 0xa3, 0x29, 0, < 1610 0x1, 0, 0x7, 0, 0, 0, 0x6b, 0x65, 0x79, 0x54, < 1611 0x79, 0x70, 0x65, 0x14, 0, 0x29, 0, 0x1, 0, 0x5, < 1612 0, 0, 0, 0x6e, 0x4b, 0x65, 0x79, 0x73, 0x14, 0, < 1613 0x34, 0, 0x1, 0, 0xe, 0, 0, 0, 0x54, 0x69, < 1614 0x6d, 0x65, 0x64, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x4b, 0x65, < 1615 0x79, 0x73, 0x1, 0, 0x4, 0, 0, 0, 0x6b, 0x65, < 1616 0x79, 0x73, 0xe, 0, 0x1, 0, 0x5, 0, 0, 0, < 1617 0x6e, 0x4b, 0x65, 0x79, 0x73, 0xf, 0, 0x14, 0, 0xb, < 1618 0, 0x1f, 0, 0x1, 0, 0x10, 0, 0, 0, 0x41, < 1619 0x6e, 0x69, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4f, 0x70, < 1620 0x74, 0x69, 0x6f, 0x6e, 0x73, 0xa, 0, 0x5, 0, 0xc0, < 1621 0x56, 0xbf, 0xe2, 0xf, 0x84, 0xcf, 0x11, 0x8f, 0x52, 0, < 1622 0x40, 0x33, 0x35, 0x94, 0xa3, 0x29, 0, 0x1, 0, 0xa, < 1623 0, 0, 0, 0x6f, 0x70, 0x65, 0x6e, 0x63, 0x6c, 0x6f, < 1624 0x73, 0x65, 0x64, 0x14, 0, 0x29, 0, 0x1, 0, 0xf, < 1625 0, 0, 0, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, < 1626 0x6e, 0x71, 0x75, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x14, 0, < 1627 0xb, 0, 0x1f, 0, 0x1, 0, 0x9, 0, 0, 0, < 1628 0x41, 0x6e, 0x69, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0xa, < 1629 0, 0x5, 0, 0x4f, 0xab, 0x82, 0x3d, 0xda, 0x62, 0xcf, < 1630 0x11, 0xab, 0x39, 0, 0x20, 0xaf, 0x71, 0xe4, 0x33, 0xe, < 1631 0, 0x12, 0, 0x12, 0, 0x12, 0, 0xf, 0, 0xb, < 1632 0, 0x1f, 0, 0x1, 0, 0xc, 0, 0, 0, 0x41, < 1633 0x6e, 0x69, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, < 1634 0x74, 0xa, 0, 0x5, 0, 0x50, 0xab, 0x82, 0x3d, 0xda, < 1635 0x62, 0xcf, 0x11, 0xab, 0x39, 0, 0x20, 0xaf, 0x71, 0xe4, < 1636 0x33, 0xe, 0, 0x1, 0, 0x9, 0, 0, 0, 0x41, < 1637 0x6e, 0x69, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0xf, 0, < 1638 0xb, 0, 0x1f, 0, 0x1, 0, 0xa, 0, 0, 0, < 1639 0x49, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x44, 0x61, 0x74, 0x61, < 1640 0xa, 0, 0x5, 0, 0xa0, 0xee, 0x23, 0x3a, 0xb1, 0x94, < 1641 0xd0, 0x11, 0xab, 0x39, 0, 0x20, 0xaf, 0x71, 0xe4, 0x33, < 1642 0xe, 0, 0x1, 0, 0x6, 0, 0, 0, 0x42, 0x49, < 1643 0x4e, 0x41, 0x52, 0x59, 0xf, 0, 0xb, 0, 0x1f, 0, < 1644 0x1, 0, 0x3, 0, 0, 0, 0x55, 0x72, 0x6c, 0xa, < 1645 0, 0x5, 0, 0xa1, 0xee, 0x23, 0x3a, 0xb1, 0x94, 0xd0, < 1646 0x11, 0xab, 0x39, 0, 0x20, 0xaf, 0x71, 0xe4, 0x33, 0x29, < 1647 0, 0x1, 0, 0x5, 0, 0, 0, 0x6e, 0x55, 0x72, < 1648 0x6c, 0x73, 0x14, 0, 0x34, 0, 0x31, 0, 0x1, 0, < 1649 0x4, 0, 0, 0, 0x75, 0x72, 0x6c, 0x73, 0xe, 0, < 1650 0x1, 0, 0x5, 0, 0, 0, 0x6e, 0x55, 0x72, 0x6c, < 1651 0x73, 0xf, 0, 0x14, 0, 0xb, 0, 0x1f, 0, 0x1, < 1652 0, 0xf, 0, 0, 0, 0x50, 0x72, 0x6f, 0x67, 0x72, < 1653 0x65, 0x73, 0x73, 0x69, 0x76, 0x65, 0x4d, 0x65, 0x73, 0x68, < 1654 0xa, 0, 0x5, 0, 0x60, 0xc3, 0x63, 0x8a, 0x7d, 0x99, < 1655 0xd0, 0x11, 0x94, 0x1c, 0, 0x80, 0xc8, 0xc, 0xfa, 0x7b, < 1656 0xe, 0, 0x1, 0, 0x3, 0, 0, 0, 0x55, 0x72, < 1657 0x6c, 0x13, 0, 0x1, 0, 0xa, 0, 0, 0, 0x49, < 1658 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x44, 0x61, 0x74, 0x61, 0xf, < 1659 0, 0xb, 0, 0x1f, 0, 0x1, 0, 0x4, 0, 0, < 1660 0, 0x47, 0x75, 0x69, 0x64, 0xa, 0, 0x5, 0, 0xe0, < 1661 0x90, 0x27, 0xa4, 0x10, 0x78, 0xcf, 0x11, 0x8f, 0x52, 0, < 1662 0x40, 0x33, 0x35, 0x94, 0xa3, 0x29, 0, 0x1, 0, 0x5, < 1663 0, 0, 0, 0x64, 0x61, 0x74, 0x61, 0x31, 0x14, 0, < 1664 0x28, 0, 0x1, 0, 0x5, 0, 0, 0, 0x64, 0x61, < 1665 0x74, 0x61, 0x32, 0x14, 0, 0x28, 0, 0x1, 0, 0x5, < 1666 0, 0, 0, 0x64, 0x61, 0x74, 0x61, 0x33, 0x14, 0, < 1667 0x34, 0, 0x2d, 0, 0x1, 0, 0x5, 0, 0, 0, < 1668 0x64, 0x61, 0x74, 0x61, 0x34, 0xe, 0, 0x3, 0, 0x8, < 1669 0, 0, 0, 0xf, 0, 0x14, 0, 0xb, 0, 0x1f, < 1670 0, 0x1, 0, 0xe, 0, 0, 0, 0x53, 0x74, 0x72, < 1671 0x69, 0x6e, 0x67, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, < 1672 0x79, 0xa, 0, 0x5, 0, 0xe0, 0x21, 0xf, 0x7f, 0xe1, < 1673 0xbf, 0xd1, 0x11, 0x82, 0xc0, 0, 0xa0, 0xc9, 0x69, 0x72, < 1674 0x71, 0x31, 0, 0x1, 0, 0x3, 0, 0, 0, 0x6b, < 1675 0x65, 0x79, 0x14, 0, 0x31, 0, 0x1, 0, 0x5, 0, < 1676 0, 0, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x14, 0, 0xb, < 1677 0, 0x1f, 0, 0x1, 0, 0xb, 0, 0, 0, 0x50, < 1678 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x42, 0x61, 0x67, < 1679 0xa, 0, 0x5, 0, 0xe1, 0x21, 0xf, 0x7f, 0xe1, 0xbf, < 1680 0xd1, 0x11, 0x82, 0xc0, 0, 0xa0, 0xc9, 0x69, 0x72, 0x71, < 1681 0xe, 0, 0x1, 0, 0xe, 0, 0, 0, 0x53, 0x74, < 1682 0x72, 0x69, 0x6e, 0x67, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, < 1683 0x74, 0x79, 0xf, 0, 0xb, 0, 0x1f, 0, 0x1, 0, < 1684 0xe, 0, 0, 0, 0x45, 0x78, 0x74, 0x65, 0x72, 0x6e, < 1685 0x61, 0x6c, 0x56, 0x69, 0x73, 0x75, 0x61, 0x6c, 0xa, 0, < 1686 0x5, 0, 0xa0, 0x6a, 0x11, 0x98, 0xba, 0xbd, 0xd1, 0x11, < 1687 0x82, 0xc0, 0, 0xa0, 0xc9, 0x69, 0x72, 0x71, 0x1, 0, < 1688 0x4, 0, 0, 0, 0x47, 0x75, 0x69, 0x64, 0x1, 0, < 1689 0x12, 0, 0, 0, 0x67, 0x75, 0x69, 0x64, 0x45, 0x78, < 1690 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x56, 0x69, 0x73, 0x75, < 1691 0x61, 0x6c, 0x14, 0, 0xe, 0, 0x12, 0, 0x12, 0, < 1692 0x12, 0, 0xf, 0, 0xb, 0, 0x1f, 0, 0x1, 0, < 1693 0xb, 0, 0, 0, 0x52, 0x69, 0x67, 0x68, 0x74, 0x48, < 1694 0x61, 0x6e, 0x64, 0x65, 0x64, 0xa, 0, 0x5, 0, 0xa0, < 1695 0x5e, 0x5d, 0x7f, 0x3a, 0xd5, 0xd1, 0x11, 0x82, 0xc0, 0, < 1696 0xa0, 0xc9, 0x69, 0x72, 0x71, 0x29, 0, 0x1, 0, 0xc, < 1697 0, 0, 0, 0x62, 0x52, 0x69, 0x67, 0x68, 0x74, 0x48, < 1698 0x61, 0x6e, 0x64, 0x65, 0x64, 0x14, 0, 0xb, 0 < 1699 ]; < 1700 < 1701 const GUID DXFILEOBJ_XSkinMeshHeader = DEFINE_GUID!(0x3cf169ce, 0xff7c, 0x44ab, < 1702 const GUID DXFILEOBJ_VertexDuplicationIndices = DEFINE_GUID!(0xb8d65549, 0xd7c9, < 1703 const GUID DXFILEOBJ_FaceAdjacency = DEFINE_GUID!(0xa64c844a, 0xe282, 0x4756, 0x < 1704 const GUID DXFILEOBJ_SkinWeights = DEFINE_GUID!(0x6f0d123b, 0xbad2, 0x4167, 0xa0 < 1705 const GUID DXFILEOBJ_Patch = DEFINE_GUID!(0xa3eb5d44, 0xfc22, 0x429d, 0x9a, 0xfb < 1706 const GUID DXFILEOBJ_PatchMesh = DEFINE_GUID!(0xd02c95cc, 0xedba, 0x4305, 0x9b, < 1707 const GUID DXFILEOBJ_PatchMesh9 = DEFINE_GUID!(0xb9ec94e1, 0xb9a6, 0x4251, 0xba, < 1708 const GUID DXFILEOBJ_PMInfo = DEFINE_GUID!(0xb6c3e656, 0xec8b, 0x4b92, 0x9b, 0x6 < 1709 const GUID DXFILEOBJ_PMAttributeRange = DEFINE_GUID!(0x917e0427, 0xc61e, 0x4a14, < 1710 const GUID DXFILEOBJ_PMVSplitRecord = DEFINE_GUID!(0x574ccc14, 0xf0b3, 0x4333, 0 < 1711 const GUID DXFILEOBJ_FVFData = DEFINE_GUID!(0xb6e70a0e, 0x8ef9, 0x4e83, 0x94, 0x < 1712 const GUID DXFILEOBJ_VertexElement = DEFINE_GUID!(0xf752461c, 0x1e23, 0x48f6, 0x < 1713 const GUID DXFILEOBJ_DeclData = DEFINE_GUID!(0xbf22e553, 0x292c, 0x4781, 0x9f, 0 < 1714 const GUID DXFILEOBJ_EffectFloats = DEFINE_GUID!(0xf1cfe2b3, 0xde3, 0x4e28, 0xaf < 1715 const GUID DXFILEOBJ_EffectString = DEFINE_GUID!(0xd55b097e, 0xbdb6, 0x4c52, 0xb < 1716 const GUID DXFILEOBJ_EffectDWord = DEFINE_GUID!(0x622c0ed0, 0x956e, 0x4da9, 0x90 < 1717 const GUID DXFILEOBJ_EffectParamFloats = DEFINE_GUID!(0x3014b9a0, 0x62f5, 0x478c < 1718 const GUID DXFILEOBJ_EffectParamString = DEFINE_GUID!(0x1dbc4c88, 0x94c1, 0x46ee < 1719 const GUID DXFILEOBJ_EffectParamDWord = DEFINE_GUID!(0xe13963bc, 0xae51, 0x4c5d, < 1720 const GUID DXFILEOBJ_EffectInstance = DEFINE_GUID!(0xe331f7e4, 0x559, 0x4cc2, 0x < 1721 const GUID DXFILEOBJ_AnimTicksPerSecond = DEFINE_GUID!(0x9e415a43, 0x7ba6, 0x4a7 < 1722 const GUID DXFILEOBJ_CompressedAnimationSet = DEFINE_GUID!(0x7f9b00b3, 0xf125, 0 < 1723 < 1724 align(1) struct XFILECOMPRESSEDANIMATIONSET < 1725 { < 1726 DWORD CompressedBlockSize; < 1727 FLOAT TicksPerSec; < 1728 DWORD PlaybackType; < 1729 DWORD BufferLength; < 1730 } < 1731 < 1732 const char[] XSKINEXP_TEMPLATES = < 1733 "xof 0303txt 0032 < 1734 template XSkinMeshHeader < 1735 { < 1736 <3CF169CE-FF7C-44ab-93C0-F78F62D172E2> < 1737 WORD nMaxSkinWeightsPerVertex; < 1738 WORD nMaxSkinWeightsPerFace; < 1739 WORD nBones; < 1740 } < 1741 template VertexDuplicationIndices < 1742 { < 1743 <B8D65549-D7C9-4995-89CF-53A9A8B031E3> < 1744 DWORD nIndices; < 1745 DWORD nOriginalVertices; < 1746 array DWORD[nIndices] indices; < 1747 } < 1748 template FaceAdjacency < 1749 { < 1750 <A64C844A-E282-4756-8B80-250CDE04398C> < 1751 DWORD nIndices; < 1752 array DWORD[nIndices] indices; < 1753 } < 1754 template SkinWeights < 1755 { < 1756 <6F0D123B-BAD2-4167-A0D0-80224F25FABB> < 1757 STRING transformNodeName; < 1758 DWORD nWeights; < 1759 array DWORD[nWeights] vertexIndices; < 1760 array float[nWeights] weights; < 1761 Matrix4x4 matrixOffset; < 1762 } < 1763 template Patch < 1764 { < 1765 <A3EB5D44-FC22-429D-9AFB-3221CB9719A6> < 1766 DWORD nControlIndices; < 1767 array DWORD[nControlIndices] controlIndices; < 1768 } < 1769 template PatchMesh < 1770 { < 1771 <D02C95CC-EDBA-4305-9B5D-1820D7704BBF> < 1772 DWORD nVertices; < 1773 array Vector[nVertices] vertices; < 1774 DWORD nPatches; < 1775 array Patch[nPatches] patches; < 1776 [ ... ] < 1777 } < 1778 template PatchMesh9 < 1779 { < 1780 <B9EC94E1-B9A6-4251-BA18-94893F02C0EA> < 1781 DWORD Type; < 1782 DWORD Degree; < 1783 DWORD Basis; < 1784 DWORD nVertices; < 1785 array Vector[nVertices] vertices; < 1786 DWORD nPatches; < 1787 array Patch[nPatches] patches; < 1788 [ ... ] < 1789 } " < 1790 "template EffectFloats < 1791 { < 1792 <F1CFE2B3-0DE3-4e28-AFA1-155A750A282D> < 1793 DWORD nFloats; < 1794 array float[nFloats] Floats; < 1795 } < 1796 template EffectString < 1797 { < 1798 <D55B097E-BDB6-4c52-B03D-6051C89D0E42> < 1799 STRING Value; < 1800 } < 1801 template EffectDWord < 1802 { < 1803 <622C0ED0-956E-4da9-908A-2AF94F3CE716> < 1804 DWORD Value; < 1805 } " < 1806 "template EffectParamFloats < 1807 { < 1808 <3014B9A0-62F5-478c-9B86-E4AC9F4E418B> < 1809 STRING ParamName; < 1810 DWORD nFloats; < 1811 array float[nFloats] Floats; < 1812 } " < 1813 "template EffectParamString < 1814 { < 1815 <1DBC4C88-94C1-46ee-9076-2C28818C9481> < 1816 STRING ParamName; < 1817 STRING Value; < 1818 } < 1819 template EffectParamDWord < 1820 { < 1821 <E13963BC-AE51-4c5d-B00F-CFA3A9D97CE5> < 1822 STRING ParamName; < 1823 DWORD Value; < 1824 } < 1825 template EffectInstance < 1826 { < 1827 <E331F7E4-0559-4cc2-8E99-1CEC1657928F> < 1828 STRING EffectFilename; < 1829 [ ... ] < 1830 } " < 1831 "template AnimTicksPerSecond < 1832 { < 1833 <9E415A43-7BA6-4a73-8743-B73D47E88476> < 1834 DWORD AnimTicksPerSecond; < 1835 } < 1836 template CompressedAnimationSet < 1837 { < 1838 <7F9B00B3-F125-4890-876E-1C42BF697C4D> < 1839 DWORD CompressedBlockSize; < 1840 FLOAT TicksPerSec; < 1841 DWORD PlaybackType; < 1842 DWORD BufferLength; < 1843 array DWORD[BufferLength] CompressedData; < 1844 } "; < 1845 < 1846 const char[] XEXTENSIONS_TEMPLATES = < 1847 "xof 0303txt 0032 < 1848 template FVFData < 1849 { < 1850 <B6E70A0E-8EF9-4e83-94AD-ECC8B0C04897> < 1851 DWORD dwFVF; < 1852 DWORD nDWords; < 1853 array DWORD[nDWords] data; < 1854 } < 1855 template VertexElement < 1856 { < 1857 <F752461C-1E23-48f6-B9F8-8350850F336F> < 1858 DWORD Type; < 1859 DWORD Method; < 1860 DWORD Usage; < 1861 DWORD UsageIndex; < 1862 } < 1863 template DeclData < 1864 { < 1865 <BF22E553-292C-4781-9FEA-62BD554BDD93> < 1866 DWORD nElements; < 1867 array VertexElement[nElements] Elements; < 1868 DWORD nDWords; < 1869 array DWORD[nDWords] data; < 1870 } < 1871 template PMAttributeRange < 1872 { < 1873 <917E0427-C61E-4a14-9C64-AFE65F9E9844> < 1874 DWORD iFaceOffset; < 1875 DWORD nFacesMin; < 1876 DWORD nFacesMax; < 1877 DWORD iVertexOffset; < 1878 DWORD nVerticesMin; < 1879 DWORD nVerticesMax; < 1880 } < 1881 template PMVSplitRecord < 1882 { < 1883 <574CCC14-F0B3-4333-822D-93E8A8A08E4C> < 1884 DWORD iFaceCLW; < 1885 DWORD iVlrOffset; < 1886 DWORD iCode; < 1887 } < 1888 template PMInfo < 1889 { < 1890 <B6C3E656-EC8B-4b92-9B62-681659522947> < 1891 DWORD nAttributes; < 1892 array PMAttributeRange[nAttributes] attributeRanges; < 1893 DWORD nMaxValence; < 1894 DWORD nMinLogicalVertices; < 1895 DWORD nMaxLogicalVertices; < 1896 DWORD nVSplits; < 1897 array PMVSplitRecord[nVSplits] splitRecords; < 1898 DWORD nAttributeMispredicts; < 1899 array DWORD[nAttributeMispredicts] attributeMispredicts; < 1900 } "; < 1901 < 1902 enum : uint < 1903 { < 1904 D3DXF_FILEFORMAT_BINARY = 0, < 1905 D3DXF_FILEFORMAT_TEXT = 1, < 1906 D3DXF_FILEFORMAT_COMPRESSED = 2 < 1907 } < 1908 alias uint D3DXF_FILEFORMAT; < 1909 < 1910 enum : uint < 1911 { < 1912 D3DXF_FILESAVE_TOFILE = 0x00L, < 1913 D3DXF_FILESAVE_TOWFILE = 0x01L < 1914 } < 1915 alias uint D3DXF_FILESAVEOPTIONS; < 1916 < 1917 enum : uint < 1918 { < 1919 D3DXF_FILELOAD_FROMFILE = 0x00L, < 1920 D3DXF_FILELOAD_FROMWFILE = 0x01L, < 1921 D3DXF_FILELOAD_FROMRESOURCE = 0x02L, < 1922 D3DXF_FILELOAD_FROMMEMORY = 0x03L < 1923 } < 1924 alias uint D3DXF_FILELOADOPTIONS; < 1925 < 1926 struct D3DXF_FILELOADRESOURCE < 1927 { < 1928 HMODULE hModule; // Desc < 1929 LPCSTR lpName; // Desc < 1930 LPCSTR lpType; // Desc < 1931 } < 1932 < 1933 struct D3DXF_FILELOADMEMORY < 1934 { < 1935 LPCVOID lpMemory; // Desc < 1936 size_t dSize; // Desc < 1937 } < 1938 < 1939 const GUID IID_ID3DXFile = DEFINE_GUID!(0xcef08cf9, 0x7b4f, 0x4429, 0x96, 0x24, < 1940 const GUID IID_ID3DXFileSaveObject = DEFINE_GUID!(0xcef08cfa, 0x7b4f, 0x4429, 0x < 1941 const GUID IID_ID3DXFileSaveData = DEFINE_GUID!(0xcef08cfb, 0x7b4f, 0x4429, 0x96 < 1942 const GUID IID_ID3DXFileEnumObject = DEFINE_GUID!(0xcef08cfc, 0x7b4f, 0x4429, 0x < 1943 const GUID IID_ID3DXFileData = DEFINE_GUID!(0xcef08cfd, 0x7b4f, 0x4429, 0x96, 0x < 1944 < 1945 interface ID3DXFile : IUnknown < 1946 { < 1947 HRESULT CreateEnumObject(LPCVOID, D3DXF_FILELOADOPTIONS, ID3DXFileEnumObject < 1948 HRESULT CreateSaveObject(LPCVOID, D3DXF_FILESAVEOPTIONS, D3DXF_FILEFORMAT, I < 1949 HRESULT RegisterTemplates(LPCVOID, size_t); < 1950 HRESULT RegisterEnumTemplates(ID3DXFileEnumObject); < 1951 } < 1952 < 1953 interface ID3DXFileSaveObject : IUnknown < 1954 { < 1955 HRESULT GetFile(ID3DXFile*); < 1956 HRESULT AddDataObject(GUID*, LPCSTR, GUID*, size_t, LPCVOID, ID3DXFileSaveDa < 1957 HRESULT Save(); < 1958 } < 1959 < 1960 interface ID3DXFileSaveData : IUnknown < 1961 { < 1962 HRESULT GetSave(ID3DXFileSaveObject*); < 1963 HRESULT GetName(LPSTR, size_t*); < 1964 HRESULT GetId(GUID*); < 1965 HRESULT GetType(GUID*); < 1966 HRESULT AddDataObject(GUID*, LPCSTR, GUID*, size_t, LPCVOID, ID3DXFileSaveDa < 1967 HRESULT AddDataReference(LPCSTR, GUID* ); < 1968 } < 1969 < 1970 interface ID3DXFileEnumObject : IUnknown < 1971 { < 1972 HRESULT GetFile(ID3DXFile*); < 1973 HRESULT GetChildren(size_t*); < 1974 HRESULT GetChild(size_t, ID3DXFileData*); < 1975 HRESULT GetDataObjectById(REFGUID, ID3DXFileData*); < 1976 HRESULT GetDataObjectByName(LPCSTR, ID3DXFileData*); < 1977 } < 1978 < 1979 interface ID3DXFileData : IUnknown < 1980 { < 1981 HRESULT GetEnum(ID3DXFileEnumObject*); < 1982 HRESULT GetName(LPSTR, size_t*); < 1983 HRESULT GetId(GUID*); < 1984 HRESULT Lock(size_t*, LPCVOID*); < 1985 HRESULT Unlock(); < 1986 HRESULT GetType(GUID*); < 1987 BOOL IsReference(); < 1988 HRESULT GetChildren(size_t*); < 1989 HRESULT GetChild(size_t, ID3DXFileData*); < 1990 } <
Deleted src/win32/directx/d3dx9.def version [9586cdec987a21cb]
1 IMPORTS < 2 _D3DXConcatenateMeshes@32 = d3dx9_29.D3DXConcatenateMeshes < 3 _D3DXCreateBox@24 = d3dx9_29.D3DXCreateBox < 4 _D3DXCreateCubeTexture@28 = d3dx9_29.D3DXCreateCubeTexture < 5 _D3DXCreateCubeTextureFromFileExA@52 = d3dx9_29.D3DXCreateCubeTextureFromFileExA < 6 _D3DXCreateCylinder@32 = d3dx9_29.D3DXCreateCylinder < 7 _D3DXCreateFontA@48 = d3dx9_29.D3DXCreateFontA < 8 _D3DXCreatePolygon@20 = d3dx9_29.D3DXCreatePolygon < 9 _D3DXCreateSkinInfoFVF@16 = d3dx9_29.D3DXCreateSkinInfoFVF < 10 _D3DXCreateSphere@24 = d3dx9_29.D3DXCreateSphere < 11 _D3DXCreateSprite@8 = d3dx9_29.D3DXCreateSprite < 12 _D3DXCreateTeapot@12 = d3dx9_29.D3DXCreateTeapot < 13 _D3DXCreateTexture@32 = d3dx9_29.D3DXCreateTexture < 14 _D3DXCreateTextureFromFileExA@56 = d3dx9_29.D3DXCreateTextureFromFileExA < 15 _D3DXCreateTextureFromFileA@12 = d3dx9_29.D3DXCreateTextureFromFileA < 16 _D3DXCreateTorus@28 = d3dx9_29.D3DXCreateTorus < 17 _D3DXFileCreate@4 = d3dx9_29.D3DXFileCreate < 18 _D3DXGetDeclVertexSize@8 = d3dx9_29.D3DXGetDeclVertexSize < 19 _D3DXLoadMeshFromXof@32 = d3dx9_29.D3DXLoadMeshFromXof < 20 _D3DXMatrixDecompose@16 = d3dx9_29.D3DXMatrixDecompose < 21 _D3DXMatrixInverse@12 = d3dx9_29.D3DXMatrixInverse < 22 _D3DXMatrixMultiply@12 = d3dx9_29.D3DXMatrixMultiply < 23 _D3DXMatrixOrthoOffCenterLH@28 = d3dx9_29.D3DXMatrixOrthoOffCenterLH < 24 _D3DXMatrixPerspectiveFovLH@20 = d3dx9_29.D3DXMatrixPerspectiveFovLH < 25 _D3DXMatrixRotationQuaternion@8 = d3dx9_29.D3DXMatrixRotationQuaternion < 26 _D3DXMatrixRotationX@8 = d3dx9_29.D3DXMatrixRotationX < 27 _D3DXMatrixRotationY@8 = d3dx9_29.D3DXMatrixRotationY < 28 _D3DXMatrixRotationYawPitchRoll@16 = d3dx9_29.D3DXMatrixRotationYawPitchRoll < 29 _D3DXMatrixRotationZ@8 = d3dx9_29.D3DXMatrixRotationZ < 30 _D3DXMatrixScaling@16 = d3dx9_29.D3DXMatrixScaling < 31 _D3DXMatrixTransformation2D@28 = d3dx9_29.D3DXMatrixTransformation2D < 32 _D3DXMatrixTranslation@16 = d3dx9_29.D3DXMatrixTranslation < 33 _D3DXPlaneNormalize@8 = d3dx9_29.D3DXPlaneNormalize < 34 _D3DXQuaternionNormalize@8 = d3dx9_29.D3DXQuaternionNormalize < 35 _D3DXQuaternionRotationYawPitchRoll@16 = d3dx9_29.D3DXQuaternionRotationYawPitch < 36 _D3DXQuaternionSlerp@16 = d3dx9_29.D3DXQuaternionSlerp < 37 _D3DXQuaternionSquad@24 = d3dx9_29.D3DXQuaternionSquad < 38 _D3DXQuaternionSquadSetup@28 = d3dx9_29.D3DXQuaternionSquadSetup < 39 _D3DXSimplifyMesh@28 = d3dx9_29.D3DXSimplifyMesh < 40 _D3DXVec2TransformCoord@12 = d3dx9_29.D3DXVec2TransformCoord < 41 _D3DXVec3CatmullRom@24 = d3dx9_29.D3DXVec3CatmullRom < 42 _D3DXVec3TransformCoord@12 = d3dx9_29.D3DXVec3TransformCoord < 43 _D3DXCreateEffect@36 = d3dx9_29.D3DXCreateEffect < 44 _D3DXCreateEffectFromFileA@32 = d3dx9_29.D3DXCreateEffectFromFileA < 45 _D3DXCreateEffectPool@4 = d3dx9_29.D3DXCreateEffectPool < 46 _D3DXGetShaderInputSemantics@12 = d3dx9_29.D3DXGetShaderInputSemantics < 47 _D3DXGetShaderVersion@4 = d3dx9_29.D3DXGetShaderVersion < 48 _D3DXMatrixTranspose@8 = d3dx9_29.D3DXMatrixTranspose <
Deleted src/win32/directx/dinput8.d version [8fb075b61afe872c]
1 module win32.directx.dinput8; < 2 < 3 //import tango.sys.win32.Types; < 4 //alias char CHAR; < 5 < 6 import win32.windows; < 7 < 8 enum { < 9 CLASS_E_NOAGGREGATION = cast(int) 0x80040110, < 10 } < 11 < 12 interface IUnknown { < 13 HRESULT QueryInterface(IID* riid, void** pvObject); < 14 ULONG AddRef(); < 15 ULONG Release(); < 16 } < 17 < 18 extern(C): < 19 < 20 struct DIDEVICEINSTANCEA < 21 { < 22 DWORD dwSize; < 23 GUID guidInstance; < 24 GUID guidProduct; < 25 DWORD dwDevType; < 26 CHAR[MAX_PATH] tszInstanceName; < 27 CHAR[MAX_PATH] tszProductName; < 28 GUID guidFFDriver; < 29 WORD wUsagePage; < 30 WORD wUsage; < 31 } < 32 alias DIDEVICEINSTANCEA DIDEVICEINSTANCE; < 33 < 34 struct DIDEVICEOBJECTINSTANCEA < 35 { < 36 DWORD dwSize; < 37 GUID guidType; < 38 DWORD dwOfs; < 39 DWORD dwType; < 40 DWORD dwFlags; < 41 CHAR[MAX_PATH] tszName; < 42 DWORD dwFFMaxForce; < 43 DWORD dwFFForceResolution; < 44 WORD wCollectionNumber; < 45 WORD wDesignatorIndex; < 46 WORD wUsagePage; < 47 WORD wUsage; < 48 DWORD dwDimension; < 49 WORD wExponent; < 50 WORD wReportId; < 51 } < 52 < 53 struct DIOBJECTDATAFORMAT < 54 { < 55 const GUID *pguid; < 56 DWORD dwOfs; < 57 DWORD dwType; < 58 DWORD dwFlags; < 59 } < 60 < 61 struct DIDATAFORMAT < 62 { < 63 DWORD dwSize; < 64 DWORD dwObjSize; < 65 DWORD dwFlags; < 66 DWORD dwDataSize; < 67 DWORD dwNumObjs; < 68 DIOBJECTDATAFORMAT* rgodf; < 69 } < 70 < 71 extern DIDATAFORMAT c_dfDIKeyboard; < 72 extern DIDATAFORMAT c_dfDIMouse2; < 73 extern DIDATAFORMAT c_dfDIJoystick; < 74 < 75 struct DIACTIONA < 76 { < 77 UINT* uAppData; < 78 DWORD dwSemantic; < 79 DWORD dwFlags; < 80 union < 81 { < 82 LPCSTR lptszActionName; < 83 UINT uResIdString; < 84 } < 85 GUID guidInstance; < 86 DWORD dwObjID; < 87 DWORD dwHow; < 88 } < 89 < 90 struct DIACTIONFORMATA < 91 { < 92 DWORD dwSize; < 93 DWORD dwActionSize; < 94 DWORD dwDataSize; < 95 DWORD dwNumActions; < 96 DIACTIONA* rgoAction; < 97 GUID guidActionMap; < 98 DWORD dwGenre; < 99 DWORD dwBufferSize; < 100 LONG lAxisMin; < 101 LONG lAxisMax; < 102 HINSTANCE hInstString; < 103 FILETIME ftTimeStamp; < 104 DWORD dwCRC; < 105 CHAR[MAX_PATH] tszActionMap; < 106 } < 107 < 108 struct DIDEVCAPS < 109 { < 110 DWORD dwSize; < 111 DWORD dwFlags; < 112 DWORD dwDevType; < 113 DWORD dwAxes; < 114 DWORD dwButtons; < 115 DWORD dwPOVs; < 116 DWORD dwFFSamplePeriod; < 117 DWORD dwFFMinTimeResolution; < 118 DWORD dwFirmwareRevision; < 119 DWORD dwHardwareRevision; < 120 DWORD dwFFDriverVersion; < 121 } < 122 < 123 struct DIPROPHEADER < 124 { < 125 DWORD dwSize; < 126 DWORD dwHeaderSize; < 127 DWORD dwObj; < 128 DWORD dwHow; < 129 } < 130 < 131 struct DIDEVICEOBJECTDATA < 132 { < 133 DWORD dwOfs; < 134 DWORD dwData; < 135 DWORD dwTimeStamp; < 136 DWORD dwSequence; < 137 UINT* uAppData; < 138 } < 139 < 140 struct DIENVELOPE < 141 { < 142 DWORD dwSize = DIENVELOPE.sizeof; < 143 DWORD dwAttackLevel; < 144 DWORD dwAttackTime; // Microseconds < 145 DWORD dwFadeLevel; < 146 DWORD dwFadeTime; // Microseconds < 147 } < 148 < 149 struct DIEFFECT < 150 { < 151 DWORD dwSize = DIEFFECT.sizeof; < 152 DWORD dwFlags; // DIEFF_* < 153 DWORD dwDuration; // Microseconds < 154 DWORD dwSamplePeriod; // Microseconds < 155 DWORD dwGain; < 156 DWORD dwTriggerButton; // or DIEB_NOTRIGGER < 157 DWORD dwTriggerRepeatInterval; // Microseconds < 158 DWORD cAxes; // Number of axes < 159 LPDWORD rgdwAxes; // Array of axes < 160 LPLONG rglDirection; // Array of directions < 161 DIENVELOPE* lpEnvelope; // Optional < 162 DWORD cbTypeSpecificParams; // Size of params < 163 LPVOID lpvTypeSpecificParams; // Pointer to params < 164 DWORD dwStartDelay; // Microseconds < 165 } < 166 < 167 struct DIEFFESCAPE < 168 { < 169 DWORD dwSize; < 170 DWORD dwCommand; < 171 LPVOID lpvInBuffer; < 172 DWORD cbInBuffer; < 173 LPVOID lpvOutBuffer; < 174 DWORD cbOutBuffer; < 175 } < 176 < 177 struct DIEFFECTINFOA < 178 { < 179 DWORD dwSize; < 180 GUID guid; < 181 DWORD dwEffType; < 182 DWORD dwStaticParams; < 183 DWORD dwDynamicParams; < 184 CHAR[MAX_PATH] tszName; < 185 } < 186 < 187 struct DIFILEEFFECT < 188 { < 189 DWORD dwSize; < 190 GUID GuidEffect; < 191 DIEFFECT* lpDiEffect; < 192 CHAR[MAX_PATH] szFriendlyName; < 193 } < 194 < 195 struct DIDEVICEIMAGEINFOA < 196 { < 197 CHAR[MAX_PATH] tszImagePath; < 198 DWORD dwFlags; < 199 // These are valid if DIDIFT_OVERLAY is present in dwFlags. < 200 DWORD dwViewID; < 201 RECT rcOverlay; < 202 DWORD dwObjID; < 203 DWORD dwcValidPts; < 204 POINT[5] rgptCalloutLine; < 205 RECT rcCalloutRect; < 206 DWORD dwTextAlign; < 207 } < 208 < 209 struct DIDEVICEIMAGEINFOHEADERA < 210 { < 211 DWORD dwSize; < 212 DWORD dwSizeImageInfo; < 213 DWORD dwcViews; < 214 DWORD dwcButtons; < 215 DWORD dwcAxes; < 216 DWORD dwcPOVs; < 217 DWORD dwBufferSize; < 218 DWORD dwBufferUsed; < 219 DIDEVICEIMAGEINFOA* lprgImageInfoArray; < 220 } < 221 < 222 struct DICONFIGUREDEVICESPARAMSA < 223 { < 224 DWORD dwSize; < 225 DWORD dwcUsers; < 226 LPSTR lptszUserNames; < 227 DWORD dwcFormats; < 228 DIACTIONFORMATA* lprgFormats; < 229 HWND hwnd; < 230 DICOLORSET dics; < 231 IUnknown lpUnkDDSTarget; < 232 } < 233 < 234 struct DICOLORSET < 235 { < 236 DWORD dwSize; < 237 DWORD cTextFore; < 238 DWORD cTextHighlight; < 239 DWORD cCalloutLine; < 240 DWORD cCalloutHighlight; < 241 DWORD cBorder; < 242 DWORD cControlFill; < 243 DWORD cHighlightFill; < 244 DWORD cAreaFill; < 245 } < 246 < 247 struct DIMOUSESTATE2 < 248 { < 249 LONG lX; < 250 LONG lY; < 251 LONG lZ; < 252 BYTE[8] rgbButtons; < 253 } < 254 < 255 struct DIJOYSTATE < 256 { < 257 LONG lX; /* x-axis position */ < 258 LONG lY; /* y-axis position */ < 259 LONG lZ; /* z-axis position */ < 260 LONG lRx; /* x-axis rotation */ < 261 LONG lRy; /* y-axis rotation */ < 262 LONG lRz; /* z-axis rotation */ < 263 LONG[2] rglSlider; /* extra axes positions */ < 264 DWORD[4]rgdwPOV; /* POV directions */ < 265 BYTE[32]rgbButtons; /* 32 buttons */ < 266 } < 267 < 268 struct DIPROPRANGE < 269 { < 270 DIPROPHEADER diph; < 271 LONG lMin; < 272 LONG lMax; < 273 } < 274 < 275 interface IDirectInputEffect : IUnknown < 276 { < 277 HRESULT Initialize(HINSTANCE, DWORD, GUID*); < 278 HRESULT GetEffectGuid(GUID*); < 279 HRESULT GetParameters(DIEFFECT*, DWORD); < 280 HRESULT SetParameters(DIEFFECT*, DWORD); < 281 HRESULT Start(DWORD, DWORD); < 282 HRESULT Stop(); < 283 HRESULT GetEffectStatus(LPDWORD); < 284 HRESULT Download(); < 285 HRESULT Unload(); < 286 HRESULT Escape(DIEFFESCAPE*); < 287 } < 288 < 289 extern(Windows) alias bool function(DIDEVICEINSTANCEA*, LPVOID) LPDIENUMDEVICESC < 290 extern(Windows) alias bool function(DIDEVICEINSTANCEA*, IDirectInputDevice8A*, D < 291 < 292 extern(Windows) alias bool function(DIDEVICEOBJECTINSTANCEA *didoi, void* pConte < 293 < 294 extern(Windows) alias bool function(DIEFFECTINFOA*, LPVOID) LPDIENUMEFFECTSCALLB < 295 extern(Windows) alias bool function(IDirectInputEffect, LPVOID) LPDIENUMCREATEDE < 296 extern(Windows) alias bool function(DIFILEEFFECT* , LPVOID) LPDIENUMEFFECTSINFIL < 297 extern(Windows) alias bool function(IUnknown, LPVOID) LPDICONFIGUREDEVICESCALLBA < 298 < 299 interface IDirectInputDevice8A : IUnknown < 300 { < 301 HRESULT GetCapabilities(DIDEVCAPS*); < 302 HRESULT EnumObjects(LPDIENUMDEVICEOBJECTSCALLBACKA, VOID*, DWORD); < 303 HRESULT GetProperty(GUID*, DIPROPHEADER*); < 304 HRESULT SetProperty(GUID*, DIPROPHEADER*); < 305 HRESULT Acquire(); < 306 HRESULT Unacquire(); < 307 HRESULT GetDeviceState(DWORD, LPVOID); < 308 HRESULT GetDeviceData(DWORD, DIDEVICEOBJECTDATA*, LPDWORD, DWORD); < 309 HRESULT SetDataFormat(DIDATAFORMAT*); < 310 HRESULT SetEventNotification(HANDLE); < 311 HRESULT SetCooperativeLevel(HWND, DWORD); < 312 HRESULT GetObjectInfo(DIDEVICEOBJECTINSTANCEA*, DWORD, DWORD); < 313 HRESULT GetDeviceInfo(DIDEVICEINSTANCEA*); < 314 HRESULT RunControlPanel(HWND, DWORD); < 315 HRESULT Initialize(HINSTANCE, DWORD, GUID*); < 316 HRESULT CreateEffect(GUID*, DIEFFECT*, IDirectInputEffect*, IUnknown); < 317 HRESULT EnumEffects(LPDIENUMEFFECTSCALLBACKA, LPVOID, DWORD); < 318 HRESULT GetEffectInfo(DIEFFECTINFOA*, GUID*); < 319 HRESULT GetForceFeedbackState(LPDWORD); < 320 HRESULT SendForceFeedbackCommand(DWORD); < 321 HRESULT EnumCreatedEffectObjects(LPDIENUMCREATEDEFFECTOBJECTSCALLBACK, LPVOI < 322 HRESULT Escape(DIEFFESCAPE*); < 323 HRESULT Poll(); < 324 HRESULT SendDeviceData(DWORD, DIDEVICEOBJECTDATA*, LPDWORD, DWORD); < 325 HRESULT EnumEffectsInFile(LPCSTR, LPDIENUMEFFECTSINFILECALLBACK, LPVOID, DWO < 326 HRESULT WriteEffectToFile(LPCSTR, DWORD, DIFILEEFFECT*, DWORD); < 327 HRESULT BuildActionMap(DIACTIONFORMATA*, LPCSTR, DWORD); < 328 HRESULT SetActionMap(DIACTIONFORMATA*, LPCSTR, DWORD); < 329 HRESULT GetImageInfo(DIDEVICEIMAGEINFOHEADERA*); < 330 } < 331 alias IDirectInputDevice8A IDirectInputDevice8; < 332 < 333 interface IDirectInput8A : IUnknown < 334 { < 335 extern(Windows): < 336 HRESULT CreateDevice(GUID*, IDirectInputDevice8A*, IUnknown); < 337 HRESULT EnumDevices(DWORD, LPDIENUMDEVICESCALLBACKA, LPVOID, DWORD); < 338 HRESULT GetDeviceStatus(GUID*); < 339 HRESULT RunControlPanel(HWND, DWORD); < 340 HRESULT Initialize(HINSTANCE, DWORD); < 341 HRESULT FindDevice(GUID*, LPCSTR, GUID*); < 342 HRESULT EnumDevicesBySemantics(LPCSTR, DIACTIONFORMATA*, LPDIENUMDEVICESBYSE < 343 HRESULT ConfigureDevices(LPDICONFIGUREDEVICESCALLBACK, DICONFIGUREDEVICESPAR < 344 } < 345 alias IDirectInput8A IDirectInput8; < 346 < 347 extern(Windows) HRESULT DirectInput8Create(HINSTANCE hinst, DWORD dwVersion, GUI < 348 < 349 const GUID IID_IDirectInput8A={0xBF798030, 0x483A, 0x4DA2, [0xAA, 0x99, 0x5D, 0x < 350 alias IID_IDirectInput8A IID_IDirectInput8; < 351 const GUID GUID_SysKeyboard = {0x6F1D2B61, 0xD5A0, 0x11CF, [0xBF, 0xC7, 0x44, 0x < 352 const GUID GUID_SysMouse = {0x6F1D2B60, 0xD5A0, 0x11CF, [0xBF, 0xC7, 0x44, 0x < 353 const GUID GUID_XAxis = {0xA36D02E0, 0xC9F3, 0x11CF, [0xBF, 0xC7, 0x44, 0x < 354 const GUID GUID_YAxis = {0xA36D02E1, 0xC9F3, 0x11CF, [0xBF, 0xC7, 0x44, 0x < 355 const GUID GUID_ZAxis = {0xA36D02E2, 0xC9F3, 0x11CF, [0xBF, 0xC7, 0x44, 0x < 356 const GUID GUID_RxAxis = {0xA36D02F4, 0xC9F3, 0x11CF, [0xBF, 0xC7, 0x44, 0x < 357 const GUID GUID_RyAxis = {0xA36D02F5, 0xC9F3, 0x11CF, [0xBF, 0xC7, 0x44, 0x < 358 const GUID GUID_RzAxis = {0xA36D02E3, 0xC9F3, 0x11CF, [0xBF, 0xC7, 0x44, 0x < 359 const GUID GUID_Slider = {0xA36D02E4, 0xC9F3, 0x11CF, [0xBF, 0xC7, 0x44, 0x < 360 const GUID GUID_Key = {0x55728220, 0xD33C, 0x11CF, [0xBF, 0xC7, 0x44, 0x < 361 const GUID GUID_POV = {0xA36D02F2, 0xC9F3, 0x11CF, [0xBF, 0xC7, 0x44, 0x < 362 < 363 enum : uint < 364 { < 365 DISCL_EXCLUSIVE= 0x00000001, < 366 DISCL_NONEXCLUSIVE= 0x00000002, < 367 DISCL_FOREGROUND= 0x00000004, < 368 DISCL_BACKGROUND= 0x00000008, < 369 DISCL_NOWINKEY= 0x00000010, < 370 < 371 DIPH_DEVICE=0, < 372 DIPH_BYOFFSET=1, < 373 < 374 DI8DEVCLASS_GAMECTRL=4, < 375 DIEDFL_ATTACHEDONLY= 0x00000001, < 376 DIDFT_AXIS= 0x00000003 < 377 } < 378 < 379 enum < 380 { < 381 SEVERITY_SUCCESS= 0, < 382 SEVERITY_ERROR= 1, < 383 FACILITY_WIN32= 7, < 384 ERROR_READ_FAULT= 30L, < 385 DIENUM_CONTINUE= 1, < 386 DIPH_BYID= 2 < 387 } < 388 < 389 struct DIPROPDWORD < 390 { < 391 DIPROPHEADER diph; < 392 DWORD dwData; < 393 } < 394 < 395 template MAKE_HRESULT(uint sev, uint fac, uint code) < 396 { < 397 const HRESULT MAKE_HRESULT = cast(HRESULT)((sev << 31) | (fac << 16) | c < 398 } < 399 < 400 const HRESULT DIERR_OLDDIRECTINPUTVERSION = MAKE_HRESULT!(SEVERITY_E < 401 const HRESULT DIERR_BETADIRECTINPUTVERSION = MAKE_HRESULT!(SEVERITY_E < 402 const HRESULT DIERR_BADDRIVERVER = MAKE_HRESULT!(SEVERITY_E < 403 const HRESULT DIERR_DEVICENOTREG = 0x80040154; < 404 const HRESULT DIERR_NOTFOUND = MAKE_HRESULT!(SEVERITY_E < 405 const HRESULT DIERR_OBJECTNOTFOUND = MAKE_HRESULT!(SEVERITY_E < 406 const HRESULT DIERR_INVALIDPARAM = E_INVALIDARG; < 407 const HRESULT DIERR_NOINTERFACE = E_NOINTERFACE; < 408 const HRESULT DIERR_GENERIC = E_FAIL; < 409 const HRESULT DIERR_OUTOFMEMORY = E_OUTOFMEMORY; < 410 const HRESULT DIERR_UNSUPPORTED = E_NOTIMPL; < 411 const HRESULT DIERR_NOTINITIALIZED = MAKE_HRESULT!(SEVERITY_E < 412 const HRESULT DIERR_ALREADYINITIALIZED = MAKE_HRESULT!(SEVERITY_E < 413 const HRESULT DIERR_NOAGGREGATION = CLASS_E_NOAGGREGATION; < 414 const HRESULT DIERR_OTHERAPPHASPRIO = 0x80070005; < 415 const HRESULT DIERR_INPUTLOST = MAKE_HRESULT!(SEVERITY_E < 416 const HRESULT DIERR_ACQUIRED = MAKE_HRESULT!(SEVERITY_E < 417 const HRESULT DIERR_NOTACQUIRED = MAKE_HRESULT!(SEVERITY_E < 418 const HRESULT DIERR_READONLY = 0x80070005; < 419 const HRESULT DIERR_HANDLEEXISTS = 0x80070005; < 420 const HRESULT DIERR_INSUFFICIENTPRIVS = 0x80040200; < 421 const HRESULT DIERR_DEVICEFULL = 0x80040201; < 422 const HRESULT DIERR_MOREDATA = 0x80040202; < 423 const HRESULT DIERR_NOTDOWNLOADED = 0x80040203; < 424 const HRESULT DIERR_HASEFFECTS = 0x80040204; < 425 const HRESULT DIERR_NOTEXCLUSIVEACQUIRED = 0x80040205; < 426 const HRESULT DIERR_INCOMPLETEEFFECT = 0x80040206; < 427 const HRESULT DIERR_NOTBUFFERED = 0x80040207; < 428 const HRESULT DIERR_EFFECTPLAYING = 0x80040208; < 429 const HRESULT DIERR_UNPLUGGED = 0x80040209; < 430 const HRESULT DIERR_REPORTFULL = 0x8004020A; < 431 const HRESULT DIERR_MAPFILEFAIL = 0x8004020B; <
Deleted src/win32/directx/dinput8.def version [1cdb1e6b2d148f1f]
Deleted src/win32/directx/dsound8.d version [21a914ceb449058e]
1 module win32.directx.dsound8; < 2 < 3 //import tango.sys.win32.Types; < 4 import win32.windows; < 5 < 6 alias GUID* LPCGUID; < 7 < 8 interface IUnknown < 9 { < 10 HRESULT QueryInterface(IID* riid, void** pvObject); < 11 ULONG AddRef(); < 12 ULONG Release(); < 13 } < 14 < 15 alias IUnknown LPUNKNOWN; < 16 < 17 interface IDirectSound : IUnknown < 18 { < 19 extern(Windows): < 20 < 21 // IDirectSound methods < 22 HRESULT CreateSoundBuffer (LPCDSBUFFERDESC pcDSBufferDesc, LPDIRECTSOUNDB < 23 HRESULT GetCaps (LPDSCAPS pDSCaps); < 24 HRESULT DuplicateSoundBuffer (LPDIRECTSOUNDBUFFER pDSBufferOriginal, LPDIREC < 25 HRESULT SetCooperativeLevel (HWND hwnd, DWORD dwLevel); < 26 HRESULT Compact (); < 27 HRESULT GetSpeakerConfig (LPDWORD pdwSpeakerConfig); < 28 HRESULT SetSpeakerConfig (DWORD dwSpeakerConfig); < 29 HRESULT Initialize (LPCGUID pcGuidDevice); < 30 } < 31 < 32 alias IDirectSound LPDIRECTSOUND; < 33 < 34 interface IDirectSound8 : IDirectSound < 35 { < 36 extern(Windows): < 37 < 38 // IDirectSound8 methods < 39 HRESULT VerifyCertification (LPDWORD pdwCertified); < 40 } < 41 < 42 alias IDirectSound8 LPDIRECTSOUND8; < 43 < 44 interface IDirectSoundBuffer : IUnknown < 45 { < 46 extern(Windows): < 47 < 48 // IDirectSoundBuffer methods < 49 HRESULT GetCaps (LPDSBCAPS pDSBufferCaps); < 50 HRESULT GetCurrentPosition (LPDWORD pdwCurrentPlayCursor, LPDWORD pdwCurre < 51 HRESULT GetFormat (LPWAVEFORMATEX pwfxFormat, DWORD dwSizeAllocat < 52 HRESULT GetVolume (LPLONG plVolume); < 53 HRESULT GetPan (LPLONG plPan); < 54 HRESULT GetFrequency (LPDWORD pdwFrequency); < 55 HRESULT GetStatus (LPDWORD pdwStatus); < 56 HRESULT Initialize (LPDIRECTSOUND pDirectSound, LPCDSBUFFERDESC pc < 57 HRESULT Lock (DWORD dwOffset, DWORD dwBytes, LPVOID *ppvAudi < 58 LPVOID *ppvAudioPtr2, LPDWORD pdwAudi < 59 HRESULT Play (DWORD dwReserved1, DWORD dwPriority, DWORD dwF < 60 HRESULT SetCurrentPosition (DWORD dwNewPosition); < 61 HRESULT SetFormat (LPCWAVEFORMATEX pcfxFormat); < 62 HRESULT SetVolume (LONG lVolume); < 63 HRESULT SetPan (LONG lPan); < 64 HRESULT SetFrequency (DWORD dwFrequency); < 65 HRESULT Stop (); < 66 HRESULT Unlock (LPVOID pvAudioPtr1, DWORD dwAudioBytes1, LPVOI < 67 HRESULT Restore (); < 68 } < 69 < 70 alias IDirectSoundBuffer LPDIRECTSOUNDBUFFER; < 71 < 72 interface IDirectSound3DListener : IUnknown < 73 { < 74 extern(Windows): < 75 < 76 // IDirectSound3DListener methods < 77 HRESULT GetAllParameters (LPDS3DLISTENER pListener); < 78 HRESULT GetDistanceFactor (D3DVALUE* pflDistanceFactor); < 79 HRESULT GetDopplerFactor (D3DVALUE* pflDopplerFactor); < 80 HRESULT GetOrientation (D3DVECTOR* pvOrientFront, D3DVECTOR* pvOri < 81 HRESULT GetPosition (D3DVECTOR* pvPosition); < 82 HRESULT GetRolloffFactor (D3DVALUE* pflRolloffFactor); < 83 HRESULT GetVelocity (D3DVECTOR* pvVelocity); < 84 HRESULT SetAllParameters (LPCDS3DLISTENER pcListener, DWORD dwApply) < 85 HRESULT SetDistanceFactor (D3DVALUE flDistanceFactor, DWORD dwApply); < 86 HRESULT SetDopplerFactor (D3DVALUE flDopplerFactor, DWORD dwApply); < 87 HRESULT SetOrientation (D3DVALUE xFront, D3DVALUE yFront, D3DVALUE < 88 D3DVALUE xTop, D3DVALUE yTop, D3D < 89 HRESULT SetPosition (D3DVALUE x, D3DVALUE y, D3DVALUE z, DWORD < 90 HRESULT SetRolloffFactor (D3DVALUE flRolloffFactor, DWORD dwApply); < 91 HRESULT SetVelocity (D3DVALUE x, D3DVALUE y, D3DVALUE z, DWORD < 92 HRESULT CommitDeferredSettings (); < 93 } < 94 < 95 struct WAVEFORMATEX < 96 { < 97 ushort wFormatTag; < 98 ushort nChannels; < 99 uint nSamplesPerSec; < 100 uint nAvgBytesPerSec; < 101 ushort nBlockAlign; < 102 ushort wBitsPerSample; < 103 ushort cbSize; < 104 } < 105 < 106 alias WAVEFORMATEX* LPWAVEFORMATEX, LPCWAVEFORMATEX; < 107 < 108 enum : uint < 109 { < 110 WAVE_FORMAT_PCM = 1 < 111 } < 112 < 113 struct DSCBUFFERDESC < 114 { < 115 DWORD dwSize; < 116 DWORD dwFlags; < 117 DWORD dwBufferBytes; < 118 DWORD dwReserved; < 119 LPWAVEFORMATEX lpwfxFormat; < 120 DWORD dwFXCount; < 121 LPDSCEFFECTDESC lpDSCFXDesc; < 122 } < 123 < 124 alias DSCBUFFERDESC* LPDSCBUFFERDESC; < 125 < 126 struct DSBUFFERDESC < 127 { < 128 DWORD dwSize; < 129 DWORD dwFlags; < 130 DWORD dwBufferBytes; < 131 DWORD dwReserved; < 132 LPWAVEFORMATEX lpwfxFormat; < 133 GUID guid3DAlgorithm; < 134 } < 135 < 136 alias DSBUFFERDESC* LPCDSBUFFERDESC; < 137 < 138 struct DSCAPS < 139 { < 140 DWORD dwSize; < 141 DWORD dwFlags; < 142 DWORD dwMinSecondarySampleRate; < 143 DWORD dwMaxSecondarySampleRate; < 144 DWORD dwPrimaryBuffers; < 145 DWORD dwMaxHwMixingAllBuffers; < 146 DWORD dwMaxHwMixingStaticBuffers; < 147 DWORD dwMaxHwMixingStreamingBuffers; < 148 DWORD dwFreeHwMixingAllBuffers; < 149 DWORD dwFreeHwMixingStaticBuffers; < 150 DWORD dwFreeHwMixingStreamingBuffers; < 151 DWORD dwMaxHw3DAllBuffers; < 152 DWORD dwMaxHw3DStaticBuffers; < 153 DWORD dwMaxHw3DStreamingBuffers; < 154 DWORD dwFreeHw3DAllBuffers; < 155 DWORD dwFreeHw3DStaticBuffers; < 156 DWORD dwFreeHw3DStreamingBuffers; < 157 DWORD dwTotalHwMemBytes; < 158 DWORD dwFreeHwMemBytes; < 159 DWORD dwMaxContigFreeHwMemBytes; < 160 DWORD dwUnlockTransferRateHwBuffers; < 161 DWORD dwPlayCpuOverheadSwBuffers; < 162 DWORD dwReserved1; < 163 DWORD dwReserved2; < 164 } < 165 < 166 alias DSCAPS* LPDSCAPS; < 167 < 168 struct DSBCAPS < 169 { < 170 DWORD dwSize; < 171 DWORD dwFlags; < 172 DWORD dwBufferBytes; < 173 DWORD dwUnlockTransferRate; < 174 DWORD dwPlayCpuOverhead; < 175 } < 176 < 177 alias DSBCAPS *LPDSBCAPS; < 178 < 179 struct DSCEFFECTDESC < 180 { < 181 DWORD dwSize; < 182 DWORD dwFlags; < 183 GUID guidDSCFXClass; < 184 GUID guidDSCFXInstance; < 185 DWORD dwReserved1; < 186 DWORD dwReserved2; < 187 } < 188 < 189 alias DSCEFFECTDESC *LPDSCEFFECTDESC; < 190 < 191 struct DS3DLISTENER < 192 { < 193 DWORD dwSize; < 194 D3DVECTOR vPosition; < 195 D3DVECTOR vVelocity; < 196 D3DVECTOR vOrientFront; < 197 D3DVECTOR vOrientTop; < 198 D3DVALUE flDistanceFactor; < 199 D3DVALUE flRolloffFactor; < 200 D3DVALUE flDopplerFactor; < 201 } < 202 < 203 alias DS3DLISTENER *LPDS3DLISTENER, LPCDS3DLISTENER; < 204 < 205 alias float D3DVALUE; < 206 < 207 struct D3DVECTOR < 208 { < 209 float x; < 210 float y; < 211 float z; < 212 } < 213 < 214 extern(Windows) export HRESULT DirectSoundCreate8(LPCGUID pcGuidDevice, LPDIRECT < 215 < 216 const DSSCL_PRIORITY = 0x00000002; < 217 const DSBCAPS_PRIMARYBUFFER = 0x00000001; < 218 const DSBCAPS_CTRL3D = 0x00000010; < 219 const DSBCAPS_GETCURRENTPOSITION2 = 0x00010000; < 220 const DSBCAPS_LOCDEFER = 0x00040000; < 221 const DSBPLAY_LOOPING = 0x00000001; < 222 const DSBSTATUS_PLAYING = 0x00000001; < 223 const DSBCAPS_CTRLFREQUENCY = 0x00000020; < 224 const DSBCAPS_CTRLPAN = 0x00000040; < 225 const DSBCAPS_CTRLVOLUME = 0x00000080; < 226 const DSBLOCK_ENTIREBUFFER = 0x00000002; < 227 < 228 const GUID IID_IDirectSound3DListener8 = {0x279AFA84,0x4981,0x11CE,[0xA5, 0x21, <
Deleted src/win32/directx/dsound8.def version [ccf10df672f0f7ce]
Deleted src/win32/directx/dxerr.d version [9090410cc0efe452]
1 /***********************************************************************\ < 2 * dxerr.d * < 3 * * < 4 * Windows API header module * < 5 * * < 6 * Placed into public domain * < 7 \***********************************************************************/ < 8 module win32.directx.dxerr; < 9 < 10 import win32.windows; < 11 < 12 pragma(lib, "dxerr.lib"); < 13 < 14 extern (Windows) { < 15 CHAR* DXGetErrorStringA(HRESULT hr); < 16 WCHAR* DXGetErrorStringW(HRESULT hr); < 17 CHAR* DXGetErrorDescriptionA(HRESULT hr); < 18 WCHAR* DXGetErrorDescriptionW(HRESULT hr); < 19 HRESULT DXTraceA(CHAR* strFile, DWORD dwLine, HRESULT hr, CHAR* strMsg, < 20 BOOL bPopMsgBox); < 21 HRESULT DXTraceW(CHAR* strFile, DWORD dwLine, HRESULT hr, WCHAR* strMsg, < 22 BOOL bPopMsgBox); < 23 } < 24 < 25 version (Unicode) { < 26 alias DXGetErrorStringW DXGetErrorString; < 27 alias DXGetErrorDescriptionW DXGetErrorDescription; < 28 alias DXTraceW DXTrace; < 29 } else { < 30 alias DXGetErrorStringA DXGetErrorString; < 31 alias DXGetErrorDescriptionA DXGetErrorDescription; < 32 alias DXTraceA DXTrace; < 33 } < 34 < 35 debug (dxerr) { < 36 HRESULT DXTRACE_MSG(TCHAR* str) { < 37 return DXTrace(__FILE__, __LINE__, 0, str, false); < 38 } < 39 HRESULT DXTRACE_ERR(TCHAR* str, HRESULT hr) { < 40 return DXTrace(__FILE__, __LINE__, hr, str, false); < 41 } < 42 HRESULT DXTRACE_ERR_MSGBOX(TCHAR* str, HRESULT hr) { < 43 return DXTrace(__FILE__, __LINE__, hr, str, true); < 44 } < 45 } else { < 46 HRESULT DXTRACE_MSG(TCHAR* str) { < 47 return 0; < 48 } < 49 HRESULT DXTRACE_ERR(TCHAR* str, HRESULT hr) { < 50 return hr; < 51 } < 52 HRESULT DXTRACE_ERR_MSGBOX(TCHAR* str, HRESULT hr) { < 53 return hr; < 54 } < 55 } <
Deleted src/win32/directx/dxerr8.d version [34ddc3a78f9452b8]
1 /***********************************************************************\ < 2 * dxerr8.d * < 3 * * < 4 * Windows API header module * < 5 * * < 6 * Translated from MinGW Windows headers * < 7 * * < 8 * Placed into public domain * < 9 \***********************************************************************/ < 10 module win32.directx.dxerr8; < 11 < 12 /* < 13 dxerr8.d - Header file for the DirectX 8 Error API < 14 < 15 Written by Filip Navara <xnavara@volny.cz> < 16 Ported to D by James Pelcis <jpelcis@gmail.com> < 17 < 18 This library is distributed in the hope that it will be useful, < 19 but WITHOUT ANY WARRANTY; without even the implied warranty of < 20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. < 21 */ < 22 < 23 private import win32.windef; < 24 < 25 extern (Windows) { < 26 char* DXGetErrorString8A (HRESULT); < 27 WCHAR* DXGetErrorString8W (HRESULT); < 28 char* DXGetErrorDescription8A (HRESULT); < 29 WCHAR* DXGetErrorDescription8W (HRESULT); < 30 HRESULT DXTraceA (char*, DWORD, HRESULT, char*, BOOL); < 31 HRESULT DXTraceW (char*, DWORD, HRESULT, WCHAR*, BOOL); < 32 } < 33 < 34 version (Unicode) { < 35 alias DXGetErrorString8W DXGetErrorString8; < 36 alias DXGetErrorDescription8W DXGetErrorDescription8; < 37 alias DXTraceW DXTrace; < 38 } else { < 39 alias DXGetErrorString8A DXGetErrorString8; < 40 alias DXGetErrorDescription8A DXGetErrorDescription8; < 41 alias DXTraceA DXTrace; < 42 } < 43 < 44 debug (dxerr) { < 45 HRESULT DXTRACE_MSG(TCHAR* str) { < 46 return DXTrace(__FILE__, __LINE__, 0, str, FALSE); < 47 } < 48 < 49 HRESULT DXTRACE_ERR(TCHAR* str, HRESULT hr) { < 50 return DXTrace(__FILE__, __LINE__, hr, str, TRUE); < 51 } < 52 < 53 HRESULT DXTRACE_ERR_NOMSGBOX (WCHAR* str, HRESULT hr) { < 54 return DXTrace(__FILE__, __LINE__, hr, str, FALSE); < 55 } < 56 } else { < 57 HRESULT DXTRACE_MSG(TCHAR* str) { < 58 return 0; < 59 } < 60 < 61 HRESULT DXTRACE_ERR(TCHAR* str, HRESULT hr) { < 62 return hr; < 63 } < 64 < 65 HRESULT DXTRACE_ERR_NOMSGBOX(TCHAR* str, HRESULT hr) { < 66 return hr; < 67 } < 68 } <
Deleted src/win32/directx/dxerr9.d version [ceb1fd2634da5b6a]
1 /***********************************************************************\ < 2 * dxerr9.d * < 3 * * < 4 * Windows API header module * < 5 * * < 6 * Translated from MinGW Windows headers * < 7 * * < 8 * Placed into public domain * < 9 \***********************************************************************/ < 10 module win32.directx.dxerr9; < 11 < 12 /* < 13 dxerr9.h - Header file for the DirectX 9 Error API < 14 < 15 Written by Filip Navara <xnavara@volny.cz> < 16 Ported to D by James Pelcis <jpelcis@gmail.com> < 17 < 18 This library is distributed in the hope that it will be useful, < 19 but WITHOUT ANY WARRANTY; without even the implied warranty of < 20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. < 21 < 22 */ < 23 < 24 private import win32.windef; < 25 < 26 extern (Windows) { < 27 char* DXGetErrorString9A(HRESULT); < 28 WCHAR* DXGetErrorString9W(HRESULT); < 29 char* DXGetErrorDescription9A(HRESULT); < 30 WCHAR* DXGetErrorDescription9W(HRESULT); < 31 HRESULT DXTraceA(char*, DWORD, HRESULT, char*, BOOL); < 32 HRESULT DXTraceW(char*, DWORD, HRESULT, WCHAR*, BOOL); < 33 } < 34 < 35 version (Unicode) { < 36 alias DXGetErrorString9W DXGetErrorString9; < 37 alias DXGetErrorDescription9W DXGetErrorDescription9; < 38 alias DXTraceW DXTrace; < 39 } else { < 40 alias DXGetErrorString9A DXGetErrorString9; < 41 alias DXGetErrorDescription9A DXGetErrorDescription9; < 42 alias DXTraceA DXTrace; < 43 } < 44 < 45 debug (dxerr) { < 46 HRESULT DXTRACE_MSG(TCHAR* str) { < 47 return DXTrace(__FILE__, cast(DWORD)__LINE__, 0, str, FALSE); < 48 } < 49 < 50 HRESULT DXTRACE_ERR(TCHAR* str, HRESULT hr) { < 51 return DXTrace(__FILE__, cast(DWORD)__LINE__, hr, str, FALSE); < 52 } < 53 < 54 HRESULT DXTRACE_ERR_NOMSGBOX(TCHAR* str, HRESULT hr) { < 55 return DXTrace(__FILE__, cast(DWORD)__LINE__, hr, str, TRUE); < 56 } < 57 } else { < 58 HRESULT DXTRACE_MSG(TCHAR* str) { < 59 return 0; < 60 } < 61 < 62 HRESULT DXTRACE_ERR(TCHAR* str, HRESULT hr) { < 63 return hr; < 64 } < 65 < 66 HRESULT DXTRACE_ERR_NOMSGBOX(TCHAR* str, HRESULT hr) { < 67 return hr; < 68 } < 69 } <
Deleted src/win32/directx/dxgi.d version [01a31b5a86041999]
1 /***********************************************************************\ < 2 * dxgi.d * < 3 * * < 4 * Windows API header module * < 5 * * < 6 * Placed into public domain * < 7 \***********************************************************************/ < 8 module win32.directx.dxgi; < 9 < 10 private import win32.windows; < 11 < 12 private import win32.directx.dxgitype; < 13 < 14 enum { < 15 DXGI_CPU_ACCESS_NONE = 0, < 16 DXGI_CPU_ACCESS_DYNAMIC = 1, < 17 DXGI_CPU_ACCESS_READ_WRITE = 2, < 18 DXGI_CPU_ACCESS_SCRATCH = 3, < 19 DXGI_CPU_ACCESS_FIELD = 15 < 20 } < 21 < 22 enum { < 23 DXGI_USAGE_SHADER_INPUT = 0b00_00010000, < 24 DXGI_USAGE_RENDER_TARGET_OUTPUT = 0b00_00100000, < 25 DXGI_USAGE_BACK_BUFFER = 0b00_01000000, < 26 DXGI_USAGE_SHARED = 0b00_10000000, < 27 DXGI_USAGE_READ_ONLY = 0b01_00000000, < 28 DXGI_USAGE_DISCARD_ON_PRESENT = 0b10_00000000, < 29 } < 30 alias UINT DXGI_USAGE; < 31 < 32 struct DXGI_FRAME_STATISTICS { < 33 UINT PresentCount; < 34 UINT PresentRefreshCount; < 35 UINT SyncRefreshCount; < 36 LARGE_INTEGER SyncQPCTime; < 37 LARGE_INTEGER SyncGPUTime; < 38 } < 39 < 40 struct DXGI_MAPPED_RECT { < 41 INT Pitch; < 42 BYTE* pBits; < 43 } < 44 < 45 struct DXGI_ADAPTER_DESC { < 46 WCHAR[128] Description; < 47 UINT VendorId; < 48 UINT DeviceId; < 49 UINT SubSysId; < 50 UINT Revision; < 51 SIZE_T DedicatedVideoMemory; < 52 SIZE_T DedicatedSystemMemory; < 53 SIZE_T SharedSystemMemory; < 54 LUID AdapterLuid; < 55 } < 56 < 57 struct DXGI_OUTPUT_DESC { < 58 WCHAR[32] DeviceName; < 59 RECT DesktopCoordinates; < 60 BOOL AttachedToDesktop; < 61 DXGI_MODE_ROTATION Rotation; < 62 HMONITOR Monitor; < 63 } < 64 < 65 struct DXGI_SHARED_RESOURCE { < 66 HANDLE Handle; < 67 } < 68 < 69 enum { < 70 DXGI_RESOURCE_PRIORITY_MINIMUM = 0x28000000, < 71 DXGI_RESOURCE_PRIORITY_LOW = 0x50000000, < 72 DXGI_RESOURCE_PRIORITY_NORMAL = 0x78000000, < 73 DXGI_RESOURCE_PRIORITY_HIGH = 0xa0000000, < 74 DXGI_RESOURCE_PRIORITY_MAXIMUM = 0xc8000000 < 75 } < 76 < 77 enum DXGI_RESIDENCY { < 78 DXGI_RESIDENCY_FULLY_RESIDENT = 1, < 79 DXGI_RESIDENCY_RESIDENT_IN_SHARED_MEMORY = 2, < 80 DXGI_RESIDENCY_EVICTED_TO_DISK = 3 < 81 } < 82 < 83 struct DXGI_SURFACE_DESC { < 84 UINT Width; < 85 UINT Height; < 86 DXGI_FORMAT Format; < 87 DXGI_SAMPLE_DESC SampleDesc; < 88 } < 89 < 90 enum DXGI_SWAP_EFFECT { < 91 DXGI_SWAP_EFFECT_DISCARD = 0, < 92 DXGI_SWAP_EFFECT_SEQUENTIAL = 1 < 93 } < 94 < 95 enum DXGI_SWAP_CHAIN_FLAG { < 96 DXGI_SWAP_CHAIN_FLAG_NONPREROTATED = 1, < 97 DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH = 2 < 98 } < 99 < 100 struct DXGI_SWAP_CHAIN_DESC { < 101 DXGI_MODE_DESC BufferDesc; < 102 DXGI_SAMPLE_DESC SampleDesc; < 103 DXGI_USAGE BufferUsage; < 104 UINT BufferCount; < 105 HWND OutputWindow; < 106 BOOL Windowed; < 107 DXGI_SWAP_EFFECT SwapEffect; < 108 UINT Flags; < 109 } < 110 < 111 interface IDXGIObject : IUnknown { < 112 extern(Windows) : < 113 HRESULT SetPrivateData(REFGUID Name, UINT DataSize, void* pData); < 114 HRESULT SetPrivateDataInterface(REFGUID Name, IUnknown pUnknown); < 115 HRESULT GetPrivateData(REFGUID Name, UINT* pDataSize, void* pData); < 116 HRESULT GetParent(REFIID riid, void** ppParent); < 117 } < 118 < 119 interface IDXGIDeviceSubObject : IDXGIObject { < 120 extern(Windows) : < 121 HRESULT GetDevice(REFIID riid, void** ppDevice); < 122 } < 123 < 124 interface IDXGIResource : IDXGIDeviceSubObject { < 125 extern(Windows) : < 126 HRESULT GetSharedHandle(HANDLE* pSharedHandle); < 127 HRESULT GetUsage(DXGI_USAGE* pUsage); < 128 HRESULT SetEvictionPriority(UINT EvictionPriority); < 129 HRESULT GetEvictionPriority(UINT* pEvictionPriority); < 130 } < 131 < 132 interface IDXGISurface : IDXGIDeviceSubObject { < 133 extern(Windows) : < 134 HRESULT GetDesc(DXGI_SURFACE_DESC* pDesc); < 135 HRESULT Map(DXGI_MAPPED_RECT* pLockedRect, UINT MapFlags); < 136 HRESULT Unmap(); < 137 } < 138 < 139 interface IDXGIAdapter : IDXGIObject { < 140 extern(Windows) : < 141 HRESULT EnumOutputs(UINT Output, IDXGIOutput* ppOutput); < 142 HRESULT GetDesc(DXGI_ADAPTER_DESC* pDesc); < 143 HRESULT CheckInterfaceSupport(REFGUID InterfaceName, LARGE_INTEGER* pUMD < 144 } < 145 < 146 interface IDXGIOutput : IDXGIObject { < 147 extern(Windows) : < 148 HRESULT GetDesc(DXGI_OUTPUT_DESC* pDesc); < 149 HRESULT GetDisplayModeList(DXGI_FORMAT EnumFormat, UINT Flags, UINT* pNu < 150 HRESULT FindClosestMatchingMode(DXGI_MODE_DESC* pModeToMatch, DXGI_MODE_ < 151 HRESULT WaitForVBlank(); < 152 HRESULT TakeOwnership(IUnknown pDevice, BOOL Exclusive); < 153 void ReleaseOwnership(); < 154 HRESULT GetGammaControlCapabilities(DXGI_GAMMA_CONTROL_CAPABILITIES* pGa < 155 HRESULT SetGammaControl(DXGI_GAMMA_CONTROL* pArray); < 156 HRESULT GetGammaControl(DXGI_GAMMA_CONTROL* pArray); < 157 HRESULT SetDisplaySurface(IDXGISurface pScanoutSurface); < 158 HRESULT GetDisplaySurfaceData(IDXGISurface pDestination); < 159 HRESULT GetFrameStatistics(DXGI_FRAME_STATISTICS* pStats); < 160 } < 161 < 162 const DXGI_MAX_SWAP_CHAIN_BUFFERS = 16; < 163 < 164 enum { < 165 DXGI_PRESENT_TEST = 0x00000001, < 166 DXGI_PRESENT_DO_NOT_SEQUENCE = 0x00000002, < 167 DXGI_PRESENT_RESTART = 0x00000004 < 168 } < 169 < 170 interface IDXGISwapChain : IDXGIDeviceSubObject { < 171 extern(Windows) : < 172 HRESULT Present(UINT SyncInterval, UINT Flags); < 173 HRESULT GetBuffer(UINT Buffer, REFIID riid, void** ppSurface); < 174 HRESULT SetFullscreenState(BOOL Fullscreen, IDXGIOutput pTarget); < 175 HRESULT GetFullscreenState(BOOL* pFullscreen, IDXGIOutput* ppTarget); < 176 HRESULT GetDesc(DXGI_SWAP_CHAIN_DESC* pDesc); < 177 HRESULT ResizeBuffers(UINT BufferCount, UINT Width, UINT Height, DXGI_FO < 178 HRESULT ResizeTarget(DXGI_MODE_DESC* pNewTargetParameters); < 179 HRESULT GetContainingOutput(IDXGIOutput* ppOutput); < 180 HRESULT GetFrameStatistics(DXGI_FRAME_STATISTICS* pStats); < 181 HRESULT GetLastPresentCount(UINT* pLastPresentCount); < 182 } < 183 < 184 interface IDXGIFactory : IDXGIObject { < 185 extern(Windows) : < 186 HRESULT EnumAdapters(UINT Adapter, IDXGIAdapter* ppAdapter); < 187 HRESULT MakeWindowAssociation(HWND WindowHandle, UINT Flags); < 188 HRESULT GetWindowAssociation(HWND* pWindowHandle); < 189 HRESULT CreateSwapChain(IUnknown pDevice, DXGI_SWAP_CHAIN_DESC* pDesc, I < 190 HRESULT CreateSoftwareAdapter(HMODULE Module, IDXGIAdapter* ppAdapter); < 191 } < 192 < 193 interface IDXGIDevice : IDXGIObject { < 194 extern(Windows) : < 195 HRESULT GetAdapter(IDXGIAdapter* pAdapter); < 196 HRESULT CreateSurface(DXGI_SURFACE_DESC* pDesc, UINT NumSurfaces, DXGI_U < 197 HRESULT QueryResourceResidency(IUnknown* ppResources, DXGI_RESIDENCY* pR < 198 HRESULT SetGPUThreadPriority(INT Priority); < 199 HRESULT GetGPUThreadPriority(INT* pPriority); < 200 } < 201 < 202 extern(C) const GUID IID_IDXGIObject = {0xaec22fb8, 0x76f3, 0 < 203 extern(C) const GUID IID_IDXGIDeviceSubObject = {0x3d3e0379, 0xf9de, 0x4d58, [ < 204 extern(C) const GUID IID_IDXGIResource = {0x035f3ab4, 0x482e, 0 < 205 extern(C) const GUID IID_IDXGISurface = {0xcafcb56c, 0x6ac3, 0 < 206 extern(C) const GUID IID_IDXGIAdapter = {0x2411e7e1, 0x12ac, 0 < 207 extern(C) const GUID IID_IDXGIOutput = {0xae02eedb, 0xc735, 0 < 208 extern(C) const GUID IID_IDXGISwapChain = {0x310d36a0, 0xd2e7, 0 < 209 extern(C) const GUID IID_IDXGIFactory = {0x7b7166ec, 0x21c7, 0 < 210 extern(C) const GUID IID_IDXGIDevice = {0x54ec77fa, 0x1377, 0 < 211 <
Deleted src/win32/directx/dxgitype.d version [84641e2b98a36529]
1 /***********************************************************************\ < 2 * dxgitype.d * < 3 * * < 4 * Windows API header module * < 5 * * < 6 * Placed into public domain * < 7 \***********************************************************************/ < 8 module win32.directx.dxgitype; < 9 < 10 private import win32.windows; < 11 < 12 const _FACDXGI = 0x87a; < 13 < 14 HRESULT MAKE_DXGI_HRESULT(T)(T code) { < 15 return MAKE_HRESULT(1, _FACDXGI, code); < 16 } < 17 < 18 HRESULT MAKE_DXGI_STATUS(T)(T code) { < 19 return MAKE_HRESULT(0, _FACDXGI, code); < 20 } < 21 < 22 const HRESULT DXGI_STATUS_OCCLUDED < 23 const HRESULT DXGI_STATUS_CLIPPED < 24 const HRESULT DXGI_STATUS_NO_REDIRECTION = MAKE_D < 25 const HRESULT DXGI_STATUS_NO_DESKTOP_ACCESS = MAKE_D < 26 const HRESULT DXGI_STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE = MAKE_DXGI_STATUS(6); < 27 const HRESULT DXGI_STATUS_MODE_CHANGED = MAKE_D < 28 const HRESULT DXGI_STATUS_MODE_CHANGE_IN_PROGRESS = MAKE_DXGI_STAT < 29 const HRESULT DXGI_ERROR_INVALID_CALL = MAKE_D < 30 const HRESULT DXGI_ERROR_NOT_FOUND < 31 const HRESULT DXGI_ERROR_MORE_DATA < 32 const HRESULT DXGI_ERROR_UNSUPPORTED = MAKE_D < 33 const HRESULT DXGI_ERROR_DEVICE_REMOVED = MAKE_D < 34 const HRESULT DXGI_ERROR_DEVICE_HUNG = MAKE_D < 35 const HRESULT DXGI_ERROR_DEVICE_RESET = MAKE_D < 36 const HRESULT DXGI_ERROR_WAS_STILL_DRAWING = MAKE_D < 37 const HRESULT DXGI_ERROR_FRAME_STATISTICS_DISJOINT = MAKE_DXGI_HRES < 38 const HRESULT DXGI_ERROR_GRAPHICS_VIDPN_SOURCE_IN_USE = MAKE_DXGI_HRESULT(12); < 39 const HRESULT DXGI_ERROR_DRIVER_INTERNAL_ERROR = MAKE_DXGI_HRES < 40 const HRESULT DXGI_ERROR_NONEXCLUSIVE = MAKE_D < 41 const HRESULT DXGI_ERROR_NOT_CURRENTLY_AVAILABLE = MAKE_DXGI_HRES < 42 const HRESULT DXGI_FORMAT_DEFINED < 43 < 44 enum DXGI_FORMAT { < 45 DXGI_FORMAT_UNKNOWN = 0, < 46 DXGI_FORMAT_R32G32B32A32_TYPELESS, < 47 DXGI_FORMAT_R32G32B32A32_FLOAT, < 48 DXGI_FORMAT_R32G32B32A32_UINT, < 49 DXGI_FORMAT_R32G32B32A32_SINT, < 50 DXGI_FORMAT_R32G32B32_TYPELESS, < 51 DXGI_FORMAT_R32G32B32_FLOAT, < 52 DXGI_FORMAT_R32G32B32_UINT, < 53 DXGI_FORMAT_R32G32B32_SINT, < 54 DXGI_FORMAT_R16G16B16A16_TYPELESS, < 55 DXGI_FORMAT_R16G16B16A16_FLOAT, < 56 DXGI_FORMAT_R16G16B16A16_UNORM, < 57 DXGI_FORMAT_R16G16B16A16_UINT, < 58 DXGI_FORMAT_R16G16B16A16_SNORM, < 59 DXGI_FORMAT_R16G16B16A16_SINT, < 60 DXGI_FORMAT_R32G32_TYPELESS, < 61 DXGI_FORMAT_R32G32_FLOAT, < 62 DXGI_FORMAT_R32G32_UINT, < 63 DXGI_FORMAT_R32G32_SINT, < 64 DXGI_FORMAT_R32G8X24_TYPELESS, < 65 DXGI_FORMAT_D32_FLOAT_S8X24_UINT, < 66 DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS, < 67 DXGI_FORMAT_X32_TYPELESS_G8X24_UINT, < 68 DXGI_FORMAT_R10G10B10A2_TYPELESS, < 69 DXGI_FORMAT_R10G10B10A2_UNORM, < 70 DXGI_FORMAT_R10G10B10A2_UINT, < 71 DXGI_FORMAT_R11G11B10_FLOAT, < 72 DXGI_FORMAT_R8G8B8A8_TYPELESS, < 73 DXGI_FORMAT_R8G8B8A8_UNORM, < 74 DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, < 75 DXGI_FORMAT_R8G8B8A8_UINT, < 76 DXGI_FORMAT_R8G8B8A8_SNORM, < 77 DXGI_FORMAT_R8G8B8A8_SINT, < 78 DXGI_FORMAT_R16G16_TYPELESS, < 79 DXGI_FORMAT_R16G16_FLOAT, < 80 DXGI_FORMAT_R16G16_UNORM, < 81 DXGI_FORMAT_R16G16_UINT, < 82 DXGI_FORMAT_R16G16_SNORM, < 83 DXGI_FORMAT_R16G16_SINT, < 84 DXGI_FORMAT_R32_TYPELESS, < 85 DXGI_FORMAT_D32_FLOAT, < 86 DXGI_FORMAT_R32_FLOAT, < 87 DXGI_FORMAT_R32_UINT, < 88 DXGI_FORMAT_R32_SINT, < 89 DXGI_FORMAT_R24G8_TYPELESS, < 90 DXGI_FORMAT_D24_UNORM_S8_UINT, < 91 DXGI_FORMAT_R24_UNORM_X8_TYPELESS, < 92 DXGI_FORMAT_X24_TYPELESS_G8_UINT, < 93 DXGI_FORMAT_R8G8_TYPELESS, < 94 DXGI_FORMAT_R8G8_UNORM, < 95 DXGI_FORMAT_R8G8_UINT, < 96 DXGI_FORMAT_R8G8_SNORM, < 97 DXGI_FORMAT_R8G8_SINT, < 98 DXGI_FORMAT_R16_TYPELESS, < 99 DXGI_FORMAT_R16_FLOAT, < 100 DXGI_FORMAT_D16_UNORM, < 101 DXGI_FORMAT_R16_UNORM, < 102 DXGI_FORMAT_R16_UINT, < 103 DXGI_FORMAT_R16_SNORM, < 104 DXGI_FORMAT_R16_SINT, < 105 DXGI_FORMAT_R8_TYPELESS, < 106 DXGI_FORMAT_R8_UNORM, < 107 DXGI_FORMAT_R8_UINT, < 108 DXGI_FORMAT_R8_SNORM, < 109 DXGI_FORMAT_R8_SINT, < 110 DXGI_FORMAT_A8_UNORM, < 111 DXGI_FORMAT_R1_UNORM, < 112 DXGI_FORMAT_R9G9B9E5_SHAREDEXP, < 113 DXGI_FORMAT_R8G8_B8G8_UNORM, < 114 DXGI_FORMAT_G8R8_G8B8_UNORM, < 115 DXGI_FORMAT_BC1_TYPELESS, < 116 DXGI_FORMAT_BC1_UNORM, < 117 DXGI_FORMAT_BC1_UNORM_SRGB, < 118 DXGI_FORMAT_BC2_TYPELESS, < 119 DXGI_FORMAT_BC2_UNORM, < 120 DXGI_FORMAT_BC2_UNORM_SRGB, < 121 DXGI_FORMAT_BC3_TYPELESS, < 122 DXGI_FORMAT_BC3_UNORM, < 123 DXGI_FORMAT_BC3_UNORM_SRGB, < 124 DXGI_FORMAT_BC4_TYPELESS, < 125 DXGI_FORMAT_BC4_UNORM, < 126 DXGI_FORMAT_BC4_SNORM, < 127 DXGI_FORMAT_BC5_TYPELESS, < 128 DXGI_FORMAT_BC5_UNORM, < 129 DXGI_FORMAT_BC5_SNORM, < 130 DXGI_FORMAT_B5G6R5_UNORM, < 131 DXGI_FORMAT_B5G5R5A1_UNORM, < 132 DXGI_FORMAT_B8G8R8A8_UNORM, < 133 DXGI_FORMAT_B8G8R8X8_UNORM, < 134 DXGI_FORMAT_FORCE_UINT = 0xffffffff < 135 } < 136 < 137 struct DXGI_RGB { < 138 float Red; < 139 float Green; < 140 float Blue; < 141 } < 142 < 143 struct DXGI_GAMMA_CONTROL { < 144 DXGI_RGB Scale; < 145 DXGI_RGB Offset; < 146 DXGI_RGB[1025] GammaCurve; < 147 } < 148 < 149 struct DXGI_GAMMA_CONTROL_CAPABILITIES { < 150 BOOL ScaleAndOffsetSupported; < 151 float MaxConvertedValue; < 152 float MinConvertedValue; < 153 UINT NumGammaControlPoints; < 154 float[1025] ControlPointPositions; < 155 } < 156 < 157 struct DXGI_RATIONAL { < 158 UINT Numerator; < 159 UINT Denominator; < 160 } < 161 < 162 enum DXGI_MODE_SCANLINE_ORDER { < 163 DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED = 0, < 164 DXGI_MODE_SCANLINE_ORDER_PROGRESSIVE = 1, < 165 DXGI_MODE_SCANLINE_ORDER_UPPER_FIELD_FIRST = 2, < 166 DXGI_MODE_SCANLINE_ORDER_LOWER_FIELD_FIRST = 3 < 167 } < 168 < 169 enum DXGI_MODE_SCALING { < 170 DXGI_MODE_SCALING_UNSPECIFIED = 0, < 171 DXGI_MODE_SCALING_CENTERED = 1, < 172 DXGI_MODE_SCALING_STRETCHED = 2 < 173 } < 174 < 175 enum DXGI_MODE_ROTATION { < 176 DXGI_MODE_ROTATION_UNSPECIFIED = 0, < 177 DXGI_MODE_ROTATION_IDENTITY = 1, < 178 DXGI_MODE_ROTATION_ROTATE90 = 2, < 179 DXGI_MODE_ROTATION_ROTATE180 = 3, < 180 DXGI_MODE_ROTATION_ROTATE270 = 4 < 181 } < 182 < 183 struct DXGI_MODE_DESC { < 184 UINT Width; < 185 UINT Height; < 186 DXGI_RATIONAL RefreshRate; < 187 DXGI_FORMAT Format; < 188 DXGI_MODE_SCANLINE_ORDER ScanlineOrdering; < 189 DXGI_MODE_SCALING Scaling; < 190 } < 191 < 192 struct DXGI_SAMPLE_DESC { < 193 UINT Count; < 194 UINT Quality; < 195 } <