SPIRV-Cross/reference/shaders-msl-no-opt/comp/glsl.std450.comp
2019-09-24 18:13:04 -04:00

290 lines
10 KiB
Plaintext

#pragma clang diagnostic ignored "-Wmissing-prototypes"
#include <metal_stdlib>
#include <simd/simd.h>
using namespace metal;
struct SSBO
{
float res;
int ires;
uint ures;
float4 f32;
int4 s32;
uint4 u32;
float2x2 m2;
float3x3 m3;
float4x4 m4;
};
struct ResType
{
float _m0;
int _m1;
};
constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u);
// Implementation of the GLSL radians() function
template<typename T>
inline T radians(T d)
{
return d * T(0.01745329251);
}
// Implementation of the GLSL degrees() function
template<typename T>
inline T degrees(T r)
{
return r * T(57.2957795131);
}
// Implementation of the GLSL findLSB() function
template<typename T>
inline T spvFindLSB(T x)
{
return select(ctz(x), T(-1), x == T(0));
}
// Implementation of the signed GLSL findMSB() function
template<typename T>
inline T spvFindSMSB(T x)
{
T v = select(x, T(-1) - x, x < T(0));
return select(clz(T(0)) - (clz(v) + T(1)), T(-1), v == T(0));
}
// Implementation of the unsigned GLSL findMSB() function
template<typename T>
inline T spvFindUMSB(T x)
{
return select(clz(T(0)) - (clz(x) + T(1)), T(-1), x == T(0));
}
// Implementation of the GLSL sign() function for integer types
template<typename T, typename E = typename enable_if<is_integral<T>::value>::type>
inline T sign(T x)
{
return select(select(select(x, T(0), x == T(0)), T(1), x > T(0)), T(-1), x < T(0));
}
// Returns the determinant of a 2x2 matrix.
static inline __attribute__((always_inline))
float spvDet2x2(float a1, float a2, float b1, float b2)
{
return a1 * b2 - b1 * a2;
}
// Returns the determinant of a 3x3 matrix.
static inline __attribute__((always_inline))
float spvDet3x3(float a1, float a2, float a3, float b1, float b2, float b3, float c1, float c2, float c3)
{
return a1 * spvDet2x2(b2, b3, c2, c3) - b1 * spvDet2x2(a2, a3, c2, c3) + c1 * spvDet2x2(a2, a3, b2, b3);
}
// Returns the inverse of a matrix, by using the algorithm of calculating the classical
// adjoint and dividing by the determinant. The contents of the matrix are changed.
static inline __attribute__((always_inline))
float4x4 spvInverse4x4(float4x4 m)
{
float4x4 adj; // The adjoint matrix (inverse after dividing by determinant)
// Create the transpose of the cofactors, as the classical adjoint of the matrix.
adj[0][0] = spvDet3x3(m[1][1], m[1][2], m[1][3], m[2][1], m[2][2], m[2][3], m[3][1], m[3][2], m[3][3]);
adj[0][1] = -spvDet3x3(m[0][1], m[0][2], m[0][3], m[2][1], m[2][2], m[2][3], m[3][1], m[3][2], m[3][3]);
adj[0][2] = spvDet3x3(m[0][1], m[0][2], m[0][3], m[1][1], m[1][2], m[1][3], m[3][1], m[3][2], m[3][3]);
adj[0][3] = -spvDet3x3(m[0][1], m[0][2], m[0][3], m[1][1], m[1][2], m[1][3], m[2][1], m[2][2], m[2][3]);
adj[1][0] = -spvDet3x3(m[1][0], m[1][2], m[1][3], m[2][0], m[2][2], m[2][3], m[3][0], m[3][2], m[3][3]);
adj[1][1] = spvDet3x3(m[0][0], m[0][2], m[0][3], m[2][0], m[2][2], m[2][3], m[3][0], m[3][2], m[3][3]);
adj[1][2] = -spvDet3x3(m[0][0], m[0][2], m[0][3], m[1][0], m[1][2], m[1][3], m[3][0], m[3][2], m[3][3]);
adj[1][3] = spvDet3x3(m[0][0], m[0][2], m[0][3], m[1][0], m[1][2], m[1][3], m[2][0], m[2][2], m[2][3]);
adj[2][0] = spvDet3x3(m[1][0], m[1][1], m[1][3], m[2][0], m[2][1], m[2][3], m[3][0], m[3][1], m[3][3]);
adj[2][1] = -spvDet3x3(m[0][0], m[0][1], m[0][3], m[2][0], m[2][1], m[2][3], m[3][0], m[3][1], m[3][3]);
adj[2][2] = spvDet3x3(m[0][0], m[0][1], m[0][3], m[1][0], m[1][1], m[1][3], m[3][0], m[3][1], m[3][3]);
adj[2][3] = -spvDet3x3(m[0][0], m[0][1], m[0][3], m[1][0], m[1][1], m[1][3], m[2][0], m[2][1], m[2][3]);
adj[3][0] = -spvDet3x3(m[1][0], m[1][1], m[1][2], m[2][0], m[2][1], m[2][2], m[3][0], m[3][1], m[3][2]);
adj[3][1] = spvDet3x3(m[0][0], m[0][1], m[0][2], m[2][0], m[2][1], m[2][2], m[3][0], m[3][1], m[3][2]);
adj[3][2] = -spvDet3x3(m[0][0], m[0][1], m[0][2], m[1][0], m[1][1], m[1][2], m[3][0], m[3][1], m[3][2]);
adj[3][3] = spvDet3x3(m[0][0], m[0][1], m[0][2], m[1][0], m[1][1], m[1][2], m[2][0], m[2][1], m[2][2]);
// Calculate the determinant as a combination of the cofactors of the first row.
float det = (adj[0][0] * m[0][0]) + (adj[0][1] * m[1][0]) + (adj[0][2] * m[2][0]) + (adj[0][3] * m[3][0]);
// Divide the classical adjoint matrix by the determinant.
// If determinant is zero, matrix is not invertable, so leave it unchanged.
return (det != 0.0f) ? (adj * (1.0f / det)) : m;
}
// Returns the inverse of a matrix, by using the algorithm of calculating the classical
// adjoint and dividing by the determinant. The contents of the matrix are changed.
static inline __attribute__((always_inline))
float3x3 spvInverse3x3(float3x3 m)
{
float3x3 adj; // The adjoint matrix (inverse after dividing by determinant)
// Create the transpose of the cofactors, as the classical adjoint of the matrix.
adj[0][0] = spvDet2x2(m[1][1], m[1][2], m[2][1], m[2][2]);
adj[0][1] = -spvDet2x2(m[0][1], m[0][2], m[2][1], m[2][2]);
adj[0][2] = spvDet2x2(m[0][1], m[0][2], m[1][1], m[1][2]);
adj[1][0] = -spvDet2x2(m[1][0], m[1][2], m[2][0], m[2][2]);
adj[1][1] = spvDet2x2(m[0][0], m[0][2], m[2][0], m[2][2]);
adj[1][2] = -spvDet2x2(m[0][0], m[0][2], m[1][0], m[1][2]);
adj[2][0] = spvDet2x2(m[1][0], m[1][1], m[2][0], m[2][1]);
adj[2][1] = -spvDet2x2(m[0][0], m[0][1], m[2][0], m[2][1]);
adj[2][2] = spvDet2x2(m[0][0], m[0][1], m[1][0], m[1][1]);
// Calculate the determinant as a combination of the cofactors of the first row.
float det = (adj[0][0] * m[0][0]) + (adj[0][1] * m[1][0]) + (adj[0][2] * m[2][0]);
// Divide the classical adjoint matrix by the determinant.
// If determinant is zero, matrix is not invertable, so leave it unchanged.
return (det != 0.0f) ? (adj * (1.0f / det)) : m;
}
// Returns the inverse of a matrix, by using the algorithm of calculating the classical
// adjoint and dividing by the determinant. The contents of the matrix are changed.
static inline __attribute__((always_inline))
float2x2 spvInverse2x2(float2x2 m)
{
float2x2 adj; // The adjoint matrix (inverse after dividing by determinant)
// Create the transpose of the cofactors, as the classical adjoint of the matrix.
adj[0][0] = m[1][1];
adj[0][1] = -m[0][1];
adj[1][0] = -m[1][0];
adj[1][1] = m[0][0];
// Calculate the determinant as a combination of the cofactors of the first row.
float det = (adj[0][0] * m[0][0]) + (adj[0][1] * m[1][0]);
// Divide the classical adjoint matrix by the determinant.
// If determinant is zero, matrix is not invertable, so leave it unchanged.
return (det != 0.0f) ? (adj * (1.0f / det)) : m;
}
template<typename T>
inline T spvReflect(T i, T n)
{
return i - T(2) * i * n * n;
}
template<typename T>
inline T spvRefract(T i, T n, T eta)
{
T NoI = n * i;
T NoI2 = NoI * NoI;
T k = T(1) - eta * eta * (T(1) - NoI2);
if (k < T(0))
{
return T(0);
}
else
{
return eta * i - (eta * NoI + sqrt(k)) * n;
}
}
template<typename T>
inline T spvFaceForward(T n, T i, T nref)
{
return i * nref < T(0) ? n : -n;
}
kernel void main0(device SSBO& _19 [[buffer(0)]])
{
_19.res = round(_19.f32.x);
_19.res = rint(_19.f32.x);
_19.res = trunc(_19.f32.x);
_19.res = abs(_19.f32.x);
_19.ires = abs(_19.s32.x);
_19.res = sign(_19.f32.x);
_19.ires = sign(_19.s32.x);
_19.res = floor(_19.f32.x);
_19.res = ceil(_19.f32.x);
_19.res = fract(_19.f32.x);
_19.res = radians(_19.f32.x);
_19.res = degrees(_19.f32.x);
_19.res = sin(_19.f32.x);
_19.res = cos(_19.f32.x);
_19.res = tan(_19.f32.x);
_19.res = asin(_19.f32.x);
_19.res = acos(_19.f32.x);
_19.res = atan(_19.f32.x);
_19.res = sinh(_19.f32.x);
_19.res = cosh(_19.f32.x);
_19.res = tanh(_19.f32.x);
_19.res = asinh(_19.f32.x);
_19.res = acosh(_19.f32.x);
_19.res = atanh(_19.f32.x);
_19.res = atan2(_19.f32.x, _19.f32.y);
_19.res = pow(_19.f32.x, _19.f32.y);
_19.res = exp(_19.f32.x);
_19.res = log(_19.f32.x);
_19.res = exp2(_19.f32.x);
_19.res = log2(_19.f32.x);
_19.res = sqrt(_19.f32.x);
_19.res = rsqrt(_19.f32.x);
_19.res = abs(_19.f32.x);
_19.res = abs(_19.f32.x - _19.f32.y);
_19.res = sign(_19.f32.x);
_19.res = spvFaceForward(_19.f32.x, _19.f32.y, _19.f32.z);
_19.res = spvReflect(_19.f32.x, _19.f32.y);
_19.res = spvRefract(_19.f32.x, _19.f32.y, _19.f32.z);
_19.res = length(_19.f32.xy);
_19.res = distance(_19.f32.xy, _19.f32.zw);
float2 v2 = normalize(_19.f32.xy);
v2 = faceforward(_19.f32.xy, _19.f32.yz, _19.f32.zw);
v2 = reflect(_19.f32.xy, _19.f32.zw);
v2 = refract(_19.f32.xy, _19.f32.yz, _19.f32.w);
float3 v3 = cross(_19.f32.xyz, _19.f32.yzw);
_19.res = determinant(_19.m2);
_19.res = determinant(_19.m3);
_19.res = determinant(_19.m4);
_19.m2 = spvInverse2x2(_19.m2);
_19.m3 = spvInverse3x3(_19.m3);
_19.m4 = spvInverse4x4(_19.m4);
float tmp;
float _287 = modf(_19.f32.x, tmp);
_19.res = _287;
_19.res = fast::min(_19.f32.x, _19.f32.y);
_19.ures = min(_19.u32.x, _19.u32.y);
_19.ires = min(_19.s32.x, _19.s32.y);
_19.res = fast::max(_19.f32.x, _19.f32.y);
_19.ures = max(_19.u32.x, _19.u32.y);
_19.ires = max(_19.s32.x, _19.s32.y);
_19.res = fast::clamp(_19.f32.x, _19.f32.y, _19.f32.z);
_19.ures = clamp(_19.u32.x, _19.u32.y, _19.u32.z);
_19.ires = clamp(_19.s32.x, _19.s32.y, _19.s32.z);
_19.res = mix(_19.f32.x, _19.f32.y, _19.f32.z);
_19.res = step(_19.f32.x, _19.f32.y);
_19.res = smoothstep(_19.f32.x, _19.f32.y, _19.f32.z);
_19.res = fma(_19.f32.x, _19.f32.y, _19.f32.z);
ResType _387;
_387._m0 = frexp(_19.f32.x, _387._m1);
int itmp = _387._m1;
_19.res = _387._m0;
_19.res = ldexp(_19.f32.x, itmp);
_19.ures = pack_float_to_snorm4x8(_19.f32);
_19.ures = pack_float_to_unorm4x8(_19.f32);
_19.ures = pack_float_to_snorm2x16(_19.f32.xy);
_19.ures = pack_float_to_unorm2x16(_19.f32.xy);
_19.ures = as_type<uint>(half2(_19.f32.xy));
v2 = unpack_snorm2x16_to_float(_19.u32.x);
v2 = unpack_unorm2x16_to_float(_19.u32.x);
v2 = float2(as_type<half2>(_19.u32.x));
float4 v4 = unpack_snorm4x8_to_float(_19.u32.x);
v4 = unpack_unorm4x8_to_float(_19.u32.x);
_19.s32 = spvFindLSB(_19.s32);
_19.s32 = int4(spvFindLSB(_19.u32));
_19.s32 = spvFindSMSB(_19.s32);
_19.s32 = int4(spvFindUMSB(_19.u32));
}