VCVRack
/
Rack
mirror of https://github.com/VCVRack/Rack.git
1
0
Fork 0
Code Issues 0 Releases 43 Wiki Activity
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.
1270 Commits
4 Branches
541MB
Tree: 635c994a6c
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '635c994a6c'
${ noResults }
Rack/plugins/community/repos/SubmarineFree/src/AO1.cpp

450 lines
19KB
Raw Blame History 

  1. #include "SubmarineFree.hpp"

  2. 

  3. namespace rack_plugin_SubmarineFree {

  4. 

  5. namespace SubmarineAO {

  6. 

  7. 	typedef float (*func_t)(float, float, float);

  8. 

  9. 	struct Functor {

  10. 		std::string name;

  11. 		func_t func;

  12. 	};

  13. 

  14. #define sMIN(a,b) (((a)>(b))?(b):(a))

  15. #define sMAX(a,b) (((a)>(b))?(a):(b))

  16. 

  17. #define LAMBDA(e) [](float x, float y, float c)->float { return e ; }

  18. #define X "X"			// X

  19. #define Y "Y"			// Y

  20. #define C "C"			// C

  21. #define A "+"			// Addition symbol

  22. #define S "-"			// Subtraction symbol

  23. #define O "%"			// Modulo symbol

  24. #define OP "("			// Open Parenthesis

  25. #define CP ")"			// Close Parenthesis

  26. #define P "|"			// Pipe symbol

  27. #define M "\xe2\xa8\xaf"	

  28. #define D "\xc3\xb7"		// Division symbol

  29. #define R "\xe2\x88\x9a"	// Root symbol

  30. #define S2 "\xc2\xb2"		// Superscript 2

  31. #define S3 "\xc2\xb3"		// Superscript 3

  32. #define s0 "\xe2\x82\x80"	// Subscript 0

  33. #define s1 "\xe2\x82\x81"	// Subscript 1

  34. #define s2 "\xe2\x82\x82"	// Subscript 2

  35. #define E "\xe2\x84\xaf"	// e

  36. #define SA "\xe2\x81\xba"	// Superscript +

  37. #define SX "\xcb\xa3"		// Superscript x

  38. #define SY "\xca\xb8"		// Superscript y

  39. #define SC "\xe1\xb6\x9c"	// Superscript c

  40. #define MIN "min"		// Minimum function

  41. #define MAX "max"		// Maximum function

  42. #define COMMA ","		// Comma symbol

  43. #define SIN "sin"		// sine function

  44. #define COS "cos"		// cosine function

  45. #define TAN "tan"		// tangent function

  46. #define ASIN "asin"		// arcsine function

  47. #define ACOS "acos"		// arcosine function

  48. #define ATAN "atan"		// arctangent function

  49. #define LOG "log"		// log function

  50. #define LOG2 LOG s2		// base-2 log function

  51. #define LOG10 LOG s1 s0		// base-10 log function

  52. #define IF "if "		// if conditional

  53. #define G ">"			// Greater Than symbol

  54. #define L "<"			// Less Than symbol

  55. #define Q "="			// Equality symbol

  56. #define Z "0"			// Zero

  57. #define W "1"			// One

  58. #define T "\xe2\x86\xa3"	// Right arrow

  59. #define H "/"			// Slash

  60. #define Pi "\xcf\x80"		// PI

  61. #define TAU "\xcf\x84"		// TAU

  62. 

  63. 	std::vector<Functor> functions {

  64. 		{ "",                      LAMBDA(  0                      ) }, // Passthrough

  65. 		{ C,                       LAMBDA(  c                      ) }, // Addition 

  66. 		{ X A C,                   LAMBDA(  x + c                  ) },

  67. 		{ Y A C,                   LAMBDA(  y + c                  ) },

  68. 		{ X A Y A C,               LAMBDA(  x + y + c              ) },

  69. 		{ C S X,                   LAMBDA(  c - x                  ) }, // Subtraction

  70. 		{ C S Y,                   LAMBDA(  c - y                  ) },

  71. 		{ X S OP Y A C CP,         LAMBDA(  x - ( y + c )          ) },

  72. 		{ OP X A C CP S Y,         LAMBDA(  ( x + c ) - y          ) },

  73. 		{ Y S OP X A C CP,         LAMBDA(  y - ( x + c )          ) },

  74. 		{ OP Y A C CP S X,         LAMBDA(  ( y + c ) - x          ) },

  75. 		{ OP X M Y CP A C,         LAMBDA(  ( x * y ) + c          ) }, // Multiplication

  76. 		{ OP X A C CP M Y,         LAMBDA(  ( x + c ) * y          ) },

  77. 		{ X M OP Y A C CP,         LAMBDA(  x * ( y + c )          ) },

  78. 		{ X M C,                   LAMBDA(  x * c                  ) },

  79. 		{ Y M C,                   LAMBDA(  y * c                  ) },

  80. 		{ X M Y M C,               LAMBDA(  x * y * c              ) },

  81. 		{ Pi M OP X A C CP,	   LAMBDA(  M_PI * ( x + c )	   ) },

  82. 		{ Pi M OP Y A C CP,	   LAMBDA(  M_PI * ( y + c )	   ) },

  83. 		{ TAU M OP X A C CP,	   LAMBDA(  2 * M_PI * ( x + c )   ) },

  84. 		{ TAU M OP Y A C CP,	   LAMBDA(  2 * M_PI * ( y + c )   ) },

  85. 		{ X D C,                   LAMBDA(  x / c                  ) }, // Division

  86. 		{ C D X,                   LAMBDA(  c / x                  ) },

  87. 		{ Y D C,                   LAMBDA(  y / c                  ) },

  88. 		{ C D Y,                   LAMBDA(  c / y                  ) },

  89. 		{ C A OP X D Y CP,         LAMBDA(  c + ( x / y )          ) },

  90. 		{ C A OP Y D X CP,         LAMBDA(  c + ( y / x )          ) },

  91. 		{ X A OP Y D C CP,	   LAMBDA(  x + ( y / c )	   ) },	

  92. 		{ X A OP C D Y CP,	   LAMBDA(  x + ( c / y ) 	   ) },

  93.  		{ Y A OP X D C CP,	   LAMBDA(  y + ( x / c )	   ) },

  94. 		{ Y A OP C D X CP,	   LAMBDA(  y + ( c / x ) 	   ) },

  95. 		{ OP X A C CP D Y,         LAMBDA(  ( x + c ) / y          ) },

  96. 		{ X D OP Y A C CP,         LAMBDA(  x / ( y + c )          ) },

  97. 		{ OP Y A C CP D X,         LAMBDA(  ( y + c ) / x          ) },

  98. 		{ Y D OP X A C CP,         LAMBDA(  y / ( x + c )          ) },

  99. 		{ OP X A C CP O Y,	   LAMBDA(  fmodf( x + c , y )	   ) }, // Modulo

  100. 		{ OP Y A C CP O X,	   LAMBDA(  fmodf( y + c , x )	   ) },

  101. 		{ X O OP Y A C CP,	   LAMBDA(  fmodf( x , y + c )	   ) },

  102. 		{ Y O OP X A C CP,	   LAMBDA(  fmodf( y , x + c)	   ) },

  103. 		{ X O C,		   LAMBDA(  fmodf( x , c )	   ) },

  104. 		{ Y O C,		   LAMBDA(  fmodf( y , c )  	   ) },

  105. 		{ X S2 A C,                LAMBDA(  x * x + c              ) }, // Quadratic

  106. 		{ Y S2 A C,                LAMBDA(  y * y + c              ) },

  107. 		{ OP X A C CP S2,          LAMBDA(  ( x + c ) * ( x + c )  ) },

  108. 		{ OP Y A C CP S2,          LAMBDA(  ( y + c ) * ( y + c )  ) },

  109. 		{ X S2 A Y A C,            LAMBDA(  x * x + y + c          ) },

  110. 		{ Y S2 A X A C,            LAMBDA(  y * y + x + c          ) },

  111. 		{ X S2 A C Y,              LAMBDA(  x * x + c * y          ) },

  112. 		{ Y S2 A C X,              LAMBDA(  y * y + c * x          ) },

  113. 		{ R OP X A C CP,           LAMBDA(  sqrt( x + c )          ) }, // Square Root

  114. 		{ R OP Y A C CP,           LAMBDA(  sqrt( y + c )          ) },

  115. 		{ C SX,			   LAMBDA(  powf( c , x )	   ) }, // Powers

  116. 		{ C SY,			   LAMBDA(  powf( c , y )	   ) },

  117. 		{ C SX SA SY,		   LAMBDA(  powf( c , x + y ) 	   ) },

  118. 		{ C SX SY,		   LAMBDA(  powf( c , x * y )	   ) },

  119. 		{ X SC,			   LAMBDA(  powf( x , c ) 	   ) },

  120. 		{ Y SC,			   LAMBDA(  powf( y , c )	   ) },

  121. 		{ X SY SA SC, 		   LAMBDA(  powf( x , y + c )	   ) },

  122. 		{ Y SX SA SC,		   LAMBDA(  powf( y , x + c )	   ) },

  123. 		{ X SC SY,		   LAMBDA(  powf( x , c * y )	   ) },

  124. 		{ Y SC SX,		   LAMBDA(  powf( y , c * x )	   ) },

  125.                 { P X A C P,               LAMBDA(  abs( x + c )           ) }, // Modulus

  126. 		{ P Y A C P,               LAMBDA(  abs( y + c )           ) },

  127. 		{ MIN OP X A C COMMA Y CP, LAMBDA(  sMIN( x + c, y )   ) }, // Minmax

  128. 		{ MIN OP X COMMA C CP,     LAMBDA(  sMIN( x, c )       ) },

  129.       		{ MIN OP Y COMMA C CP,     LAMBDA(  sMIN( y, c )       ) },

  130.      		{ MAX OP X A C COMMA Y CP, LAMBDA(  sMAX( x + c, y )   ) },

  131. 		{ MAX OP X COMMA C CP,     LAMBDA(  sMAX( x, c )       ) },

  132. 		{ MAX OP Y COMMA C CP,     LAMBDA(  sMAX( y, c )       ) },

  133. 		{ SIN OP X A C CP,         LAMBDA(  sin( x + c )           ) }, // Trigonometric

  134. 		{ SIN OP Y A C CP,         LAMBDA(  sin( y + c )           ) },

  135. 		{ SIN OP X A Y CP,         LAMBDA(  sin( x + y )           ) },

  136.  		{ SIN OP C X CP,           LAMBDA(  sin( c * x )           ) },

  137. 		{ SIN OP C Y CP,           LAMBDA(  sin( c * y )           ) },

  138. 		{ SIN OP X Y CP,           LAMBDA(  sin( x * y )           ) },

  139. 		{ COS OP X A C CP,         LAMBDA(  cos( x + c )           ) },

  140. 		{ COS OP Y A C CP,         LAMBDA(  cos( y + c )           ) },

  141. 		{ COS OP X A Y CP,         LAMBDA(  cos( x + y )           ) },

  142.  		{ COS OP C X CP,           LAMBDA(  cos( c * x )           ) },

  143. 		{ COS OP C Y CP,           LAMBDA(  cos( c * y )           ) },

  144. 		{ COS OP X Y CP,           LAMBDA(  cos( x * y )           ) },

  145. 		{ TAN OP X A C CP,         LAMBDA(  tan( x + c )           ) },

  146. 		{ TAN OP Y A C CP,         LAMBDA(  tan( y + c )           ) },

  147. 		{ TAN OP X A Y CP,         LAMBDA(  tan( x + y )           ) },

  148.  		{ TAN OP C X CP,           LAMBDA(  tan( c * x )           ) },

  149. 		{ TAN OP C Y CP,           LAMBDA(  tan( c * y )           ) },

  150. 		{ TAN OP X Y CP,           LAMBDA(  tan( x * y )           ) },

  151. 		{ ASIN OP X A C CP,        LAMBDA(  asin( x + c )          ) },

  152. 		{ ASIN OP Y A C CP,        LAMBDA(  asin( y + c )          ) },

  153. 		{ ASIN OP X A Y CP,        LAMBDA(  asin( x + y )          ) },

  154.  		{ ASIN OP C X CP,          LAMBDA(  asin( c * x )          ) },

  155. 		{ ASIN OP C Y CP,          LAMBDA(  asin( c * y )          ) },

  156. 		{ ASIN OP X Y CP,          LAMBDA(  asin( x * y )          ) },

  157. 		{ ACOS OP X A C CP,        LAMBDA(  acos( x + c )          ) },

  158. 		{ ACOS OP Y A C CP,        LAMBDA(  acos( y + c )          ) },

  159. 		{ ACOS OP X A Y CP,        LAMBDA(  acos( x + y )          ) },

  160.  		{ ACOS OP C X CP,          LAMBDA(  acos( c * x )          ) },

  161. 		{ ACOS OP C Y CP,          LAMBDA(  acos( c * y )          ) },

  162. 		{ ACOS OP X Y CP,          LAMBDA(  acos( x * y )          ) },

  163. 		{ ATAN OP X A C CP,        LAMBDA(  atan( x + c )          ) },

  164. 		{ ATAN OP Y A C CP,        LAMBDA(  atan( y + c )          ) },

  165. 		{ ATAN OP X A Y CP,        LAMBDA(  atan( x + y )          ) },

  166.  		{ ATAN OP C X CP,          LAMBDA(  atan( c * x )          ) },

  167. 		{ ATAN OP C Y CP,          LAMBDA(  atan( c * y )          ) },

  168. 		{ ATAN OP X Y CP,          LAMBDA(  atan( x * y )          ) },

  169. 		{ LOG OP X A C CP,         LAMBDA(  log( x + c )           ) }, // Logarithmic

  170. 		{ LOG OP Y A C CP,         LAMBDA(  log( y + c )           ) },

  171. 		{ LOG2 OP X A C CP,        LAMBDA(  log2( x + c )          ) },

  172. 		{ LOG2 OP Y A C CP,        LAMBDA(  log2( y + c )          ) },

  173. 		{ LOG10 OP X A C CP,       LAMBDA(  log10( x + c )         ) },

  174. 		{ LOG10 OP Y A C CP,       LAMBDA(  log10( y + c )         ) },

  175. 		{ E SX SA SC,              LAMBDA(  exp( x + c )           ) }, // Exponential

  176. 		{ E SY SA SC,              LAMBDA(  exp( y + c )           ) },

  177. 		{ E SC SX,                 LAMBDA(  exp( c * x )           ) },

  178. 		{ E SC SY,                 LAMBDA(  exp( c * y )           ) },

  179. 		{ "2" SX SA SC,            LAMBDA(  powf( 2, x + c )       ) },

  180. 		{ "2" SY SA SC,            LAMBDA(  powf( 2, y + c )       ) },

  181. 		{ "2" SC SX,               LAMBDA(  powf( 2, c * x )       ) },

  182. 		{ "2" SC SY,               LAMBDA(  powf( 2, c * y )       ) },

  183. 		{ "10" SX SA SC,           LAMBDA(  powf( 10, x + c )      ) },

  184. 		{ "10" SY SA SC,           LAMBDA(  powf( 10, y + c )      ) },

  185. 		{ "10" SC SX,              LAMBDA(  powf( 10, c * x )      ) },

  186. 		{ "10" SC SY,              LAMBDA(  powf( 10, c * y )      ) },

  187. 

  188. 		{ IF X G Z T Y H C,	   LAMBDA(  (x > 0) ? y : c	   ) }, // Conditional

  189. 		{ IF X L Z T Y H C,	   LAMBDA(  (x < 0) ? y : c	   ) },

  190. 		{ IF X Q Z T Y H C,	   LAMBDA(  (x == 0) ? y : c	   ) },

  191. 		{ IF X G Z T C H Y,	   LAMBDA(  (x > 0) ? c : y	   ) },

  192. 		{ IF X L Z T C H Y,	   LAMBDA(  (x < 0) ? c : y	   ) },

  193. 		{ IF X Q Z T C H Y,	   LAMBDA(  (x == 0) ? c : y	   ) },

  194. 		{ IF X G Z T W H Z,	   LAMBDA(  (x > 0) ? 1 : 0	   ) },

  195. 		{ IF X L Z T W H Z,	   LAMBDA(  (x < 0) ? 1 : 0	   ) },

  196. 		{ IF X Q Z T W H Z,	   LAMBDA(  (x == 0) ? 1 : 0	   ) },

  197. 		{ IF X G Z T X H C,	   LAMBDA(  (x > 0) ? x : c	   ) },

  198. 		{ IF X L Z T X H C,	   LAMBDA(  (x < 0) ? x : c	   ) },

  199. 		{ IF X Q Z T X H C,	   LAMBDA(  (x == 0) ? x : c	   ) },

  200. 		{ IF X G Z T C H X,	   LAMBDA(  (x > 0) ? c : x	   ) },

  201. 		{ IF X L Z T C H X,	   LAMBDA(  (x < 0) ? c : x	   ) },

  202. 		{ IF X Q Z T C H X,	   LAMBDA(  (x == 0) ? c : x	   ) },

  203. 

  204. 		{ IF Y G Z T X H C,	   LAMBDA(  (y > 0) ? x : c	   ) },

  205. 		{ IF Y L Z T X H C,	   LAMBDA(  (y < 0) ? x : c	   ) },

  206. 		{ IF Y Q Z T X H C,	   LAMBDA(  (y == 0) ? x : c	   ) },

  207. 		{ IF Y G Z T C H X,	   LAMBDA(  (y > 0) ? c : x	   ) },

  208. 		{ IF Y L Z T C H X,	   LAMBDA(  (y < 0) ? c : x	   ) },

  209. 		{ IF Y Q Z T C H X,	   LAMBDA(  (y == 0) ? c : x	   ) },

  210. 		{ IF Y G Z T W H Z,	   LAMBDA(  (y > 0) ? 1 : 0	   ) },

  211. 		{ IF Y L Z T W H Z,	   LAMBDA(  (y < 0) ? 1 : 0	   ) },

  212. 		{ IF Y Q Z T W H Z,	   LAMBDA(  (y == 0) ? 1 : 0	   ) },

  213. 		{ IF Y G Z T Y H C,	   LAMBDA(  (y > 0) ? y : c	   ) },

  214. 		{ IF Y L Z T Y H C,	   LAMBDA(  (y < 0) ? y : c	   ) },

  215. 		{ IF Y Q Z T Y H C,	   LAMBDA(  (y == 0) ? y : c	   ) },

  216. 		{ IF Y G Z T C H Y,	   LAMBDA(  (y > 0) ? c : y	   ) },

  217. 		{ IF Y L Z T C H Y,	   LAMBDA(  (y < 0) ? c : y	   ) },

  218. 		{ IF Y Q Z T C H Y,	   LAMBDA(  (y == 0) ? c : y	   ) },

  219. 

  220. 		{ IF X G Y T C H Z,	   LAMBDA(  (x > y) ? c : 0	   ) },

  221. 		{ IF X L Y T C H Z,        LAMBDA(  (x < y) ? c : 0	   ) },

  222. 		{ IF X Q Y T C H Z,	   LAMBDA(  (x == y) ? c : 0	   ) },

  223. 		{ IF Y G X T C H Z,	   LAMBDA(  (y > x) ? c : 0	   ) },

  224. 		{ IF Y L X T C H Z,        LAMBDA(  (y < x) ? c : 0	   ) },

  225. 		{ IF X G Y T X H Z,	   LAMBDA(  (x > y) ? x : 0	   ) },

  226. 		{ IF X L Y T X H Z,        LAMBDA(  (x < y) ? x : 0	   ) },

  227. 		{ IF X Q Y T X H Z,	   LAMBDA(  (x == y) ? x : 0	   ) },

  228. 		{ IF Y G X T X H Z,	   LAMBDA(  (y > x) ? x : 0	   ) },

  229. 		{ IF Y L X T X H Z,        LAMBDA(  (y < x) ? x : 0	   ) },

  230. 		{ IF X G Y T Y H Z,	   LAMBDA(  (x > y) ? y : 0	   ) },

  231. 		{ IF X L Y T Y H Z,        LAMBDA(  (x < y) ? y : 0	   ) },

  232. 		{ IF X Q Y T Y H Z,	   LAMBDA(  (x == y) ? y : 0	   ) },

  233. 		{ IF Y G X T Y H Z,	   LAMBDA(  (y > x) ? y : 0	   ) },

  234. 		{ IF Y L X T Y H Z,        LAMBDA(  (y < x) ? y : 0	   ) },

  235. 

  236. 		{ IF X G C T Y H Z,	   LAMBDA(  (x > c) ? y : 0	   ) },

  237. 		{ IF X L C T Y H Z,        LAMBDA(  (x < c) ? y : 0	   ) },

  238. 		{ IF X Q C T Y H Z,	   LAMBDA(  (x == c) ? y : 0	   ) },

  239. 		{ IF C G X T Y H Z,	   LAMBDA(  (c > x) ? y : 0	   ) },

  240. 		{ IF C L X T Y H Z,        LAMBDA(  (c < x) ? y : 0	   ) },

  241. 		{ IF X G C T X H Z,	   LAMBDA(  (x > c) ? x : 0	   ) },

  242. 		{ IF X L C T X H Z,        LAMBDA(  (x < c) ? x : 0	   ) },

  243. 		{ IF X Q C T X H Z,	   LAMBDA(  (x == c) ? x : 0	   ) },

  244. 		{ IF C G X T X H Z,	   LAMBDA(  (c > x) ? x : 0	   ) },

  245. 		{ IF C L X T X H Z,        LAMBDA(  (c < x) ? x : 0	   ) },

  246. 		{ IF X G C T X H Y,	   LAMBDA(  (x > c) ? x : y	   ) },

  247. 		{ IF X L C T X H Y,        LAMBDA(  (x < c) ? x : y	   ) },

  248. 		{ IF X Q C T X H Y,	   LAMBDA(  (x == c) ? x : y	   ) },

  249. 		{ IF C G X T X H Y,	   LAMBDA(  (c > x) ? x : y	   ) },

  250. 		{ IF C L X T X H Y,        LAMBDA(  (c < x) ? x : y	   ) },

  251. 

  252. 		{ IF Y G C T X H Z,	   LAMBDA(  (y > c) ? x : 0	   ) },

  253. 		{ IF Y L C T X H Z,        LAMBDA(  (y < c) ? x : 0	   ) },

  254. 		{ IF Y Q C T X H Z,	   LAMBDA(  (y == c) ? x : 0	   ) },

  255. 		{ IF C G Y T X H Z,	   LAMBDA(  (c > y) ? x : 0	   ) },

  256. 		{ IF C L Y T X H Z,        LAMBDA(  (c < y) ? x : 0	   ) },

  257. 		{ IF Y G C T Y H Z,	   LAMBDA(  (y > c) ? y : 0	   ) },

  258. 		{ IF Y L C T Y H Z,        LAMBDA(  (y < c) ? y : 0	   ) },

  259. 		{ IF Y Q C T Y H Z,	   LAMBDA(  (y == c) ? y : 0	   ) },

  260. 		{ IF C G Y T Y H Z,	   LAMBDA(  (c > y) ? y : 0	   ) },

  261. 		{ IF C L Y T Y H Z,        LAMBDA(  (c < y) ? y : 0	   ) },

  262. 		{ IF Y G C T Y H X,	   LAMBDA(  (y > c) ? y : x	   ) },

  263. 		{ IF Y L C T Y H X,        LAMBDA(  (y < c) ? y : x	   ) },

  264. 		{ IF Y Q C T Y H X,	   LAMBDA(  (y == c) ? y : x	   ) },

  265. 		{ IF C G Y T Y H X,	   LAMBDA(  (c > y) ? y : x	   ) },

  266. 		{ IF C L Y T Y H X,        LAMBDA(  (c < y) ? y : x	   ) },

  267. 

  268. 	};	

  269. 

  270. #undef X

  271. #undef Y

  272. #undef C

  273. #undef A

  274. #undef S

  275. #undef O

  276. #undef OP

  277. #undef CP

  278. #undef P

  279. #undef M

  280. #undef D

  281. #undef R

  282. #undef S2

  283. #undef S3

  284. #undef s0

  285. #undef s1

  286. #undef s2

  287. #undef E

  288. #undef SA

  289. #undef SX

  290. #undef SY

  291. #undef SC

  292. #undef COMMA

  293. #undef MIN

  294. #undef MAX

  295. #undef SIN

  296. #undef COS

  297. #undef TAN

  298. #undef ASIN

  299. #undef ACOS

  300. #undef ATAN

  301. #undef LOG

  302. #undef LOG2

  303. #undef LOG10

  304. #undef IF

  305. #undef G

  306. #undef L

  307. #undef Q

  308. #undef Z

  309. #undef W

  310. #undef T

  311. #undef H

  312. #undef Pi

  313. #undef TAU

  314. 

  315. } // end namespace SubmarineA0

  316. 

  317. struct AOFuncDisplay : Knob {

  318. 	std::shared_ptr<Font> font;

  319. 	AOFuncDisplay() {

  320. 		box.size.x = 80;

  321. 		box.size.y = 15;

  322. 		snap = true;

  323. 		smooth = false;

  324. 		speed = 0.5f;

  325. 		font = Font::load(assetGlobal("res/fonts/DejaVuSans.ttf"));

  326. 	}

  327. 	void draw(NVGcontext *vg) override {

  328. 		nvgFontSize(vg, 16);

  329. 		nvgFontFaceId(vg, font->handle);

  330. 		nvgFillColor(vg, nvgRGBA(0x28, 0xb0, 0xf3, 0xff));

  331. 		nvgTextAlign(vg, NVG_ALIGN_CENTER);

  332. 		nvgText(vg, 41.5, 13, SubmarineAO::functions[value].name.c_str(), NULL);

  333. 	}

  334. };

  335. 

  336. struct AOConstDisplay : Knob {

  337. 	std::shared_ptr<Font> font;

  338. 	AOConstDisplay() {

  339. 		box.size.x = 80;

  340. 		box.size.y = 15;

  341. 		snap = true;

  342. 		speed = 0.005;

  343. 		font = Font::load(assetGlobal("res/fonts/DejaVuSans.ttf"));

  344. 	}

  345. 	void draw(NVGcontext *vg) override {

  346. 		char mtext[41];

  347. 		sprintf(mtext, "C=%4.2f", ((int)value)/100.0f);

  348. 		nvgFontSize(vg, 16);

  349. 		nvgFontFaceId(vg, font->handle);

  350. 		nvgFillColor(vg, nvgRGBA(0x28, 0xb0, 0xf3, 0xff));

  351. 		nvgTextAlign(vg, NVG_ALIGN_CENTER);

  352. 		nvgText(vg, 41.5, 13, mtext, NULL);

  353. 	}

  354. };

  355. 

  356. template <unsigned int x, unsigned int y>

  357. struct AO1 : Module {

  358. 	enum ParamIds {

  359. 		PARAM_FUNC_1,

  360. 		PARAM_CONST_1 = x * y,

  361. 		NUM_PARAMS = 2 * x * y

  362. 	};

  363. 	enum InputIds {

  364. 		INPUT_X_1,

  365. 		INPUT_Y_1 = x,

  366. 		NUM_INPUTS = x + y

  367. 	};

  368. 	enum OutputIds {

  369. 		OUTPUT_X_1,

  370. 		OUTPUT_Y_1 = x,

  371. 		NUM_OUTPUTS = x + y

  372. 	};

  373. 	enum LightIds {

  374. 		NUM_LIGHTS

  375. 	};

  376. 

  377. 	AO1() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS) {}

  378. 	void step() override {

  379. 		float vx[x];

  380. 		for (unsigned int ix = 0; ix < x; ix++) {

  381. 			vx[ix] = inputs[INPUT_X_1 + ix].value;

  382. 		}

  383. 		for (unsigned int iy = 0; iy < y; iy++) {

  384. 			float vy = inputs[INPUT_Y_1 + iy].value;

  385. 			for (unsigned int ix = 0; ix < x; ix++) {

  386. 				unsigned int f = params[PARAM_FUNC_1 + ix + iy * x].value;

  387. 				if (f >= SubmarineAO::functions.size())

  388. 					f = SubmarineAO::functions.size() - 1;

  389. 				if (f > 0)

  390. 					vy = vx[ix] = SubmarineAO::functions[f].func(vx[ix], vy, ((int)params[PARAM_CONST_1 + ix + iy * x].value)/100.0f);

  391. 				// if f is equal to 0, then both x and y pass (crossing) through the module unchanged.

  392. 			}

  393. 			outputs[OUTPUT_Y_1 + iy].value = std::isfinite(vy)?vy:0.0f;

  394. 		}

  395. 		for (unsigned int ix = 0; ix < x; ix++) {

  396. 			outputs[OUTPUT_X_1 + ix].value = std::isfinite(vx[ix])?vx[ix]:0.0f;

  397. 		}

  398. 	}

  399. };

  400. 

  401. template <unsigned int x, unsigned int y>

  402. struct AOWidget : ModuleWidget {

  403. 	AOWidget(AO1<x,y> *module) : ModuleWidget(module) {

  404. 		setPanel(SubHelper::LoadPanel(plugin, "AO-1", x*y));

  405. 		for (unsigned int ix = 0; ix < x; ix++) {

  406. 			addInput(Port::create<SilverPort>(Vec(4, 61 + ix * 46), Port::INPUT, module, AO1<x,y>::INPUT_X_1 + ix));

  407. 			addOutput(Port::create<SilverPort>(Vec(46 + y * 90, 61 + ix * 46), Port::OUTPUT, module, AO1<x,y>::OUTPUT_X_1 + ix));

  408. 		}

  409. 		for (unsigned int iy = 0; iy < y; iy++) {

  410. 			addInput(Port::create<SilverPort>(Vec(70 + 90 * iy, 19), Port::INPUT, module, AO1<x,y>::INPUT_Y_1 + iy));

  411. 			addOutput(Port::create<SilverPort>(Vec(70 + 90 * iy, 335), Port::OUTPUT, module, AO1<x,y>::OUTPUT_Y_1 + iy));

  412. 		}

  413. 		for (unsigned int iy = 0; iy < y; iy++) {

  414. 			for (unsigned int ix = 0; ix < x; ix++) {

  415. 				addParam(ParamWidget::create<AOFuncDisplay>(Vec(42.5 + 90 * iy, 59 + 46 * ix), module, AO1<x,y>::PARAM_FUNC_1 + ix + iy * x, 0.0f, SubmarineAO::functions.size() - 1.0f, 0.0f ));

  416. 				addParam(ParamWidget::create<AOConstDisplay>(Vec(42.5 + 90 * iy, 78 + 46 * ix), module, AO1<x,y>::PARAM_CONST_1 + ix + iy * x, -10000.0f, 10000.0f, 0.0f));

  417. 			}

  418. 		}

  419. 	}

  420. };

  421. 

  422. } // namespace rack_plugin_SubmarineFree

  423. 

  424. using namespace rack_plugin_SubmarineFree;

  425. 

  426. RACK_PLUGIN_MODEL_INIT(SubmarineFree, AO106) {

  427.    Model *modelAO106 = Model::create<AO1<6,1>, AOWidget<6,1>>("Submarine (Free)", "A0-106", "A0-106 Arithmetic Operators", UTILITY_TAG, MULTIPLE_TAG);

  428.    return modelAO106;

  429. }

  430. 

  431. RACK_PLUGIN_MODEL_INIT(SubmarineFree, AO112) {

  432.    Model *modelAO112 = Model::create<AO1<6,2>, AOWidget<6,2>>("Submarine (Free)", "A0-112", "A0-112 Arithmetic Operators", UTILITY_TAG, MULTIPLE_TAG);

  433.    return modelAO112;

  434. }

  435. 

  436. RACK_PLUGIN_MODEL_INIT(SubmarineFree, AO118) {

  437.    Model *modelAO118 = Model::create<AO1<6,3>, AOWidget<6,3>>("Submarine (Free)", "A0-118", "A0-118 Arithmetic Operators", UTILITY_TAG, MULTIPLE_TAG);

  438.    return modelAO118;

  439. }

  440. 

  441. RACK_PLUGIN_MODEL_INIT(SubmarineFree, AO124) {

  442.    Model *modelAO124 = Model::create<AO1<6,4>, AOWidget<6,4>>("Submarine (Free)", "A0-124", "A0-124 Arithmetic Operators", UTILITY_TAG, MULTIPLE_TAG);

  443.    return modelAO124;

  444. }

  445. 

  446. RACK_PLUGIN_MODEL_INIT(SubmarineFree, AO136) {

  447.    Model *modelAO136 = Model::create<AO1<6,6>, AOWidget<6,6>>("Submarine (Free)", "A0-136", "A0-136 Arithmetic Operators", UTILITY_TAG, MULTIPLE_TAG);

  448.    return modelAO136;

  449. }