tests/spec/arb_gpu_shader_int64/execution/fs-ushr-and-mask.shader_test

   1 [require]
   2 GL >= 4.0
   3 GLSL >= 4.00
   4 GL_ARB_gpu_shader_int64
   5
   6 [vertex shader passthrough]
   7
   8 [fragment shader]
   9 #version 400
  10 #extension GL_ARB_gpu_shader_int64 : require
  11
  12 uniform uint64_t ival[] = uint64_t[](0xBADDC0DEDEADBEEFul,
  13                                      0xDEADBEA7BA5EBA11ul,
  14                                      0xF0F1F2F3F4F5F6F7ul,
  15                                      0x0F1F2F3F4F5F6F7Ful,
  16                                      0x7071727374757677ul,
  17                                      0x0717273747576777ul,
  18                                      0x1F2E3D4C5B6A7988ul,
  19                                      0xBADB100DDEADC0DEul);
  20
  21 const uint64_t expected[] = uint64_t[](0x00000000000000EFul,
  22                                        0x00000000000000BAul,
  23                                        0x00000000000000F5ul,
  24                                        0x000000000000004Ful,
  25                                        0x0000000000000073ul,
  26                                        0x0000000000000027ul,
  27                                        0x000000000000002Eul,
  28                                        0x00000000000000BAul);
  29
  30 out vec4 piglit_fragcolor;
  31
  32 void main()
  33 {
  34         uint fail_mask = 0;
  35         uint64_t result;
  36         uint i;
  37
  38         /* This is INTENTIONALLY not a loop.  Putting it in a loop causes the
  39          * optimization that generates the extract instructions to trigger
  40          * before the shift count is known to be a constant.  The effectively
  41          * prevents the bad code generation in the i965 driver from occurring.
  42          */
  43         i = 0;
  44         result = (ival[i] >> (i * 8u)) & 0x0FFul;
  45         fail_mask |= result != expected[i] ? 1u << i : 0u;
  46
  47         i = 1;
  48         result = (ival[i] >> (i * 8u)) & 0x0FFul;
  49         fail_mask |= result != expected[i] ? 1u << i : 0u;
  50
  51         i = 2;
  52         result = (ival[i] >> (i * 8u)) & 0x0FFul;
  53         fail_mask |= result != expected[i] ? 1u << i : 0u;
  54
  55         i = 3;
  56         result = (ival[i] >> (i * 8u)) & 0x0FFul;
  57         fail_mask |= result != expected[i] ? 1u << i : 0u;
  58
  59         i = 4;
  60         result = (ival[i] >> (i * 8u)) & 0x0FFul;
  61         fail_mask |= result != expected[i] ? 1u << i : 0u;
  62
  63         i = 5;
  64         result = (ival[i] >> (i * 8u)) & 0x0FFul;
  65         fail_mask |= result != expected[i] ? 1u << i : 0u;
  66
  67         i = 6;
  68         result = (ival[i] >> (i * 8u)) & 0x0FFul;
  69         fail_mask |= result != expected[i] ? 1u << i : 0u;
  70
  71         i = 7;
  72         result = (ival[i] >> (i * 8u)) & 0x0FFul;
  73         fail_mask |= result != expected[i] ? 1u << i : 0u;
  74
  75         /* Construct a clever color so that just looking at the "Observed:"
  76          * output from shader_runner will tell you exactly which values did
  77          * not match.
  78          */
  79         piglit_fragcolor = fail_mask == 0
  80                 ? vec4(0.0, 1.0, 0.0, 1.0)
  81                 : vec4(float(fail_mask) / 255.0, 0.0, 0.0, 1.0);
  82 }
  83
  84 [test]
  85 clear color 0.5 0.5 0.5 0.5
  86 clear
  87
  88 draw rect -1 -1 2 2
  89 probe all rgba 0.0 1.0 0.0 1.0