MetaOscil.h

/*
 * MetaOscil.h
 *
 * A wrap-up to swap between different oscillators seemlessly, allowing to produce non-aliased sounds by automatically switching between oscillators.
 *
 * This file is part of Mozzi.
 *
 * Copyright 2021-2024 T. Combriat and the Mozzi Team
 *
 * Mozzi is licensed under the GNU Lesser General Public Licence (LGPL) Version 2.1 or later.
 *
 */
 
 
#ifndef META_OSCIL_H
#define META_OSCIL_H
 
 
#include <Arduino.h>
 
#include "Oscil.h"
#include "mozzi_fixmath.h"
#include <FixMath.h>
 
 
template<uint16_t NUM_TABLE_CELLS, uint16_t UPDATE_RATE, byte N_OSCIL>
  class MetaOscil
  
{
 public:
  template<class... T>  MetaOscil(Oscil<NUM_TABLE_CELLS, UPDATE_RATE>* first, T*... elements):oscillators{first, elements...} {
    current_osc=oscillators[0];};
 
  MetaOscil(){};
  
  /* Add one oscil to the MetaOscil.
      @param osc is a pointer toward an Oscil
      @param cutoff_freq is the cutoff frequency of this Oscil 
  void addOscil(Oscil<NUM_TABLE_CELLS, UPDATE_RATE>* osc, int cutoff_freq)
  {
    oscillators[current_rank] = osc;
    cutoff_freqs[current_rank] = cutoff_freq;
    if (current_rank == 0) current_osc=oscillators[0];
    current_rank += 1;
  }*/
 
 
  template<typename ... T >  void setOscils(Oscil<NUM_TABLE_CELLS, UPDATE_RATE>* first,T... elements)
    {
      oscillators[current_rank]=first;
      if (current_rank == 0) current_osc=oscillators[0];
      current_rank+=1;
      setOscils(elements...);
      current_rank = 0;
    }
 
  void setOscils(){};
 
  
  template<typename ... T >  void setCutoffFreqs(int first,T... elements)
    {
      cutoff_freqs[current_rank]=first;
      current_rank+=1;
      setCutoffFreqs(elements...);
      current_rank = 0;
    }
 
  void setCutoffFreqs() {};
 
  void setCutoffFreq(int freq, byte rank)
  {
    cutoff_freqs[rank] = freq;
  }
  
  inline
    int8_t next() {return current_osc->next();}
 
  void setTable(const int8_t * TABLE_NAME, byte rank) {oscillators[rank]->setTable(TABLE_NAME);}
 
  
  void setPhase(unsigned int phase) {current_osc->setPhase(phase);}
 
 
  void setPhaseFractional(unsigned long phase) {current_osc->setPhaseFractional(phase);}
 
 
  unsigned long getPhaseFractional() {return current_osc->getPhaseFractional();}
 
 
  
  inline
    int8_t phMod(Q15n16 phmod_proportion) {return current_osc->phMod(phmod_proportion);}
 
 
  inline
    void setFreq(int frequency, bool apply = true)
  {
    if (frequency < cutoff_freqs[0])  //getting out the extreme cases
      {
    oscillators[0]->setPhaseFractional(current_osc->getPhaseFractional());
    current_osc = oscillators[0];
    current_osc->setFreq(frequency);
      }
    
    else if (frequency > cutoff_freqs[N_OSCIL-1])
      {     
    oscillators[N_OSCIL-1]->setPhaseFractional(current_osc->getPhaseFractional());
    current_osc = oscillators[N_OSCIL-1];
    current_osc->setFreq(frequency);      
      }
    else  // dichotomic search
      {
    byte low_point = 0, high_point = N_OSCIL-1, mid_point = (N_OSCIL-1)>>1;
    while(low_point != high_point)
      {
        if (frequency > cutoff_freqs[mid_point]) low_point = mid_point+1;
        else if (frequency < cutoff_freqs[mid_point]) high_point = mid_point;
        else
          {
        break;
          }
        mid_point = (low_point + high_point)>>1;
      }
    oscillators[mid_point]->setPhaseFractional(current_osc->getPhaseFractional());
    current_osc = oscillators[mid_point];
    if (apply) current_osc->setFreq(frequency);      
      }
      
  }
 
 
  inline
    void setFreq(float frequency)
  {
    setFreq((int) frequency, false);
    current_osc->setFreq(frequency);    
  }
  
 
  template <int8_t NI, int8_t NF, uint64_t RANGE>
  inline
    void setFreq(UFix<NI,NF,RANGE> frequency)
  {
    setFreq(frequency.asInt(), false);
    current_osc->setFreq(frequency);
  }
  
 
 
  inline
    void setFreq_Q24n8(Q24n8 frequency)
  {
    setFreq((int) (frequency>>8), false);
    current_osc->setFreq_Q24n8(frequency);
  }
    
 
  
  inline
    void setFreq_Q16n16(Q16n16 frequency)
  {
    setFreq((int) (frequency>>16), false);
    current_osc->setFreq_Q16n16(frequency);
  }
 
 
  inline
    int8_t atIndex(unsigned int index) {return current_osc->atIndex(index);}
 
 
  inline
    unsigned long phaseIncFromFreq(int frequency) {return current_osc->phaseIncFromFreq(frequency);}
 
  inline
    void setPhaseInc(unsigned long phaseinc_fractional) {current_osc->setPhaseInc(phaseinc_fractional);}
 
    
 
 private:
  Oscil<NUM_TABLE_CELLS, UPDATE_RATE> * oscillators[N_OSCIL];
  Oscil<NUM_TABLE_CELLS, UPDATE_RATE> * current_osc = NULL;
  int cutoff_freqs[N_OSCIL];
  byte current_rank = 0;
  
};
 
#endif  /* META_OSCIL_H */