Download EVALUA for free and make your own noises: http://shiru.untergrund.net/files/evalua.zip (x86 and x64 builds are there, along with source code)
EVALUA is an experimental VSTi synth plugin that uses math equations to describe various waveforms, ranging from the most basic ones to very complex. Inspired by the one-liner music programs that rocked the web back in 2011, as well as by the 8BitSynth module in the Caustic 3 software that came out sometime later.
Please note that this plugin only shares the same concept, but has a very different implementation, thus it is not directly compatible with either of the mentioned things.
- 64-bit integer math only
- Binary operations only, no unary or ternary for now
- Custom parser with very fast RPN-based calculator
- A number of variables to use in the equations
- Polyphonic or monophonic modes
- Portamento in the monophonic mode
A small insight on the plugin development
Initially I planned to do it the easy way: just take an existing math expression parser and evaluator library, and base my plugin around it, to save time and get best feature set with all kinds of math operations supported. This plan has been ruined quickly as I tested out a few popular libraries of this kind. All of them shared the same two issues.
The first is an unexpected one. None of them compatible with any of Visual Studio C compilers as a throw-in. They all tend to use latest C++ features and standards that somehow never work in any version of VC without a good deal of fiddling, even though a library explicitly declares compatibility with a particular VC version.
The second one is more obvious. Any of these parsers aren't terribly fast in an application like this, when the plugin needs to calculate the same exact equation over and over again many thousands times per second. This is not because the libraries any bad, they're pretty good in fac. That's just the nature of the design, they parse an equation (which is relatively slow part), then calculate it (which is quick part) every time, repeating the parsing part even though the equation does not change between calls.
After spending some time trying to get any of the libraries working, I opted to re-invent the wheel, and made my own parser/solver, which also served as a nice programming exercise in things I'm not doing too often. My solution is very simple and limited, but it has been designed for fast repetitive calculations, and it is compatible with whatever compiler I'm going to use. As I'm planning to support x64 in all of my plugins, I wanted to target both platforms off the bat, so I picked VC Community 2017 instead of the usual choice of VC 2008 Express that I was using for all of my previous x86 plugins.
What makes my equation solver different is that it splits the process into two well separated stages. It parses the equation only once, using the basic shunting-yard algorithm, and creates RPN stack. Parsing does not have to be optimized for speed in this case, it can take its time to do all the syntax checks and other stuff. Once correct RPN stack is generated, it can then be calculated very quickly, there is no need for error checks or any other operations besides actual evaluation, it is as basic as it gets. This allows to have more complex equations with reasonable CPU load to be used in real time.
At the moment the evaluator only supports binary operations, i.e. operations with two operands, such as addition and subtraction. There is no support for unary operators, such as negation (you can use 0-N for now), and no support for ternary operators either. The latter could come very handy for a synth like this, so they're in the plans for future versions.
When my plugin was mostly done, I learned there is a Reaktor synth called digit 8 released in 2014 that is more or less similar to that my plugin is trying to be, it already have some of the features that I planned but not implemented yet. Another proof that it is difficult to think up something new these days that hasn't been made already.