render()

void mood_ring::GrooveLayer::render	(	const RoomSense &	s,
		const MoodPalette &	pal,
		float	dtSec,
		RingCanvas &	c )

Definition at line 165 of file layers.cpp.

                                                     {
    const float dtMs = dtSec * 1000.0f;
    const float slot = 1.0f / static_cast<float>(kMarkers);
    const float beatsPerSec = (s.bpm > 20.0f) ? s.bpm / 60.0f : 0.0f;
 
    // Rotate continuously at tempo: one slot per beat. On each beat, measure
    // how far the nearest marker is from its slot boundary and slew that
    // error out over the next fraction of a beat, so the geometry locks to
    // the music without ever jumping.
    mRotation = advance(mRotation, slot * beatsPerSec, dtSec);
    if (s.events.beat) {
        const float inSlot =
            mRotation -
            slot * static_cast<float>(static_cast<int>(mRotation / slot));
        // Nearest boundary: either back to the start of this slot or forward
        // to the next one.
        const float err = (inSlot < slot * 0.5f) ? -inSlot : (slot - inSlot);
        mCorrection = err;
    }
    if (mCorrection != 0.0f && beatsPerSec > 0.0f) {
        const float maxStep = slot * beatsPerSec * dtSec / kCorrectionBeats;
        float step = mCorrection;
        if (step > maxStep)
            step = maxStep;
        if (step < -maxStep)
            step = -maxStep;
        mRotation = wrapTurns(mRotation + step);
        mCorrection -= step;
        if (mCorrection < 1e-5f && mCorrection > -1e-5f)
            mCorrection = 0.0f;
    }
 
    // Swell into the beat: brightness climbs over the last quarter of the
    // beat and releases right after it. Followed so a beat that lands early
    // (phase reset from 0.9 to 0) ramps over a frame instead of stepping.
    float swellTarget;
    if (s.beatPhase >= kSwellStart) {
        swellTarget = smoothstepf(kSwellStart, 1.0f, s.beatPhase);
    } else {
        swellTarget = 1.0f - smoothstepf(0.0f, 0.25f, s.beatPhase);
    }
    const float swell =
        mSwell.update(swellTarget, dtMs, kSwellAttackMs, kSwellReleaseMs);
 
    // Event envelopes: instant-feeling attack, smooth release.
    const float flash = mFlash.update(s.events.downbeat ? 1.0f : 0.0f, dtMs,
                                      kFlashAttackMs, kFlashReleaseMs);
    const float snare = mSnare.update(s.events.snare ? 1.0f : 0.0f, dtMs,
                                      kSnareAttackMs, kSnareReleaseMs);
 
    const float markerGain = 0.45f + 0.55f * swell + 0.5f * s.punch;
 
    // Bed: measure phase breathes the whole ring once per bar.
    const float bar = 0.5f + 0.5f * fl::sin(kTwoPi * s.measurePhase);
    c.fill(paletteColor(pal, 0.2f), 0.08f + 0.12f * bar);
 
    // Markers alternate ends of the palette so the geometry reads.
    for (int k = 0; k < kMarkers; ++k) {
        const float pos = wrapTurns(mRotation + slot * static_cast<float>(k));
        const float t = (k & 1) ? 1.0f : 0.4f;
        c.lobe(pos, kMarkerSigma + 0.02f * s.low, paletteColor(pal, t),
               markerGain);
    }
 
    // Snare: a thin counter-marker halfway between each pair.
    if (snare > 0.001f) {
        for (int k = 0; k < kMarkers; ++k) {
            const float pos =
                wrapTurns(mRotation + slot * (static_cast<float>(k) + 0.5f));
            c.lobe(pos, kMarkerSigma * 0.6f, rgbfWhite(), 0.6f * snare);
        }
    }
 
    // Downbeat: whole-ring flash in the warm end of the family.
    if (flash > 0.001f) {
        c.fill(paletteColor(pal, 1.0f), 0.5f * flash);
    }
}

References mood_ring::RoomEvents::beat, mood_ring::RoomSense::beatPhase, mood_ring::RoomSense::bpm, mood_ring::RoomEvents::downbeat, mood_ring::RoomSense::events, mood_ring::RingCanvas::fill(), kMarkers, mood_ring::RingCanvas::lobe(), mood_ring::RoomSense::low, mCorrection, mood_ring::RoomSense::measurePhase, mFlash, mRotation, mSnare, mSwell, mood_ring::paletteColor(), pos, mood_ring::RoomSense::punch, mood_ring::rgbfWhite(), fl::sin(), mood_ring::smoothstepf(), mood_ring::RoomEvents::snare, t, and mood_ring::wrapTurns().

Here is the call graph for this function: