tests/hlsl/ternary.shader_test

   1 [require]
   2 % The ternary operator works differently in sm6. See sm6-ternary.shader_test.
   3 shader model < 6.0
   4
   5
   6 [pixel shader]
   7 uniform float4 x;
   8
   9 float4 main() : sv_target
  10 {
  11     return x.x ? x : x - 1;
  12 }
  13
  14 [test]
  15 uniform 0 float4 2.0 3.0 4.0 5.0
  16 draw quad
  17 probe (0, 0) rgba (2.0, 3.0, 4.0, 5.0)
  18 uniform 0 float4 0.0 10.0 11.0 12.0
  19 draw quad
  20 probe (0, 0) rgba (-1.0, 9.0, 10.0, 11.0)
  21
  22
  23 [pixel shader]
  24 uniform float4 x;
  25
  26 float4 main() : sv_target
  27 {
  28     float4 ret;
  29
  30     ret.x = x.x ? x.x : 1;
  31     ret.y = x.y ? 2 : x.y;
  32     ret.z = ret.w = 0.0;
  33     return ret;
  34 }
  35
  36 [test]
  37 uniform 0 float4 1.1 3.0 4.0 5.0
  38 draw quad
  39 probe (0, 0) rgba (1.1, 2.0, 0.0, 0.0)
  40
  41
  42 [pixel shader]
  43 float4 f;
  44
  45 float4 main() : sv_target
  46 {
  47     float f1 = 0.1, f2 = 0.2, f3;
  48     f3 = f.x ? (f1 = 0.5) + 0.2 : (f2 = 0.6);
  49     return float4(f1, f2, f3, 0.0);
  50 }
  51
  52 [test]
  53 uniform 0 float4 1.0 0.0 0.0 0.0
  54 draw quad
  55 probe (0, 0) rgba (0.5, 0.6, 0.7, 0.0)
  56
  57
  58 [pixel shader]
  59 float4 x, y, z;
  60
  61 float4 main() : sv_target
  62 {
  63     return x ? y : z;
  64 }
  65
  66 [test]
  67 uniform 0 float4 0.0 1.0 0.0 -3.0
  68 uniform 4 float4 1.0 2.0 3.0 4.0
  69 uniform 8 float4 5.0 6.0 7.0 8.0
  70 draw quad
  71 probe (0, 0) rgba (5.0, 2.0, 7.0, 4.0)
  72
  73
  74 % The usual type conversion is applied to the first and second expression, as
  75 % long as they are numeric.
  76
  77 [pixel shader fail]
  78
  79 uniform float2x4 a;
  80 uniform float3x2 b;
  81
  82 float4 main() : sv_target
  83 {
  84     0 ? a : b;
  85     return 0;
  86 }
  87
  88
  89 [pixel shader]
  90
  91 static float3x3 a = {0, 1, 2, 3, 4, 5, 6, 7, 8};
  92 static float2x2 b = {.1, .2, .3, .4};
  93
  94 float4 main() : sv_target
  95 {
  96     return float4(1 ? a : b);
  97 }
  98
  99 [test]
 100 draw quad
 101 probe (0, 0) rgba (0.0, 1.0, 3.0, 4.0)
 102
 103
 104 [pixel shader]
 105
 106 static float3 a = {0, 1, 2};
 107 static float4 b = {5, 6, 7, 8};
 108
 109 float4 main() : sv_target
 110 {
 111     return float4(0 ? a : b, 1.0);
 112 }
 113
 114 [test]
 115 draw quad
 116 probe (0, 0) rgba (5.0, 6.0, 7.0, 1.0)
 117
 118
 119 % More restrictions are placed on the type of the first (condition) operand,
 120 % relative to the common type computed from the other two (result). Either:
 121 % * the class and dimensions must match exactly;
 122 % * the condition operand is scalar;
 123 % * the result operands are scalar;
 124 % * one is a typeN and the other is a type1xN
 125
 126 [pixel shader fail]
 127
 128 uniform float4 cond;
 129 uniform float2x2 a, b;
 130
 131 float4 main() : sv_target
 132 {
 133     return float4(cond ? a : b);
 134 }
 135
 136
 137 [pixel shader fail]
 138
 139 uniform float2x2 cond;
 140 uniform float4 a, b;
 141
 142 float4 main() : sv_target
 143 {
 144     return float4(cond ? a : b);
 145 }
 146
 147
 148 [pixel shader]
 149
 150 static float2x2 cond = {1, 0, 0, 1};
 151 static float2x2 a = {1, 2, 3, 4};
 152 static float2x2 b = {5, 6, 7, 8};
 153
 154 float4 main() : sv_target
 155 {
 156     return float4(cond ? a : b);
 157 }
 158
 159 [test]
 160 draw quad
 161 probe (0, 0) rgba (1.0, 6.0, 7.0, 4.0)
 162
 163
 164 [pixel shader fail]
 165
 166 uniform float3 cond;
 167 uniform float4 a, b;
 168
 169 float4 main() : sv_target
 170 {
 171     (cond ? a : b);
 172     return 0;
 173 }
 174
 175
 176 [pixel shader fail]
 177
 178 uniform float4 cond;
 179 uniform float4x1 a, b;
 180
 181 float4 main() : sv_target
 182 {
 183     (cond ? a : b);
 184     return 0;
 185 }
 186
 187
 188 % As may be expected, this yields the type of the arguments, not the conditional.
 189
 190 [pixel shader]
 191
 192 static float4 cond = {1, 0, 0, 1};
 193 static float1x4 a = {1, 2, 3, 4};
 194 static float1x4 b = {5, 6, 7, 8};
 195
 196 float4 main() : sv_target
 197 {
 198     return (cond ? a : b)[0];
 199 }
 200
 201 [test]
 202 draw quad
 203 probe (0, 0) rgba (1.0, 6.0, 7.0, 4.0)
 204
 205
 206 [pixel shader]
 207
 208 static float1x4 cond = {1, 0, 0, 1};
 209 static float4 a = {1, 2, 3, 4};
 210 static float4 b = {5, 6, 7, 8};
 211
 212 float4 main() : sv_target
 213 {
 214     return (cond ? a : b)[0];
 215 }
 216
 217 [test]
 218 draw quad
 219 probe (0, 0) rgba (1.0, 1.0, 1.0, 1.0)
 220
 221
 222 [pixel shader fail]
 223
 224 uniform float1x4 cond;
 225 uniform float4 a, b;
 226
 227 float4 main() : sv_target
 228 {
 229     return (cond ? a : b)[0][0];
 230 }
 231
 232
 233 [pixel shader]
 234
 235 static float1 cond = {0};
 236 static float1x1 a = {2};
 237 static float1x1 b = {3};
 238
 239 float4 main() : sv_target
 240 {
 241     return (cond ? a : b)[0][0];
 242 }
 243
 244 [test]
 245 draw quad
 246 probe (0, 0) rgba (3.0, 3.0, 3.0, 3.0)
 247
 248
 249 [pixel shader]
 250
 251 static float1x1 cond = {1};
 252 static float1 a = {2};
 253 static float1 b = {3};
 254
 255 float4 main() : sv_target
 256 {
 257     return (cond ? a : b)[0];
 258 }
 259
 260 [test]
 261 draw quad
 262 probe (0, 0) rgba (2.0, 2.0, 2.0, 2.0)
 263
 264
 265 [pixel shader fail]
 266
 267 static float1x1 cond = {1};
 268 static float1 a = {2};
 269 static float1 b = {3};
 270
 271 float4 main() : sv_target
 272 {
 273     return (cond ? a : b)[0][0];
 274 }
 275
 276
 277 [pixel shader]
 278
 279 uniform float cond;
 280 uniform float4 a, b;
 281
 282 float4 main() : sv_target
 283 {
 284     return float4(cond ? a : b);
 285 }
 286
 287 [test]
 288 uniform 0 float4 1.0 0.0 0.0 0.0
 289 uniform 4 float4 1.0 2.0 3.0 4.0
 290 uniform 8 float4 5.0 6.0 7.0 8.0
 291 draw quad
 292 probe (0, 0) rgba (1.0, 2.0, 3.0, 4.0)
 293
 294
 295 [pixel shader]
 296
 297 // "scalar" can mean any 1-component numeric type.
 298 static float1x1 cond = {0};
 299 static float4 a = {1, 2, 3, 4};
 300 static float4 b = {5, 6, 7, 8};
 301
 302 float4 main() : sv_target
 303 {
 304     return float4(cond ? a : b);
 305 }
 306
 307 [test]
 308 draw quad
 309 probe (0, 0) rgba (5.0, 6.0, 7.0, 8.0)
 310
 311
 312 [pixel shader]
 313
 314 uniform float4 cond;
 315 uniform float4 a, b;
 316
 317 float4 main() : sv_target
 318 {
 319     return float4(cond ? a.x : b.x);
 320 }
 321
 322 [test]
 323 uniform 0 float4 1.0 0.0 1.0 0.0
 324 uniform 4 float4 1.0 2.0 3.0 4.0
 325 uniform 8 float4 5.0 6.0 7.0 8.0
 326 draw quad
 327 probe (0, 0) rgba (1.0, 5.0, 1.0, 5.0)
 328
 329
 330 [pixel shader]
 331
 332 // "scalar" can mean any 1-component numeric type.
 333 static float4 cond = {1, 0, 0, 1};
 334 static float1x1 a = {2};
 335 static float1x1 b = {3};
 336
 337 float4 main() : sv_target
 338 {
 339     return float4(cond ? a : b);
 340 }
 341
 342 [test]
 343 draw quad
 344 probe (0, 0) rgba (2.0, 3.0, 3.0, 2.0)
 345
 346
 347 % Objects can be used, but their types have to be identical.
 348
 349 [pixel shader]
 350 Texture2D t;
 351
 352 float4 main() : sv_target
 353 {
 354     Texture2D tmp = 0 ? t : t;
 355     return 0;
 356 }
 357
 358
 359 [pixel shader fail todo]
 360 Texture2D t;
 361 float4 f;
 362
 363 float4 main() : sv_target
 364 {
 365     f ? t : t;
 366     return 0;
 367 }
 368
 369
 370 [pixel shader fail]
 371 Texture2D t;
 372 Texture3D u;
 373
 374 float4 main() : sv_target
 375 {
 376     0 ? t : u;
 377     return 0;
 378 }
 379
 380
 381 % Of course objects cannot be used as the condition.
 382
 383 [pixel shader fail]
 384 Texture2D t;
 385
 386 float4 main() : sv_target
 387 {
 388     t ? 0 : 1;
 389     return 0;
 390 }