tests/hlsl/hull-shader-attributes.shader_test

   1 [require]
   2 shader model >= 5.0
   3
   4 [hull shader]
   5 struct patch_constant_data
   6 {
   7     float edges[2] : SV_TessFactor;
   8 };
   9
  10 patch_constant_data patch_constant()
  11 {
  12     return (patch_constant_data)0;
  13 }
  14
  15     [domain("isoline")]
  16     [outputcontrolpoints(3)]
  17     [partitioning("integer")]
  18     [outputtopology("point")]
  19     [patchconstantfunc("patch_constant")]
  20 float4 main() : POSITION
  21 {
  22     return 0;
  23 }
  24
  25 %% Test missing attributes.
  26
  27 [hull shader fail]
  28 struct patch_constant_data
  29 {
  30     float edges[2] : SV_TessFactor;
  31 };
  32
  33 patch_constant_data patch_constant()
  34 {
  35     return (patch_constant_data)0;
  36 }
  37
  38     //[domain("isoline")]
  39     [outputcontrolpoints(3)]
  40     [partitioning("integer")]
  41     [outputtopology("point")]
  42     [patchconstantfunc("patch_constant")]
  43 float4 main() : POSITION
  44 {
  45     return 0;
  46 }
  47
  48 % outputcontrolpoints defaults to 0 for SM >= 6.
  49 [hull shader fail]
  50 struct patch_constant_data
  51 {
  52     float edges[2] : SV_TessFactor;
  53 };
  54
  55 patch_constant_data patch_constant()
  56 {
  57     return (patch_constant_data)0;
  58 }
  59
  60     [domain("isoline")]
  61     //[outputcontrolpoints(3)]
  62     [partitioning("integer")]
  63     [outputtopology("point")]
  64     [patchconstantfunc("patch_constant")]
  65 float4 main() : POSITION
  66 {
  67     return 0;
  68 }
  69
  70 [hull shader fail]
  71 struct patch_constant_data
  72 {
  73     float edges[2] : SV_TessFactor;
  74 };
  75
  76 patch_constant_data patch_constant()
  77 {
  78     return (patch_constant_data)0;
  79 }
  80
  81     [domain("isoline")]
  82     [outputcontrolpoints(3)]
  83     //[partitioning("integer")]
  84     [outputtopology("point")]
  85     [patchconstantfunc("patch_constant")]
  86 float4 main() : POSITION
  87 {
  88     return 0;
  89 }
  90
  91 [hull shader fail]
  92 struct patch_constant_data
  93 {
  94     float edges[2] : SV_TessFactor;
  95 };
  96
  97 patch_constant_data patch_constant()
  98 {
  99     return (patch_constant_data)0;
 100 }
 101
 102     [domain("isoline")]
 103     [outputcontrolpoints(3)]
 104     [partitioning("integer")]
 105     //[outputtopology("point")]
 106     [patchconstantfunc("patch_constant")]
 107 float4 main() : POSITION
 108 {
 109     return 0;
 110 }
 111
 112 [hull shader fail]
 113 struct patch_constant_data
 114 {
 115     float edges[2] : SV_TessFactor;
 116 };
 117
 118 patch_constant_data patch_constant()
 119 {
 120     return (patch_constant_data)0;
 121 }
 122
 123     [domain("isoline")]
 124     [outputcontrolpoints(3)]
 125     [partitioning("integer")]
 126     [outputtopology("point")]
 127     //[patchconstantfunc("patch_constant")]
 128 float4 main() : POSITION
 129 {
 130     return 0;
 131 }
 132
 133 %% Test valid combinations of the domain and outputtopology attributes.
 134
 135 [hull shader]
 136 struct patch_constant_data
 137 {
 138     float edges[2] : SV_TessFactor;
 139 };
 140
 141 patch_constant_data patch_constant()
 142 {
 143     return (patch_constant_data)0;
 144 }
 145
 146     [domain("isoline")]
 147     [outputcontrolpoints(3)]
 148     [partitioning("integer")]
 149     [outputtopology("point")]
 150     [patchconstantfunc("patch_constant")]
 151 float4 main() : POSITION
 152 {
 153     return 0;
 154 }
 155
 156 [hull shader]
 157 struct patch_constant_data
 158 {
 159     float edges[2] : SV_TessFactor;
 160 };
 161
 162 patch_constant_data patch_constant()
 163 {
 164     return (patch_constant_data)0;
 165 }
 166
 167     [domain("isoline")]
 168     [outputcontrolpoints(3)]
 169     [partitioning("integer")]
 170     [outputtopology("line")]
 171     [patchconstantfunc("patch_constant")]
 172 float4 main() : POSITION
 173 {
 174     return 0;
 175 }
 176
 177 [hull shader fail]
 178 struct patch_constant_data
 179 {
 180     float edges[2] : SV_TessFactor;
 181 };
 182
 183 patch_constant_data patch_constant()
 184 {
 185     return (patch_constant_data)0;
 186 }
 187
 188     [domain("isoline")]
 189     [outputcontrolpoints(3)]
 190     [partitioning("integer")]
 191     [outputtopology("triangle_cw")]
 192     [patchconstantfunc("patch_constant")]
 193 float4 main() : POSITION
 194 {
 195     return 0;
 196 }
 197
 198 [hull shader fail]
 199 struct patch_constant_data
 200 {
 201     float edges[2] : SV_TessFactor;
 202 };
 203
 204 patch_constant_data patch_constant()
 205 {
 206     return (patch_constant_data)0;
 207 }
 208
 209     [domain("isoline")]
 210     [outputcontrolpoints(3)]
 211     [partitioning("integer")]
 212     [outputtopology("triangle_ccw")]
 213     [patchconstantfunc("patch_constant")]
 214 float4 main() : POSITION
 215 {
 216     return 0;
 217 }
 218
 219 [hull shader]
 220 struct patch_constant_data
 221 {
 222     float edges[3] : SV_TessFactor;
 223     float inside : SV_InsideTessFactor;
 224 };
 225
 226 patch_constant_data patch_constant()
 227 {
 228     return (patch_constant_data)0;
 229 }
 230
 231     [domain("tri")]
 232     [outputcontrolpoints(3)]
 233     [partitioning("integer")]
 234     [outputtopology("point")]
 235     [patchconstantfunc("patch_constant")]
 236 float4 main() : POSITION
 237 {
 238     return 0;
 239 }
 240
 241 [hull shader fail]
 242 struct patch_constant_data
 243 {
 244     float edges[3] : SV_TessFactor;
 245     float inside : SV_InsideTessFactor;
 246 };
 247
 248 patch_constant_data patch_constant()
 249 {
 250     return (patch_constant_data)0;
 251 }
 252
 253     [domain("tri")]
 254     [outputcontrolpoints(3)]
 255     [partitioning("integer")]
 256     [outputtopology("line")]
 257     [patchconstantfunc("patch_constant")]
 258 float4 main() : POSITION
 259 {
 260     return 0;
 261 }
 262
 263 [hull shader]
 264 struct patch_constant_data
 265 {
 266     float edges[3] : SV_TessFactor;
 267     float inside : SV_InsideTessFactor;
 268 };
 269
 270 patch_constant_data patch_constant()
 271 {
 272     return (patch_constant_data)0;
 273 }
 274
 275     [domain("tri")]
 276     [outputcontrolpoints(3)]
 277     [partitioning("integer")]
 278     [outputtopology("triangle_cw")]
 279     [patchconstantfunc("patch_constant")]
 280 float4 main() : POSITION
 281 {
 282     return 0;
 283 }
 284
 285 [hull shader]
 286 struct patch_constant_data
 287 {
 288     float edges[3] : SV_TessFactor;
 289     float inside : SV_InsideTessFactor;
 290 };
 291
 292 patch_constant_data patch_constant()
 293 {
 294     return (patch_constant_data)0;
 295 }
 296
 297     [domain("tri")]
 298     [outputcontrolpoints(3)]
 299     [partitioning("integer")]
 300     [outputtopology("triangle_ccw")]
 301     [patchconstantfunc("patch_constant")]
 302 float4 main() : POSITION
 303 {
 304     return 0;
 305 }
 306
 307 [hull shader]
 308 struct patch_constant_data
 309 {
 310     float edges[4] : SV_TessFactor;
 311     float inside[2] : SV_InsideTessFactor;
 312 };
 313
 314 patch_constant_data patch_constant()
 315 {
 316     return (patch_constant_data)0;
 317 }
 318
 319     [domain("quad")]
 320     [outputcontrolpoints(3)]
 321     [partitioning("integer")]
 322     [outputtopology("point")]
 323     [patchconstantfunc("patch_constant")]
 324 float4 main() : POSITION
 325 {
 326     return 0;
 327 }
 328
 329 [hull shader fail]
 330 struct patch_constant_data
 331 {
 332     float edges[4] : SV_TessFactor;
 333     float inside[2] : SV_InsideTessFactor;
 334 };
 335
 336 patch_constant_data patch_constant()
 337 {
 338     return (patch_constant_data)0;
 339 }
 340
 341     [domain("quad")]
 342     [outputcontrolpoints(3)]
 343     [partitioning("integer")]
 344     [outputtopology("line")]
 345     [patchconstantfunc("patch_constant")]
 346 float4 main() : POSITION
 347 {
 348     return 0;
 349 }
 350
 351 [hull shader]
 352 struct patch_constant_data
 353 {
 354     float edges[4] : SV_TessFactor;
 355     float inside[2] : SV_InsideTessFactor;
 356 };
 357
 358 patch_constant_data patch_constant()
 359 {
 360     return (patch_constant_data)0;
 361 }
 362
 363     [domain("quad")]
 364     [outputcontrolpoints(3)]
 365     [partitioning("integer")]
 366     [outputtopology("triangle_cw")]
 367     [patchconstantfunc("patch_constant")]
 368 float4 main() : POSITION
 369 {
 370     return 0;
 371 }
 372
 373 [hull shader]
 374 struct patch_constant_data
 375 {
 376     float edges[4] : SV_TessFactor;
 377     float inside[2] : SV_InsideTessFactor;
 378 };
 379
 380 patch_constant_data patch_constant()
 381 {
 382     return (patch_constant_data)0;
 383 }
 384
 385     [domain("quad")]
 386     [outputcontrolpoints(3)]
 387     [partitioning("integer")]
 388     [outputtopology("triangle_ccw")]
 389     [patchconstantfunc("patch_constant")]
 390 float4 main() : POSITION
 391 {
 392     return 0;
 393 }
 394
 395
 396 %% Test the valid range for outputcontrolpoints ([0, 32]).
 397
 398 [hull shader fail(sm>=6)]
 399 struct patch_constant_data
 400 {
 401     float edges[2] : SV_TessFactor;
 402 };
 403
 404 patch_constant_data patch_constant()
 405 {
 406     return (patch_constant_data)0;
 407 }
 408
 409     [domain("isoline")]
 410     [outputcontrolpoints(0)]
 411     [partitioning("integer")]
 412     [outputtopology("point")]
 413     [patchconstantfunc("patch_constant")]
 414 float4 main() : POSITION
 415 {
 416     return 0;
 417 }
 418
 419 [hull shader]
 420 struct patch_constant_data
 421 {
 422     float edges[2] : SV_TessFactor;
 423 };
 424
 425 patch_constant_data patch_constant()
 426 {
 427     return (patch_constant_data)0;
 428 }
 429
 430     [domain("isoline")]
 431     [outputcontrolpoints(32)]
 432     [partitioning("integer")]
 433     [outputtopology("point")]
 434     [patchconstantfunc("patch_constant")]
 435 float4 main() : POSITION
 436 {
 437     return 0;
 438 }
 439
 440 [hull shader fail]
 441 struct patch_constant_data
 442 {
 443     float edges[2] : SV_TessFactor;
 444 };
 445
 446 patch_constant_data patch_constant()
 447 {
 448     return (patch_constant_data)0;
 449 }
 450
 451     [domain("isoline")]
 452     [outputcontrolpoints(33)]
 453     [partitioning("integer")]
 454     [outputtopology("point")]
 455     [patchconstantfunc("patch_constant")]
 456 float4 main() : POSITION
 457 {
 458     return 0;
 459 }
 460
 461
 462 % patchconstantfunc can't point to the main function.
 463 [hull shader notimpl(sm<6) fail(sm>=6)]
 464 struct patch_constant_data
 465 {
 466     float edges[2] : SV_TessFactor;
 467 };
 468
 469 patch_constant_data patch_constant()
 470 {
 471     return (patch_constant_data)0;
 472 }
 473
 474     [domain("isoline")]
 475     [outputcontrolpoints(3)]
 476     [partitioning("integer")]
 477     [outputtopology("point")]
 478     [patchconstantfunc("main")]
 479 float4 main() : POSITION
 480 {
 481     return 0;
 482 }