| ►Nautoresearch | |
| ►Nanimartrix_check | |
| CPerlinBenchResult | |
| CPerlinBenchState | |
| ►Nieee754_check | |
| CFormatCase | |
| CIeee754CaseState | |
| CParseCase | |
| CResult | |
| ►Nlow_memory | |
| CRemoteState | |
| ►Nmath_exp | |
| CResult | |
| ►Nmp3_check | |
| CDecoded | |
| CResult | |
| ►Nmp3_fixture | |
| CStream | |
| ►Nparlio_bench | |
| CParlioEncodeResult | |
| ►Nparlio_stream | |
| CParlioLedState | |
| CValidateResult | |
| ►Nsimd_check | |
| CBenchmarkResult | |
| COpAdd | |
| COpDivFloat | |
| COpDivS16x16 | |
| COpDivS8x8 | |
| COpDivU16x16 | |
| COpMul | |
| COpSub | |
| CSimdBenchmarkState | |
| CSimdTestEntry | |
| ►Ntiming_drift | |
| CDriftResult | |
| CMillisDelay | Faithful emulation of the millisDelay library used by the issue sketch: start(t) arms a deadline; justFinished() fires true exactly once when elapsed >= t; stop() disarms |
| CTimingDriftState | |
| ►Nwave8_bench | |
| CWave8ExpandResult | |
| CStubAutorunLedState | |
| ►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} | |
| CMicros64State | |
| CMillis64State | |
| ►Nanonymous_namespace{colorutils.cpp.hpp} | |
| COklab | |
| CProgmemRGBPaletteReader | |
| CRuntimeRGBPaletteReader | |
| ►Nanonymous_namespace{gamut_map.cpp.hpp} | |
| CRgbFeasible | Feasibility against the three-emitter hull |
| CRgbwFeasible | Feasibility against the device's real hull when it has a white emitter |
| CRgbwwFeasible | Feasibility against the device's real hull when it has two white emitters |
| ►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{pir.cpp.hpp} | |
| CPirNameCounter | |
| ►Nanonymous_namespace{random.cpp.hpp} | |
| CLockedRandom | |
| ►Nanonymous_namespace{rgbw.cpp.hpp} | |
| CNamedGamut | |
| CRgb2RgbwUserState | |
| CRgbwColorimetricState | |
| ►Nanonymous_namespace{rgbww.cpp.hpp} | |
| CRgb2RgbwwUserState | |
| CRgbwwColorimetricState | |
| ►Nanonymous_namespace{uart_wave_encoder.cpp.hpp} | |
| CUartWaveFit | Fit result for one UART wave geometry (P pulses per LED bit) |
| ►Nanonymous_namespace{wave.cpp.hpp} | |
| CBatchDraw | Internal helper for batched gradient color mapping |
| ►Nanonymous_namespace{white_allocation.cpp.hpp} | |
| CSplitBound | A bound on the split, as (numerator + slope * s) / denominator with a positive denominator |
| ►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 >())))> | |
| ►Nchannels | |
| ►Nrx | |
| ►CWs2812StreamDecoder | Streaming decoder over (rise, fall) capture pairs |
| CException | |
| CPending | |
| CStats | |
| ►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 |
| ►Ncolor | |
| CDiodeProfile | |
| ►Ncolorimetric_detail | |
| CEmitterProfile | |
| CLutTable | |
| CProfileCache | |
| CRgbcctProfile | |
| CRgbColorimetricCache | |
| ►Ncolorimetric_response | |
| CEmitterProfile | |
| CRgbColorimetricCache | |
| ►Ndetail | Compile-time linker keep-alive hook for a single fl::Bus |
| ►Nanonymous_namespace{allocator.cpp.hpp} | |
| CSlabRegistryEntry | |
| CSlabRegistryState | |
| ►Nanonymous_namespace{five_bit_semantics.cpp.hpp} | |
| CHdFieldFloorStorage | |
| ►Nanonymous_namespace{runtime_rpc_binding.cpp.hpp} | |
| CRuntimeRpcSlotCleanup | |
| ►Nanonymous_namespace{singleton.cpp.hpp} | |
| CRegistryEntry | |
| ►Nruntime_rpc | |
| CArgTypesTable | |
| CArgTypesTable<> | |
| CTrampolineHelper | |
| CTrampolineHelper< void, Args... > | |
| 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, Which > | |
| CCallableHolderBase | |
| CCascadedEMAImpl | |
| Ccontrol_block_alignment | |
| CControlBlock | |
| CControlBlockBase | |
| CDCBlockerImpl | |
| Cdefault_delete | |
| CDeviceInfoResolver | |
| CDeviceInfoResolver< Bus::AUTO, Which > | |
| CDeviceInfoResolver< Bus::BIT_BANG, Which > | |
| CDoubleBits | |
| Cenable_clockless_for | enable_clockless<Traits>() only for the clockless chipset family |
| Cenable_clockless_for< ClocklessChipset, Traits > | |
| CErasedInvoker | |
| CErasedSchemaGenerator | |
| CExponentialSmootherImpl | |
| Cflat_map_ops | |
| CFlexIOLoggerInfo | |
| CFloatBits | |
| 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_fl_fixed_point | |
| Cis_fl_fixed_point< T, decltype(static_cast< void >(T::INT_BITS), static_cast< void >(T::FRAC_BITS), static_cast< void >(fl::declval< const T & >().raw()), static_cast< void >(T::from_raw(fl::declval< const T & >().raw())), void())> | |
| 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 && >()))> | |
| 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 | |
| Clog_literal | |
| Clog_seed | |
| 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 | |
| COnlyIf | type exists only when B is true: a self-contained enable_if so the binder below can key on a constant that only PixelController declares |
| COnlyIf< true > | |
| 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...)> | |
| CRgbwNoEncoder | Tag for constructing an inactive Rgbw without linking the RGBW encoder |
| CRgbwwNoEncoder | Tag for constructing an inactive Rgbww without linking the RGBWW encoder |
| CRmtLoggerInfo | |
| CRpcEntry | |
| CRpcTypeOps | |
| CRpcTypeOpsFor | |
| CRpcTypeOpsFor< void > | |
| CRuntimeRpcBinding | |
| CSavitzkyGolayFilterImpl | |
| 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) |
| Cslab_lock_guard | RAII guard for slab_mutex |
| Cslab_mutex | Single-threaded MCUs: no-op |
| 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::u16 > | |
| CTypeToJson< fl::u32 > | |
| 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 | |
| Caligned_ptr | |
| Cmax_align_selector | |
| Cmax_align_selector< false > | |
| ►Nfled | |
| CFledBuilder | |
| CFledImpl | |
| CParsedHeader | |
| CPixelStorage | |
| CVideoColor | |
| CVideoFrameView | |
| ►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 | |
| CBleNotifyQueue | Bounded FIFO of outbound notification payloads, drained in MTU-sized chunks |
| 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 | |
| Cscalar_kind | |
| Cscalar_kind< bool > | |
| Cscalar_kind< char > | |
| Cscalar_kind< double > | |
| Cscalar_kind< float > | |
| Cscalar_kind< int > | |
| Cscalar_kind< long > | |
| Cscalar_kind< long long > | |
| Cscalar_kind< short > | |
| Cscalar_kind< signed char > | |
| Cscalar_kind< unsigned char > | |
| Cscalar_kind< unsigned int > | |
| Cscalar_kind< unsigned long > | |
| Cscalar_kind< unsigned long long > | |
| Cscalar_kind< unsigned short > | |
| CScalarArg | |
| ►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 | Function and platform tuning for an OS-level coroutine task |
| 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); |
| CSkipState | |
| 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 | |
| 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 | |
| CMp3FrameInfo | |
| CMp3MemoryDeleter | |
| CMp3Minimp3Decoder | |
| CMp3StreamDecoderImpl | |
| CMp3VbrTag | |
| 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 | |
| CPixelSample | |
| CPixelStream | |
| CVideoImpl | |
| ►Nwave_perf | |
| CWavePerfRepeatResult | |
| CWavePerfResult | |
| CAdaptationMatrixQ16 | A collapsed adaptation transform in s16.16 |
| 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 | |
| CAnalogRGBController | Drives one non-addressable RGB LED or strip from three PWM pins |
| 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 | |
| CBinaryDither | Temporal binary dithering over caller-owned d[3]/e[3] |
| 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 | |
| CBootGuardDecision | What the early-boot hook does on this boot |
| CBootGuardRecord | Reset-persistent boot-guard record |
| CBusInstanceCount | |
| 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 |
| CChannelRequest | |
| CChasing_Spirals_Float | |
| CChasing_Spirals_Q31 | |
| CChasing_Spirals_Q31_SIMD | |
| CChasingSpiralPixelLUT | |
| CChipsetClocklessTiming | |
| 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 | |
| CChromaticity | CIE 1931 xy chromaticity, independent of encoded storage and chipset |
| CCirclePath | |
| Ccircular_buffer | |
| Ccircular_buffer_core | |
| CCLEDController | |
| CClocklessChipset | Clockless chipset configuration (single data pin) |
| CClocklessTimingCapability | |
| CColorManagedPixelSource | Runs processPixelQ16 over a PixelController's pixels as they are read |
| CColorPipelineHooks | |
| CColorProfileBinding | Immutable profile binding carried by a channel |
| CColorProfileEvent | Payload shared by every color-profile notification |
| CColorProfileStorage | One immutable allocation for every borrowed member in EmitterProfile |
| 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 | |
| CDemoReel100 | |
| ►Cdeque | |
| Cconst_iterator | |
| Citerator | |
| Cdeque_traits | |
| CDeviceInfo | |
| CDeviceRuntime | |
| ►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 | |
| ►CDriverCapabilities | |
| CFlags | Peripheral-flavor flags. Default zero = neutral / no claim |
| 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) |
| CEmitterChromaticitiesQ16 | A three-emitter profile with every field in s16.16 |
| CEmitterProfile | |
| CEmitterSolveMatrixQ16 | Inverse emitter matrix in s16.16, mapping XYZ to three emitter drives |
| 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 | |
| CFled | |
| 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 | |
| CFluxScalar | A linear flux scalar in s16.16 |
| CFont | |
| CFontImpl | |
| CFontMetrics | |
| ►CFontRenderer | |
| CScaledMetrics | |
| Cforward_iterator_tag | |
| CFrame | |
| CFramePowerPlan | Result of the shared frame-budget prepass on large-memory managed output |
| CFreqRange | |
| ►CFsImpl | A mounted storage medium |
| 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 | |
| CGamutMapQ16 | Everything the per-pixel mapper needs, derived once when a profile binds |
| CGamutMapRgbwQ16 | The same mapper for a device with a white emitter |
| CGamutMapRgbwwQ16 | The same mapper for a device with two white emitters |
| 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 | |
| Cindex_sequence_concat | |
| Cindex_sequence_concat< index_sequence< Lhs... >, index_sequence< Rhs... > > | |
| 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 | |
| ►Citerator | |
| CKeyValue | |
| CJsonArgConverter | |
| CJsonArgConverter< R()> | |
| CJsonStreamWriter | |
| Cjust8bits | Structure representing 8 bits of access |
| Cjust8bits.__unnamed0__ | |
| CKalmanFilter | |
| CLava1 | |
| CLava1_FP | |
| CLeakyIntegrator | |
| CLEDError | LED error information for a single run |
| CLeds | |
| CLedsXY | |
| CLegacySettings | |
| 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 > | |
| Cmake_index_sequence_impl< 1 > | |
| 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 |
| CNanosRange | |
| CNoDither | The disabled policy: same interface, no work |
| 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 | |
| Cnumber | |
| 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 | |
| CPinGroup | |
| 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 |
| CPinSet | |
| CPir | |
| CPirLowLevel | |
| CPixelControllerVtable | |
| CPixelIterator | |
| CPixelIteratorAny | Adapter class that creates a PixelIterator from any color order |
| CPointPath | |
| CPolar_Waves | |
| CPolar_Waves_FP | |
| ►CPotentiometer | |
| CListener | |
| CPotentiometerLowLevel | |
| CPowerCodecPolicy | |
| 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 |
| CRawPremixBinder | Raw-pixel thunk + the source's own colour order, for PixelController sources on non-AVR targets |
| CRawPremixBinder< T, typename detail::OnlyIf<(T::kColorOrder==T::kColorOrder)>::type > | |
| 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...)> | |
| CResponseLutsQ16 | Owned code-to-light samples for the three physical emitters |
| 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 | |
| CRgbPrimaries | |
| CRgbw | |
| CRgbwDefault | |
| CRgbwInvalid | |
| CRgbwLoadBinder | Per-type RGBW/RGBWW thunks |
| CRgbwLoadBinder< T, typename detail::OnlyIf<(T::kColorOrder==T::kColorOrder)>::type > | Any PixelController (it has kColorOrder): no per-type RGBW/RGBWW thunk at all; RawPremixBinder below supplies the raw pixel and the type-erased conversion does the rest (#4795) |
| CRGBWPixel | Simple RGBW pixel struct for encoder input |
| CRgbww | |
| 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 | |
| CShape | |
| 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 | |
| ►CSlabAllocator | |
| CSlab | |
| CSlimBridgeController | Shared legacy addLeds<>() bridge controller over an IChannelDriver |
| CSlimBridgeShowPolicy | How a SlimBridgeController reaches its driver |
| CSlimBridgeShowPolicy< false > | Default: registered with ChannelManager, which owns enable/disable and flushes every registered driver once at the end of FastLED.show() |
| CSlimBridgeShowPolicy< true > | Direct: no registry, so there is no runtime enable/disable or exclusive-driver selection, and no end-of-show flush – the controller shows its own frame, as the pre-bridge LPC controllers did |
| CSlimSpiBridgeController | Shared legacy addLeds<ESPIChipsets ...>() bridge controller over an IChannelDriver, for chipsets whose encoding never needs the colour-managed pipeline (see file-level comment) |
| CSlow_Fade | |
| CSlow_Fade_FP | |
| CSmallMapEqualTo | |
| CSortedHeapVector | |
| CSourceMatrixQ16 | Source-primaries matrix in s16.16, rows ordered X, Y, Z |
| CSourceProfile | A source declaration, not a container or an output-device selection |
| 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 > | |
| CStaticProfileChannel | A compile-time profile channel |
| CStbVorbisDecoder | |
| CStreamingPipelineQ16 | Everything the per-pixel path needs, derived once when a profile binds |
| 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_GS1903 | GS1903 RGB controller @ 800 kHz (12 V) Four-phase: TH0=300ns, TH1=900ns, TL0=900ns, TL1=300ns, TRST>40µs |
| 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_LC8816E | LC8816E RGBW controller @ 800 kHz Four-phase: TH0=300ns, TH1=900ns, TL0=900ns, TL1=300ns |
| 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 RGBW controller @ 800 kHz Four-phase: TH0=300ns, TH1=900ns, TL0=900ns, TL1=300ns, TRST=200µs Datasheet typicals are identical to the SM16703 / WS2811-800kHz RZ family, so this timing also lets SM16824E and SM16703 chips share a single data line |
| 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_TM1812_RGBWW_800KHZ | TM1812 RGBCCT controller @ 800 kHz (issue #995) |
| 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_TM1908 | TM1908 RGB controller @ 1.2 MHz |
| 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_WS2814 | WS2814 RGBW controller @ 800 kHz 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 |
| CTIMING_WS2818 | WS2818 RGB controller @ approximately 833 kHz Four-phase: TH0=300ns, TH1=600ns, TL0=900ns, TL1=600ns |
| 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 | |
| CTwoWhiteAllocationQ16 | Everything the two-white allocation needs, derived once when a profile binds (C3, #4198) |
| 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 | |
| CWave10Lut | Wave lookup table for UART LED encoding (waveN family) |
| 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 | |
| CPsramStorage | |
| Cweak_ptr | |
| CWeakPtr | |
| CWeightedMovingAverage | |
| CWhiteAllocationQ16 | Everything the per-pixel allocation needs, derived once when a profile binds |
| CWideLoadBinder | Binds the wide thunk only when T declares loadAndScaleRGB16 |
| CWideLoadBinder< T, decltype(static_cast< void >(fl::declval< T & >().loadAndScaleRGB16(static_cast< u16 * >(nullptr), static_cast< u16 * >(nullptr), static_cast< u16 * >(nullptr))))> | |
| CWidePipelineQ16 | Allocated only for a bound four- or five-emitter profile |
| 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 | |
| ►Nmood_ring | |
| CBreathLayer | Calm room |
| ►CFlowLayer | Busy room without a beat |
| CGrain | |
| CFollower | Smoothed one-pole follower with independent attack and release |
| CGrooveLayer | Music with a beat |
| CListenerTuning | Everything the UI is allowed to tune on the listening side |
| ►CMoodPainter | |
| CPulse | |
| CMoodPalette | |
| CPainterTuning | |
| CRGBf | Linear-light float pixel, nominal range [0, 1], may exceed 1 before clip |
| CRingCanvas | Additive drawing helpers over a span of float pixels |
| CRoomEvents | One-frame rising edges. Set on the frame the event lands, cleared next |
| CRoomListener | |
| CRoomSense | Everything a visual is allowed to react to |
| CXorshift | Small deterministic RNG for sparkle. No libc, no global state |
| ►Nobjectfled | |
| CPinValidationResult | |
| ►Nsimd_test | |
| CTestResult | Stores the result of a single SIMD test |
| ►Ntest_client | |
| CRequestResult | |
| CTestConfig | |
| ►Ntest_server | |
| CHTTPBinHandler | |
| ►Ntest_stress | |
| CStressTestConfig | |
| CStressTestResults | |
| CANALOG_RGB | FastLED chipset-style wrapper for three-pin PWM RGB output |
| CAPA102Controller | APA102 controller class |
| CAPA102ControllerHD | APA102 high definition controller class |
| 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 | And refresh rates, and provides access functions for driving led data to controllers via the show() / showColor() / clear() methods |
| 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 |
| 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 clockless controller from runtime inputs |
| 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 | |
| Cmp3dec_frame_info_t | |
| Cmp3dec_scratch_t | |
| Cmp3dec_t | |
| CMY9221Controller | MY9221 controller class |
| 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 Used for 4-channel LEDs (SK6812 RGBW and similar) |
| CPowerModelRGBWW | RGBWW LED power consumption model (RGB + warm white + cool white) |
| CREFHardwareSPIOutput | A skeletal implementation of hardware SPI support |
| CRgbw | |
| CRgbwDefault | |
| ►CRGBWEmulatedController | Emulation layer to support RGBW LEDs on RGB controllers |
| CControllerT | |
| CRgbwInvalid | |
| CRgbwwEmitterPower | |
| 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 | |
| CTProgmemHSVPalette16 | CHSVPalette16 entries stored in PROGMEM memory |
| CTProgmemHSVPalette32 | CHSVPalette32 entries stored in PROGMEM memory |
| Cui_state | |
| CWaveEffect | |
| CWhiteEmitterPower | The white emitter's draw, when the caller declared one |
| CWS2801Controller | WS2801 controller class |
| CWS2803Controller | WS2803 controller class |
1.13.2