Test/spv.int8.frag

   1 #version 450
   2
   3 #extension GL_EXT_shader_explicit_arithmetic_types: enable
   4 #extension GL_EXT_shader_explicit_arithmetic_types_int8: require
   5 #extension GL_EXT_shader_explicit_arithmetic_types_int16: require
   6 #extension GL_EXT_shader_explicit_arithmetic_types_int32: require
   7 #extension GL_EXT_shader_explicit_arithmetic_types_int64: require
   8 #extension GL_EXT_shader_explicit_arithmetic_types_float16: require
   9 #extension GL_EXT_shader_explicit_arithmetic_types_float32: require
  10 #extension GL_EXT_shader_explicit_arithmetic_types_float64: require
  11
  12 layout(binding = 0) uniform Uniforms
  13 {
  14     uint index;
  15 };
  16
  17 layout(std140, binding = 1) uniform Block
  18 {
  19     int8_t   i8;
  20     i8vec2   i8v2;
  21     i8vec3   i8v3;
  22     i8vec4   i8v4;
  23     uint8_t  u8;
  24     u8vec2   u8v2;
  25     u8vec3   u8v3;
  26     u8vec4   u8v4;
  27 } block;
  28
  29 void main()
  30 {
  31 }
  32
  33 void literal()
  34 {
  35     const int8_t i8Const[3] =
  36     {
  37         int8_t(-0x11),           // Hex
  38         int8_t(-1),              // Dec
  39         int8_t(0400),            // Oct
  40     };
  41
  42     int8_t i8 = i8Const[index];
  43
  44     const uint8_t u8Const[] =
  45     {
  46         uint8_t(0xFF),             // Hex
  47         uint8_t(255),              // Dec
  48         uint8_t(0177),             // Oct
  49     };
  50
  51     uint8_t u8 = u8Const[index];
  52 }
  53
  54 void typeCast8()
  55 {
  56     i8vec2 i8v;
  57     u8vec2 u8v;
  58     i16vec2 i16v;
  59     u16vec2 u16v;
  60     i32vec2 i32v;
  61     u32vec2 u32v;
  62     i64vec2 i64v;
  63     u64vec2 u64v;
  64     f16vec2 f16v;
  65     f32vec2 f32v;
  66     f64vec2 f64v;
  67     bvec2   bv;
  68
  69     u8v = i8v;      // int8_t  ->  uint8_t
  70     i16v = i8v;     // int8_t  ->   int16_t
  71     i16v = u8v;     // uint8_t ->   int16_t
  72     i32v = i8v;     // int8_t  ->   int32_t
  73     i32v = u8v;     // uint8_t ->   int32_t
  74     u32v = i8v;     // int8_t  ->  uint32_t
  75     i64v = i8v;     // int8_t  ->   int64_t
  76     u64v = i8v;     // int8_t  ->  uint64_t
  77     u32v = u8v;     // uint8_t ->  uint32_t
  78     i64v = u8v;     // uint8_t ->   int64_t
  79     u64v = u8v;     // uint8_t ->  uint64_t
  80     f16v = i8v;     // int8_t  ->  float16_t
  81     f32v = i8v;     // int8_t  ->  float32_t
  82     f64v = i8v;     // int8_t  ->  float64_t
  83     f16v = u8v;     // uint8_t ->  float16_t
  84     f32v = u8v;     // uint8_t ->  float32_t
  85     f64v = u8v;     // uint8_t ->  float64_t
  86
  87     i8v =  i8vec2(u8v);       // uint8_t  ->   int8_t
  88     i16v = i16vec2(i8v);      // int8_t   ->   int16_t
  89     i16v = i16vec2(u8v);      // uint8_t  ->   int16_t
  90     i32v = i32vec2(i8v);      // int8_t   ->   int32_t
  91     i32v = i32vec2(u8v);      // uint8_t  ->   int32_t
  92     i64v = i64vec2(i8v);      // int8_t   ->   int64_t
  93     u64v = i64vec2(i8v);      // int8_t   ->  uint64_t
  94     u16v = u16vec2(i8v);      // int8_t   ->  uint16_t
  95     u16v = u16vec2(u8v);      // uint8_t  ->  uint16_t
  96     u32v = u32vec2(u8v);      // uint8_t  ->  uint32_t
  97     i64v = i64vec2(u8v);      // uint8_t  ->   int64_t
  98     u64v = i64vec2(u8v);      // uint8_t  ->  uint64_t
  99     f16v = f16vec2(i8v);      // int8_t   ->  float16_t
 100     f32v = f32vec2(i8v);      // int8_t   ->  float32_t
 101     f64v = f64vec2(i8v);      // int8_t   ->  float64_t
 102     f16v = f16vec2(u8v);      // uint8_t  ->  float16_t
 103     f32v = f32vec2(u8v);      // uint8_t  ->  float32_t
 104     f64v = f64vec2(u8v);      // uint8_t  ->  float64_t
 105
 106     i8v = i8vec2(bv);       // bool     ->   int8
 107     u8v = u8vec2(bv);       // bool     ->   uint8
 108     bv  = bvec2(i8v);       // int8    ->   bool
 109     bv  = bvec2(u8v);       // uint8   ->   bool
 110 }
 111
 112 void operators()
 113 {
 114     u8vec3 u8v;
 115     int8_t i8;
 116     uvec3   uv;
 117     int32_t i;
 118     int16_t i16;
 119     bool    b;
 120     float   arr[4] = {1.0, 2.0, 3.0, 4.0};
 121     float   f;
 122
 123     // Unary
 124     u8v++;
 125     i8--;
 126     ++i8;
 127     --u8v;
 128
 129     u8v = ~u8v;
 130
 131     i8 = +i8;
 132     u8v = -u8v;
 133
 134     // Arithmetic
 135     i8  += i8;
 136     u8v -= u8v;
 137     i  *= i8;
 138     uv /= u8v;
 139     uv %= i8;
 140
 141     uv = u8v + uv;
 142     i16  = i8 - i16;
 143     uv = u8v * uv;
 144     i16  = i8 * i16;
 145     i  = i8 % i;
 146
 147     // Shift
 148     u8v <<= i8;
 149     i8  >>= u8v.y;
 150
 151     i8  = i8 << u8v.z;
 152     u8v = u8v << i8;
 153
 154     // Relational
 155     b = (u8v.x != i8);
 156     b = (i8 == u8v.x);
 157     b = (u8v.x > uv.y);
 158     b = (i8 < i);
 159     b = (u8v.y >= uv.x);
 160     b = (i8 <= i);
 161
 162     // Bitwise
 163     uv |= i8;
 164     i  = i8 | i;
 165     i16  &= i8;
 166     uv = u8v & uv;
 167     uv ^= i8;
 168     u8v = u8v ^ i8;
 169
 170     // Index
 171     f = arr[i8];
 172 }
 173
 174 void builtinFuncs()
 175 {
 176     i8vec2  i8v;
 177     i8vec4  i8v4;
 178     u8vec3  u8v;
 179     u8vec2  u8v2;
 180     u8vec4  u8v4;
 181     bvec3   bv;
 182     int16_t i16;
 183     int32_t i32;
 184     uint16_t u16;
 185     uint32_t u32;
 186
 187     int8_t  i8;
 188     uint8_t u8;
 189
 190     // abs()
 191     i8v = abs(i8v);
 192
 193     // sign()
 194     i8  = sign(i8);
 195
 196     // min()
 197     i8v = min(i8v, i8);
 198     i8v = min(i8v, i8vec2(-1));
 199     u8v = min(u8v, u8);
 200     u8v = min(u8v, u8vec3(0));
 201
 202     // max()
 203     i8v = max(i8v, i8);
 204     i8v = max(i8v, i8vec2(-1));
 205     u8v = max(u8v, u8);
 206     u8v = max(u8v, u8vec3(0));
 207
 208     // clamp()
 209     i8v = clamp(i8v, -i8, i8);
 210     i8v = clamp(i8v, -i8v, i8v);
 211     u8v = clamp(u8v, -u8, u8);
 212     u8v = clamp(u8v, -u8v, u8v);
 213
 214     // mix()
 215     i8  = mix(i8v.x, i8v.y, true);
 216     i8v = mix(i8vec2(i8), i8vec2(-i8), bvec2(false));
 217     u8  = mix(u8v.x, u8v.y, true);
 218     u8v = mix(u8vec3(u8), u8vec3(-u8), bvec3(false));
 219
 220     //pack
 221     i16 = pack16(i8v);
 222     i32 = pack32(i8v4);
 223     u16 = pack16(u8v2);
 224     u32 = pack32(u8v4);
 225
 226     i8v  = unpack8(i16);
 227     i8v4 = unpack8(i32);
 228     u8v2 = unpack8(u16);
 229     u8v4 = unpack8(u32);
 230
 231     // lessThan()
 232     bv    = lessThan(u8v, u8vec3(u8));
 233     bv.xy = lessThan(i8v, i8vec2(i8));
 234
 235     // lessThanEqual()
 236     bv    = lessThanEqual(u8v, u8vec3(u8));
 237     bv.xy = lessThanEqual(i8v, i8vec2(i8));
 238
 239     // greaterThan()
 240     bv    = greaterThan(u8v, u8vec3(u8));
 241     bv.xy = greaterThan(i8v, i8vec2(i8));
 242
 243     // greaterThanEqual()
 244     bv    = greaterThanEqual(u8v, u8vec3(u8));
 245     bv.xy = greaterThanEqual(i8v, i8vec2(i8));
 246
 247     // equal()
 248     bv    = equal(u8v, u8vec3(u8));
 249     bv.xy = equal(i8v, i8vec2(i8));
 250
 251     // notEqual()
 252     bv    = notEqual(u8v, u8vec3(u8));
 253     bv.xy = notEqual(i8v, i8vec2(i8));
 254 }
 255
 256 // Type conversion for specialization constant
 257 layout(constant_id = 100) const int8_t  si8 = int8_t(-10);
 258 layout(constant_id = 101) const uint8_t su8 = uint8_t(20);