SlimDXc_Jun2010(VC++2008)/source/d3dcompiler/EnumsDC.h

   1 /*\r
   2 * Copyright (c) 2007-2010 SlimDX Group\r
   3 * \r
   4 * Permission is hereby granted, free of charge, to any person obtaining a copy\r
   5 * of this software and associated documentation files (the "Software"), to deal\r
   6 * in the Software without restriction, including without limitation the rights\r
   7 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r
   8 * copies of the Software, and to permit persons to whom the Software is\r
   9 * furnished to do so, subject to the following conditions:\r
  10 * \r
  11 * The above copyright notice and this permission notice shall be included in\r
  12 * all copies or substantial portions of the Software.\r
  13 * \r
  14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r
  15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r
  16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r
  17 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r
  18 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r
  19 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\r
  20 * THE SOFTWARE.\r
  21 */\r
  22 #pragma once\r
  23 \r
  24 #include "../direct3d11/Enums11.h"\r
  25 \r
  26 namespace SlimDX\r
  27 {\r
  28         namespace D3DCompiler\r
  29         {\r
  30                 // NOTE: The enumerations defined in this file are in alphabetical order. When\r
  31                 //       adding new enumerations or renaming existing ones, please make sure\r
  32                 //       the ordering is maintained.\r
  33 \r
  34                 /// <summary>\r
  35                 /// Indicates a constant buffer's type.\r
  36                 /// </summary>\r
  37                 /// <unmanaged>D3D11_CBUFFER_TYPE</unmanaged>\r
  38                 public enum class ConstantBufferType : System::Int32\r
  39                 {\r
  40                         /// <summary>\r
  41                         /// A buffer containing scalar constants.\r
  42                         /// </summary>\r
  43                         ConstantBuffer = D3D11_CT_CBUFFER,\r
  44 \r
  45                         /// <summary>\r
  46                         /// A buffer containing texture data.\r
  47                         /// </summary>\r
  48                         TextureBuffer = D3D11_CT_TBUFFER,\r
  49 \r
  50                         /// <summary>\r
  51                         /// A buffer containing interface pointers.\r
  52                         /// </summary>\r
  53                         InterfacePointers = D3D11_CT_INTERFACE_POINTERS,\r
  54 \r
  55                         /// <summary>\r
  56                         /// A buffer containing binding information.\r
  57                         /// </summary>\r
  58                         ResourceBinding = D3D11_CT_RESOURCE_BIND_INFO\r
  59                 };\r
  60 \r
  61                 /// <summary>\r
  62                 /// Specifies flags that affect the output of shader disassembly.\r
  63                 /// </summary>\r
  64                 [System::Flags]\r
  65                 public enum class DisassemblyFlags : System::Int32\r
  66                 {\r
  67                         /// <summary>\r
  68                         /// No specific flags specified.\r
  69                         /// </summary>\r
  70                         None = 0,\r
  71 \r
  72                         /// <summary>\r
  73                         /// Enable the output of color codes.\r
  74                         /// </summary>\r
  75                         EnableColorCodes = D3D_DISASM_ENABLE_COLOR_CODE,\r
  76 \r
  77                         /// <summary>\r
  78                         /// Enable the output of default values.\r
  79                         /// </summary>\r
  80                         EnableDefaultValues = D3D_DISASM_ENABLE_DEFAULT_VALUE_PRINTS,\r
  81 \r
  82                         /// <summary>\r
  83                         /// Enable instruction numbering.\r
  84                         /// </summary>\r
  85                         EnableInstructionNumbering = D3D_DISASM_ENABLE_INSTRUCTION_NUMBERING\r
  86                 };\r
  87 \r
  88                 /// <summary>Specifies compile- or run-time options during effect creation.</summary>\r
  89                 /// <unmanaged>D3D10_EFFECT</unmanaged>\r
  90                 [System::Flags]\r
  91                 public enum class EffectFlags : System::Int32\r
  92                 {\r
  93                         /// <summary>\r
  94                         /// Standard compile- and run-time behavior.\r
  95                         /// </summary>\r
  96                         None = 0,\r
  97                         \r
  98                         /// <summary>\r
  99                         /// Compile the .fx file to a child effect. Child effects do not initialize shared values\r
 100                         /// (as those values are instead initialized by the effect pool).\r
 101                         /// </summary>\r
 102                         ChildEffect = D3D10_EFFECT_COMPILE_CHILD_EFFECT,\r
 103                         \r
 104                         /// <summary>\r
 105                         /// Allow mutable state objects (non-literal expressions may appear in state object definitions). This\r
 106                         /// has a negative impact on run-time performance.\r
 107                         /// </summary>\r
 108                         AllowSlowOperations = D3D10_EFFECT_COMPILE_ALLOW_SLOW_OPS,\r
 109                         \r
 110                         /// <summary>\r
 111                         /// Do not attempt to synchronize with other threads loading effects into the same pool.\r
 112                         /// </summary>\r
 113                         SingleThreaded = D3D10_EFFECT_SINGLE_THREADED,\r
 114                 };\r
 115 \r
 116                 /// <summary>\r
 117                 /// Flags that indicate the location of an include file.\r
 118                 /// </summary>\r
 119                 /// <unmanaged>D3D10_INCLUDE_TYPE</unmanaged>\r
 120                 [System::Flags]\r
 121                 public enum class IncludeType : System::Int32\r
 122                 {\r
 123                         /// <summary>\r
 124                         /// Indicates that the include is in the local path (or paths).\r
 125                         /// </summary>\r
 126                         Local = D3D10_INCLUDE_LOCAL,\r
 127                         \r
 128                         /// <summary>\r
 129                         /// Indicates that the include is in the system path (or paths).\r
 130                         /// </summary>\r
 131                         System = D3D10_INCLUDE_SYSTEM\r
 132                 };\r
 133 \r
 134                 /// <summary>\r
 135                 /// Indicates how the pipeline interprets geometry or hull shader input primitives.\r
 136                 /// </summary>\r
 137                 /// <unmanaged>D3D11_PRIMITIVE</unmanaged>\r
 138                 public enum class InputPrimitive : System::Int32\r
 139                 {\r
 140                         /// <summary>\r
 141                         /// The shader has not been initialized with an input primitive type.\r
 142                         /// </summary>\r
 143                         Undefined = D3D11_PRIMITIVE_UNDEFINED,\r
 144 \r
 145                         /// <summary>\r
 146                         /// Interpret the input primitive as a point.\r
 147                         /// </summary>\r
 148                         Point = D3D11_PRIMITIVE_POINT,\r
 149 \r
 150                         /// <summary>\r
 151                         /// Interpret the input primitive as a line.\r
 152                         /// </summary>\r
 153                         Line = D3D11_PRIMITIVE_LINE,\r
 154 \r
 155                         /// <summary>\r
 156                         /// Interpret the input primitive as a triangle.\r
 157                         /// </summary>\r
 158                         Triangle = D3D11_PRIMITIVE_TRIANGLE,\r
 159 \r
 160                         /// <summary>\r
 161                         /// Interpret the input primitive as a line with adjacency data.\r
 162                         /// </summary>\r
 163                         LineWithAdjacency = D3D11_PRIMITIVE_LINE_ADJ,\r
 164 \r
 165                         /// <summary>\r
 166                         /// Interpret the input primitive as a triangle with adjacency data.\r
 167                         /// </summary>\r
 168                         TriangleWithAdjacency = D3D11_PRIMITIVE_TRIANGLE_ADJ,\r
 169 \r
 170                         /// <summary>\r
 171                         /// Interpret the input primitive as a control point patch with one control point.\r
 172                         /// </summary>\r
 173                         PatchWith1ControlPoint = D3D11_PRIMITIVE_1_CONTROL_POINT_PATCH,\r
 174 \r
 175                         /// <summary>\r
 176                         /// Interpret the input primitive as a control point patch with two control points.\r
 177                         /// </summary>\r
 178                         PatchWith2ControlPoints = D3D11_PRIMITIVE_2_CONTROL_POINT_PATCH,\r
 179 \r
 180                         /// <summary>\r
 181                         /// Interpret the input primitive as a control point patch with three control points.\r
 182                         /// </summary>\r
 183                         PatchWith3ControlPoints = D3D11_PRIMITIVE_3_CONTROL_POINT_PATCH,\r
 184 \r
 185                         /// <summary>\r
 186                         /// Interpret the input primitive as a control point patch with four control points.\r
 187                         /// </summary>\r
 188                         PatchWith4ControlPoints = D3D11_PRIMITIVE_4_CONTROL_POINT_PATCH,\r
 189 \r
 190                         /// <summary>\r
 191                         /// Interpret the input primitive as a control point patch with five control points.\r
 192                         /// </summary>\r
 193                         PatchWith5ControlPoints = D3D11_PRIMITIVE_5_CONTROL_POINT_PATCH,\r
 194 \r
 195                         /// <summary>\r
 196                         /// Interpret the input primitive as a control point patch with six control points.\r
 197                         /// </summary>\r
 198                         PatchWith6ControlPoints = D3D11_PRIMITIVE_6_CONTROL_POINT_PATCH,\r
 199 \r
 200                         /// <summary>\r
 201                         /// Interpret the input primitive as a control point patch with seven control points.\r
 202                         /// </summary>\r
 203                         PatchWith7ControlPoints = D3D11_PRIMITIVE_7_CONTROL_POINT_PATCH,\r
 204 \r
 205                         /// <summary>\r
 206                         /// Interpret the input primitive as a control point patch with eight control points.\r
 207                         /// </summary>\r
 208                         PatchWith8ControlPoints = D3D11_PRIMITIVE_8_CONTROL_POINT_PATCH,\r
 209 \r
 210                         /// <summary>\r
 211                         /// Interpret the input primitive as a control point patch with nine control points.\r
 212                         /// </summary>\r
 213                         PatchWith9ControlPoints = D3D11_PRIMITIVE_9_CONTROL_POINT_PATCH,\r
 214 \r
 215                         /// <summary>\r
 216                         /// Interpret the input primitive as a control point patch with ten control points.\r
 217                         /// </summary>\r
 218                         PatchWith10ControlPoints = D3D11_PRIMITIVE_10_CONTROL_POINT_PATCH,\r
 219 \r
 220                         /// <summary>\r
 221                         /// Interpret the input primitive as a control point patch with 11 control points.\r
 222                         /// </summary>\r
 223                         PatchWith11ControlPoints = D3D11_PRIMITIVE_11_CONTROL_POINT_PATCH,\r
 224 \r
 225                         /// <summary>\r
 226                         /// Interpret the input primitive as a control point patch with 12 control points.\r
 227                         /// </summary>\r
 228                         PatchWith12ControlPoints = D3D11_PRIMITIVE_12_CONTROL_POINT_PATCH,\r
 229 \r
 230                         /// <summary>\r
 231                         /// Interpret the input primitive as a control point patch with 13 control points.\r
 232                         /// </summary>\r
 233                         PatchWith13ControlPoints = D3D11_PRIMITIVE_13_CONTROL_POINT_PATCH,\r
 234 \r
 235                         /// <summary>\r
 236                         /// Interpret the input primitive as a control point patch with 14 control points.\r
 237                         /// </summary>\r
 238                         PatchWith14ControlPoints = D3D11_PRIMITIVE_14_CONTROL_POINT_PATCH,\r
 239 \r
 240                         /// <summary>\r
 241                         /// Interpret the input primitive as a control point patch with 15 control points.\r
 242                         /// </summary>\r
 243                         PatchWith15ControlPoints = D3D11_PRIMITIVE_15_CONTROL_POINT_PATCH,\r
 244 \r
 245                         /// <summary>\r
 246                         /// Interpret the input primitive as a control point patch with 16 control points.\r
 247                         /// </summary>\r
 248                         PatchWith16ControlPoints = D3D11_PRIMITIVE_16_CONTROL_POINT_PATCH,\r
 249 \r
 250                         /// <summary>\r
 251                         /// Interpret the input primitive as a control point patch with 17 control points.\r
 252                         /// </summary>\r
 253                         PatchWith17ControlPoints = D3D11_PRIMITIVE_17_CONTROL_POINT_PATCH,\r
 254 \r
 255                         /// <summary>\r
 256                         /// Interpret the input primitive as a control point patch with 18 control points.\r
 257                         /// </summary>\r
 258                         PatchWith18ControlPoints = D3D11_PRIMITIVE_18_CONTROL_POINT_PATCH,\r
 259 \r
 260                         /// <summary>\r
 261                         /// Interpret the input primitive as a control point patch with 19 control points.\r
 262                         /// </summary>\r
 263                         PatchWith19ControlPoints = D3D11_PRIMITIVE_19_CONTROL_POINT_PATCH,\r
 264 \r
 265                         /// <summary>\r
 266                         /// Interpret the input primitive as a control point patch with 20 control points.\r
 267                         /// </summary>\r
 268                         PatchWith20ControlPoints = D3D11_PRIMITIVE_20_CONTROL_POINT_PATCH,\r
 269 \r
 270                         /// <summary>\r
 271                         /// Interpret the input primitive as a control point patch with 21 control points.\r
 272                         /// </summary>\r
 273                         PatchWith21ControlPoints = D3D11_PRIMITIVE_21_CONTROL_POINT_PATCH,\r
 274 \r
 275                         /// <summary>\r
 276                         /// Interpret the input primitive as a control point patch with 22 control points.\r
 277                         /// </summary>\r
 278                         PatchWith22ControlPoints = D3D11_PRIMITIVE_22_CONTROL_POINT_PATCH,\r
 279 \r
 280                         /// <summary>\r
 281                         /// Interpret the input primitive as a control point patch with 23 control points.\r
 282                         /// </summary>\r
 283                         PatchWith23ControlPoints = D3D11_PRIMITIVE_23_CONTROL_POINT_PATCH,\r
 284 \r
 285                         /// <summary>\r
 286                         /// Interpret the input primitive as a control point patch with 24 control points.\r
 287                         /// </summary>\r
 288                         PatchWith24ControlPoints = D3D11_PRIMITIVE_24_CONTROL_POINT_PATCH,\r
 289 \r
 290                         /// <summary>\r
 291                         /// Interpret the input primitive as a control point patch with 25 control points.\r
 292                         /// </summary>\r
 293                         PatchWith25ControlPoints = D3D11_PRIMITIVE_25_CONTROL_POINT_PATCH,\r
 294 \r
 295                         /// <summary>\r
 296                         /// Interpret the input primitive as a control point patch with 26 control points.\r
 297                         /// </summary>\r
 298                         PatchWith26ControlPoints = D3D11_PRIMITIVE_26_CONTROL_POINT_PATCH,\r
 299 \r
 300                         /// <summary>\r
 301                         /// Interpret the input primitive as a control point patch with 27 control points.\r
 302                         /// </summary>\r
 303                         PatchWith27ControlPoints = D3D11_PRIMITIVE_27_CONTROL_POINT_PATCH,\r
 304 \r
 305                         /// <summary>\r
 306                         /// Interpret the input primitive as a control point patch with 28 control points.\r
 307                         /// </summary>\r
 308                         PatchWith28ControlPoints = D3D11_PRIMITIVE_28_CONTROL_POINT_PATCH,\r
 309 \r
 310                         /// <summary>\r
 311                         /// Interpret the input primitive as a control point patch with 29 control points.\r
 312                         /// </summary>\r
 313                         PatchWith29ControlPoints = D3D11_PRIMITIVE_29_CONTROL_POINT_PATCH,\r
 314 \r
 315                         /// <summary>\r
 316                         /// Interpret the input primitive as a control point patch with 30 control points.\r
 317                         /// </summary>\r
 318                         PatchWith30ControlPoints = D3D11_PRIMITIVE_30_CONTROL_POINT_PATCH,\r
 319 \r
 320                         /// <summary>\r
 321                         /// Interpret the input primitive as a control point patch with 31 control points.\r
 322                         /// </summary>\r
 323                         PatchWith31ControlPoints = D3D11_PRIMITIVE_31_CONTROL_POINT_PATCH,\r
 324 \r
 325                         /// <summary>\r
 326                         /// Interpret the input primitive as a control point patch with 32 control points.\r
 327                         /// </summary>\r
 328                         PatchWith32ControlPoints = D3D11_PRIMITIVE_32_CONTROL_POINT_PATCH\r
 329                 };\r
 330 \r
 331                 /// <summary>\r
 332                 /// Flags that indicate which components of a value are valid.\r
 333                 /// </summary>\r
 334                 [System::Flags]\r
 335                 public enum class RegisterComponentMaskFlags : System::Int32\r
 336                 {\r
 337                         /// <summary>\r
 338                         /// Indicates that no components are valid.\r
 339                         /// </summary>\r
 340                         None = 0,\r
 341                         \r
 342                         /// <summary>\r
 343                         /// Indicates that the X (or R) component is valid.\r
 344                         /// </summary>\r
 345                         ComponentX = 1,\r
 346                         \r
 347                         /// <summary>\r
 348                         /// Indicates that the Y (or G) component is valid.\r
 349                         /// </summary>\r
 350                         ComponentY = 2,\r
 351                         \r
 352                         /// <summary>\r
 353                         /// Indicates that the Z (or B) component is valid.\r
 354                         /// </summary>\r
 355                         ComponentZ = 4,\r
 356                         \r
 357                         /// <summary>\r
 358                         /// Indicates that the W (or A) component is valid.\r
 359                         /// </summary>\r
 360                         ComponentW = 8,\r
 361                         \r
 362                         /// <summary>\r
 363                         /// Indicates that all components are valid.\r
 364                         /// </summary>\r
 365                         All = ComponentX | ComponentY | ComponentZ | ComponentW\r
 366                 };\r
 367                 \r
 368                 /// <summary>Defines possible register component types.</summary>\r
 369                 /// <unmanaged>D3D10_REGISTER_COMPONENT_TYPE</unmanaged>\r
 370                 public enum class RegisterComponentType : System::Int32\r
 371                 {\r
 372                         /// <summary>\r
 373                         /// Unknown data type.\r
 374                         /// </summary>\r
 375                         Unknown = D3D10_REGISTER_COMPONENT_UNKNOWN,\r
 376 \r
 377                         /// <summary>\r
 378                         /// 32-bit unsigned integer.\r
 379                         /// </summary>\r
 380                         UInt32 = D3D10_REGISTER_COMPONENT_UINT32,\r
 381 \r
 382                         /// <summary>\r
 383                         /// 32-bit signed integer.\r
 384                         /// </summary>\r
 385                         SInt32 = D3D10_REGISTER_COMPONENT_SINT32,\r
 386 \r
 387                         /// <summary>\r
 388                         /// 32-bit floating-point number.\r
 389                         /// </summary>\r
 390                         Float32 = D3D10_REGISTER_COMPONENT_FLOAT32\r
 391                 };\r
 392 \r
 393                 /// <summary>\r
 394                 /// Indicates return value types.\r
 395                 /// </summary>\r
 396                 /// <unmanaged>D3D11_RESOURCE_RETURN_TYPE</unmanaged>\r
 397                 public enum class ResourceReturnType : System::Int32\r
 398                 {\r
 399                         /// <summary>\r
 400                         /// Return type of unsigned normalized integer.\r
 401                         /// </summary>\r
 402                         UNorm = D3D11_RETURN_TYPE_UNORM,\r
 403 \r
 404                         /// <summary>\r
 405                         /// Return type of signed normalized integer.\r
 406                         /// </summary>\r
 407                         SNorm = D3D11_RETURN_TYPE_SNORM,\r
 408 \r
 409                         /// <summary>\r
 410                         /// Return type of signed integer.\r
 411                         /// </summary>\r
 412                         SInt = D3D11_RETURN_TYPE_SINT,\r
 413 \r
 414                         /// <summary>\r
 415                         /// Return type of unsigned integer.\r
 416                         /// </summary>\r
 417                         UInt = D3D11_RETURN_TYPE_UINT,\r
 418 \r
 419                         /// <summary>\r
 420                         /// Return type of single precision floating point value.\r
 421                         /// </summary>\r
 422                         Float = D3D11_RETURN_TYPE_FLOAT,\r
 423 \r
 424                         /// <summary>\r
 425                         /// Return type is unknown.\r
 426                         /// </summary>\r
 427                         Mixed = D3D11_RETURN_TYPE_MIXED,\r
 428 \r
 429                         /// <summary>\r
 430                         /// Return type of double precision floating point value.\r
 431                         /// </summary>\r
 432                         Double = D3D11_RETURN_TYPE_DOUBLE,\r
 433 \r
 434                         /// <summary>\r
 435                         /// Return type is a multiple-dword type, such as a double or uint64, and the component is continued from the\r
 436                         /// previous component that was declared. The first component represents the lower bits. \r
 437                         /// </summary>\r
 438                         Continued = D3D11_RETURN_TYPE_CONTINUED\r
 439                 };\r
 440 \r
 441                 /// <summary>Provides various shader compilation flags.</summary>\r
 442                 /// <unmanaged>D3D10_SHADER</unmanaged>\r
 443                 [System::Flags]\r
 444                 public enum class ShaderFlags : System::Int32\r
 445                 {\r
 446                         /// <summary>\r
 447                         /// No specific compilation options.\r
 448                         /// </summary>\r
 449                         None = 0,\r
 450 \r
 451                         /// <summary>\r
 452                         /// Insert debug file/line/type/symbol information into the resulting shader.\r
 453                         /// </summary>\r
 454                         Debug = D3D10_SHADER_DEBUG,\r
 455 \r
 456                         /// <summary>\r
 457                         /// Do not validate the generated code against known capabilities and constraints. Only use this with shaders that have been successfully\r
 458                         /// compiled in the past. Shaders are always validated by DirectX before they are set to the device.\r
 459                         /// </summary>\r
 460                         SkipValidation = D3D10_SHADER_SKIP_VALIDATION,\r
 461 \r
 462                         /// <summary>\r
 463                         /// Skip optimization during code generation; generally recommended for debug only.\r
 464                         /// </summary>\r
 465                         SkipOptimization = D3D10_SHADER_SKIP_OPTIMIZATION,\r
 466 \r
 467                         /// <summary>\r
 468                         /// Unless explicitly specified, matrices will be packed in row-major order on input and output from the shader.\r
 469                         /// </summary>\r
 470                         PackMatrixRowMajor = D3D10_SHADER_PACK_MATRIX_ROW_MAJOR,\r
 471                         \r
 472                         /// <summary>\r
 473                         /// Unless explicitly specified, matrices will be packed in column-major order on input and output from the shader. This is generally\r
 474                         /// more efficient, since it allows vector-matrix multiplication to be performed using a series of dot-products.\r
 475                         /// </summary>\r
 476                         PackMatrixColumnMajor = D3D10_SHADER_PACK_MATRIX_COLUMN_MAJOR,\r
 477                         \r
 478                         /// <summary>\r
 479                         /// Force all computations to be done with partial precision; this may run faster on some hardware.\r
 480                         /// </summary>\r
 481                         PartialPrecision = D3D10_SHADER_PARTIAL_PRECISION,\r
 482 \r
 483                         /// <summary>\r
 484                         /// Compile a vertex shader for the next highest shader profile. This option turns debugging on (and optimizations off).\r
 485                         /// </summary>\r
 486                         ForceSoftwareVertexShader = D3D10_SHADER_FORCE_VS_SOFTWARE_NO_OPT,\r
 487                         \r
 488                         /// <summary>\r
 489                         /// Compile a pixel shader for the next highest shader profile. This option turns debugging on (and optimizations off).\r
 490                         /// </summary>\r
 491                         ForceSoftwarePixelShader = D3D10_SHADER_FORCE_PS_SOFTWARE_NO_OPT,\r
 492                         \r
 493                         /// <summary>\r
 494                         /// Disables Preshaders. Using this flag will cause the compiler to not pull out static expression for evaluation.\r
 495                         /// </summary>\r
 496                         NoPreshader = D3D10_SHADER_NO_PRESHADER,\r
 497                         \r
 498                         /// <summary>\r
 499                         /// Tells the compiler to not allow flow-control (when possible).\r
 500                         /// </summary>\r
 501                         AvoidFlowControl = D3D10_SHADER_AVOID_FLOW_CONTROL,\r
 502                         \r
 503                         /// <summary>\r
 504                         /// Tells the compiler to use flow-control (when possible).\r
 505                         /// </summary>\r
 506                         PreferFlowControl = D3D10_SHADER_PREFER_FLOW_CONTROL,\r
 507                         \r
 508                         /// <summary>\r
 509                         /// By default, the HLSL compiler disables strictness on deprecated syntax. Specifying this flag enables strictness which may not allow for legacy syntax.\r
 510                         /// </summary>\r
 511                         EnableStrictness = D3D10_SHADER_ENABLE_STRICTNESS,\r
 512                         \r
 513                         /// <summary>\r
 514                         /// This enables older shaders to compile to 4_0 targets.\r
 515                         /// </summary>\r
 516                         EnableBackwardsCompatibility = D3D10_SHADER_ENABLE_BACKWARDS_COMPATIBILITY,\r
 517                         \r
 518                         /// <summary>\r
 519                         /// Enables IEEE floating point strictness.\r
 520                         /// </summary>\r
 521                         EnableIEEEStrictness = D3D10_SHADER_IEEE_STRICTNESS,\r
 522                         \r
 523                         /// <summary>\r
 524                         /// Lowest optimization level. May produce slower code but will do so more quickly. This may be useful in a highly iterative shader development cycle.\r
 525                         /// </summary>\r
 526                         OptimizationLevel0 = D3D10_SHADER_OPTIMIZATION_LEVEL0,\r
 527                         \r
 528                         /// <summary>\r
 529                         /// Second lowest optimization level.\r
 530                         /// </summary>\r
 531                         OptimizationLevel1 = D3D10_SHADER_OPTIMIZATION_LEVEL1,\r
 532                         \r
 533                         /// <summary>\r
 534                         /// Second highest optimization level.\r
 535                         /// </summary>\r
 536                         OptimizationLevel2 = D3D10_SHADER_OPTIMIZATION_LEVEL2,\r
 537                         \r
 538                         /// <summary>\r
 539                         /// Highest optimization level. Will produce best possible code but may take significantly longer to do so. This will be useful for\r
 540                         /// final builds of an application where performance is the most important factor.\r
 541                         /// </summary>\r
 542                         OptimizationLevel3 = D3D10_SHADER_OPTIMIZATION_LEVEL3,\r
 543 \r
 544                         /// <summary>\r
 545                         /// Inform the HLSL compiler to treat all warnings as errors when compiling the shader code. For new shader code, you should use this\r
 546                         /// option so you can resolve all warnings and ensure the fewest possible hard-to-find code defects.\r
 547                         /// </summary>\r
 548                         WarningsAreErrors = D3D10_SHADER_WARNINGS_ARE_ERRORS\r
 549                 };\r
 550 \r
 551                 /// <summary>\r
 552                 /// Identifies shader input options.\r
 553                 /// </summary>\r
 554                 /// <unmanaged>D3D10_SHADER_INPUT_FLAGS</unmanaged>\r
 555                 [System::Flags]\r
 556                 public enum class ShaderInputFlags : System::Int32\r
 557                 {\r
 558                         /// <summary>\r
 559                         /// Assign a shader input to a register based on the register assignment in the HLSL code (instead of letting the compiler choose the register).\r
 560                         /// </summary>\r
 561                         UserPacked = D3D10_SIF_USERPACKED,\r
 562 \r
 563                         /// <summary>\r
 564                         /// Use a comparison sampler, which uses the SampleCmp and SampleCmpLevelZero sampling functions.\r
 565                         /// </summary>\r
 566                         ComparisonSampler = D3D10_SIF_COMPARISON_SAMPLER,\r
 567 \r
 568                         /// <summary>\r
 569                         /// A 2-bit value for encoding texture components.\r
 570                         /// </summary>\r
 571                         TextureComponent0 = D3D10_SIF_TEXTURE_COMPONENT_0,\r
 572 \r
 573                         /// <summary>\r
 574                         /// A 2-bit value for encoding texture components.\r
 575                         /// </summary>\r
 576                         TextureComponent1 = D3D10_SIF_TEXTURE_COMPONENT_1,\r
 577 \r
 578                         /// <summary>\r
 579                         /// A 2-bit value for encoding texture components.\r
 580                         /// </summary>\r
 581                         TextureComponents = D3D10_SIF_TEXTURE_COMPONENTS\r
 582                 };\r
 583 \r
 584                 /// <summary>\r
 585                 /// Identifies shader resource types.\r
 586                 /// </summary>\r
 587                 /// <unmanaged>D3D10_SHADER_INPUT_TYPE</unmanaged>\r
 588                 public enum class ShaderInputType : System::Int32\r
 589                 {\r
 590                         /// <summary>\r
 591                         /// The shader resource is a constant buffer.\r
 592                         /// </summary>\r
 593                         ConstantBuffer = D3D10_SIT_CBUFFER,\r
 594 \r
 595                         /// <summary>\r
 596                         /// The shader resource is a texture buffer.\r
 597                         /// </summary>\r
 598                         TextureBuffer = D3D10_SIT_TBUFFER,\r
 599 \r
 600                         /// <summary>\r
 601                         /// The shader resource is a texture.\r
 602                         /// </summary>\r
 603                         Texture = D3D10_SIT_TEXTURE,\r
 604 \r
 605                         /// <summary>\r
 606                         /// The shader resource is a sampler.\r
 607                         /// </summary>\r
 608                         Sampler = D3D10_SIT_SAMPLER,\r
 609 \r
 610                         /// <summary>\r
 611                         /// The shader resource is a structure buffer.\r
 612                         /// </summary>\r
 613                         Structured = D3D11_SIT_STRUCTURED,\r
 614 \r
 615                         /// <summary>\r
 616                         /// The shader resource is a read and write structured buffer.\r
 617                         /// </summary>\r
 618                         RWStructured = D3D11_SIT_UAV_RWSTRUCTURED,\r
 619 \r
 620                         /// <summary>\r
 621                         /// The shader resource is a byte-address buffer.\r
 622                         /// </summary>\r
 623                         ByteAddress = D3D11_SIT_BYTEADDRESS,\r
 624 \r
 625                         /// <summary>\r
 626                         /// The shader resource is a read and write byte-address buffer.\r
 627                         /// </summary>\r
 628                         RWByteAddress = D3D11_SIT_UAV_RWBYTEADDRESS,\r
 629 \r
 630                         /// <summary>\r
 631                         /// The shader resource is an append-structured buffer.\r
 632                         /// </summary>\r
 633                         AppendStructured = D3D11_SIT_UAV_APPEND_STRUCTURED,\r
 634 \r
 635                         /// <summary>\r
 636                         /// The shader resource is a consume-structured buffer.\r
 637                         /// </summary>\r
 638                         ConsumeStructured = D3D11_SIT_UAV_CONSUME_STRUCTURED,\r
 639 \r
 640                         /// <summary>\r
 641                         /// The shader resource is a read and write structured buffer that uses the built-in counter to append or consume.\r
 642                         /// </summary>\r
 643                         RWStructuredWithCounter = D3D11_SIT_UAV_RWSTRUCTURED_WITH_COUNTER\r
 644                 };\r
 645 \r
 646                 /// <summary>\r
 647                 /// Identifies shader variable classes.\r
 648                 /// </summary>\r
 649                 /// <unmanaged>D3D10_SHADER_VARIABLE_CLASS</unmanaged>\r
 650                 public enum class ShaderVariableClass : System::Int32\r
 651                 {\r
 652                         /// <summary>\r
 653                         /// The shader variable is a scalar.\r
 654                         /// </summary>\r
 655                         Scalar = D3D10_SVC_SCALAR,\r
 656 \r
 657                         /// <summary>\r
 658                         /// The shader variable is a vector.\r
 659                         /// </summary>\r
 660                         Vector = D3D10_SVC_VECTOR,\r
 661 \r
 662                         /// <summary>\r
 663                         /// The shader variable is a row-major matrix.\r
 664                         /// </summary>\r
 665                         MatrixRows = D3D10_SVC_MATRIX_ROWS,\r
 666 \r
 667                         /// <summary>\r
 668                         /// The shader variable is a column-major matrix.\r
 669                         /// </summary>\r
 670                         MatrixColumns = D3D10_SVC_MATRIX_COLUMNS,\r
 671 \r
 672                         /// <summary>\r
 673                         /// The shader variable is an object.\r
 674                         /// </summary>\r
 675                         Object = D3D10_SVC_OBJECT,\r
 676 \r
 677                         /// <summary>\r
 678                         /// The shader variable is a structure.\r
 679                         /// </summary>\r
 680                         Struct = D3D10_SVC_STRUCT,\r
 681 \r
 682                         /// <summary>\r
 683                         /// The shader variable is a class.\r
 684                         /// </summary>\r
 685                         InterfaceClass = D3D11_SVC_INTERFACE_CLASS,\r
 686 \r
 687                         /// <summary>\r
 688                         /// The shader variable is an interface pointer.\r
 689                         /// </summary>\r
 690                         InterfacePointer = D3D11_SVC_INTERFACE_POINTER,\r
 691                 };\r
 692 \r
 693                 /// <summary>\r
 694                 /// Indicates additional information about a shader variable.\r
 695                 /// </summary>\r
 696                 /// <unmanaged>D3D10_SHADER_VARIABLE_FLAGS</unmanaged>\r
 697                 [System::Flags]\r
 698                 public enum class ShaderVariableFlags : System::Int32\r
 699                 {\r
 700                         /// <summary>\r
 701                         /// Indicates that the registers assigned to this shader variable were explicitly declared in shader code (instead of automatically assigned by the compiler).\r
 702                         /// </summary>\r
 703                         UserPacked = D3D10_SVF_USERPACKED,\r
 704 \r
 705                         /// <summary>\r
 706                         /// Indicates that this variable is used by this shader. This value confirms that a particular shader variable\r
 707                         /// (which can be common to many different shaders) is indeed used by a particular shader. \r
 708                         /// </summary>\r
 709                         Used = D3D10_SVF_USED\r
 710                 };\r
 711 \r
 712                 /// <summary>\r
 713                 /// Identifies possible shader variable types.\r
 714                 /// </summary>\r
 715                 /// <unmanaged>D3D10_SHADER_VARIABLE_TYPE</unmanaged>\r
 716                 public enum class ShaderVariableType : System::Int32\r
 717                 {\r
 718                         /// <summary>\r
 719                         /// The variable is a void pointer.\r
 720                         /// </summary>\r
 721                         Void = D3D10_SVT_VOID,\r
 722 \r
 723                         /// <summary>\r
 724                         /// The variable is a boolean.\r
 725                         /// </summary>\r
 726                         Bool = D3D10_SVT_BOOL,\r
 727 \r
 728                         /// <summary>\r
 729                         /// The variable is an integer.\r
 730                         /// </summary>\r
 731                         Int = D3D10_SVT_INT,\r
 732 \r
 733                         /// <summary>\r
 734                         /// The variable is a floating-point number.\r
 735                         /// </summary>\r
 736                         Float = D3D10_SVT_FLOAT,\r
 737 \r
 738                         /// <summary>\r
 739                         /// The variable is a string.\r
 740                         /// </summary>\r
 741                         String = D3D10_SVT_STRING,\r
 742 \r
 743                         /// <summary>\r
 744                         /// The variable is a texture.\r
 745                         /// </summary>\r
 746                         Texture = D3D10_SVT_TEXTURE,\r
 747 \r
 748                         /// <summary>\r
 749                         /// The variable is a 1D texture.\r
 750                         /// </summary>\r
 751                         Texture1D = D3D10_SVT_TEXTURE1D,\r
 752 \r
 753                         /// <summary>\r
 754                         /// The variable is a 2D texture.\r
 755                         /// </summary>\r
 756                         Texture2D = D3D10_SVT_TEXTURE2D,\r
 757 \r
 758                         /// <summary>\r
 759                         /// The variable is a 3D texture.\r
 760                         /// </summary>\r
 761                         Texture3D = D3D10_SVT_TEXTURE3D,\r
 762 \r
 763                         /// <summary>\r
 764                         /// The variable is a texture cube.\r
 765                         /// </summary>\r
 766                         TextureCube = D3D10_SVT_TEXTURECUBE,\r
 767 \r
 768                         /// <summary>\r
 769                         /// The variable is a sampler.\r
 770                         /// </summary>\r
 771                         Sampler = D3D10_SVT_SAMPLER,\r
 772 \r
 773                         /// <summary>\r
 774                         /// The variable is a pixel shader.\r
 775                         /// </summary>\r
 776                         PixelShader = D3D10_SVT_PIXELSHADER,\r
 777 \r
 778                         /// <summary>\r
 779                         /// The variable is a vertex shader.\r
 780                         /// </summary>\r
 781                         VertexShader = D3D10_SVT_VERTEXSHADER,\r
 782 \r
 783                         /// <summary>\r
 784                         /// The variable is an unsigned integer.\r
 785                         /// </summary>\r
 786                         UInt = D3D10_SVT_UINT,\r
 787 \r
 788                         /// <summary>\r
 789                         /// The variable is an 8-bit unsigned integer.\r
 790                         /// </summary>\r
 791                         UInt8 = D3D10_SVT_UINT8,\r
 792 \r
 793                         /// <summary>\r
 794                         /// The variable is a geometry shader.\r
 795                         /// </summary>\r
 796                         GeometryShader = D3D10_SVT_GEOMETRYSHADER,\r
 797 \r
 798                         /// <summary>\r
 799                         /// The variable is a rasterizer-state object.\r
 800                         /// </summary>\r
 801                         Rasterizer = D3D10_SVT_RASTERIZER,\r
 802 \r
 803                         /// <summary>\r
 804                         /// The variable is a depth-stencil-state object.\r
 805                         /// </summary>\r
 806                         DepthStencil = D3D10_SVT_DEPTHSTENCIL,\r
 807 \r
 808                         /// <summary>\r
 809                         /// The variable is a blend-state object.\r
 810                         /// </summary>\r
 811                         Blend = D3D10_SVT_BLEND,\r
 812 \r
 813                         /// <summary>\r
 814                         /// The variable is a buffer.\r
 815                         /// </summary>\r
 816                         Buffer = D3D10_SVT_BUFFER,\r
 817 \r
 818                         /// <summary>\r
 819                         /// The variable is a constant buffer.\r
 820                         /// </summary>\r
 821                         CBuffer = D3D10_SVT_CBUFFER,\r
 822 \r
 823                         /// <summary>\r
 824                         /// The variable is a texture buffer.\r
 825                         /// </summary>\r
 826                         TBuffer = D3D10_SVT_TBUFFER,\r
 827 \r
 828                         /// <summary>\r
 829                         /// The variable is a 1D-texture array.\r
 830                         /// </summary>\r
 831                         Texture1DArray = D3D10_SVT_TEXTURE1DARRAY,\r
 832 \r
 833                         /// <summary>\r
 834                         /// The variable is a 2D-texture array.\r
 835                         /// </summary>\r
 836                         Texture2DArray = D3D10_SVT_TEXTURE2DARRAY,\r
 837 \r
 838                         /// <summary>\r
 839                         /// The variable is a render-target view.\r
 840                         /// </summary>\r
 841                         RenderTargetView = D3D10_SVT_RENDERTARGETVIEW,\r
 842 \r
 843                         /// <summary>\r
 844                         /// The variable is a depth-stencil view.\r
 845                         /// </summary>\r
 846                         DepthStencilView = D3D10_SVT_DEPTHSTENCILVIEW,\r
 847 \r
 848                         /// <summary>\r
 849                         /// The variable is a 2D-multisampled texture.\r
 850                         /// </summary>\r
 851                         Texture2DMS = D3D10_SVT_TEXTURE2DMS,\r
 852 \r
 853                         /// <summary>\r
 854                         /// The variable is a 2D-multisampled-texture array.\r
 855                         /// </summary>\r
 856                         Texture2DMSArray = D3D10_SVT_TEXTURE2DMSARRAY,\r
 857 \r
 858                         /// <summary>\r
 859                         /// The variable is a texture-cube array.\r
 860                         /// </summary>\r
 861                         TextureCubeArray = D3D10_SVT_TEXTURECUBEARRAY,\r
 862 \r
 863                         /// <summary>\r
 864                         /// The variable holds a compiled hull-shader binary.\r
 865                         /// </summary>\r
 866                         HullShader = D3D11_SVT_HULLSHADER,\r
 867 \r
 868                         /// <summary>\r
 869                         /// The variable holds a compiled domain-shader binary.\r
 870                         /// </summary>\r
 871                         DomainShader = D3D11_SVT_DOMAINSHADER,\r
 872 \r
 873                         /// <summary>\r
 874                         /// The variable is an interface.\r
 875                         /// </summary>\r
 876                         InterfacePointer = D3D11_SVT_INTERFACE_POINTER,\r
 877 \r
 878                         /// <summary>\r
 879                         /// The variable holds a compiled compute-shader binary.\r
 880                         /// </summary>\r
 881                         ComputeShader = D3D11_SVT_COMPUTESHADER,\r
 882 \r
 883                         /// <summary>\r
 884                         /// The variable is a double precision (64-bit) floating-point number.\r
 885                         /// </summary>\r
 886                         Double = D3D11_SVT_DOUBLE,\r
 887 \r
 888                         /// <summary>\r
 889                         /// The variable is a 1D read and write texture.\r
 890                         /// </summary>\r
 891                         RWTexture1D = D3D11_SVT_RWTEXTURE1D,\r
 892 \r
 893                         /// <summary>\r
 894                         /// The variable is an array of 1D read and write textures.\r
 895                         /// </summary>\r
 896                         RWTexture1DArray = D3D11_SVT_RWTEXTURE1DARRAY,\r
 897 \r
 898                         /// <summary>\r
 899                         /// The variable is a 2D read and write texture.\r
 900                         /// </summary>\r
 901                         RWTexture2D = D3D11_SVT_RWTEXTURE2D,\r
 902 \r
 903                         /// <summary>\r
 904                         /// The variable is an array of 2D read and write textures.\r
 905                         /// </summary>\r
 906                         RWTexture2DArray = D3D11_SVT_RWTEXTURE2DARRAY,\r
 907 \r
 908                         /// <summary>\r
 909                         /// he variable is a 3D read and write texture.\r
 910                         /// </summary>\r
 911                         RWTexture3D = D3D11_SVT_RWTEXTURE3D,\r
 912 \r
 913                         /// <summary>\r
 914                         /// The variable is a read and write buffer.\r
 915                         /// </summary>\r
 916                         RWBuffer = D3D11_SVT_RWBUFFER,\r
 917 \r
 918                         /// <summary>\r
 919                         /// The variable is a byte-address buffer.\r
 920                         /// </summary>\r
 921                         ByteAddressBuffer = D3D11_SVT_BYTEADDRESS_BUFFER,\r
 922 \r
 923                         /// <summary>\r
 924                         /// The variable is a read and write byte-address buffer.\r
 925                         /// </summary>\r
 926                         RWByteAddressBuffer = D3D11_SVT_RWBYTEADDRESS_BUFFER,\r
 927 \r
 928                         /// <summary>\r
 929                         /// he variable is a structured buffer. \r
 930                         /// </summary>\r
 931                         StructuredBuffer = D3D11_SVT_STRUCTURED_BUFFER,\r
 932 \r
 933                         /// <summary>\r
 934                         /// The variable is a read and write structured buffer.\r
 935                         /// </summary>\r
 936                         RWStructuredBuffer = D3D11_SVT_RWSTRUCTURED_BUFFER,\r
 937 \r
 938                         /// <summary>\r
 939                         /// The variable is an append structured buffer.\r
 940                         /// </summary>\r
 941                         AppendStructuredBuffer = D3D11_SVT_APPEND_STRUCTURED_BUFFER,\r
 942 \r
 943                         /// <summary>\r
 944                         /// The variable is a consume structured buffer.\r
 945                         /// </summary>\r
 946                         ConsumeStructuredBuffer = D3D11_SVT_CONSUME_STRUCTURED_BUFFER\r
 947                 };\r
 948 \r
 949                 /// <summary>\r
 950                 /// Indicates possible shader types.\r
 951                 /// </summary>\r
 952                 /// <unmanaged>D3D11_SHADER_VERSION_TYPE</unmanaged>\r
 953                 public enum class ShaderVersion : System::Int32\r
 954                 {\r
 955                         /// <summary>\r
 956                         /// A pixel shader.\r
 957                         /// </summary>\r
 958                         PixelShader = D3D11_SHVER_PIXEL_SHADER,\r
 959 \r
 960                         /// <summary>\r
 961                         /// A vertex shader.\r
 962                         /// </summary>\r
 963                         VertexShader = D3D11_SHVER_VERTEX_SHADER,\r
 964 \r
 965                         /// <summary>\r
 966                         /// A geometry shader.\r
 967                         /// </summary>\r
 968                         GeometryShader = D3D11_SHVER_GEOMETRY_SHADER,\r
 969 \r
 970                         /// <summary>\r
 971                         /// A hull shader.\r
 972                         /// </summary>\r
 973                         HullShader = D3D11_SHVER_HULL_SHADER,\r
 974 \r
 975                         /// <summary>\r
 976                         /// A domain shader.\r
 977                         /// </summary>\r
 978                         DomainShader = D3D11_SHVER_DOMAIN_SHADER,\r
 979 \r
 980                         /// <summary>\r
 981                         /// A compute shader.\r
 982                         /// </summary>\r
 983                         ComputeShader = D3D11_SHVER_COMPUTE_SHADER\r
 984                 };\r
 985 \r
 986                 /// <summary>\r
 987                 /// Specifies options for stripping data from a shader or effect.\r
 988                 /// </summary>\r
 989                 /// <unmanaged>D3DCOMPILER_STRIP_FLAGS</unmanaged>\r
 990                 [System::Flags]\r
 991                 public enum class StripFlags : System::Int32\r
 992                 {\r
 993                         /// <summary>\r
 994                         /// No extra stripping options.\r
 995                         /// </summary>\r
 996                         None = 0,\r
 997 \r
 998                         /// <summary>\r
 999                         /// Remove reflection data.\r
1000                         /// </summary>\r
1001                         StripReflectionData = D3DCOMPILER_STRIP_REFLECTION_DATA,\r
1002 \r
1003                         /// <summary>\r
1004                         /// Remove debug information.\r
1005                         /// </summary>\r
1006                         StripDebugInformation = D3DCOMPILER_STRIP_DEBUG_INFO,\r
1007 \r
1008                         /// <summary>\r
1009                         /// Remove test blob data.\r
1010                         /// </summary>\r
1011                         StripTestBlobs = D3DCOMPILER_STRIP_TEST_BLOBS\r
1012                 };\r
1013 \r
1014                 /// <summary>Identifies shader parameters that use system-value semantics.</summary>\r
1015                 /// <unmanaged>D3D10_NAME</unmanaged>\r
1016                 public enum class SystemValueType : System::Int32\r
1017                 {\r
1018                         /// <summary>\r
1019                         /// This parameter does not use a predefined system-value semantic.\r
1020                         /// </summary>\r
1021                         Undefined = D3D10_NAME_UNDEFINED,\r
1022 \r
1023                         /// <summary>\r
1024                         /// This parameter contains position data.\r
1025                         /// </summary>\r
1026                         Position = D3D10_NAME_POSITION,\r
1027 \r
1028                         /// <summary>\r
1029                         /// This parameter contains clip-distance data.\r
1030                         /// </summary>\r
1031                         ClipDistance = D3D10_NAME_CLIP_DISTANCE,\r
1032 \r
1033                         /// <summary>\r
1034                         /// This parameter contains cull distance data.\r
1035                         /// </summary>\r
1036                         CullDistance = D3D10_NAME_CULL_DISTANCE,\r
1037 \r
1038                         /// <summary>\r
1039                         /// This parameter contains a render-target-array index.\r
1040                         /// </summary>\r
1041                         RenderTargetArrayIndex = D3D10_NAME_RENDER_TARGET_ARRAY_INDEX,\r
1042 \r
1043                         /// <summary>\r
1044                         /// This parameter contains a viewport-array index.\r
1045                         /// </summary>\r
1046                         ViewportArrayIndex = D3D10_NAME_VIEWPORT_ARRAY_INDEX,\r
1047 \r
1048                         /// <summary>\r
1049                         /// This parameter contains a vertex ID.\r
1050                         /// </summary>\r
1051                         VertexId = D3D10_NAME_VERTEX_ID,\r
1052 \r
1053                         /// <summary>\r
1054                         /// This parameter contains a primitive ID.\r
1055                         /// </summary>\r
1056                         PrimitiveId = D3D10_NAME_PRIMITIVE_ID,\r
1057 \r
1058                         /// <summary>\r
1059                         /// This parameter contains a instance ID.\r
1060                         /// </summary>\r
1061                         InstanceId = D3D10_NAME_INSTANCE_ID,\r
1062 \r
1063                         /// <summary>\r
1064                         /// This parameter contains data that identifies whether or not the primitive faces the camera.\r
1065                         /// </summary>\r
1066                         FrontFaceFlag = D3D10_NAME_IS_FRONT_FACE,\r
1067 \r
1068                         /// <summary>\r
1069                         /// This parameter contains a sampler-array index.\r
1070                         /// </summary>\r
1071                         SampleIndex = D3D10_NAME_SAMPLE_INDEX,\r
1072 \r
1073                         /// <summary>\r
1074                         /// This parameter contains render-target data.\r
1075                         /// </summary>\r
1076                         Target = D3D10_NAME_TARGET,\r
1077 \r
1078                         /// <summary>\r
1079                         /// This parameter contains depth data.\r
1080                         /// </summary>\r
1081                         Depth = D3D10_NAME_DEPTH,\r
1082 \r
1083                         /// <summary>\r
1084                         /// This parameter contains alpha-coverage data.\r
1085                         /// </summary>\r
1086                         Coverage = D3D10_NAME_COVERAGE,\r
1087 \r
1088                         /// <summary>\r
1089                         /// This parameter signifies that the value is greater than or equal to a reference value. This flag is used to specify conservative depth for a pixel shader.\r
1090                         /// </summary>\r
1091                         DepthGreaterEqual = D3D11_NAME_DEPTH_GREATER_EQUAL,\r
1092 \r
1093                         /// <summary>\r
1094                         /// This parameter signifies that the value is less than or equal to a reference value. This flag is used to specify conservative depth for a pixel shader.\r
1095                         /// </summary>\r
1096                         DepthLessEqual = D3D11_NAME_DEPTH_LESS_EQUAL,\r
1097 \r
1098                         /// <summary>\r
1099                         /// his parameter contains one of four tessellation factors that correspond to the amount of parts that a quad patch is broken into along\r
1100                         /// the given edge. This flag is used to tessellate a quad patch.\r
1101                         /// </summary>\r
1102                         FinalQuadEdgeTessellationFactor = D3D11_NAME_FINAL_QUAD_EDGE_TESSFACTOR,\r
1103 \r
1104                         /// <summary>\r
1105                         /// This parameter contains one of two tessellation factors that correspond to the amount of parts that a quad patch is broken into vertically\r
1106                         /// and horizontally within the patch. This flag is used to tessellate a quad patch.\r
1107                         /// </summary>\r
1108                         FinalQuadInsideTessellationFactor = D3D11_NAME_FINAL_QUAD_INSIDE_TESSFACTOR,\r
1109 \r
1110                         /// <summary>\r
1111                         /// This parameter contains one of three tessellation factors that correspond to the amount of parts that a tri patch is broken into\r
1112                         /// along the given edge. This flag is used to tessellate a tri patch.\r
1113                         /// </summary>\r
1114                         FinalTriangleEdgeTessellationFactor = D3D11_NAME_FINAL_TRI_EDGE_TESSFACTOR,\r
1115 \r
1116                         /// <summary>\r
1117                         /// This parameter contains the tessellation factor that corresponds to the amount of parts that a tri patch is broken into within the patch.\r
1118                         /// This flag is used to tessellate a tri patch.\r
1119                         /// </summary>\r
1120                         FinalTriangleInsideTessellationFactor = D3D11_NAME_FINAL_TRI_INSIDE_TESSFACTOR,\r
1121 \r
1122                         /// <summary>\r
1123                         /// This parameter contains the tessellation factor that corresponds to the amount of lines broken into within the patch. This flag is used to tessellate an isolines patch.\r
1124                         /// </summary>\r
1125                         FinalLineDetailTessellationFactor = D3D11_NAME_FINAL_LINE_DETAIL_TESSFACTOR,\r
1126 \r
1127                         /// <summary>\r
1128                         /// This parameter contains the tessellation factor that corresponds to the amount of lines that are created within the patch. This flag is used to tessellate an isolines patch.\r
1129                         /// </summary>\r
1130                         FinalLineDensityTessellationFactor = D3D11_NAME_FINAL_LINE_DENSITY_TESSFACTOR\r
1131                 };\r
1132 \r
1133                 /// <summary>\r
1134                 /// Specifies domain options for tessellator data.\r
1135                 /// </summary>\r
1136                 /// <unmanaged>D3D11_TESSELLATOR_DOMAIN</unmanaged>\r
1137                 public enum class TessellatorDomain : System::Int32\r
1138                 {\r
1139                         /// <summary>\r
1140                         /// The data type is undefined.\r
1141                         /// </summary>\r
1142                         Undefined = D3D11_TESSELLATOR_DOMAIN_UNDEFINED,\r
1143 \r
1144                         /// <summary>\r
1145                         /// Isoline data.\r
1146                         /// </summary>\r
1147                         Isoline = D3D11_TESSELLATOR_DOMAIN_ISOLINE,\r
1148 \r
1149                         /// <summary>\r
1150                         /// Triangle data.\r
1151                         /// </summary>\r
1152                         Triangle = D3D11_TESSELLATOR_DOMAIN_TRI,\r
1153 \r
1154                         /// <summary>\r
1155                         /// Quad data.\r
1156                         /// </summary>\r
1157                         Quad = D3D11_TESSELLATOR_DOMAIN_QUAD\r
1158                 };\r
1159 \r
1160                 /// <summary>\r
1161                 /// Specifies output primitive types for the tessellator.\r
1162                 /// </summary>\r
1163                 /// <unmanaged>D3D11_TESSELLATOR_OUTPUT_PRIMITIVE</unmanaged>\r
1164                 public enum class TessellatorOutputPrimitive : System::Int32\r
1165                 {\r
1166                         /// <summary>\r
1167                         /// The output primitive type is undefined.\r
1168                         /// </summary>\r
1169                         Undefined = D3D11_TESSELLATOR_OUTPUT_UNDEFINED,\r
1170 \r
1171                         /// <summary>\r
1172                         /// The output primitive type a point.\r
1173                         /// </summary>\r
1174                         Point = D3D11_TESSELLATOR_OUTPUT_POINT,\r
1175 \r
1176                         /// <summary>\r
1177                         /// The output primitive type is a line.\r
1178                         /// </summary>\r
1179                         Line = D3D11_TESSELLATOR_OUTPUT_LINE,\r
1180 \r
1181                         /// <summary>\r
1182                         /// The output primitive type is a clockwise triangle.\r
1183                         /// </summary>\r
1184                         TriangleClockwise = D3D11_TESSELLATOR_OUTPUT_TRIANGLE_CW,\r
1185 \r
1186                         /// <summary>\r
1187                         /// The output primitive type is a counter clockwise triangle.\r
1188                         /// </summary>\r
1189                         TriangleCounterclockwise = D3D11_TESSELLATOR_OUTPUT_TRIANGLE_CCW\r
1190                 };\r
1191 \r
1192                 /// <summary>\r
1193                 /// Specifies tessellator partitioning options.\r
1194                 /// </summary>\r
1195                 /// <unmanaged>D3D11_TESSELLATOR_PARTITIONING</unmanaged>\r
1196                 public enum class TessellatorPartitioning : System::Int32\r
1197                 {\r
1198                         /// <summary>\r
1199                         /// The partitioning type is undefined.\r
1200                         /// </summary>\r
1201                         Undefined = D3D11_TESSELLATOR_PARTITIONING_UNDEFINED,\r
1202 \r
1203                         /// <summary>\r
1204                         /// Partition with integers only.\r
1205                         /// </summary>\r
1206                         Integer = D3D11_TESSELLATOR_PARTITIONING_INTEGER,\r
1207 \r
1208                         /// <summary>\r
1209                         /// Partition with a power-of-two number only.\r
1210                         /// </summary>\r
1211                         PowerOfTwo = D3D11_TESSELLATOR_PARTITIONING_POW2,\r
1212 \r
1213                         /// <summary>\r
1214                         /// Partition with an odd, fractional number.\r
1215                         /// </summary>\r
1216                         FractionalOdd = D3D11_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD,\r
1217 \r
1218                         /// <summary>\r
1219                         /// Partition with an even, fractional number.\r
1220                         /// </summary>\r
1221                         FractionalEven = D3D11_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN\r
1222                 };\r
1223         }\r
1224 }