API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jul 17th, 2019
109
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 34.42 KB | None | 0 0
raw download clone embed print report
  1. #version 450 core
  2.  
  3. layout( local_size_x = 1, local_size_y = 1, local_size_z = 1 ) in;
  4.  
  5. layout(binding = 0) uniform sampler2D texBind0;
  6. layout(binding = 1) uniform sampler2D texBind1;
  7. layout(binding = 2) uniform sampler2D texBind2;
  8. layout(binding = 3) uniform sampler2D texBind3;
  9. layout(binding = 4) uniform sampler2D texBind4;
  10. layout(binding = 5) uniform sampler2D texBind5;
  11. layout(binding = 6) uniform sampler2D texBind6;
  12. layout(binding = 7) uniform sampler2D texBind7;
  13. layout(binding = 8) uniform sampler2D texBind8;
  14. layout(binding = 9) uniform sampler2D texBind9;
  15.  
  16. vec4 sampleNodeLod0(int i, vec2 uv){
  17. if(i == 0) return textureLod(texBind0 , uv, 0).rgba;
  18. if(i == 1) return textureLod(texBind1 , uv, 0).rgba;
  19. if(i == 2) return textureLod(texBind2 , uv, 0).rgba;
  20. if(i == 3) return textureLod(texBind3 , uv, 0).rgba;
  21. if(i == 4) return textureLod(texBind4 , uv, 0).rgba;
  22. if(i == 5) return textureLod(texBind5 , uv, 0).rgba;
  23. if(i == 6) return textureLod(texBind6 , uv, 0).rgba;
  24. if(i == 7) return textureLod(texBind7 , uv, 0).rgba;
  25. if(i == 8) return textureLod(texBind8 , uv, 0).rgba;
  26. if(i == 9) return textureLod(texBind9 , uv, 0).rgba;
  27. }
  28.  
  29. layout (std430, binding = 0) coherent buffer SharedMemoryIntBuffer
  30. {
  31. int SharedMemoryInt[];
  32. };
  33. layout (std430, binding = 1) coherent buffer SharedMemoryFloatBuffer
  34. {
  35. float SharedMemoryFloat[];
  36. };
  37. layout (std430, binding = 2) coherent buffer SharedMemoryVec2Buffer
  38. {
  39. vec2 SharedMemoryVec2[];
  40. };
  41. layout (std430, binding = 3) coherent buffer SharedMemoryVec3Buffer
  42. {
  43. vec3 SharedMemoryVec3[];
  44. };
  45. layout (std430, binding = 4) coherent buffer SharedMemoryVec4Buffer
  46. {
  47. vec4 SharedMemoryVec4[];
  48. };
  49.  
  50. #define MASM_DIRECTIVE_STORE_INT -1
  51. #define MASM_DIRECTIVE_STORE_FLOAT 104
  52. #define MASM_DIRECTIVE_STORE_VEC2 1
  53. #define MASM_DIRECTIVE_STORE_VEC3 2
  54. #define MASM_DIRECTIVE_STORE_VEC4 3
  55. #define MASM_DIRECTIVE_LOAD_INT 4
  56. #define MASM_DIRECTIVE_LOAD_FLOAT 5
  57. #define MASM_DIRECTIVE_LOAD_VEC2 6
  58. #define MASM_DIRECTIVE_LOAD_VEC3 7
  59. #define MASM_DIRECTIVE_LOAD_VEC4 8
  60. #define MASM_DIRECTIVE_REGMOV_INT 93
  61. #define MASM_DIRECTIVE_REGMOV_FLOAT 9
  62. #define MASM_DIRECTIVE_REGMOV_VEC2 10
  63. #define MASM_DIRECTIVE_REGMOV_VEC3 11
  64. #define MASM_DIRECTIVE_REGMOV_VEC4 12
  65.  
  66. #define MASM_DIRECTIVE_TEXTURE_R 13
  67. #define MASM_DIRECTIVE_TEXTURE_G 14
  68. #define MASM_DIRECTIVE_TEXTURE_B 15
  69. #define MASM_DIRECTIVE_TEXTURE_A 16
  70.  
  71. #define MASM_DIRECTIVE_TEXTURE_RG 17
  72. #define MASM_DIRECTIVE_TEXTURE_GB 18
  73. #define MASM_DIRECTIVE_TEXTURE_BA 19
  74.  
  75. #define MASM_DIRECTIVE_TEXTURE_RGB 20
  76. #define MASM_DIRECTIVE_TEXTURE_GBA 21
  77.  
  78. #define MASM_DIRECTIVE_TEXTURE_RGBA 22
  79.  
  80. #define MASM_DIRECTIVE_MIX_FLOAT_FLOAT 23
  81. #define MASM_DIRECTIVE_MIX_VEC2_FLOAT 24
  82. #define MASM_DIRECTIVE_MIX_VEC3_FLOAT 25
  83. #define MASM_DIRECTIVE_MIX_VEC4_FLOAT 26
  84. #define MASM_DIRECTIVE_POW_FLOAT_FLOAT 27
  85. #define MASM_DIRECTIVE_POW_VEC2_FLOAT 28
  86. #define MASM_DIRECTIVE_POW_VEC3_FLOAT 29
  87. #define MASM_DIRECTIVE_POW_VEC4_FLOAT 30
  88.  
  89. #define MASM_DIRECTIVE_JUMP_ABSOLUTE 31
  90. #define MASM_DIRECTIVE_JUMP_RELATIVE 32 // cool
  91.  
  92. #define MASM_DIRECTIVE_LONG_JUMP_ABSOLUTE 105
  93. #define MASM_DIRECTIVE_LONG_JUMP_RELATIVE 106 // cool
  94.  
  95. #define MASM_DIRECTIVE_LONG_JUMP_BACK 33 // and i thought recursiveness wouldnt be possible
  96.  
  97. #define MASM_DIRECTIVE_JUMP_IF_EQUAL_INT 34
  98. #define MASM_DIRECTIVE_JUMP_IF_EQUAL_FLOAT 35
  99. #define MASM_DIRECTIVE_JUMP_IF_EQUAL_VEC2 36
  100. #define MASM_DIRECTIVE_JUMP_IF_EQUAL_VEC3 37
  101. #define MASM_DIRECTIVE_JUMP_IF_EQUAL_VEC4 38
  102.  
  103. #define MASM_DIRECTIVE_JUMP_IF_NOT_EQUAL_INT 39
  104. #define MASM_DIRECTIVE_JUMP_IF_NOT_EQUAL_FLOAT 40
  105. #define MASM_DIRECTIVE_JUMP_IF_NOT_EQUAL_VEC2 41
  106. #define MASM_DIRECTIVE_JUMP_IF_NOT_EQUAL_VEC3 42
  107. #define MASM_DIRECTIVE_JUMP_IF_NOT_EQUAL_VEC4 43
  108.  
  109. #define MASM_DIRECTIVE_JUMP_IF_HIGHER_INT 44
  110. #define MASM_DIRECTIVE_JUMP_IF_HIGHER_FLOAT 45
  111. #define MASM_DIRECTIVE_JUMP_IF_HIGHER_VEC2 46
  112. #define MASM_DIRECTIVE_JUMP_IF_HIGHER_VEC3 47
  113. #define MASM_DIRECTIVE_JUMP_IF_HIGHER_VEC4 48
  114.  
  115. #define MASM_DIRECTIVE_JUMP_IF_LOWER_INT 49
  116. #define MASM_DIRECTIVE_JUMP_IF_LOWER_FLOAT 50
  117. #define MASM_DIRECTIVE_JUMP_IF_LOWER_VEC2 51
  118. #define MASM_DIRECTIVE_JUMP_IF_LOWER_VEC3 52
  119. #define MASM_DIRECTIVE_JUMP_IF_LOWER_VEC4 53
  120.  
  121. #define MASM_DIRECTIVE_INC_INT 54
  122. #define MASM_DIRECTIVE_DEC_INT 55
  123.  
  124. #define MASM_DIRECTIVE_ADD_INT 56
  125. #define MASM_DIRECTIVE_ADD_FLOAT 57
  126. #define MASM_DIRECTIVE_ADD_VEC2 58
  127. #define MASM_DIRECTIVE_ADD_VEC2_FLOAT 59
  128. #define MASM_DIRECTIVE_ADD_VEC3 60
  129. #define MASM_DIRECTIVE_ADD_VEC3_FLOAT 61
  130. #define MASM_DIRECTIVE_ADD_VEC4 62
  131. #define MASM_DIRECTIVE_ADD_VEC4_FLOAT 63
  132.  
  133. #define MASM_DIRECTIVE_SUB_INT 64
  134. #define MASM_DIRECTIVE_SUB_FLOAT 65
  135. #define MASM_DIRECTIVE_SUB_VEC2 66
  136. #define MASM_DIRECTIVE_SUB_VEC2_FLOAT 67
  137. #define MASM_DIRECTIVE_SUB_VEC3 68
  138. #define MASM_DIRECTIVE_SUB_VEC3_FLOAT 69
  139. #define MASM_DIRECTIVE_SUB_VEC4 70
  140. #define MASM_DIRECTIVE_SUB_VEC4_FLOAT 71
  141.  
  142. #define MASM_DIRECTIVE_MUL_INT 72
  143. #define MASM_DIRECTIVE_MUL_FLOAT 73
  144. #define MASM_DIRECTIVE_MUL_VEC2 74
  145. #define MASM_DIRECTIVE_MUL_VEC2_FLOAT 75
  146. #define MASM_DIRECTIVE_MUL_VEC3 76
  147. #define MASM_DIRECTIVE_MUL_VEC3_FLOAT 77
  148. #define MASM_DIRECTIVE_MUL_VEC4 78
  149. #define MASM_DIRECTIVE_MUL_VEC4_FLOAT 79
  150.  
  151. #define MASM_DIRECTIVE_DIV_INT 80
  152. #define MASM_DIRECTIVE_DIV_FLOAT 81
  153. #define MASM_DIRECTIVE_DIV_VEC2 82
  154. #define MASM_DIRECTIVE_DIV_VEC2_FLOAT 83
  155. #define MASM_DIRECTIVE_DIV_VEC3 84
  156. #define MASM_DIRECTIVE_DIV_VEC3_FLOAT 85
  157. #define MASM_DIRECTIVE_DIV_VEC4 86
  158. #define MASM_DIRECTIVE_DIV_VEC4_FLOAT 87
  159.  
  160. #define MASM_DIRECTIVE_MOV_INVOCATION_ID 88
  161.  
  162. #define MASM_DIRECTIVE_CAST_INT_FLOAT 89
  163. #define MASM_DIRECTIVE_CAST_FLOAT_INT 90
  164. #define MASM_DIRECTIVE_CAST_FLOAT_VEC2 91
  165. #define MASM_DIRECTIVE_CAST_FLOAT_VEC3 92
  166. #define MASM_DIRECTIVE_CAST_FLOAT_VEC4 94 // one reserved for missing REGMOV_INT
  167.  
  168. #define MASM_DIRECTIVE_LOAD_BY_POINTER_INT 95
  169. #define MASM_DIRECTIVE_LOAD_BY_POINTER_FLOAT 96
  170. #define MASM_DIRECTIVE_LOAD_BY_POINTER_VEC2 97
  171. #define MASM_DIRECTIVE_LOAD_BY_POINTER_VEC3 98
  172. #define MASM_DIRECTIVE_LOAD_BY_POINTER_VEC4 99
  173.  
  174. #define MASM_DIRECTIVE_STORE_BY_POINTER_INT 100
  175. #define MASM_DIRECTIVE_STORE_BY_POINTER_FLOAT 101
  176. #define MASM_DIRECTIVE_STORE_BY_POINTER_VEC2 102
  177. #define MASM_DIRECTIVE_STORE_BY_POINTER_VEC3 103
  178. #define MASM_DIRECTIVE_STORE_BY_POINTER_VEC4 107
  179.  
  180. #define MASM_DIRECTIVE_HALT 0
  181.  
  182. #define MASM_JUMP_STACK_SIZE 16
  183. #define MASM_OUTPUT_CHUNK_SIZE 4
  184. #define MASM_REGISTER_CHUNK_SIZE 32
  185.  
  186. #define MAX_PROGRAM_LENGTH 2048
  187.  
  188. #define MASM_MAX_TEXTURES 10
  189.  
  190. uniform vec2 TexturesScales[MASM_MAX_TEXTURES];
  191. uniform int TexturesCount;
  192.  
  193. struct MaterialObject{
  194. vec3 diffuseColor;
  195. vec3 normal;
  196. };
  197.  
  198. void main(){
  199. int i = 0;
  200.  
  201. int memory_int[MASM_REGISTER_CHUNK_SIZE];
  202. float memory_float[MASM_REGISTER_CHUNK_SIZE];
  203. vec2 memory_vec2[MASM_REGISTER_CHUNK_SIZE];
  204. vec3 memory_vec3[MASM_REGISTER_CHUNK_SIZE];
  205. vec4 memory_vec4[MASM_REGISTER_CHUNK_SIZE];
  206.  
  207. float output_float[MASM_OUTPUT_CHUNK_SIZE];
  208. vec3 output_vec3[MASM_OUTPUT_CHUNK_SIZE];
  209. vec4 output_vec4[MASM_OUTPUT_CHUNK_SIZE];
  210.  
  211. int jump_stack[MASM_JUMP_STACK_SIZE];
  212. int jump_stack_pointer = 0;
  213.  
  214. int target = 0;
  215. int source = 0;
  216. int temp1 = 0;
  217. int temp2 = 0;
  218. int temp3 = 0;
  219. while(true){
  220. int c = SharedMemoryInt[i++];
  221. switch(c){
  222. //################################################################//
  223. case MASM_DIRECTIVE_STORE_INT:
  224. target = SharedMemoryInt[i++];
  225. source = SharedMemoryInt[i++];
  226. SharedMemoryInt[target] = memory_int[source];
  227. break;
  228. case MASM_DIRECTIVE_STORE_FLOAT:
  229. target = SharedMemoryInt[i++];
  230. source = SharedMemoryInt[i++];
  231. SharedMemoryFloat[target] = memory_float[source];
  232. break;
  233. case MASM_DIRECTIVE_STORE_VEC2:
  234. target = SharedMemoryInt[i++];
  235. source = SharedMemoryInt[i++];
  236. SharedMemoryVec2[target] = memory_vec2[source];
  237. break;
  238. case MASM_DIRECTIVE_STORE_VEC3:
  239. target = SharedMemoryInt[i++];
  240. source = SharedMemoryInt[i++];
  241. SharedMemoryVec3[target] = memory_vec3[source];
  242. break;
  243. case MASM_DIRECTIVE_STORE_VEC4:
  244. target = SharedMemoryInt[i++];
  245. source = SharedMemoryInt[i++];
  246. SharedMemoryVec4[target] = memory_vec4[source];
  247. break;
  248. //################################################################//
  249. case MASM_DIRECTIVE_LOAD_INT:
  250. target = SharedMemoryInt[i++];
  251. source = SharedMemoryInt[i++];
  252. memory_int[target] = SharedMemoryInt[source];
  253. break;
  254. case MASM_DIRECTIVE_LOAD_FLOAT:
  255. target = SharedMemoryInt[i++];
  256. source = SharedMemoryInt[i++];
  257. memory_float[target] = SharedMemoryFloat[source];
  258. break;
  259. case MASM_DIRECTIVE_LOAD_VEC2:
  260. target = SharedMemoryInt[i++];
  261. source = SharedMemoryInt[i++];
  262. memory_vec2[target] = SharedMemoryVec2[source];
  263. break;
  264. case MASM_DIRECTIVE_LOAD_VEC3:
  265. target = SharedMemoryInt[i++];
  266. source = SharedMemoryInt[i++];
  267. memory_vec3[target] = SharedMemoryVec3[source];
  268. break;
  269. case MASM_DIRECTIVE_LOAD_VEC4:
  270. target = SharedMemoryInt[i++];
  271. source = SharedMemoryInt[i++];
  272. memory_vec4[target] = SharedMemoryVec4[source];
  273. break;
  274. //################################################################//
  275. case MASM_DIRECTIVE_REGMOV_INT:
  276. target = SharedMemoryInt[i++];
  277. source = SharedMemoryInt[i++];
  278. memory_int[target] = memory_int[source];
  279. break;
  280. case MASM_DIRECTIVE_REGMOV_FLOAT:
  281. target = SharedMemoryInt[i++];
  282. source = SharedMemoryInt[i++];
  283. memory_float[target] = memory_float[source];
  284. break;
  285. case MASM_DIRECTIVE_REGMOV_VEC2:
  286. target = SharedMemoryInt[i++];
  287. source = SharedMemoryInt[i++];
  288. memory_vec2[target] = memory_vec2[source];
  289. break;
  290. case MASM_DIRECTIVE_REGMOV_VEC3:
  291. target = SharedMemoryInt[i++];
  292. source = SharedMemoryInt[i++];
  293. memory_vec3[target] = memory_vec3[source];
  294. break;
  295. case MASM_DIRECTIVE_REGMOV_VEC4:
  296. target = SharedMemoryInt[i++];
  297. source = SharedMemoryInt[i++];
  298. memory_vec4[target] = memory_vec4[source];
  299. break;
  300. //################################################################//
  301. case MASM_DIRECTIVE_TEXTURE_R:
  302. target = SharedMemoryInt[i++];
  303. source = SharedMemoryInt[i++];
  304. temp1 = SharedMemoryInt[i++];
  305. memory_float[target] = sampleNodeLod0(source, memory_vec2[temp1]).r;
  306. break;
  307. case MASM_DIRECTIVE_TEXTURE_G:
  308. target = SharedMemoryInt[i++];
  309. source = SharedMemoryInt[i++];
  310. temp1 = SharedMemoryInt[i++];
  311. memory_float[target] = sampleNodeLod0(source, memory_vec2[temp1]).g;
  312. break;
  313. case MASM_DIRECTIVE_TEXTURE_B:
  314. target = SharedMemoryInt[i++];
  315. source = SharedMemoryInt[i++];
  316. temp1 = SharedMemoryInt[i++];
  317. memory_float[target] = sampleNodeLod0(source, memory_vec2[temp1]).b;
  318. break;
  319. case MASM_DIRECTIVE_TEXTURE_A:
  320. target = SharedMemoryInt[i++];
  321. source = SharedMemoryInt[i++];
  322. temp1 = SharedMemoryInt[i++];
  323. memory_float[target] = sampleNodeLod0(source, memory_vec2[temp1]).a;
  324. break;
  325. ////////////
  326. case MASM_DIRECTIVE_TEXTURE_RG:
  327. target = SharedMemoryInt[i++];
  328. source = SharedMemoryInt[i++];
  329. temp1 = SharedMemoryInt[i++];
  330. memory_vec2[target] = sampleNodeLod0(source, memory_vec2[temp1]).rg;
  331. break;
  332. case MASM_DIRECTIVE_TEXTURE_GB:
  333. target = SharedMemoryInt[i++];
  334. source = SharedMemoryInt[i++];
  335. temp1 = SharedMemoryInt[i++];
  336. memory_vec2[target] = sampleNodeLod0(source, memory_vec2[temp1]).gb;
  337. break;
  338. case MASM_DIRECTIVE_TEXTURE_BA:
  339. target = SharedMemoryInt[i++];
  340. source = SharedMemoryInt[i++];
  341. temp1 = SharedMemoryInt[i++];
  342. memory_vec2[target] = sampleNodeLod0(source, memory_vec2[temp1]).ba;
  343. break;
  344. ////////////
  345. case MASM_DIRECTIVE_TEXTURE_RGB:
  346. target = SharedMemoryInt[i++];
  347. source = SharedMemoryInt[i++];
  348. temp1 = SharedMemoryInt[i++];
  349. memory_vec3[target] = sampleNodeLod0(source, memory_vec2[temp1]).rgb;
  350. break;
  351. case MASM_DIRECTIVE_TEXTURE_GBA:
  352. target = SharedMemoryInt[i++];
  353. source = SharedMemoryInt[i++];
  354. temp1 = SharedMemoryInt[i++];
  355. memory_vec3[target] = sampleNodeLod0(source, memory_vec2[temp1]).gba;
  356. break;
  357. ////////////
  358. case MASM_DIRECTIVE_TEXTURE_RGBA:
  359. target = SharedMemoryInt[i++];
  360. source = SharedMemoryInt[i++];
  361. temp1 = SharedMemoryInt[i++];
  362. memory_vec4[target] = sampleNodeLod0(source, memory_vec2[temp1]).rgba;
  363. break;
  364. //################################################################//
  365. case MASM_DIRECTIVE_MIX_FLOAT_FLOAT:
  366. target = SharedMemoryInt[i++];
  367. temp1 = SharedMemoryInt[i++];
  368. temp2 = SharedMemoryInt[i++];
  369. temp3 = SharedMemoryInt[i++];
  370. memory_float[target] = mix(memory_float[temp1], memory_float[temp2], memory_float[temp3]);
  371. break;
  372. case MASM_DIRECTIVE_MIX_VEC2_FLOAT:
  373. target = SharedMemoryInt[i++];
  374. temp1 = SharedMemoryInt[i++];
  375. temp2 = SharedMemoryInt[i++];
  376. temp3 = SharedMemoryInt[i++];
  377. memory_vec2[target] = mix(memory_vec2[temp1], memory_vec2[temp2], memory_float[temp3]);
  378. break;
  379. case MASM_DIRECTIVE_MIX_VEC3_FLOAT:
  380. target = SharedMemoryInt[i++];
  381. temp1 = SharedMemoryInt[i++];
  382. temp2 = SharedMemoryInt[i++];
  383. temp3 = SharedMemoryInt[i++];
  384. memory_vec3[target] = mix(memory_vec3[temp1], memory_vec3[temp2], memory_float[temp3]);
  385. break;
  386. case MASM_DIRECTIVE_MIX_VEC4_FLOAT:
  387. target = SharedMemoryInt[i++];
  388. temp1 = SharedMemoryInt[i++];
  389. temp2 = SharedMemoryInt[i++];
  390. temp3 = SharedMemoryInt[i++];
  391. memory_vec4[target] = mix(memory_vec4[temp1], memory_vec4[temp2], memory_float[temp3]);
  392. break;
  393. //################################################################//
  394. case MASM_DIRECTIVE_POW_FLOAT_FLOAT:
  395. target = SharedMemoryInt[i++];
  396. temp1 = SharedMemoryInt[i++];
  397. temp2 = SharedMemoryInt[i++];
  398. memory_float[target] = pow(memory_float[temp1], memory_float[temp2]);
  399. break;
  400. case MASM_DIRECTIVE_POW_VEC2_FLOAT:
  401. target = SharedMemoryInt[i++];
  402. temp1 = SharedMemoryInt[i++];
  403. temp2 = SharedMemoryInt[i++];
  404. memory_vec2[target] = pow(memory_vec2[temp1], vec2(memory_float[temp2]));
  405. break;
  406. case MASM_DIRECTIVE_POW_VEC3_FLOAT:
  407. target = SharedMemoryInt[i++];
  408. temp1 = SharedMemoryInt[i++];
  409. temp2 = SharedMemoryInt[i++];
  410. memory_vec3[target] = pow(memory_vec3[temp1], vec3(memory_float[temp2]));
  411. break;
  412. case MASM_DIRECTIVE_POW_VEC4_FLOAT:
  413. target = SharedMemoryInt[i++];
  414. temp1 = SharedMemoryInt[i++];
  415. temp2 = SharedMemoryInt[i++];
  416. memory_vec4[target] = pow(memory_vec4[temp1], vec4(memory_float[temp2]));
  417. break;
  418. //################################################################//
  419. case MASM_DIRECTIVE_JUMP_ABSOLUTE:
  420. temp1 = SharedMemoryInt[i++]; // raw address into the assembly
  421. i = temp1;
  422. break;
  423. case MASM_DIRECTIVE_JUMP_RELATIVE:
  424. temp1 = SharedMemoryInt[i++];
  425. i += temp1;
  426. break;
  427. case MASM_DIRECTIVE_LONG_JUMP_ABSOLUTE:
  428. temp1 = SharedMemoryInt[i++];
  429. jump_stack[jump_stack_pointer++] = i;
  430. i = temp1;
  431. break;
  432. case MASM_DIRECTIVE_LONG_JUMP_RELATIVE:
  433. temp1 = SharedMemoryInt[i++];
  434. jump_stack[jump_stack_pointer++] = i;
  435. i += temp1;
  436. break;
  437. case MASM_DIRECTIVE_LONG_JUMP_BACK:
  438. i = jump_stack[--jump_stack_pointer]; // beautiful!
  439. break;
  440. //################################################################//
  441. case MASM_DIRECTIVE_JUMP_IF_EQUAL_INT:
  442. temp1 = SharedMemoryInt[i++];
  443. temp2 = SharedMemoryInt[i++];
  444. if(!(memory_int[temp1] == memory_int[temp2])) i++;// skips next instruction, jump for example
  445. break;
  446. case MASM_DIRECTIVE_JUMP_IF_EQUAL_FLOAT:
  447. temp1 = SharedMemoryInt[i++];
  448. temp2 = SharedMemoryInt[i++];
  449. if(!(memory_float[temp1] == memory_float[temp2])) i++;
  450. break;
  451. case MASM_DIRECTIVE_JUMP_IF_EQUAL_VEC2:
  452. temp1 = SharedMemoryInt[i++];
  453. temp2 = SharedMemoryInt[i++];
  454. if(!(memory_vec2[temp1] == memory_vec2[temp2])) i++;
  455. break;
  456. case MASM_DIRECTIVE_JUMP_IF_EQUAL_VEC3:
  457. temp1 = SharedMemoryInt[i++];
  458. temp2 = SharedMemoryInt[i++];
  459. if(!(memory_vec3[temp1] == memory_vec3[temp2])) i++;
  460. break;
  461. case MASM_DIRECTIVE_JUMP_IF_EQUAL_VEC4:
  462. temp1 = SharedMemoryInt[i++];
  463. temp2 = SharedMemoryInt[i++];
  464. if(!(memory_vec4[temp1] == memory_vec4[temp2])) i++;
  465. break;
  466. /////////////
  467. case MASM_DIRECTIVE_JUMP_IF_NOT_EQUAL_INT:
  468. temp1 = SharedMemoryInt[i++];
  469. temp2 = SharedMemoryInt[i++];
  470. if(!(memory_int[temp1] != memory_int[temp2])) i++;
  471. break;
  472. case MASM_DIRECTIVE_JUMP_IF_NOT_EQUAL_FLOAT:
  473. temp1 = SharedMemoryInt[i++];
  474. temp2 = SharedMemoryInt[i++];
  475. if(!(memory_float[temp1] != memory_float[temp2])) i++;
  476. break;
  477. case MASM_DIRECTIVE_JUMP_IF_NOT_EQUAL_VEC2:
  478. temp1 = SharedMemoryInt[i++];
  479. temp2 = SharedMemoryInt[i++];
  480. if(!(memory_vec2[temp1] != memory_vec2[temp2])) i++;
  481. break;
  482. case MASM_DIRECTIVE_JUMP_IF_NOT_EQUAL_VEC3:
  483. temp1 = SharedMemoryInt[i++];
  484. temp2 = SharedMemoryInt[i++];
  485. if(!(memory_vec3[temp1] != memory_vec3[temp2])) i++;
  486. break;
  487. case MASM_DIRECTIVE_JUMP_IF_NOT_EQUAL_VEC4:
  488. temp1 = SharedMemoryInt[i++];
  489. temp2 = SharedMemoryInt[i++];
  490. if(!(memory_vec4[temp1] != memory_vec4[temp2])) i++;
  491. break;
  492. /////////////
  493. case MASM_DIRECTIVE_JUMP_IF_HIGHER_INT:
  494. temp1 = SharedMemoryInt[i++];
  495. temp2 = SharedMemoryInt[i++];
  496. if(!(memory_int[temp1] > memory_int[temp2])) i++;
  497. break;
  498. case MASM_DIRECTIVE_JUMP_IF_HIGHER_FLOAT:
  499. temp1 = SharedMemoryInt[i++];
  500. temp2 = SharedMemoryInt[i++];
  501. if(!(memory_float[temp1] > memory_float[temp2])) i++;
  502. break;
  503. case MASM_DIRECTIVE_JUMP_IF_HIGHER_VEC2:
  504. temp1 = SharedMemoryInt[i++];
  505. temp2 = SharedMemoryInt[i++];
  506. if(!(length(memory_vec2[temp1]) > length(memory_vec2[temp2]))) i++;
  507. break;
  508. case MASM_DIRECTIVE_JUMP_IF_HIGHER_VEC3:
  509. temp1 = SharedMemoryInt[i++];
  510. temp2 = SharedMemoryInt[i++];
  511. if(!(length(memory_vec3[temp1]) > length(memory_vec3[temp2]))) i++;
  512. break;
  513. case MASM_DIRECTIVE_JUMP_IF_HIGHER_VEC4:
  514. temp1 = SharedMemoryInt[i++];
  515. temp2 = SharedMemoryInt[i++];
  516. if(!(length(memory_vec4[temp1]) > length(memory_vec4[temp2]))) i++;
  517. break;
  518. /////////////
  519. case MASM_DIRECTIVE_JUMP_IF_LOWER_INT:
  520. temp1 = SharedMemoryInt[i++];
  521. temp2 = SharedMemoryInt[i++];
  522. if(!(memory_int[temp1] < memory_int[temp2])) i++;
  523. break;
  524. case MASM_DIRECTIVE_JUMP_IF_LOWER_FLOAT:
  525. temp1 = SharedMemoryInt[i++];
  526. temp2 = SharedMemoryInt[i++];
  527. if(!(memory_float[temp1] < memory_float[temp2])) i++;
  528. break;
  529. case MASM_DIRECTIVE_JUMP_IF_LOWER_VEC2:
  530. temp1 = SharedMemoryInt[i++];
  531. temp2 = SharedMemoryInt[i++];
  532. if(!(length(memory_vec2[temp1]) < length(memory_vec2[temp2]))) i++;
  533. break;
  534. case MASM_DIRECTIVE_JUMP_IF_LOWER_VEC3:
  535. temp1 = SharedMemoryInt[i++];
  536. temp2 = SharedMemoryInt[i++];
  537. if(!(length(memory_vec3[temp1]) < length(memory_vec3[temp2]))) i++;
  538. break;
  539. case MASM_DIRECTIVE_JUMP_IF_LOWER_VEC4:
  540. temp1 = SharedMemoryInt[i++];
  541. temp2 = SharedMemoryInt[i++];
  542. if(!(length(memory_vec4[temp1]) < length(memory_vec4[temp2]))) i++;
  543. break;
  544. //################################################################//
  545. case MASM_DIRECTIVE_INC_INT:
  546. target = SharedMemoryInt[i++];
  547. memory_int[target]++;
  548. break;
  549. case MASM_DIRECTIVE_DEC_INT:
  550. target = SharedMemoryInt[i++];
  551. memory_int[target]--;
  552. break;
  553. //################################################################//
  554. case MASM_DIRECTIVE_ADD_INT:
  555. target = SharedMemoryInt[i++];
  556. source = SharedMemoryInt[i++];
  557. memory_int[target] += memory_int[source];
  558. break;
  559. case MASM_DIRECTIVE_ADD_FLOAT:
  560. target = SharedMemoryInt[i++];
  561. source = SharedMemoryInt[i++];
  562. memory_float[target] += memory_float[source];
  563. break;
  564. case MASM_DIRECTIVE_ADD_VEC2:
  565. target = SharedMemoryInt[i++];
  566. source = SharedMemoryInt[i++];
  567. memory_vec2[target] += memory_vec2[source];
  568. break;
  569. case MASM_DIRECTIVE_ADD_VEC2_FLOAT:
  570. target = SharedMemoryInt[i++];
  571. source = SharedMemoryInt[i++];
  572. memory_vec2[target] += memory_float[source];
  573. break;
  574. case MASM_DIRECTIVE_ADD_VEC3:
  575. target = SharedMemoryInt[i++];
  576. source = SharedMemoryInt[i++];
  577. memory_vec3[target] += memory_vec3[source];
  578. break;
  579. case MASM_DIRECTIVE_ADD_VEC3_FLOAT:
  580. target = SharedMemoryInt[i++];
  581. source = SharedMemoryInt[i++];
  582. memory_vec3[target] += memory_float[source];
  583. break;
  584. case MASM_DIRECTIVE_ADD_VEC4:
  585. target = SharedMemoryInt[i++];
  586. source = SharedMemoryInt[i++];
  587. memory_vec4[target] += memory_vec4[source];
  588. break;
  589. case MASM_DIRECTIVE_ADD_VEC4_FLOAT:
  590. target = SharedMemoryInt[i++];
  591. source = SharedMemoryInt[i++];
  592. memory_vec4[target] += memory_float[source];
  593. break;
  594. //################################################################//
  595. case MASM_DIRECTIVE_SUB_INT:
  596. target = SharedMemoryInt[i++];
  597. source = SharedMemoryInt[i++];
  598. memory_int[target] -= memory_int[source];
  599. break;
  600. case MASM_DIRECTIVE_SUB_FLOAT:
  601. target = SharedMemoryInt[i++];
  602. source = SharedMemoryInt[i++];
  603. memory_float[target] -= memory_float[source];
  604. break;
  605. case MASM_DIRECTIVE_SUB_VEC2:
  606. target = SharedMemoryInt[i++];
  607. source = SharedMemoryInt[i++];
  608. memory_vec2[target] -= memory_vec2[source];
  609. break;
  610. case MASM_DIRECTIVE_SUB_VEC2_FLOAT:
  611. target = SharedMemoryInt[i++];
  612. source = SharedMemoryInt[i++];
  613. memory_vec2[target] -= memory_float[source];
  614. break;
  615. case MASM_DIRECTIVE_SUB_VEC3:
  616. target = SharedMemoryInt[i++];
  617. source = SharedMemoryInt[i++];
  618. memory_vec3[target] -= memory_vec3[source];
  619. break;
  620. case MASM_DIRECTIVE_SUB_VEC3_FLOAT:
  621. target = SharedMemoryInt[i++];
  622. source = SharedMemoryInt[i++];
  623. memory_vec3[target] -= memory_float[source];
  624. break;
  625. case MASM_DIRECTIVE_SUB_VEC4:
  626. target = SharedMemoryInt[i++];
  627. source = SharedMemoryInt[i++];
  628. memory_vec4[target] -= memory_vec4[source];
  629. break;
  630. case MASM_DIRECTIVE_SUB_VEC4_FLOAT:
  631. target = SharedMemoryInt[i++];
  632. source = SharedMemoryInt[i++];
  633. memory_vec4[target] -= memory_float[source];
  634. break;
  635. //################################################################//
  636. case MASM_DIRECTIVE_MUL_INT:
  637. target = SharedMemoryInt[i++];
  638. source = SharedMemoryInt[i++];
  639. memory_int[target] *= memory_int[source];
  640. break;
  641. case MASM_DIRECTIVE_MUL_FLOAT:
  642. target = SharedMemoryInt[i++];
  643. source = SharedMemoryInt[i++];
  644. memory_float[target] *= memory_float[source];
  645. break;
  646. case MASM_DIRECTIVE_MUL_VEC2:
  647. target = SharedMemoryInt[i++];
  648. source = SharedMemoryInt[i++];
  649. memory_vec2[target] *= memory_vec2[source];
  650. break;
  651. case MASM_DIRECTIVE_MUL_VEC2_FLOAT:
  652. target = SharedMemoryInt[i++];
  653. source = SharedMemoryInt[i++];
  654. memory_vec2[target] *= memory_float[source];
  655. break;
  656. case MASM_DIRECTIVE_MUL_VEC3:
  657. target = SharedMemoryInt[i++];
  658. source = SharedMemoryInt[i++];
  659. memory_vec3[target] *= memory_vec3[source];
  660. break;
  661. case MASM_DIRECTIVE_MUL_VEC3_FLOAT:
  662. target = SharedMemoryInt[i++];
  663. source = SharedMemoryInt[i++];
  664. memory_vec3[target] *= memory_float[source];
  665. break;
  666. case MASM_DIRECTIVE_MUL_VEC4:
  667. target = SharedMemoryInt[i++];
  668. source = SharedMemoryInt[i++];
  669. memory_vec4[target] *= memory_vec4[source];
  670. break;
  671. case MASM_DIRECTIVE_MUL_VEC4_FLOAT:
  672. target = SharedMemoryInt[i++];
  673. source = SharedMemoryInt[i++];
  674. memory_vec4[target] *= memory_float[source];
  675. break;
  676. //################################################################//
  677. case MASM_DIRECTIVE_DIV_INT:
  678. target = SharedMemoryInt[i++];
  679. source = SharedMemoryInt[i++];
  680. memory_int[target] /= memory_int[source];
  681. break;
  682. case MASM_DIRECTIVE_DIV_FLOAT:
  683. target = SharedMemoryInt[i++];
  684. source = SharedMemoryInt[i++];
  685. memory_float[target] /= memory_float[source];
  686. break;
  687. case MASM_DIRECTIVE_DIV_VEC2:
  688. target = SharedMemoryInt[i++];
  689. source = SharedMemoryInt[i++];
  690. memory_vec2[target] /= memory_vec2[source];
  691. break;
  692. case MASM_DIRECTIVE_DIV_VEC2_FLOAT:
  693. target = SharedMemoryInt[i++];
  694. source = SharedMemoryInt[i++];
  695. memory_vec2[target] /= memory_float[source];
  696. break;
  697. case MASM_DIRECTIVE_DIV_VEC3:
  698. target = SharedMemoryInt[i++];
  699. source = SharedMemoryInt[i++];
  700. memory_vec3[target] /= memory_vec3[source];
  701. break;
  702. case MASM_DIRECTIVE_DIV_VEC3_FLOAT:
  703. target = SharedMemoryInt[i++];
  704. source = SharedMemoryInt[i++];
  705. memory_vec3[target] /= memory_float[source];
  706. break;
  707. case MASM_DIRECTIVE_DIV_VEC4:
  708. target = SharedMemoryInt[i++];
  709. source = SharedMemoryInt[i++];
  710. memory_vec4[target] /= memory_vec4[source];
  711. break;
  712. case MASM_DIRECTIVE_DIV_VEC4_FLOAT:
  713. target = SharedMemoryInt[i++];
  714. source = SharedMemoryInt[i++];
  715. memory_vec4[target] /= memory_float[source];
  716. break;
  717. //################################################################//
  718. case MASM_DIRECTIVE_MOV_INVOCATION_ID:
  719. target = SharedMemoryInt[i++];
  720. memory_int[target] = int(gl_GlobalInvocationID);
  721. break;
  722. //################################################################//
  723. case MASM_DIRECTIVE_CAST_INT_FLOAT:
  724. target = SharedMemoryInt[i++];
  725. source = SharedMemoryInt[i++];
  726. memory_float[target] = float(memory_int[source]);
  727. break;
  728. case MASM_DIRECTIVE_CAST_FLOAT_INT:
  729. target = SharedMemoryInt[i++];
  730. source = SharedMemoryInt[i++];
  731. memory_int[target] = int(memory_float[source]);
  732. break;
  733. case MASM_DIRECTIVE_CAST_FLOAT_VEC2:
  734. target = SharedMemoryInt[i++];
  735. source = SharedMemoryInt[i++];
  736. memory_vec2[target] = vec2(memory_float[source]);
  737. break;
  738. case MASM_DIRECTIVE_CAST_FLOAT_VEC3:
  739. target = SharedMemoryInt[i++];
  740. source = SharedMemoryInt[i++];
  741. memory_vec3[target] = vec3(memory_float[source]);
  742. break;
  743. case MASM_DIRECTIVE_CAST_FLOAT_VEC4:
  744. target = SharedMemoryInt[i++];
  745. source = SharedMemoryInt[i++];
  746. memory_vec4[target] = vec4(memory_float[source]);
  747. break;
  748. //################################################################//
  749. case MASM_DIRECTIVE_LOAD_BY_POINTER_INT:
  750. target = SharedMemoryInt[i++];
  751. source = SharedMemoryInt[i++];
  752. memory_int[target] = SharedMemoryInt[memory_int[source]];
  753. break;
  754. case MASM_DIRECTIVE_LOAD_BY_POINTER_FLOAT:
  755. target = SharedMemoryInt[i++];
  756. source = SharedMemoryInt[i++];
  757. memory_float[target] = SharedMemoryFloat[memory_int[source]];
  758. break;
  759. case MASM_DIRECTIVE_LOAD_BY_POINTER_VEC2:
  760. target = SharedMemoryInt[i++];
  761. source = SharedMemoryInt[i++];
  762. memory_vec2[target] = SharedMemoryVec2[memory_int[source]];
  763. break;
  764. case MASM_DIRECTIVE_LOAD_BY_POINTER_VEC3:
  765. target = SharedMemoryInt[i++];
  766. source = SharedMemoryInt[i++];
  767. memory_vec3[target] = SharedMemoryVec3[memory_int[source]];
  768. break;
  769. case MASM_DIRECTIVE_LOAD_BY_POINTER_VEC4:
  770. target = SharedMemoryInt[i++];
  771. source = SharedMemoryInt[i++];
  772. memory_vec4[target] = SharedMemoryVec4[memory_int[source]];
  773. break;
  774. //################################################################//
  775. case MASM_DIRECTIVE_STORE_BY_POINTER_INT:
  776. target = SharedMemoryInt[i++];
  777. source = SharedMemoryInt[i++];
  778. SharedMemoryInt[memory_int[target]] = memory_int[source];
  779. break;
  780. case MASM_DIRECTIVE_STORE_BY_POINTER_FLOAT:
  781. target = SharedMemoryInt[i++];
  782. source = SharedMemoryInt[i++];
  783. SharedMemoryFloat[memory_int[target]] = memory_float[source];
  784. break;
  785. case MASM_DIRECTIVE_STORE_BY_POINTER_VEC2:
  786. target = SharedMemoryInt[i++];
  787. source = SharedMemoryInt[i++];
  788. SharedMemoryVec2[memory_int[target]] = memory_vec2[source];
  789. break;
  790. case MASM_DIRECTIVE_STORE_BY_POINTER_VEC3:
  791. target = SharedMemoryInt[i++];
  792. source = SharedMemoryInt[i++];
  793. SharedMemoryVec3[memory_int[target]] = memory_vec3[source];
  794. break;
  795. case MASM_DIRECTIVE_STORE_BY_POINTER_VEC4:
  796. target = SharedMemoryInt[i++];
  797. source = SharedMemoryInt[i++];
  798. SharedMemoryVec4[memory_int[target]] = memory_vec4[source];
  799. break;
  800. //################################################################//
  801. case MASM_DIRECTIVE_HALT:
  802. barrier();
  803. memoryBarrier();
  804. return;
  805. break;
  806. }
  807. }
  808. barrier();
  809. memoryBarrier();
  810. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!