SHARE
TWEET

Untitled

a guest Jul 17th, 2019 68 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  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. }
RAW Paste Data
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
 
Top