SynthMaker

Reaktor Sine function conversion....

Archive · 2008 42 old posts

From the original SynthMaker forum (2004–2014), with its members’ names and dates.

aliasant ·

Another little project that might be fun.

I converted a Sine function from Reaktor and turned it into code.

You feed the input with a ramp and the output is a sine. Simple enough. The first conversion used about 87 cycles ( thats without the ramp ) Then I turned it into code and now it uses 65.4 cycles.

Now I have tried to asm it and by replacing the rectifying part with the absmask version I got it down to 46 cycles but Im stuck. It must be possible to get it down more but my brain is boiling over.

Here is the original code I wrote and it can most likely be written in a much smarter way.

streamin ramp; streamout sine;

float x,rect,k,i,j;

x = ramp -0.5;

rect = x * (1 - x < 0 & 2); k = (rect + 0.42493299) *(rect -0.5) * (rect - 0.92493302) ; i = 0.436501 + (rect * (rect + 1.05802)); j = 1.21551 + (rect * (rect - 2.0580201)); sine = i*j*k*60.252201*x;

Couldnt help myself. I wrote the code in a different way thinking that maybe the asm would be easier. I got the asm down to 36.4 but I think thats still to high. The stock Sine uses 26.4 cycles and of course it doesnt need a ramp to drive it.

Here is the second version of the code.

streamin ramp; streamout sine;

float x,rect,a,b,c,d,e,f,g,h,k,i,j;

x = ramp -0.5;

rect = x * (1 - x < 0 & 2);

a = rect + 0.42493299; b = rect - 0.5; c = rect - 0.92493302; d = rect + 1.05802; e = rect - 2.0580201;

g = rect * e; j = 1.21551 + g; f = rect * d; i = 0.436501 + f;

k = a * b * c ;

sine = i*j*k*60.252201*x;

And here is the asm'd version of that

streamin ramp; streamout sine; float x=0;float rect=0;float a=0;float b=0;float c=0;float d=0; float e=0;float f=0;float g=0;float h=0;float k=0;float i=0; float j=0;float F0P5=0.5;float F1=1;float F0=0;float F2=2; float F0P424933=0.424933;float F0P924933=0.924933; float F1P05802=1.05802;float F2P05802=2.05802;float F1P21551=1.21551; float F0P436501=0.436501;float F60P2522=60.2522;

movaps xmm0,ramp; subps xmm0,F0P5; movaps x,xmm0; // made the x and save for later

int absmask=2147483647; andps xmm0,absmask; movaps rect,xmm0; // Rectified

addps xmm0,F0P424933; movaps a,xmm0;

movaps xmm7,rect; subps xmm7,F0P5;

movaps xmm6,rect; subps xmm6,F0P924933;

movaps xmm5,rect; addps xmm5,F1P05802;

movaps xmm4,rect; subps xmm4,F2P05802;

movaps xmm3,rect; mulps xmm3,xmm4;

movaps xmm2,F1P21551; addps xmm2,xmm3;

movaps xmm1,rect; mulps xmm1,xmm5;

movaps xmm5,F0P436501; addps xmm5,xmm1;

movaps xmm4,a; mulps xmm4,xmm7; mulps xmm4,xmm6;

movaps xmm0,xmm5; mulps xmm0,xmm2; mulps xmm0,xmm4; mulps xmm0,F60P2522; mulps xmm0,x; movaps sine,xmm0;

matti ·

Usually it's faster if you use registers instead of memory locations. So i tested to remove some memory use from the code.. It resulted to only a 10% improvement on my P4. Should be more on a Core processor. Here's the code: streamin ramp; streamout sine; float F0P5=0.5; float F1P21551=1.21551; float F0P424933=0.424933;float F0P924933=0.924933; float F1P05802=1.05802;float F2P05802=2.05802; float F0P436501=0.436501;float F60P2522=60.2522; int absmask=2147483647;

movaps xmm0,ramp; subps xmm0,F0P5; movaps xmm6,xmm0;

andps xmm0,absmask; movaps xmm5,xmm0; movaps xmm4,F0P5; addps xmm0,F0P424933;

movaps xmm7,xmm5; subps xmm7,xmm4; mulps xmm0,xmm7;

movaps xmm4,xmm5; subps xmm4,F0P924933; mulps xmm0,xmm4;

movaps xmm7,xmm5; addps xmm7,F1P05802;

movaps xmm4,xmm5; subps xmm4,F2P05802;

movaps xmm3,xmm5; mulps xmm3,xmm4;

