okay i think i figured this out way more early than i thought 
The sincInterpolate function took me some night shifts to debug because of one implicit cast to int which i have overlooked and a memory corruption bug.
I have implemented the wavetable oscillator from scratch based on my initial SC implementation with sinc interpolation and mipmapping studying the chapter in the GO book once more, the Supercollider API and BufRd sourcecode for LOOP_BODY and investigating the OscOS and some additional AI help. There is some syntax in there which im currently not fully understanding, but its nice to have a moment of success beside my ongoing c++ course. The code is already quite clean in my opinion and its working as intended. Next is the oversampling implementation and then cross modulation PM. Im so happy
Here is the Utils.hpp with all the utilities needed, then you have everything external from the next function in the main cpp file:
#pragma once
#include "SC_PlugIn.hpp"
#include "wavetables.h"
namespace Utils {
// ===== BASIC MATH UTILITIES =====
inline float lerp(float a, float b, float t) {
return a * (1.0f - t) + b * t;
}
// ===== PHASE PROCESSING UTILITIES =====
struct RampToSlope {
float m_lastPhase{0.0f};
void reset(float currentPhase) {
m_lastPhase = currentPhase;
}
float process(float currentPhase) {
float delta = currentPhase - m_lastPhase;
m_lastPhase = currentPhase;
return sc_wrap(delta, -0.5f, 0.5f);
}
};
// ===== BUFFER INTERPOLATION UTILITIES =====
inline float peekNoInterp(const float* buffer, int bufSize, int index) {
const int wrappedIndex = sc_wrap(index, 0, bufSize - 1);
return buffer[wrappedIndex];
}
inline float peekLinearInterp(const float* buffer, int bufSize, float phase) {
const float sampleIndex = phase;
const int intPart = static_cast<int>(sampleIndex);
const float fracPart = sampleIndex - intPart;
const int idx1 = sc_wrap(intPart, 0, bufSize - 1);
const int idx2 = sc_wrap(intPart + 1, 0, bufSize - 1);
const float a = buffer[idx1];
const float b = buffer[idx2];
return lerp(a, b, fracPart);
}
inline float peekCubicInterp(const float* buffer, int bufSize, float phase) {
const float sampleIndex = phase;
const int intPart = static_cast<int>(sampleIndex);
const float fracPart = sampleIndex - intPart;
const int idx0 = sc_wrap(intPart - 1, 0, bufSize - 1);
const int idx1 = sc_wrap(intPart, 0, bufSize - 1);
const int idx2 = sc_wrap(intPart + 1, 0, bufSize - 1);
const int idx3 = sc_wrap(intPart + 2, 0, bufSize - 1);
const float a = buffer[idx0];
const float b = buffer[idx1];
const float c = buffer[idx2];
const float d = buffer[idx3];
return cubicinterp(fracPart, a, b, c, d);
}
// ===== SINC INTERPOLATION UTILITIES =====
struct SincTable {
static constexpr int TABLE_SIZE = 8192;
static constexpr int SINC_LEN = 8;
static constexpr int SINC_HALF_LEN = 4;
std::array<float, TABLE_SIZE> table;
SincTable() {
// Load table and convert in constructor
auto doubleTable = get_sinc_window8();
for (int i = 0; i < TABLE_SIZE; ++i) {
table[i] = static_cast<float>(doubleTable[i]);
}
}
const float* data() const { return table.data(); }
constexpr int size() const { return TABLE_SIZE; }
constexpr int sincLen() const { return SINC_LEN; }
constexpr int sincHalfLen() const { return SINC_HALF_LEN; }
};
// Sinc interpolation function using the sinc table
inline float sincInterpolate(float scaledPhase, const float* buffer, int bufSize, int startPos, int endPos, int sampleSpacing, const SincTable& sincTable) {
const float sampleIndex = scaledPhase / static_cast<float>(sampleSpacing);
const int intPart = static_cast<int>(sampleIndex);
const float fracPart = sampleIndex - static_cast<float>(intPart);
float result = 0.0f;
for (int i = 0; i < sincTable.sincLen(); ++i) {
// === WAVEFORM BUFFER ACCESS (no interpolation) ===
int waveIndex = startPos + (intPart + (i - sincTable.sincHalfLen())) * sampleSpacing;
waveIndex = sc_wrap(waveIndex, startPos, endPos);
float waveSample = peekNoInterp(buffer, bufSize, waveIndex);
// === SINC TABLE ACCESS (cubic interpolation) ===
float sincPhase = (static_cast<float>(i) - fracPart) / static_cast<float>(sincTable.sincLen()) * static_cast<float>(sincTable.size());
float sincSample = peekCubicInterp(sincTable.data(), sincTable.size(), sincPhase);
result += waveSample * sincSample;
}
return result;
}
// ===== MIPMAP UTILITIES =====
inline float mipmapInterpolate(float phase, const float* buffer, int bufSize, int startPos, int endPos, float slope, const SincTable& sincTable) {
// Calculate mipmap parameters
const float rangeSize = static_cast<float>(endPos - startPos);
float samplesPerFrame = std::abs(slope) * rangeSize;
float octave = std::max(0.0f, std::log2(samplesPerFrame));
int layer = static_cast<int>(std::ceil(octave));
// Calculate spacings for adjacent mipmap levels
int spacing1 = static_cast<int>(std::pow(2, layer));
int spacing2 = static_cast<int>(std::pow(2, layer + 1));
// Pre-scale phase by range size
const float scaledPhase = phase * rangeSize;
// Get interpolated signals within the specified range
float sig1 = sincInterpolate(scaledPhase, buffer, bufSize, startPos, endPos, spacing1, sincTable);
float sig2 = sincInterpolate(scaledPhase, buffer, bufSize, startPos, endPos, spacing2, sincTable);
// Crossfade between the two interpolated signals
return lerp(sig1, sig2, sc_wrap(octave, 0.0f, 1.0f));
}
// ===== MULTI-CYCLE WAVETABLE UTILITIES =====
inline float wavetableInterpolate(float phase, const float* buffer, int bufSize, int numCycles, float cyclePos, RampToSlope& rampToSlope, const SincTable& sincTable) {
// Calculate slope
float slope = rampToSlope.process(phase);
// Calculate cycle parameters
const int cycleSamples = bufSize / numCycles;
// GO book approach: wrap cyclePos to 0-1, then scale by numCycles
//const float wrappedPos = sc_wrap(cyclePos, 0.0f, 1.0f);
//const float scaledPos = wrappedPos * static_cast<float>(numCycles);
// OscOS approach: clip cyclePos to 0-1, then scale by (numCycles - 1)
const float clippedPos = sc_clip(cyclePos, 0.0f, 1.0f);
const float scaledPos = clippedPos * static_cast<float>(numCycles - 1);
const int intPart = static_cast<int>(scaledPos);
const float fracPart = scaledPos - static_cast<float>(intPart);
// Calculate cycle indices
const int cycleIndex1 = intPart % numCycles;
const int cycleIndex2 = (intPart + 1) % numCycles;
// Calculate start/end positions for each cycle
const int startPos1 = cycleIndex1 * cycleSamples;
const int endPos1 = startPos1 + cycleSamples;
const int startPos2 = cycleIndex2 * cycleSamples;
const int endPos2 = startPos2 + cycleSamples;
// Process each cycle
float output1 = mipmapInterpolate(phase, buffer, bufSize, startPos1, endPos1, slope, sincTable);
float output2 = mipmapInterpolate(phase, buffer, bufSize, startPos2, endPos2, slope, sincTable);
// Crossfade between the two cycles
return lerp(output1, output2, fracPart);
}
} // namespace Utils
