Test/hlsl.intrinsics.frag

   1 float PixelShaderFunction(float inF0, float inF1, float inF2)
   2 {
   3     all(inF0);
   4     abs(inF0);
   5     acos(inF0);
   6     any(inF0);
   7     asin(inF0);
   8     atan(inF0);
   9     atan2(inF0, inF1);
  10     ceil(inF0);
  11     clamp(inF0, inF1, inF2);
  12     clip(inF0);
  13     cos(inF0);
  14     cosh(inF0);
  15     countbits(7);
  16     ddx(inF0);
  17     ddx_coarse(inF0);
  18     ddx_fine(inF0);
  19     ddy(inF0);
  20     ddy_coarse(inF0);
  21     ddy_fine(inF0);
  22     degrees(inF0);
  23     // EvaluateAttributeAtCentroid(inF0);
  24     // EvaluateAttributeAtSample(inF0, 0);
  25     // TODO: EvaluateAttributeSnapped(inF0, int2(1,2));
  26     exp(inF0);
  27     exp2(inF0);
  28     firstbithigh(7);
  29     firstbitlow(7);
  30     floor(inF0);
  31     // TODO: fma(inD0, inD1, inD2);
  32     fmod(inF0, inF1);
  33     frac(inF0);
  34     frexp(inF0, inF1);
  35     fwidth(inF0);
  36     isinf(inF0);
  37     isnan(inF0);
  38     ldexp(inF0, inF1);
  39     log(inF0);
  40     log10(inF0);
  41     log2(inF0);
  42     max(inF0, inF1);
  43     min(inF0, inF1);
  44     pow(inF0, inF1);
  45     radians(inF0);
  46     rcp(inF0);
  47     reversebits(2);
  48     round(inF0);
  49     rsqrt(inF0);
  50     saturate(inF0);
  51     sign(inF0);
  52     sin(inF0);
  53     sincos(inF0, inF1, inF2);
  54     sinh(inF0);
  55     smoothstep(inF0, inF1, inF2);
  56     sqrt(inF0);
  57     step(inF0, inF1);
  58     tan(inF0);
  59     tanh(inF0);
  60     // TODO: sampler intrinsics, when we can declare the types.
  61     trunc(inF0);
  62
  63     return 0.0;
  64 }
  65
  66 float1 PixelShaderFunction(float1 inF0, float1 inF1, float1 inF2)
  67 {
  68     // TODO: ... add when float1 prototypes are generated
  69     return 0.0;
  70 }
  71
  72 float2 PixelShaderFunction(float2 inF0, float2 inF1, float2 inF2)
  73 {
  74     all(inF0);
  75     abs(inF0);
  76     acos(inF0);
  77     any(inF0);
  78     asin(inF0);
  79     atan(inF0);
  80     atan2(inF0, inF1);
  81     ceil(inF0);
  82     clamp(inF0, inF1, inF2);
  83     clip(inF0);
  84     cos(inF0);
  85     cosh(inF0);
  86     countbits(int2(7,3));
  87     ddx(inF0);
  88     ddx_coarse(inF0);
  89     ddx_fine(inF0);
  90     ddy(inF0);
  91     ddy_coarse(inF0);
  92     ddy_fine(inF0);
  93     degrees(inF0);
  94     distance(inF0, inF1);
  95     dot(inF0, inF1);
  96     // EvaluateAttributeAtCentroid(inF0);
  97     // EvaluateAttributeAtSample(inF0, 0);
  98     // TODO: EvaluateAttributeSnapped(inF0, int2(1,2));
  99     exp(inF0);
 100     exp2(inF0);
 101     faceforward(inF0, inF1, inF2);
 102     firstbithigh(7);
 103     firstbitlow(7);
 104     floor(inF0);
 105     // TODO: fma(inD0, inD1, inD2);
 106     fmod(inF0, inF1);
 107     frac(inF0);
 108     frexp(inF0, inF1);
 109     fwidth(inF0);
 110     isinf(inF0);
 111     isnan(inF0);
 112     ldexp(inF0, inF1);
 113     length(inF0);
 114     log(inF0);
 115     log10(inF0);
 116     log2(inF0);
 117     max(inF0, inF1);
 118     min(inF0, inF1);
 119     normalize(inF0);
 120     pow(inF0, inF1);
 121     radians(inF0);
 122     rcp(inF0);
 123     reflect(inF0, inF1);
 124     refract(inF0, inF1, 2.0);
 125     reversebits(int2(1,2));
 126     round(inF0);
 127     rsqrt(inF0);
 128     saturate(inF0);
 129     sign(inF0);
 130     sin(inF0);
 131     sincos(inF0, inF1, inF2);
 132     sinh(inF0);
 133     smoothstep(inF0, inF1, inF2);
 134     sqrt(inF0);
 135     step(inF0, inF1);
 136     tan(inF0);
 137     tanh(inF0);
 138     // TODO: sampler intrinsics, when we can declare the types.
 139     trunc(inF0);
 140
 141     // TODO: ... add when float1 prototypes are generated
 142     return float2(1,2);
 143 }
 144
 145 float3 PixelShaderFunction(float3 inF0, float3 inF1, float3 inF2)
 146 {
 147     all(inF0);
 148     abs(inF0);
 149     acos(inF0);
 150     any(inF0);
 151     asin(inF0);
 152     atan(inF0);
 153     atan2(inF0, inF1);
 154     ceil(inF0);
 155     clamp(inF0, inF1, inF2);
 156     clip(inF0);
 157     cos(inF0);
 158     cosh(inF0);
 159     countbits(int3(7,3,5));
 160     cross(inF0, inF1);
 161     ddx(inF0);
 162     ddx_coarse(inF0);
 163     ddx_fine(inF0);
 164     ddy(inF0);
 165     ddy_coarse(inF0);
 166     ddy_fine(inF0);
 167     degrees(inF0);
 168     distance(inF0, inF1);
 169     dot(inF0, inF1);
 170     // EvaluateAttributeAtCentroid(inF0);
 171     // EvaluateAttributeAtSample(inF0, 0);
 172     // TODO: EvaluateAttributeSnapped(inF0, int2(1,2));
 173     exp(inF0);
 174     exp2(inF0);
 175     faceforward(inF0, inF1, inF2);
 176     firstbithigh(7);
 177     firstbitlow(7);
 178     floor(inF0);
 179     // TODO: fma(inD0, inD1, inD2);
 180     fmod(inF0, inF1);
 181     frac(inF0);
 182     frexp(inF0, inF1);
 183     fwidth(inF0);
 184     isinf(inF0);
 185     isnan(inF0);
 186     ldexp(inF0, inF1);
 187     length(inF0);
 188     log(inF0);
 189     log10(inF0);
 190     log2(inF0);
 191     max(inF0, inF1);
 192     min(inF0, inF1);
 193     normalize(inF0);
 194     pow(inF0, inF1);
 195     radians(inF0);
 196     rcp(inF0);
 197     reflect(inF0, inF1);
 198     refract(inF0, inF1, 2.0);
 199     reversebits(int3(1,2,3));
 200     round(inF0);
 201     rsqrt(inF0);
 202     saturate(inF0);
 203     sign(inF0);
 204     sin(inF0);
 205     sincos(inF0, inF1, inF2);
 206     sinh(inF0);
 207     smoothstep(inF0, inF1, inF2);
 208     sqrt(inF0);
 209     step(inF0, inF1);
 210     tan(inF0);
 211     tanh(inF0);
 212     // TODO: sampler intrinsics, when we can declare the types.
 213     trunc(inF0);
 214
 215     // TODO: ... add when float1 prototypes are generated
 216     return float3(1,2,3);
 217 }
 218
 219 float4 PixelShaderFunction(float4 inF0, float4 inF1, float4 inF2)
 220 {
 221     all(inF0);
 222     abs(inF0);
 223     acos(inF0);
 224     any(inF0);
 225     asin(inF0);
 226     atan(inF0);
 227     atan2(inF0, inF1);
 228     ceil(inF0);
 229     clamp(inF0, inF1, inF2);
 230     clip(inF0);
 231     cos(inF0);
 232     cosh(inF0);
 233     countbits(int4(7,3,5,2));
 234     ddx(inF0);
 235     ddx_coarse(inF0);
 236     ddx_fine(inF0);
 237     ddy(inF0);
 238     ddy_coarse(inF0);
 239     ddy_fine(inF0);
 240     degrees(inF0);
 241     distance(inF0, inF1);
 242     dot(inF0, inF1);
 243     dst(inF0, inF1);
 244     // EvaluateAttributeAtCentroid(inF0);
 245     // EvaluateAttributeAtSample(inF0, 0);
 246     // TODO: EvaluateAttributeSnapped(inF0, int2(1,2));
 247     exp(inF0);
 248     exp2(inF0);
 249     faceforward(inF0, inF1, inF2);
 250     firstbithigh(7);
 251     firstbitlow(7);
 252     floor(inF0);
 253     // TODO: fma(inD0, inD1, inD2);
 254     fmod(inF0, inF1);
 255     frac(inF0);
 256     frexp(inF0, inF1);
 257     fwidth(inF0);
 258     isinf(inF0);
 259     isnan(inF0);
 260     ldexp(inF0, inF1);
 261     length(inF0);
 262     log(inF0);
 263     log10(inF0);
 264     log2(inF0);
 265     max(inF0, inF1);
 266     min(inF0, inF1);
 267     normalize(inF0);
 268     pow(inF0, inF1);
 269     radians(inF0);
 270     rcp(inF0);
 271     reflect(inF0, inF1);
 272     refract(inF0, inF1, 2.0);
 273     reversebits(int4(1,2,3,4));
 274     round(inF0);
 275     rsqrt(inF0);
 276     saturate(inF0);
 277     sign(inF0);
 278     sin(inF0);
 279     sincos(inF0, inF1, inF2);
 280     sinh(inF0);
 281     smoothstep(inF0, inF1, inF2);
 282     sqrt(inF0);
 283     step(inF0, inF1);
 284     tan(inF0);
 285     tanh(inF0);
 286     // TODO: sampler intrinsics, when we can declare the types.
 287     trunc(inF0);
 288
 289     // TODO: ... add when float1 prototypes are generated
 290     return float4(1,2,3,4);
 291 }
 292
 293 // TODO: FXC doesn't accept this with (), but glslang doesn't accept it without.
 294 #define MATFNS() \
 295     all(inF0); \
 296     abs(inF0); \
 297     acos(inF0); \
 298     any(inF0); \
 299     asin(inF0); \
 300     atan(inF0); \
 301     atan2(inF0, inF1); \
 302     ceil(inF0); \
 303     clip(inF0); \
 304     clamp(inF0, inF1, inF2); \
 305     cos(inF0); \
 306     cosh(inF0); \
 307     ddx(inF0); \
 308     ddx_coarse(inF0); \
 309     ddx_fine(inF0); \
 310     ddy(inF0); \
 311     ddy_coarse(inF0); \
 312     ddy_fine(inF0); \
 313     degrees(inF0); \
 314     determinant(inF0); \
 315     exp(inF0); \
 316     exp2(inF0); \
 317     firstbithigh(7); \
 318     firstbitlow(7); \
 319     floor(inF0); \
 320     fmod(inF0, inF1); \
 321     frac(inF0); \
 322     frexp(inF0, inF1); \
 323     fwidth(inF0); \
 324     ldexp(inF0, inF1); \
 325     log(inF0); \
 326     log10(inF0); \
 327     log2(inF0);      \
 328     max(inF0, inF1); \
 329     min(inF0, inF1); \
 330     pow(inF0, inF1); \
 331     radians(inF0); \
 332     round(inF0); \
 333     rsqrt(inF0); \
 334     saturate(inF0); \
 335     sign(inF0); \
 336     sin(inF0); \
 337     sincos(inF0, inF1, inF2); \
 338     sinh(inF0); \
 339     smoothstep(inF0, inF1, inF2); \
 340     sqrt(inF0); \
 341     step(inF0, inF1); \
 342     tan(inF0); \
 343     tanh(inF0); \
 344     transpose(inF0); \
 345     trunc(inF0);
 346
 347 // TODO: turn on non-square matrix tests when protos are available.
 348
 349 float2x2 PixelShaderFunction(float2x2 inF0, float2x2 inF1, float2x2 inF2)
 350 {
 351     // TODO: FXC doesn't accept this with (), but glslang doesn't accept it without.
 352     MATFNS()
 353
 354     // TODO: ... add when float1 prototypes are generated
 355     return float2x2(2,2,2,2);
 356 }
 357
 358 float3x3 PixelShaderFunction(float3x3 inF0, float3x3 inF1, float3x3 inF2)
 359 {
 360     // TODO: FXC doesn't accept this with (), but glslang doesn't accept it without.
 361     MATFNS()
 362
 363     // TODO: ... add when float1 prototypes are generated
 364     return float3x3(3,3,3,3,3,3,3,3,3);
 365 }
 366
 367 float4x4 PixelShaderFunction(float4x4 inF0, float4x4 inF1, float4x4 inF2)
 368 {
 369     // TODO: FXC doesn't accept this with (), but glslang doesn't accept it without.
 370     MATFNS()
 371
 372     // TODO: ... add when float1 prototypes are generated
 373     return float4x4(4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4);
 374 }
 375
 376 #define TESTGENMUL(ST, VT, MT) \
 377     ST r0 = mul(inF0,  inF1);  \
 378     VT r1 = mul(inFV0, inF0);  \
 379     VT r2 = mul(inF0,  inFV0); \
 380     ST r3 = mul(inFV0, inFV1); \
 381     VT r4 = mul(inFM0, inFV0); \
 382     VT r5 = mul(inFV0, inFM0); \
 383     MT r6 = mul(inFM0, inF0);  \
 384     MT r7 = mul(inF0, inFM0);  \
 385     MT r8 = mul(inFM0, inFM1);
 386
 387
 388 void TestGenMul(float inF0, float inF1,
 389                 float2 inFV0, float2 inFV1,
 390                 float2x2 inFM0, float2x2 inFM1)
 391 {
 392     TESTGENMUL(float, float2, float2x2);
 393 }
 394
 395 void TestGenMul(float inF0, float inF1,
 396                 float3 inFV0, float3 inFV1,
 397                 float3x3 inFM0, float3x3 inFM1)
 398 {
 399     TESTGENMUL(float, float3, float3x3);
 400 }
 401
 402 void TestGenMul(float inF0, float inF1,
 403                 float4 inFV0, float4 inFV1,
 404                 float4x4 inFM0, float4x4 inFM1)
 405 {
 406     TESTGENMUL(float, float4, float4x4);
 407 }