Guest User

Pixel shader

a guest
Mar 27th, 2017
819
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #version 400
  2. #extension GL_ARB_texture_gather : enable
  3.  
  4. uniform ivec4 uf_remappedPS[5];
  5. uniform sampler2D textureUnitPS3;
  6. uniform sampler2D textureUnitPS4;
  7. uniform sampler2D textureUnitPS5;
  8. in vec4 passParameter0;
  9. in vec4 passParameter1;
  10. in vec4 passParameter2;
  11. in vec4 passParameter3;
  12. in vec4 passParameter4;
  13. in vec4 passParameter5;
  14. layout(location = 0) out vec4 passPixelColor0;
  15. layout(location = 1) out vec4 passPixelColor1;
  16. layout(location = 3) out vec4 passPixelColor3;
  17. int clampFI32(int v)
  18. {
  19. if( v == 0x7FFFFFFF )
  20.     return floatBitsToInt(1.0);
  21. else if( v == 0xFFFFFFFF )
  22.     return floatBitsToInt(0.0);
  23. return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0));
  24. }
  25. float mul_nonIEEE(float a, float b){ if( a == 0.0 || b == 0.0 ) return 0.0; return a*b; }
  26. void main()
  27. {
  28. vec4 R0f = vec4(0.0);
  29. vec4 R1f = vec4(0.0);
  30. vec4 R2f = vec4(0.0);
  31. vec4 R3f = vec4(0.0);
  32. vec4 R4f = vec4(0.0);
  33. vec4 R5f = vec4(0.0);
  34. vec4 R6f = vec4(0.0);
  35. vec4 R7f = vec4(0.0);
  36. vec4 R122f = vec4(0.0);
  37. vec4 R123f = vec4(0.0);
  38. vec4 R124f = vec4(0.0);
  39. vec4 R125f = vec4(0.0);
  40. vec4 R126f = vec4(0.0);
  41. vec4 R127f = vec4(0.0);
  42. float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f;
  43. vec4 PV0f = vec4(0.0), PV1f = vec4(0.0);
  44. float PS0f = 0.0, PS1f = 0.0;
  45. vec4 tempf = vec4(0.0);
  46. float tempResultf;
  47. int tempResulti;
  48. ivec4 ARi = ivec4(0);
  49. bool predResult = true;
  50. vec3 cubeMapSTM;
  51. int cubeMapFaceId;
  52. R0f = passParameter0;
  53. R1f = passParameter1;
  54. R2f = passParameter2;
  55. R3f = passParameter3;
  56. R4f = passParameter4;
  57. R5f = passParameter5;
  58. R6f.xy = (texture(textureUnitPS4, R0f.xy).xy); // TEX_INST_SAMPLE OffsetXYZ 00 00 00
  59. R7f.xyz = (texture(textureUnitPS5, R0f.xy).xyz); // TEX_INST_SAMPLE OffsetXYZ 00 00 00
  60. R0f.xyz = (texture(textureUnitPS3, R0f.xy).xyz); // TEX_INST_SAMPLE OffsetXYZ 00 00 00
  61. // 0
  62. R127f.x = R1f.x + R3f.x;
  63. PV0f.x = R127f.x;
  64. R127f.y = R1f.y + R3f.y;
  65. PV0f.y = R127f.y;
  66. R127f.z = R1f.z + R3f.z;
  67. PV0f.z = R127f.z;
  68. R126f.w = (R6f.x * intBitsToFloat(0x40008102) + intBitsToFloat(0xbf810204));
  69. PV0f.w = R126f.w;
  70. R126f.y = (R6f.y * intBitsToFloat(0x40008102) + intBitsToFloat(0xbf810204));
  71. PS0f = R126f.y;
  72. // 1
  73. tempf.x = PV0f.x * PV0f.x + PV0f.y * PV0f.y + PV0f.z * PV0f.z + intBitsToFloat(0x80000000) * 0.0;
  74. PV1f.x = tempf.x;
  75. PV1f.y = tempf.x;
  76. PV1f.z = tempf.x;
  77. PV1f.w = tempf.x;
  78. R126f.x = mul_nonIEEE(PV0f.w, PV0f.w);
  79. PS1f = R126f.x;
  80. // 2
  81. tempf.x = R5f.x * R5f.x + R5f.y * R5f.y + R5f.z * R5f.z + intBitsToFloat(0x80000000) * 0.0;
  82. PV0f.x = tempf.x;
  83. PV0f.y = tempf.x;
  84. PV0f.z = tempf.x;
  85. PV0f.w = tempf.x;
  86. tempResultf = 1.0 / sqrt(PV1f.x);
  87. PS0f = tempResultf;
  88. // 3
  89. backupReg0f = R126f.x;
  90. backupReg1f = R127f.y;
  91. R126f.x = mul_nonIEEE(R127f.x, PS0f);
  92. PV1f.x = R126f.x;
  93. R127f.y = (R126f.y * R126f.y + backupReg0f);
  94. R127f.y = clamp(R127f.y, 0.0, 1.0);
  95. PV1f.y = R127f.y;
  96. R124f.z = mul_nonIEEE(R127f.z, PS0f);
  97. PV1f.z = R124f.z;
  98. R125f.w = mul_nonIEEE(backupReg1f, PS0f);
  99. PV1f.w = R125f.w;
  100. PS1f = sqrt(PV0f.x);
  101. // 4
  102. PV0f.x = mul_nonIEEE(R4f.x, PV1f.z);
  103. PV0f.y = mul_nonIEEE(R4f.z, PV1f.w);
  104. R126f.z = mul_nonIEEE(R4f.w, R126f.y);
  105. PV0f.z = R126f.z;
  106. PV0f.w = mul_nonIEEE(R4f.y, PV1f.x);
  107. R127f.w = 1.0 / PS1f;
  108. PS0f = R127f.w;
  109. // 5
  110. R127f.x = (-(R4f.x) * R125f.w + PV0f.w);
  111. PV1f.x = R127f.x;
  112. R126f.y = (-(R4f.z) * R126f.x + PV0f.x);
  113. PV1f.y = R126f.y;
  114. R127f.z = (-(R4f.y) * R124f.z + PV0f.y);
  115. PV1f.z = R127f.z;
  116. R124f.w = mul_nonIEEE(R5f.x, PS0f);
  117. PV1f.w = R124f.w;
  118. R4f.y = mul_nonIEEE(R5f.y, PS0f);
  119. PS1f = R4f.y;
  120. // 6
  121. R124f.x = mul_nonIEEE(R5f.z, R127f.w);
  122. PV0f.x = R124f.x;
  123. PV0f.y = mul_nonIEEE(R125f.w, PV1f.z);
  124. PV0f.z = mul_nonIEEE(R126f.x, PV1f.x);
  125. PV0f.w = mul_nonIEEE(R124f.z, PV1f.y);
  126. R125f.z = -(R127f.y) + 1.0;
  127. PS0f = R125f.z;
  128. // 7
  129. backupReg0f = R127f.z;
  130. R123f.x = (-(R125f.w) * R127f.x + PV0f.w);
  131. PV1f.x = R123f.x;
  132. PV1f.y = mul_nonIEEE(R127f.z, R126f.z);
  133. R127f.z = (-(R126f.x) * R126f.y + PV0f.y);
  134. PV1f.z = R127f.z;
  135. R123f.w = (-(R124f.z) * backupReg0f + PV0f.z);
  136. PV1f.w = R123f.w;
  137. PS1f = mul_nonIEEE(R126f.y, R126f.z);
  138. // 8
  139. backupReg0f = R127f.x;
  140. R127f.x = (R126f.w * PV1f.w + PS1f);
  141. PV0f.x = R127f.x;
  142. R126f.y = (R126f.w * PV1f.x + PV1f.y);
  143. PV0f.y = R126f.y;
  144. PV0f.z = mul_nonIEEE(backupReg0f, R126f.z);
  145. R127f.w = R124f.w + intBitsToFloat(uf_remappedPS[0].x);
  146. PV0f.w = R127f.w;
  147. R127f.y = R4f.y + intBitsToFloat(uf_remappedPS[0].y);
  148. PS0f = R127f.y;
  149. // 9
  150. backupReg0f = R127f.z;
  151. R125f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].z), intBitsToFloat(uf_remappedPS[1].w));
  152. PV1f.x = R125f.x;
  153. R125f.y = 0.0;
  154. PV1f.y = R125f.y;
  155. R127f.z = R124f.x + intBitsToFloat(uf_remappedPS[0].z);
  156. PV1f.z = R127f.z;
  157. R123f.w = (R126f.w * backupReg0f + PV0f.z);
  158. PV1f.w = R123f.w;
  159. PS1f = sqrt(R125f.z);
  160. // 10
  161. backupReg0f = R127f.x;
  162. backupReg1f = R124f.z;
  163. R127f.x = (PS1f * R126f.x + R126f.y);
  164. PV0f.x = R127f.x;
  165. R126f.y = (PS1f * R125f.w + backupReg0f);
  166. PV0f.y = R126f.y;
  167. R124f.z = (PS1f * backupReg1f + PV1f.w);
  168. PV0f.z = R124f.z;
  169. R126f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].x), intBitsToFloat(uf_remappedPS[1].w));
  170. PV0f.w = R126f.w;
  171. R124f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].y), intBitsToFloat(uf_remappedPS[1].w));
  172. PS0f = R124f.y;
  173. // 11
  174. tempf.x = R127f.w * R127f.w + R127f.y * R127f.y + R127f.z * R127f.z + intBitsToFloat(0x80000000) * 0.0;
  175. PV1f.x = tempf.x;
  176. PV1f.y = tempf.x;
  177. PV1f.z = tempf.x;
  178. PV1f.w = tempf.x;
  179. R125f.w = 0.0;
  180. PS1f = R125f.w;
  181. // 12
  182. tempf.x = R127f.x * R127f.x + R126f.y * R126f.y + R124f.z * R124f.z + intBitsToFloat(0x80000000) * 0.0;
  183. PV0f.x = tempf.x;
  184. PV0f.y = tempf.x;
  185. PV0f.z = tempf.x;
  186. PV0f.w = tempf.x;
  187. tempResultf = 1.0 / sqrt(PV1f.x);
  188. PS0f = tempResultf;
  189. // 13
  190. PV1f.x = mul_nonIEEE(R127f.y, PS0f);
  191. PV1f.y = mul_nonIEEE(R127f.w, PS0f);
  192. R125f.z = (R7f.x * intBitsToFloat(0x40008102) + intBitsToFloat(0xbf810204));
  193. PV1f.z = R125f.z;
  194. PV1f.w = mul_nonIEEE(R127f.z, PS0f);
  195. tempResultf = 1.0 / sqrt(PV0f.x);
  196. R127f.w = tempResultf;
  197. PS1f = R127f.w;
  198. // 14
  199. backupReg0f = R127f.x;
  200. backupReg1f = R126f.y;
  201. R127f.x = mul_nonIEEE(PV1f.y, intBitsToFloat(uf_remappedPS[1].w));
  202. PV0f.x = R127f.x;
  203. R126f.y = mul_nonIEEE(PV1f.x, intBitsToFloat(uf_remappedPS[1].w));
  204. PV0f.y = R126f.y;
  205. R127f.z = mul_nonIEEE(PV1f.w, intBitsToFloat(uf_remappedPS[1].w));
  206. PV0f.z = R127f.z;
  207. R4f.w = mul_nonIEEE(backupReg0f, PS1f);
  208. PV0f.w = R4f.w;
  209. R127f.y = mul_nonIEEE(backupReg1f, PS1f);
  210. PS0f = R127f.y;
  211. // 15
  212. backupReg0f = R124f.z;
  213. R126f.x = (R7f.y * intBitsToFloat(0x40008102) + intBitsToFloat(0xbf810204));
  214. PV1f.x = R126f.x;
  215. R1f.y = (PS0f * 0.5 + 0.5);
  216. PV1f.y = R1f.y;
  217. R124f.z = mul_nonIEEE(backupReg0f, R127f.w);
  218. PV1f.z = R124f.z;
  219. R127f.w = (R7f.z * intBitsToFloat(0x40008102) + intBitsToFloat(0xbf810204));
  220. PV1f.w = R127f.w;
  221. R6f.w = intBitsToFloat(0x3f800000);
  222. PS1f = R6f.w;
  223. // 16
  224. backupReg0f = R125f.w;
  225. tempf.x = -(R127f.x) * R4f.w + -(R126f.y) * R127f.y + -(R127f.z) * PV1f.z + -(backupReg0f) * PV1f.z;
  226. PV0f.x = tempf.x;
  227. PV0f.y = tempf.x;
  228. PV0f.z = tempf.x;
  229. PV0f.w = tempf.x;
  230. R125f.w = tempf.x;
  231. R6f.x = intBitsToFloat(0x3ce0e0e1);
  232. PS0f = R6f.x;
  233. // 17
  234. tempf.x = -(R126f.w) * R4f.w + -(R124f.y) * R127f.y + -(R125f.x) * R124f.z + -(R125f.y) * R124f.z;
  235. PV1f.x = tempf.x;
  236. PV1f.y = tempf.x;
  237. PV1f.z = tempf.x;
  238. PV1f.w = tempf.x;
  239. R1f.x = (R4f.w * 0.5 + 0.5);
  240. PS1f = R1f.x;
  241. // 18
  242. PV0f.x = mul_nonIEEE(R124f.x, R125f.x);
  243. PV0f.y = mul_nonIEEE(R124f.x, R124f.z);
  244. R7f.z = mul_nonIEEE(PV1f.x, R125f.w);
  245. PV0f.z = R7f.z;
  246. R3f.w = intBitsToFloat(0x3c008081);
  247. PV0f.w = R3f.w;
  248. R1f.z = (R124f.z * 0.5 + 0.5);
  249. PS0f = R1f.z;
  250. // 19
  251. tempf.x = R124f.w * R126f.w + R4f.y * R124f.y + PV0f.x * 1.0 + intBitsToFloat(0x80000000) * 0.0;
  252. PV1f.x = tempf.x;
  253. PV1f.y = tempf.x;
  254. PV1f.z = tempf.x;
  255. PV1f.w = tempf.x;
  256. R122f.x = (R4f.y * R127f.y + PV0f.y);
  257. PS1f = R122f.x;
  258. // 20
  259. PV0f.x = max(-(PV1f.x), 0.0);
  260. R123f.y = (R124f.w * R4f.w + PS1f);
  261. PV0f.y = R123f.y;
  262. R1f.w = 0.0;
  263. PV0f.w = R1f.w;
  264. // 21
  265. R7f.x = PV0f.y + 1.0;
  266. R7f.x = clamp(R7f.x, 0.0, 1.0);
  267. PV1f.x = R7f.x;
  268. PV1f.y = min(PV0f.x, 1.0);
  269. // 22
  270. R123f.x = (PV1f.x * PV1f.x + R126f.x);
  271. R123f.x = clamp(R123f.x, 0.0, 1.0);
  272. PV0f.x = R123f.x;
  273. R123f.y = (PV1f.x * PV1f.x + R125f.z);
  274. R123f.y = clamp(R123f.y, 0.0, 1.0);
  275. PV0f.y = R123f.y;
  276. PV0f.z = mul_nonIEEE(PV1f.y, PV1f.y);
  277. R123f.w = (PV1f.x * PV1f.x + R127f.w);
  278. R123f.w = clamp(R123f.w, 0.0, 1.0);
  279. PV0f.w = R123f.w;
  280. // 23
  281. R4f.x = mul_nonIEEE(PV0f.w, PV0f.z);
  282. PV1f.x = R4f.x;
  283. R4f.y = mul_nonIEEE(PV0f.x, PV0f.z);
  284. PV1f.y = R4f.y;
  285. R4f.w = mul_nonIEEE(PV0f.y, PV0f.z);
  286. PV1f.w = R4f.w;
  287. // 0
  288. R123f.w = (-(R5f.z) * intBitsToFloat(uf_remappedPS[2].y) + intBitsToFloat(uf_remappedPS[2].z));
  289. R123f.w = clamp(R123f.w, 0.0, 1.0);
  290. PV0f.w = R123f.w;
  291. // 1
  292. R6f.y = intBitsToFloat(uf_remappedPS[3].z);
  293. PV1f.y = R6f.y;
  294. R123f.w = (-(PV0f.w) * R7f.z + R7f.z);
  295. R123f.w = clamp(R123f.w, 0.0, 1.0);
  296. PV1f.w = R123f.w;
  297. // 2
  298. tempResultf = log2(PV1f.w);
  299. if( isinf(tempResultf) == true ) tempResultf = -3.40282347E+38F;
  300. PS0f = tempResultf;
  301. // 3
  302. PV1f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].x), PS0f);
  303. // 4
  304. PS0f = exp2(PV1f.x);
  305. // 5
  306. PV1f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].y), PS0f);
  307. // 6
  308. PV0f.y = mul_nonIEEE(R7f.x, PV1f.w);
  309. // 7
  310. R123f.x = (intBitsToFloat(uf_remappedPS[2].w) * R4f.w + PV0f.y);
  311. PV1f.x = R123f.x;
  312. R123f.z = (intBitsToFloat(uf_remappedPS[2].w) * R4f.y + PV0f.y);
  313. PV1f.z = R123f.z;
  314. R123f.w = (intBitsToFloat(uf_remappedPS[2].w) * R4f.x + PV0f.y);
  315. PV1f.w = R123f.w;
  316. // 8
  317. R123f.x = (R0f.y * PV1f.z + R0f.y);
  318. PV0f.x = R123f.x;
  319. R123f.y = (R0f.x * PV1f.x + R0f.x);
  320. PV0f.y = R123f.y;
  321. R123f.z = (R0f.z * PV1f.w + R0f.z);
  322. PV0f.z = R123f.z;
  323. // 9
  324. R3f.x = mul_nonIEEE(R2f.x, PV0f.y);
  325. PV1f.x = R3f.x;
  326. R3f.y = mul_nonIEEE(R2f.x, PV0f.x);
  327. PV1f.y = R3f.y;
  328. R3f.z = mul_nonIEEE(R2f.x, PV0f.z);
  329. PV1f.z = R3f.z;
  330. // 10
  331. R2f.x = R1f.x;
  332. PV0f.x = R2f.x;
  333. R2f.y = R1f.y;
  334. PV0f.y = R2f.y;
  335. R2f.z = R1f.z;
  336. PV0f.z = R2f.z;
  337. R2f.w = R1f.w;
  338. PV0f.w = R2f.w;
  339. // 11
  340. R1f.x = R3f.x;
  341. PV1f.x = R1f.x;
  342. R1f.y = R3f.y;
  343. PV1f.y = R1f.y;
  344. R1f.z = R3f.z;
  345. PV1f.z = R1f.z;
  346. R1f.w = R3f.w;
  347. PV1f.w = R1f.w;
  348. // 12
  349. R0f.x = R6f.x;
  350. PV0f.x = R0f.x;
  351. R0f.y = R6f.y;
  352. PV0f.y = R0f.y;
  353. R0f.z = R6f.z;
  354. PV0f.z = R0f.z;
  355. R0f.w = R6f.w;
  356. PV0f.w = R0f.w;
  357. // export
  358. passPixelColor0 = vec4(R0f.x, R0f.y, R0f.z, R0f.w);
  359. passPixelColor1 = vec4(R1f.x, R1f.y, R1f.z, R1f.w);
  360. passPixelColor3 = vec4(R2f.x, R2f.y, R2f.z, R2f.w);
  361. }
RAW Paste Data