#version 450 | |
#extension GL_ARB_gpu_shader_int64: enable | |
#extension GL_EXT_shader_explicit_arithmetic_types_int64: require | |
layout(binding = 0) uniform Uniforms | |
{ | |
uint index; | |
}; | |
layout(std140, binding = 1) uniform Block | |
{ | |
i64vec3 i64v; | |
uint64_t u64; | |
} block; | |
void main() | |
{ | |
} | |
void literal() | |
{ | |
const int64_t i64Const[3] = | |
{ | |
-0x1111111111111111l, // Hex | |
-1l, // Dec | |
040000000000l, // Oct | |
}; | |
int64_t i64 = i64Const[index]; | |
const uint64_t u64Const[] = | |
{ | |
0xFFFFFFFFFFFFFFFFul, // Hex | |
4294967296UL, // Dec | |
077777777777ul, // Oct | |
}; | |
uint64_t u64 = u64Const[index]; | |
} | |
void typeCast() | |
{ | |
bvec2 bv; | |
ivec2 iv; | |
uvec2 uv; | |
vec2 fv; | |
dvec2 dv; | |
i64vec2 i64v; | |
u64vec2 u64v; | |
i64v = i64vec2(bv); // bool -> int64 | |
u64v = u64vec2(bv); // bool -> uint64 | |
i64v = iv; // int -> int64 | |
iv = ivec2(i64v); // int64 -> int | |
u64v = uv; // uint -> uint64 | |
uv = uvec2(u64v); // uint64 -> uint | |
fv = vec2(i64v); // int64 -> float | |
dv = i64v; // int64 -> double | |
fv = vec2(u64v); // uint64 -> float | |
dv = u64v; // uint64 -> double | |
i64v = i64vec2(fv); // float -> int64 | |
i64v = i64vec2(dv); // double -> int64 | |
u64v = u64vec2(fv); // float -> uint64 | |
u64v = u64vec2(dv); // double -> uint64 | |
bv = bvec2(i64v); // int64 -> bool | |
bv = bvec2(u64v); // uint64 -> bool | |
u64v = i64v; // int64 -> uint64 | |
i64v = i64vec2(u64v); // uint64 -> int64 | |
uv = uvec2(i64v); // int64 -> uint | |
i64v = i64vec2(uv); // uint -> int64 | |
iv = ivec2(u64v); // uint64 -> int | |
u64v = iv; // int -> uint64 | |
} | |
void operators() | |
{ | |
u64vec3 u64v; | |
int64_t i64; | |
uvec3 uv; | |
int i; | |
bool b; | |
// Unary | |
u64v++; | |
i64--; | |
++i64; | |
--u64v; | |
u64v = ~u64v; | |
i64 = +i64; | |
u64v = -u64v; | |
// Arithmetic | |
i64 += i64; | |
u64v -= u64v; | |
i64 *= i; | |
u64v /= uv; | |
u64v %= i; | |
u64v = u64v + uv; | |
i64 = i64 - i; | |
u64v = u64v * uv; | |
i64 = i64 * i; | |
i64 = i64 % i; | |
// Shift | |
u64v = u64v << i; | |
i64 = i64 >> uv.y; | |
u64v <<= i; | |
i64 >>= uv.y; | |
i64 = i64 << u64v.z; | |
u64v = u64v << i64; | |
// Relational | |
b = (u64v.x != i64); | |
b = (i64 == u64v.x); | |
b = (u64v.x > uv.y); | |
b = (i64 < i); | |
b = (u64v.y >= uv.x); | |
b = (i64 <= i); | |
// Bitwise | |
u64v |= i; | |
i64 = i64 | i; | |
i64 &= i; | |
u64v = u64v & uv; | |
u64v ^= i64; | |
u64v = u64v ^ i64; | |
} | |
void builtinFuncs() | |
{ | |
i64vec2 i64v; | |
u64vec3 u64v; | |
dvec3 dv; | |
bvec3 bv; | |
int64_t i64; | |
uint64_t u64; | |
// abs() | |
i64v = abs(i64v); | |
// sign() | |
i64 = sign(i64); | |
// min() | |
i64v = min(i64v, i64); | |
i64v = min(i64v, i64vec2(-1)); | |
u64v = min(u64v, u64); | |
u64v = min(u64v, u64vec3(0)); | |
// max() | |
i64v = max(i64v, i64); | |
i64v = max(i64v, i64vec2(-1)); | |
u64v = max(u64v, u64); | |
u64v = max(u64v, u64vec3(0)); | |
// clamp() | |
i64v = clamp(i64v, -i64, i64); | |
i64v = clamp(i64v, -i64v, i64v); | |
u64v = clamp(u64v, -u64, u64); | |
u64v = clamp(u64v, -u64v, u64v); | |
// mix() | |
i64 = mix(i64v.x, i64v.y, true); | |
i64v = mix(i64vec2(i64), i64vec2(-i64), bvec2(false)); | |
u64 = mix(u64v.x, u64v.y, true); | |
u64v = mix(u64vec3(u64), u64vec3(-u64), bvec3(false)); | |
// doubleBitsToInt64() | |
i64v = doubleBitsToInt64(dv.xy); | |
// doubleBitsToUint64() | |
u64v.x = doubleBitsToUint64(dv.z); | |
// int64BitsToDouble() | |
dv.xy = int64BitsToDouble(i64v); | |
// uint64BitsToDouble() | |
dv = uint64BitsToDouble(u64v); | |
// packInt2x32() | |
i64 = packInt2x32(ivec2(1, 2)); | |
// unpackInt2x32() | |
ivec2 iv = unpackInt2x32(i64); | |
// packUint2x32() | |
u64 = packUint2x32(uvec2(2, 3)); | |
// unpackUint2x32() | |
uvec2 uv = unpackUint2x32(u64); | |
// lessThan() | |
bv = lessThan(u64v, u64vec3(u64)); | |
bv.xy = lessThan(i64v, i64vec2(i64)); | |
// lessThanEqual() | |
bv = lessThanEqual(u64v, u64vec3(u64)); | |
bv.xy = lessThanEqual(i64v, i64vec2(i64)); | |
// greaterThan() | |
bv = greaterThan(u64v, u64vec3(u64)); | |
bv.xy = greaterThan(i64v, i64vec2(i64)); | |
// greaterThanEqual() | |
bv = greaterThanEqual(u64v, u64vec3(u64)); | |
bv.xy = greaterThanEqual(i64v, i64vec2(i64)); | |
// equal() | |
bv = equal(u64v, u64vec3(u64)); | |
bv.xy = equal(i64v, i64vec2(i64)); | |
// notEqual() | |
bv = notEqual(u64v, u64vec3(u64)); | |
bv.xy = notEqual(i64v, i64vec2(i64)); | |
} | |
// Type conversion for specialization constant | |
layout(constant_id = 100) const int64_t si64 = -10L; | |
layout(constant_id = 101) const uint64_t su64 = 20UL; | |
layout(constant_id = 102) const int si = -5; | |
layout(constant_id = 103) const uint su = 4; | |
layout(constant_id = 104) const bool sb = true; | |
layout(constant_id = 105) const uint64_t su64inc = su64 + 1UL; | |
// bool <-> int64/uint64 | |
const bool i64_to_b = bool(si64); | |
const bool u64_to_b = bool(su64); | |
const int64_t b_to_i64 = int64_t(sb); | |
const uint64_t b_to_u64 = uint64_t(sb); | |
// int <-> int64 | |
const int i64_to_i = int(si64); | |
const int64_t i_to_i64 = int64_t(si); | |
// uint <-> uint64 | |
const uint u64_to_u = uint(su64); | |
const uint64_t u_to_u64 = uint64_t(su); | |
// int64 <-> uint64 | |
const int64_t u64_to_i64 = int64_t(su64); | |
const uint64_t i64_to_u64 = uint64_t(si64); | |
// int <-> uint64 | |
const int u64_to_i = int(su64); | |
const uint64_t i_to_u64 = uint64_t(si); | |
// uint <-> int64 | |
const uint i64_to_u = uint(si64); | |
const int64_t u_to_i64 = int64_t(su); | |
#define UINT64_MAX 18446744073709551615ul | |
uint64_t u64Max = UINT64_MAX; |