/bgfx/3rdparty/spirv-cross/reference/shaders-msl-no-opt/comp/glsl.std450.comp

https://gitlab.com/JFT/Irrlicht_extended · GLSL · 282 lines · 221 code · 35 blank · 26 comment · 8 complexity · b35f32ce59e36e546022750c07a4e791 MD5 · raw file 

    

  1. #pragma clang diagnostic ignored "-Wmissing-prototypes"
    2. 

  2. 

  3. #include <metal_stdlib>
    4. 

  4. #include <simd/simd.h>
    5. 

  5. 

  6. using namespace metal;
    7. 

  7. 

  8. struct SSBO
    9. 

  9. {
    10. 

  10.     float res;
    11. 

  11.     int ires;
    12. 

  12.     uint ures;
    13. 

  13.     float4 f32;
    14. 

  14.     int4 s32;
    15. 

  15.     uint4 u32;
    16. 

  16.     float2x2 m2;
    17. 

  17.     float3x3 m3;
    18. 

  18.     float4x4 m4;
    19. 

  19. };
    20. 

  20. 

  21. struct ResType
    22. 

  22. {
    23. 

  23.     float _m0;
    24. 

  24.     int _m1;
    25. 

  25. };
    26. 

  26. 

  27. // Implementation of the GLSL radians() function
    28. 

  28. template<typename T>
    29. 

  29. T radians(T d)
    30. 

  30. {
    31. 

  31.     return d * T(0.01745329251);
    32. 

  32. }
    33. 

  33. 

  34. // Implementation of the GLSL degrees() function
    35. 

  35. template<typename T>
    36. 

  36. T degrees(T r)
    37. 

  37. {
    38. 

  38.     return r * T(57.2957795131);
    39. 

  39. }
    40. 

  40. 

  41. // Implementation of the GLSL findLSB() function
    42. 

  42. template<typename T>
    43. 

  43. T spvFindLSB(T x)
    44. 

  44. {
    45. 

  45.     return select(ctz(x), T(-1), x == T(0));
    46. 

  46. }
    47. 

  47. 

  48. // Implementation of the signed GLSL findMSB() function
    49. 

  49. template<typename T>
    50. 

  50. T spvFindSMSB(T x)
    51. 

  51. {
    52. 

  52.     T v = select(x, T(-1) - x, x < T(0));
    53. 

  53.     return select(clz(T(0)) - (clz(v) + T(1)), T(-1), v == T(0));
    54. 

  54. }
    55. 

  55. 

  56. // Implementation of the unsigned GLSL findMSB() function
    57. 

  57. template<typename T>
    58. 

  58. T spvFindUMSB(T x)
    59. 

  59. {
    60. 

  60.     return select(clz(T(0)) - (clz(x) + T(1)), T(-1), x == T(0));
    61. 

  61. }
    62. 

  62. 

  63. // Implementation of the GLSL sign() function for integer types
    64. 

  64. template<typename T, typename E = typename enable_if<is_integral<T>::value>::type>
    65. 

  65. T sign(T x)
    66. 

  66. {
    67. 

  67.     return select(select(select(x, T(0), x == T(0)), T(1), x > T(0)), T(-1), x < T(0));
    68. 

  68. }
    69. 

  69. 

  70. // Returns the determinant of a 2x2 matrix.
    71. 

  71. inline float spvDet2x2(float a1, float a2, float b1, float b2)
    72. 

  72. {
    73. 

  73.     return a1 * b2 - b1 * a2;
    74. 

  74. }
    75. 

  75. 

  76. // Returns the determinant of a 3x3 matrix.
    77. 

  77. inline float spvDet3x3(float a1, float a2, float a3, float b1, float b2, float b3, float c1, float c2, float c3)
    78. 

  78. {
    79. 

  79.     return a1 * spvDet2x2(b2, b3, c2, c3) - b1 * spvDet2x2(a2, a3, c2, c3) + c1 * spvDet2x2(a2, a3, b2, b3);
    80. 

  80. }
    81. 

  81. 

  82. // Returns the inverse of a matrix, by using the algorithm of calculating the classical
    83. 

  83. // adjoint and dividing by the determinant. The contents of the matrix are changed.
    84. 

  84. float4x4 spvInverse4x4(float4x4 m)
    85. 

  85. {
    86. 

  86.     float4x4 adj;	// The adjoint matrix (inverse after dividing by determinant)
    87. 

  87. 

  88.     // Create the transpose of the cofactors, as the classical adjoint of the matrix.
    89. 

  89.     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]);
    90. 

  90.     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]);
    91. 

  91.     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]);
    92. 

  92.     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]);
    93. 

  93. 

  94.     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]);
    95. 

  95.     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]);
    96. 

  96.     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]);
    97. 

  97.     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]);
    98. 

  98. 

  99.     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]);
    100. 

  100.     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]);
    101. 

  101.     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]);
    102. 

  102.     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]);
    103. 

  103. 

  104.     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]);
    105. 

  105.     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]);
    106. 

  106.     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]);
    107. 

  107.     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]);
    108. 

  108. 

  109.     // Calculate the determinant as a combination of the cofactors of the first row.
    110. 

  110.     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]);
    111. 

  111. 

  112.     // Divide the classical adjoint matrix by the determinant.
    113. 

  113.     // If determinant is zero, matrix is not invertable, so leave it unchanged.
    114. 

  114.     return (det != 0.0f) ? (adj * (1.0f / det)) : m;
    115. 

  115. }
    116. 

  116. 

  117. // Returns the inverse of a matrix, by using the algorithm of calculating the classical
    118. 

  118. // adjoint and dividing by the determinant. The contents of the matrix are changed.
    119. 

  119. float3x3 spvInverse3x3(float3x3 m)
    120. 

  120. {
    121. 

  121.     float3x3 adj;	// The adjoint matrix (inverse after dividing by determinant)
    122. 

  122. 

  123.     // Create the transpose of the cofactors, as the classical adjoint of the matrix.
    124. 

  124.     adj[0][0] =  spvDet2x2(m[1][1], m[1][2], m[2][1], m[2][2]);
    125. 

  125.     adj[0][1] = -spvDet2x2(m[0][1], m[0][2], m[2][1], m[2][2]);
    126. 

  126.     adj[0][2] =  spvDet2x2(m[0][1], m[0][2], m[1][1], m[1][2]);
    127. 

  127. 

  128.     adj[1][0] = -spvDet2x2(m[1][0], m[1][2], m[2][0], m[2][2]);
    129. 

  129.     adj[1][1] =  spvDet2x2(m[0][0], m[0][2], m[2][0], m[2][2]);
    130. 

  130.     adj[1][2] = -spvDet2x2(m[0][0], m[0][2], m[1][0], m[1][2]);
    131. 

  131. 

  132.     adj[2][0] =  spvDet2x2(m[1][0], m[1][1], m[2][0], m[2][1]);
    133. 

  133.     adj[2][1] = -spvDet2x2(m[0][0], m[0][1], m[2][0], m[2][1]);
    134. 

  134.     adj[2][2] =  spvDet2x2(m[0][0], m[0][1], m[1][0], m[1][1]);
    135. 

  135. 

  136.     // Calculate the determinant as a combination of the cofactors of the first row.
    137. 

  137.     float det = (adj[0][0] * m[0][0]) + (adj[0][1] * m[1][0]) + (adj[0][2] * m[2][0]);
    138. 

  138. 

  139.     // Divide the classical adjoint matrix by the determinant.
    140. 

  140.     // If determinant is zero, matrix is not invertable, so leave it unchanged.
    141. 

  141.     return (det != 0.0f) ? (adj * (1.0f / det)) : m;
    142. 

  142. }
    143. 

  143. 

  144. // Returns the inverse of a matrix, by using the algorithm of calculating the classical
    145. 

  145. // adjoint and dividing by the determinant. The contents of the matrix are changed.
    146. 

  146. float2x2 spvInverse2x2(float2x2 m)
    147. 

  147. {
    148. 

  148.     float2x2 adj;	// The adjoint matrix (inverse after dividing by determinant)
    149. 

  149. 

  150.     // Create the transpose of the cofactors, as the classical adjoint of the matrix.
    151. 

  151.     adj[0][0] =  m[1][1];
    152. 

  152.     adj[0][1] = -m[0][1];
    153. 

  153. 

  154.     adj[1][0] = -m[1][0];
    155. 

  155.     adj[1][1] =  m[0][0];
    156. 

  156. 

  157.     // Calculate the determinant as a combination of the cofactors of the first row.
    158. 

  158.     float det = (adj[0][0] * m[0][0]) + (adj[0][1] * m[1][0]);
    159. 

  159. 

  160.     // Divide the classical adjoint matrix by the determinant.
    161. 

  161.     // If determinant is zero, matrix is not invertable, so leave it unchanged.
    162. 

  162.     return (det != 0.0f) ? (adj * (1.0f / det)) : m;
    163. 

  163. }
    164. 

  164. 

  165. template<typename T>
    166. 

  166. inline T spvReflect(T i, T n)
    167. 

  167. {
    168. 

  168.     return i - T(2) * i * n * n;
    169. 

  169. }
    170. 

  170. 

  171. template<typename T>
    172. 

  172. inline T spvRefract(T i, T n, T eta)
    173. 

  173. {
    174. 

  174.     T NoI = n * i;
    175. 

  175.     T NoI2 = NoI * NoI;
    176. 

  176.     T k = T(1) - eta * eta * (T(1) - NoI2);
    177. 

  177.     if (k < T(0))
    178. 

  178.     {
    179. 

  179.         return T(0);
    180. 

  180.     }
    181. 

  181.     else
    182. 

  182.     {
    183. 

  183.         return eta * i - (eta * NoI + sqrt(k)) * n;
    184. 

  184.     }
    185. 

  185. }
    186. 

  186. 

  187. template<typename T>
    188. 

  188. inline T spvFaceForward(T n, T i, T nref)
    189. 

  189. {
    190. 

  190.     return i * nref < T(0) ? n : -n;
    191. 

  191. }
    192. 

  192. 

  193. kernel void main0(device SSBO& _19 [[buffer(0)]])
    194. 

  194. {
    195. 

  195.     _19.res = round(_19.f32.x);
    196. 

  196.     _19.res = rint(_19.f32.x);
    197. 

  197.     _19.res = trunc(_19.f32.x);
    198. 

  198.     _19.res = abs(_19.f32.x);
    199. 

  199.     _19.ires = abs(_19.s32.x);
    200. 

  200.     _19.res = sign(_19.f32.x);
    201. 

  201.     _19.ires = sign(_19.s32.x);
    202. 

  202.     _19.res = floor(_19.f32.x);
    203. 

  203.     _19.res = ceil(_19.f32.x);
    204. 

  204.     _19.res = fract(_19.f32.x);
    205. 

  205.     _19.res = radians(_19.f32.x);
    206. 

  206.     _19.res = degrees(_19.f32.x);
    207. 

  207.     _19.res = sin(_19.f32.x);
    208. 

  208.     _19.res = cos(_19.f32.x);
    209. 

  209.     _19.res = tan(_19.f32.x);
    210. 

  210.     _19.res = asin(_19.f32.x);
    211. 

  211.     _19.res = acos(_19.f32.x);
    212. 

  212.     _19.res = atan(_19.f32.x);
    213. 

  213.     _19.res = sinh(_19.f32.x);
    214. 

  214.     _19.res = cosh(_19.f32.x);
    215. 

  215.     _19.res = tanh(_19.f32.x);
    216. 

  216.     _19.res = asinh(_19.f32.x);
    217. 

  217.     _19.res = acosh(_19.f32.x);
    218. 

  218.     _19.res = atanh(_19.f32.x);
    219. 

  219.     _19.res = atan2(_19.f32.x, _19.f32.y);
    220. 

  220.     _19.res = pow(_19.f32.x, _19.f32.y);
    221. 

  221.     _19.res = exp(_19.f32.x);
    222. 

  222.     _19.res = log(_19.f32.x);
    223. 

  223.     _19.res = exp2(_19.f32.x);
    224. 

  224.     _19.res = log2(_19.f32.x);
    225. 

  225.     _19.res = sqrt(_19.f32.x);
    226. 

  226.     _19.res = rsqrt(_19.f32.x);
    227. 

  227.     _19.res = abs(_19.f32.x);
    228. 

  228.     _19.res = abs(_19.f32.x - _19.f32.y);
    229. 

  229.     _19.res = sign(_19.f32.x);
    230. 

  230.     _19.res = spvFaceForward(_19.f32.x, _19.f32.y, _19.f32.z);
    231. 

  231.     _19.res = spvReflect(_19.f32.x, _19.f32.y);
    232. 

  232.     _19.res = spvRefract(_19.f32.x, _19.f32.y, _19.f32.z);
    233. 

  233.     _19.res = length(_19.f32.xy);
    234. 

  234.     _19.res = distance(_19.f32.xy, _19.f32.zw);
    235. 

  235.     float2 v2 = normalize(_19.f32.xy);
    236. 

  236.     v2 = faceforward(_19.f32.xy, _19.f32.yz, _19.f32.zw);
    237. 

  237.     v2 = reflect(_19.f32.xy, _19.f32.zw);
    238. 

  238.     v2 = refract(_19.f32.xy, _19.f32.yz, _19.f32.w);
    239. 

  239.     float3 v3 = cross(_19.f32.xyz, _19.f32.yzw);
    240. 

  240.     _19.res = determinant(_19.m2);
    241. 

  241.     _19.res = determinant(_19.m3);
    242. 

  242.     _19.res = determinant(_19.m4);
    243. 

  243.     _19.m2 = spvInverse2x2(_19.m2);
    244. 

  244.     _19.m3 = spvInverse3x3(_19.m3);
    245. 

  245.     _19.m4 = spvInverse4x4(_19.m4);
    246. 

  246.     float tmp;
    247. 

  247.     float _287 = modf(_19.f32.x, tmp);
    248. 

  248.     _19.res = _287;
    249. 

  249.     _19.res = fast::min(_19.f32.x, _19.f32.y);
    250. 

  250.     _19.ures = min(_19.u32.x, _19.u32.y);
    251. 

  251.     _19.ires = min(_19.s32.x, _19.s32.y);
    252. 

  252.     _19.res = fast::max(_19.f32.x, _19.f32.y);
    253. 

  253.     _19.ures = max(_19.u32.x, _19.u32.y);
    254. 

  254.     _19.ires = max(_19.s32.x, _19.s32.y);
    255. 

  255.     _19.res = fast::clamp(_19.f32.x, _19.f32.y, _19.f32.z);
    256. 

  256.     _19.ures = clamp(_19.u32.x, _19.u32.y, _19.u32.z);
    257. 

  257.     _19.ires = clamp(_19.s32.x, _19.s32.y, _19.s32.z);
    258. 

  258.     _19.res = mix(_19.f32.x, _19.f32.y, _19.f32.z);
    259. 

  259.     _19.res = step(_19.f32.x, _19.f32.y);
    260. 

  260.     _19.res = smoothstep(_19.f32.x, _19.f32.y, _19.f32.z);
    261. 

  261.     _19.res = fma(_19.f32.x, _19.f32.y, _19.f32.z);
    262. 

  262.     ResType _387;
    263. 

  263.     _387._m0 = frexp(_19.f32.x, _387._m1);
    264. 

  264.     int itmp = _387._m1;
    265. 

  265.     _19.res = _387._m0;
    266. 

  266.     _19.res = ldexp(_19.f32.x, itmp);
    267. 

  267.     _19.ures = pack_float_to_snorm4x8(_19.f32);
    268. 

  268.     _19.ures = pack_float_to_unorm4x8(_19.f32);
    269. 

  269.     _19.ures = pack_float_to_snorm2x16(_19.f32.xy);
    270. 

  270.     _19.ures = pack_float_to_unorm2x16(_19.f32.xy);
    271. 

  271.     _19.ures = as_type<uint>(half2(_19.f32.xy));
    272. 

  272.     v2 = unpack_snorm2x16_to_float(_19.u32.x);
    273. 

  273.     v2 = unpack_unorm2x16_to_float(_19.u32.x);
    274. 

  274.     v2 = float2(as_type<half2>(_19.u32.x));
    275. 

  275.     float4 v4 = unpack_snorm4x8_to_float(_19.u32.x);
    276. 

  276.     v4 = unpack_unorm4x8_to_float(_19.u32.x);
    277. 

  277.     _19.s32 = spvFindLSB(_19.s32);
    278. 

  278.     _19.s32 = int4(spvFindLSB(_19.u32));
    279. 

  279.     _19.s32 = spvFindSMSB(_19.s32);
    280. 

  280.     _19.s32 = int4(spvFindUMSB(_19.u32));
    281. 

  281. }
    282.