addps xmm3,F1P21551; mulps xmm3,xmm0; //

movaps xmm1,xmm5; mulps xmm1,xmm7;

addps xmm1,F0P436501; mulps xmm1,xmm3; // mulps xmm1,F60P2522; mulps xmm1,xmm6; movaps sine,xmm1;

aliasant ·

matti wrote: Usually it's faster if you use registers instead of memory locations. So i tested to remove some memory use from the code.. It resulted to only a 10% improvement on my P4. Should be more on a Core processor.

Nice. It now uses 29 cycles on my machine ( and with my analyzer)

Im trying a different sine function now. Also from Reaktor. It looks as if it could be faster. I converted it so that it works in SM but it needs a slightly modified ramp to work. Now trying to make it into code but its a bit hard. Trying to write the whole thing in one line. Except the first multiplier.

Update: Ok Here is the coded version. It uses a little less then previous codes. This uses 67 cycles. It also has a nice xtra input that can morph from saw thru sin to sawsin. BUT. The saws alias like..... so its probably best to fix it to the sin 😉

streamin ramp; streamin x; // 1.5 = Saw 3.142 = Sin 4.5 = SawSin streamout sine; float saw,saw2; saw = (ramp * 2 - 1) * x; saw2 = saw * saw;

sine = -0.166667 + saw2 * (0.00833333 + saw2 * (-0.000198409 + saw2 * (2.7526e-006+saw2 * -2.39e-008))); sine = saw * (1+ saw2 * sine);

aliasant ·

Lol. Im having fun today.

Here is the new code ASMd and the asm looks really fast. But it isnt..... Got it down to 43 cycles. What is it with this asm code that makes it slow? Its only multiplications and adds. Not many lines either. I also tried to movup most of the floats to their own xmms but that really didnt do any difference at al. Does that depend on your cpu? Maybe it does make a difference for some one else?

// Sine Code 43 cycles streamin ramp; streamout sine; float saw=0;float saw2=0;float F2=2;float F1=1;float F3P142=3.142; float FM0P166667=-0.166667;float F0P00833333=0.00833333; float FM0P000198409=-0.000198409;float F2P7526eM006=2.7526e-006; float FM2P39eM008=-2.39e-008;

movaps xmm0,ramp; movaps xmm6,F2; movaps xmm5,F1; movaps xmm4,F3P142; movaps xmm3,FM2P39eM008; movaps xmm2,F2P7526eM006; movaps xmm1,FM0P000198409; mulps xmm0,xmm6; subps xmm0,xmm5; mulps xmm0,xmm4; movaps saw,xmm0; mulps xmm0,xmm0; movaps xmm7,xmm0; mulps xmm0,xmm3; addps xmm0,xmm2; mulps xmm0,xmm7; addps xmm0,xmm1; mulps xmm0,xmm7; addps xmm0,F0P00833333; mulps xmm0,xmm7; addps xmm0,FM0P166667; mulps xmm0,xmm7; addps xmm0,xmm5; mulps xmm0,saw; movaps sine,xmm0;

/ Original Code streamin ramp; streamout sine; float saw,saw2; saw = (ramp * 2 - 1) * 3.142; saw2 = saw * saw;

sine = -0.166667 + saw2 * (0.00833333 + saw2 * (-0.000198409 + saw2 * (2.7526e-006+saw2 * -2.39e-008))); sine = saw * (1+ saw2 * sine);

aliasant ·

To continue the saga..........

I hopped the last Sine asm code and placed a fast lopass after that. It works pretty good as a fast LFO. Sounds and looks right up to 200Hz Well enough for an LFO and it uses only 13.9 cycles. Thats with the ramp and the lopass.

here is the osm to dissect.

matti ·

aliasant wrote: Lol. Im having fun today.

Here is the new code ASMd and the asm looks really fast. But it isnt..... Got it down to 43 cycles. What is it with this asm code that makes it slow? Its only multiplications and adds. Not many lines either. I also tried to movup most of the floats to their own xmms but that really didnt do any difference at al. Does that depend on your cpu? Maybe it does make a difference for some one else?

