Vector Surgeon 1.1 Read Me
Hello, good evening, and welcome to Vector Surgeon, the Prophet VS editor/librarian.
This document explains some of the design principles surrounding
the program, how to get started, and how to use it effectively.
PLEASE READ THE ENTIRE DOCUMENT BEFORE FIRING UP THE PROGRAM. THANKS.
First, the legal stuff.
The Java classes and XML documents comprising this package are copyright 2019 Jason Proctor.
The package is not in the public domain. The program is technically shareware. If you find
yourself using it a lot, then Paypal a donation to email@example.com -- I'll leave the size up to you.
I am currently quite broke, so donations mean that I can prioritise development of this
program ahead of things that don't make money. Thanks.
First Thing to Know About Vector Surgeon on Mac!
NOTE THAT AS OF VS VERSION 1.1.9 YOU DO NOT NEED MMJ ANY MORE!! WHEEE!
News! Vector Surgeon on Github!
Source here: https://github.com/juvation/vectorsurgeon
What The Program Does
The program currently performs the following functions:
- Transmit and receive patches, singly or in banks, between your computer and your Prophet.
- Load and save patches, singly or in banks, between your computer and its disk drive.
- Transmit and receive banks of waves between your computer and your Prophet.
- Load and save banks of waves between your computer and its disk drive.
- Graphically view banks of patches, allowing copy & paste etc in the same window or between windows.
- Graphically view patches, allowing edits of most parameters.
- Graphically view waves, allowing visual editing by drawing with the mouse.
- Import wavs, aiffs, and straight binary files into wave locations.
- Edits of parameters are sent live to the Prophet, in theory keeping computer & Prophet in sync.
- Edits of parameters made on the Prophet are reflected in the computer display.
- Generate variations on a patch, with various rules determining parameter values.
- Play the Prophet with an on-screen keyboard.
- Play the Prophet from your controller keyboard via the MIDI Thru function.
What The Program Does Not Do
The program does not currently perform the following functions:
- SDS between the computer and Prophet. But you don't need it, because you can request
wave banks, edit them etc, then transmit back. You only need SDS if you don't have a computer.
- That's it. Maybe you can find more things it doesn't do :-)
The program has the following known defects (so don't report them):
- If you select the full patch name, then start typing a new one, it will take 2 characters before the
patch window title catches up. The patch is fine and the Prophet is fine, though. I think this is a bug
in Swing. Maybe they fixed it in later Java versions.
- Changing the patch name on the Prophet doesn't result in the patch name changing in the edit window.
Offhand I don't know if anyone cares about fiddling with the Prophet and watching the controls change
on the screen - I doubt it, particularly for patch naming, which is a pain. But I might fix this one anyway.
- That's it. Maybe you can find more bugs :-)
The Computer/Synth Sync Problem and My Solution
All ed/libs have the same problem to overcome. How to enable users to quickly manage patches and banks and stuff,
while keeping the computer and synth reasonably in sync during edits. Some ed/libs party on the edit buffer,
if there is one, and truck large amounts of parameter change messages down to the synth when a patch edit window
comes up. Others, like most SoundDiver adaptations, hijack a memory location (99 in the SD VS adaptation) and just transmit
patches to that location. That way, when you open a patch for editing, you don't need to sync the parameters, because the
patch is already there.
This program does neither of those things. Instead, it tries to figure out whether the bank window you're looking at
is currently in the Prophet. If you just received it from the Prophet, then it is, and if you just sent this bank to the Prophet,
then it is. Otherwise, it's not. The difference is that opening patch editing windows on a bank that the program thinks is
not in the Prophet requires a confirmation from you. So you can override what the program thinks. This is good, because you
might have an identical copy of your Prophet's bank on disk, and you *know* that's what's in the Prophet. So if you see
that confirmation dialog, and you say Yes, then the program then regards that bank as in the Prophet and doesn't bug you
about edits any more.
Helpfully, what the program thinks is always displayed at the top of each bank window. Just so you know. And just to help
a bit more, operations that overwrite stuff in the Prophet always have a confirmation step. Losing patches sucks.
This program is written in Java. As such you will need a Java VM installed on your machine, and I recommend anything from
1.8 up. Prior versions might work, but I can't support them any more. Most if not all platforms now have 1.10 even, so that shouldn't
be too hard.
The Control Window
Once launched the program will go scanning your system for MIDI facilities. This can take a few seconds on the Mac,
I'm not sure about other platforms.
Then, providing nothing catastrophic happened, the control window will appear, which looks like this
The bottom pane allows you to select the device and MIDI channel where your Prophet lives.
The Prophet uses a combination of sysex and kinda-NRPNs to do its remote editing stuff,
so you have to get the MIDI channel right as well as the device. The program remembers this for you too.
Also you can now set a device to listen to for notes to route to the Prophet, so you can connect up
your controller keyboard and play a rack Prophet without having to fire up a DAW or something.
The "Open File" button allows you to load a file off disk. This is expected to be either a single patch, a bank of 100 patches,
or a bank of 32 user waves. Anything in between will most likely result in an error.
Providing this operation works OK, you'll be looking at a bank window, which in the case of a single patch dump contains
100 copies of the same patch, or a wave bank window.
The "Request Patches" button allows you to... suck the bank of patches out of your Prophet. As it happens, you don't really need
to click the button, as the program is always hungry for banks and will respond if you just send stuff from the Prophet
without warning it. It turns out that writing it like that was easier. I'm sorry about the lack of user feedback while
the bank is being received, but the Sun Java MIDI package works like that. The old Apple one, which I preferred, allowed
some code to get in the way. But then the Sun one allows you Windows and Linux users to play, and that's good. Probably.
Anyway again you'll be looking at a bank window.
The "Request Waves" button allows you to... suck the user waves out of your Prophet. As with banks of patches, the
program is always listening. If the waves are received OK, then you'll be looking at a wave bank window.
The "Keyboard" button opens up the onscreen keyboard. It's basic but has octave transpose, variable velocity, and
hold functions. So you can keep a chord playing while you wail on parameters.
The "Choose Config File..." button allows you to specify an alternative UI description file for the patch editing window.
If loading it doesn't work, then it will use the default one. If you've hacked the default one (by unzipping the jar file???)
and that doesn't work, then the program will become confused.
The Bank Window
The bank window looks like this
This window allows manipulation of banks of patches. You can move them around, send them to the Prophet, etc, all
that good stuff. The bank window is kinda big, because I wanted to convey some information about each patch rather than
just its name. I'm open to feedback on this one. Maybe people don't have big screens, certainly Windows makes a bit of
a pig's ear of it (and everything else) - the preferred Windows way is to maximise it then scroll around the middle
pane. That way you get to see the button bar, which otherwise it is determined to hide from you. Yuck.
Again most things should be easy to understand here. Click a patch to select it, then you can copy, paste, send, etc. Swap
paste swaps the selection and the clipboard, so if you swap paste twice, then effectively nothing has happened. What use
is that, you might ask, well I found it useful if I was reordering lots of patches within a bank. See if you like it.
Click the Vary Patch button to enter the patch variation generator stuff.
Note the red message at the top of the window. This means that the program thinks this bank is not currently in the Prophet.
This is to prevent you opening up a patch and cheerfully editing it, while not realising that on the Prophet, it's not
Zingers2, it's something else completely. If that message is red, then double-clicking a patch in order to edit it
requires confirmation - you have to assure the program that you know what you're doing and this bank is really in the Prophet,
honest. If you say Yes to the confirmation, then the program backs off and turns on editing for you. It also
changes the message to a comforting blue one. I quite like this because I know what's going on,
but if you have a better solution to the computer/synth sync problem, hold forth.
The Patch Edit Window
Aha, now we get to the meat of the operation. Double-clicking on a patch in the bank window opens that patch for juicy
graphic editing. The first tab of the patch window looks like this
The Prophet's parameters are grouped into what I thought were logical areas. You'll note however that some parameters
appear twice - some modulation parameters appear on both the source and the destination pages. I like that. And again
if you don't like my layout, you're free to make your own, for the price of a bit of XML hacking.
This part should be *really* straightforward. Move a slider, check a checkbox, pick something from a popup, and the
relevant control change is sent to the Prophet. Yummy! Finally we can get to the bottom of this amazing machine.
You'll note that when you do change something, then you'll be required to confirm the save of the patch back into the
bank it came from. Note that changes to patches are *not* automatically saved to the Prophet, so if you want to
update it, then send the patch, or send the entire bank.
The Patch Generator Window
This window comes up when you select a patch in the bank window and click Vary Patch... and it looks like this
Well, it looks like that if you've added a few parameters. The generator works by applying transforms to parameters.
So you click "Add Parameter Transform" to add a parameter, then select a transform to apply to it, then when you're done,
click "Generate Bank" to generate a bank of patches based on the transforms. The transforms currently available are patch number,
ROM patch number, set, and random. The generator generates entire banks, patch by patch, and so if you like you can set a particular
parameter to the patch number. This is fun for generating banks full of sounds which differ only by their waveforms. And you
can specify a ROM patch number so that you can get to waves above 100. Set just sets a parameter to a particular value, and Random
will randomise a parameter either within its range, or inside a range that you specify.
The generator window stays up after it generates a bank, so that you can make further tweaks etc. At some point I might make
it possible to save collections of transforms, but the program doesn't currently allow that.
The Wave Bank Window
The wave bank window looks like this
This window behaves in much the same fashion as the regular patch bank window, except that you're dealing with
waves instead of patches. The exception is that you can't transmit or receive them singly. I was going to include
that in this release, but then I realised that it's not necessary. Since you can graphically edit the waves, and
import sound files into wave locations, then transmit and receive banks, you don't actually need single wave
transfer. And it's a pain in the arse to implement, and in my experience, VS version 1.0 doesn't support it anyway!
Click Import to import a sound file into a selected location. If the file doesn't check out as a wav file or aiff file,
then the program will load it as an 8-bit raw binary sound file. So be prepared for a surprise if it wasn't a sound
file to begin with :-)
The Wave Edit Window
The wave edit window looks like this
This appears when you double click a wave in the wave bank window. Draw the wave with the mouse - cool eh?
Bonus! Reverse Editing
I was fooling with the program one night and walked over to the Prophet to play the patch. I made a change to a parameter
and then thought shite! I've just invalidated the program's view of that patch. Wouldn't it be great if... changing a
parameter on the Prophet also changed it in the program! An hour and some hair-pulling later, it worked. What a nice
surprise. Ensure you turn on parameter transmission though - click the button in the Control Window or set it on the Prophet.
It's turned off by default when the Prophet powers up.
Well, everything on the 1.0 list pretty much got done in 1.1 :-) Please feel free to let me know if you have any ideas
for further features etc.
Have fun with the program. I do. It makes editing *super* easy and everyone should be able to make amazing patches now.
Contact me at firstname.lastname@example.org with bug reports, feature requests, flat-out adulation, and, of course, money (thank you, Scott).
And Here's The Link