p5.js Web Editor | Kurumi FM Wavetable builder

xxxxxxxxxx
// Calculates phase depending on Macro.
function getPhase(op)
{
  if(op.customPhase)
    return ((op.custPhaseEnv[clamp(macro, 0, op.custPhaseEnv.length-1)]/macLen-1) * op.phaseRev * op.detune * op.phaseMod)
  return ((macro/(macLen-1)) * op.phaseRev * op.detune * op.phaseMod)
}
​
// Calculates feedback
function getFB(op)
{
  return op.fb * (op.prev / (6 * op.mult));
}
​
// var modMode = 3;
​
function modulate(x, op1, op2, prevRes = 0)
{
  var output = 0
  switch(op1.modMode)
    {
      case 0: // FM
        {
          var s1 = waves[op1.waveform](x + prevRes + getFB(op1), op1) * getVolume(op1);
          var s2 = waves[op2.waveform](x + s1 + getFB(op2), op2) * getVolume(op2);
          op1.prev = s1
          op2.prev = s2
          
          output = s2
          break;
        }
      case 1: // OR
        {
          var s1 = waves[op1.waveform](x + getFB(op1), op1) * getVolume(op1);
          var s2 = waves[op2.waveform](x + getFB(op2), op2) * getVolume(op2);
          op1.prev = s1
          op2.prev = s2
          
          s1 = Math.round((s1+1) * 127.5)
          s2 = Math.round((s2+1) * 127.5)
          
          output = s1 | s2
          output = (output / 127.5)-1
          break;
        }
      case 2: // XOR
        {
          var s1 = waves[op1.waveform](x + getFB(op1), op1) * getVolume(op1);
          var s2 = waves[op2.waveform](x + getFB(op2), op2) * getVolume(op2);
          op1.prev = s1
          op2.prev = s2
          
          s1 = Math.round((s1+1) * 127.5)
          s2 = Math.round((s2+1) * 127.5)
          
          output = s1 ^ s2
          output = (output / 127.5)-1
          break;
        }
      case 3: // AND
        {
          var s1 = waves[op1.waveform](x + getFB(op1), op1) * getVolume(op1);
          var s2 = waves[op2.waveform](x + getFB(op2), op2) * getVolume(op2);
          op1.prev = s1
          op2.prev = s2
          
          s1 = Math.round((s1+1) * 127.5)
          s2 = Math.round((s2+1) * 127.5)
          
          output = s1 & s2
          output = (output / 127.5)-1
          break;
        }
      case 4: // NAND
        {
          var s1 = waves[op1.waveform](x + getFB(op1), op1) * getVolume(op1);
          var s2 = waves[op2.waveform](x + getFB(op2), op2) * getVolume(op2);
          op1.prev = s1
          op2.prev = s2
          
          s1 = Math.round((s1+1) * 127.5)
          s2 = Math.round((s2+1) * 127.5)
          
          output = ~(s1 & s2)
          output = (output / 127.5)-1
          break;
        }
      case 5: // ADD
        {
          var s1 = waves[op1.waveform](x + getFB(op1), op1) * getVolume(op1);
          var s2 = waves[op2.waveform](x + getFB(op2), op2) * getVolume(op2);
          op1.prev = s1
          op2.prev = s2
          
          output = s1 + s2
          // output = (output / 127.5)
          break;
        }
      case 6: // SUB
        {
          var s1 = waves[op1.waveform](x + getFB(op1), op1) * getVolume(op1);
          var s2 = waves[op2.waveform](x + getFB(op2), op2) * getVolume(op2);
          op1.prev = s1
          op2.prev = s2
          
          output = s2 - s1
          // output = (output / 127.5)
          break;
        }
      case 7: // MUL
        {
          var s1 = waves[op1.waveform](x + getFB(op1), op1) * getVolume(op1);
          var s2 = waves[op2.waveform](x + getFB(op2), op2) * getVolume(op2);
          op1.prev = s1
          op2.prev = s2
          
          output = s1 * s2
          // output = (output / 127.5)
          break;
        }
      case 8: // DIV
        {
          var s1 = waves[op1.waveform](x + getFB(op1), op1) * getVolume(op1);
          var s2 = waves[op2.waveform](x + getFB(op2), op2) * getVolume(op2);
          op1.prev = s1
          op2.prev = s2
          
          s1 = Math.round((s1) * 127.5)
          s2 = Math.round((s2) * 127.5)
          
          output = s2 != 0? s1 / s2 : 0
          output = (output / 127.5)
          break;
        }
    }
  return output
}
​
// Does FM operations
function fm(x)
{ 
  var s1, s2, s3, s4, sum;
  
  switch(algorithm)
    {
      case 0:
        {
          /* 
          ALG 0
          1 --> 2 --> 3 --> 4 --> Out
          */
          
​
          s1 = waves[operators[0].waveform](x + getFB(operators[0]), operators[0]) * getVolume(operators[0]);
          operators[0].prev = s1
          s2 = waves[operators[1].waveform](x + s1 + getFB(operators[1]), operators[1]) * getVolume(operators[1]);
          operators[1].prev = s2
          s3 = waves[operators[2].waveform](x + s2 + getFB(operators[2]), operators[2]) * getVolume(operators[2]);
          operators[2].prev = s3;
          s4 = waves[operators[3].waveform](x + s3 + getFB(operators[3]), operators[3]) * getVolume(operators[3]);
          operators[3].prev = s4;
          
          // var e = modulate(x, operators[0], operators[1])
          // var f = modulate(x, operators[2], operators[3], e)
          
          // console.log("S4 = " + s4)
          // console.log("f = " + f)
          
          return Math.round((s4 + 1) * heigth/2)
          break;
        }
      case 1:
        {
          /*
           ALG 1
           1-+
             |--> 3 --> 4 --> Out
           2-+
          */
          
          s1 = waves[operators[0].waveform](x + getFB(operators[0]), operators[0]) * getVolume(operators[0]);
          operators[0].prev = s1;
          s2 = waves[operators[1].waveform](x + getFB(operators[1]), operators[1]) * getVolume(operators[1]);
          operators[1].prev = s2;
          
          sum = s1 + s2;
          
          s3 = waves[operators[2].waveform](x + sum + getFB(operators[2]), operators[2]) * getVolume(operators[2]);
          operators[2].prev = s3;
          s4 = waves[operators[3].waveform](x + s3 + getFB(operators[3]), operators[3]) * getVolume(operators[3]);
          operators[3].prev = s4;
          
          return Math.round((s4 + 1) * heigth/2);
          break;
        }
      case 2:
        {
          /*
          ALG2
                1 -+
                   |--> 4 --> Out
          2 --> 3 -+
          */
          
          s1 = waves[operators[0].waveform](x + getFB(operators[0]), operators[0]) * getVolume(operators[0]);
          operators[0].prev = s1;
          s2 = waves[operators[1].waveform](x + getFB(operators[1]), operators[1]) * getVolume(operators[1]);
          operators[1].prev = s2;
          s3 = waves[operators[2].waveform](x + s2 + getFB(operators[2]), operators[2]) * getVolume(operators[2]);
          operators[2].prev = s3;
          
          sum = s1 + s3;
          
          s4 = waves[operators[3].waveform](x + sum + getFB(operators[3]), operators[3]) * getVolume(operators[3]);
          operators[3].prev = s4;
          
          return Math.round((s4 + 1) * heigth/2);
          break;
        }
      case 3:
        {
          /*
          ALG3
          1 --> 2 -+
                   |--> Out
          3 --> 4 -+
          */
          
          var s1 = waves[operators[0].waveform](x + getFB(operators[0]), operators[0]) * getVolume(operators[0]);
          operators[0].prev = s1;
          var s2 = waves[operators[1].waveform](x + s1 + getFB(operators[1]), operators[1]) * getVolume(operators[1]);
          operators[1].prev = s2;
          
          var s3 = waves[operators[2].waveform](x + getFB(operators[2]), operators[2]) * getVolume(operators[2]);
          operators[2].prev = s3;
          var s4 = waves[operators[3].waveform](x + s3 + getFB(operators[3]), operators[3]) * getVolume(operators[3]);
          operators[3].prev = s4;
            
          sum = s2 + s4;
          
          return Math.round((sum + 1) * heigth/2);
          break;
        }
      case 4:
        {
          /*
          ALG4
            +--> 2 --+
            |        |
          1-+--> 3 --+--> Out
            |        |
            +--> 4 --+
          */
          
          s1 = waves[operators[0].waveform](x + getFB(operators[0]), operators[0]) * getVolume(operators[0]);
          operators[0].prev = s1
          s2 = waves[operators[1].waveform](x + s1 + getFB(operators[1]), operators[1]) * getVolume(operators[1]);
          operators[1].prev = s2;
          
          s3 = waves[operators[2].waveform](x + s1 + getFB(operators[2]), operators[2]) * getVolume(operators[2]);
          operators[2].prev = s3;
          
          s4 = waves[operators[3].waveform](x + s1 + getFB(operators[3]), operators[3]) * getVolume(operators[3]);
          operators[3].prev = s4;
          
          sum = s2 + s3 + s4;
​
          return Math.round((sum + 1) * heigth/2);
          break;
        }
      case 5:
        {
          /*
          ALG5
          1 --> 2 --+
                    |
                3 --+--> Out
                    |
                4 --+ 
          */
          
          s1 = waves[operators[0].waveform](x + getFB(operators[0]), operators[0]) * getVolume(operators[0]);
          operators[0].prev = s1;
          s2 = waves[operators[1].waveform](x + s1 + getFB(operators[1]), operators[1]) * getVolume(operators[1]);
          operators[1].prev = s2;
          
          
          s3 = waves[operators[2].waveform](x + getFB(operators[2]), operators[2]) * getVolume(operators[2]);
          operators[2].prev = s3;
          
          s4 = waves[operators[3].waveform](x + getFB(operators[3]), operators[3]) * getVolume(operators[3]);
          operators[3].prev = s4;
          
          sum = s2 + s3 + s4;
          
          return Math.round((sum + 1) * heigth/2);
          break;
        }
      case 6:
        {
          /*
          ALG6
          1 -+
             |
          2 -+
             |--> Out
          3 -+
             |
          4 -+
          */
          
          s1 = waves[operators[0].waveform](x + getFB(operators[0]), operators[0]) * getVolume(operators[0]);
          operators[0].prev = s1;
          
          s2 = waves[operators[1].waveform](x + getFB(operators[1]), operators[1]) * getVolume(operators[1]);
          operators[1].prev = s2;
          
          s3 = waves[operators[2].waveform](x + getFB(operators[2]), operators[2]) * getVolume(operators[2]);
          operators[2].prev = s3;
          
          // output = math.sin(math.pi*(accumulator + feedback*output)
          // prev starts at 0;
          s4 = waves[operators[3].waveform](x + getFB(operators[3]), operators[3]) * getVolume(operators[3]);
          operators[3].prev = s4;
          
          sum = s1 + s2 + s3 + s4;
          return Math.round((sum + 1) * heigth/2);
          break;
        }
      case 7:
        {
          /*
          ALG7
               +-> 2 -+
            1 -|      |-> 4 --> Out
               +-> 3 -+
          */
          
          s1 = waves[operators[0].waveform](x + getFB(operators[0]), operators[0]) * getVolume(operators[0]);
          operators[0].prev = s1;
          s2 = waves[operators[1].waveform](x + s1 + getFB(operators[1]), operators[1]) * getVolume(operators[1]);
          operators[1].prev = s2;
          s3 = waves[operators[2].waveform](x + s1 + getFB(operators[2]), operators[2]) * getVolume(operators[2]);
          operators[2].prev = s3;
          
          sum = s2 + s3
          
          s4 = waves[operators[3].waveform](x + sum + getFB(operators[3]), operators[3]) * getVolume(operators[3]);
          operators[3].prev = s4;
          
          return Math.round((s4 + 1) * heigth/2);
          break;
        }
      case 8:
        {
          /*
          ALG8
                     +-> 3 -+
            1 --> 2 -|      |--> Out
                     +-> 4 -+
          */
          
          s1 = waves[operators[0].waveform](x + getFB(operators[0]), operators[0]) * getVolume(operators[0]);
          operators[0].prev = s1;
          s2 = waves[operators[1].waveform](x + s1 + getFB(operators[1]), operators[1]) * getVolume(operators[1]);
          operators[1].prev = s2;
          s3 = waves[operators[2].waveform](x + s2 + getFB(operators[2]), operators[2]) * getVolume(operators[2]);
          operators[2].prev = s3;
          s4 = waves[operators[3].waveform](x + s2 + getFB(operators[3]), operators[3]) * getVolume(operators[3]);
          operators[3].prev = s4;
          
          sum = s3 + s4;
          
          return Math.round((sum + 1) * heigth/2);
          break;
        }
      case 9:
        {
          /*
          ALG 9
            1 --> 2 --> 3 -+
                           |--> Out
                        4 -+
          */
          
          s1 = waves[operators[0].waveform](x + getFB(operators[0]), operators[0]) * getVolume(operators[0]);
          operators[0].prev = s1;
          s2 = waves[operators[1].waveform](x + s1 + getFB(operators[1]), operators[1]) * getVolume(operators[1]);
          operators[1].prev = s2;
          s3 = waves[operators[2].waveform](x + s2 + getFB(operators[2]), operators[2]) * getVolume(operators[2]);
          operators[2].prev = s3;
          s4 = waves[operators[3].waveform](x + getFB(operators[3]), operators[3]) * getVolume(operators[3]);
          operators[3].prev = s4;
          
          sum = s3 + s4;
          
          //console.log(s3)
          
          return Math.round((sum + 1) * heigth/2);
          break;
        }
      case 10:
        {
          /*
          ALG A
                +-> 2 -+
            1 --|      |
                +-> 3 -+--> Out
                       |
                    4 -+ 
          */
          
          s1 = waves[operators[0].waveform](x + getFB(operators[0]), operators[0]) * getVolume(operators[0]);
          operators[0].prev = s1;
          s2 = waves[operators[1].waveform](x + s1 + getFB(operators[1]), operators[1]) * getVolume(operators[1]);
          operators[1].prev = s2;
          s3 = waves[operators[2].waveform](x + s1 + getFB(operators[2]), operators[2]) * getVolume(operators[2]);
          operators[2].prev = s3;
          s4 = waves[operators[3].waveform](x + getFB(operators[3]), operators[3]) * getVolume(operators[3]);
          operators[3].prev = s4;
          
          sum = s2 + s3 + s4
          return Math.round((sum + 1) * heigth/2);
          break;
        }
      case 11:
        {
          /*
          ALG B
            1 --+
                |
            2 --+-4-> Out
                |
            3 --+
          */
          
          s1 = waves[operators[0].waveform](x + getFB(operators[0]), operators[0]) * getVolume(operators[0]);
          operators[0].prev = s1;
          
          s2 = waves[operators[1].waveform](x + getFB(operators[1]), operators[1]) * getVolume(operators[1]);
          operators[1].prev = s2;
          
          s3 = waves[operators[2].waveform](x + getFB(operators[2]), operators[2]) * getVolume(operators[2]);
          operators[2].prev = s3;
          
          sum = s1 + s2 + s3
          
          s4 = waves[operators[3].waveform](x + sum + getFB(operators[3]), operators[3]) * getVolume(operators[3]);
          operators[3].prev = s4;
          
          return Math.round((s4 + 1) * heigth/2);
          break;
        }
    }
}
Cookies

Sketch Files

Console

Preview