The thing about SSE assembler instructions(very simplified description) is that the processor can do one type(move, add/sub, mul, divide, logics) at a time, but several different types at the same time(very cpu dependant tho). When the processor receives a mulps command it fetches the needed data from memory and/or cache, and does the multiply, which on a P4 takes 5 clock cycles(not including the fetching). At the same time the processor decodes next instructions and if it doesn't use the same "work unit" or the same data(same registers or memory locations)as the current operation it can start it before the earlier one finishes. This is kind of multi tasking i guess. Can't remember what the actual name for it is. Anyhow, there are processor specs that tell you how many cycles it takes for each operation and how many operations can be overlaid like this. Usually mixing different types can help in getting the code faster. If you have several mulps right after each other, you can get "free" subps and adds from between them. Same as after divps(takes around 20-30cycles usually) you can get alot of "free" operations. Intel docs are a very nice read on the topic 🙂

Moving the values to registers usually has a positive effect only if there's many operations that use them. The processor knows how to prefetch this data to the cache so it's usually faster to just use the memory location on operations like this mulps xmm0,F1; addps xmm0,F2; subps xmm0,F3

Instead of moving the data first.

On the other hand, writing to memory can be alot slower than using a register as a temporary memory location. So avoiding things like this can help..: movaps x,xmm0; movaps xmm0,somethingelse; mulps xmm0,x;

Instead do this movaps xmm1,xmm0; movaps xmm0,somethingelse; mulps xmm0,xmm1;

aliasant ·

Hmmm. Not quite sure I understood that. but maybe one day, not to far away, I might do that reading......... . . . . . . .

In the mean time =)

I made a fast Triangle.

The stock Triangle uses about 90 cycles and this one uses 24 and then you get a basic Saw as well ( the Saw aliases but is good for LFOs. It can also be hopped for LFO purposes and then it uses almost nothing. ( 14.4 including the ramp)

// Triangle osc. Hop it by removing the "//" streamin ramp; streamout saw; streamout tri; float rect=0;float F2=2;float F1=1;float F0=0;

mov eax,ecx;and eax,15;cmp eax,0;jnz end0; movaps xmm7,F2; movaps xmm6,F1; movaps xmm0,ramp; mulps xmm0,xmm7; subps xmm0,xmm6; movaps saw,xmm0; cmpps xmm0,F0,1; andps xmm0,xmm7; movaps xmm2,xmm6; subps xmm2,xmm0; mulps xmm2,saw; mulps xmm7,xmm2; subps xmm7,xmm6; movaps tri,xmm7; end0:

/ Original code streamin ramp; streamout saw; streamout tri; float rect;

hop(16){ saw = (ramp * 2 - 1); rect = saw * (1 - saw < 0 & 2); tri = 2 *rect -1; }

matti ·

aliasant wrote: Hmmm. Not quite sure I understood that. but maybe one day, not to far away, I might do that reading......... . . . . . . .

Hehe, no prob. That sine is already quite optimal. Not much can be done to get it any faster. Unless you figure out how to change the equation for it.

Eska ·

A mulps "xmm0,F2" can be replaced by "addps xmm0,xmm0".

matti ·

Eska wrote: A mulps "xmm0,F2" can be replaced by "addps xmm0,xmm0".

Good find 😀 That saves atleast 1 cycle.

Correction, it saves 2.5 cycles according to my tests. That's about 5%. So a very good find indeed 🙂

Tom7777 ·

This is cool but im just wondering if NI has some restrictions over copying things from it, if they are user based one would most likely need to ask also if posting online but i dunno... But yeah cool stuff 🙂

matti ·

Tom7777 wrote: This is cool but im just wondering if NI has some restrictions over copying things from it, if they are user based one would most likely need to ask also if posting online but i dunno... But yeah cool stuff 🙂

Yeah, that's what i was thinking with the Reaktor Filter. Very cool stuff, but i'd bet they are not "opensource" in that way. Maybe someone with a Reaktor license should look into the license agreement or send a post to NI and ask about it? I'd do it myself but i guess they'd just think i've pirated it somewhere and now wan't to pick it apart 😀

aliasant ·

Hmm. Not sure if this is the case or not. I thought they used basic algos for their osc and filters. Hard to copyright something that has been done all over the planet for years. But I really dont know. They can mail me if I have done something wrong 😉 Then again. I have changed things in all the codes so I sort of made it my own. Sounds a bit like the old "allowed to sample 4 bars " question. Which isnt allowed by the way.

Another thought. Doing this. Picking their stuff apart, is a great way to learn how osc's and filters are built. The triangle osc is not a rip from Reaktor but something I build on my own using the techs I learned from copying the sines. Like the Japanese in the 70's The copied a lot and eventually came out making better stuff then the originals. Not that I will make anything better then NI. Just glad I can make some of my own codes.

Back to coffee...

Acrobat ·

I think you should not worry about that, I mean, they really can copyright a simple "multiplication for a fractional number"? Naa... 🙂

aliasant ·

Acrobat wrote: I think you should not worry about that, I mean, they really can copyright a simple "multiplication for a fractional number"? Naa... 🙂

My thought exactly =)

Tom7777 ·

Hmm. Not sure if this is the case or not. I thought they used basic algos for their osc and filters. Hard to copyright something that has been done all over the planet for years. But I really dont know. They can mail me if I have done something wrong 😉 Then again. I have changed things in all the codes so I sort of made it my own. Sounds a bit like the old "allowed to sample 4 bars " question. Which isnt allowed by the way.

I think you should not worry about that, I mean, they really can copyright a simple "multiplication for a fractional number"? Naa... 🙂

Well yeah i agree somewhat but i think if you take someones code and change it to another format thats still using someones code really, kind of like taking a image and applying a filter too it still the same thing but with a new look etc 🙂 If your looking to convert code etc to SM format it's probably a safer bet using something like the Music DSP archive which i think is open source -

http://www.musicdsp.org/archive.php?classid=3

But yeah for common maths it's probably too general so ok but filters etc im not sure. But im guessing reaktors not planned to be opensource by NI so it was kind of a hint/thought really. 😀

rl ·

Here is pretty good lecture on efficient sine calculations: http://www.research.scea.com/research/p ... _GDC02.pdf and other math functions: http://www.research.scea.com/gdc2003/fa ... tions.html

Acrobat ·

waycool,rl - Playstation! 😍 😀

infuzion ·

rl wrote: Here is pretty good lecture on efficient sine calculations: http://www.research.scea.com/research/p ... _GDC02.pdf and other math functions: http://www.research.scea.com/gdc2003/fa ... tions.html

part 1 PDF wrote: Compiler “Optimizations” Floating Point does not obey the laws of algebra. ... • Replace x/10 with 0.1*x – bad • Replace (x+y)+z with x+(y+z) – bad

I wonder how they draw those conclusions?

bootsy ·

infuzion wrote: rl wrote: Here is pretty good lecture on efficient sine calculations: http://www.research.scea.com/research/p ... _GDC02.pdf and other math functions: http://www.research.scea.com/gdc2003/fa ... tions.html

part 1 PDF wrote: Compiler “Optimizations” Floating Point does not obey the laws of algebra. ... • Replace x/10 with 0.1*x – bad • Replace (x+y)+z with x+(y+z) – bad

I wonder how they draw those conclusions?

We saw the first one in a recent topic here: here.

The second one is when performing operations on very small together with large numbers. Then the ordering of excecution gets more relevant.

infuzion ·

bootsy wrote: infuzion wrote: part 1 PDF wrote: • Replace (x+y)+z with x+(y+z) – bad

I wonder how they draw those conclusions?

The second one is when performing operations on very small together with large numbers. Then the ordering of execution gets more relevant.

Oh, that makes sense; one should add together numbers first with a similar range, so you don't lose resolution.

bootsy ·

I would say: first the smaller, then that results to the larger.

MegaHurtz ·

