Function bodies 1,902 total

stepTrack method · cpp · L257-L268 (12 LOC)

src/EuclideanRhythm.cpp

        
        void stepTrack() {
            cycleCompleted = false;
            currentStep = (currentStep + 1) % length;
            if (currentStep == 0) {
                cycleCompleted = true;
            }
            gateState = !pattern.empty() && pattern[currentStep];
            if (gateState) {
                trigPulse.trigger(0.01f);
            }
        }

reset method · cpp · L282-L289 (8 LOC)

src/EuclideanRhythm.cpp

        
        void reset() {
            currentTrackIndex = 0;
            globalClockCount = 0;
            for (int i = 0; i < 3; ++i) {
                trackStartClock[i] = 0;
            }
        }

calculateTrackCycleClock method · cpp · L290-L293 (4 LOC)

src/EuclideanRhythm.cpp

        
        int calculateTrackCycleClock(const TrackState& track) {
            return track.length * track.division / track.multiplication;
        }

processStep method · cpp · L294-L327 (34 LOC)

src/EuclideanRhythm.cpp

        
        float processStep(TrackState tracks[], float sampleTime, bool globalClockTriggered) {
            if (trackIndices.empty()) {
                return 0.0f;
            }
            
            if (globalClockTriggered) {
                globalClockCount++;
            }
            
            if (currentTrackIndex >= (int)trackIndices.size()) {
                currentTrackIndex = 0;
            }
            
            int activeTrackIdx = trackIndices[currentTrackIndex];
            if (activeTrackIdx < 0 || activeTrackIdx >= 3) {
                return 0.0f;
            }
            
            TrackState& activeTrack = tracks[activeTrackIdx];
            int trackCycleClock = calculateTrackCycleClock(activeTrack);
            int elapsedClock = globalClockCount - trackStartClock[activeTrackIdx];
            
            if (elapsedClock >= trackCycleClock) {
                currentTrackIndex++;
                if (currentTrackIndex >= (int)trackIndices.size()

EuclideanRhythm method · cpp · L330-L426 (97 LOC)

src/EuclideanRhythm.cpp

    EuclideanRhythm() {
        config(PARAMS_LEN, INPUTS_LEN, OUTPUTS_LEN, LIGHTS_LEN);
        
        configInput(GLOBAL_CLOCK_INPUT, "Global Clock");
        configInput(GLOBAL_RESET_INPUT, "Global Reset");
        configParam(MANUAL_RESET_PARAM, 0.0f, 1.0f, 0.0f, "Manual Reset");

        chain12.trackIndices = {0, 1};
        chain23.trackIndices = {1, 2};
        chain123.trackIndices = {0, 1, 0, 2};

        // Track 1 預設值
        configParam(TRACK1_DIVMULT_PARAM, -3.0f, 3.0f, 0.0f, "T1 Div/Mult");
        getParamQuantity(TRACK1_DIVMULT_PARAM)->snapEnabled = true;
        delete paramQuantities[TRACK1_DIVMULT_PARAM];
        paramQuantities[TRACK1_DIVMULT_PARAM] = new DivMultParamQuantity;
        paramQuantities[TRACK1_DIVMULT_PARAM]->module = this;
        paramQuantities[TRACK1_DIVMULT_PARAM]->paramId = TRACK1_DIVMULT_PARAM;
        paramQuantities[TRACK1_DIVMULT_PARAM]->minValue = -3.0f;
        paramQuantities[TRACK1_DIVMULT_PARAM]->maxValue = 3.0f;
        paramQuantit

onReset method · cpp · L427-L437 (11 LOC)

src/EuclideanRhythm.cpp

    void onReset() override {
        secondsSinceLastClock = -1.0f;
        globalClockSeconds = 0.5f;
        for (int i = 0; i < 3; ++i) {
            tracks[i].reset();
        }
        chain12.reset();
        chain23.reset();
        chain123.reset();
    }

dataToJson method · cpp · L438-L444 (7 LOC)

src/EuclideanRhythm.cpp

    json_t* dataToJson() override {
        json_t* rootJ = json_object();
        json_object_set_new(rootJ, "panelTheme", json_integer(panelTheme));
        json_object_set_new(rootJ, "panelContrast", json_real(panelContrast));
        return rootJ;
    }

Generated by Repobility's multi-pass static-analysis pipeline (https://repobility.com)

dataFromJson method · cpp · L445-L455 (11 LOC)

src/EuclideanRhythm.cpp

    void dataFromJson(json_t* rootJ) override {
        json_t* themeJ = json_object_get(rootJ, "panelTheme");
        if (themeJ) {
            panelTheme = json_integer_value(themeJ);
        }
        json_t* contrastJ = json_object_get(rootJ, "panelContrast");
        if (contrastJ) {
            panelContrast = json_real_value(contrastJ);
        }
    }

process method · cpp · L456-L596 (141 LOC)

src/EuclideanRhythm.cpp

    void process(const ProcessArgs& args) override {
        bool globalClockActive = inputs[GLOBAL_CLOCK_INPUT].isConnected();
        bool globalClockTriggered = false;
        bool globalResetTriggered = false;
        bool manualResetTriggered = false;
        
        if (globalClockActive) {
            float clockVoltage = inputs[GLOBAL_CLOCK_INPUT].getVoltage();
            globalClockTriggered = clockTrigger.process(clockVoltage);
        }
        
        if (inputs[GLOBAL_RESET_INPUT].isConnected()) {
            globalResetTriggered = resetTrigger.process(inputs[GLOBAL_RESET_INPUT].getVoltage());
        }
        
        manualResetTriggered = manualResetTrigger.process(params[MANUAL_RESET_PARAM].getValue());
        
        if (globalResetTriggered || manualResetTriggered) {
            onReset();
            return;
        }
        
        if (globalClockTriggered) {
            if (secondsSinceLastClock > 0.0f) {
                globalClockSeconds = secondsSinceL

EuclideanRhythmWidget method · cpp · L603-L690 (88 LOC)

src/EuclideanRhythm.cpp

    EuclideanRhythmWidget(EuclideanRhythm* module) {
        setModule(module);
        panelThemeHelper.init(this, "8HP", module ? &module->panelContrast : nullptr);
        
        box.size = Vec(8 * RACK_GRID_WIDTH, RACK_GRID_HEIGHT);

        addChild(new EnhancedTextLabel(Vec(0, 1), Vec(box.size.x, 20), "Euclidean Rhythm", 14.f, nvgRGB(255, 200, 0), true));
        addChild(new EnhancedTextLabel(Vec(0, 13), Vec(box.size.x, 20), "MADZINE", 10.f, nvgRGB(255, 200, 0), false));

        addChild(new EnhancedTextLabel(Vec(18, 34), Vec(30, 15), "CLK"));
        addInput(createInputCentered<PJ301MPort>(Vec(33, 56), module, EuclideanRhythm::GLOBAL_CLOCK_INPUT));

        addChild(new EnhancedTextLabel(Vec(62, 34), Vec(30, 15), "RST"));
        addInput(createInputCentered<PJ301MPort>(Vec(77, 56), module, EuclideanRhythm::GLOBAL_RESET_INPUT));

        addParam(createParamCentered<VCVButton>(Vec(100, 56), module, EuclideanRhythm::MANUAL_RESET_PARAM));

        float trackY[3] = {77, 159,

step method · cpp · L691-L713 (23 LOC)

src/EuclideanRhythm.cpp

    void step() override {
        EuclideanRhythm* module = dynamic_cast<EuclideanRhythm*>(this->module);
        if (module) {
            panelThemeHelper.step(module);

            // CV 調變顯示更新
            for (int track = 0; track < 3; track++) {
                for (int param = 0; param < 3; param++) {
                    if (knobs[track][param]) {
                        // param: 0=Length, 1=Fill, 2=Shift
                        int inputId = EuclideanRhythm::TRACK1_LENGTH_CV_INPUT + track * 3 + param;
                        bool connected = module->inputs[inputId].isConnected();
                        knobs[track][param]->setModulationEnabled(connected);
                        if (connected) {
                            knobs[track][param]->setModulation(module->cvMod[track][param]);
                        }
                    }
                }
            }
        }
        ModuleWidget::step();
    }

appendContextMenu method · cpp · L714-L720 (7 LOC)

src/EuclideanRhythm.cpp

    void appendContextMenu(ui::Menu* menu) override {
        EuclideanRhythm* module = dynamic_cast<EuclideanRhythm*>(this->module);
        if (!module) return;

        addPanelThemeMenu(menu, module);
    }

WhiteBackgroundBox method · cpp · L10-L13 (4 LOC)

src/Facehugger.cpp

    WhiteBackgroundBox(Vec pos, Vec size) {
        box.pos = pos;
        box.size = size;
    }

draw method · cpp · L14-L20 (7 LOC)

src/Facehugger.cpp

    void draw(const DrawArgs &args) override {
        nvgBeginPath(args.vg);
        nvgRect(args.vg, 0, 0, box.size.x, box.size.y);
        nvgFillColor(args.vg, nvgRGB(255, 255, 255));
        nvgFill(args.vg);
    }

BlackBackgroundBox method · cpp · L24-L27 (4 LOC)

src/Facehugger.cpp

    BlackBackgroundBox(Vec pos, Vec size) {
        box.pos = pos;
        box.size = size;
    }

Repobility (the analyzer behind this table) · https://repobility.com

draw method · cpp · L28-L38 (11 LOC)

src/Facehugger.cpp

    void draw(const DrawArgs &args) override {
        nvgBeginPath(args.vg);
        nvgRect(args.vg, 0, 0, box.size.x, box.size.y);
        nvgFillColor(args.vg, nvgRGB(10, 30, 20));
        nvgFill(args.vg);

        nvgStrokeWidth(args.vg, 1.0f);
        nvgStrokeColor(args.vg, nvgRGBA(100, 100, 100, 255));
        nvgStroke(args.vg);
    }

FacehuggerTitleLabel method · cpp · L46-L53 (8 LOC)

src/Facehugger.cpp

    FacehuggerTitleLabel(Vec pos, Vec size, std::string l1, std::string l2, std::string l3) {
        box.pos = pos;
        box.size = size;
        line1 = l1;
        line2 = l2;
        line3 = l3;
    }

draw method · cpp · L54-L75 (22 LOC)

src/Facehugger.cpp

    void draw(const DrawArgs &args) override {
        nvgFontFaceId(args.vg, APP->window->uiFont->handle);
        nvgTextAlign(args.vg, NVG_ALIGN_CENTER | NVG_ALIGN_MIDDLE);

        // Line 1: 模組名稱 (12pt 白色, 字元間距縮窄) - Y=11
        nvgFontSize(args.vg, 12.f);
        nvgTextLetterSpacing(args.vg, -1.0f);
        nvgFillColor(args.vg, nvgRGB(255, 255, 255));
        nvgText(args.vg, box.size.x / 2.f, 11.f, line1.c_str(), NULL);

        // Line 2: 品牌 (10pt 黃色) - Y=26
        nvgTextLetterSpacing(args.vg, 0.f);
        nvgFontSize(args.vg, 10.f);
        nvgFillColor(args.vg, nvgRGB(255, 200, 0));
        nvgText(args.vg, box.size.x / 2.f, 26.f, line3.c_str(), NULL);

        // Line 3: 效果類型 (7pt 外星螢光綠) - Y=33（MADZINE下方）
        nvgFontSize(args.vg, 7.f);
        nvgFillColor(args.vg, nvgRGB(57, 255, 20));
        nvgText(args.vg, box.size.x / 2.f, 33.f, line2.c_str(), NULL);
    }

draw method · cpp · L94-L111 (18 LOC)

src/Facehugger.cpp

    void draw(const DrawArgs &args) override {
        nvgFontSize(args.vg, fontSize);
        nvgFontFaceId(args.vg, APP->window->uiFont->handle);
        nvgTextAlign(args.vg, NVG_ALIGN_CENTER | NVG_ALIGN_MIDDLE);

        if (bold) {
            // 使用描邊模擬粗體效果
            nvgFillColor(args.vg, color);
            nvgText(args.vg, box.size.x / 2.f, box.size.y / 2.f, text.c_str(), NULL);
            nvgStrokeColor(args.vg, color);
            nvgStrokeWidth(args.vg, 0.3f);
            nvgText(args.vg, box.size.x / 2.f, box.size.y / 2.f, text.c_str(), NULL);
        } else {
            nvgFillColor(args.vg, color);
            nvgText(args.vg, box.size.x / 2.f, box.size.y / 2.f, text.c_str(), NULL);
        }
    }

Facehugger method · cpp · L169-L193 (25 LOC)

src/Facehugger.cpp

    Facehugger() {
        config(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS);

        configParam(SIZE_PARAM, 0.0f, 1.0f, 0.3f, "Size");
        configParam(BREAK_PARAM, 0.0f, 1.0f, 0.4f, "Break");
        configParam(SHIFT_PARAM, 0.0f, 1.0f, 0.5f, "Shift");
        configParam(MIX_PARAM, 0.0f, 1.0f, 0.5f, "Mix", "%", 0.f, 100.f);
        configParam(CHAOS_PARAM, 0.0f, 1.0f, 0.0f, "Chaos", "%", 0.f, 100.f);
        configParam(RATE_PARAM, 0.01f, 2.0f, 0.5f, "Rate", "x");

        configInput(LEFT_INPUT, "Left Audio");
        configInput(RIGHT_INPUT, "Right Audio");
        configInput(SIZE_CV_INPUT, "Size CV");
        configInput(BREAK_CV_INPUT, "Break CV");
        configInput(SHIFT_CV_INPUT, "Shift CV");
        configInput(MIX_CV_INPUT, "Mix CV");
        configInput(CHAOS_CV_INPUT, "Chaos CV");
        configInput(RATE_CV_INPUT, "Rate CV");

        configOutput(LEFT_OUTPUT, "Left Audio");
        configOutput(RIGHT_OUTPUT, "Right Audio");
        configOutput(CHAOS_OUTPU

onReset method · cpp · L194-L201 (8 LOC)

src/Facehugger.cpp

    void onReset() override {
        for (int c = 0; c < MAX_POLY; c++) {
            chaosGen[c].reset();
            leftGrainProcessor[c].reset();
            rightGrainProcessor[c].reset();
        }
    }

dataToJson method · cpp · L202-L208 (7 LOC)

src/Facehugger.cpp

    json_t* dataToJson() override {
        json_t* rootJ = json_object();
        json_object_set_new(rootJ, "panelTheme", json_integer(panelTheme));
        json_object_set_new(rootJ, "panelContrast", json_real(panelContrast));
        return rootJ;
    }

dataFromJson method · cpp · L209-L219 (11 LOC)

src/Facehugger.cpp

    void dataFromJson(json_t* rootJ) override {
        json_t* themeJ = json_object_get(rootJ, "panelTheme");
        if (themeJ) {
            panelTheme = json_integer_value(themeJ);
        }
        json_t* contrastJ = json_object_get(rootJ, "panelContrast");
        if (contrastJ) {
            panelContrast = json_real_value(contrastJ);
        }
    }

Citation: Repobility (2026). State of AI-Generated Code. https://repobility.com/research/

process method · cpp · L220-L354 (135 LOC)

src/Facehugger.cpp

    void process(const ProcessArgs& args) override {
        if (args.sampleRate <= 0) return;

        int leftChannels = inputs[LEFT_INPUT].getChannels();
        int rightChannels = inputs[RIGHT_INPUT].getChannels();
        int channels = std::max({1, leftChannels, rightChannels});

        outputs[LEFT_OUTPUT].setChannels(channels);
        outputs[RIGHT_OUTPUT].setChannels(channels);
        outputs[CHAOS_OUTPUT].setChannels(channels);
        outputs[SH_OUTPUT].setChannels(channels);

        float chaosAmountBase = params[CHAOS_PARAM].getValue();
        float chaosRateBase = params[RATE_PARAM].getValue();

        for (int c = 0; c < channels; c++) {
            // Chaos 參數 + CV
            float chaosAmount = chaosAmountBase;
            if (inputs[CHAOS_CV_INPUT].isConnected()) {
                float cv = inputs[CHAOS_CV_INPUT].getPolyVoltage(c < inputs[CHAOS_CV_INPUT].getChannels() ? c : 0);
                chaosAmount += cv * 0.1f;
                if (c == 0) chaosCvMod

processBypass method · cpp · L355-L373 (19 LOC)

src/Facehugger.cpp

    void processBypass(const ProcessArgs& args) override {
        int leftChannels = inputs[LEFT_INPUT].getChannels();
        int rightChannels = inputs[RIGHT_INPUT].getChannels();
        int channels = std::max({1, leftChannels, rightChannels});

        outputs[LEFT_OUTPUT].setChannels(channels);
        outputs[RIGHT_OUTPUT].setChannels(channels);

        for (int c = 0; c < channels; c++) {
            float leftInput = (c < leftChannels) ? inputs[LEFT_INPUT].getPolyVoltage(c) : 0.0f;
            float rightInput = inputs[RIGHT_INPUT].isConnected()
                ? ((c < rightChannels) ? inputs[RIGHT_INPUT].getPolyVoltage(c) : 0.0f)
                : leftInput;

            outputs[LEFT_OUTPUT].setVoltage(leftInput, c);
            outputs[RIGHT_OUTPUT].setVoltage(rightInput, c);
        }
    }

FacehuggerWidget method · cpp · L392-L475 (84 LOC)

src/Facehugger.cpp

    FacehuggerWidget(Facehugger* module) {
        setModule(module);
        panelThemeHelper.init(this, "4HP", module ? &module->panelContrast : nullptr);

        box.size = Vec(4 * RACK_GRID_WIDTH, RACK_GRID_HEIGHT);

        // 黑色標題背景
        addChild(new BlackBackgroundBox(Vec(0, 1), Vec(box.size.x, 18)));

        // 三行標題（壓縮高度，與標準模組對齊）
        addChild(new FacehuggerTitleLabel(Vec(0, 0), Vec(box.size.x, 30),
            "Facehugger", "the Gratch effect", "MADZINE"));

        float centerX = box.size.x / 2.0f;  // 30
        float leftX = 15.0f;
        float rightX = 45.0f;

        // Row 1: SIZE, BREAK (Y=72, 標籤 Y=48)
        addChild(new FacehuggerParamLabel(Vec(0, 48), Vec(30, 15), "SIZE"));
        sizeKnob = createParamCentered<StandardBlackKnob26>(Vec(leftX, 72), module, Facehugger::SIZE_PARAM);
        addParam(sizeKnob);

        addChild(new FacehuggerParamLabel(Vec(30, 48), Vec(30, 15), "BREAK"));
        breakKnob = createParamCentered<StandardBlackKnob26>(Vec(righ

step method · cpp · L476-L685 (210 LOC)

src/Facehugger.cpp

    void step() override {
        Facehugger* module = dynamic_cast<Facehugger*>(this->module);
        if (module) {
            panelThemeHelper.step(module);

            if (sizeKnob) {
                bool connected = module->inputs[Facehugger::SIZE_CV_INPUT].isConnected();
                sizeKnob->setModulationEnabled(connected);
                if (connected) sizeKnob->setModulation(module->sizeCvMod);
            }
            if (breakKnob) {
                bool connected = module->inputs[Facehugger::BREAK_CV_INPUT].isConnected();
                breakKnob->setModulationEnabled(connected);
                if (connected) breakKnob->setModulation(module->breakCvMod);
            }
            if (shiftKnob) {
                bool connected = module->inputs[Facehugger::SHIFT_CV_INPUT].isConnected();
                shiftKnob->setModulationEnabled(connected);
                if (connected) shiftKnob->setModulation(module->shiftCvMod);
            }
            if (mixKnob) {

appendContextMenu method · cpp · L686-L691 (6 LOC)

src/Facehugger.cpp

    void appendContextMenu(ui::Menu* menu) override {
        Facehugger* module = dynamic_cast<Facehugger*>(this->module);
        if (!module) return;
        addPanelThemeMenu(menu, module);
    }

KEN method · cpp · L62-L91 (30 LOC)

src/KEN.cpp

    KEN() {
        config(PARAMS_LEN, INPUTS_LEN, OUTPUTS_LEN, LIGHTS_LEN);
        
        configParam(LEVEL_PARAM, 0.f, 1.f, 0.7f, "Level", "%", 0.f, 100.f);

        configInput(INPUT_1, "1");
        configInput(INPUT_2, "2");
        configInput(INPUT_3, "3");
        configInput(INPUT_4, "4");
        configInput(INPUT_5, "5");
        configInput(INPUT_6, "6");
        configInput(INPUT_7, "7");
        configInput(INPUT_8, "8");

        configOutput(LEFT_OUTPUT, "Left");
        configOutput(RIGHT_OUTPUT, "Right");

        initializeHRTF();
        initializeDelays();
        initializeDistanceFilters();
        initializeElevationFilters();
        initializeReverbFilters();
        
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 2; j++) {
                smoothedGains[i][j] = hrtfGains[i][j];
            }
        }
    }

dataToJson method · cpp · L92-L98 (7 LOC)

src/KEN.cpp

    json_t* dataToJson() override {
        json_t* rootJ = json_object();
        json_object_set_new(rootJ, "panelTheme", json_integer(panelTheme));
        json_object_set_new(rootJ, "panelContrast", json_real(panelContrast));
        return rootJ;
    }

dataFromJson method · cpp · L99-L109 (11 LOC)

src/KEN.cpp

    void dataFromJson(json_t* rootJ) override {
        json_t* themeJ = json_object_get(rootJ, "panelTheme");
        if (themeJ) {
            panelTheme = json_integer_value(themeJ);
        }
        json_t* contrastJ = json_object_get(rootJ, "panelContrast");
        if (contrastJ) {
            panelContrast = json_real_value(contrastJ);
        }
    }

initializeHRTF method · cpp · L110-L119 (10 LOC)

src/KEN.cpp

    void initializeHRTF() {
        for (int i = 0; i < 8; i++) {
            float azimuth = speakers[i].azimuth * M_PI / 180.0f;
            float elevation = speakers[i].elevation * M_PI / 180.0f;
            
            hrtfGains[i][0] = calculateAdvancedHRTF(azimuth, elevation, 0, i);
            hrtfGains[i][1] = calculateAdvancedHRTF(azimuth, elevation, 1, i);
        }
    }

initializeDistanceFilters method · cpp · L120-L137 (18 LOC)

src/KEN.cpp

    void initializeDistanceFilters() {
        for (int i = 0; i < 8; i++) {
            for (int ear = 0; ear < 2; ear++) {
                float sampleRate = 44100.0f;
                float distance = speakers[i].distance;
                float cutoffFreq = 20000.0f / (1.0f + distance * 3.0f);
                cutoffFreq = clamp(cutoffFreq, 1000.0f, 20000.0f);
                
                distanceFilters[i][ear].setParameters(
                    dsp::TBiquadFilter<>::LOWPASS, 
                    cutoffFreq / sampleRate,
                    0.8f,
                    1.0f
                );
            }
        }
    }

initializeElevationFilters method · cpp · L138-L173 (36 LOC)

src/KEN.cpp

    void initializeElevationFilters() {
        for (int i = 0; i < 8; i++) {
            for (int ear = 0; ear < 2; ear++) {
                float sampleRate = 44100.0f;
                float elevation = speakers[i].elevation;
                
                float centerFreq, gain, q;
                if (elevation > 0) {
                    centerFreq = 8000.0f + elevation * 40.0f;
                    gain = 2.0f;
                    q = 1.5f;
                } else {
                    centerFreq = 7000.0f - abs(elevation) * 30.0f;
                    gain = 0.3f;
                    q = 2.0f;
                }
                
                if (elevation > 0) {
                    elevationFilters[i][ear].setParameters(
                        dsp::TBiquadFilter<>::PEAK,
                        centerFreq / sampleRate,
                        q,
                        gain
                    );
                } else {
                    elevationFilters[i][ear].setParameter

initializeReverbFilters method · cpp · L174-L191 (18 LOC)

src/KEN.cpp

    void initializeReverbFilters() {
        for (int i = 0; i < 8; i++) {
            for (int ear = 0; ear < 2; ear++) {
                float sampleRate = 44100.0f;
                float distance = speakers[i].distance;
                
                float reverbGain = 0.1f + distance * 0.4f;
                
                reverbFilters[i][ear].setParameters(
                    dsp::TBiquadFilter<>::HIGHPASS,
                    3000.0f / sampleRate,
                    0.7f,
                    reverbGain
                );
            }
        }
    }

initializeDelays method · cpp · L192-L219 (28 LOC)

src/KEN.cpp

    void initializeDelays() {
        float sampleRate = 44100.0f;
        float headWidth = 0.18f;
        float soundSpeed = 343.0f;
        
        for (int i = 0; i < 8; i++) {
            float azimuth = speakers[i].azimuth * M_PI / 180.0f;
            
            float itdSeconds = (headWidth / soundSpeed) * sin(azimuth);
            int itdSamples = (int)(itdSeconds * sampleRate);
            
            if (itdSamples > 0) {
                delaySamplesL[i] = itdSamples;
                delaySamplesR[i] = 0;
            } else {
                delaySamplesL[i] = 0;
                delaySamplesR[i] = -itdSamples;
            }
            
            delayPosL[i] = 0;
            delayPosR[i] = 0;
            for (int j = 0; j < 128; j++) {
                delayBufferL[i][j] = 0.0f;
                delayBufferR[i][j] = 0.0f;
            }
        }
    }

calculateAdvancedHRTF method · cpp · L220-L258 (39 LOC)

src/KEN.cpp

    float calculateAdvancedHRTF(float azimuth, float elevation, int ear, int speakerIndex) {
        float gain = 1.0f;
        
        float ildEffect = 1.0f;
        if (ear == 0) { 
            if (azimuth > 0) { 
                ildEffect = 1.0f - (azimuth / M_PI) * 0.8f;
            } else { 
                ildEffect = 1.0f + (-azimuth / M_PI) * 0.3f;
            }
        } else { 
            if (azimuth < 0) { 
                ildEffect = 1.0f - (-azimuth / M_PI) * 0.8f;
            } else { 
                ildEffect = 1.0f + (azimuth / M_PI) * 0.3f;
            }
        }
        
        float headShadowEffect = 1.0f;
        if (abs(azimuth) > M_PI / 2) { 
            headShadowEffect *= 0.6f;
        }
        
        float elevationEffect = 1.0f;
        if (elevation > 0) {
            elevationEffect = 1.0f + elevation * 0.8f;
        } else {
            elevationEffect = 0.7f - abs(elevation) * 0.4f;
        }
        
        float distance = speakers[speakerInd

processDelay method · cpp · L259-L276 (18 LOC)

src/KEN.cpp

    float processDelay(float input, int speaker, int ear) {
        float output;
        
        if (ear == 0) { 
            delayBufferL[speaker][delayPosL[speaker]] = input;
            int readPos = (delayPosL[speaker] - delaySamplesL[speaker] + 128) % 128;
            output = delayBufferL[speaker][readPos];
            delayPosL[speaker] = (delayPosL[speaker] + 1) % 128;
        } else { 
            delayBufferR[speaker][delayPosR[speaker]] = input;
            int readPos = (delayPosR[speaker] - delaySamplesR[speaker] + 128) % 128;
            output = delayBufferR[speaker][readPos];
            delayPosR[speaker] = (delayPosR[speaker] + 1) % 128;
        }
        
        return output;
    }

processDistanceFiltering method · cpp · L277-L280 (4 LOC)

src/KEN.cpp

    float processDistanceFiltering(float input, int speaker, int ear) {
        return distanceFilters[speaker][ear].process(input);
    }

Generated by Repobility's multi-pass static-analysis pipeline (https://repobility.com)

processElevationFiltering method · cpp · L281-L284 (4 LOC)

src/KEN.cpp

    float processElevationFiltering(float input, int speaker, int ear) {
        return elevationFilters[speaker][ear].process(input);
    }

processReverbFiltering method · cpp · L285-L288 (4 LOC)

src/KEN.cpp

    float processReverbFiltering(float input, int speaker, int ear) {
        return reverbFilters[speaker][ear].process(input);
    }

process method · cpp · L289-L328 (40 LOC)

src/KEN.cpp

    void process(const ProcessArgs& args) override {
        float level = params[LEVEL_PARAM].getValue();
        float leftOut = 0.0f;
        float rightOut = 0.0f;

        for (int i = 0; i < 8; i++) {
            if (inputs[INPUT_1 + i].isConnected()) {
                float input = inputs[INPUT_1 + i].getVoltage();
                
                float delayedLeft = processDelay(input, i, 0);
                float delayedRight = processDelay(input, i, 1);
                
                delayedLeft = processDistanceFiltering(delayedLeft, i, 0);
                delayedRight = processDistanceFiltering(delayedRight, i, 1);
                
                delayedLeft = processElevationFiltering(delayedLeft, i, 0);
                delayedRight = processElevationFiltering(delayedRight, i, 1);
                
                float reverbLeft = processReverbFiltering(delayedLeft, i, 0);
                float reverbRight = processReverbFiltering(delayedRight, i, 1);

draw method · cpp · L346-L363 (18 LOC)

src/KEN.cpp

    void draw(const DrawArgs &args) override {
        nvgFontSize(args.vg, fontSize);
        nvgFontFaceId(args.vg, APP->window->uiFont->handle);
        nvgTextAlign(args.vg, NVG_ALIGN_CENTER | NVG_ALIGN_MIDDLE);

        if (bold) {
            // 使用描邊模擬粗體效果
            nvgFillColor(args.vg, color);
            nvgText(args.vg, box.size.x / 2.f, box.size.y / 2.f, text.c_str(), NULL);
            nvgStrokeColor(args.vg, color);
            nvgStrokeWidth(args.vg, 0.3f);
            nvgText(args.vg, box.size.x / 2.f, box.size.y / 2.f, text.c_str(), NULL);
        } else {
            nvgFillColor(args.vg, color);
            nvgText(args.vg, box.size.x / 2.f, box.size.y / 2.f, text.c_str(), NULL);
        }
    }

WhiteBackgroundBox method · cpp · L367-L370 (4 LOC)

src/KEN.cpp

    WhiteBackgroundBox(Vec pos, Vec size) {
        box.pos = pos;
        box.size = size;
    }

draw method · cpp · L371-L381 (11 LOC)

src/KEN.cpp

    
    void draw(const DrawArgs &args) override {
        nvgBeginPath(args.vg);
        nvgRect(args.vg, 0, 0, box.size.x, box.size.y);
        nvgFillColor(args.vg, nvgRGB(255, 255, 255));
        nvgFill(args.vg);
        
        nvgStrokeWidth(args.vg, 1.0f);
        nvgStrokeColor(args.vg, nvgRGBA(200, 200, 200, 255));
        nvgStroke(args.vg);
    }

KENWidget method · cpp · L387-L417 (31 LOC)

src/KEN.cpp

    KENWidget(KEN* module) {
        setModule(module);
        panelThemeHelper.init(this, "8HP", module ? &module->panelContrast : nullptr);
        
        box.size = Vec(4 * RACK_GRID_WIDTH, RACK_GRID_HEIGHT);

        addChild(new TechnoEnhancedTextLabel(Vec(0, 1), Vec(box.size.x, 20), "KEN", 14.f, nvgRGB(255, 200, 0), true));
        addChild(new TechnoEnhancedTextLabel(Vec(0, 13), Vec(box.size.x, 20), "MADZINE", 10.f, nvgRGB(255, 200, 0), false));

        addChild(new TechnoEnhancedTextLabel(Vec(15, 43), Vec(30, 10), "LEVEL"));
        addParam(createParamCentered<StandardBlackKnob>(Vec(30, 70), module, KEN::LEVEL_PARAM));

        float inputStartY = 110;
        float inputSpacing = 28;

        for (int i = 0; i < 8; i++) {
            float y = inputStartY + i * inputSpacing;

            addChild(new TechnoEnhancedTextLabel(Vec(3, y-5), Vec(20, 10), std::to_string(i + 1)));
            addInput(createInputCentered<PJ301MPort>(Vec(30, y), module, KEN::INPUT_1 + i));

step method · cpp · L418-L425 (8 LOC)

src/KEN.cpp

    void step() override {
        KEN* module = dynamic_cast<KEN*>(this->module);
        if (module) {
            panelThemeHelper.step(module);
        }
        ModuleWidget::step();
    }

Repobility (the analyzer behind this table) · https://repobility.com

appendContextMenu method · cpp · L426-L432 (7 LOC)

src/KEN.cpp

    void appendContextMenu(ui::Menu* menu) override {
        KEN* module = dynamic_cast<KEN*>(this->module);
        if (!module) return;

        addPanelThemeMenu(menu, module);
    }

draw method · cpp · L22-L39 (18 LOC)

src/KIMO.cpp

    void draw(const DrawArgs &args) override {
        nvgFontSize(args.vg, fontSize);
        nvgFontFaceId(args.vg, APP->window->uiFont->handle);
        nvgTextAlign(args.vg, NVG_ALIGN_CENTER | NVG_ALIGN_MIDDLE);

        if (bold) {
            // 使用描邊模擬粗體效果
            nvgFillColor(args.vg, color);
            nvgText(args.vg, box.size.x / 2.f, box.size.y / 2.f, text.c_str(), NULL);
            nvgStrokeColor(args.vg, color);
            nvgStrokeWidth(args.vg, 0.3f);
            nvgText(args.vg, box.size.x / 2.f, box.size.y / 2.f, text.c_str(), NULL);
        } else {
            nvgFillColor(args.vg, color);
            nvgText(args.vg, box.size.x / 2.f, box.size.y / 2.f, text.c_str(), NULL);
        }
    }

getDisplayValueString method · cpp · L47-L50 (4 LOC)

src/KIMO.cpp

    std::string getDisplayValueString() override {
        int value = (int)std::round(getValue());
        return string::f("%d step", value);
    }

‹ prevpage 4 / 39next ›