compositor for 2d shader
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

ASDFPIXELSORT.pde 6.5KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293
  1. class ASDFPIXELSORT extends Shader {
  2. ASDFPIXELSORT() {
  3. name = "fxASDFPixelSort";
  4. params.add(new Param("black", 0, 200, new int[]{SIN, LINE, RAMPUPDOWN, TAN, COS}));
  5. params.add(new Param("white", -20000000, -6000000, new int[]{SIN, LINE, RAMPUPDOWN, TAN, COS}));
  6. params.add(new Param("brightness", -15000000, 2000000, new int[]{SIN, LINE, RAMPUPDOWN, TAN, COS}));
  7. params.add(new Param("mode", 3, new int[]{RANDOM}));
  8. }
  9. /*
  10. float playSpeed = 4;
  11. float inc1, inc2, inc3;
  12. void animate() {
  13. inc1+=playSpeed/400;
  14. inc2+=playSpeed/300;
  15. inc3+=playSpeed/350;
  16. if ((frameCount % int(map(playSpeed, 0, 4, 15, 120))) == 0) {
  17. for (int i = 0; i < params.size(); i++)
  18. params.get(i).randomize();
  19. }
  20. params.get(0).setValue((sin(inc1)+1)/2);
  21. params.get(2).setValue((sin(inc2)+1)/2);
  22. params.get(1).setValue((sin(inc3)+1)/2);
  23. }
  24. */
  25. void apply() {
  26. row = 0;
  27. column = 0;
  28. renderer.beginDraw();
  29. renderer.colorMode(RGB);
  30. colorMode(RGB);
  31. while (column < renderer.width-1) {
  32. renderer.loadPixels();
  33. sortColumn();
  34. column++;
  35. renderer.updatePixels();
  36. }
  37. while (row < renderer.height-1) {
  38. renderer.loadPixels();
  39. sortRow();
  40. row++;
  41. renderer.updatePixels();
  42. }
  43. renderer.endDraw();
  44. }
  45. int row = 0;
  46. int column = 0;
  47. void sortRow() {
  48. int x = 0;
  49. int y = row;
  50. int xend = 0;
  51. while (xend < renderer.width-1) {
  52. switch((int)params.get(3).value) {
  53. case 0:
  54. x = getFirstNotBlackX(x, y);
  55. xend = getNextBlackX(x, y);
  56. break;
  57. case 1:
  58. x = getFirstBrightX(x, y);
  59. xend = getNextDarkX(x, y);
  60. break;
  61. case 2:
  62. x = getFirstNotWhiteX(x, y);
  63. xend = getNextWhiteX(x, y);
  64. break;
  65. default:
  66. break;
  67. }
  68. if (x < 0) break;
  69. int sortLength = xend-x;
  70. color[] unsorted = new color[sortLength];
  71. color[] sorted = new color[sortLength];
  72. for (int i=0; i<sortLength; i++) {
  73. unsorted[i] = renderer.pixels[x + i + y * renderer.width];
  74. }
  75. sorted = sort(unsorted);
  76. for (int i=0; i<sortLength; i++) {
  77. renderer.pixels[x + i + y * renderer.width] = sorted[i];
  78. }
  79. x = xend+1;
  80. }
  81. }
  82. void sortColumn() {
  83. int x = column;
  84. int y = 0;
  85. int yend = 0;
  86. while (yend < renderer.height-1) {
  87. switch((int)params.get(3).value) {
  88. case 0:
  89. y = getFirstNotBlackY(x, y);
  90. yend = getNextBlackY(x, y);
  91. break;
  92. case 1:
  93. y = getFirstBrightY(x, y);
  94. yend = getNextDarkY(x, y);
  95. break;
  96. case 2:
  97. y = getFirstNotWhiteY(x, y);
  98. yend = getNextWhiteY(x, y);
  99. break;
  100. default:
  101. break;
  102. }
  103. if (y < 0) break;
  104. int sortLength = yend-y;
  105. color[] unsorted = new color[sortLength];
  106. color[] sorted = new color[sortLength];
  107. for (int i=0; i<sortLength; i++) {
  108. unsorted[i] = renderer.pixels[x + (y+i) * renderer.width];
  109. }
  110. sorted = sort(unsorted);
  111. for (int i=0; i<sortLength; i++) {
  112. renderer.pixels[x + (y+i) * renderer.width] = sorted[i];
  113. }
  114. y = yend+1;
  115. }
  116. }
  117. //BLACK
  118. int getFirstNotBlackX(int _x, int _y) {
  119. int x = _x;
  120. int y = _y;
  121. color c;
  122. while ( (c = renderer.pixels[x + y * renderer.width]) < params.get(0).value) {
  123. x++;
  124. if (x >= renderer.width) return -1;
  125. }
  126. return x;
  127. }
  128. int getNextBlackX(int _x, int _y) {
  129. int x = _x+1;
  130. int y = _y;
  131. color c;
  132. while ( (c = renderer.pixels[x + y * renderer.width]) > params.get(0).value) {
  133. x++;
  134. if (x >= renderer.width) return renderer.width-1;
  135. }
  136. return x-1;
  137. }
  138. //BRIGHTNESS
  139. int getFirstBrightX(int _x, int _y) {
  140. int x = _x;
  141. int y = _y;
  142. color c;
  143. while (brightness (c = renderer.pixels[x + y * renderer.width]) < params.get(2).value) {
  144. x++;
  145. if (x >= renderer.width) return -1;
  146. }
  147. return x;
  148. }
  149. int getNextDarkX(int _x, int _y) {
  150. int x = _x+1;
  151. int y = _y;
  152. color c;
  153. while (brightness (c = renderer.pixels[x + y * renderer.width]) > params.get(2).value) {
  154. x++;
  155. if (x >= renderer.width) return renderer.width-1;
  156. }
  157. return x-1;
  158. }
  159. //WHITE
  160. int getFirstNotWhiteX(int _x, int _y) {
  161. int x = _x;
  162. int y = _y;
  163. color c;
  164. while ( (c = renderer.pixels[x + y * renderer.width]) > params.get(1).value) {
  165. x++;
  166. if (x >= renderer.width) return -1;
  167. }
  168. return x;
  169. }
  170. int getNextWhiteX(int _x, int _y) {
  171. int x = _x+1;
  172. int y = _y;
  173. color c;
  174. while ( (c = renderer.pixels[x + y * renderer.width]) < params.get(1).value) {
  175. x++;
  176. if (x >= renderer.width) return renderer.width-1;
  177. }
  178. return x-1;
  179. }
  180. //BLACK
  181. int getFirstNotBlackY(int _x, int _y) {
  182. int x = _x;
  183. int y = _y;
  184. color c;
  185. if (y < renderer.height) {
  186. while ( (c = renderer.pixels[x + y * renderer.width]) < params.get(0).value) {
  187. y++;
  188. if (y >= renderer.height) return -1;
  189. }
  190. }
  191. return y;
  192. }
  193. int getNextBlackY(int _x, int _y) {
  194. int x = _x;
  195. int y = _y+1;
  196. color c;
  197. if (y < renderer.height) {
  198. while ( (c = renderer.pixels[x + y * renderer.width]) > params.get(0).value) {
  199. y++;
  200. if (y >= renderer.height) return renderer.height-1;
  201. }
  202. }
  203. return y-1;
  204. }
  205. //BRIGHTNESS
  206. int getFirstBrightY(int _x, int _y) {
  207. int x = _x;
  208. int y = _y;
  209. color c;
  210. if (y < renderer.height) {
  211. while (brightness (c = renderer.pixels[x + y * renderer.width]) < params.get(2).value) {
  212. y++;
  213. if (y >= renderer.height) return -1;
  214. }
  215. }
  216. return y;
  217. }
  218. int getNextDarkY(int _x, int _y) {
  219. int x = _x;
  220. int y = _y+1;
  221. color c;
  222. if (y < renderer.height) {
  223. while (brightness (c = renderer.pixels[x + y * renderer.width]) > params.get(2).value) {
  224. y++;
  225. if (y >= renderer.height) return renderer.height-1;
  226. }
  227. }
  228. return y-1;
  229. }
  230. //WHITE
  231. int getFirstNotWhiteY(int _x, int _y) {
  232. int x = _x;
  233. int y = _y;
  234. color c;
  235. if (y < renderer.height) {
  236. while ( (c = renderer.pixels[x + y * renderer.width]) > params.get(2).value) {
  237. y++;
  238. if (y >= renderer.height) return -1;
  239. }
  240. }
  241. return y;
  242. }
  243. int getNextWhiteY(int _x, int _y) {
  244. int x = _x;
  245. int y = _y+1;
  246. color c;
  247. if (y < renderer.height) {
  248. while ( (c = renderer.pixels[x + y * renderer.width]) < params.get(1).value) {
  249. y++;
  250. if (y >= renderer.height) return renderer.height-1;
  251. }
  252. }
  253. return y-1;
  254. }
  255. }