Nice algo. Began my synthausis becouse of Sync Modular. Great fan of Vadim Zavalishin`s work.

datsound ·

i have an idea, its pretty obvious... to save about 50 percent of cpu on the lfo... i.e. 7-8 cycles total instead of 13, because the ramp is taking 10 and the lfo is 4.

make a hopped counter, i.e asm hop 128 (i=i+1) and feed just a 1 into it at sample rate, i.e. a float input at one or a float to stream imput, sending 1-1-1-1-1-1-1- into the hopped counter at audio rate... even maybe make the counter into the same code as the lfo and just feed 1-1-1-1-1 into it at stream rate? (i think you have done that already ? in which case it would perhaps need a second input for the sync and a third imput that would make phase, i.e. adding numbers to the counter) instaed of a float of 1 going in you could use the frequency input port and say tell the asm that it values 1 and use that to count?

native are not into defending maths property afk, they get their dsp from books, can you imagine what the berlin hq library is like - we are not worthy ... apparently shmitt has lazerbeams in his eyes that fry the bad employees.

datsound ·

sorry im an ubernoob... please i dont understand where the hop is in the asm code for the "sine R B asm hopped 8.3", i want to make hop 128, it sais hopped by 16 in the title but i can't see 16 anywhere in the code. thankyou !

trogluddite ·

you need to look for the lines...

mov eax,ecx; and eax,15; //This number sets the hop amount cmp eax,0; jnz end0;

//hopped code in here//

end0: //hop ends at this line.

...the 'and eax' is basically doing 'counter modulus hop number', and then looks for a zero crossing - so you 'and eax' with one less than the hop amount. The 'cmp eax,0' is not strictly necessary as the 'and eax' will set the zero flag anyway, so you may see the same code but without that line - if it is there, you can safely delete it.

TomC ·

trogluddite wrote: you need to look for the lines...

mov eax,ecx; and eax,15; //This number sets the hop amount cmp eax,0; jnz end0;

//hopped code in here//

end0: //hop ends at this line.

... or you can go to the Wiki, someone very smart and good looking already made a well documented assembler module for whatever HOP-value you need.

🙂

Edit: oh, and when you look into the generated assembler code of a 'hop' you have to search for the value n-1, e.g. when you've programmed a hop(16) the generated ASM uses the value 15 because it counts down to 0. But when you use my dynamic hop module you won't need that anyway.

aliasant ·

TomC wrote: someone very smart and good looking already made a well documented assembler module for whatever HOP-value you need.

I never made that. Dont know what your talking about?? Besides.. Im not smart. Just incredibly good looking.

TomC ·

aliasant wrote: TomC wrote: someone very smart and good looking already made a well documented assembler module for whatever HOP-value you need.

[...] Im not smart. Just incredibly good looking.

Yeah, we already knew from you forum avatar

Tom

datsound ·

his avatar is a sheep. that is not really him, did you think that a sheep does web surfing and has a computer... err.

when you use the lfo do you use the built in ramp (counter) module? i have found some code ramps in the forums... would i have to change the code in the lfo sine function if the incoming counter was hopped, i suppose no.

when i change the frequency knob the lfo doesnt change shape in the scope, the only way to get the new frequency is cut and paste a module to reboot SM, why isnt the knob sending refreshing the f speed?

any chance you could paste this counter code into the the hopped counted in this thread and kind of merge all the eax ebx mmx xmm lines.... the advantage is that you would have a reversible LFO... REVERSIBLE!!! WOO! maybe if i can make a synth from SM i can buy a front door area for my flat and upgrade the shower from a orange juice bottle and a metal sheet into a real shower and i could get a scooter! woot 🙂

aliasant ·

datsound wrote: have a reversible LFO... REVERSIBLE!!! WOO! maybe if i can make a synth from SM i can buy a front door area for my flat and upgrade the shower from a orange juice bottle and a metal sheet into a real shower and i could get a scooter! woot 🙂

Lol m8. The string sample you have in the waveplayer... I recognized it emediatly. I used that for a track way back. Its from that samplecd that Massive Attack used for Blue I think.

About reversible LFO. There might be other simpler ways to do that but have you tried the very nice multi lfo that someone upped a couple of months back? It has all the main waveforms + S&H and is fully asm optimized. Cant remember who gave it to us. Maybe MB?

datsound ·

hi, i recognise the string sound although it depends what octave it is on, it sounds also like the moby track... blue lines is the massive attack one 🙂0>

the idea was to use 40 lfo's going to some maths that distribute modulation in lots of variations to lots of parameters pretty balanced mixes. it sound fat so far. as there are so many LFO the can be abit approximate but they take up 72 percent of my synth at the moment in SM! that is why your one is pretty attractive to me at the moment. dont take that as an innuendo.

the multi lfo is a great lfo, it is from ensemble monosynth shematic.osm which is in mono, it is made of lots and lots of modules and i didnt manage to plug in the cpu cycle meter so i cant say how much it uses. it will take a while to go though its innards.

aliasant ·

datsound wrote: hi, i recognise the string sound although it depends what octave it is on, it sounds also like the moby track... blue lines is the massive attack one 🙂0>

the idea was to use 40 lfo's going to some maths that distribute modulation in lots of variations to lots of parameters pretty balanced mixes. it sound fat so far. as there are so many LFO the can be abit approximate but they take up 72 percent of my synth at the moment in SM! that is why your one is pretty attractive to me at the moment. dont take that as an innuendo.

the multi lfo is a great lfo, it is from ensemble monosynth shematic.osm which is in mono, it is made of lots and lots of modules and i didnt manage to plug in the cpu cycle meter so i cant say how much it uses. it will take a while to go though its innards.

I ment this one. For some reason I dont have the notes telling who made this so please, if someone recognizes this let us know so we can give credits.

infuzion ·

aliasant wrote: I meant this one. For some reason I don't have the notes telling who made this so please, if someone recognizes this let us know so we can give credits.

Why the Damping Lowpass Filter after the LFO please?

aliasant ·

infuzion wrote: aliasant wrote: I meant this one. For some reason I don't have the notes telling who made this so please, if someone recognizes this let us know so we can give credits.

Why the Damping Lowpass Filter after the LFO please?

Mainly to smoothen the signal since the LFO is ( this version anyways) hoped. If it is indeed ment as an LFO it can probably be hoped a lot more and then any artifacts filtered with the "damping filter" I dont think hoping it more would save that much but if someone is to use 10 packedx4 to get 40 LFos ther might be a little something to save.

The filter's also nice to smoothen the lfo a bit. 😀

trogluddite ·

🙂 Nice Think the SM 'Multi-LFO' might be visiting the recycle bin soon...

datsound ·

oh, very nice! what an excellent lfo. it's amazing. what can i say. super dooper. wowo. omg!

MichaelBenjamin ·

yes, yes its mine, bow down all, because i invented this, struck by some spark of the pure mystical genius thats embedded in all the inner things of being. credit me and drown me in free stuff untill i beg you to stop. ok stop please.

btw theres 2 variables FM0P5, obviously it needs only one, and then there is the rampfix variable i cant remember, did you add this? maybe i screwed up the ramp part when it resets, because when i tried to use it as an oscillator it was awkwardly out of tune at the higher octaves.

movaps xmm0,ramp; movaps xmm2,reset; movaps xmm1,xmm0; movaps xmm4,freq; addps xmm0,xmm4; cmpps xmm1,xmm6,1; andps xmm0,xmm1; cmpps xmm2,xmm7,0; andps xmm2,xmm0; movaps ramp,xmm2;

i guess cmpps 1 is <, so that would be ramp=(ramp+freq)&(ramp<1);

which i think isnt quite right and maybe it resets one sample too late/too early so the ramp gets more and more screwed the smaller its cycle is.

exonerate ·

MichaelBenjamin wrote: yes, yes its mine, bow down all, because i invented this, struck by some spark of the pure mystical genius thats embedded in all the inner things of being. credit me and drown me in free stuff untill i beg you to stop. ok stop please.

btw theres 2 variables FM0P5, obviously it needs only one, and then there is the rampfix variable i cant remember, did you add this? maybe i screwed up the ramp part when it resets, because when i tried to use it as an oscillator it was awkwardly out of tune at the higher octaves.

movaps xmm0,ramp; movaps xmm2,reset; movaps xmm1,xmm0; movaps xmm4,freq; addps xmm0,xmm4; cmpps xmm1,xmm6,1; andps xmm0,xmm1; cmpps xmm2,xmm7,0; andps xmm2,xmm0; movaps ramp,xmm2;

i guess cmpps 1 is <, so that would be ramp=(ramp+freq)&(ramp<1);

which i think isnt quite right and maybe it resets one sample too late/too early so the ramp gets more and more screwed the smaller its cycle is.

The ramp shouldn't be reset to zero. This causes the ramp top go out of tune.

The correct way to write a ramp is

ramp = ramp+freq; ramp = ramp-(ramp>=1)&1;

Cheers 😉

Exo

MichaelBenjamin ·

thank you. i guess for the lfo the cheap ramp is sufficient for most things where you dont hold the note for minutes. maybe i (or someone else) will add the correct ramp as an option where precision is needed.

exonerate ·

Fixed the ramp 🙂

MichaelBenjamin ·

thanks, do you like to add it to the dev toolkit at this state?

Wrote something here? To have a post removed or your name hidden, write to [email protected].

Before your first post

A few rules keep this a friendly place. You agree to them once.

Shown next to what you post, here and in the app. It doesn’t have to be your real name: 3–24 lower-case letters, digits or _ (capitals become lower case, spaces become _).

    Then your post goes up straight away.

    Delete this reply?

    Open it in SynthMaker?

    It goes on the track you’re editing there, in place of that track’s sound, and into My sounds. Your other tracks stay as they are.

    Want to keep that track’s sound? Start a new song in SynthMaker first (Song › New song), then open this.

    Report this reply?

    Only the developer reads reports. The person isn’t told who reported them.

    What’s wrong with it?

    Block this person?

    You won’t see their posts and replies here any more. They aren’t told, and you can unblock them at any time.

    People you’ve blocked

    Their posts and replies are hidden from you. Unblock someone to see them again.

    The community rules

    A few rules keep this a friendly place. Everyone agrees to them once, before their first post.