| ►Nanimartrix_ring | |
| COrchestratorConfig | |
| CSoundOrchestrator | Top-level orchestrator |
| ►Nanonymous_namespace{AutoResearchRemote.cpp} | |
| CScopedFastLedBrightness | |
| ►Nautoresearch | |
| ►Nanimartrix_check | |
| CPerlinBenchResult | |
| ►Nparlio_bench | |
| CParlioEncodeResult | |
| ►Nparlio_stream | |
| CValidateResult | |
| ►Nsimd_check | |
| CBenchmarkResult | |
| COpAdd | |
| COpDivFloat | |
| COpDivS16x16 | |
| COpDivS8x8 | |
| COpDivU16x16 | |
| COpMul | |
| COpSub | |
| CSimdTestEntry | |
| ►Nwave8_bench | |
| CWave8ExpandResult | |
| ►Nfl | Base definition for an LED controller |
| ►Nalpha_detail | |
| Cis_non_bool_integer | |
| ►Nanonymous_namespace{channel.cpp.hpp} | |
| CReorderingPixelIteratorAny | Encapsulates pixel iterator construction with optional XYMap reordering |
| CStubChannelEngine | |
| ►Nanonymous_namespace{chasing_spirals.cpp.hpp} | |
| CFrameSetup | |
| ►Nanonymous_namespace{chrono.cpp.hpp} | |
| CMillis64State | |
| ►Nanonymous_namespace{colorutils.cpp.hpp} | |
| CProgmemRGBPaletteReader | |
| CRuntimeRGBPaletteReader | |
| ►Nanonymous_namespace{gradient.cpp.hpp} | |
| CVisitor | |
| CVisitorFill | |
| ►Nanonymous_namespace{h264.cpp.hpp} | |
| CBitReader | |
| ►Nanonymous_namespace{json.cpp.hpp} | |
| ►CJsonBuilder | |
| CStackFrame | |
| CJsonTokenizer | |
| CJsonValidator | |
| CJsonVisitor | |
| ►Nanonymous_namespace{memory_resource.cpp.hpp} | |
| CDefaultMemoryResource | |
| CPSRamMemoryResource | |
| ►Nanonymous_namespace{random.cpp.hpp} | |
| CLockedRandom | |
| ►Nanonymous_namespace{rgbw.cpp.hpp} | |
| CNamedGamut | |
| CRgb2RgbwUserState | |
| CRgbwColorimetricState | |
| ►Nanonymous_namespace{rgbww.cpp.hpp} | |
| CRgb2RgbwwUserState | |
| CRgbwwColorimetricState | |
| ►Nanonymous_namespace{wave.cpp.hpp} | |
| CBatchDraw | Internal helper for batched gradient color mapping |
| ►Nasio | |
| ►Nhttp | |
| CRequest | HTTP request object (immutable, passed by const reference) |
| CResponse | HTTP response builder (fluent interface) |
| ►CServer | HTTP Server class |
| CClientConnection | |
| CRouteEntry | |
| CServerAsyncRunner | |
| ►Nip | |
| ►Ntcp | |
| Cendpoint | Asio-compatible endpoint type: bundles host address + port |
| Cerror_code | Asio-compatible error code: numeric code + optional human-readable message |
| ►Nasset_detail | |
| CAssetEntry | Process-local registry of (asset_path → resolved URL) pairs |
| ►Naudio | |
| ►Nanonymous_namespace{audio.cpp.hpp} | |
| CAudioSamplePool | |
| CGuardedFFT | |
| ►Ndetector | |
| CBackbeat | Detects backbeats (beats 2 and 4 in 4/4 time) in music |
| CBeat | |
| CBuildup | |
| CBuildupDetector | |
| CChord | |
| CChordDetector | |
| CChordTemplate | |
| CDownbeat | Detects downbeats (first beat of each measure) in music |
| CDrop | |
| CDropDetector | |
| CDynamicsAnalyzer | |
| CEnergyAnalyzer | |
| CEqualizer | Snapshot of equalizer state, passed to onEqualizer callbacks |
| CEqualizerConfig | Configuration for the equalizer detector |
| CEqualizerDetector | WLED-style equalizer detector that provides a 16-bin frequency spectrum normalized to 0.0-1.0, plus convenience bass/mid/treble/volume getters |
| CFrequencyBands | |
| CKey | |
| CKeyDetector | |
| CMood | |
| CMoodAnalyzer | |
| CMultibandAccent | Multi-band accent information for backbeat detection |
| ►CMultiBandBeat | MultiBandBeat performs frequency-specific beat detection |
| CStats | Get statistics (for debugging/monitoring) |
| CMultiBandBeatDetectorConfig | Configuration for multi-band beat detection |
| ►CMusicalBeat | MusicalBeat distinguishes true musical beats from random onset detection |
| CStats | Get statistics (for debugging/monitoring) |
| CMusicalBeatDetectorConfig | Configuration for musical beat detection |
| CNote | Note - Musical note detection with MIDI output |
| CPercussion | |
| CPitch | Pitch - Continuous pitch tracking using autocorrelation |
| CSilence | |
| ►CTempoAnalyzer | |
| CTempoHypothesis | |
| CTransient | Transient - Detects sharp attack transients in audio |
| CVibe | |
| CVibeLevels | |
| CVocal | |
| CVocalDetectorDiagnostics | |
| ►Nfft | |
| CArgs | |
| CBins | |
| ►CContext | |
| CFftScratch | |
| COctaveInfo | |
| ►CFFT | |
| CImplCache | |
| CFloatVectorPool | |
| ►CImpl | |
| CResult | |
| CAudioManager | |
| ►CAutoGain | AutoGain implements adaptive gain control using a PI (proportional-integral) controller with slow peak envelope tracking, inspired by WLED Sound Reactive |
| CStats | Get current statistics (for monitoring/debugging) |
| CAutoGainConfig | Configuration for automatic gain control |
| CBandEnergy | |
| CBeatDetectors | |
| CConfig | |
| CConfigI2S | |
| CConfigPdm | |
| ►CContext | |
| CFFTCacheEntry | |
| CData | |
| CDetector | |
| ►CFrequencyBinMapper | FrequencyBinMapper maps FFT output bins to perceptually-spaced frequency channels |
| CBinMapping | Mapping from output bins to FFT bin ranges Each entry contains (startBin, endBin) for averaging |
| CFrequencyRange | Get frequency boundaries for a specific output bin |
| CStats | Get statistics (for debugging/monitoring) |
| CFrequencyBinMapperConfig | Configuration for frequency bin mapping |
| CIInput | |
| CISynthEngine | Interface for synth engine that holds BLEP/BLAMP tables |
| CISynthOscillator | Interface class for synth oscillator |
| CMicResponseCurve | |
| ►CNoiseFloorTracker | NoiseFloorTracker maintains an adaptive estimate of the background noise floor for audio signals, with hysteresis to prevent "noise chasing" where the floor continuously adjusts to the signal level |
| CStats | Get current statistics (for monitoring/debugging) |
| CNoiseFloorTrackerConfig | Configuration for noise floor tracking |
| CPerceptualWeighting | |
| CProcessor | |
| CReactive | |
| CReactiveConfig | |
| CSample | |
| CSampleImpl | |
| ►CSignalConditioner | SignalConditioner performs low-level audio preprocessing to clean raw PCM samples before FFT analysis or beat detection |
| CStats | Get current statistics (for debugging/monitoring) |
| CSignalConditionerConfig | Configuration for signal conditioning pipeline |
| ►CSilenceEnvelope | |
| CConfig | |
| CSoundLevelMeter | |
| ►CSpectralEqualizer | SpectralEqualizer applies frequency-dependent gain correction to address mid-frequency dominance and provide perceptual weighting of audio spectra |
| CStats | Get statistics (for debugging/monitoring) |
| CSpectralEqualizerConfig | Configuration for spectral equalizer |
| CSpectralFluxDetector | |
| CSynthEngineImpl | |
| CSynthOscillatorImpl | |
| CSynthParams | Waveform parameters for custom waveforms |
| ►Nceil_detail | |
| Chas_static_ceil | |
| Chas_static_ceil< T, decltype(static_cast< void >(T::ceil(declval< T >())))> | |
| ►Nchrono | |
| Cduration | Represents a time duration |
| Csteady_clock | Monotonic clock that never goes backwards |
| Csystem_clock | Wall clock (may not be monotonic) |
| Ctime_point | Represents a point in time relative to a clock |
| ►Ncolorimetric_detail | |
| CLutTable | |
| CProfileCache | |
| CRgbcctProfile | |
| ►Ndetail | Compile-time linker keep-alive hook for a single fl::Bus |
| ►Nanonymous_namespace{allocator.cpp.hpp} | |
| CSlabRegistryEntry | |
| ►Nanonymous_namespace{singleton.cpp.hpp} | |
| CRegistryEntry | |
| CActiveLoggerRegistry | Active logger registry for iteration (flush operations) Only tracks loggers that have been instantiated via template access |
| CAlphaTrimmedMeanImpl | |
| Carray_delete | |
| CAsyncLoggerServiceTask | Auto-instantiating task for async logger servicing Registers itself with fl::task::Scheduler when first accessed Only instantiated if at least one async logger is used (linker removes if unused) |
| CAttackDecayFilterImpl | |
| CAudioLoggerInfo | |
| CBackgroundFlushState | |
| CBilateralFilterImpl | |
| CBiquadFilterImpl | |
| CBusKeepAliveImpl | |
| CBusKeepAliveImpl< fl::Bus::AUTO > | |
| CCallableHolderBase | |
| CCascadedEMAImpl | |
| Ccontrol_block_alignment | |
| CControlBlock | |
| CControlBlockBase | |
| CDCBlockerImpl | |
| Cdefault_delete | |
| CErasedInvoker | |
| CErasedSchemaGenerator | |
| CExponentialSmootherImpl | |
| CFlexIOLoggerInfo | |
| CGaussianFilterImpl | |
| Cget_encoder | |
| Cget_encoder< CHIPSET, true > | |
| CHampelFilterImpl | |
| Chas_copy_ctor | |
| Chas_copy_ctor< T, decltype(void(T(fl::declval< const T & >())))> | |
| Chas_default_ctor | |
| Chas_default_ctor< T, decltype(void(T()))> | |
| Chas_move_ctor | |
| Chas_move_ctor< T, decltype(void(T(fl::declval< T && >())))> | |
| Cint_to_fixed | |
| Cint_to_fixed< IntBits, FracBits, false > | |
| Cint_to_fixed< IntBits, FracBits, true > | |
| Cinteger_digits10_helper | |
| Cinteger_digits_helper | |
| Cinteger_max_helper | |
| Cinteger_max_helper< T, false > | |
| Cinteger_max_helper< T, true > | |
| Cinteger_min_helper | |
| Cinteger_min_helper< T, false > | |
| Cinteger_min_helper< T, true > | |
| CInterruptLoggerInfo | |
| Cis_comparable_to_nullptr | |
| Cis_dereferenceable | |
| Cis_member_data_pointer | |
| Cis_member_data_pointer< T C::* > | |
| Cis_non_bool_integer | |
| Cis_pointer_like | |
| Cis_pointer_like< fl::unique_ptr< T, Deleter > > | |
| Cis_pointer_like< T * > | |
| Cis_reference | |
| Cis_reference< T & > | |
| Cis_reference< T && > | |
| Cis_swappable | |
| Cis_swappable< T, decltype(void(fl::declval< T & >()=fl::declval< T && >()))> | |
| CJsonToBoolVisitor | |
| CJsonToFloatVisitor | |
| CJsonToIntegerVisitor | |
| CJsonToStringVisitor | |
| CJsonToType | |
| CJsonToType< bool, void > | |
| CJsonToType< fl::ConstCharPtrWrapper, void > | |
| CJsonToType< fl::ConstSpanWrapper< T >, void > | |
| CJsonToType< fl::json, void > | |
| CJsonToType< fl::string, void > | |
| CJsonToType< fl::vector< fl::u8 >, void > | |
| CJsonToType< fl::vector< T >, void > | |
| CJsonToType< T, typename fl::enable_if< fl::is_floating_point< T >::value >::type > | |
| CJsonToType< T, typename fl::enable_if< fl::is_integral< T >::value &&!fl::is_same< T, bool >::value >::type > | |
| CKalmanFilterImpl | |
| CLeakyIntegratorImpl | |
| CLutArray | |
| Cmake_shared_tag | |
| Cmax_align_with_ld | |
| Cmax_align_without_ld | |
| CMedianFilterImpl | |
| Cmemorybuf | |
| CMethodBuilder | |
| CMethodSchema | |
| CMethodSchema< R(Args...)> | |
| CMethodSchema< void(Args...)> | |
| CMovingAverageImpl | |
| Cno_op_deleter | |
| Cno_tracking_tag | |
| CObjectFLEDLoggerInfo | |
| COneEuroFilterImpl | |
| CParlioLoggerInfo | Info providers for each logger category Used to supply category name, define name, and enabled status |
| Cposix_filebuf | |
| Cresolve_bus | Resolve a possibly-Bus::AUTO template argument to the concrete platform default for the given Chipset family |
| Cresolve_bus< Bus::AUTO, Chipset > | |
| CResponseAwareInvoker | Invoker for response-aware RPC methods |
| CResponseAwareInvoker< R(Args...)> | |
| CResponseAwareInvoker< void(Args...)> | |
| CRmtLoggerInfo | |
| CRpcEntry | |
| CSavitzkyGolayFilterImpl | |
| CScaledPixelIteratorBrightness | Input iterator adapter for PixelIterator yielding brightness values |
| CScaledPixelIteratorRGB | Input iterator adapter for PixelIterator yielding 3-byte pixel data |
| CScaledPixelIteratorRGB16 | Input iterator adapter for PixelIterator yielding 16-bit RGB pixel data |
| CScaledPixelIteratorRGBW | Input iterator adapter for PixelIterator yielding 4-byte pixel data |
| CScaledPixelIteratorRGBWW | Input iterator adapter yielding 5-byte RGBWW pixels (issue #2558) |
| CSpectralVarianceImpl | Multi-channel EMA with per-bin relative deviation measurement |
| CSpiLoggerInfo | |
| CTriangularFilterImpl | |
| CTypedCallableHolder | |
| CTypedInvoker | |
| CTypedInvoker< R(Args...)> | |
| CTypedInvoker< void(Args...)> | |
| CTypedSchemaGenerator | |
| CTypeSchema | |
| CTypeSchema< bool, void > | |
| CTypeSchema< fl::string, void > | |
| CTypeSchema< T, typename fl::enable_if< fl::is_floating_point< T >::value >::type > | |
| CTypeSchema< T, typename fl::enable_if< fl::is_integral< T >::value &&!fl::is_same< T, bool >::value >::type > | |
| CTypeSchema< void, void > | |
| CTypeTag | |
| CTypeToJson | |
| CTypeToJson< fl::json > | |
| CTypeToJson< fl::string > | |
| CTypeToJson< fl::vector< fl::u8 > > | |
| CTypeToJson< fl::vector< T > > | |
| CTypeToJson< void > | |
| Cuse_pointer_syntax | |
| CWeightedMovingAverageImpl | |
| ►Nfl | |
| ►Ndetail | |
| Cmax_align_with_ld | |
| Cmax_align_without_ld | |
| ►Nint_cast_detail | |
| Ccast_target | |
| Ccast_target< T, 1, false > | |
| Ccast_target< T, 1, true > | |
| Ccast_target< T, 2, false > | |
| Ccast_target< T, 2, true > | |
| Ccast_target< T, 4, false > | |
| Ccast_target< T, 4, true > | |
| Ccast_target< T, 8, false > | |
| Ccast_target< T, 8, true > | |
| ►Nmake_unsigned_detail | |
| Cunsigned_by_size | |
| Cunsigned_by_size< 1 > | |
| Cunsigned_by_size< 2 > | |
| Cunsigned_by_size< 4 > | |
| Cunsigned_by_size< 8 > | |
| Cadd_pointer | |
| Cadd_pointer< T & > | |
| Cadd_pointer< T && > | |
| Cadd_rvalue_reference | |
| Cadd_rvalue_reference< T & > | |
| Caligned_ptr | |
| Calignment_of | |
| Ccallable_traits | |
| Ccallable_traits< R(*)(Args...)> | |
| Ccallable_traits< R(Args...)> | |
| Ccallable_traits< R(C::*)(Args...) const > | |
| Ccallable_traits< R(C::*)(Args...)> | |
| Ccallable_traits< T, typename enable_if< is_member_function_pointer< decltype(&T::operator())>::value >::type > | |
| Cchoose_by_rank | |
| Cchoose_by_signedness | |
| Cchoose_by_size | |
| Ccommon_type | |
| Ccommon_type_impl | |
| Ccommon_type_impl< double, float > | |
| Ccommon_type_impl< double, long double > | |
| Ccommon_type_impl< double, T, typename enable_if<(is_integral< T >::value||is_floating_point< T >::value) &&!is_same< T, double >::value >::type > | |
| Ccommon_type_impl< float, double > | |
| Ccommon_type_impl< float, long double > | |
| Ccommon_type_impl< float, T, typename enable_if<(is_integral< T >::value||is_floating_point< T >::value) &&!is_same< T, float >::value >::type > | |
| Ccommon_type_impl< i8, u8, void > | |
| Ccommon_type_impl< long double, double > | |
| Ccommon_type_impl< long double, float > | |
| Ccommon_type_impl< T, double, typename enable_if<(is_integral< T >::value||is_floating_point< T >::value) &&!is_same< T, double >::value >::type > | |
| Ccommon_type_impl< T, float, typename enable_if<(is_integral< T >::value||is_floating_point< T >::value) &&!is_same< T, float >::value >::type > | |
| Ccommon_type_impl< T, T > | |
| Ccommon_type_impl< T, U, typename enable_if< is_integral< T >::value &&is_integral< U >::value &&!is_same< T, U >::value &&!((is_same< T, i8 >::value &&is_same< U, u8 >::value)||(is_same< T, u8 >::value &&is_same< U, i8 >::value))>::type > | |
| Ccommon_type_impl< u8, i8, void > | |
| Cconditional | |
| Cconditional< false, T, F > | |
| Ccontains_type | |
| Ccontains_type< T > | |
| Ccontains_type< T, U, Rest... > | |
| Cdecay | |
| Cenable_if | |
| Cenable_if< true, T > | |
| ►Chas_member_swap | |
| Chelper | |
| Cidentity | |
| Cindex_sequence | |
| Cinteger_promotion_impl | |
| Cintegral_constant | |
| Cis_arithmetic | |
| Cis_arithmetic< const T > | |
| Cis_arithmetic< T & > | |
| Cis_arithmetic< volatile T > | |
| Cis_array | |
| Cis_array< T[]> | |
| Cis_array< T[N]> | |
| Cis_base_of | |
| Cis_base_of_v_helper | |
| Cis_char_type | |
| Cis_char_type< char > | |
| Cis_char_type< const T > | |
| Cis_char_type< signed char > | |
| Cis_char_type< T & > | |
| Cis_char_type< unsigned char > | |
| Cis_char_type< volatile T > | |
| Cis_const | |
| Cis_const< const T > | |
| Cis_enum | |
| Cis_fixed_point | |
| Cis_floating_point | |
| Cis_floating_point< const T > | |
| Cis_floating_point< double > | |
| Cis_floating_point< float > | |
| Cis_floating_point< long double > | |
| Cis_floating_point< T & > | |
| Cis_floating_point< volatile T > | |
| Cis_function | |
| Cis_function< Ret(Args...) const > | |
| Cis_function< Ret(Args...) const volatile > | |
| Cis_function< Ret(Args...) volatile > | |
| Cis_function< Ret(Args...)> | |
| Cis_integral | |
| Cis_integral< bool > | |
| Cis_integral< char > | |
| Cis_integral< const T > | |
| Cis_integral< int > | |
| Cis_integral< long > | |
| Cis_integral< long long > | |
| Cis_integral< short > | |
| Cis_integral< signed char > | |
| Cis_integral< T & > | |
| Cis_integral< unsigned char > | |
| Cis_integral< unsigned int > | |
| Cis_integral< unsigned long > | |
| Cis_integral< unsigned long long > | |
| Cis_integral< unsigned short > | |
| Cis_integral< volatile T > | |
| Cis_lvalue_reference | |
| Cis_lvalue_reference< T & > | |
| Cis_member_function_pointer | |
| Cis_member_function_pointer< Ret(C::*)(A...) const > | |
| Cis_member_function_pointer< Ret(C::*)(A...)> | |
| Cis_multi_byte_integer | |
| Cis_pod | |
| Cis_pod< bool > | |
| Cis_pod< char > | |
| Cis_pod< double > | |
| Cis_pod< float > | |
| Cis_pod< int > | |
| Cis_pod< long > | |
| Cis_pod< long double > | |
| Cis_pod< long long > | |
| Cis_pod< short > | |
| Cis_pod< signed char > | |
| Cis_pod< unsigned char > | |
| Cis_pod< unsigned int > | |
| Cis_pod< unsigned long > | |
| Cis_pod< unsigned long long > | |
| Cis_pod< unsigned short > | |
| Cis_pod_v_helper | |
| Cis_pointer | |
| Cis_pointer< T * > | |
| Cis_pointer< T *const > | |
| Cis_pointer< T *const volatile > | |
| Cis_pointer< T *volatile > | |
| Cis_reference | |
| Cis_rvalue_reference | |
| Cis_rvalue_reference< T && > | |
| Cis_same | |
| Cis_same< T, T > | |
| Cis_same_v_helper | |
| Cis_signed | |
| Cis_signed< char > | |
| Cis_signed< const T > | |
| Cis_signed< const volatile T > | |
| Cis_signed< double > | |
| Cis_signed< float > | |
| Cis_signed< int > | |
| Cis_signed< long > | |
| Cis_signed< long double > | |
| Cis_signed< long long > | |
| Cis_signed< short > | |
| Cis_signed< signed char > | |
| Cis_signed< volatile T > | |
| Cis_trivially_copyable | |
| Cis_trivially_copyable_v_helper | |
| Cis_void | |
| Cis_void< void > | |
| Cmake_index_sequence_impl | |
| Cmake_index_sequence_impl< 0, Is... > | |
| Cmake_unsigned | |
| Cmake_unsigned< T, typename enable_if< is_integral< T >::value &&!is_same< typename remove_cv< T >::type, bool >::value >::type > | |
| Cmax_align | |
| Cmax_align< T, Rest... > | |
| Cmax_align<> | |
| Cmax_align_selector | |
| Cmax_align_selector< false > | |
| Cmax_size | |
| Cmax_size< T, Rest... > | |
| Cmax_size<> | |
| Cremove_const | |
| Cremove_const< const T > | |
| Cremove_cv | |
| Cremove_cv< const T > | |
| Cremove_cv< const volatile T > | |
| Cremove_cv< volatile T > | |
| Cremove_extent | |
| Cremove_extent< T[]> | |
| Cremove_extent< T[N]> | |
| Cremove_pointer | |
| Cremove_pointer< T * > | |
| Cremove_pointer< T *const > | |
| Cremove_pointer< T *const volatile > | |
| Cremove_pointer< T *volatile > | |
| Cremove_reference | |
| Cremove_reference< T & > | |
| Cremove_reference< T && > | |
| ►Cs0x32 | |
| CRawTag | |
| Cs0x32x4 | 4-wide s0x32 vector (normalized values [-1, 1]) Backed by 128-bit SIMD register (4× i32 in Q31 format) |
| Cstatic_assert_failure | |
| Cstatic_assert_failure< true > | |
| Cswap_impl | |
| Cswap_impl< T, false > | |
| Cswap_impl< T, true > | |
| Ctype_rank | |
| Ctype_rank< bool > | |
| Ctype_rank< char > | |
| Ctype_rank< double > | |
| Ctype_rank< float > | |
| Ctype_rank< int > | |
| Ctype_rank< long > | |
| Ctype_rank< long double > | |
| Ctype_rank< long long > | |
| Ctype_rank< short > | |
| Ctype_rank< signed char > | |
| Ctype_rank< unsigned char > | |
| Ctype_rank< unsigned int > | |
| Ctype_rank< unsigned long > | |
| Ctype_rank< unsigned long long > | |
| Ctype_rank< unsigned short > | |
| Cunderlying_type | |
| ►Nfloor_detail | |
| Chas_static_floor | |
| Chas_static_floor< T, decltype(static_cast< void >(T::floor(declval< T >())))> | |
| ►Nformat_detail | |
| CFormatArg | |
| CFormatSpec | |
| ►Ngfx | |
| ►Nblur_detail | |
| Cinterior_row | |
| Cinterior_row< 0, RGB_T, acc_t > | |
| Cinterior_row< 1, RGB_T, acc_t > | |
| Cinterior_row< 2, RGB_T, acc_t > | |
| Cinterior_row< 3, RGB_T, acc_t > | |
| Cinterior_row< 4, RGB_T, acc_t > | |
| Cpixel_ops | |
| Cpixel_ops< CRGB > | |
| Cpixel_ops< CRGB16 > | |
| Csimd_hconv_dispatch | |
| Csimd_hconv_dispatch< 0 > | |
| Csimd_hconv_dispatch< 1 > | |
| Csimd_hconv_dispatch< 2 > | |
| Csimd_hconv_dispatch< 3 > | |
| Csimd_hconv_dispatch< 4 > | |
| Csimd_vconv_dispatch | |
| Csimd_vconv_dispatch< 0 > | |
| Csimd_vconv_dispatch< 1 > | |
| Csimd_vconv_dispatch< 2 > | |
| Csimd_vconv_dispatch< 3 > | |
| Csimd_vconv_dispatch< 4 > | |
| Cvpass_pixel_kernel | |
| Cvpass_pixel_kernel< 0, RGB_T, acc_t > | |
| Cvpass_pixel_kernel< 1, RGB_T, acc_t > | |
| Cvpass_pixel_kernel< 2, RGB_T, acc_t > | |
| Cvpass_pixel_kernel< 3, RGB_T, acc_t > | |
| Cvpass_pixel_kernel< 4, RGB_T, acc_t > | |
| ►Ndetail | ============================================================================ |
| CDiscCtx | Disc context: bundles per-circle constants into a struct passed by reference |
| Cneeds_division | |
| Cneeds_division< Coord, typename voider< fl::bool_constant<(Coord::FRAC_BITS< 16)> >::type > | |
| CRingCtx | Ring context: bundles all per-circle constants into a struct passed by reference |
| CStrokeCtx | Stroke line context: bundles per-line constants into a struct passed by reference |
| Cvoider | |
| CCanvas | Simple rectangular canvas for graphics operations Combines a pixel buffer with dimensions for cache-optimal drawing |
| CCanvasMapped | XYMap-backed canvas for non-rectangular or remapped layouts |
| ►Nint_cast_detail | |
| Ccast_target | |
| Ccast_target< T, 1, false > | |
| Ccast_target< T, 1, true > | |
| Ccast_target< T, 2, false > | |
| Ccast_target< T, 2, true > | |
| Ccast_target< T, 4, false > | |
| Ccast_target< T, 4, true > | |
| Ccast_target< T, 8, false > | |
| Ccast_target< T, 8, true > | |
| ►Nisr | |
| Cconfig | Configuration for ISR attachment |
| Ccritical_section | RAII helper for critical sections (interrupt disable/enable) Automatically disables interrupts on construction and enables on destruction |
| Chandle | Opaque handle to an attached ISR |
| ►Nmake_unsigned_detail | |
| Cunsigned_by_size | |
| Cunsigned_by_size< 1 > | |
| Cunsigned_by_size< 2 > | |
| Cunsigned_by_size< 4 > | |
| Cunsigned_by_size< 8 > | |
| ►Nmap_range_detail | |
| Cmap_range_math< T, vec2< V > > | |
| ►Nmath | |
| Crandom | A random number generator class that wraps FastLED's random functions |
| ►Nnet | |
| ►Nble | |
| CStatusInfo | Platform-neutral BLE diagnostics (returned by queryStatus) |
| ►Nhttp | |
| CChunkedReader | |
| CChunkedReadResult | |
| CChunkedWriter | |
| CFetchEngineListener | |
| CFetchManager | Internal fetch manager for promise tracking |
| CFetchOptions | Fetch options builder (fluent interface) |
| CFetchRequest | Non-blocking HTTP request state machine |
| ►CHttpStreamTransport | Base class for HTTP streaming transport Implements RequestSource and ResponseSink for Remote class Manages HTTP connection lifecycle with chunked encoding |
| CPendingCall | |
| CPendingStream | |
| CRequestOptions | Request options (matches JavaScript fetch RequestInit) |
| CResponse | HTTP response class (unified interface) |
| CStreamHandle | Handle for ASYNC_STREAM calls Provides onData() for intermediate updates, plus then()/catch_() for final result |
| CNetworkDetector | Stub NetworkDetector for platforms without the real implementation |
| COTA | OTA (Over-The-Air) update manager for ESP32 platforms |
| ►CRpcScheduler | Generic time-based task scheduler |
| CScheduledTask | |
| ►Nprintf_detail | |
| CFormatSpec | |
| ►Npwm_state | |
| CPwmPinState | |
| CPwmStateData | |
| ►Nq31 | |
| CChasing_Spirals_Q31 | |
| CChasing_Spirals_Q31_SIMD | |
| ►Nspi | |
| ►CDevice | Single-channel SPI device interface (TX-only, transaction-based, optimized for FastLED) |
| ►CImpl | Private implementation data for Device class |
| CAsyncState | State for async operations |
| CDeviceImplBase | Common functionality for device implementation (pImpl pattern) |
| CLane | Single lane in a multi-lane SPI device |
| ►CMultiLaneDevice | Multi-lane SPI device (1-8 independent LED strips) |
| CConfig | Configuration for multi-lane SPI |
| CImpl | |
| ►CParallelDevice | Parallel GPIO SPI device (1-32 pins driven from single data stream) |
| CConfig | Configuration for parallel GPIO SPI |
| CImpl | |
| ►CTransaction | Handle for asynchronous SPI operations |
| CImpl | Private implementation data for Transaction class |
| ►Nsqrt_detail | |
| Chas_static_sqrt | |
| Chas_static_sqrt< T, decltype(static_cast< void >(T::sqrt(declval< T >())))> | |
| ►Ntask | |
| ►Ndetail | |
| CPromiseImpl | Implementation class for Promise - holds the actual state and logic |
| CCoroutine | |
| CCoroutineConfig | Configuration for OS-level coroutine tasks |
| CCoroutineTask | |
| CError | Error type for promises |
| CExecutor | Task executor (singleton) — manages registered runners |
| CHandle | Task Handle with fluent API (was class fl::task, renamed to avoid namespace collision) |
| CITaskImpl | |
| CPromise | Promise class that provides fluent .then() and .catch_() semantics This is a lightweight wrapper around a shared PromiseImpl for easy copying/sharing |
| CPromiseResult | Result type for promise operations |
| CRunner | Generic task runner interface |
| CScheduler | |
| CTimeTask | |
| ►Ntest | |
| ►Ndetail | |
| CSuiteScope | |
| CTypeIterator | |
| CTypeIterator< TypeList< T, Rest... >, TestFunc > | |
| CTypeIterator< TypeList<>, TestFunc > | |
| CTypeList | |
| CTypeNameHolder | |
| CApprox | Helper class for approximate floating-point comparisons |
| CAssertResult | |
| CCompareEq | |
| CCompareGe | |
| CCompareGt | |
| CCompareLe | |
| CCompareLt | |
| CCompareNe | |
| CDefaultReporter | |
| CExpressionValue | |
| CIReporter | |
| CJSONReporter | JSON reporter that outputs test results in JSON format |
| CSerialReporter | Serial reporter for embedded devices Usage: SerialReporter reporter(mySerialPrint); fl::test::TestContext::instance().setReporter(&reporter); |
| CSourceLocation | |
| CSubcase | |
| CSubcaseSignature | |
| CTAPReporter | TAP reporter that outputs TAP-compatible test results Can output to a string buffer or use a print function for streaming output |
| ►CTestContext | |
| CTestCaseInfo | |
| CTestRegistrar | |
| CTestStats | |
| CXMLReporter | XML reporter that outputs JUnit-compatible XML format The output is accumulated in a string buffer provided by the user |
| ►Nthird_party | |
| ►Nhexwave | |
| Chexvert | |
| CHexWave | |
| CHexWaveEngine | Engine state holding BLEP/BLAMP tables |
| CHexWaveParameters | |
| ►Ntruetype | |
| Cstbrp_context | |
| Cstbrp_node | |
| Cstbrp_rect | |
| Cstbtt__active_edge | |
| Cstbtt__bitmap | |
| Cstbtt__buf | |
| Cstbtt__csctx | |
| Cstbtt__edge | |
| Cstbtt__hheap | |
| Cstbtt__hheap_chunk | |
| Cstbtt__point | |
| Cstbtt_aligned_quad | |
| Cstbtt_bakedchar | |
| Cstbtt_fontinfo | |
| Cstbtt_kerningentry | |
| Cstbtt_pack_context | |
| Cstbtt_pack_range | |
| Cstbtt_packedchar | |
| Cstbtt_vertex | |
| ►Nvorbis | |
| CCodebook | |
| CCRCscan | |
| Cfloat_conv | |
| CFloor | |
| CFloor0 | |
| CFloor1 | |
| CMapping | |
| CMappingChannel | |
| CMode | |
| CProbedPage | |
| CResidue | |
| Cstb_vorbis | |
| Cstb_vorbis_alloc | |
| Cstb_vorbis_comment | |
| Cstb_vorbis_info | |
| Cstbv__floor_ordering | |
| CStbvTempBuffer | |
| C_BitStreamInfo | |
| C_BlockCount | |
| C_DequantInfo | |
| C_FrameHeader | |
| C_HuffmanInfo | |
| C_HuffTabLookup | |
| C_IMDCTInfo | |
| C_ScaleFactorInfo | |
| C_ScaleFactorInfoSub | |
| C_ScaleFactorJS | |
| C_SFBandTable | |
| C_SideInfo | |
| C_SideInfoSub | |
| C_SubbandInfo | |
| CCriticalBandInfo | |
| CezWS2812 | EzWS2812 SPI driver for WS2812 LEDs |
| CezWS2812gpio | EzWS2812 GPIO driver for WS2812 LEDs |
| CGifBitmap | |
| CJDEC | |
| CJDEC_Progressive | |
| CJRECT | |
| Clzw_ctx | LZW decompression context |
| Clzw_read_ctx | Context for reading LZW data |
| Clzw_table_entry | LZW table entry |
| CMp3Frame | |
| ►CMp3HelixDecoder | |
| CFrameInfo | |
| CMp3StreamDecoderImpl | |
| CMpeg1Config | |
| Cnsgif | GIF animation data |
| Cnsgif_bitmap_cb_vt | Bitmap callbacks function table |
| Cnsgif_colour_layout | Pixel format: colour component order |
| Cnsgif_frame | GIF frame data |
| Cnsgif_frame_info | Information about a GIF frame |
| Cnsgif_info | Information about a GIF |
| Cnsgif_rect | LibNSGIF rectangle structure |
| Cplm_audio_t | |
| Cplm_buffer_t | |
| Cplm_demux_t | |
| Cplm_frame_t | |
| Cplm_packet_t | |
| Cplm_plane_t | |
| Cplm_quantizer_spec_t | |
| Cplm_samples_t | |
| Cplm_t | |
| Cplm_video_motion_t | |
| Cplm_video_t | |
| Cplm_vlc_t | |
| Cplm_vlc_uint_t | |
| CSoftwareGifDecoder | Software GIF decoder implementation using libnsgif |
| ►CSoftwareMpeg1Decoder | |
| CMpeg1DecoderData | |
| CTJpg_Decoder | |
| ►CTJpgInstanceDecoder | |
| CEmbeddedTJpgState | |
| CTJpgProgressiveConfig | |
| ►Nvideo | |
| ►CFrameInterpolator | |
| CLess | |
| CFrameTracker | |
| CPixelStream | |
| CVideoImpl | |
| Cadd_pointer | |
| Cadd_pointer< T & > | |
| Cadd_pointer< T && > | |
| Cadd_rvalue_reference | |
| Cadd_rvalue_reference< T & > | |
| Caligned_ptr | |
| Calignment_of | |
| Callocation_result | |
| ►Callocator | |
| Crebind | |
| ►Callocator_inlined | |
| CInlinedStorage | |
| Crebind | |
| ►Callocator_psram | |
| Crebind | |
| ►Callocator_realloc | |
| Crebind | |
| ►Callocator_slab | |
| Crebind | |
| ►Callocator_traits | |
| Chas_allocate_at_least | |
| Chas_allocate_at_least< A, decltype((void) fl::declval< A >().allocate_at_least(fl::declval< typename A::size_type >()))> | |
| Chas_reallocate | |
| Chas_reallocate< A, decltype((void) fl::declval< A >().reallocate(fl::declval< typename A::pointer >(), fl::declval< typename A::size_type >(), fl::declval< typename A::size_type >()))> | |
| Calpha16 | Unsigned 16-bit alpha / brightness — UNORM16 |
| Calpha8 | Unsigned 8-bit alpha / brightness — UNORM8 |
| CAlphaTrimmedMean | |
| CAnimartrix | |
| CAnimartrixAnimInfo | |
| CAnimartrixEntry | |
| CArchimedeanSpiralPath | |
| Carray | A fixed-size array implementation similar to std::array |
| Carray< T, 0 > | |
| Casset_ref | Opaque handle to a sketch-local asset |
| CAsyncLogger | ISR-safe async logger wrapper (zero heap allocation) Uses embedded AsyncLogQueue instead of heap-allocated pointer Registers itself automatically in ActiveLoggerRegistry on first access |
| ►CAsyncLogQueue | High-performance SPSC async log queue |
| CDescriptor | Descriptor for one log message |
| CAtomicFake | |
| CAttackDecayFilter | |
| CAudioBatch | |
| CAudioFrame | Lightweight snapshot of pre-computed audio analysis for one audio sample |
| CAutoResearchConfig | Configuration for driver-agnostic autoresearch testing Contains all input parameters needed for autoresearch (excludes output parameters) |
| Cback_insert_iterator | Back insert iterator - an output iterator that inserts elements at the end of a container |
| ►Cbasic_string | Concrete type-erased string class |
| Cconst_iterator | |
| CConstLiteral | |
| CConstView | |
| Citerator | |
| Cbidirectional_iterator_tag | |
| CBig_Caleido | |
| CBig_Caleido_FP | |
| CBilateralFilter | |
| CBindResult | Wraps the result of binding to a method by name |
| CBindResult< R(Args...)> | |
| CBiquadFilter | |
| Cbitset_dynamic | A dynamic bitset implementation that can be resized at runtime |
| Cbitset_fixed | |
| Cbitset_inlined | |
| Cbitswap_type | Union containing a full 8 bytes to swap the bit orientation on |
| Cbitswap_type.__unnamed0__ | |
| ►CBlend2d | |
| CEntry | |
| CBlend2dParams | |
| CBoolConversionVisitor | |
| CBusSupports | Capability check: does bus B accept chipset family Chipset? |
| CBusTraits | Primary template — intentionally undefined |
| ►CButton | |
| CListener | |
| CButtonLowLevel | |
| CCaleido1 | |
| CCaleido1_FP | |
| CCaleido2 | |
| CCaleido2_FP | |
| CCaleido3 | |
| CCaleido3_FP | |
| Ccallable_traits | |
| Ccallable_traits< R(*)(Args...)> | |
| Ccallable_traits< R(Args...)> | |
| Ccallable_traits< R(C::*)(Args...) const > | |
| Ccallable_traits< R(C::*)(Args...)> | |
| Ccallable_traits< T, typename enable_if< is_member_function_pointer< decltype(&T::operator())>::value >::type > | |
| CCanvas | Generic canvas for any pixel type (e.g |
| CCanvasRGB | Convenience alias for CRGB canvas — use fl::CanvasRGB for no-template syntax |
| CCascadedEMA | |
| CCatmullRomParams | |
| CCatmullRomPath | Catmull–Rom spline through arbitrary points |
| CCenter_Field | |
| CCenter_Field_FP | |
| CChannel | LED channel for parallel output, pretty much a CPixelLEDController but with timing and pin information |
| CChannelConfig | Configuration for a single LED channel |
| CChannelConfigOf | Strongly-typed channel configuration with compile-time chipset family |
| CChannelData | Transmission data for a single LED channel |
| CChannelEvents | Singleton event router for Channel lifecycle events |
| ►CChannelManager | Unified channel manager with priority-based driver selection |
| CEngineEntry | Engine registry entry (priority + shared pointer + runtime control) |
| CChannelOptions | Optional channel configuration parameters All fields have sensible defaults and can be overridden as needed |
| CChasing_Spirals_Float | |
| CChasing_Spirals_Q31 | |
| CChasing_Spirals_Q31_SIMD | |
| CChasingSpiralPixelLUT | |
| CChipsetTiming | Generic chipset timing entry Provides T1, T2, T3 timing parameters in nanoseconds for any LED protocol |
| CChipsetTiming4Phase | 4-phase RX timing thresholds for chipset detection |
| CChipsetTimingConfig | Runtime bit-period timing for a clockless chipset |
| Cchoose_by_rank | |
| Cchoose_by_signedness | |
| Cchoose_by_size | |
| CCirclePath | |
| Ccircular_buffer | |
| Ccircular_buffer_core | |
| CCLEDController | |
| CClocklessChipset | Clockless chipset configuration (single data pin) |
| Ccommon_type | |
| Ccommon_type_impl | |
| Ccommon_type_impl< double, float > | |
| Ccommon_type_impl< double, long double > | |
| Ccommon_type_impl< double, T, typename enable_if<(is_integral< T >::value||is_floating_point< T >::value) &&!is_same< T, double >::value >::type > | |
| Ccommon_type_impl< float, double > | |
| Ccommon_type_impl< float, long double > | |
| Ccommon_type_impl< float, T, typename enable_if<(is_integral< T >::value||is_floating_point< T >::value) &&!is_same< T, float >::value >::type > | |
| Ccommon_type_impl< i8, u8, void > | |
| Ccommon_type_impl< long double, double > | |
| Ccommon_type_impl< long double, float > | |
| Ccommon_type_impl< T, double, typename enable_if<(is_integral< T >::value||is_floating_point< T >::value) &&!is_same< T, double >::value >::type > | |
| Ccommon_type_impl< T, float, typename enable_if<(is_integral< T >::value||is_floating_point< T >::value) &&!is_same< T, float >::value >::type > | |
| Ccommon_type_impl< T, T > | |
| Ccommon_type_impl< T, U, typename enable_if< is_integral< T >::value &&is_integral< U >::value &&!is_same< T, U >::value &&!((is_same< T, i8 >::value &&is_same< U, u8 >::value)||(is_same< T, u8 >::value &&is_same< U, i8 >::value))>::type > | |
| Ccommon_type_impl< u8, i8, void > | |
| CComplex_Kaleido | |
| CComplex_Kaleido_2 | |
| CComplex_Kaleido_2_FP | |
| CComplex_Kaleido_3 | |
| CComplex_Kaleido_3_FP | |
| CComplex_Kaleido_4 | |
| CComplex_Kaleido_4_FP | |
| CComplex_Kaleido_5 | |
| CComplex_Kaleido_5_FP | |
| CComplex_Kaleido_6 | |
| CComplex_Kaleido_6_FP | |
| CComplex_Kaleido_FP | |
| Cconditional | |
| Cconditional< false, T, F > | |
| CConnectionConfig | |
| CConstCharPtrWrapper | |
| CConstSpanWrapper | |
| Ccontains_type | |
| Ccontains_type< T > | |
| Ccontains_type< T, U, Rest... > | |
| CContext | |
| CCopyToOutputIteratorVisitor | |
| CCopyToVisitor | |
| ►CCorkscrew | |
| Citerator | |
| CCRGB | Representation of an 8-bit RGB pixel (Red, Green, Blue) |
| CCRGB.__unnamed0__ | |
| CCRGB.__unnamed0__.__unnamed0__ | |
| CCRGB.__unnamed0__.__unnamed0__.__unnamed0__ | |
| CCRGB.__unnamed0__.__unnamed0__.__unnamed1__ | |
| CCRGB.__unnamed0__.__unnamed0__.__unnamed2__ | |
| CCRGB16 | |
| CCRGBA5 | |
| CCustomTimingTraits | Helper to create timing traits from individual timing values Useful for creating custom timing configurations at compile-time |
| CCylon | An animation that moves a single LED back and forth (Larson Scanner effect) |
| CDCBlocker | |
| Cdec_t | |
| Cdecay | |
| Cdefault_delete | |
| Cdefault_delete< T[]> | |
| Cdefault_value_visitor | |
| CDefaultBus | Per-platform default bus for a given chipset family |
| CDemoReel100 | |
| ►Cdeque | |
| Cconst_iterator | |
| Citerator | |
| ►CDigitalMultiWrite16 | Pre-computed nibble LUT for fast 16-pin digital writes |
| CPinList | |
| ►CDigitalMultiWrite8 | Pre-computed nibble LUT for fast 8-pin digital writes |
| CPinList | |
| CDigitalPin | |
| CDigitalPinImpl | |
| CDiodeProfile | |
| CDistance_Experiment | |
| CDistance_Experiment_FP | |
| CDrawContext | |
| CDrawItem | |
| CDriverFailureInfo | Driver failure tracking with detailed error information |
| CDriverInfo | Driver state information for channel manager |
| CDriverTestResult | Driver test result tracking (moved from ValidationTest.h) |
| CEdgeRange | Edge range specification for getRawEdgeTimes() debugging |
| CEdgeTime | Universal edge timing representation (platform-agnostic) |
| CEmpty | |
| Cenable_if | |
| Cenable_if< true, T > | |
| Cendl_t | |
| CEngine | |
| ►CEngineEvents | |
| CListener | |
| CEqLevels | Snapshot of 16-bin normalized spectrum |
| CEqualTo | |
| CErrorInfo | Error information for expected type |
| Cexpected | Expected type for operations that can fail (C++23-style) |
| Cexpected< void, E > | Specialization for void (no value to return) |
| CExponentialSmoother | |
| CFastHash | |
| CFastHash< vec2< T > > | |
| CFastLEDAdapter | Real FastLED implementation adapter |
| CFILE_impl | |
| Cfilebuf | |
| CFileSystem | |
| CFire2012 | |
| Cfixed_point | |
| ►Cfixed_point_base | |
| CRawTag | |
| Cfixed_point_impl | |
| Cfixed_point_impl< 0, 32, Sign::SIGNED > | |
| Cfixed_point_impl< 0, 32, Sign::UNSIGNED > | |
| Cfixed_point_impl< 12, 4, Sign::SIGNED > | |
| Cfixed_point_impl< 12, 4, Sign::UNSIGNED > | |
| Cfixed_point_impl< 16, 16, Sign::SIGNED > | |
| Cfixed_point_impl< 16, 16, Sign::UNSIGNED > | |
| Cfixed_point_impl< 24, 8, Sign::SIGNED > | |
| Cfixed_point_impl< 24, 8, Sign::UNSIGNED > | |
| Cfixed_point_impl< 4, 12, Sign::SIGNED > | |
| Cfixed_point_impl< 4, 12, Sign::UNSIGNED > | |
| Cfixed_point_impl< 8, 24, Sign::SIGNED > | |
| Cfixed_point_impl< 8, 24, Sign::UNSIGNED > | |
| Cfixed_point_impl< 8, 8, Sign::SIGNED > | |
| Cfixed_point_impl< 8, 8, Sign::UNSIGNED > | |
| Cfixed_point_traits | |
| ►CFixedVector | |
| Cconst_reverse_iterator | |
| Creverse_iterator | |
| Cflat_map | |
| Cflat_set | |
| Cfloat_conversion_visitor | |
| Cfloat_conversion_visitor< double > | |
| CFlowField | Abstract base class for 2D flow field effects |
| ►CFlowFieldFloat | Float-precision flow field implementation |
| CPerlin2D | |
| CFlowFieldFP | Pure fixed-point (s16x16) flow field implementation for maximum speed |
| CFlowFieldFPState | SoA (Structure-of-Arrays) state for FlowFieldFP |
| CFlowFieldParams | Configuration parameters for FlowField |
| CFluffy_Blobs | |
| CFluffy_Blobs_FP | |
| CFont | |
| CFontImpl | |
| CFontMetrics | |
| ►CFontRenderer | |
| CScaledMetrics | |
| Cforward_iterator_tag | |
| CFrame | |
| ►CFsImpl | |
| CVisitor | |
| Cfstream | |
| Cfunction | |
| Cfunction_traits | |
| Cfunction_traits< fl::function< R(Args...)> > | |
| Cfunction_traits< R(*)(Args...)> | |
| Cfunction_traits< R(Args...)> | |
| CFx | |
| CFx1d | |
| CFx2d | |
| CFx2dTo1d | Fx2dTo1d samples a 2D effect into a 1D LED strip using a ScreenMap |
| CFxCompositor | |
| CFxEngine | Manages and renders multiple visual effects (Fx) for LED strips |
| CFxLayer | |
| CGamma8 | |
| ►CGamma8Impl | |
| Cfrom_progmem_lut_tag | |
| CGammaEval | |
| CGammaEval16 | |
| CGap | Struct representing gap parameters for corkscrew mapping |
| CGaussianFilter | |
| CGielisCurveParams | |
| CGielisCurvePath | |
| CGif | |
| CGifConfig | |
| CGifInfo | |
| CGlyphBitmap | |
| CGlyphMetrics | |
| CGradient | |
| CGradientInlined | |
| Cgreater | Binary function object that returns whether the first argument is greater than the second |
| Cgreater< void > | Specialization of greater for void, allowing for transparent comparisons |
| CGrid | |
| CH264 | |
| CH264Config | |
| CH264Info | |
| CHampelFilter | |
| Chas_data_and_size | |
| Chas_data_method | |
| Chas_encoder | |
| ►Chas_member_swap | |
| Chelper | |
| Chas_size_method | |
| CHash | |
| CHash< audio::fft::Args > | |
| CHash< bool > | |
| CHash< double > | |
| CHash< fl::shared_ptr< T > > | |
| CHash< fl::string > | |
| CHash< fl::string_view > | |
| CHash< fl::u8 > | |
| CHash< float > | |
| CHash< i16 > | |
| CHash< i32 > | |
| CHash< i8 > | |
| CHash< T * > | |
| CHash< u16 > | |
| CHash< u32 > | |
| CHash< vec2< T > > | |
| ►CHashMapLru | |
| CValueWithTimestamp | |
| CHashSet | |
| CHeapInfo | Heap memory information |
| CHeartPath | |
| Chex_t | |
| CHot_Blob | |
| CHot_Blob_FP | |
| CHSV16 | |
| Chsv8 | Representation of an HSV pixel (hue, saturation, value (aka brightness)) |
| Chsv8.__unnamed0__ | |
| Chsv8.__unnamed0__.__unnamed0__ | |
| Chsv8.__unnamed0__.__unnamed0__.__unnamed0__ | |
| Chsv8.__unnamed0__.__unnamed0__.__unnamed1__ | |
| Chsv8.__unnamed0__.__unnamed0__.__unnamed2__ | |
| CHttpConnection | |
| CHttpRequest | |
| CHttpRequestParser | |
| CHttpResponse | |
| CHttpResponseParser | |
| CIAnimartrix2Viz | |
| CIButtonInput | |
| CIChannel | Polymorphic identification base for any channel in the system |
| ►CIChannelDriver | Minimal interface for LED channel transmission drivers |
| CCapabilities | Driver capabilities |
| CDriverState | Driver state with optional error message |
| CPollNeededCallback | ISR-safe callback handle invoked when the manager should poll again |
| ►CPollNeededCallbackSlot | ISR-safe storage for a poll-needed callback handle |
| CSnapshot | |
| CIDecoder | |
| Cidentity | |
| CIdTracker | Thread-safe ID tracker that maps void* pointers to unique integer IDs |
| CIEEE754binary32_t | Typedef for IEEE754 "binary32" float type internals |
| CIEEE754binary32_t.__unnamed0__ | |
| CIEEE754binary32_t.__unnamed1__ | |
| CIEEE754binary32_t.__unnamed2__ | |
| CIFastLED | Pure virtual interface for FastLED operations |
| Cifstream | |
| Cindex_sequence | |
| Cinput_iterator_tag | |
| Cint_conversion_visitor | |
| Cint_conversion_visitor< i64 > | |
| Cinteger_promotion_impl | |
| Cintegral_constant | |
| Cis_arithmetic | |
| Cis_arithmetic< const T > | |
| Cis_arithmetic< T & > | |
| Cis_arithmetic< volatile T > | |
| Cis_array | |
| Cis_array< T[]> | |
| Cis_array< T[N]> | |
| Cis_base_of | |
| Cis_base_of_v_helper | |
| Cis_bitcast_compatible | |
| Cis_bitcast_compatible< const T > | |
| Cis_bitcast_compatible< T * > | |
| Cis_char_type | |
| Cis_char_type< char > | |
| Cis_char_type< const T > | |
| Cis_char_type< signed char > | |
| Cis_char_type< T & > | |
| Cis_char_type< unsigned char > | |
| Cis_char_type< volatile T > | |
| Cis_const | |
| Cis_const< const T > | |
| Cis_enum | |
| Cis_fixed_point | |
| Cis_fixed_point< const T > | |
| Cis_fixed_point< const volatile T > | |
| Cis_fixed_point< fixed_point< I, F, S > > | |
| Cis_fixed_point< T & > | |
| Cis_fixed_point< volatile T > | |
| Cis_floating_point | |
| Cis_floating_point< const T > | |
| Cis_floating_point< double > | |
| Cis_floating_point< float > | |
| Cis_floating_point< long double > | |
| Cis_floating_point< T & > | |
| Cis_floating_point< volatile T > | |
| Cis_fp_promotable | |
| Cis_fp_promotable< fixed_point< FromInt, FromFrac, FromSign >, fixed_point< ToInt, ToFrac, ToSign > > | |
| Cis_function | |
| Cis_function< Ret(Args...) const > | |
| Cis_function< Ret(Args...) const volatile > | |
| Cis_function< Ret(Args...) volatile > | |
| Cis_function< Ret(Args...)> | |
| Cis_integral | |
| Cis_integral< bool > | |
| Cis_integral< char > | |
| Cis_integral< const T > | |
| Cis_integral< int > | |
| Cis_integral< long > | |
| Cis_integral< long long > | |
| Cis_integral< short > | |
| Cis_integral< signed char > | |
| Cis_integral< T & > | |
| Cis_integral< unsigned char > | |
| Cis_integral< unsigned int > | |
| Cis_integral< unsigned long > | |
| Cis_integral< unsigned long long > | |
| Cis_integral< unsigned short > | |
| Cis_integral< volatile T > | |
| Cis_lvalue_reference | |
| Cis_lvalue_reference< T & > | |
| Cis_member_function_pointer | |
| Cis_member_function_pointer< Ret(C::*)(A...) const > | |
| Cis_member_function_pointer< Ret(C::*)(A...)> | |
| Cis_multi_byte_integer | |
| Cis_pod | |
| Cis_pod< bool > | |
| Cis_pod< char > | |
| Cis_pod< double > | |
| Cis_pod< float > | |
| Cis_pod< int > | |
| Cis_pod< long > | |
| Cis_pod< long double > | |
| Cis_pod< long long > | |
| Cis_pod< short > | |
| Cis_pod< signed char > | |
| Cis_pod< unsigned char > | |
| Cis_pod< unsigned int > | |
| Cis_pod< unsigned long > | |
| Cis_pod< unsigned long long > | |
| Cis_pod< unsigned short > | |
| Cis_pod_v_helper | |
| Cis_pointer | |
| Cis_pointer< T * > | |
| Cis_pointer< T *const > | |
| Cis_pointer< T *const volatile > | |
| Cis_pointer< T *volatile > | |
| Cis_reference | |
| Cis_response_send | |
| Cis_response_send< const ResponseSend & > | |
| Cis_response_send< ResponseSend & > | |
| Cis_response_send< ResponseSend && > | |
| Cis_response_send< ResponseSend > | |
| Cis_rvalue_reference | |
| Cis_rvalue_reference< T && > | |
| Cis_same | |
| Cis_same< T, T > | |
| Cis_same_v_helper | |
| Cis_signed | |
| Cis_signed< char > | |
| Cis_signed< const T > | |
| Cis_signed< const volatile T > | |
| Cis_signed< double > | |
| Cis_signed< float > | |
| Cis_signed< int > | |
| Cis_signed< long > | |
| Cis_signed< long double > | |
| Cis_signed< long long > | |
| Cis_signed< short > | |
| Cis_signed< signed char > | |
| Cis_signed< volatile T > | |
| Cis_trivially_copyable | |
| Cis_trivially_copyable_v_helper | |
| Cis_void | |
| Cis_void< void > | |
| Cistream | |
| Cistream_real | |
| Citerator_traits | Iterator traits - provides standard typedefs for any iterator type Specializations provided for raw pointers Generic version - tries to extract nested typedefs, provides defaults if missing |
| Citerator_traits< const T * > | Specialization for const raw pointers |
| Citerator_traits< T * > | Specialization for raw pointers |
| CJpeg | |
| CJpegConfig | |
| ►CJpegDecoder | |
| CImpl | |
| CJpegInfo | |
| Cjson | |
| ►Cjson_value | |
| Carray_iterator | |
| ►Cconst_iterator | |
| CKeyValue | |
| CIsArrayVisitor | |
| ►Citerator | |
| CKeyValue | |
| CJsonArgConverter | |
| CJsonArgConverter< R()> | |
| Cjust8bits | Structure representing 8 bits of access |
| Cjust8bits.__unnamed0__ | |
| CKalmanFilter | |
| CLava1 | |
| CLava1_FP | |
| CLeakyIntegrator | |
| CLEDError | LED error information for a single run |
| CLeds | |
| CLedsXY | |
| Cless | Binary function object that returns whether the first argument is less than the second |
| Cless< void > | Specialization of less for void, allowing for transparent comparisons |
| Cline_xy | |
| CLinePath | |
| CLinePathParams | |
| CLineSimplifier | |
| CLineSimplifierExact | |
| ►Clist | A doubly-linked list container |
| Cconst_iterator | |
| Citerator | |
| CNode | |
| CLnkMetadata | Metadata extracted from a .lnk asset link file |
| ►CLuminova | |
| CParticle | |
| CLuminovaParams | |
| CLUT | |
| Cmake_index_sequence_impl | |
| Cmake_index_sequence_impl< 0, Is... > | |
| Cmake_unsigned | |
| Cmake_unsigned< T, typename enable_if< is_integral< T >::value &&!is_same< typename remove_cv< T >::type, bool >::value >::type > | |
| ►CMapRedBlackTree | |
| CPairCompare | |
| Cvalue_compare | |
| CMatrix3x3f | |
| CMatrixSlice | |
| Cmax_align | |
| Cmax_align< T, Rest... > | |
| Cmax_align<> | |
| Cmax_align_selector | |
| Cmax_align_selector< false > | |
| Cmax_size | |
| Cmax_size< T, Rest... > | |
| Cmax_size<> | |
| CMedianFilter | |
| Cmemory_resource | Polymorphic memory resource base class (PMR-style) |
| CMethodInfo | Method information |
| Cmodulators | |
| CModule_Experiment1 | |
| CModule_Experiment10 | |
| CModule_Experiment10_FP | |
| CModule_Experiment1_FP | |
| CModule_Experiment2 | |
| CModule_Experiment2_FP | |
| CModule_Experiment3 | |
| CModule_Experiment3_FP | |
| CModule_Experiment4 | |
| CModule_Experiment4_FP | |
| CModule_Experiment5 | |
| CModule_Experiment5_FP | |
| CModule_Experiment6 | |
| CModule_Experiment6_FP | |
| CModule_Experiment7 | |
| CModule_Experiment7_FP | |
| CModule_Experiment8 | |
| CModule_Experiment8_FP | |
| CModule_Experiment9 | |
| CModule_Experiment9_FP | |
| CMovingAverage | |
| CMp3 | |
| CMp3Decoder | |
| CMp3Info | |
| CMp4TrackInfo | |
| CMpeg1 | |
| CMpeg1FileHandle | |
| CMpeg1Info | |
| CMultiChannelConfig | |
| CMultiMap | |
| ►CMultiMapTree | |
| CConstIteratorWrapper | |
| CConstReverseIteratorWrapper | |
| CIteratorWrapper | |
| CPairCompareWithId | |
| CReverseIteratorWrapper | |
| Cvalue_compare | |
| CValueWithId | |
| CMultiRunConfig | Multi-run test configuration |
| CMultiSet | |
| ►CMultiSetTree | |
| CConstIteratorWrapper | |
| CConstReverseIteratorWrapper | |
| CKeyCompareWithId | |
| CValueWithId | |
| CNamedTimingConfig | Chipset timing configuration with name for testing |
| CNoiseBias1D | Per-position attack/decay bias for one axis |
| CNoiseBias2D | Two-axis attack/decay bias for 2D effects (per-column X + per-row Y) |
| CNoisePalette | |
| CNoiseWave | |
| Cnot_null | |
| CNullDecoder | |
| CNullFileHandle | |
| CNullFileSystem | |
| Cnullopt_t | |
| Cnumeric_limits | |
| Cnumeric_limits< bool > | |
| Cnumeric_limits< char > | |
| Cnumeric_limits< double > | |
| Cnumeric_limits< float > | |
| Cnumeric_limits< int > | |
| Cnumeric_limits< long > | |
| Cnumeric_limits< long long > | |
| Cnumeric_limits< short > | |
| Cnumeric_limits< signed char > | |
| Cnumeric_limits< unsigned char > | |
| Cnumeric_limits< unsigned int > | |
| Cnumeric_limits< unsigned long > | |
| Cnumeric_limits< unsigned long long > | |
| Cnumeric_limits< unsigned short > | |
| CNumericExtractVisitor | |
| CObjectFLED | |
| Coct_t | |
| Cofstream | |
| COneEuroFilter | |
| COptional | |
| COptional< T && > | |
| Coscillators | |
| Costream | |
| Coutput_iterator_tag | |
| CPacifica | |
| Cpair | |
| Cpair_element | |
| Cpair_element< 0, T1, T2 > | |
| Cpair_element< 1, T1, T2 > | |
| Cpair_xy | |
| CParametric_Water | |
| CParametric_Water_FP | |
| CParamInfo | Method parameter information |
| Cparse_result | |
| ►CParticles1d | Power-based particle system for 1D LED strips creating organic light effects |
| CParticle | Individual particle with power-based lifecycle |
| CPercussionState | Snapshot of percussion detection state |
| Cperlin_i16_optimized | |
| Cperlin_q16 | |
| Cperlin_s16x16 | |
| Cperlin_s16x16_simd | |
| Cperlin_s8x8 | |
| ►CPerlinParticlePunch | |
| CAmbientParticle | |
| CDebrisParticle | |
| CMeteorParticle | |
| CPhyllotaxisParams | |
| CPhyllotaxisPath | |
| CPinInfo | Pin number with its resolved port ID |
| CPins16 | POD struct holding 16 pin numbers for bulk pin writes |
| CPins8 | POD struct holding 8 pin numbers for bulk pin writes |
| CPir | |
| CPirLowLevel | |
| CPixelControllerVtable | |
| CPixelIterator | |
| CPixelIteratorAny | Adapter class that creates a PixelIterator from any color order |
| CPointPath | |
| CPolar_Waves | |
| CPolar_Waves_FP | |
| ►CPotentiometer | |
| CListener | |
| CPotentiometerLowLevel | |
| CPride2015 | |
| ►Cpriority_queue_stable | Stable priority queue that maintains FIFO ordering for equal-priority elements |
| CStableElement | |
| CPriorityQueue | |
| CProgmemLUT | |
| CProgmemLUT16 | |
| CProgressiveConfig | |
| CPSRamAllocator | |
| CPSRamDeleter | |
| Cqfx | Template class for representing fractional ints |
| Cqueue | A first-in, first-out (FIFO) queue container adapter |
| Crandom_access_iterator_tag | |
| Cratio | Compile-time rational arithmetic |
| Crect | |
| CRectangularDrawBuffer | |
| ►CRedBlackTree | |
| Cconst_iterator | |
| Cconst_reverse_iterator | |
| Citerator | |
| CRBNode | |
| Creverse_iterator | |
| ►CRedSquare | |
| CMath | |
| ►CRemote | JSON-RPC server with scheduling support |
| CAsyncRequest | |
| Cremove_const | |
| Cremove_const< const T > | |
| Cremove_cv | |
| Cremove_cv< const T > | |
| Cremove_cv< const volatile T > | |
| Cremove_cv< volatile T > | |
| Cremove_extent | |
| Cremove_extent< T[]> | |
| Cremove_extent< T[N]> | |
| Cremove_pointer | |
| Cremove_pointer< T * > | |
| Cremove_pointer< T *const > | |
| Cremove_pointer< T *const volatile > | |
| Cremove_pointer< T *volatile > | |
| Cremove_reference | |
| Cremove_reference< T & > | |
| Cremove_reference< T && > | |
| Crender_parameters | |
| Crender_parameters_fp | |
| CResetInfo | Detailed reset information bundling the normalized cause with a platform-specific subcause id and the raw cause-register value |
| Cresponse_aware_signature | Type trait to detect if a function signature has ResponseSend& as first parameter |
| Cresponse_aware_signature< R(*)(ResponseSend &, Args...)> | |
| Cresponse_aware_signature< R(ResponseSend &, Args...)> | |
| CResponseSend | Helper class for sending responses in async/streaming RPC methods |
| Creverse_iterator | Reverse iterator adapter - reverses the direction of a bidirectional iterator |
| Crgb | |
| CRGB_Blobs | |
| CRGB_Blobs2 | |
| CRGB_Blobs2_FP | |
| CRGB_Blobs3 | |
| CRGB_Blobs3_FP | |
| CRGB_Blobs4 | |
| CRGB_Blobs4_FP | |
| CRGB_Blobs5 | |
| CRGB_Blobs5_FP | |
| CRGB_Blobs_FP | |
| CRgbw | |
| CRgbwDefault | |
| CRgbwInvalid | |
| CRGBWPixel | Simple RGBW pixel struct for encoder input |
| CRgbww | Per-strip RGBWW configuration |
| CRgbwwDefault | Default RGBWW configuration: colorimetric mode at warm=2700K / cool=6500K, default profile, end-aligned warm-then-cool W byte placement |
| CRgbwWhiteIsOff | |
| CRgbwwInvalid | Sentinel: disables RGBWW (variant should hold fl::Empty instead, but this is kept for symmetry with RgbwInvalid) |
| CRGBWWPixel | Simple 5-channel pixel struct: red, green, blue, warm-white, cool-white |
| CRings | |
| CRings_FP | |
| CRosePath | |
| CRosePathParams | |
| CRotating_Blob | |
| CRotating_Blob_FP | |
| ►CRpc | |
| CConfig | Configuration for method registration with optional metadata |
| Crpc_storage_type | |
| Crpc_storage_type< char * > | |
| Crpc_storage_type< const char * > | |
| Crpc_storage_type< fl::span< const double > > | |
| Crpc_storage_type< fl::span< const fl::string > > | |
| Crpc_storage_type< fl::span< const float > > | |
| Crpc_storage_type< fl::span< const int > > | |
| Crpc_storage_type< fl::span< const T > > | |
| CRpcHandle | |
| CRpcHandle< R(Args...)> | |
| CRpcResult | Result metadata for executed RPC calls |
| CRunResult | Single run result with error tracking |
| CRxChannel | |
| CRxChannelConfig | |
| CRxConfig | Configuration for RX device initialization |
| CRxDevice | Common interface for RX devices |
| ►Cs0x32 | |
| CRawTag | |
| Cs0x32x4 | 4-wide s0x32 vector (normalized values [-1, 1]) Backed by 128-bit SIMD register (4× i32 in Q31 format) |
| ►Cs12x4 | |
| CRawTag | |
| ►Cs16x16 | |
| CRawTag | |
| Cs16x16x4 | 4-wide s16x16 vector (general fixed-point) Backed by 128-bit SIMD register (4× i32 in Q16 format) |
| ►Cs24x8 | |
| CRawTag | |
| ►Cs4x12 | |
| CRawTag | |
| ►Cs8x24 | |
| CRawTag | |
| ►Cs8x8 | |
| CRawTag | |
| CSavitzkyGolayFilter | |
| CScaledemo1 | |
| CScaledemo1_FP | |
| CScaleUp | Effect wrapper that upscales delegate effects using bilinear interpolation |
| Cscope_exit | RAII guard that executes a callable when destroyed |
| CScopedLogDisable | RAII class to temporarily disable all logging output |
| CScopedTrace | RAII guard for automatic call stack tracking |
| CScopedWatchdog | RAII watchdog guard for the canonical loop()-top use case |
| CScreenMap | |
| CSerializerVisitor | |
| CSerialPort | Arduino-compatible Serial class for cross-platform serial I/O |
| CSerialReader | Serial adapter using fl:: input functions (fl::available, fl::read) |
| CSerialWriter | Serial adapter using fl:: output functions (fl::println) |
| CServer | JSON-RPC server with callback-based I/O |
| Cset | |
| CSetRedBlackTree | |
| Cshared_ptr | |
| CSinCos32 | |
| CSingleTestConfig | Single test configuration - fully stateless |
| CSingleTestResult | Single test result - comprehensive pass/fail information |
| CSingleton | |
| CSingletonShared | |
| CSingletonThreadLocal | |
| CSizeVisitor | |
| ►CSlabAllocator | |
| CSlab | |
| CSlow_Fade | |
| CSlow_Fade_FP | |
| CSmallMapEqualTo | |
| CSortedHeapVector | |
| Cspan | |
| Cspan< T, dynamic_extent > | |
| CSpectralVariance | |
| CSpi | SPI Device - RAII wrapper for multi-lane SPI |
| ►CSpiChannelEngineAdapter | Adapter that wraps HW SPI controllers for ChannelManager |
| CClockPinAssignment | |
| CClockPinGroup | Group data structure for channels with same clock pin |
| CControllerInfo | Information about a registered SPI hardware controller |
| CSpiChipsetConfig | SPI chipset configuration (data + clock pins) |
| CSpiConfig | Configuration for SPI device (supports 1-8 lanes) |
| CSpiEncoder | SPI encoder configuration for LED protocols |
| CSpiralMatrix1 | |
| CSpiralMatrix10 | |
| CSpiralMatrix10_FP | |
| CSpiralMatrix1_FP | |
| CSpiralMatrix2 | |
| CSpiralMatrix2_FP | |
| CSpiralMatrix3 | |
| CSpiralMatrix3_FP | |
| CSpiralMatrix4 | |
| CSpiralMatrix4_FP | |
| CSpiralMatrix5 | |
| CSpiralMatrix5_FP | |
| CSpiralMatrix6 | |
| CSpiralMatrix6_FP | |
| CSpiralMatrix8 | |
| CSpiralMatrix8_FP | |
| CSpiralMatrix9 | |
| CSpiralMatrix9_FP | |
| CSpiralus | |
| CSpiralus2 | |
| CSpiralus2_FP | |
| CSpiralus_FP | |
| ►CSPITransposer | Unified stateless bit-interleaving transposer for multi-lane SPI parallel LED transmission |
| CLaneData | Lane data structure: payload + padding frame |
| Csstream | |
| Csstream_noop | |
| Cstatic_assert_failure | |
| Cstatic_assert_failure< true > | |
| CStbVorbisDecoder | |
| Cstring | |
| Cstring_n | |
| Cstring_view | |
| CStringConversionVisitor | |
| CStringFastLess | |
| CStringHolder | |
| CStringInterner | |
| Csub4 | Structure representing 32 bits of access |
| Cswap_impl | |
| Cswap_impl< T, false > | |
| Cswap_impl< T, true > | |
| CTestContext | Test context for detailed error reporting Aggregates all test configuration parameters for error messages |
| CThreadLocalFake | |
| CTile2x2_u8 | |
| CTile2x2_u8_wrap | |
| CTimeAlpha | |
| CTimeClampedTransition | |
| CTimeFunction | |
| CTimeout | Generic timeout timer with rollover-safe arithmetic |
| CTimeRamp | |
| CTimeWarp | |
| CTIMING_DP1903_400KHZ | DP1903 controller @ 400 kHz Four-phase: TH0=800ns, TH1=2400ns, TL0=2400ns, TL1=800ns |
| CTIMING_DP1903_800KHZ | DP1903 controller @ 800 kHz Four-phase: TH0=400ns, TH1=1400ns, TL0=1400ns, TL1=400ns |
| CTIMING_GE8822_800KHZ | GE8822 RGB controller @ 800 kHz Four-phase: TH0=350ns, TH1=1010ns, TL0=1010ns, TL1=350ns |
| CTIMING_GW6205_400KHZ | GW6205 controller @ 400 kHz Four-phase: TH0=800ns, TH1=1600ns, TL0=1600ns, TL1=800ns |
| CTIMING_GW6205_800KHZ | GW6205 controller @ 800 kHz (fast variant) Four-phase: TH0=400ns, TH1=800ns, TL0=800ns, TL1=400ns |
| CTIMING_LPD1886_1250KHZ | LPD1886 RGB controller @ 1250 kHz Four-phase: TH0=200ns, TH1=600ns, TL0=600ns, TL1=200ns |
| CTIMING_PL9823 | PL9823 RGB controller @ 800 kHz Four-phase: TH0=350ns, TH1=1360ns, TL0=1360ns, TL1=350ns |
| CTIMING_SK6812 | SK6812 RGBW controller @ 800 kHz Four-phase: TH0=300ns, TH1=900ns, TL0=900ns, TL1=300ns |
| CTIMING_SK6822 | SK6822 RGB controller @ 800 kHz Four-phase: TH0=375ns, TH1=1375ns, TL0=1375ns, TL1=375ns |
| CTIMING_SM16703 | SM16703 RGB controller @ 800 kHz Four-phase: TH0=300ns, TH1=900ns, TL0=900ns, TL1=300ns |
| CTIMING_SM16824E | SM16824E RGB controller (high-speed variant) Four-phase: TH0=300ns, TH1=1200ns, TL0=1000ns, TL1=100ns |
| CTIMING_TM1803_400KHZ | TM1803 controller @ 400 kHz Four-phase: TH0=700ns, TH1=1800ns, TL0=1800ns, TL1=700ns |
| CTIMING_TM1809_800KHZ | TM1809 RGB controller @ 800 kHz Four-phase: TH0=350ns, TH1=700ns, TL0=800ns, TL1=450ns |
| CTIMING_TM1814 | TM1814 RGBW controller @ 800 kHz Four-phase: TH0=360ns, TH1=960ns, TL0=940ns, TL1=340ns |
| CTIMING_TM1829_1600KHZ | TM1829 RGB controller @ 1600 kHz (high-speed variant) Four-phase: TH0=100ns, TH1=400ns, TL0=500ns, TL1=200ns |
| CTIMING_TM1829_800KHZ | TM1829 RGB controller @ 800 kHz Four-phase: TH0=340ns, TH1=680ns, TL0=890ns, TL1=550ns |
| CTIMING_UCS1903_400KHZ | UCS1903 controller @ 400 kHz Four-phase: TH0=500ns, TH1=2000ns, TL0=2000ns, TL1=500ns |
| CTIMING_UCS1903B_800KHZ | UCS1903B controller @ 800 kHz Four-phase: TH0=400ns, TH1=850ns, TL0=900ns, TL1=450ns |
| CTIMING_UCS1904_800KHZ | UCS1904 controller @ 800 kHz Four-phase: TH0=400ns, TH1=800ns, TL0=850ns, TL1=450ns |
| CTIMING_UCS1912 | UCS1912 controller @ 800 kHz Four-phase: TH0=250ns, TH1=1250ns, TL0=1350ns, TL1=350ns |
| CTIMING_UCS2903 | UCS2903 controller @ 800 kHz Four-phase: TH0=250ns, TH1=1000ns, TL0=1000ns, TL1=250ns |
| CTIMING_UCS7604_1600KHZ | UCS7604 RGBW controller @ 1600 kHz (16-bit color depth, high-speed) Four-phase: TH0=200ns, TH1=400ns, TL0=425ns, TL1=225ns |
| CTIMING_UCS7604_800KHZ | UCS7604 RGBW controller @ 800 kHz (16-bit color depth) Four-phase: TH0=400ns, TH1=800ns, TL0=850ns, TL1=450ns |
| CTIMING_UCS7604_8BIT_800KHZ | UCS7604 RGBW controller @ 800 kHz (8-bit color depth) Same wire timing as 16-bit 800KHz, but uses 8-bit encoding mode |
| CTIMING_WS2811_400KHZ | WS2811 @ 400kHz (standard mode, datasheet specification) |
| CTIMING_WS2811_800KHZ_LEGACY | WS2811 @ 800kHz (fast mode, half the timing of 400kHz mode) |
| CTIMING_WS2812_800KHZ | WS2812 RGB controller @ 800 kHz (most common, overclockable) Four-phase: TH0=250ns, TH1=875ns, TL0=1000ns, TL1=375ns |
| CTIMING_WS2812_800KHZ_LEGACY | WS2812 RGB controller @ 800 kHz legacy variant Four-phase: TH0=320ns, TH1=640ns, TL0=960ns, TL1=640ns |
| CTIMING_WS2812B_MINI_V3 | WS2812B-Mini-V3 / WS2812B-V5 RGB controller @ 800 kHz Four-phase: TH0=225ns, TH1=580ns, TL0=1000ns, TL1=645ns These newer variants share identical timing specifications with tighter tolerances |
| CTIMING_WS2813 | WS2813 RGB controller (same timing as WS2812) Four-phase: TH0=320ns, TH1=640ns, TL0=960ns, TL1=640ns |
| CTIMING_WS2815 | WS2815 RGB controller @ 400 kHz Four-phase: TH0=250ns, TH1=1340ns, TL0=1640ns, TL1=550ns |
| CTimingTraits | Compile-time trait to extract timing values from timing types |
| CTraceEntry | A single stack trace entry with location information |
| CTraceStorage | Internal storage for the trace system Encapsulates call stack and depth tracking per-thread |
| CTransform16 | |
| CTransformFloat | |
| CTransformFloatImpl | |
| CTransition | |
| CTriangularFilter | |
| Ctuple | |
| Ctuple< Head, Tail... > | |
| Ctuple_element | |
| Ctuple_element< 0, pair< T1, T2 > > | |
| Ctuple_element< 0, tuple< Head, Tail... > > | |
| Ctuple_element< 1, pair< T1, T2 > > | |
| Ctuple_element< I, tuple< Head, Tail... > > | |
| Ctuple_size | |
| Ctuple_size< pair< T1, T2 > > | |
| Ctuple_size< tuple< Ts... > > | |
| CTwinkleFox | |
| Ctype_rank | |
| Ctype_rank< bool > | |
| Ctype_rank< char > | |
| Ctype_rank< double > | |
| Ctype_rank< float > | |
| Ctype_rank< int > | |
| Ctype_rank< long > | |
| Ctype_rank< long double > | |
| Ctype_rank< long long > | |
| Ctype_rank< short > | |
| Ctype_rank< signed char > | |
| Ctype_rank< unsigned char > | |
| Ctype_rank< unsigned int > | |
| Ctype_rank< unsigned long > | |
| Ctype_rank< unsigned long long > | |
| Ctype_rank< unsigned short > | |
| CTypeConversionResult | |
| CTypedChannel | Templated channel facade |
| CTypedRpcBinding | |
| CTypedRpcBinding< R(Args...)> | |
| CTypedRpcBinding< void(Args...)> | |
| ►Cu0x32 | |
| CRawTag | |
| ►Cu12x4 | |
| CRawTag | |
| ►Cu16x16 | |
| CRawTag | |
| ►Cu24x8 | |
| CRawTag | |
| ►Cu4x12 | |
| CRawTag | |
| ►Cu8x24 | |
| CRawTag | |
| ►Cu8x8 | |
| CRawTag | |
| ►CUCS7604ControllerT | UCS7604 controller extending CPixelLEDController |
| CDelegateController | |
| CUCS7604CurrentControl | UCS7604 current control structure with 4-bit fields for each channel |
| CUIAudio | |
| CUIAudioImpl | |
| ►CUIButton | |
| CListener | |
| CUIButtonImpl | |
| ►CUICheckbox | |
| CListener | |
| CUICheckboxImpl | |
| CUIDescription | |
| CUIDescriptionImpl | |
| ►CUIDropdown | |
| CListener | |
| CUIDropdownImpl | |
| CUIElement | |
| CUIGroup | |
| CUIGroupImpl | |
| CUIHelp | |
| CUIHelpImpl | |
| ►CUINumberField | |
| CListener | |
| CUINumberFieldImpl | |
| ►CUISlider | |
| CListener | |
| CUISliderImpl | |
| CUITitle | |
| CUITitleImpl | |
| Cunderlying_type | |
| Cunique_ptr | |
| Cunique_ptr< T[], Deleter > | |
| ►Cunordered_map | |
| Cconst_iterator | |
| Citerator | |
| ►Cunordered_map_small | |
| Cconst_iterator | |
| Citerator | |
| ►Cunordered_set | |
| Cconst_iterator | |
| Citerator | |
| Cunsorted_map_fixed | |
| ►Curl | |
| CSpan | |
| Cvec2 | |
| Cvec3 | |
| ►Cvector | |
| Cconst_reverse_iterator | |
| Creverse_iterator | |
| Cvector_basic | Type-erased vector base class |
| Cvector_element_ops | Function pointer table for type-specific element operations |
| Cvector_psram | |
| CVectorN | |
| CVectorSet | |
| CVectorSetFixed | |
| CVibeLevels | Snapshot of self-normalizing MilkDrop-style vibe levels |
| CVideo | |
| CVideoFxWrapper | |
| CVoidSuccess | Dummy type for void expected success state |
| CVorbis | |
| CVorbisDecoder | |
| CVorbisDecoderImpl | |
| CVorbisFrame | |
| CVorbisInfo | |
| CWatchdog | Unified cross-platform watchdog interface |
| CWatchdogCrashReport | Decoded crash report (Tier 2) |
| CWater | |
| CWater_FP | |
| CWave3Byte | Type-safe container for 3-byte wave pulse pattern (wave3 encoding) |
| CWave8Bit | Type-safe container for packed 8-bit wave pulse pattern |
| CWaveCrgbGradientMap | Wave-to-color mapper using gradient/palette coloring |
| CWaveCrgbMap | Abstract base class for mapping wave simulation values to LED colors |
| CWaveCrgbMapDefault | Default wave-to-color mapper producing grayscale output |
| CWaveFx | 2D wave simulation effect with supersampling and gradient coloring |
| CWaveFxArgs | Configuration parameters for WaveFx effect |
| CWaves | |
| CWaves_FP | |
| CWaveSimulation1D | |
| CWaveSimulation1D_Real | |
| CWaveSimulation2D | |
| CWaveSimulation2D_Real | |
| Cweak_ptr | |
| CWeakPtr | |
| CWeightedMovingAverage | |
| CWLED | WLED-specific Remote RPC extension |
| CWLEDClient | WLED Client for controlling LEDs through FastLED interface |
| CWLEDSegment | WLED segment configuration |
| CWriteResult | Result of a write operation |
| CXMap | |
| CXYDrawComposited | |
| CXYDrawGradient | |
| CXYMap | |
| CXYPath | |
| CXYPathFunction | |
| CXYPathGenerator | |
| CXYPathParams | |
| CXYPathRenderer | |
| CXYRasterSparse_RGB8 | |
| CXYRasterU8Sparse | |
| CYves | |
| CYves_FP | |
| CZoom | |
| CZoom2 | |
| CZoom2_FP | |
| CZoom_FP | |
| ►Ngen | |
| CHexagonAngle | |
| CPoint | |
| ►Nobjectfled | |
| CPinValidationResult | |
| ►Nsimd_test | |
| CTestResult | Stores the result of a single SIMD test |
| ►Ntest_client | |
| CRequestResult | |
| CTestConfig | |
| ►Ntest_server | |
| CHTTPBinHandler | |
| ►Ntest_stress | |
| CStressTestConfig | |
| CStressTestResults | |
| C_MP3DecInfo | |
| C_MP3FrameInfo | |
| CAPA102Controller | APA102 controller class |
| CAPA102ControllerHD | APA102 high definition controller class |
| CAudioReactive | |
| CAutoResearchBleState | State for BLE autoresearch |
| CAutoResearchNetState | State for network autoresearch |
| CAutoResearchOtaState | State for OTA autoresearch |
| CAutoResearchRemoteControl | Remote RPC control system for test autoresearch Encapsulates all RPC function registration and processing logic |
| CAutoResearchState | AutoResearch runtime state (shared between main loop and RPC handlers) |
| CCEveryNMillisDynamic | Create the CEveryNMillisDynamic class for dynamic millisecond intervals |
| CCEveryNMillisRandom | |
| CCEveryNTime | Time interval checking class |
| ►CCFastLED | High level controller interface for FastLED |
| CClockedChipsetHelper | |
| CCMinWait | Class to ensure that a minimum amount of time has kicked since the last time run - and delay if not enough time has passed yet |
| CCMpaDecObj | |
| CColor3i | |
| CColorAdjustment | Color adjustment structure for pixel output |
| CColorHSV | |
| CColorScheme | |
| CColorSelector | |
| Ccorkscrew_args | |
| CCountingButton | |
| CCPixelLEDController | Template extension of the CLEDController class |
| ►CCPixelView | Represents a view/window into a set of LED pixels, providing array-like access and rich color operations |
| Cpixelset_iterator_base | Iterator helper class for CPixelView |
| Ccq_kernel_cfg | |
| CCRGBArray | A version of CPixelView<CRGB> with an included array of CRGB LEDs |
| CDATA_NOP | Dummy class for output controllers that need no data transformations |
| CDefaultPlatform | |
| CDefaultSerialSettings | |
| CDefaultSettings | Default Settings for the MIDI Library |
| CDMXSerialController | DMX512 based LED controller class, using the DMXSerial library |
| CDMXSimpleController | DMX512 based LED controller class, using the DmxSimple library |
| CDrawRasterToWaveSimulator | |
| CDriverTestRunner | Main test runner that orchestrates all driver tests |
| CFrameBuffer | |
| CFrameBufferBase | |
| CHD107Controller | HD107 is just the APA102 with a default 40Mhz clock rate |
| CHD107HDController | HD107HD is just the APA102HD with a default 40Mhz clock rate |
| CHD108Controller | |
| CInterpData | |
| CKey | |
| CKeyboardState | |
| Ckiss_fft_cpx | |
| Ckiss_fft_state | |
| Ckiss_fftr_state | |
| CLedColumns | |
| CLedRopeInterface | |
| CLedRopeTCL | |
| CLegacyClocklessProxy | Proxy that creates a legacy WS2812B controller from a runtime pin number |
| CLoopbackTestRunner | |
| CLPD6803Controller | LPD6803 controller class (LPD1101) |
| ►CLPD8806Controller | LPD8806 controller class |
| CLPD8806_ADJUST | |
| CMaxFadeTracker | Tracks a smoothed peak with attack, decay, and output-inertia time-constants |
| CMessage | |
| CMidiInterface | The main class for MIDI handling. It is templated over the type of serial port to provide abstraction from the hardware interface, meaning you can use HardwareSerial, SoftwareSerial or ak47's Uart classes. The only requirement is that the class implements the begin, read, write and available methods |
| CMidiShieldButton | |
| CNoiseGenerator | |
| CNOPSPIOutput | A nop/stub class, mostly to show the SPI methods that are needed/used by the various SPI chipset implementations |
| CP | |
| CP9813Controller | P9813 controller class |
| CPainter | |
| CPinToggle | Pin toggle instruction for RX channel testing |
| CPixelController | Pixel controller class |
| CPotentiometer | |
| CPowerModelRGB | RGB LED power consumption model Used for standard 3-channel LEDs (WS2812, WS2812B, APA102, etc.) |
| CPowerModelRGBW | RGBW LED power consumption model |
| CPowerModelRGBWW | RGBWW LED power consumption model (RGB + Cool White + Warm White) |
| CREFHardwareSPIOutput | A skeletal implementation of hardware SPI support |
| CRgbw | |
| CRgbwDefault | |
| ►CRGBWEmulatedController | Emulation layer to support RGBW LEDs on RGB controllers |
| CControllerT | |
| CRgbwInvalid | |
| CRgbwWhiteIsOff | |
| CRipple | |
| CRPN | |
| CSerialMIDI | |
| CServerCleanup | |
| CSK9822Controller | SK9822 controller class |
| CSK9822ControllerHD | SK9822 controller class |
| CSketchHalt | Sketch halting mechanism that prevents watchdog timer resets |
| CSM16716Controller | SM16716 controller class |
| CSoftwareSPIOutput | Software SPI output (generic cross-platform bit-banging) NOTE: This is NOT in the fl namespace per fastspi.h design requirements |
| Csparse_arr | |
| Csparse_arr_elem | |
| CTestResult | Stores the result of a single test |
| CThru | |
| CTimer | A simple timer utility class for tracking timed events |
| CToggleButton | |
| Cui_state | |
| CWaveEffect | |
| CWS2801Controller | WS2801 controller class |
| CWS2803Controller | WS2803 controller class |
1.13.2