fl Namespace Reference

Detailed Description

Base definition for an LED controller.

Platform-agnostic integer types.

Service function to check timer flag and flush all async loggers.

Implements a simple red square effect for 2D LED grids.

Pretty much the methods that every LED controller object will make available. If you want to pass LED controllers around to methods, make them references to this type, keeps your code saner. However, most people won't be seeing/using these objects directly at all.

Note

That the methods for eventual checking of background writing of data (I'm looking at you, Teensy 3.0 DMA controller!) are not yet implemented.

Deprecated

This function is now optional - async loggers are automatically serviced by fl::task system when using fl::delay() Call this from your main loop() if using enableBackgroundFlush() This function is lightweight - returns immediately if no flush needed

Version and configuration FastLED configuration and platform definitions Compiler and language features Memory and type utilities Basic color types (CRGB, HSV) Pixel types and color ordering Pixel utilities Base LED controller classes Platform-specific definitions and initialization Timing utilities Math utilities from lib8tion Bit manipulation Memory utilities Hardware pin definitions Color utilities and palettes

Trace System

The trace system provides source location information and call stack tracking for debugging.

Components:

• fl::TracePoint: A tuple of (file, line, timestamp)
• FL_TRACE: Macro that captures current file, line, and timestamp
• fl::ScopedTrace: RAII guard for automatic call stack tracking
• FL_SCOPED_TRACE(name): Convenience macro for stack tracing
• FL_TRACE_DUMP(): Print current call stack

Stack Trace Usage:

void criticalFunction() {
    FL_SCOPED_TRACE;  // Automatically uses function name
    // Function body - trace automatically pushed/popped
 
    if (error) {
        FL_TRACE_DUMP();  // Print call stack for debugging
    }
}
 
// For custom trace names:
void helper() {
    FL_SCOPED_TRACE_NAMED("custom_trace_name");
    // ...
}

Configuration:

• FASTLED_DEBUG_STACK_TRACE - Enable stack tracing (default: disabled)
• Stack depth limit: 32 entries (configurable via FL_STACK_TRACE_MAX_DEPTH)

Usage Example

// IWYU pragma: begin_keep
#include <fl/system/fastled.h>
#include <fl/task/task.h>
// IWYU pragma: end_keep
 
void setup() {
    // Create a recurring task that runs every 100ms
    auto t = fl::task::every_ms(100, FL_TRACE)
        .then([]() {
            // Task logic here
        })
        .catch_([](const fl::task::Error& e) {
            // Error handling here
        });
 
    // Add task to scheduler
    fl::task::Scheduler::instance().add_task(t);
}
 
void loop() {
    // Execute ready tasks
    fl::task::Scheduler::instance().update();
 
    // Yield for other operations
    fl::task::run(1000);
}

Coroutine (OS-Level Task Management)

This file also provides a LOW-LEVEL OS/RTOS task wrapper for hardware drivers and platform-specific threading needs. This is separate from the high-level task scheduler above.

Coroutine Usage Example

#include "fl/task/task.h"
 
void myTaskFunction() {
    while (true) {
        // Task work...
        if (shouldShutdown) {
            fl::task::exit_current();  // Self-delete
            // UNREACHABLE on ESP32
        }
    }
}
 
// Create and start OS-level task (RAII - auto-cleanup on destruction)
auto t = fl::task::coroutine({
    .func = myTaskFunction,
    .name = "MyTask"
});
 
// Task is automatically cleaned up when 't' goes out of scope
// Or manually: t.stop();

Coroutine with Async/Await (ESP32 only)

On ESP32 platforms, coroutines can use fl::task::await() to efficiently block on promises without busy-waiting. This provides zero-CPU-overhead asynchronous operations perfect for network requests, timers, or sensor readings.

#include "fl/task/task.h"
#include "fl/task/executor.h"
 
// Create a coroutine that performs sequential async operations
auto t = fl::task::coroutine({
    .func = []() {
        // Fetch data from an API (zero CPU usage while waiting)
        auto result = fl::task::await(fl::fetch_get("http://api.example.com/data"));
 
        if (result.ok()) {
            fl::string data = result.value().text();
 
            // Process the data
            process_data(data);
        } else {
            FL_WARN("Fetch failed: " << result.error().message);
        }
 
        // Task completes and automatically cleans up
    },
    .name = "AsyncWorker"
});

Platform support:**

• ESP32: FreeRTOS tasks via xTaskCreate/vTaskDelete + fl::task::await() support
• Host/Stub: std::thread + fl::task::await() support (for testing)
• Other platforms: Null implementation (no-op, fl::task::await() not available)

Namespaces
namespace	alpha_detail
namespace	anonymous_namespace{allocator.cpp.hpp}
namespace	anonymous_namespace{base64.cpp.hpp}
namespace	anonymous_namespace{blur.cpp.hpp}
namespace	anonymous_namespace{channel.cpp.hpp}
namespace	anonymous_namespace{chasing_spirals.cpp.hpp}
namespace	anonymous_namespace{chrono.cpp.hpp}
namespace	anonymous_namespace{colorutils.cpp.hpp}
namespace	anonymous_namespace{corkscrew.cpp.hpp}
namespace	anonymous_namespace{five_bit_hd_gamma.cpp.hpp}
namespace	anonymous_namespace{gradient.cpp.hpp}
namespace	anonymous_namespace{h264.cpp.hpp}
namespace	anonymous_namespace{http_parser.cpp.hpp}
namespace	anonymous_namespace{ieee754_string.cpp.hpp}
namespace	anonymous_namespace{istream.cpp.hpp}
namespace	anonymous_namespace{json.cpp.hpp}
namespace	anonymous_namespace{line_simplification.cpp.hpp}
namespace	anonymous_namespace{memory_resource.cpp.hpp}
namespace	anonymous_namespace{mp4_parser.cpp.hpp}
namespace	anonymous_namespace{noise_woryley.cpp.hpp}
namespace	anonymous_namespace{perlin_particle_punch.cpp.hpp}
namespace	anonymous_namespace{pins.cpp.hpp}
namespace	anonymous_namespace{pir.cpp.hpp}
namespace	anonymous_namespace{random.cpp.hpp}
namespace	anonymous_namespace{rgbw.cpp.hpp}
namespace	anonymous_namespace{rgbww.cpp.hpp}
namespace	anonymous_namespace{tile2x2.cpp.hpp}
namespace	anonymous_namespace{wave.cpp.hpp}
namespace	anonymous_namespace{xypath.cpp.hpp}
namespace	asio
namespace	asset_detail
namespace	audio
namespace	ceil_detail
namespace	channels
namespace	chrono
namespace	colorimetric_detail
namespace	detail
	Compile-time linker keep-alive hook for a single fl::Bus.
namespace	fl
namespace	floor_detail
namespace	format_detail
namespace	gfx
namespace	int_cast_detail
namespace	io
namespace	ios
namespace	isr
namespace	json2
namespace	make_unsigned_detail
namespace	map_range_detail
namespace	math
namespace	net
namespace	platforms
namespace	printf_detail
namespace	pwm_state
namespace	q16
namespace	q31
namespace	simd
namespace	spi
namespace	sqrt_detail
namespace	task
namespace	test
namespace	third_party
namespace	this_thread
	this_thread namespace for thread-specific operations
namespace	ttf
namespace	ucs7604
	UCS7604 runtime brightness control namespace.
namespace	validation
namespace	video
namespace	wave_detail
namespace	wled
namespace	xypath_detail

Classes
struct	add_pointer
struct	add_pointer< T & >
struct	add_pointer< T && >
struct	add_rvalue_reference
struct	add_rvalue_reference< T & >
class	aligned_ptr
struct	alignment_of
struct	allocation_result
class	allocator
class	allocator_inlined
class	allocator_psram
class	allocator_realloc
class	allocator_slab
struct	allocator_traits
struct	alpha16
	Unsigned 16-bit alpha / brightness — UNORM16. More...
struct	alpha8
	Unsigned 8-bit alpha / brightness — UNORM8. More...
class	AlphaTrimmedMean
class	Animartrix
struct	AnimartrixAnimInfo
struct	AnimartrixEntry
class	ArchimedeanSpiralPath
class	array
	A fixed-size array implementation similar to std::array. More...
class	array< T, 0 >
class	asset_ref
	Opaque handle to a sketch-local asset. More...
class	AsyncLogger
	ISR-safe async logger wrapper (zero heap allocation) Uses embedded AsyncLogQueue instead of heap-allocated pointer Registers itself automatically in ActiveLoggerRegistry on first access. More...
class	AsyncLogQueue
	High-performance SPSC async log queue. More...
class	AtomicFake
class	AttackDecayFilter
class	AudioBatch
struct	AudioFrame
	Lightweight snapshot of pre-computed audio analysis for one audio sample. More...
struct	AutoResearchConfig
	Configuration for driver-agnostic autoresearch testing Contains all input parameters needed for autoresearch (excludes output parameters) More...
class	back_insert_iterator
	Back insert iterator - an output iterator that inserts elements at the end of a container. More...
class	basic_string
	Concrete type-erased string class. More...
struct	bidirectional_iterator_tag
class	Big_Caleido
class	Big_Caleido_FP
class	BilateralFilter
struct	BindResult
	Wraps the result of binding to a method by name. More...
struct	BindResult< R(Args...)>
class	BiquadFilter
class	bitset_dynamic
	A dynamic bitset implementation that can be resized at runtime. More...
class	bitset_fixed
class	bitset_inlined
union	bitswap_type
	Union containing a full 8 bytes to swap the bit orientation on. More...
struct	bitswap_type.__unnamed0__
class	Blend2d
struct	Blend2dParams
struct	BoolConversionVisitor
struct	BusSupports
	Capability check: does bus B accept chipset family Chipset? More...
struct	BusTraits
	Primary template — intentionally undefined. More...
class	Button
class	ButtonLowLevel
class	Caleido1
class	Caleido1_FP
class	Caleido2
class	Caleido2_FP
class	Caleido3
class	Caleido3_FP
struct	callable_traits
struct	callable_traits< R(*)(Args...)>
struct	callable_traits< R(Args...)>
struct	callable_traits< R(C::*)(Args...) const >
struct	callable_traits< R(C::*)(Args...)>
struct	callable_traits< T, typename enable_if< is_member_function_pointer< decltype(&T::operator())>::value >::type >
class	Canvas
	Generic canvas for any pixel type (e.g. More...
class	CanvasRGB
	Convenience alias for CRGB canvas — use fl::CanvasRGB for no-template syntax. More...
class	CascadedEMA
class	CatmullRomParams
class	CatmullRomPath
	Catmull–Rom spline through arbitrary points. More...
class	Center_Field
class	Center_Field_FP
class	Channel
	LED channel for parallel output, pretty much a CPixelLEDController but with timing and pin information. More...
struct	ChannelConfig
	Configuration for a single LED channel. More...
struct	ChannelConfigOf
	Strongly-typed channel configuration with compile-time chipset family. More...
class	ChannelData
	Transmission data for a single LED channel. More...
struct	ChannelEvents
	Singleton event router for Channel lifecycle events. More...
class	ChannelManager
	Unified channel manager with priority-based driver selection. More...
struct	ChannelOptions
	Optional channel configuration parameters All fields have sensible defaults and can be overridden as needed. More...
class	Chasing_Spirals_Float
class	Chasing_Spirals_Q31
class	Chasing_Spirals_Q31_SIMD
struct	ChasingSpiralPixelLUT
struct	ChipsetTiming
	Generic chipset timing entry Provides T1, T2, T3 timing parameters in nanoseconds for any LED protocol. More...
struct	ChipsetTiming4Phase
	4-phase RX timing thresholds for chipset detection More...
struct	ChipsetTimingConfig
	Runtime bit-period timing for a clockless chipset. More...
struct	choose_by_rank
struct	choose_by_signedness
struct	choose_by_size
class	CirclePath
class	circular_buffer
class	circular_buffer_core
class	CLEDController
struct	ClocklessChipset
	Clockless chipset configuration (single data pin) More...
struct	common_type
struct	common_type_impl
struct	common_type_impl< double, float >
struct	common_type_impl< double, long double >
struct	common_type_impl< double, T, typename enable_if<(is_integral< T >::value||is_floating_point< T >::value) &&!is_same< T, double >::value >::type >
struct	common_type_impl< float, double >
struct	common_type_impl< float, long double >
struct	common_type_impl< float, T, typename enable_if<(is_integral< T >::value||is_floating_point< T >::value) &&!is_same< T, float >::value >::type >
struct	common_type_impl< i8, u8, void >
struct	common_type_impl< long double, double >
struct	common_type_impl< long double, float >
struct	common_type_impl< T, double, typename enable_if<(is_integral< T >::value||is_floating_point< T >::value) &&!is_same< T, double >::value >::type >
struct	common_type_impl< T, float, typename enable_if<(is_integral< T >::value||is_floating_point< T >::value) &&!is_same< T, float >::value >::type >
struct	common_type_impl< T, T >
struct	common_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 >
struct	common_type_impl< u8, i8, void >
class	Complex_Kaleido
class	Complex_Kaleido_2
class	Complex_Kaleido_2_FP
class	Complex_Kaleido_3
class	Complex_Kaleido_3_FP
class	Complex_Kaleido_4
class	Complex_Kaleido_4_FP
class	Complex_Kaleido_5
class	Complex_Kaleido_5_FP
class	Complex_Kaleido_6
class	Complex_Kaleido_6_FP
class	Complex_Kaleido_FP
struct	conditional
struct	conditional< false, T, F >
struct	ConnectionConfig
struct	ConstCharPtrWrapper
struct	ConstSpanWrapper
struct	contains_type
struct	contains_type< T >
struct	contains_type< T, U, Rest... >
struct	Context
struct	CopyToOutputIteratorVisitor
struct	CopyToVisitor
class	Corkscrew
struct	CRGB
	Representation of an 8-bit RGB pixel (Red, Green, Blue) More...
union	CRGB.__unnamed0__
struct	CRGB.__unnamed0__.__unnamed0__
union	CRGB.__unnamed0__.__unnamed0__.__unnamed0__
union	CRGB.__unnamed0__.__unnamed0__.__unnamed1__
union	CRGB.__unnamed0__.__unnamed0__.__unnamed2__
struct	CRGB16
struct	CRGBA5
struct	CustomTimingTraits
	Helper to create timing traits from individual timing values Useful for creating custom timing configurations at compile-time. More...
class	Cylon
	An animation that moves a single LED back and forth (Larson Scanner effect) More...
class	DCBlocker
struct	dec_t
struct	decay
struct	default_delete
struct	default_delete< T[]>
struct	default_value_visitor
struct	DefaultBus
	Per-platform default bus for a given chipset family. More...
class	DemoReel100
class	deque
class	DigitalMultiWrite16
	Pre-computed nibble LUT for fast 16-pin digital writes. More...
class	DigitalMultiWrite8
	Pre-computed nibble LUT for fast 8-pin digital writes. More...
class	DigitalPin
class	DigitalPinImpl
struct	DiodeProfile
class	Distance_Experiment
class	Distance_Experiment_FP
struct	DrawContext
struct	DrawItem
struct	DriverFailureInfo
	Driver failure tracking with detailed error information. More...
struct	DriverInfo
	Driver state information for channel manager. More...
struct	DriverTestResult
	Driver test result tracking (moved from ValidationTest.h) More...
struct	EdgeRange
	Edge range specification for getRawEdgeTimes() debugging. More...
struct	EdgeTime
	Universal edge timing representation (platform-agnostic) More...
struct	Empty
struct	enable_if
struct	enable_if< true, T >
struct	endl_t
struct	Engine
class	EngineEvents
struct	EqLevels
	Snapshot of 16-bin normalized spectrum. More...
struct	EqualTo
struct	ErrorInfo
	Error information for expected type. More...
class	expected
	expected type for operations that can fail (C++23-style) More...
class	expected< void, E >
	Specialization for void (no value to return) More...
class	ExponentialSmoother
struct	FastHash
struct	FastHash< vec2< T > >
class	FastLEDAdapter
	Real FastLED implementation adapter. More...
struct	FILE_impl
class	filebuf
class	FileSystem
class	Fire2012
class	fixed_point
class	fixed_point_base
struct	fixed_point_impl
struct	fixed_point_impl< 0, 32, Sign::SIGNED >
struct	fixed_point_impl< 0, 32, Sign::UNSIGNED >
struct	fixed_point_impl< 12, 4, Sign::SIGNED >
struct	fixed_point_impl< 12, 4, Sign::UNSIGNED >
struct	fixed_point_impl< 16, 16, Sign::SIGNED >
struct	fixed_point_impl< 16, 16, Sign::UNSIGNED >
struct	fixed_point_impl< 24, 8, Sign::SIGNED >
struct	fixed_point_impl< 24, 8, Sign::UNSIGNED >
struct	fixed_point_impl< 4, 12, Sign::SIGNED >
struct	fixed_point_impl< 4, 12, Sign::UNSIGNED >
struct	fixed_point_impl< 8, 24, Sign::SIGNED >
struct	fixed_point_impl< 8, 24, Sign::UNSIGNED >
struct	fixed_point_impl< 8, 8, Sign::SIGNED >
struct	fixed_point_impl< 8, 8, Sign::UNSIGNED >
struct	fixed_point_traits
class	FixedVector
class	flat_map
class	flat_set
struct	float_conversion_visitor
struct	float_conversion_visitor< double >
class	FlowField
	Abstract base class for 2D flow field effects. More...
class	FlowFieldFloat
	Float-precision flow field implementation. More...
class	FlowFieldFP
	Pure fixed-point (s16x16) flow field implementation for maximum speed. More...
struct	FlowFieldFPState
	SoA (Structure-of-Arrays) state for FlowFieldFP. More...
struct	FlowFieldParams
	Configuration parameters for FlowField. More...
class	Fluffy_Blobs
class	Fluffy_Blobs_FP
class	Font
class	FontImpl
struct	FontMetrics
class	FontRenderer
struct	forward_iterator_tag
class	Frame
class	FsImpl
class	fstream
class	function
struct	function_traits
struct	function_traits< fl::function< R(Args...)> >
struct	function_traits< R(*)(Args...)>
struct	function_traits< R(Args...)>
class	Fx
class	Fx1d
class	Fx2d
class	Fx2dTo1d
	Fx2dTo1d samples a 2D effect into a 1D LED strip using a ScreenMap. More...
class	FxCompositor
class	FxEngine
	Manages and renders multiple visual effects (Fx) for LED strips. More...
class	FxLayer
class	Gamma8
class	Gamma8Impl
struct	GammaEval
struct	GammaEval16
struct	Gap
	Struct representing gap parameters for corkscrew mapping. More...
class	GaussianFilter
class	GielisCurveParams
class	GielisCurvePath
class	Gif
struct	GifConfig
struct	GifInfo
struct	GlyphBitmap
struct	GlyphMetrics
class	Gradient
class	GradientInlined
struct	greater
	Binary function object that returns whether the first argument is greater than the second. More...
struct	greater< void >
	Specialization of greater for void, allowing for transparent comparisons. More...
class	Grid
class	H264
struct	H264Config
struct	H264Info
class	HampelFilter
struct	has_data_and_size
class	has_data_method
struct	has_encoder
struct	has_member_swap
class	has_size_method
struct	Hash
struct	Hash< audio::fft::Args >
struct	Hash< bool >
struct	Hash< double >
struct	Hash< fl::shared_ptr< T > >
struct	Hash< fl::string >
struct	Hash< fl::string_view >
struct	Hash< fl::u8 >
struct	Hash< float >
struct	Hash< i16 >
struct	Hash< i32 >
struct	Hash< i8 >
struct	Hash< T * >
struct	Hash< u16 >
struct	Hash< u32 >
struct	Hash< vec2< T > >
class	HashMapLru
class	HashSet
struct	HeapInfo
	Heap memory information. More...
class	HeartPath
struct	hex_t
class	Hot_Blob
class	Hot_Blob_FP
struct	HSV16
struct	hsv8
	Representation of an HSV pixel (hue, saturation, value (aka brightness)). More...
union	hsv8.__unnamed0__
struct	hsv8.__unnamed0__.__unnamed0__
union	hsv8.__unnamed0__.__unnamed0__.__unnamed0__
union	hsv8.__unnamed0__.__unnamed0__.__unnamed1__
union	hsv8.__unnamed0__.__unnamed0__.__unnamed2__
class	HttpConnection
struct	HttpRequest
class	HttpRequestParser
struct	HttpResponse
class	HttpResponseParser
class	IAnimartrix2Viz
class	IButtonInput
class	IChannel
	Polymorphic identification base for any channel in the system. More...
class	IChannelDriver
	Minimal interface for LED channel transmission drivers. More...
class	IDecoder
struct	identity
class	IdTracker
	Thread-safe ID tracker that maps void* pointers to unique integer IDs. More...
union	IEEE754binary32_t
	typedef for IEEE754 "binary32" float type internals More...
struct	IEEE754binary32_t.__unnamed0__
struct	IEEE754binary32_t.__unnamed1__
struct	IEEE754binary32_t.__unnamed2__
class	IFastLED
	Pure virtual interface for FastLED operations. More...
class	ifstream
struct	index_sequence
struct	input_iterator_tag
struct	int_conversion_visitor
struct	int_conversion_visitor< i64 >
struct	integer_promotion_impl
struct	integral_constant
struct	is_arithmetic
struct	is_arithmetic< const T >
struct	is_arithmetic< T & >
struct	is_arithmetic< volatile T >
struct	is_array
struct	is_array< T[]>
struct	is_array< T[N]>
struct	is_base_of
struct	is_base_of_v_helper
struct	is_bitcast_compatible
struct	is_bitcast_compatible< const T >
struct	is_bitcast_compatible< T * >
struct	is_char_type
struct	is_char_type< char >
struct	is_char_type< const T >
struct	is_char_type< signed char >
struct	is_char_type< T & >
struct	is_char_type< unsigned char >
struct	is_char_type< volatile T >
struct	is_const
struct	is_const< const T >
struct	is_enum
struct	is_fixed_point
struct	is_fixed_point< const T >
struct	is_fixed_point< const volatile T >
struct	is_fixed_point< fixed_point< I, F, S > >
struct	is_fixed_point< T & >
struct	is_fixed_point< volatile T >
struct	is_floating_point
struct	is_floating_point< const T >
struct	is_floating_point< double >
struct	is_floating_point< float >
struct	is_floating_point< long double >
struct	is_floating_point< T & >
struct	is_floating_point< volatile T >
struct	is_fp_promotable
struct	is_fp_promotable< fixed_point< FromInt, FromFrac, FromSign >, fixed_point< ToInt, ToFrac, ToSign > >
struct	is_function
struct	is_function< Ret(Args...) const >
struct	is_function< Ret(Args...) const volatile >
struct	is_function< Ret(Args...) volatile >
struct	is_function< Ret(Args...)>
struct	is_integral
struct	is_integral< bool >
struct	is_integral< char >
struct	is_integral< const T >
struct	is_integral< int >
struct	is_integral< long >
struct	is_integral< long long >
struct	is_integral< short >
struct	is_integral< signed char >
struct	is_integral< T & >
struct	is_integral< unsigned char >
struct	is_integral< unsigned int >
struct	is_integral< unsigned long >
struct	is_integral< unsigned long long >
struct	is_integral< unsigned short >
struct	is_integral< volatile T >
struct	is_lvalue_reference
struct	is_lvalue_reference< T & >
struct	is_member_function_pointer
struct	is_member_function_pointer< Ret(C::*)(A...) const >
struct	is_member_function_pointer< Ret(C::*)(A...)>
struct	is_multi_byte_integer
struct	is_pod
struct	is_pod< bool >
struct	is_pod< char >
struct	is_pod< double >
struct	is_pod< float >
struct	is_pod< int >
struct	is_pod< long >
struct	is_pod< long double >
struct	is_pod< long long >
struct	is_pod< short >
struct	is_pod< signed char >
struct	is_pod< unsigned char >
struct	is_pod< unsigned int >
struct	is_pod< unsigned long >
struct	is_pod< unsigned long long >
struct	is_pod< unsigned short >
struct	is_pod_v_helper
struct	is_pointer
struct	is_pointer< T * >
struct	is_pointer< T *const >
struct	is_pointer< T *const volatile >
struct	is_pointer< T *volatile >
struct	is_reference
struct	is_response_send
struct	is_response_send< const ResponseSend & >
struct	is_response_send< ResponseSend & >
struct	is_response_send< ResponseSend && >
struct	is_response_send< ResponseSend >
struct	is_rvalue_reference
struct	is_rvalue_reference< T && >
struct	is_same
struct	is_same< T, T >
struct	is_same_v_helper
struct	is_signed
struct	is_signed< char >
struct	is_signed< const T >
struct	is_signed< const volatile T >
struct	is_signed< double >
struct	is_signed< float >
struct	is_signed< int >
struct	is_signed< long >
struct	is_signed< long double >
struct	is_signed< long long >
struct	is_signed< short >
struct	is_signed< signed char >
struct	is_signed< volatile T >
struct	is_trivially_copyable
struct	is_trivially_copyable_v_helper
struct	is_void
struct	is_void< void >
class	istream
class	istream_real
struct	iterator_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. More...
struct	iterator_traits< const T * >
	Specialization for const raw pointers. More...
struct	iterator_traits< T * >
	Specialization for raw pointers. More...
class	Jpeg
struct	JpegConfig
class	JpegDecoder
struct	JpegInfo
class	json
struct	json_value
class	JsonArgConverter
class	JsonArgConverter< R(Args...)>
union	just8bits
	Structure representing 8 bits of access. More...
struct	just8bits.__unnamed0__
class	KalmanFilter
class	Lava1
class	Lava1_FP
class	LeakyIntegrator
struct	LEDError
	LED error information for a single run. More...
class	Leds
class	LedsXY
struct	less
	Binary function object that returns whether the first argument is less than the second. More...
struct	less< void >
	Specialization of less for void, allowing for transparent comparisons. More...
struct	line_xy
class	LinePath
class	LinePathParams
class	LineSimplifier
class	LineSimplifierExact
class	list
	A doubly-linked list container. More...
struct	LnkMetadata
	Metadata extracted from a .lnk asset link file. More...
class	Luminova
struct	LuminovaParams
class	LUT
struct	make_index_sequence_impl
struct	make_index_sequence_impl< 0, Is... >
struct	make_unsigned
struct	make_unsigned< T, typename enable_if< is_integral< T >::value &&!is_same< typename remove_cv< T >::type, bool >::value >::type >
class	MapRedBlackTree
struct	Matrix3x3f
class	MatrixSlice
struct	max_align
struct	max_align< T, Rest... >
struct	max_align<>
struct	max_align_selector
struct	max_align_selector< false >
struct	max_size
struct	max_size< T, Rest... >
struct	max_size<>
class	MedianFilter
class	memory_resource
	Polymorphic memory resource base class (PMR-style). More...
struct	MethodInfo
	Method information. More...
struct	modulators
class	Module_Experiment1
class	Module_Experiment10
class	Module_Experiment10_FP
class	Module_Experiment1_FP
class	Module_Experiment2
class	Module_Experiment2_FP
class	Module_Experiment3
class	Module_Experiment3_FP
class	Module_Experiment4
class	Module_Experiment4_FP
class	Module_Experiment5
class	Module_Experiment5_FP
class	Module_Experiment6
class	Module_Experiment6_FP
class	Module_Experiment7
class	Module_Experiment7_FP
class	Module_Experiment8
class	Module_Experiment8_FP
class	Module_Experiment9
class	Module_Experiment9_FP
class	MovingAverage
class	Mp3
class	Mp3Decoder
struct	Mp3Info
struct	Mp4TrackInfo
class	Mpeg1
class	Mpeg1FileHandle
struct	Mpeg1Info
struct	MultiChannelConfig
class	MultiMap
class	MultiMapTree
struct	MultiRunConfig
	Multi-run test configuration. More...
class	MultiSet
class	MultiSetTree
struct	NamedTimingConfig
	Chipset timing configuration with name for testing. More...
class	NoiseBias1D
	Per-position attack/decay bias for one axis. More...
class	NoiseBias2D
	Two-axis attack/decay bias for 2D effects (per-column X + per-row Y). More...
class	NoisePalette
class	NoiseWave
class	not_null
class	NullDecoder
class	NullFileHandle
class	NullFileSystem
struct	nullopt_t
struct	numeric_limits
struct	numeric_limits< bool >
struct	numeric_limits< char >
struct	numeric_limits< double >
struct	numeric_limits< float >
struct	numeric_limits< int >
struct	numeric_limits< long >
struct	numeric_limits< long long >
struct	numeric_limits< short >
struct	numeric_limits< signed char >
struct	numeric_limits< unsigned char >
struct	numeric_limits< unsigned int >
struct	numeric_limits< unsigned long >
struct	numeric_limits< unsigned long long >
struct	numeric_limits< unsigned short >
struct	NumericExtractVisitor
class	ObjectFLED
struct	oct_t
class	ofstream
class	OneEuroFilter
class	Optional
class	Optional< T && >
struct	oscillators
class	ostream
struct	output_iterator_tag
class	Pacifica
struct	pair
struct	pair_element
struct	pair_element< 0, T1, T2 >
struct	pair_element< 1, T1, T2 >
struct	pair_xy
class	Parametric_Water
class	Parametric_Water_FP
struct	ParamInfo
	Method parameter information. More...
struct	parse_result
class	Particles1d
	Power-based particle system for 1D LED strips creating organic light effects. More...
struct	PercussionState
	Snapshot of percussion detection state. More...
struct	perlin_i16_optimized
struct	perlin_q16
struct	perlin_s16x16
struct	perlin_s16x16_simd
struct	perlin_s8x8
class	PerlinParticlePunch
class	PhyllotaxisParams
class	PhyllotaxisPath
struct	PinInfo
	Pin number with its resolved port ID. More...
struct	Pins16
	POD struct holding 16 pin numbers for bulk pin writes. More...
struct	Pins8
	POD struct holding 8 pin numbers for bulk pin writes. More...
class	Pir
class	PirLowLevel
struct	PixelControllerVtable
class	PixelIterator
class	PixelIteratorAny
	Adapter class that creates a PixelIterator from any color order. More...
class	PointPath
class	Polar_Waves
class	Polar_Waves_FP
class	Potentiometer
class	PotentiometerLowLevel
class	Pride2015
class	priority_queue_stable
	Stable priority queue that maintains FIFO ordering for equal-priority elements. More...
class	PriorityQueue
struct	ProgmemLUT
struct	ProgmemLUT16
struct	ProgressiveConfig
class	PSRamAllocator
struct	PSRamDeleter
class	qfx
	Template class for representing fractional ints. More...
class	queue
	A first-in, first-out (FIFO) queue container adapter. More...
struct	random_access_iterator_tag
struct	ratio
	Compile-time rational arithmetic. More...
struct	rect
class	RectangularDrawBuffer
class	RedBlackTree
class	RedSquare
class	Remote
	JSON-RPC server with scheduling support. More...
struct	remove_const
struct	remove_const< const T >
struct	remove_cv
struct	remove_cv< const T >
struct	remove_cv< const volatile T >
struct	remove_cv< volatile T >
struct	remove_extent
struct	remove_extent< T[]>
struct	remove_extent< T[N]>
struct	remove_pointer
struct	remove_pointer< T * >
struct	remove_pointer< T *const >
struct	remove_pointer< T *const volatile >
struct	remove_pointer< T *volatile >
struct	remove_reference
struct	remove_reference< T & >
struct	remove_reference< T && >
struct	render_parameters
struct	render_parameters_fp
struct	ResetInfo
	Detailed reset information bundling the normalized cause with a platform-specific subcause id and the raw cause-register value. More...
struct	response_aware_signature
	Type trait to detect if a function signature has ResponseSend& as first parameter. More...
struct	response_aware_signature< R(*)(ResponseSend &, Args...)>
struct	response_aware_signature< R(ResponseSend &, Args...)>
class	ResponseSend
	Helper class for sending responses in async/streaming RPC methods. More...
class	reverse_iterator
	Reverse iterator adapter - reverses the direction of a bidirectional iterator. More...
struct	rgb
class	RGB_Blobs
class	RGB_Blobs2
class	RGB_Blobs2_FP
class	RGB_Blobs3
class	RGB_Blobs3_FP
class	RGB_Blobs4
class	RGB_Blobs4_FP
class	RGB_Blobs5
class	RGB_Blobs5_FP
class	RGB_Blobs_FP
struct	Rgbw
struct	RgbwDefault
struct	RgbwInvalid
struct	RGBWPixel
	Simple RGBW pixel struct for encoder input. More...
struct	Rgbww
	Per-strip RGBWW configuration. More...
struct	RgbwwDefault
	Default RGBWW configuration: colorimetric mode at warm=2700K / cool=6500K, default profile, end-aligned warm-then-cool W byte placement. More...
struct	RgbwWhiteIsOff
struct	RgbwwInvalid
	Sentinel: disables RGBWW (variant should hold fl::Empty instead, but this is kept for symmetry with RgbwInvalid). More...
struct	RGBWWPixel
	Simple 5-channel pixel struct: red, green, blue, warm-white, cool-white. More...
class	Rings
class	Rings_FP
class	RosePath
class	RosePathParams
class	Rotating_Blob
class	Rotating_Blob_FP
class	Rpc
struct	rpc_storage_type
struct	rpc_storage_type< char * >
struct	rpc_storage_type< const char * >
struct	rpc_storage_type< fl::span< const double > >
struct	rpc_storage_type< fl::span< const fl::string > >
struct	rpc_storage_type< fl::span< const float > >
struct	rpc_storage_type< fl::span< const int > >
struct	rpc_storage_type< fl::span< const T > >
class	RpcHandle
class	RpcHandle< R(Args...)>
struct	RpcResult
	Result metadata for executed RPC calls. More...
struct	RunResult
	Single run result with error tracking. More...
class	RxChannel
struct	RxChannelConfig
struct	RxConfig
	Configuration for RX device initialization. More...
class	RxDevice
	Common interface for RX devices. More...
class	s0x32
struct	s0x32x4
	4-wide s0x32 vector (normalized values [-1, 1]) Backed by 128-bit SIMD register (4× i32 in Q31 format) More...
class	s12x4
class	s16x16
struct	s16x16x4
	4-wide s16x16 vector (general fixed-point) Backed by 128-bit SIMD register (4× i32 in Q16 format) More...
class	s24x8
class	s4x12
class	s8x24
class	s8x8
class	SavitzkyGolayFilter
class	Scaledemo1
class	Scaledemo1_FP
class	ScaleUp
	Effect wrapper that upscales delegate effects using bilinear interpolation. More...
class	scope_exit
	RAII guard that executes a callable when destroyed. More...
class	ScopedLogDisable
	RAII class to temporarily disable all logging output. More...
class	ScopedTrace
	RAII guard for automatic call stack tracking. More...
class	ScopedWatchdog
	RAII watchdog guard for the canonical loop()-top use case. More...
class	ScreenMap
struct	SerializerVisitor
class	SerialPort
	Arduino-compatible Serial class for cross-platform serial I/O. More...
struct	SerialReader
	Serial adapter using fl:: input functions (fl::available, fl::read) More...
struct	SerialWriter
	Serial adapter using fl:: output functions (fl::println) More...
class	Server
	JSON-RPC server with callback-based I/O. More...
class	set
class	SetRedBlackTree
class	shared_ptr
struct	SinCos32
struct	SingleTestConfig
	Single test configuration - fully stateless. More...
struct	SingleTestResult
	Single test result - comprehensive pass/fail information. More...
class	Singleton
class	SingletonShared
class	SingletonThreadLocal
struct	SizeVisitor
class	SlabAllocator
class	Slow_Fade
class	Slow_Fade_FP
struct	SmallMapEqualTo
class	SortedHeapVector
class	span
class	span< T, dynamic_extent >
class	SpectralVariance
class	Spi
	SPI Device - RAII wrapper for multi-lane SPI. More...
class	SpiChannelEngineAdapter
	Adapter that wraps HW SPI controllers for ChannelManager. More...
struct	SpiChipsetConfig
	SPI chipset configuration (data + clock pins) More...
struct	SpiConfig
	Configuration for SPI device (supports 1-8 lanes) More...
struct	SpiEncoder
	SPI encoder configuration for LED protocols. More...
class	SpiralMatrix1
class	SpiralMatrix10
class	SpiralMatrix10_FP
class	SpiralMatrix1_FP
class	SpiralMatrix2
class	SpiralMatrix2_FP
class	SpiralMatrix3
class	SpiralMatrix3_FP
class	SpiralMatrix4
class	SpiralMatrix4_FP
class	SpiralMatrix5
class	SpiralMatrix5_FP
class	SpiralMatrix6
class	SpiralMatrix6_FP
class	SpiralMatrix8
class	SpiralMatrix8_FP
class	SpiralMatrix9
class	SpiralMatrix9_FP
class	Spiralus
class	Spiralus2
class	Spiralus2_FP
class	Spiralus_FP
class	SPITransposer
	Unified stateless bit-interleaving transposer for multi-lane SPI parallel LED transmission. More...
class	sstream
class	sstream_noop
struct	static_assert_failure
struct	static_assert_failure< true >
class	StbVorbisDecoder
class	string
class	string_n
class	string_view
struct	StringConversionVisitor
struct	StringFastLess
class	StringHolder
class	StringInterner
struct	sub4
	Structure representing 32 bits of access. More...
struct	swap_impl
struct	swap_impl< T, false >
struct	swap_impl< T, true >
struct	TestContext
	Test context for detailed error reporting Aggregates all test configuration parameters for error messages. More...
class	ThreadLocalFake
class	Tile2x2_u8
class	Tile2x2_u8_wrap
class	TimeAlpha
class	TimeClampedTransition
class	TimeFunction
class	Timeout
	Generic timeout timer with rollover-safe arithmetic. More...
class	TimeRamp
class	TimeWarp
struct	TIMING_DP1903_400KHZ
	DP1903 controller @ 400 kHz Four-phase: TH0=800ns, TH1=2400ns, TL0=2400ns, TL1=800ns. More...
struct	TIMING_DP1903_800KHZ
	DP1903 controller @ 800 kHz Four-phase: TH0=400ns, TH1=1400ns, TL0=1400ns, TL1=400ns. More...
struct	TIMING_GE8822_800KHZ
	GE8822 RGB controller @ 800 kHz Four-phase: TH0=350ns, TH1=1010ns, TL0=1010ns, TL1=350ns. More...
struct	TIMING_GW6205_400KHZ
	GW6205 controller @ 400 kHz Four-phase: TH0=800ns, TH1=1600ns, TL0=1600ns, TL1=800ns. More...
struct	TIMING_GW6205_800KHZ
	GW6205 controller @ 800 kHz (fast variant) Four-phase: TH0=400ns, TH1=800ns, TL0=800ns, TL1=400ns. More...
struct	TIMING_LPD1886_1250KHZ
	LPD1886 RGB controller @ 1250 kHz Four-phase: TH0=200ns, TH1=600ns, TL0=600ns, TL1=200ns. More...
struct	TIMING_PL9823
	PL9823 RGB controller @ 800 kHz Four-phase: TH0=350ns, TH1=1360ns, TL0=1360ns, TL1=350ns. More...
struct	TIMING_SK6812
	SK6812 RGBW controller @ 800 kHz Four-phase: TH0=300ns, TH1=900ns, TL0=900ns, TL1=300ns. More...
struct	TIMING_SK6822
	SK6822 RGB controller @ 800 kHz Four-phase: TH0=375ns, TH1=1375ns, TL0=1375ns, TL1=375ns. More...
struct	TIMING_SM16703
	SM16703 RGB controller @ 800 kHz Four-phase: TH0=300ns, TH1=900ns, TL0=900ns, TL1=300ns. More...
struct	TIMING_SM16824E
	SM16824E RGB controller (high-speed variant) Four-phase: TH0=300ns, TH1=1200ns, TL0=1000ns, TL1=100ns. More...
struct	TIMING_TM1803_400KHZ
	TM1803 controller @ 400 kHz Four-phase: TH0=700ns, TH1=1800ns, TL0=1800ns, TL1=700ns. More...
struct	TIMING_TM1809_800KHZ
	TM1809 RGB controller @ 800 kHz Four-phase: TH0=350ns, TH1=700ns, TL0=800ns, TL1=450ns. More...
struct	TIMING_TM1814
	TM1814 RGBW controller @ 800 kHz Four-phase: TH0=360ns, TH1=960ns, TL0=940ns, TL1=340ns. More...
struct	TIMING_TM1829_1600KHZ
	TM1829 RGB controller @ 1600 kHz (high-speed variant) Four-phase: TH0=100ns, TH1=400ns, TL0=500ns, TL1=200ns. More...
struct	TIMING_TM1829_800KHZ
	TM1829 RGB controller @ 800 kHz Four-phase: TH0=340ns, TH1=680ns, TL0=890ns, TL1=550ns. More...
struct	TIMING_UCS1903_400KHZ
	UCS1903 controller @ 400 kHz Four-phase: TH0=500ns, TH1=2000ns, TL0=2000ns, TL1=500ns. More...
struct	TIMING_UCS1903B_800KHZ
	UCS1903B controller @ 800 kHz Four-phase: TH0=400ns, TH1=850ns, TL0=900ns, TL1=450ns. More...
struct	TIMING_UCS1904_800KHZ
	UCS1904 controller @ 800 kHz Four-phase: TH0=400ns, TH1=800ns, TL0=850ns, TL1=450ns. More...
struct	TIMING_UCS1912
	UCS1912 controller @ 800 kHz Four-phase: TH0=250ns, TH1=1250ns, TL0=1350ns, TL1=350ns. More...
struct	TIMING_UCS2903
	UCS2903 controller @ 800 kHz Four-phase: TH0=250ns, TH1=1000ns, TL0=1000ns, TL1=250ns. More...
struct	TIMING_UCS7604_1600KHZ
	UCS7604 RGBW controller @ 1600 kHz (16-bit color depth, high-speed) Four-phase: TH0=200ns, TH1=400ns, TL0=425ns, TL1=225ns. More...
struct	TIMING_UCS7604_800KHZ
	UCS7604 RGBW controller @ 800 kHz (16-bit color depth) Four-phase: TH0=400ns, TH1=800ns, TL0=850ns, TL1=450ns. More...
struct	TIMING_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. More...
struct	TIMING_WS2811_400KHZ
	WS2811 @ 400kHz (standard mode, datasheet specification) More...
struct	TIMING_WS2811_800KHZ_LEGACY
	WS2811 @ 800kHz (fast mode, half the timing of 400kHz mode) More...
struct	TIMING_WS2812_800KHZ
	WS2812 RGB controller @ 800 kHz (most common, overclockable) Four-phase: TH0=250ns, TH1=875ns, TL0=1000ns, TL1=375ns. More...
struct	TIMING_WS2812_800KHZ_LEGACY
	WS2812 RGB controller @ 800 kHz legacy variant Four-phase: TH0=320ns, TH1=640ns, TL0=960ns, TL1=640ns. More...
struct	TIMING_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. More...
struct	TIMING_WS2813
	WS2813 RGB controller (same timing as WS2812) Four-phase: TH0=320ns, TH1=640ns, TL0=960ns, TL1=640ns. More...
struct	TIMING_WS2815
	WS2815 RGB controller @ 400 kHz Four-phase: TH0=250ns, TH1=1340ns, TL0=1640ns, TL1=550ns. More...
struct	TimingTraits
	Compile-time trait to extract timing values from timing types. More...
struct	TraceEntry
	A single stack trace entry with location information. More...
struct	TraceStorage
	Internal storage for the trace system Encapsulates call stack and depth tracking per-thread. More...
struct	Transform16
struct	TransformFloat
class	TransformFloatImpl
class	Transition
class	TriangularFilter
struct	tuple
struct	tuple< Head, Tail... >
struct	tuple<>
struct	tuple_element
struct	tuple_element< 0, pair< T1, T2 > >
struct	tuple_element< 0, tuple< Head, Tail... > >
struct	tuple_element< 1, pair< T1, T2 > >
struct	tuple_element< I, tuple< Head, Tail... > >
struct	tuple_size
struct	tuple_size< pair< T1, T2 > >
struct	tuple_size< tuple< Ts... > >
class	TwinkleFox
struct	type_rank
struct	type_rank< bool >
struct	type_rank< char >
struct	type_rank< double >
struct	type_rank< float >
struct	type_rank< int >
struct	type_rank< long >
struct	type_rank< long double >
struct	type_rank< long long >
struct	type_rank< short >
struct	type_rank< signed char >
struct	type_rank< unsigned char >
struct	type_rank< unsigned int >
struct	type_rank< unsigned long >
struct	type_rank< unsigned long long >
struct	type_rank< unsigned short >
class	TypeConversionResult
class	TypedChannel
	Templated channel facade. More...
class	TypedRpcBinding
class	TypedRpcBinding< R(Args...)>
class	TypedRpcBinding< void(Args...)>
class	u0x32
class	u12x4
class	u16x16
class	u24x8
class	u4x12
class	u8x24
class	u8x8
class	UCS7604ControllerT
	UCS7604 controller extending CPixelLEDController. More...
struct	UCS7604CurrentControl
	UCS7604 current control structure with 4-bit fields for each channel. More...
class	UIAudio
class	UIAudioImpl
class	UIButton
class	UIButtonImpl
class	UICheckbox
class	UICheckboxImpl
class	UIDescription
class	UIDescriptionImpl
class	UIDropdown
class	UIDropdownImpl
class	UIElement
class	UIGroup
class	UIGroupImpl
class	UIHelp
class	UIHelpImpl
class	UINumberField
class	UINumberFieldImpl
class	UISlider
class	UISliderImpl
class	UITitle
class	UITitleImpl
struct	underlying_type
class	unique_ptr
class	unique_ptr< T[], Deleter >
class	unordered_map
class	unordered_map_small
class	unordered_set
class	unsorted_map_fixed
class	url
struct	vec2
struct	vec3
class	vector
class	vector_basic
	Type-erased vector base class. More...
struct	vector_element_ops
	Function pointer table for type-specific element operations. More...
class	vector_psram
class	VectorN
class	VectorSet
class	VectorSetFixed
struct	VibeLevels
	Snapshot of self-normalizing MilkDrop-style vibe levels. More...
class	Video
class	VideoFxWrapper
struct	VoidSuccess
	Dummy type for void expected success state. More...
class	Vorbis
class	VorbisDecoder
class	VorbisDecoderImpl
struct	VorbisFrame
struct	VorbisInfo
class	Watchdog
	Unified cross-platform watchdog interface. More...
struct	WatchdogCrashReport
	Decoded crash report (Tier 2). More...
class	Water
class	Water_FP
struct	Wave3Byte
	Type-safe container for 3-byte wave pulse pattern (wave3 encoding) More...
struct	Wave8Bit
	Type-safe container for packed 8-bit wave pulse pattern. More...
class	WaveCrgbGradientMap
	Wave-to-color mapper using gradient/palette coloring. More...
class	WaveCrgbMap
	Abstract base class for mapping wave simulation values to LED colors. More...
class	WaveCrgbMapDefault
	Default wave-to-color mapper producing grayscale output. More...
class	WaveFx
	2D wave simulation effect with supersampling and gradient coloring More...
struct	WaveFxArgs
	Configuration parameters for WaveFx effect. More...
class	Waves
class	Waves_FP
class	WaveSimulation1D
class	WaveSimulation1D_Real
class	WaveSimulation2D
class	WaveSimulation2D_Real
class	weak_ptr
class	WeakPtr
class	WeightedMovingAverage
class	WLED
	WLED-specific Remote RPC extension. More...
class	WLEDClient
	WLED Client for controlling LEDs through FastLED interface. More...
struct	WLEDSegment
	WLED segment configuration. More...
struct	WriteResult
	Result of a write operation. More...
class	XMap
struct	XYDrawComposited
struct	XYDrawGradient
class	XYMap
class	XYPath
class	XYPathFunction
class	XYPathGenerator
class	XYPathParams
class	XYPathRenderer
class	XYRasterSparse_RGB8
class	XYRasterU8Sparse
class	Yves
class	Yves_FP
class	Zoom
class	Zoom2
class	Zoom2_FP
class	Zoom_FP

Typedefs
typedef u16	accum124
	no direct ANSI counterpart. 12 bits int, 4 bits fraction
typedef u16	accum124
	no direct ANSI counterpart. 12 bits int, 4 bits fraction
typedef u32	accum1616
	ANSI: signed _Accum. 16 bits int, 16 bits fraction.
typedef u32	accum1616
	ANSI: signed _Accum. 16 bits int, 16 bits fraction.
typedef u16	accum88
	ANSI: unsigned short _Accum. 8 bits int, 8 bits fraction.
typedef u16	accum88
	ANSI: unsigned short _Accum. 8 bits int, 8 bits fraction.
template<typename T>
using	add_pointer_t = typename add_pointer<T>::type
typedef void(*	advanceDataFunction) (void *pixel_controller)
template<typename T, fl::size N>
using	allocator_inlined_psram = allocator_inlined<T, N, fl::allocator_psram<T>>
template<typename T, fl::size N>
using	allocator_inlined_slab = allocator_inlined<T, N, fl::allocator_slab<T>>
template<typename T, fl::size N, fl::size SLAB_SIZE = 8>
using	allocator_inlined_slab_psram = allocator_inlined<T, N, fl::allocator_slab<T, SLAB_SIZE>>
using	AnimartrixVizFactory = IAnimartrix2Viz* (*)()
template<typename T>
using	atomic = AtomicFake<T>
using	atomic_bool = atomic<bool>
using	atomic_i32 = atomic<fl::i32>
using	atomic_int = atomic<int>
using	atomic_u32 = atomic<fl::u32>
using	atomic_uint = atomic<unsigned int>
using	AudioFrameCallback = fl::function<void(const audio::Sample&)>
using	binary_semaphore = fl::platforms::binary_semaphore
	Binary semaphore abstraction for FastLED.
template<bool B>
using	bool_constant = integral_constant<bool, B>
using	centi = ratio<1, 100>
	1/100
using	ChipsetVariant = fl::variant<ClocklessChipset, SpiChipsetConfig>
template<typename T, typename U>
using	common_type_t = typename common_type<T, U>::type
template<bool B, typename T, typename F>
using	conditional_t = typename conditional<B, T, F>::type
template<ptrdiff_t LeastMaxValue = 1>
using	counting_semaphore = fl::platforms::counting_semaphore<LeastMaxValue>
	Counting semaphore abstraction for FastLED.
using	CRGB = fl::CRGB
using	deca = ratio<10, 1>
	10/1
template<typename T>
using	decay_t = typename decay<T>::type
using	deci = ratio<1, 10>
	1/10
template<typename T>
using	DefaultLess = less<T>
typedef deque< double >	deque_double
typedef deque< float >	deque_float
typedef deque< int >	deque_int
template<bool Condition, typename T = void>
using	enable_if_t = typename enable_if<Condition, T>::type
template<typename T>
using	equal_to = EqualTo<T>
using	false_type = integral_constant<bool, false>
using	FILE = FILE_impl
using	filebuf_ptr = fl::shared_ptr<filebuf>
template<typename Key, size N>
using	FixedSet = VectorSetFixed<Key, N>
template<typename Key, typename T, typename Compare = fl::less<Key>>
using	fl_map = map<Key, T, Compare>
using	fl_random = math::random
using	FontPtr = fl::shared_ptr<Font>
typedef u16	fract16
	ANSI: unsigned _Fract.
typedef u16	fract16
	ANSI: unsigned _Fract.
typedef u32	fract32
	ANSI: unsigned long _Fract. 32 bits int, 32 bits fraction.
typedef u32	fract32
	ANSI: unsigned long _Fract. 32 bits int, 32 bits fraction.
typedef u8	fract8
	Fixed-Point Fractional Types.
typedef u8	fract8
	Fixed-Point Fractional Types.
using	FrameTracker = video::FrameTracker
typedef ProgmemLUT< GammaEval< gamma< u8x24 >(2.2f)>, 256 >	Gamma22LUT
typedef ProgmemLUT16< GammaEval16< gamma< u8x24 >(2.2f)>, 256 >	Gamma22LUT16
typedef ProgmemLUT< GammaEval< gamma< u8x24 >(2.8f)>, 256 >	Gamma28LUT
typedef ProgmemLUT16< GammaEval16< gamma< u8x24 >(2.8f)>, 256 >	Gamma28LUT16
using	GammaKey = fl::ufixed_point<4, 12>
template<u32 G>
using	GammaTable16_256 = ProgmemLUT16<GammaEval16<G>, 256>
template<u32 G>
using	GammaTable256 = ProgmemLUT<GammaEval<G>, 256>
typedef void(*	getHdScaleFunction) (void *pixel_controller, u8 *c0, u8 *c1, u8 *c2, u8 *brightness)
using	giga = ratio<1000000000, 1>
	1,000,000,000/1
typedef u8(*	globalBrightness) (void *pixel_controller)
typedef bool(*	hasFunction) (void *pixel_controller, int n)
template<typename Key, typename T, typename Hash = Hash<Key>, typename KeyEqual = equal_to<Key>>
using	hash_map = unordered_map<Key, T, Hash, KeyEqual>
using	hecto = ratio<100, 1>
	100/1
using	http_request = asio::http::Request
using	http_response = asio::http::Response
using	HttpRequestPtr = fl::shared_ptr<HttpRequest>
using	HttpRequestPtrConst = fl::shared_ptr<const HttpRequest>
using	HttpResponsePtr = fl::shared_ptr<HttpResponse>
using	HttpResponsePtrConst = fl::shared_ptr<const HttpResponse>
using	HttpServer = asio::http::Server
typedef fl::i64	i64
typedef signed char	i8
template<typename T, fl::size INLINED_SIZE>
using	InlinedVector = VectorN<T, INLINED_SIZE>
typedef fl::i16	int16_t
typedef fl::i32	int32_t
typedef signed char	int8_t
typedef fl::iptr	intptr_t
template<typename Base, typename Derived>
using	is_derived = enable_if_t<is_base_of<Base, Derived>::value>
using	JpegDecoderPtr = fl::shared_ptr<JpegDecoder>
using	json_array = fl::vector<fl::shared_ptr<json_value>>
using	json_object = fl::flat_map<fl::string, fl::shared_ptr<json_value>, fl::StringFastLess>
using	kilo = ratio<1000, 1>
	1,000/1
using	LineCap = gfx::LineCap
	Line cap style.
typedef void(*	loadAndScaleRGBFunction) (void *pixel_controller, u8 *r_out, u8 *g_out, u8 *b_out)
typedef void(*	loadAndScaleRGBWFunction) (void *pixel_controller, Rgbw rgbw, u8 *b0_out, u8 *b1_out, u8 *b2_out, u8 *b3_out)
typedef void(*	loadAndScaleRGBWWFunction) (void *pixel_controller, Rgbww rgbww, u8 *b0_out, u8 *b1_out, u8 *b2_out, u8 *b3_out, u8 *b4_out)
typedef void(*	loadRGBScaleAndBrightnessFunction) (void *pixel_controller, u8 *c0, u8 *c1, u8 *c2, u8 *brightness)
typedef LUT< u16 >	LUT16
typedef LUT< vec2< u16 > >	LUTXY16
using	LUTXYFLOAT = LUT<vec2f>
using	LUTXYFLOATPtr = shared_ptr<LUTXYFLOAT>
typedef LUT< vec3f >	LUTXYZFLOAT
template<fl::size N>
using	make_index_sequence = typename make_index_sequence_impl<N>::type
template<typename Key, typename T, typename Compare = fl::less<Key>>
using	map = MapRedBlackTree<Key, T, Compare, fl::allocator_slab<char>>
typedef max_align_selector<(sizeof(longdouble)>sizeof(double))>::type	max_align_t
using	mega = ratio<1000000, 1>
	1,000,000/1
using	memorybuf = detail::memorybuf
using	micro = ratio<1, 1000000>
	1/1,000,000
using	milli = ratio<1, 1000>
	1/1,000
using	Mp3DecoderPtr = fl::shared_ptr<Mp3Decoder>
using	Mpeg1Config = third_party::Mpeg1Config
template<typename Key, typename T, typename Compare = fl::less<Key>>
using	multi_map = MultiMapTree<Key, T, Compare, fl::allocator_slab<char>>
template<typename Key, typename Compare = fl::less<Key>>
using	multi_set = MultiSetTree<Key, Compare, fl::allocator_slab<char>>
using	mutex = fl::platforms::mutex
using	nano = ratio<1, 1000000000>
	1/1,000,000,000
using	NetworkDetector = ::fl::net::NetworkDetector
using	NotNullStringHolderPtr = fl::not_null<StringHolderPtr>
typedef decltype(nullptr)	nullptr_t
template<typename T>
using	optional = Optional<T>
using	PaddingGenerator = fl::function<void(fl::span<const u8> src, fl::span<u8> dst)>
	Padding generator function type.
template<typename T1, typename T2>
using	Pair = pair<T1, T2>
using	pair_xy_float = vec2<float>
using	pair_xyz_float = vec3<float>
using	PixelStream = video::PixelStream
using	PixelStreamPtr = video::PixelStreamPtr
typedef fl::ptrdiff	ptrdiff_t
typedef qfx< u16, 12, 4 >	q124
	A 12.4 integer (12 bits integer, 4 bits fraction)
typedef qfx< u8, 4, 4 >	q44
	A 4.4 integer (4 bits integer, 4 bits fraction)
typedef qfx< u8, 6, 2 >	q62
	A 6.2 integer (6 bits integer, 2 bits fraction)
typedef qfx< u16, 8, 8 >	q88
	A 8.8 integer (8 bits integer, 8 bits fraction)
typedef int(*	qsort_compare_fn) (const void *, const void *)
template<typename R1, typename R2>
using	ratio_divide
	Divide two ratios at compile time.
template<typename R1, typename R2>
using	ratio_multiply
	Multiply two ratios at compile time.
using	recursive_mutex = fl::platforms::recursive_mutex
template<typename T>
using	remove_cv_t = typename remove_cv<T>::type
template<typename T>
using	remove_pointer_t = typename remove_pointer<T>::type
template<typename T>
using	remove_reference_t = typename remove_reference<T>::type
template<typename T, typename E = ResultError>
using	result = expected<T, E>
	Alias for expected (Rust-style naming)
typedef void(*	rgb_2_rgbw_function) (u16 w_color_temperature, u8 r, u8 g, u8 b, u8 r_scale, u8 g_scale, u8 b_scale, u8 *out_r, u8 *out_g, u8 *out_b, u8 *out_w)
typedef void(*	rgb_2_rgbww_function) (const Rgbww &cfg, fl::u8 r, fl::u8 g, fl::u8 b, fl::u8 r_scale, fl::u8 g_scale, fl::u8 b_scale, fl::u8 *out_r, fl::u8 *out_g, fl::u8 *out_b, fl::u8 *out_ww, fl::u8 *out_wc)
using	RpcFactory = Rpc
template<class Sig>
using	RpcFn = fl::function<Sig>
typedef i32	saccum114
	no direct ANSI counterpart. 1 bit int, 14 bits fraction
typedef i32	saccum114
	no direct ANSI counterpart. 1 bit int, 14 bits fraction
typedef i32	saccum1516
	ANSI: signed _Accum. 15 bits int, 16 bits fraction.
typedef i32	saccum1516
	ANSI: signed _Accum. 15 bits int, 16 bits fraction.
typedef i16	saccum78
	ANSI: signed short _Accum. 7 bits int, 8 bits fraction.
typedef i16	saccum78
	ANSI: signed short _Accum. 7 bits int, 8 bits fraction.
template<typename T, typename Deleter = default_delete<T>>
using	scoped_ptr = unique_ptr<T, Deleter>
template<typename T, fl::size N>
using	set_inlined = fl::set<T, fl::allocator_inlined_slab<T, N>>
template<int IntBits, int FracBits>
using	sfixed_integer = fixed_point<IntBits, FracBits, Sign::SIGNED>
template<int IntBits, int FracBits>
using	sfixed_point = sfixed_integer<IntBits, FracBits>
typedef i16	sfract15
	ANSI: signed _Fract.
typedef i16	sfract15
	ANSI: signed _Fract.
typedef i32	sfract31
	ANSI: signed long _Fract. 31 bits int, 1 bit fraction.
typedef i32	sfract31
	ANSI: signed long _Fract. 31 bits int, 1 bit fraction.
typedef i8	sfract7
	ANSI: signed short _Fract.
typedef i8	sfract7
	ANSI: signed short _Fract.
typedef fl::size	size_t
typedef int(*	sizeFunction) (void *pixel_controller)
template<typename T = void>
using	SpiResult = spi::Result<T>
using	SpiTransaction = spi::Transaction
typedef void(*	stepDitheringFunction) (void *pixel_controller)
using	string_large = string_n<256>
using	string_small = string_n<32>
using	StringHolderPtr = fl::shared_ptr<fl::StringHolder>
using	thread = fl::platforms::thread
	Thread abstraction for FastLED.
using	thread_id = fl::platforms::thread_id
	Thread ID type.
template<typename T>
using	ThreadLocal = ThreadLocalFake<T>
using	TIMING_WS2812B_V5 = TIMING_WS2812B_MINI_V3
	Convenience alias - WS2812B-V5 uses identical timing to Mini-V3.
using	TracePoint = fl::tuple<const char*, int, fl::u32>
	A structure to hold source trace information.
using	true_type = integral_constant<bool, true>
typedef fl::u64	u64
typedef unsigned char	u8
template<int DATA_PIN, EOrder RGB_ORDER, template< int, typename, EOrder > class CLOCKLESS_CONTROLLER>
using	UCS7604Controller16bit1600T = UCS7604ControllerT<DATA_PIN, RGB_ORDER, fl::UCS7604Mode::UCS7604_MODE_16BIT_1600KHZ, fl::TIMING_UCS7604_1600KHZ, CLOCKLESS_CONTROLLER>
template<int DATA_PIN, EOrder RGB_ORDER, template< int, typename, EOrder > class CLOCKLESS_CONTROLLER>
using	UCS7604Controller16bitT = UCS7604ControllerT<DATA_PIN, RGB_ORDER, fl::UCS7604Mode::UCS7604_MODE_16BIT_800KHZ, fl::TIMING_UCS7604_800KHZ, CLOCKLESS_CONTROLLER>
template<int DATA_PIN, EOrder RGB_ORDER, template< int, typename, EOrder > class CLOCKLESS_CONTROLLER>
using	UCS7604Controller8bitT = UCS7604ControllerT<DATA_PIN, RGB_ORDER, fl::UCS7604Mode::UCS7604_MODE_8BIT_800KHZ, fl::TIMING_UCS7604_800KHZ, CLOCKLESS_CONTROLLER>
template<int IntBits, int FracBits>
using	ufixed_integer = fixed_point<IntBits, FracBits, Sign::UNSIGNED>
template<int IntBits, int FracBits>
using	ufixed_point = ufixed_integer<IntBits, FracBits>
typedef unsigned int	uint
typedef fl::u16	uint16_t
typedef fl::u32	uint32_t
typedef unsigned char	uint8_t
typedef fl::uptr	uintptr_t
template<typename T>
using	underlying_type_t = typename underlying_type<T>::type
using	Url = url
using	vec2f = vec2<float>
using	vec2i16 = vec2<i16>
using	vec2u8 = vec2<fl::u8>
using	vec3f = vec3<float>
template<typename T, fl::size INLINED_SIZE>
using	vector_fixed = FixedVector<T, INLINED_SIZE>
template<typename T, fl::size INLINED_SIZE = 64>
using	vector_inlined = VectorN<T, INLINED_SIZE>
using	VideoImpl = video::VideoImpl
using	VideoImplPtr = fl::shared_ptr<VideoImpl>
using	WatchdogTimeoutCallback = void(*)(void* user_data)
	ISR-safe C function pointer callback for onTimeout().
using	WS2812ChipsetTiming = TIMING_WS2812_800KHZ
	Convenience alias for WS2812 timing (commonly used name)
typedef u16(*	XFunction) (u16 x, u16 length)
typedef u16(*	XYFunction) (u16 x, u16 y, u16 width, u16 height)
using	XYMapCallback = fl::u16 (*)(fl::u16 x, fl::u16 y, void *userData)
using	XYMapPtr = shared_ptr<XYMap>
using	XYRaster = XYRasterU8Sparse
using	XYRasterSparse_CRGB = XYRasterSparse_RGB8

Enumerations
enum	{ kRGBWDefaultColorTemp = 6000 }
enum	{ kRGBWWDefaultWarmCct = 2700 , kRGBWWDefaultCoolCct = 6500 }
	Default warm / cool reference CCTs for built-in profiles. More...
enum class	AdcRange {   Default = 0 , Range0_1V1 , Range0_1V5 , Range0_2V2 ,   Range0_3V3 , Range0_5V , External }
	ADC voltage range configuration. More...
enum class	AnimartrixAnim {   RGB_BLOBS5 = 0 , RGB_BLOBS4 , RGB_BLOBS3 , RGB_BLOBS2 ,   RGB_BLOBS , POLAR_WAVES , SLOW_FADE , ZOOM2 ,   ZOOM , HOT_BLOB , SPIRALUS2 , SPIRALUS ,   YVES , SCALEDEMO1 , LAVA1 , CALEIDO3 ,   CALEIDO2 , CALEIDO1 , DISTANCE_EXPERIMENT , CENTER_FIELD ,   WAVES , CHASING_SPIRALS , ROTATING_BLOB , RINGS ,   COMPLEX_KALEIDO , COMPLEX_KALEIDO_2 , COMPLEX_KALEIDO_3 , COMPLEX_KALEIDO_4 ,   COMPLEX_KALEIDO_5 , COMPLEX_KALEIDO_6 , WATER , PARAMETRIC_WATER ,   MODULE_EXPERIMENT1 , MODULE_EXPERIMENT2 , MODULE_EXPERIMENT3 , MODULE_EXPERIMENT4 ,   MODULE_EXPERIMENT5 , MODULE_EXPERIMENT6 , MODULE_EXPERIMENT7 , MODULE_EXPERIMENT8 ,   MODULE_EXPERIMENT9 , MODULE_EXPERIMENT10 , MODULE_EXPERIMENT_SM1 , MODULE_EXPERIMENT_SM2 ,   MODULE_EXPERIMENT_SM3 , MODULE_EXPERIMENT_SM4 , MODULE_EXPERIMENT_SM5 , MODULE_EXPERIMENT_SM6 ,   MODULE_EXPERIMENT_SM8 , MODULE_EXPERIMENT_SM9 , MODULE_EXPERIMENT_SM10 , FLUFFY_BLOBS ,   NUM_ANIMATIONS }
enum class	BindError { NotFound , SignatureMismatch }
enum class	BumpShape : u8 { HalfSine , Gaussian }
	Shape function for NoiseBias triggers. More...
enum class	Bus : fl::u8 {   AUTO = 0 , RMT , PARLIO , SPI ,   I2S , I2S_SPI , LCD_RGB , LCD_SPI ,   LCD_CLOCKLESS , UART , FLEX_IO , OBJECT_FLED ,   LPUART , BIT_BANG , STUB }
	Driver identifier for compile-time bus selection. More...
enum class	ButtonStrategy { kHighLowFloating , kPullUp , kPullDown }
enum class	ClocklessEncoder : u8 { CLOCKLESS_ENCODER_WS2812 = 0 , CLOCKLESS_ENCODER_UCS7604_8BIT , CLOCKLESS_ENCODER_UCS7604_16BIT , CLOCKLESS_ENCODER_UCS7604_16BIT_1600 }
	Identifies which encoder to use for clockless chipsets in the Channel API. More...
enum class	ConnectionState {   DISCONNECTED , CONNECTING , CONNECTED , RECONNECTING ,   CLOSED }
enum class	DecodeError : u8 { OK = 0 , HIGH_ERROR_RATE , BUFFER_OVERFLOW , INVALID_ARGUMENT }
	Error codes for RX decoder operations. More...
enum class	DecodeResult {   Success , NeedsMoreData , EndOfStream , Error ,   UnsupportedFormat }
enum class	DrawMode { DRAW_MODE_OVERWRITE , DRAW_MODE_BLEND , DRAW_MODE_BLEND_BY_MAX_BRIGHTNESS }
enum class	EaseType {   EASE_NONE , EASE_IN_QUAD , EASE_OUT_QUAD , EASE_IN_OUT_QUAD ,   EASE_IN_CUBIC , EASE_OUT_CUBIC , EASE_IN_OUT_CUBIC , EASE_IN_SINE ,   EASE_OUT_SINE , EASE_IN_OUT_SINE }
enum class	EOrder {   RGB =0012 , RBG =0021 , GRB =0102 , GBR =0120 ,   BRG =0201 , BGR =0210 }
	RGB color channel orderings, used when instantiating controllers to determine what order the controller should send data out in. More...
enum class	EOrderW {   W3 = 0x3 , W2 = 0x2 , W1 = 0x1 , W0 = 0x0 ,   WDefault = W3 }
enum class	EOrderWW : fl::u8 {   WwWcEnd = 0x34 , WcWwEnd = 0x43 , WwWcStart = 0x01 , WcWwStart = 0x10 ,   WWDefault = WwWcEnd }
	White-byte ordering for 5-channel RGBWW output. More...
enum class	FiveBitGammaCorrectionMode { kFiveBitGammaCorrectionMode_Null = 0 , kFiveBitGammaCorrectionMode_BitShift = 1 }
enum class	fmtflags { dec = 0 , hex = 1 , oct = 2 }
enum	HSVHue {   HUE_RED = 0 , HUE_ORANGE = 32 , HUE_YELLOW = 64 , HUE_GREEN = 96 ,   HUE_AQUA = 128 , HUE_BLUE = 160 , HUE_PURPLE = 192 , HUE_PINK = 224 }
	Pre-defined hue values for hsv8 objects. More...
enum class	InputGamut : u8 {   Native = 0 , Rec709 , Rec2020 , DciP3D65 ,   DciP3D60 }
enum class	LaplacianStencil : u8 { FivePoint = 0 , NinePointIsotropic = 1 }
enum class	LogCategory : fl::u8 {   PARLIO_ISR = 0 , PARLIO_MAIN = 1 , RMT_ISR = 2 , RMT_MAIN = 3 ,   SPI_ISR = 4 , SPI_MAIN = 5 , AUDIO_ISR = 6 , AUDIO_MAIN = 7 ,   INTERRUPT_ISR = 8 , INTERRUPT_MAIN = 9 , MAX_CATEGORIES = 10 }
	Logger category identifiers for registry-based access Each category has separate ISR and main thread loggers (SPSC requirement) More...
enum class	LogLevel : u8 {   FL_LOG_LEVEL_NONE = 0 , FL_LOG_LEVEL_ERROR = 1 , FL_LOG_LEVEL_WARN = 2 , FL_LOG_LEVEL_INFO = 3 ,   FL_LOG_LEVEL_DEBUG = 4 }
	Log level constants - higher values include more output Prefixed with FL_ to avoid macro collisions (e.g. More...
enum	memory_order {   memory_order_relaxed , memory_order_acquire , memory_order_release , memory_order_acq_rel ,   memory_order_seq_cst }
enum class	PinMode { Input = 0 , Output , InputPullup , InputPulldown }
	Pin mode configuration. More...
enum class	PinValue { Low = 0 , High = 1 }
	Digital pin value. More...
enum class	PixelFormat { RGB565 , RGB888 , RGBA8888 , YUV420 }
enum class	RampPhase { Inactive , Rising , Plateau , Falling }
enum class	RemoteClearFlags : u8 {   None = 0 , Results = 1 << 0 , Scheduled = 1 << 1 , Functions = 1 << 2 ,   All = Results | Scheduled | Functions }
	Flags for clearing Remote state (can be OR'd together) More...
enum class	ResetCause : fl::u8 {   UNKNOWN = 0 , POWER_ON , BROWNOUT , EXTERNAL_PIN ,   WATCHDOG , SOFTWARE , LOCKUP , DEBUGGER ,   PANIC }
	Cause of the previous boot. Call once early in setup(). More...
enum class	ResultError : u8 {   OK , UNKNOWN , INVALID_ARGUMENT , OUT_OF_RANGE ,   NOT_INITIALIZED , ALREADY_INITIALIZED , ALLOCATION_FAILED , TIMEOUT ,   BUSY , NOT_SUPPORTED , IO_ERROR }
	Generic error codes for expected type. More...
enum class	RGBW_MODE {   kRGBWInvalid , kRGBWNullWhitePixel , kRGBWExactColors , kRGBWBoostedWhite ,   kRGBWMaxBrightness , kRGBWColorimetric , kRGBWColorimetricBoosted , kRGBWUserFunction }
enum class	RgbwLutInterp : u8 { Bilinear = 0 , Hermite = 1 }
enum class	RGBWW_MODE : fl::u8 { kRGBWWInvalid , kRGBWWColorimetric , kRGBWWColorimetricBoosted , kRGBWWUserFunction }
	RGB -> RGBWW conversion modes (issue #2558, Phase 3 of #2545). More...
enum class	RpcMode { SYNC , ASYNC , ASYNC_STREAM }
enum class	RxBackend : u8 {   PLATFORM_DEFAULT = 0 , RMT = 1 , ISR = 2 , FLEXPWM = 3 ,   FLEXIO = 4 , LPC_SCT_CAPTURE = 5 }
enum class	RxDeviceType : u8 {   PLATFORM_DEFAULT = 0 , ISR = 1 , RMT = 2 , FLEXPWM = 3 ,   FLEXIO = 4 , LPC_SCT_CAPTURE = 5 }
	RX device type enumeration. More...
enum class	RxWaitResult : u8 { SUCCESS = 0 , TIMEOUT = 1 , BUFFER_OVERFLOW = 2 }
	Result codes for RX wait() operations. More...
enum class	SampleMode { SAMPLE_NEAREST , SAMPLE_BILINEAR }
	Interpolation mode for sampling a 2D grid. More...
enum class	seek_dir { beg = 0 , cur = 1 , end = 2 }
enum class	Sign { SIGNED , UNSIGNED }
enum class	spi_output_mode_t : u8 { SPI_AUTO = 0 , SPI_HW , SPI_BITBANG , SPI_ISR }
	SPI output mode for multi-lane devices. More...
enum class	SpiChipset {   LPD6803 , LPD8806 , WS2801 , WS2803 ,   SM16716 , P9813 , APA102 , SK9822 ,   SK9822HD , DOTSTAR , DOTSTARHD , APA102HD ,   HD107 , HD107HD , HD108 }
	LED chipsets with SPI interface (clocked protocols) Modern type-safe enum class - prefer this for new code. More...
enum class	SpiParallelMode : u8 { AUTO = 0 , ISR_ASYNC , BITBANG_BLOCKING }
	Parallel device execution modes. More...
enum class	SuperSample { SUPER_SAMPLE_NONE = 1 , SUPER_SAMPLE_2X = 2 , SUPER_SAMPLE_4X = 4 , SUPER_SAMPLE_8X = 8 }
enum	TGradientDirectionCode { FORWARD_HUES , BACKWARD_HUES , SHORTEST_HUES , LONGEST_HUES }
	Hue direction for calculating fill gradients. More...
enum class	U8EasingFunction { WAVE_U8_MODE_LINEAR , WAVE_U8_MODE_SQRT }
enum class	UCS7604Mode { UCS7604_MODE_8BIT_800KHZ = 0x03 , UCS7604_MODE_16BIT_800KHZ = 0x8B , UCS7604_MODE_16BIT_1600KHZ = 0x9B }
	UCS7604 protocol configuration modes. More...

Functions
FL_OPTIMIZE_FUNCTION constexpr u32	_isqrt32_start (u32 x, u32 bit) FL_NOEXCEPT
FL_OPTIMIZE_FUNCTION constexpr u16	_isqrt32_step (u32 x, u32 result, u32 bit) FL_NOEXCEPT
FL_OPTIMIZE_FUNCTION constexpr u64	_isqrt64_start (u64 x, u64 bit) FL_NOEXCEPT
FL_OPTIMIZE_FUNCTION constexpr u32	_isqrt64_step (u64 x, u64 result, u64 bit) FL_NOEXCEPT
int	abs (int x)
template<typename T>
constexpr T	abs (T value) FL_NOEXCEPT
template<typename T>
constexpr enable_if< is_fixed_point< T >::value, T >::type	abs (T x) FL_NOEXCEPT
double	acos (double value) FL_NOEXCEPT
template<typename T>
enable_if< is_integral< T >::value, float >::type	acos (T value) FL_NOEXCEPT
template<typename T>
enable_if< is_fixed_point< T >::value, T >::type	acos (T x) FL_NOEXCEPT
double	acos_impl_double (double value)
float	acos_impl_float (float value)
float	acosf (float value) FL_NOEXCEPT
float	add (float &a, float &b)
FASTLED_FORCE_INLINE fl::i32	add_fp (fl::i32 a, fl::i32 b)
void *	aligned_alloc (fl::size_t alignment, fl::size_t size)
void	aligned_free (void *ptr)
template<typename T, typename A, typename... Args>
shared_ptr< T >	allocate_shared (const A &alloc, Args &&... args)
bool	almost_equal (double a, double b) FL_NOEXCEPT
bool	almost_equal (float a, float b) FL_NOEXCEPT
template<typename T, typename U>
constexpr bool	almost_equal (T a, T b, U tolerance) FL_NOEXCEPT
u16	analogRead (int pin)
	Read analog value from pin.
void	analogWrite (int pin, u16 val)
	Write analog value to pin (PWM)
void	analogWrite16 (int pin, u16 val)
	Alias for setPwm16 - Set PWM duty cycle with 16-bit resolution.
static void	append_u64_decimal (fl::string &out, fl::u64 value) FL_NOEXCEPT
CRGB	applyGamma_video (const CRGB &orig, float gamma)
CRGB	applyGamma_video (const CRGB &orig, float gammaR, float gammaG, float gammaB)
fl::u8	applyGamma_video (fl::u8 brightness, float gamma)
template<typename T, fl::size Extent>
span< const fl::u8,(Extent==dynamic_extent) ? dynamic_extent :(Extent *sizeof(T))>	as_bytes (const span< T, Extent > &s) FL_NOEXCEPT
template<typename T, fl::size Extent>
span< fl::u8,(Extent==dynamic_extent) ? dynamic_extent :(Extent *sizeof(T))>	as_writable_bytes (span< T, Extent > &s) FL_NOEXCEPT
double	asin (double value) FL_NOEXCEPT
template<typename T>
enable_if< is_integral< T >::value, float >::type	asin (T value) FL_NOEXCEPT
template<typename T>
enable_if< is_fixed_point< T >::value, T >::type	asin (T x) FL_NOEXCEPT
double	asin_impl_double (double value)
float	asin_impl_float (float value)
float	asinf (float value) FL_NOEXCEPT
constexpr asset_ref	asset (const char *path) FL_NOEXCEPT
	Construct an asset handle from a relative sketch path at runtime.
template<fl::size_t N, typename T>
const T *	assume_aligned (const T *ptr) FL_NOEXCEPT
template<fl::size_t N, typename T>
T *	assume_aligned (T *ptr) FL_NOEXCEPT
void	async_log_service ()
double	atan (double value) FL_NOEXCEPT
template<typename T>
enable_if< is_integral< T >::value, float >::type	atan (T value) FL_NOEXCEPT
template<typename T>
enable_if< is_fixed_point< T >::value, T >::type	atan (T x) FL_NOEXCEPT
double	atan2 (double y, double x) FL_NOEXCEPT
template<typename T>
enable_if< is_fixed_point< T >::value, T >::type	atan2 (T y, T x) FL_NOEXCEPT
template<typename T>
enable_if< is_integral< T >::value, float >::type	atan2 (T y, T x) FL_NOEXCEPT
double	atan2_impl_double (double y, double x)
float	atan2_impl_float (float y, float x)
float	atan2f (float y, float x) FL_NOEXCEPT
double	atan_impl_double (double value)
float	atan_impl_float (float value)
float	atanf (float value) FL_NOEXCEPT
int	atoi (const char *str)
long	atol (const char *str)
int	available ()
template<typename Container>
back_insert_iterator< Container >	back_inserter (Container &c) FL_NOEXCEPT
	Helper function to create a back_insert_iterator.
fl::vector< fl::u8 >	base64_decode (const fl::string &encoded)
fl::string	base64_encode (fl::span< const fl::u8 > data)
LIB8STATIC u16	beat16 (accum88 beats_per_minute, u32 timebase=0) FL_NOEXCEPT
	Generates a 16-bit "sawtooth" wave at a given BPM.
LIB8STATIC u8	beat8 (accum88 beats_per_minute, u32 timebase=0) FL_NOEXCEPT
	Generates an 8-bit "sawtooth" wave at a given BPM.
LIB8STATIC u16	beat88 (accum88 beats_per_minute_88, u32 timebase=0) FL_NOEXCEPT
	Generates a 16-bit "sawtooth" wave at a given BPM, with BPM specified in Q8.8 fixed-point format.
LIB8STATIC u16	beatsin16 (accum88 beats_per_minute, u16 lowest=0, u16 highest=65535, u32 timebase=0, u16 phase_offset=0) FL_NOEXCEPT
	Generates a 16-bit sine wave at a given BPM that oscillates within a given range.
LIB8STATIC u8	beatsin8 (accum88 beats_per_minute, u8 lowest=0, u8 highest=255, u32 timebase=0, u8 phase_offset=0) FL_NOEXCEPT
	Generates an 8-bit sine wave at a given BPM that oscillates within a given range.
LIB8STATIC u16	beatsin88 (accum88 beats_per_minute_88, u16 lowest=0, u16 highest=65535, u32 timebase=0, u16 phase_offset=0) FL_NOEXCEPT
	Generates a 16-bit sine wave at a given BPM that oscillates within a given range.
template<typename Container>
constexpr auto	begin (const Container &c) -> decltype(c.begin())
template<typename Container>
constexpr auto	begin (Container &c) -> decltype(c.begin())
template<typename T, fl::size N>
constexpr T *	begin (T(&array)[N]) FL_NOEXCEPT
u8	bilinearInterpolate (u8 v00, u8 v10, u8 v01, u8 v11, u16 dx, u16 dy)
u8	bilinearInterpolatePowerOf2 (u8 v00, u8 v10, u8 v01, u8 v11, u8 dx, u8 dy)
template<typename To, typename From>
To	bit_cast (const From &from) FL_NOEXCEPT
template<typename To>
const To *	bit_cast_ptr (const void *storage) FL_NOEXCEPT
template<typename To>
To *	bit_cast_ptr (void *storage) FL_NOEXCEPT
CHSV	blend (const CHSV &p1, const CHSV &p2, fract8 amountOfP2, TGradientDirectionCode directionCode)
CHSV *	blend (const CHSV *src1, const CHSV *src2, CHSV *dest, fl::u16 count, fract8 amountOfsrc2, TGradientDirectionCode directionCode)
CRGB	blend (const CRGB &p1, const CRGB &p2, fract8 amountOfP2)
CRGB *	blend (const CRGB *src1, const CRGB *src2, CRGB *dest, fl::u16 count, fract8 amountOfsrc2)
void	blur1d (CRGB *leds, u16 numLeds, fract8 blur_amount) FL_NOEXCEPT
void	blur1d (fl::span< CRGB > leds, fract8 blur_amount) FL_NOEXCEPT
void	blur2d (CRGB *leds, u8 width, u8 height, fract8 blur_amount, const XYMap &xymap) FL_NOEXCEPT
void	blur2d (fl::span< CRGB > leds, u8 width, u8 height, fract8 blur_amount, const XYMap &xymap) FL_NOEXCEPT
void	blur2d (gfx::Canvas< CRGB > &canvas, alpha8 blur_amount) FL_NOEXCEPT
void	blurColumns (CRGB *leds, u8 width, u8 height, fract8 blur_amount, const XYMap &xymap) FL_NOEXCEPT
void	blurColumns (fl::span< CRGB > leds, u8 width, u8 height, fract8 blur_amount, const XYMap &xymap) FL_NOEXCEPT
void	blurColumns (gfx::Canvas< CRGB > &canvas, alpha8 blur_amount) FL_NOEXCEPT
FL_DISABLE_WARNING_POP void	blurRows (CRGB *leds, u8 width, u8 height, fract8 blur_amount, const XYMap &xymap) FL_NOEXCEPT
void	blurRows (fl::span< CRGB > leds, u8 width, u8 height, fract8 blur_amount, const XYMap &xymap) FL_NOEXCEPT
void	blurRows (gfx::Canvas< CRGB > &canvas, alpha8 blur_amount) FL_NOEXCEPT
LIB8STATIC u16	bseconds16 () FL_NOEXCEPT
	Returns the current time-since-boot in "binary seconds", which are actually 1024/1000 of a second long.
template<typename OutputIterator>
void	buildUCS7604Preamble (OutputIterator out, UCS7604Mode mode, u8 r_current, u8 g_current, u8 b_current, u8 w_current)
	Build UCS7604 preamble (15 bytes)
FL_OPTIMIZE_FUNCTION Wave3BitExpansionLut	buildWave3ExpansionLUT (const ChipsetTiming &timing)
	Build a Wave3BitExpansionLut from chipset timing data.
Wave8ByteExpansionLut	buildWave8ByteExpansionLUT (const Wave8BitExpansionLut &nibble)
	Build a byte-indexed expansion LUT (#2526) from the nibble LUT.
FL_OPTIMIZE_FUNCTION Wave8BitExpansionLut	buildWave8ExpansionLUT (const ChipsetTiming &timing)
	Build a Wave8BitExpansionLut from chipset timing data.
template<fl::Bus B>
void	busKeepAlive () FL_NOEXCEPT
const char *	busName (Bus b) FL_NOEXCEPT
	Canonical driver-name string for a Bus value.
void	calculate_oscillators (oscillators &timings, modulators &move, fl::u32 current_time, float speed_factor)
FASTLED_FORCE_INLINE u32	calculate_transpose_buffer_size (u16 num_leds, u8 bytes_per_led) FL_NOEXCEPT
	Calculate output buffer size needed for transposed data.
constexpr fl::u16	calculateCorkscrewHeight (float totalTurns, fl::u16 numLeds)
constexpr fl::u16	calculateCorkscrewWidth (float totalTurns, fl::u16 numLeds)
void *	calloc (size_t nmemb, size_t size)
FL_OPTIMIZE_FUNCTION bool	canUseWave3 (const ChipsetTiming &timing)
	Check if a chipset timing is eligible for wave3 encoding.
double	ceil (double value) FL_NOEXCEPT
template<typename T>
enable_if< is_integral< T >::value, float >::type	ceil (T value) FL_NOEXCEPT
template<typename T>
enable_if< ceil_detail::has_static_ceil< T >::value, decltype(T::ceil(declval< T >()))>::type	ceil (T value) FL_NOEXCEPT
template<typename T>
constexpr enable_if< is_fixed_point< T >::value, T >::type	ceil (T x) FL_NOEXCEPT
constexpr int	ceil_constexpr (float value) FL_NOEXCEPT
double	ceil_impl_double (double value)
float	ceil_impl_float (float value)
float	ceilf (float value) FL_NOEXCEPT
ChannelManager &	channelManager () FL_NOEXCEPT
	Get the global ChannelManager singleton instance.
static int	charToDigit (char c)
istream_real &	cin_real ()
template<typename T>
FL_DISABLE_WARNING_POP FASTLED_FORCE_INLINE T	clamp (T value, T lo, T hi) FL_NOEXCEPT
template<typename T>
constexpr enable_if< is_fixed_point< T >::value, T >::type	clamp (T x, T lo, T hi) FL_NOEXCEPT
template<typename Container>
void	clear (Container &container)
template<int N>
void	clear (CRGB(&arr)[N])
template<typename T>
void	clear (Grid< T > &grid)
void	clear (Leds &leds)
template<fl::size W, fl::size H>
void	clear (LedsXY< W, H > &leds)
void	clear_errno ()
void	clearerr (FILE *file)
	Clear file error indicators.
u16	cled_contoller_size () FL_NOEXCEPT
	Get the size of the CLEDController object for introspection.
float	colorburn (float &a, float &b)
FASTLED_FORCE_INLINE fl::i32	colorburn_fp (fl::i32 a, fl::i32 b)
float	colordodge (float &a, float &b)
FASTLED_FORCE_INLINE fl::i32	colordodge_fp (fl::i32 a, fl::i32 b)
CHSV	ColorFromPalette (const CHSVPalette16 &pal, fl::u8 index, fl::u8 brightness, TBlendType blendType)
CHSV	ColorFromPalette (const CHSVPalette256 &pal, fl::u8 index, fl::u8 brightness, TBlendType)
CHSV	ColorFromPalette (const CHSVPalette32 &pal, fl::u8 index, fl::u8 brightness, TBlendType blendType)
CRGB	ColorFromPalette (const CRGBPalette16 &pal, fl::u8 index, fl::u8 brightness, TBlendType blendType)
CRGB	ColorFromPalette (const CRGBPalette256 &pal, fl::u8 index, fl::u8 brightness, TBlendType)
CRGB	ColorFromPalette (const CRGBPalette32 &pal, fl::u8 index, fl::u8 brightness, TBlendType blendType)
CRGB	ColorFromPalette (const TProgmemRGBPalette16 &pal, fl::u8 index, fl::u8 brightness, TBlendType blendType)
CRGB	ColorFromPalette (const TProgmemRGBPalette32 &pal, fl::u8 index, fl::u8 brightness, TBlendType blendType)
CRGB	ColorFromPaletteExtended (const CRGBPalette16 &pal, fl::u16 index, fl::u8 brightness, TBlendType blendType)
CRGB	ColorFromPaletteExtended (const CRGBPalette256 &pal, fl::u16 index, fl::u8 brightness, TBlendType blendType)
CRGB	ColorFromPaletteExtended (const CRGBPalette32 &pal, fl::u16 index, fl::u8 brightness, TBlendType blendType)
CRGB	ColorFromPaletteExtended (const TProgmemRGBPalette16 &pal, fl::u16 index, fl::u8 brightness, TBlendType blendType)
CRGB	ColorFromPaletteExtended (const TProgmemRGBPalette32 &pal, fl::u16 index, fl::u8 brightness, TBlendType blendType)
CRGB16	ColorFromPaletteHD (const CRGBPalette16 &pal, fl::u16 index, fl::u8x8 brightness, TBlendType blendType)
CRGB16	ColorFromPaletteHD (const CRGBPalette256 &pal, fl::u16 index, fl::u8x8 brightness, TBlendType blendType)
CRGB16	ColorFromPaletteHD (const CRGBPalette32 &pal, fl::u16 index, fl::u8x8 brightness, TBlendType blendType)
CRGB16	ColorFromPaletteHD (const TProgmemRGBPalette16 &pal, fl::u16 index, fl::u8x8 brightness, TBlendType blendType)
CRGB16	ColorFromPaletteHD (const TProgmemRGBPalette32 &pal, fl::u16 index, fl::u8x8 brightness, TBlendType blendType)
void	configureAsyncLogService (u32 interval_ms=16, fl::size messages_per_tick=5) FL_NOEXCEPT
	Configure async logger automatic servicing task.
template<typename T, typename Y>
shared_ptr< T >	const_pointer_cast (const shared_ptr< Y > &other) FL_NOEXCEPT
void	convert_fastled_timings_to_timedeltas (u16 t1_in, u16 t2_in, u16 t3_in, u16 *out_t0h, u16 *out_t0l, u16 *out_t1h, u16 *out_t1l) FL_NOEXCEPT
double	cos (double value) FL_NOEXCEPT
template<typename T>
enable_if< is_fixed_point< T >::value, T >::type	cos (T angle) FL_NOEXCEPT
template<typename T>
enable_if< is_integral< T >::value, float >::type	cos (T value) FL_NOEXCEPT
FASTLED_FORCE_INLINE i16	cos16lut (u16 angle) FL_NOEXCEPT
FASTLED_FORCE_INLINE i32	cos32 (u32 angle) FL_NOEXCEPT
double	cos_impl_double (double value)
float	cos_impl_float (float value)
float	cosf (float value) FL_NOEXCEPT
fl::shared_ptr< IFastLED >	createFastLEDController (u8 controllerIndex=0)
	Create a FastLED controller adapter.
fl::function< fl::optional< fl::json >()>	createSerialRequestSource (const char *prefix="")
	Create a JSON-RPC RequestSource that reads from fl:: serial input.
fl::function< void(const fl::json &)>	createSerialResponseSink (const char *prefix="REMOTE: ")
	Create a JSON-RPC ResponseSink that writes to fl:: serial output.
fl::pair< fl::function< fl::optional< fl::json >()>, fl::function< void(const fl::json &)> >	createSerialTransport (const char *responsePrefix="REMOTE: ", const char *requestPrefix="")
	Create RequestSource and ResponseSink pair for serial I/O.
template<typename T>
add_rvalue_reference< T >::type	declval () FL_NOEXCEPT
constexpr int	default_bus_priority (Bus b) FL_NOEXCEPT
	Default priority assigned to a Bus when registered with the manager.
memory_resource *	default_memory_resource () FL_NOEXCEPT
	Get the default memory resource (wraps fl::Malloc / fl::Free / fl::realloc).
math::random &	default_random () FL_NOEXCEPT
	Global default random number generator instance.
template<typename T>
constexpr T	degrees (T rad) FL_NOEXCEPT
template<int Dummy = 0>
void	delay (u32 ms, bool run_async=true) FL_NOEXCEPT
	Public delay wrapper that keeps bare Arduino delay() preferred after using fl::delay; while still allowing explicit fl::delay() calls.
template<cycle_t CYCLES>
void	delaycycles () FL_NOEXCEPT
	Forward declaration of delaycycles template.
template<>
FASTLED_FORCE_INLINE void	delaycycles< 0 > () FL_NOEXCEPT
template<>
void	delaycycles< 1 > () FL_NOEXCEPT
template<>
void	delaycycles< 10 > () FL_NOEXCEPT
template<>
void	delaycycles< 11 > () FL_NOEXCEPT
template<>
void	delaycycles< 12 > () FL_NOEXCEPT
template<>
void	delaycycles< 13 > () FL_NOEXCEPT
template<>
void	delaycycles< 14 > () FL_NOEXCEPT
template<>
void	delaycycles< 15 > () FL_NOEXCEPT
template<>
void	delaycycles< 16 > () FL_NOEXCEPT
template<>
void	delaycycles< 17 > () FL_NOEXCEPT
template<>
void	delaycycles< 18 > () FL_NOEXCEPT
template<>
void	delaycycles< 19 > () FL_NOEXCEPT
template<>
void	delaycycles< 2 > () FL_NOEXCEPT
template<>
void	delaycycles< 20 > () FL_NOEXCEPT
template<>
void	delaycycles< 21 > () FL_NOEXCEPT
template<>
void	delaycycles< 22 > () FL_NOEXCEPT
template<>
void	delaycycles< 23 > () FL_NOEXCEPT
template<>
void	delaycycles< 24 > () FL_NOEXCEPT
template<>
void	delaycycles< 25 > () FL_NOEXCEPT
template<>
void	delaycycles< 26 > () FL_NOEXCEPT
template<>
void	delaycycles< 27 > () FL_NOEXCEPT
template<>
void	delaycycles< 28 > () FL_NOEXCEPT
template<>
void	delaycycles< 29 > () FL_NOEXCEPT
template<>
void	delaycycles< 3 > () FL_NOEXCEPT
template<>
void	delaycycles< 30 > () FL_NOEXCEPT
template<>
void	delaycycles< 31 > () FL_NOEXCEPT
template<>
void	delaycycles< 32 > () FL_NOEXCEPT
template<>
void	delaycycles< 33 > () FL_NOEXCEPT
template<>
void	delaycycles< 34 > () FL_NOEXCEPT
template<>
void	delaycycles< 35 > () FL_NOEXCEPT
template<>
void	delaycycles< 36 > () FL_NOEXCEPT
template<>
void	delaycycles< 37 > () FL_NOEXCEPT
template<>
void	delaycycles< 38 > () FL_NOEXCEPT
template<>
void	delaycycles< 39 > () FL_NOEXCEPT
template<>
void	delaycycles< 4 > () FL_NOEXCEPT
template<>
void	delaycycles< 40 > () FL_NOEXCEPT
template<>
void	delaycycles< 41 > () FL_NOEXCEPT
template<>
void	delaycycles< 42 > () FL_NOEXCEPT
template<>
void	delaycycles< 43 > () FL_NOEXCEPT
template<>
void	delaycycles< 44 > () FL_NOEXCEPT
template<>
void	delaycycles< 45 > () FL_NOEXCEPT
template<>
void	delaycycles< 46 > () FL_NOEXCEPT
template<>
void	delaycycles< 47 > () FL_NOEXCEPT
template<>
void	delaycycles< 48 > () FL_NOEXCEPT
template<>
void	delaycycles< 49 > () FL_NOEXCEPT
template<>
void	delaycycles< 5 > () FL_NOEXCEPT
template<>
void	delaycycles< 50 > () FL_NOEXCEPT
template<>
void	delaycycles< 6 > () FL_NOEXCEPT
template<>
void	delaycycles< 7 > () FL_NOEXCEPT
template<>
void	delaycycles< 8 > () FL_NOEXCEPT
template<>
void	delaycycles< 9 > () FL_NOEXCEPT
template<>
FASTLED_FORCE_INLINE void	delaycycles<-1 > () FL_NOEXCEPT
template<>
FASTLED_FORCE_INLINE void	delaycycles<-10 > () FL_NOEXCEPT
template<>
FASTLED_FORCE_INLINE void	delaycycles<-2 > () FL_NOEXCEPT
template<>
FASTLED_FORCE_INLINE void	delaycycles<-3 > () FL_NOEXCEPT
template<>
FASTLED_FORCE_INLINE void	delaycycles<-4 > () FL_NOEXCEPT
template<>
FASTLED_FORCE_INLINE void	delaycycles<-5 > () FL_NOEXCEPT
template<>
FASTLED_FORCE_INLINE void	delaycycles<-6 > () FL_NOEXCEPT
template<>
FASTLED_FORCE_INLINE void	delaycycles<-7 > () FL_NOEXCEPT
template<>
FASTLED_FORCE_INLINE void	delaycycles<-8 > () FL_NOEXCEPT
template<>
FASTLED_FORCE_INLINE void	delaycycles<-9 > () FL_NOEXCEPT
template<cycle_t CYCLES>
void	delaycycles_min1 () FL_NOEXCEPT
	A variant of delaycycles that will always delay at least one cycle.
void	delayMicroseconds (u32 us) FL_NOEXCEPT
	Delay for a given number of microseconds.
void	delayMillis (u32 ms) FL_NOEXCEPT
	Delay for a given number of milliseconds (legacy - no async pumping)
void	delayMs (u32 ms, bool run_async=true) FL_NOEXCEPT
	Shorter alias for delay with optional async task pumping.
template<fl::u32 NS>
FASTLED_FORCE_INLINE void	delayNanoseconds () FL_NOEXCEPT
	Delay for a compile-time constant number of nanoseconds.
void	delayNanoseconds (fl::u32 ns) FL_NOEXCEPT
	Delay for a runtime number of nanoseconds.
void	delayNanoseconds (fl::u32 ns, fl::u32 hz) FL_NOEXCEPT
	Delay for a runtime number of nanoseconds with explicit clock frequency.
template<u32 NS>
void	delayNs () FL_NOEXCEPT
	Shorter alias for delayNanoseconds (template version)
void	delayNs (u32 ns) FL_NOEXCEPT
	Shorter alias for delayNanoseconds (runtime version)
void	delayNs (u32 ns, u32 hz) FL_NOEXCEPT
	Shorter alias for delayNanoseconds with explicit clock frequency.
void	delayUs (u32 us) FL_NOEXCEPT
	Shorter alias for delayMicroseconds.
void	digitalMultiWrite16 (const Pins16 &pins, fl::span< const u16 > pin_data)
	Convenience free function — creates a temporary DigitalMultiWrite16, initializes it, and writes.
void	digitalMultiWrite8 (const Pins8 &pins, fl::span< const u8 > pin_data)
	Convenience free function — creates a temporary DigitalMultiWrite8, initializes it, and writes.
PinValue	digitalRead (int pin)
	Read digital value from pin.
void	digitalWrite (int pin, PinValue val)
	Write digital value to pin.
void	disable_rgbw_colorimetric_lut () FL_NOEXCEPT
LIB8STATIC u16	div1024_32_16 (u32 in32) FL_NOEXCEPT
	Helper routine to divide a 32-bit value by 1024, returning only the low 16 bits.
void	downscale (const CRGB *src, const XYMap &srcXY, CRGB *dst, const XYMap &dstXY)
void	downscaleArbitrary (const CRGB *src, const XYMap &srcXY, CRGB *dst, const XYMap &dstXY)
void	downscaleHalf (const CRGB *src, const XYMap &srcXY, CRGB *dst, const XYMap &dstXY)
void	downscaleHalf (const CRGB *src, fl::u16 srcWidth, fl::u16 srcHeight, CRGB *dst)
void	drawSquare (void *, uint16_t, uint16_t, int, int, uint32_t, uint32_t)
void	ease16 (EaseType type, u16 *src, u16 *dst, u16 count) FL_NOEXCEPT
u16	ease16 (EaseType type, u16 i) FL_NOEXCEPT
void	ease8 (EaseType type, u8 *src, u8 *dst, u8 count) FL_NOEXCEPT
u8	ease8 (EaseType type, u8 i) FL_NOEXCEPT
u16	easeInCubic16 (u16 i) FL_NOEXCEPT
	16-bit cubic ease-in function Takes an input value 0-65535 and returns an eased value 0-65535
u8	easeInCubic8 (u8 i) FL_NOEXCEPT
	8-bit cubic ease-in function Takes an input value 0-255 and returns an eased value 0-255 More pronounced acceleration than quadratic
u16	easeInOutCubic16 (u16 i) FL_NOEXCEPT
	16-bit cubic ease-in/ease-out function Takes an input value 0-65535 and returns an eased value 0-65535
u8	easeInOutCubic8 (u8 i) FL_NOEXCEPT
	8-bit cubic ease-in/ease-out function Takes an input value 0-255 and returns an eased value 0-255 More pronounced easing curve than quadratic
u16	easeInOutQuad16 (u16 i) FL_NOEXCEPT
	16-bit quadratic ease-in/ease-out function Takes an input value 0-65535 and returns an eased value 0-65535
u8	easeInOutQuad8 (u8 i) FL_NOEXCEPT
	8-bit quadratic ease-in/ease-out function Takes an input value 0-255 and returns an eased value 0-255 The curve starts slow, accelerates in the middle, then slows down again
u16	easeInOutSine16 (u16 i) FL_NOEXCEPT
	16-bit sine ease-in/ease-out function Takes an input value 0-65535 and returns an eased value 0-65535
u8	easeInOutSine8 (u8 i) FL_NOEXCEPT
	8-bit sine ease-in/ease-out function Takes an input value 0-255 and returns an eased value 0-255 Smooth sinusoidal acceleration and deceleration
u16	easeInQuad16 (u16 i) FL_NOEXCEPT
	16-bit quadratic ease-in function Takes an input value 0-65535 and returns an eased value 0-65535
u8	easeInQuad8 (u8 i) FL_NOEXCEPT
	8-bit quadratic ease-in function Takes an input value 0-255 and returns an eased value 0-255 The curve starts slow and accelerates (ease-in only)
u16	easeInSine16 (u16 i) FL_NOEXCEPT
	16-bit sine ease-in function Takes an input value 0-65535 and returns an eased value 0-65535
u8	easeInSine8 (u8 i) FL_NOEXCEPT
	8-bit sine ease-in function Takes an input value 0-255 and returns an eased value 0-255 Smooth sinusoidal acceleration
u16	easeOutCubic16 (u16 i) FL_NOEXCEPT
	16-bit cubic ease-out function Takes an input value 0-65535 and returns an eased value 0-65535
u8	easeOutCubic8 (u8 i) FL_NOEXCEPT
	8-bit cubic ease-out function Takes an input value 0-255 and returns an eased value 0-255 More pronounced deceleration than quadratic
u16	easeOutQuad16 (u16 i) FL_NOEXCEPT
	16-bit quadratic ease-out function Takes an input value 0-65535 and returns an eased value 0-65535
u8	easeOutQuad8 (u8 i) FL_NOEXCEPT
	8-bit quadratic ease-out function Takes an input value 0-255 and returns an eased value 0-255 The curve starts fast and decelerates (ease-out only)
u16	easeOutSine16 (u16 i) FL_NOEXCEPT
	16-bit sine ease-out function Takes an input value 0-65535 and returns an eased value 0-65535
u8	easeOutSine8 (u8 i) FL_NOEXCEPT
	8-bit sine ease-out function Takes an input value 0-255 and returns an eased value 0-255 Smooth sinusoidal deceleration
bool	enable_rgbw_colorimetric_lut (int) FL_NOEXCEPT
bool	enable_rgbw_colorimetric_lut (int, RgbwLutInterp) FL_NOEXCEPT
void	enableAllDrivers () FL_NOEXCEPT
	Register every channel driver available on this platform with ChannelManager, restoring 3.10.3-style runtime driver selection.
template<Bus... Buses>
void	enableDrivers () FL_NOEXCEPT
	Register the named drivers with ChannelManager for runtime selection.
template<typename InputIterator, typename OutputIterator>
void	encodeAPA102 (InputIterator first, InputIterator last, OutputIterator out, u8 global_brightness=31) FL_NOEXCEPT
	Encode pixel data in APA102 format with global brightness.
template<typename InputIterator, typename OutputIterator>
FL_NO_INLINE_IF_AVR FL_OPTIMIZE_O2 void	encodeAPA102_AutoBrightness (InputIterator first, InputIterator last, OutputIterator out) FL_NOEXCEPT
	Encode pixel data in APA102 format (auto-detected brightness from first pixel)
template<typename InputIterator, typename BrightnessIterator, typename OutputIterator>
void	encodeAPA102_HD (InputIterator first, InputIterator last, BrightnessIterator brightness_first, OutputIterator out) FL_NOEXCEPT
	Encode pixel data in APA102 format with per-LED brightness.
template<typename InputIterator, typename OutputIterator>
void	encodeHD108 (InputIterator first, InputIterator last, OutputIterator out, u8 global_brightness=255) FL_NOEXCEPT
	Encode pixel data in HD108 format with global brightness.
template<typename InputIterator, typename BrightnessIterator, typename OutputIterator>
void	encodeHD108_HD (InputIterator first, InputIterator last, BrightnessIterator brightness_first, OutputIterator out) FL_NOEXCEPT
	Encode pixel data in HD108 format with per-LED brightness.
template<typename InputIterator, typename OutputIterator>
void	encodeLPD6803 (InputIterator first, InputIterator last, OutputIterator out) FL_NOEXCEPT
	Encode pixel data in LPD6803 format.
template<typename InputIterator, typename OutputIterator>
void	encodeLPD8806 (InputIterator first, InputIterator last, OutputIterator out) FL_NOEXCEPT
	Encode pixel data in LPD8806 format.
template<typename InputIterator, typename OutputIterator>
void	encodeP9813 (InputIterator first, InputIterator last, OutputIterator out) FL_NOEXCEPT
	Encode pixel data in P9813 format.
template<typename TIMING>
constexpr ClocklessEncoder	encoder_for () FL_NOEXCEPT
	Extract the encoder selector from a compile-time TIMING type.
template<typename InputIterator, typename OutputIterator>
void	encodeSK9822 (InputIterator first, InputIterator last, OutputIterator out, u8 global_brightness=31) FL_NOEXCEPT
	Encode pixel data in SK9822 format with global brightness.
template<typename InputIterator, typename OutputIterator>
FL_NO_INLINE_IF_AVR void	encodeSK9822_AutoBrightness (InputIterator first, InputIterator last, OutputIterator out) FL_NOEXCEPT
	Encode pixel data in SK9822 format (auto-detected brightness from first pixel)
template<typename InputIterator, typename BrightnessIterator, typename OutputIterator>
void	encodeSK9822_HD (InputIterator first, InputIterator last, BrightnessIterator brightness_first, OutputIterator out) FL_NOEXCEPT
	Encode pixel data in SK9822 format with per-LED brightness.
template<typename InputIterator, typename OutputIterator>
void	encodeSM16716 (InputIterator first, InputIterator last, OutputIterator out) FL_NOEXCEPT
	Encode pixel data in SM16716 format.
template<typename OutputIterator>
void	encodeUCS7604 (PixelIterator &pixel_iter, size_t num_leds, OutputIterator out, UCS7604Mode mode, const UCS7604CurrentControl &current, bool is_rgbw, const Gamma8 *gamma=nullptr)
	Encode complete UCS7604 frame (preamble + padding + pixel data)
template<typename InputIterator, typename OutputIterator>
void	encodeUCS7604_16bit_RGB (InputIterator first, InputIterator last, OutputIterator out, const Gamma8 &gamma)
	Encode RGB pixels in UCS7604 16-bit format with gamma correction.
template<typename InputIterator, typename OutputIterator>
void	encodeUCS7604_16bit_RGBW (InputIterator first, InputIterator last, OutputIterator out, const Gamma8 &gamma)
	Encode RGBW pixels in UCS7604 16-bit format with gamma correction.
template<typename InputIterator, typename OutputIterator>
void	encodeUCS7604_8bit_RGB (InputIterator first, InputIterator last, OutputIterator out)
	Encode RGB pixels in UCS7604 8-bit format.
template<typename InputIterator, typename OutputIterator>
void	encodeUCS7604_8bit_RGBW (InputIterator first, InputIterator last, OutputIterator out)
	Encode RGBW pixels in UCS7604 8-bit format.
template<typename InputIterator, typename OutputIterator>
void	encodeWS2801 (InputIterator first, InputIterator last, OutputIterator out) FL_NOEXCEPT
	Encode pixel data in WS2801/WS2803 format.
template<typename InputIterator, typename OutputIterator>
void	encodeWS2803 (InputIterator first, InputIterator last, OutputIterator out) FL_NOEXCEPT
	Encode pixel data in WS2803 format (alias for WS2801)
template<typename InputIterator, typename OutputIterator>
void	encodeWS2812 (InputIterator first, InputIterator last, OutputIterator out, const Rgbw &rgbw) FL_NOEXCEPT
	Encode pixel data in WS2812 format (automatic RGB/RGBW selection)
template<typename InputIterator, typename OutputIterator>
void	encodeWS2812_RGB (InputIterator first, InputIterator last, OutputIterator out) FL_NOEXCEPT
	Encode 3-byte pixel data in WS2812 format.
template<typename InputIterator, typename OutputIterator>
void	encodeWS2812_RGBW (InputIterator first, InputIterator last, OutputIterator out) FL_NOEXCEPT
	Encode 4-byte pixel data in WS2812 format.
template<typename InputIterator, typename OutputIterator>
void	encodeWS2812_RGBWW (InputIterator first, InputIterator last, OutputIterator out) FL_NOEXCEPT
	Encode 5-byte pixel data in WS2812 format (issue #2558, RGBWW).
template<typename InputIterator, typename OutputIterator>
void	encodeWS2816 (InputIterator first, InputIterator last, OutputIterator out)
	Encode 16-bit RGB pixel data into dual 8-bit RGB format for WS2816.
template<typename Container>
constexpr auto	end (const Container &c) -> decltype(c.end())
template<typename Container>
constexpr auto	end (Container &c) -> decltype(c.end())
template<typename T, fl::size N>
constexpr T *	end (T(&array)[N]) FL_NOEXCEPT
template<typename Iterator1, typename Iterator2>
bool	equal (Iterator1 first1, Iterator1 last1, Iterator2 first2) FL_NOEXCEPT
template<typename Iterator1, typename Iterator2, typename BinaryPredicate>
bool	equal (Iterator1 first1, Iterator1 last1, Iterator2 first2, BinaryPredicate pred) FL_NOEXCEPT
template<typename Iterator1, typename Iterator2>
bool	equal (Iterator1 first1, Iterator1 last1, Iterator2 first2, Iterator2 last2) FL_NOEXCEPT
template<typename Iterator1, typename Iterator2, typename BinaryPredicate>
bool	equal (Iterator1 first1, Iterator1 last1, Iterator2 first2, Iterator2 last2, BinaryPredicate pred) FL_NOEXCEPT
template<typename Container1, typename Container2>
bool	equal_container (const Container1 &c1, const Container2 &c2) FL_NOEXCEPT
template<typename Container1, typename Container2, typename BinaryPredicate>
bool	equal_container (const Container1 &c1, const Container2 &c2, BinaryPredicate pred) FL_NOEXCEPT
void	exit (int code)
	No-op exit function for embedded systems In embedded environments, calling exit is typically not meaningful, so this is a placeholder that does nothing.
double	exp (double value) FL_NOEXCEPT
template<typename T>
enable_if< is_integral< T >::value, float >::type	exp (T value) FL_NOEXCEPT
template<typename T>
enable_if< is_fixed_point< T >::value, T >::type	exp (T x) FL_NOEXCEPT
double	exp_impl_double (double value)
float	exp_impl_float (float value)
float	expf (float value) FL_NOEXCEPT
template<typename T>
enable_if< is_fixed_point< T >::value, T >::type	expfp (T x) FL_NOEXCEPT
fl::vector< fl::u8 >	extractH264NalUnits (fl::span< const fl::u8 > data, const Mp4TrackInfo &track, fl::string *error)
double	fabs (double value) FL_NOEXCEPT
template<typename T>
enable_if< is_integral< T >::value, float >::type	fabs (T value) FL_NOEXCEPT
double	fabs_impl_double (double value)
float	fabs_impl_float (float value)
float	fabsf (float value) FL_NOEXCEPT
FASTLED_FORCE_INLINE float	fade (float t)
void	fade_raw (CRGB *leds, fl::u16 num_leds, fl::u8 fadeBy)
void	fade_video (CRGB *leds, fl::u16 num_leds, fl::u8 fadeBy)
void	fadeLightBy (CRGB *leds, fl::u16 num_leds, fl::u8 fadeBy)
void	fadeToBlackBy (CRGB *leds, fl::u16 num_leds, fl::u8 fadeBy)
void	fadeToColorBy (void *, uint16_t, uint32_t, uint8_t)
void	fadeUsingColor (CRGB *leds, fl::u16 numLeds, const CRGB &colormask)
static u32	fast_hash32 (u32 x) FL_NOEXCEPT
static u32	fast_hash64 (u64 x) FL_NOEXCEPT
float	fast_logf_approx (float x) FL_NOEXCEPT
	FASTLED_DEPRECATED ("Use blur2d(..., const XYMap& xymap) instead") FL_NOEXCEPT inline void blur2d(CRGB *leds
const char *	fastled_file_offset (const char *file)
	FASTLED_SHARED_PTR (Animartrix)
	FASTLED_SHARED_PTR (ArchimedeanSpiralPath)
	FASTLED_SHARED_PTR (Blend2d)
	FASTLED_SHARED_PTR (CatmullRomParams)
	FASTLED_SHARED_PTR (CatmullRomPath)
	FASTLED_SHARED_PTR (Channel)
	FASTLED_SHARED_PTR (ChannelData)
	FASTLED_SHARED_PTR (CirclePath)
	FASTLED_SHARED_PTR (Cylon)
	FASTLED_SHARED_PTR (DemoReel100)
	FASTLED_SHARED_PTR (DigitalPinImpl)
	FASTLED_SHARED_PTR (FileSystem)
	FASTLED_SHARED_PTR (Fire2012)
	Simple one-dimensional fire animation function.
	FASTLED_SHARED_PTR (FlowField)
	FASTLED_SHARED_PTR (FlowFieldFloat)
	FASTLED_SHARED_PTR (FlowFieldFP)
	FASTLED_SHARED_PTR (Frame)
	FASTLED_SHARED_PTR (FsImpl)
	FASTLED_SHARED_PTR (Fx)
	FASTLED_SHARED_PTR (Fx2d)
	FASTLED_SHARED_PTR (Fx2dTo1d)
	FASTLED_SHARED_PTR (FxLayer)
	FASTLED_SHARED_PTR (GielisCurvePath)
	FASTLED_SHARED_PTR (HeartPath)
	FASTLED_SHARED_PTR (IDecoder)
	FASTLED_SHARED_PTR (LinePath)
	FASTLED_SHARED_PTR (LinePathParams)
	FASTLED_SHARED_PTR (Luminova)
	FASTLED_SHARED_PTR (Mp3Decoder)
	FASTLED_SHARED_PTR (NoisePalette)
	FASTLED_SHARED_PTR (NoiseWave)
	FASTLED_SHARED_PTR (Pacifica)
	FASTLED_SHARED_PTR (Particles1d)
	FASTLED_SHARED_PTR (PerlinParticlePunch)
	FASTLED_SHARED_PTR (PhyllotaxisPath)
	FASTLED_SHARED_PTR (PointPath)
	FASTLED_SHARED_PTR (Pride2015)
	FASTLED_SHARED_PTR (RedSquare)
	FASTLED_SHARED_PTR (RosePath)
	FASTLED_SHARED_PTR (RosePathParams)
	FASTLED_SHARED_PTR (RxChannel)
	FASTLED_SHARED_PTR (ScaleUp)
	FASTLED_SHARED_PTR (TimeFunction)
	FASTLED_SHARED_PTR (TimeWarp)
	FASTLED_SHARED_PTR (TransformFloatImpl)
	FASTLED_SHARED_PTR (TwinkleFox)
	FASTLED_SHARED_PTR (VideoFxWrapper)
	FASTLED_SHARED_PTR (VorbisDecoder)
	FASTLED_SHARED_PTR (WaveCrgbGradientMap)
	FASTLED_SHARED_PTR (WaveCrgbMap)
	FASTLED_SHARED_PTR (WaveCrgbMapDefault)
	FASTLED_SHARED_PTR (WaveFx)
	FASTLED_SHARED_PTR (XYPath)
	FASTLED_SHARED_PTR (XYPathFunction)
	FASTLED_SHARED_PTR (XYPathGenerator)
	FASTLED_SHARED_PTR (XYPathRenderer)
	FASTLED_SHARED_PTR_NO_FWD (LUT16)
	FASTLED_SHARED_PTR_NO_FWD (LUTXY16)
	FASTLED_SHARED_PTR_NO_FWD (LUTXYFLOAT)
	FASTLED_SHARED_PTR_NO_FWD (LUTXYZFLOAT)
	FASTLED_SHARED_PTR_NO_FWD (memorybuf)
	FASTLED_SHARED_PTR_STRUCT (ChannelConfig)
int	fclose (FILE *file)
	Close a file.
int	feof (FILE *file)
	Check for end-of-file.
int	ferror (FILE *file)
	Check for file error.
int	fflush (FILE *file)
	Flush file buffers.
template<typename Iterator, typename T>
void	fill (Iterator first, Iterator last, const T &value) FL_NOEXCEPT
template<typename T>
void	fill_gradient (T *targetArray, u16 numLeds, const CHSV &c1, const CHSV &c2, const CHSV &c3, const CHSV &c4, TGradientDirectionCode directionCode=SHORTEST_HUES) FL_NOEXCEPT
	Fill a range of LEDs with a smooth HSV gradient between four HSV colors.
template<typename T>
void	fill_gradient (T *targetArray, u16 numLeds, const CHSV &c1, const CHSV &c2, const CHSV &c3, TGradientDirectionCode directionCode=SHORTEST_HUES) FL_NOEXCEPT
	Fill a range of LEDs with a smooth HSV gradient between three HSV colors.
template<typename T>
void	fill_gradient (T *targetArray, u16 numLeds, const CHSV &c1, const CHSV &c2, TGradientDirectionCode directionCode=SHORTEST_HUES) FL_NOEXCEPT
	Fill a range of LEDs with a smooth HSV gradient between two HSV colors.
template<typename T>
void	fill_gradient (T *targetArray, u16 startpos, CHSV startcolor, u16 endpos, CHSV endcolor, TGradientDirectionCode directionCode=SHORTEST_HUES) FL_NOEXCEPT
	Fill a range of LEDs with a smooth HSV gradient between two HSV colors.
void	fill_gradient_RGB (CRGB *leds, u16 numLeds, const CRGB &c1, const CRGB &c2) FL_NOEXCEPT
	Fill a range of LEDs with a smooth RGB gradient between two RGB colors.
void	fill_gradient_RGB (CRGB *leds, u16 numLeds, const CRGB &c1, const CRGB &c2, const CRGB &c3) FL_NOEXCEPT
	Fill a range of LEDs with a smooth RGB gradient between three RGB colors.
void	fill_gradient_RGB (CRGB *leds, u16 numLeds, const CRGB &c1, const CRGB &c2, const CRGB &c3, const CRGB &c4) FL_NOEXCEPT
	Fill a range of LEDs with a smooth RGB gradient between four RGB colors.
void	fill_gradient_RGB (CRGB *leds, u16 startpos, CRGB startcolor, u16 endpos, CRGB endcolor) FL_NOEXCEPT
	Fill a range of LEDs with a smooth RGB gradient between two RGB colors.
void	fill_gradient_RGB (fl::span< CRGB > leds, const CRGB &c1, const CRGB &c2) FL_NOEXCEPT
	Fill a range of LEDs with a smooth RGB gradient between two RGB colors.
void	fill_gradient_RGB (fl::span< CRGB > leds, const CRGB &c1, const CRGB &c2, const CRGB &c3) FL_NOEXCEPT
	Fill a range of LEDs with a smooth RGB gradient between two RGB colors.
void	fill_gradient_RGB (fl::span< CRGB > leds, const CRGB &c1, const CRGB &c2, const CRGB &c3, const CRGB &c4) FL_NOEXCEPT
	Fill a range of LEDs with a smooth RGB gradient between two RGB colors.
void	fill_rainbow (CHSV *targetArray, int numToFill, fl::u8 initialhue, fl::u8 deltahue=5) FL_NOEXCEPT
	Fill a range of LEDs with a rainbow of colors.
void	fill_rainbow (CRGB *targetArray, int numToFill, fl::u8 initialhue, fl::u8 deltahue=5) FL_NOEXCEPT
	Fill a range of LEDs with a rainbow of colors.
void	fill_rainbow (fl::span< CRGB > leds, fl::u8 initialhue, fl::u8 deltahue=5) FL_NOEXCEPT
	Fill a range of LEDs with a rainbow of colors.
void	fill_rainbow_circular (CHSV *targetArray, int numToFill, fl::u8 initialhue, bool reversed=false) FL_NOEXCEPT
	Fill a range of LEDs with a rainbow of colors, so that the hues are continuous between the end of the strip and the beginning.
void	fill_rainbow_circular (CRGB *targetArray, int numToFill, fl::u8 initialhue, bool reversed=false) FL_NOEXCEPT
	Fill a range of LEDs with a rainbow of colors, so that the hues are continuous between the end of the strip and the beginning.
void	fill_rainbow_circular (fl::span< CRGB > leds, fl::u8 initialhue, bool reversed=false) FL_NOEXCEPT
	Fill a range of LEDs with a rainbow of colors, so that the hues are continuous between the end of the strip and the beginning.
void	fill_solid (CHSV *targetArray, int numToFill, const CHSV &color) FL_NOEXCEPT
	Fill a range of LEDs with a solid color.
void	fill_solid (CRGB *targetArray, int numToFill, const CRGB &color) FL_NOEXCEPT
	Fill a range of LEDs with a solid color.
void	fill_solid (fl::span< CRGB > leds, const CRGB &color) FL_NOEXCEPT
	Fill a range of LEDs with a solid color.
template<typename Iterator, typename T>
Iterator	find (Iterator first, Iterator last, const T &value) FL_NOEXCEPT
template<typename Iterator, typename UnaryPredicate>
Iterator	find_if (Iterator first, Iterator last, UnaryPredicate pred) FL_NOEXCEPT
template<typename Iterator, typename UnaryPredicate>
Iterator	find_if_not (Iterator first, Iterator last, UnaryPredicate pred) FL_NOEXCEPT
FL_OPTIMIZE_FUNCTION void	five_bit_hd_gamma_bitshift (fl::span< const CRGB > colors, CRGB colors_scale, u8 global_brightness, fl::span< CRGB > out_colors, fl::span< u8 > out_power_5bit)
FL_OPTIMIZE_FUNCTION void	five_bit_hd_gamma_bitshift (fl::span< const CRGB > colors, CRGB colors_scale, u8 global_brightness, fl::span< CRGBA5 > out)
template<typename... Types>
class	FL_ALIGN_AS_T (max_align< Types... >::value) variant
	FL_ALIGN_PROGMEM (64) const u16 GAMMA_2_8_LUT[256]
struct	FL_ALIGNAS (16) SinCos32_simd
	Combined sin+cos result for 4 angles (raw SIMD primitives)
struct	FL_ALIGNAS (4) Wave3BitExpansionLut
	Lookup table for nibble-to-waveform expansion in wave3 format (32 bytes)
	FL_ALIGNAS (64) static const fl
struct	FL_ALIGNAS (8) Wave8Byte
	Container for 8 packed wave symbols (8 bytes total)
template<typename T, fl::size N>
struct	FL_ALIGNAS (alignof(T) > alignof(fl::uptr) ? alignof(T) :alignof(fl::uptr)) InlinedMemoryBlock
FL_DISABLE_WARNING_PUSH	FL_DISABLE_WARNING (cast-align) void FL_OPTIMIZE_FUNCTION FL_IRAM transpose8x1_noinline(unsigned char *A
FL_DISABLE_WARNING_PUSH	FL_DISABLE_WARNING (float-equal) FL_DISABLE_WARNING(double-promotion) FL_DISABLE_WARNING_FLOAT_CONVERSION FL_DISABLE_WARNING_SIGN_CONVERSION FL_DISABLE_WARNING_IMPLICIT_INT_CONVERSION FL_DISABLE_WARNING_FLOAT_CONVERSION namespace map_range_detail
FL_DISABLE_WARNING_PUSH	FL_DISABLE_WARNING (sign-compare) FL_DISABLE_WARNING_FLOAT_CONVERSION FL_DISABLE_WARNING_SIGN_CONVERSION FL_DISABLE_WARNING_IMPLICIT_INT_CONVERSION template< typename T
	FL_STATIC_ASSERT (static_cast< fl::u8 >(Bus::STUB)==14, "Bus changed: add the new value to busName() in this file")
static bool	float_bits_magnitude_exceeds_2_24 (u32 bits) FL_NOEXCEPT
double	floor (double value) FL_NOEXCEPT
template<typename T>
enable_if< is_integral< T >::value, float >::type	floor (T value) FL_NOEXCEPT
template<typename T>
enable_if< floor_detail::has_static_floor< T >::value, decltype(T::floor(declval< T >()))>::type	floor (T value) FL_NOEXCEPT
template<typename T>
constexpr enable_if< is_fixed_point< T >::value, T >::type	floor (T x) FL_NOEXCEPT
double	floor_impl_double (double value)
float	floor_impl_float (float value)
float	floorf (float value) FL_NOEXCEPT
bool	flush (u32 timeoutMs)
template<typename T>
enable_if<!is_integral< T >::value, T >::type	fmod (T x, T y) FL_NOEXCEPT
template<typename T>
enable_if< is_integral< T >::value, float >::type	fmod (T x, T y) FL_NOEXCEPT
template<>
double	fmod< double > (double x, double y) FL_NOEXCEPT
double	fmod_impl_double (double x, double y)
float	fmod_impl_float (float x, float y)
float	fmodf (float x, float y) FL_NOEXCEPT
FILE *	fopen (const char *path, const char *mode)
	Open a file.
fl::string	format (const char *fmt)
	Format with no arguments.
template<typename... Args>
fl::string	format (const char *fmt, const Args &... args)
	Format with variadic arguments.
fl::string	formatJsonResponse (const fl::json &response, const char *prefix="")
	Serialize JSON response to a string.
template<typename T>
constexpr T &&	forward (typename remove_reference< T >::type &&t) FL_NOEXCEPT
template<typename T>
constexpr T &&	forward (typename remove_reference< T >::type &t) FL_NOEXCEPT
template<typename T>
constexpr enable_if< is_fixed_point< T >::value, T >::type	fract (T x) FL_NOEXCEPT
fl::size_t	fread (void *buffer, fl::size_t size, fl::size_t count, FILE *file)
	Read from file.
void	Free (void *ptr)
void	free (void *ptr)
int	fseek (FILE *file, long offset, int origin)
	Set file position.
long	ftell (FILE *file)
	Get current file position.
void	ftoa (float value, char *buffer, int precision=2) FL_NOEXCEPT
	Convert floating point number to string buffer.
fl::size_t	fwrite (const void *data, fl::size_t size, fl::size_t count, FILE *file)
	Write to file.
template<typename Fixed>
constexpr u32	gamma (float g) FL_NOEXCEPT
u16	gamma_2_8 (u8 value)
template<fl::size I, typename T1, typename T2>
const pair_element< I, T1, T2 >::type &	get (const pair< T1, T2 > &p) FL_NOEXCEPT
template<typename T, typename T1, typename T2>
const T &	get (const pair< T1, T2 > &p) FL_NOEXCEPT
template<size_t I, typename Head, typename... Tail>
enable_if< I==0, constHead & >::type	get (const tuple< Head, Tail... > &t) FL_NOEXCEPT
template<size_t I, typename Head, typename... Tail>
enable_if< I!=0, consttypenametuple_element< I, tuple< Head, Tail... > >::type & >::type	get (const tuple< Head, Tail... > &t) FL_NOEXCEPT
template<fl::size I, typename T1, typename T2>
pair_element< I, T1, T2 >::type &&	get (pair< T1, T2 > &&p) FL_NOEXCEPT
template<typename T, typename T1, typename T2>
T &&	get (pair< T1, T2 > &&p) FL_NOEXCEPT
template<fl::size I, typename T1, typename T2>
pair_element< I, T1, T2 >::type &	get (pair< T1, T2 > &p) FL_NOEXCEPT
template<typename T, typename T1, typename T2>
T &	get (pair< T1, T2 > &p) FL_NOEXCEPT
template<size_t I, typename Head, typename... Tail>
enable_if< I==0, Head && >::type	get (tuple< Head, Tail... > &&t) FL_NOEXCEPT
template<size_t I, typename Head, typename... Tail>
enable_if< I!=0, typenametuple_element< I, tuple< Head, Tail... > >::type && >::type	get (tuple< Head, Tail... > &&t) FL_NOEXCEPT
template<size_t I, typename Head, typename... Tail>
enable_if< I==0, Head & >::type	get (tuple< Head, Tail... > &t) FL_NOEXCEPT
template<size_t I, typename Head, typename... Tail>
enable_if< I!=0, typenametuple_element< I, tuple< Head, Tail... > >::type & >::type	get (tuple< Head, Tail... > &t) FL_NOEXCEPT
template<fl::size N, typename InfoProvider>
AsyncLogger &	get_async_logger_by_index ()
	Template-based logger accessor with auto-registration and enablement check.
AsyncLogger &	get_audio_async_logger_isr ()
AsyncLogger &	get_audio_async_logger_main ()
constexpr u32	get_bit_period_ns (const ChipsetTiming &timing) FL_NOEXCEPT
	Get total bit period (T1 + T2 + T3) in nanoseconds.
json_object &	get_empty_json_obj ()
int	get_errno ()
AsyncLogger &	get_flexio_async_logger_isr ()
AsyncLogger &	get_flexio_async_logger_main ()
AsyncLogger &	get_interrupt_async_logger_isr ()
AsyncLogger &	get_interrupt_async_logger_main ()
json_value &	get_null_json_value ()
AsyncLogger &	get_objectfled_async_logger_isr ()
AsyncLogger &	get_objectfled_async_logger_main ()
AsyncLogger &	get_parlio_async_logger_isr ()
AsyncLogger &	get_parlio_async_logger_main ()
void	get_ready (unsigned long &a, unsigned long &b)
const DiodeProfile *	get_rgbw_colorimetric_profile () FL_NOEXCEPT
const colorimetric_detail::RgbcctProfile *	get_rgbww_colorimetric_profile () FL_NOEXCEPT
AsyncLogger &	get_rmt_async_logger_isr ()
AsyncLogger &	get_rmt_async_logger_main ()
AsyncLogger &	get_spi_async_logger_isr ()
AsyncLogger &	get_spi_async_logger_main ()
const ChipsetTiming *	get_timing_by_name (const char *name) FL_NOEXCEPT
	Get timing by name (for dynamic lookup if needed)
constexpr u32	get_timing_t1 (const ChipsetTiming &timing) FL_NOEXCEPT
	Extract T1 (high time for bit 0) from timing constant.
constexpr u32	get_timing_t2 (const ChipsetTiming &timing) FL_NOEXCEPT
	Extract T2 (additional high time for bit 1) from timing constant.
constexpr u32	get_timing_t3 (const ChipsetTiming &timing) FL_NOEXCEPT
	Extract T3 (low tail duration) from timing constant.
int	getAnimartrixCount ()
AnimartrixAnimInfo	getAnimartrixInfo (int index)
fl::string	getAnimartrixName (int animation)
fl::u8	getBytesPerPixel (PixelFormat format)
int	getDataPinFromChipset (const ChipsetVariant &chipset)
const char *	getenv (const char *name)
HeapInfo	getFreeHeap ()
	Query available heap memory.
u8	getLogLevel () FL_NOEXCEPT
	Get the current global log level.
u32	getPwmFrequency (int pin)
	Query the configured PWM frequency for a pin.
IChannelDriver *	getStubChannelEngine ()
	Get stub channel driver for testing or unsupported platforms.
ChipsetTimingConfig	getTimingFromChipset (const ChipsetVariant &chipset)
static TraceStorage &	getTraceStorage () FL_NOEXCEPT
StringInterner &	global_interner ()
static fl::mutex &	global_interner_mutex ()
FASTLED_FORCE_INLINE float	grad (int hash, float x, float y, float z)
static u32	hash_pair (u32 a, u32 b, u32 seed=0) FL_NOEXCEPT
u32	hash_string_view (string_view sv) FL_NOEXCEPT
void	hd108BrightnessHeader (u8 brightness_8bit, u8 *f0_out, u8 *f1_out) FL_NOEXCEPT
	Generate HD108 per-channel gain header bytes.
u16	hd108GammaCorrect (u8 value) FL_NOEXCEPT
	Convert 8-bit color to HD108 16-bit gamma-corrected value (gamma 2.8)
CRGB	HeatColor (fl::u8 temperature)
LIB8STATIC u8	hours8 () FL_NOEXCEPT
	Return the current hours since boot in an 8-bit value.
static CRGB	HSV16toRGB (const HSV16 &hsv)
double	hypot (double x, double y) FL_NOEXCEPT
template<typename T>
enable_if< is_integral< T >::value, float >::type	hypot (T x, T y) FL_NOEXCEPT
double	hypot_impl_double (double x, double y)
float	hypot_impl_float (float x, float y)
float	hypotf (float x, float y) FL_NOEXCEPT
fl::string	ieee754_format_decimal (u32 bits, int precision=6) FL_NOEXCEPT
	Format IEEE 754 single-precision bits as decimal text.
u32	ieee754_parse_decimal (const char *s, fl::size len, fl::size *consumed=nullptr) FL_NOEXCEPT
	Parse a decimal floating-point number into IEEE 754 single-precision bits.
void	init (Context &ctx, int w, int h)
template<typename T>
T *	int_to_ptr (uptr value) FL_NOEXCEPT
fl::string	intern (const char *str)
fl::string	intern (const fl::span< const char > &sp)
fl::string	intern (const fl::string &str)
fl::string	intern (const string_view &sv)
void	interrupt_disable ()
	Disable global interrupts (platform-specific).
void	interrupt_enable ()
	Enable global interrupts (platform-specific).
template<typename F, typename... Args>
auto	invoke (F &&f, Args &&... args) FL_NOEXCEPT -> enable_if_t<!is_member_function_pointer< typename remove_reference< F >::type >::value &&!detail::is_member_data_pointer< typename remove_reference< F >::type >::value, decltype(fl::forward< F >(f)(fl::forward< Args >(args)...))>
template<typename F, typename T1>
auto	invoke (F &&f, T1 &&t1) FL_NOEXCEPT -> enable_if_t< detail::is_member_data_pointer< typename remove_reference< F >::type >::value &&!detail::use_pointer_syntax< T1 >::value, decltype(fl::forward< T1 >(t1).*f)>
template<typename F, typename T1, typename... Args>
auto	invoke (F &&f, T1 &&t1, Args &&... args) FL_NOEXCEPT -> enable_if_t< is_member_function_pointer< typename remove_reference< F >::type >::value &&!detail::use_pointer_syntax< T1 >::value, decltype((fl::forward< T1 >(t1).*f)(fl::forward< Args >(args)...))>
bool	isdigit (char c) FL_NOEXCEPT
	Check if character is a decimal digit (0-9)
static bool	isDigitInBase (char c, int base)
FL_OPTIMIZE_FUNCTION constexpr u16	isqrt32 (u32 x) FL_NOEXCEPT
FL_OPTIMIZE_FUNCTION constexpr u32	isqrt64 (u64 x) FL_NOEXCEPT
bool	isspace (char c) FL_NOEXCEPT
	Check if character is whitespace (space, tab, newline, carriage return)
int	itoa (i32 value, char *buffer, int radix) FL_NOEXCEPT
	Convert signed 32-bit integer to string buffer in given radix.
int	itoa64 (i64 value, char *buffer, int radix) FL_NOEXCEPT
	Convert signed 64-bit integer to string buffer in given radix.
fl::vector< float >	jsonArrayToFloatVector (const fl::json &jsonArray)
double	ldexp (double value, int exp) FL_NOEXCEPT
template<typename T>
enable_if< is_integral< T >::value, float >::type	ldexp (T value, int exp) FL_NOEXCEPT
double	ldexp_impl_double (double value, int exp)
float	ldexp_impl_float (float value, int exp)
float	ldexpf (float value, int exp) FL_NOEXCEPT
FASTLED_FORCE_INLINE float	lerp (float t, float a, float b)
template<typename T>
constexpr enable_if< is_fixed_point< T >::value, T >::type	lerp (T a, T b, T t) FL_NOEXCEPT
template<typename Iterator1, typename Iterator2>
bool	lexicographical_compare (Iterator1 first1, Iterator1 last1, Iterator2 first2, Iterator2 last2) FL_NOEXCEPT
template<typename Iterator1, typename Iterator2, typename Compare>
bool	lexicographical_compare (Iterator1 first1, Iterator1 last1, Iterator2 first2, Iterator2 last2, Compare comp) FL_NOEXCEPT
FramePtr	loadJpegFromSD (int cs_pin, const char *filepath, const JpegConfig &config=JpegConfig(), fl::string *error_message=nullptr)
double	log (double value) FL_NOEXCEPT
template<typename T>
enable_if< is_integral< T >::value, float >::type	log (T value) FL_NOEXCEPT
double	log10 (double value) FL_NOEXCEPT
template<typename T>
enable_if< is_integral< T >::value, float >::type	log10 (T value) FL_NOEXCEPT
double	log10_impl_double (double value)
float	log10_impl_float (float value)
float	log10f (float value) FL_NOEXCEPT
double	log2 (double value) FL_NOEXCEPT
template<typename T>
enable_if< is_integral< T >::value, float >::type	log2 (T value) FL_NOEXCEPT
float	log2f (float value) FL_NOEXCEPT
double	log_impl_double (double value)
float	log_impl_float (float value)
float	logf (float value) FL_NOEXCEPT
void	logFrame (unsigned long &c)
void	logOutput (unsigned long &b)
template<typename Iterator, typename T>
Iterator	lower_bound (Iterator first, Iterator last, const T &value) FL_NOEXCEPT
template<typename Iterator, typename T, typename Compare>
Iterator	lower_bound (Iterator first, Iterator last, const T &value, Compare comp) FL_NOEXCEPT
u16	lpd6803EncodeRGB (u8 r, u8 g, u8 b) FL_NOEXCEPT
	Convert RGB to LPD6803 16-bit format (1bbbbbgggggrrrrr)
u8	lpd8806Encode (u8 value) FL_NOEXCEPT
	Apply LPD8806 encoding to a single color byte.
long	lround (double value) FL_NOEXCEPT
template<typename T>
enable_if< is_integral< T >::value, long >::type	lround (T value) FL_NOEXCEPT
long	lround_impl_double (double value)
long	lround_impl_float (float value)
long	lroundf (float value) FL_NOEXCEPT
fl::u8	lsrX4 (fl::u8 dividend)
	Helper function to divide a number by 16, aka four logical shift right (LSR)'s.
ChipsetTiming4Phase	make4PhaseTiming (const ChipsetTiming &timing_3phase, u32 tolerance_ns=150) FL_NOEXCEPT
	Create 4-phase RX timing from 3-phase chipset timing with tolerance.
template<typename T>
optional< T >	make_optional (const T &value) FL_NOEXCEPT
template<typename T>
optional< T >	make_optional (T &&value) FL_NOEXCEPT
template<typename T1, typename T2>
pair< typename fl::decay< T1 >::type, typename fl::decay< T2 >::type >	make_pair (T1 &&t, T2 &&u) FL_NOEXCEPT
template<typename EF>
scope_exit< decay_t< EF > >	make_scope_exit (EF &&f)
	Factory for C++11/14 (no CTAD).
FsImplPtr	make_sdcard_filesystem (int cs_pin)
template<typename T, typename... Args>
shared_ptr< T >	make_shared (Args &&... args)
template<typename T>
shared_ptr< T >	make_shared_array (size_t n)
template<typename T>
shared_ptr< T >	make_shared_no_tracking (T &obj) FL_NOEXCEPT
template<typename T, typename... Args>
fl::shared_ptr< T >	make_shared_ptr (Args &&... args) FL_NOEXCEPT
template<typename T, typename Deleter, typename... Args>
shared_ptr< T >	make_shared_with_deleter (Deleter d, Args &&... args)
template<typename... Ts>
tuple< typename fl::decay< Ts >::type... >	make_tuple (Ts &&... args) FL_NOEXCEPT
template<typename T, typename... Args>
fl::enable_if<!fl::is_array< T >::value, unique_ptr< T > >::type	make_unique (Args &&... args) FL_NOEXCEPT
template<typename T>
fl::enable_if< fl::is_array< T >::value, unique_ptr< T > >::type	make_unique (fl::size_t size) FL_NOEXCEPT
template<typename TIMING>
constexpr ClocklessChipset	makeClockless (int pin) FL_NOEXCEPT
	Build a ClocklessChipset from a compile-time TIMING trait.
pair< detail::ScaledPixelIteratorBrightness, detail::ScaledPixelIteratorBrightness >	makeScaledBrightnessRange (PixelIterator *pixels) FL_NOEXCEPT
	Create brightness input iterator range from PixelIterator.
pair< detail::ScaledPixelIteratorRGB, detail::ScaledPixelIteratorRGB >	makeScaledPixelRangeRGB (PixelIterator *pixels) FL_NOEXCEPT
	Create RGB input iterator range from PixelIterator.
pair< detail::ScaledPixelIteratorRGB16, detail::ScaledPixelIteratorRGB16 >	makeScaledPixelRangeRGB16 (PixelIterator *pixels) FL_NOEXCEPT
	Create 16-bit RGB input iterator range from PixelIterator.
pair< detail::ScaledPixelIteratorRGBW, detail::ScaledPixelIteratorRGBW >	makeScaledPixelRangeRGBW (PixelIterator *pixels) FL_NOEXCEPT
	Create RGBW input iterator range from PixelIterator.
pair< detail::ScaledPixelIteratorRGBWW, detail::ScaledPixelIteratorRGBWW >	makeScaledPixelRangeRGBWW (PixelIterator *pixels) FL_NOEXCEPT
	Create RGBWW input iterator range from PixelIterator (issue #2558)
template<typename CHIPSET>
constexpr ChipsetTimingConfig	makeTimingConfig () FL_NOEXCEPT
	Convert compile-time CHIPSET type to runtime timing config.
template<typename T>
static IAnimartrix2Viz *	makeViz ()
void *	Malloc (fl::size size)
void *	malloc (size_t size)
u32	map16_to_32 (u16 x) FL_NOEXCEPT
u8	map16_to_8 (u16 x) FL_NOEXCEPT
u16	map32_to_16 (u32 x) FL_NOEXCEPT
u8	map32_to_8 (u32 x) FL_NOEXCEPT
u16	map8_to_16 (u8 x) FL_NOEXCEPT
u32	map8_to_32 (u8 x) FL_NOEXCEPT
FASTLED_FORCE_INLINE float	map_float (float x, float in_min, float in_max, float out_min, float out_max)
template<typename T, typename U>
FASTLED_FORCE_INLINE U	map_range (T value, T in_min, T in_max, U out_min, U out_max) FL_NOEXCEPT
template<typename T, typename U>
FASTLED_FORCE_INLINE U	map_range_clamped (T value, T in_min, T in_max, U out_min, U out_max) FL_NOEXCEPT
u8	mapBrightness8to5 (u8 brightness_8bit) FL_NOEXCEPT
	Map 8-bit brightness to 5-bit (0-31)
template<typename T, typename U>
constexpr common_type_t< T, U >	max (T a, U b) FL_NOEXCEPT
template<typename Iterator>
Iterator	max_element (Iterator first, Iterator last) FL_NOEXCEPT
template<typename Iterator, typename Compare>
Iterator	max_element (Iterator first, Iterator last, Compare comp) FL_NOEXCEPT
const void *	memchr (const void *s, int c, size_t n) FL_NOEXCEPT
void *	memchr (void *s, int c, size_t n) FL_NOEXCEPT
int	memcmp (const void *s1, const void *s2, size_t n) FL_NOEXCEPT
void *	memcopy (void *dest, const void *src, size_t n) FL_NOEXCEPT
void *	memcpy (void *dest, const void *src, size_t n) FL_NOEXCEPT
void *	memmove (void *dest, const void *src, size_t n) FL_NOEXCEPT
void *	memset (void *s, int c, size_t n) FL_NOEXCEPT
fl::u32	micros () FL_NOEXCEPT
	Universal microsecond timer - returns microseconds since system startup.
fl::u32	millis () FL_NOEXCEPT
	Universal millisecond timer - returns milliseconds since system startup.
fl::u64	millis64 () FL_NOEXCEPT
	64-bit millisecond timer - returns milliseconds since system startup without wraparound
void	millis64_reset ()
FL_DISABLE_WARNING_PUSH U constexpr common_type_t< T, U >	min (T a, U b) FL_NOEXCEPT
template<typename Iterator>
Iterator	min_element (Iterator first, Iterator last) FL_NOEXCEPT
template<typename Iterator, typename Compare>
Iterator	min_element (Iterator first, Iterator last, Compare comp) FL_NOEXCEPT
LIB8STATIC u16	minutes16 () FL_NOEXCEPT
	Return the current minutes since boot in a 16-bit value.
template<typename T>
constexpr enable_if< is_fixed_point< T >::value, T >::type	mod (T a, T b) FL_NOEXCEPT
template<typename T>
constexpr remove_reference< T >::type &&	move (T &&t) FL_NOEXCEPT
float	multiply (float &a, float &b)
FASTLED_FORCE_INLINE fl::i32	multiply_fp (fl::i32 a, fl::i32 b)
static u32	MurmurHash3_x86_32 (const void *key, fl::size len, u32 seed=0)
CRGB &	napplyGamma_video (CRGB &rgb, float gamma)
CRGB &	napplyGamma_video (CRGB &rgb, float gammaR, float gammaG, float gammaB)
void	napplyGamma_video (CRGB *rgbarray, fl::u16 count, float gamma)
void	napplyGamma_video (CRGB *rgbarray, fl::u16 count, float gammaR, float gammaG, float gammaB)
CHSV &	nblend (CHSV &existing, const CHSV &overlay, fract8 amountOfOverlay, TGradientDirectionCode directionCode)
void	nblend (CHSV *existing, const CHSV *overlay, fl::u16 count, fract8 amountOfOverlay, TGradientDirectionCode directionCode)
CRGB &	nblend (CRGB &existing, const CRGB &overlay, fract8 amountOfOverlay)
void	nblend (CRGB *existing, const CRGB *overlay, fl::u16 count, fract8 amountOfOverlay)
void	nblendPaletteTowardPalette (CRGBPalette16 &current, CRGBPalette16 &target, fl::u8 maxChanges)
CRGB	noiseCylinderCRGB (float angle, float height, u32 time, float radius=1.0f)
	Generate CRGB noise for a cylinder pattern.
HSV16	noiseCylinderHSV16 (float angle, float height, u32 time, float radius)
	Cylinder noise functions - sample three z-slices for independent component evolution.
CHSV	noiseCylinderHSV8 (float angle, float height, u32 time, float radius=1.0f)
	Generate HSV8 (8-bit) noise for a cylinder pattern.
CRGB	noiseRingCRGB (float angle, u32 time, float radius=1.0f)
	Generate CRGB noise for a ring pattern.
HSV16	noiseRingHSV16 (float angle, u32 time, float radius)
	Ring noise functions - sample three z-slices for independent component evolution.
CHSV	noiseRingHSV8 (float angle, u32 time, float radius=1.0f)
	Generate HSV8 (8-bit) noise for a ring pattern.
CRGB	noiseSphereCRGB (float angle, float phi, u32 time, float radius=1.0f)
	Generate CRGB noise for a sphere pattern.
HSV16	noiseSphereHSV16 (float angle, float phi, u32 time, float radius)
	Sphere noise functions - sample three z-slices for independent component evolution.
CHSV	noiseSphereHSV8 (float angle, float phi, u32 time, float radius=1.0f)
	Generate HSV8 (8-bit) noise for a sphere pattern.
void	nscale8 (CRGB *leds, fl::u16 num_leds, fl::u8 scale)
void	nscale8_video (CRGB *leds, fl::u16 num_leds, fl::u8 scale)
bool	operator! (RemoteClearFlags flags)
template<typename T, fl::size N>
bool	operator!= (const array< T, N > &lhs, const array< T, N > &rhs) FL_NOEXCEPT
FASTLED_FORCE_INLINE bool	operator!= (const CRGB &lhs, const CRGB &rhs) FL_NOEXCEPT
	Check if two CRGB objects do not have the same color data.
template<typename Key, typename Value, typename Less>
bool	operator!= (const flat_map< Key, Value, Less > &lhs, const flat_map< Key, Value, Less > &rhs) FL_NOEXCEPT
template<typename Key, typename Less>
bool	operator!= (const flat_set< Key, Less > &lhs, const flat_set< Key, Less > &rhs)
template<typename T1, typename T2, typename U1, typename U2>
bool	operator!= (const pair< T1, T2 > &lhs, const pair< U1, U2 > &rhs) FL_NOEXCEPT
template<typename T, typename Container>
bool	operator!= (const queue< T, Container > &lhs, const queue< T, Container > &rhs)
	Non-member inequality comparison for queues.
template<typename T, typename Y>
bool	operator!= (const shared_ptr< T > &lhs, const shared_ptr< Y > &rhs) FL_NOEXCEPT
template<typename T>
bool	operator!= (const shared_ptr< T > &lhs, fl::nullptr_t) FL_NOEXCEPT
template<typename T, typename Deleter>
bool	operator!= (const unique_ptr< T, Deleter > &ptr, fl::nullptr_t) FL_NOEXCEPT
template<typename T1, typename Deleter1, typename T2, typename Deleter2>
bool	operator!= (const unique_ptr< T1, Deleter1 > &lhs, const unique_ptr< T2, Deleter2 > &rhs) FL_NOEXCEPT
template<typename T>
bool	operator!= (fl::nullptr_t, const shared_ptr< T > &rhs) FL_NOEXCEPT
template<typename T, typename Deleter>
bool	operator!= (fl::nullptr_t, const unique_ptr< T, Deleter > &ptr) FL_NOEXCEPT
bool	operator!= (string_view lhs, string_view rhs) FL_NOEXCEPT
template<typename T, typename U>
constexpr bool	operator!= (T lhs, const not_null< U > &rhs) FL_NOEXCEPT
FASTLED_FORCE_INLINE CRGB	operator% (const CRGB &p1, u8 d) FL_NOEXCEPT
	Scale using CRGB::nscale8_video()
FASTLED_FORCE_INLINE CRGB	operator& (const CRGB &p1, const CRGB &p2) FL_NOEXCEPT
	Combine two CRGB objects, taking the smallest value of each channel.
RemoteClearFlags	operator& (RemoteClearFlags a, RemoteClearFlags b)
FASTLED_FORCE_INLINE CRGB	operator* (const CRGB &p1, u8 d) FL_NOEXCEPT
	Multiply each of the channels by a constant, saturating each channel at 0xFF.
template<class T, int F, int I>
static i16	operator* (i16 v, qfx< T, F, I > &q) FL_NOEXCEPT
template<class T, int F, int I>
static i32	operator* (i32 v, qfx< T, F, I > &q) FL_NOEXCEPT
constexpr FASTLED_FORCE_INLINE s16x16	operator* (s16x16 a, s0x32 b)
template<class T, int F, int I>
static u16	operator* (u16 v, qfx< T, F, I > &q) FL_NOEXCEPT
template<class T, int F, int I>
static u32	operator* (u32 v, qfx< T, F, I > &q) FL_NOEXCEPT
string	operator+ (const char *lhs, const string &rhs) FL_NOEXCEPT
template<typename T>
fl::enable_if<!fl::is_arithmetic< T >::value, string >::type	operator+ (const char *lhs, const T &rhs) FL_NOEXCEPT
FASTLED_FORCE_INLINE CRGB	operator+ (const CRGB &p1, const CRGB &p2) FL_NOEXCEPT
	Add one CRGB to another, saturating at 0xFF for each channel.
string	operator+ (const string &lhs, const char *rhs) FL_NOEXCEPT
string	operator+ (const string &lhs, const string &rhs) FL_NOEXCEPT
template<typename T>
string	operator+ (const string &lhs, const T &rhs) FL_NOEXCEPT
template<typename T>
fl::enable_if<!fl::is_arithmetic< T >::value, string >::type	operator+ (const T &lhs, const char *rhs) FL_NOEXCEPT
template<typename T>
string	operator+ (const T &lhs, const string &rhs) FL_NOEXCEPT
FASTLED_FORCE_INLINE CRGB	operator- (const CRGB &p1, const CRGB &p2) FL_NOEXCEPT
	Subtract one CRGB from another, saturating at 0x00 for each channel.
FASTLED_FORCE_INLINE CRGB	operator/ (const CRGB &p1, u8 d) FL_NOEXCEPT
	Divide each of the channels by a constant.
template<typename T, fl::size N>
bool	operator< (const array< T, N > &lhs, const array< T, N > &rhs) FL_NOEXCEPT
FASTLED_FORCE_INLINE bool	operator< (const CRGB &lhs, const CRGB &rhs) FL_NOEXCEPT
	Check if the sum of the color channels in one CRGB object is less than another.
template<typename Key, typename Value, typename Less>
bool	operator< (const flat_map< Key, Value, Less > &lhs, const flat_map< Key, Value, Less > &rhs) FL_NOEXCEPT
template<typename Key, typename Less>
bool	operator< (const flat_set< Key, Less > &lhs, const flat_set< Key, Less > &rhs)
template<typename T1, typename T2, typename U1, typename U2>
bool	operator< (const pair< T1, T2 > &lhs, const pair< U1, U2 > &rhs) FL_NOEXCEPT
template<typename T, typename Container>
bool	operator< (const queue< T, Container > &lhs, const queue< T, Container > &rhs)
	Non-member less-than comparison for queues.
template<typename T, typename Y>
bool	operator< (const shared_ptr< T > &lhs, const shared_ptr< Y > &rhs) FL_NOEXCEPT
bool	operator< (string_view lhs, string_view rhs) FL_NOEXCEPT
ostream &	operator<< (ostream &os, const dec_t &)
ostream &	operator<< (ostream &os, const endl_t &) FL_NOEXCEPT
ostream &	operator<< (ostream &os, const hex_t &)
ostream &	operator<< (ostream &os, const oct_t &)
sstream &	operator<< (sstream &ss, const dec_t &)
sstream &	operator<< (sstream &ss, const hex_t &)
sstream &	operator<< (sstream &ss, const oct_t &)
template<typename T, fl::size N>
bool	operator<= (const array< T, N > &lhs, const array< T, N > &rhs) FL_NOEXCEPT
FASTLED_FORCE_INLINE bool	operator<= (const CRGB &lhs, const CRGB &rhs) FL_NOEXCEPT
	Check if the sum of the color channels in one CRGB object is less than or equal to another.
template<typename Key, typename Value, typename Less>
bool	operator<= (const flat_map< Key, Value, Less > &lhs, const flat_map< Key, Value, Less > &rhs) FL_NOEXCEPT
template<typename Key, typename Less>
bool	operator<= (const flat_set< Key, Less > &lhs, const flat_set< Key, Less > &rhs)
template<typename T1, typename T2, typename U1, typename U2>
bool	operator<= (const pair< T1, T2 > &lhs, const pair< U1, U2 > &rhs) FL_NOEXCEPT
template<typename T, typename Container>
bool	operator<= (const queue< T, Container > &lhs, const queue< T, Container > &rhs)
	Non-member less-than-or-equal comparison for queues.
template<typename T, typename Y>
bool	operator<= (const shared_ptr< T > &lhs, const shared_ptr< Y > &rhs) FL_NOEXCEPT
bool	operator<= (string_view lhs, string_view rhs) FL_NOEXCEPT
template<typename T, fl::size N>
bool	operator== (const array< T, N > &lhs, const array< T, N > &rhs) FL_NOEXCEPT
FASTLED_FORCE_INLINE bool	operator== (const CRGB &lhs, const CRGB &rhs) FL_NOEXCEPT
	Check if two CRGB objects have the same color data.
template<typename Key, typename Value, typename Less>
bool	operator== (const flat_map< Key, Value, Less > &lhs, const flat_map< Key, Value, Less > &rhs) FL_NOEXCEPT
template<typename Key, typename Less>
bool	operator== (const flat_set< Key, Less > &lhs, const flat_set< Key, Less > &rhs)
template<typename T1, typename T2, typename U1, typename U2>
bool	operator== (const pair< T1, T2 > &lhs, const pair< U1, U2 > &rhs) FL_NOEXCEPT
template<typename T, typename Container>
bool	operator== (const queue< T, Container > &lhs, const queue< T, Container > &rhs)
	Non-member equality comparison for queues.
template<typename T, typename Y>
bool	operator== (const shared_ptr< T > &lhs, const shared_ptr< Y > &rhs) FL_NOEXCEPT
template<typename T>
bool	operator== (const shared_ptr< T > &lhs, fl::nullptr_t) FL_NOEXCEPT
template<typename T, typename Deleter>
bool	operator== (const unique_ptr< T, Deleter > &ptr, fl::nullptr_t) FL_NOEXCEPT
template<typename T1, typename Deleter1, typename T2, typename Deleter2>
bool	operator== (const unique_ptr< T1, Deleter1 > &lhs, const unique_ptr< T2, Deleter2 > &rhs) FL_NOEXCEPT
template<typename T>
bool	operator== (fl::nullptr_t, const shared_ptr< T > &rhs) FL_NOEXCEPT
template<typename T, typename Deleter>
bool	operator== (fl::nullptr_t, const unique_ptr< T, Deleter > &ptr) FL_NOEXCEPT
bool	operator== (string_view lhs, string_view rhs) FL_NOEXCEPT
template<typename T, typename U>
constexpr bool	operator== (T lhs, const not_null< U > &rhs) FL_NOEXCEPT
template<typename T, fl::size N>
bool	operator> (const array< T, N > &lhs, const array< T, N > &rhs) FL_NOEXCEPT
FASTLED_FORCE_INLINE bool	operator> (const CRGB &lhs, const CRGB &rhs) FL_NOEXCEPT
	Check if the sum of the color channels in one CRGB object is greater than another.
template<typename Key, typename Value, typename Less>
bool	operator> (const flat_map< Key, Value, Less > &lhs, const flat_map< Key, Value, Less > &rhs) FL_NOEXCEPT
template<typename Key, typename Less>
bool	operator> (const flat_set< Key, Less > &lhs, const flat_set< Key, Less > &rhs)
template<typename T1, typename T2, typename U1, typename U2>
bool	operator> (const pair< T1, T2 > &lhs, const pair< U1, U2 > &rhs) FL_NOEXCEPT
template<typename T, typename Container>
bool	operator> (const queue< T, Container > &lhs, const queue< T, Container > &rhs)
	Non-member greater-than comparison for queues.
template<typename T, typename Y>
bool	operator> (const shared_ptr< T > &lhs, const shared_ptr< Y > &rhs) FL_NOEXCEPT
bool	operator> (string_view lhs, string_view rhs) FL_NOEXCEPT
template<typename T, fl::size N>
bool	operator>= (const array< T, N > &lhs, const array< T, N > &rhs) FL_NOEXCEPT
FASTLED_FORCE_INLINE bool	operator>= (const CRGB &lhs, const CRGB &rhs) FL_NOEXCEPT
	Check if the sum of the color channels in one CRGB object is greater than or equal to another.
template<typename Key, typename Value, typename Less>
bool	operator>= (const flat_map< Key, Value, Less > &lhs, const flat_map< Key, Value, Less > &rhs) FL_NOEXCEPT
template<typename Key, typename Less>
bool	operator>= (const flat_set< Key, Less > &lhs, const flat_set< Key, Less > &rhs)
template<typename T1, typename T2, typename U1, typename U2>
bool	operator>= (const pair< T1, T2 > &lhs, const pair< U1, U2 > &rhs) FL_NOEXCEPT
template<typename T, typename Container>
bool	operator>= (const queue< T, Container > &lhs, const queue< T, Container > &rhs)
	Non-member greater-than-or-equal comparison for queues.
template<typename T, typename Y>
bool	operator>= (const shared_ptr< T > &lhs, const shared_ptr< Y > &rhs) FL_NOEXCEPT
bool	operator>= (string_view lhs, string_view rhs) FL_NOEXCEPT
FASTLED_FORCE_INLINE CRGB	operator| (const CRGB &p1, const CRGB &p2) FL_NOEXCEPT
	Combine two CRGB objects, taking the largest value of each channel.
RemoteClearFlags	operator| (RemoteClearFlags a, RemoteClearFlags b)
FASTLED_FORCE_INLINE fl::u8	P (fl::u8 x)
u8	p9813FlagByte (u8 r, u8 g, u8 b) FL_NOEXCEPT
	Generate P9813 flag byte from RGB components.
pair< CRGB, CRGB >	packWS2816Pixel (u16 s0, u16 s1, u16 s2)
	Pack a single 16-bit RGB pixel into two 8-bit CRGB pixels for WS2816.
url	parse_lnk (fl::string_view content) FL_NOEXCEPT
	Parse the contents of a .lnk file into a fl::url.
LnkMetadata	parse_lnk_with_metadata (fl::string_view content) FL_NOEXCEPT
	Parse a .lnk file into URL + metadata (forward-compat).
float	parseFloat (const char *str, fl::size len) FL_NOEXCEPT
	Parse a floating point number from a character buffer.
int	parseInt (const char *str) FL_NOEXCEPT
	Parse an integer from a null-terminated string.
int	parseInt (const char *str, fl::size len) FL_NOEXCEPT
	Parse an integer from a character buffer.
Mp4TrackInfo	parseMp4 (fl::span< const fl::u8 > data, fl::string *error)
static bool	parseV2SegmentArray (const fl::json &segmentsArr, fl::flat_map< string, ScreenMap > *segmentMaps, string *err) FL_NOEXCEPT
int	peek ()
void	pinMap (fl::span< PinInfo > pins)
	Resolve port IDs for an array of PinInfo in-place.
void	pinMode (int pin, PinMode mode)
	Set pin mode (input, output, pull-up, pull-down)
int	pinToPort (int pin)
	Map a runtime pin number to an integer port ID using FastPin<N>::port().
FASTLED_FORCE_INLINE float	pnoise (float x, float y, float z)
template<typename Iterator>
void	pop_heap (Iterator first, Iterator last)
template<typename Iterator, typename Compare>
void	pop_heap (Iterator first, Iterator last, Compare comp)
double	pow (double base, double exponent) FL_NOEXCEPT
template<typename T>
enable_if< is_fixed_point< T >::value, T >::type	pow (T base, T exp) FL_NOEXCEPT
template<typename T>
enable_if< is_integral< T >::value, float >::type	pow (T base, T exponent) FL_NOEXCEPT
double	pow_impl_double (double base, double exponent)
float	pow_impl_float (float base, float exponent)
float	powf (float base, float exponent) FL_NOEXCEPT
template<typename T>
enable_if< is_fixed_point< T >::value, T >::type	powfp (T base, T exp) FL_NOEXCEPT
void	print (const char *str)
template<typename... Args>
void	printf (const char *format, const Args &... args) FL_NOEXCEPT
	Printf-like formatting function that prints directly to the platform output.
void	println (const char *str) FL_NOEXCEPT
memory_resource *	psram_memory_resource () FL_NOEXCEPT
	Get the PSRAM memory resource (wraps PSRamAllocate / PSRamDeallocate).
void *	PSRamAllocate (fl::size size, bool zero)
void	PSRamDeallocate (void *ptr)
template<typename T>
uptr	ptr_to_int (T *ptr) FL_NOEXCEPT
template<typename Iterator>
void	push_heap (Iterator first, Iterator last)
template<typename Iterator, typename Compare>
void	push_heap (Iterator first, Iterator last, Compare comp)
int	pwmEnd (int pin)
	Release PWM channel and stop output on a pin.
void	qsort (void *base, size_t nmemb, size_t size, qsort_compare_fn compar)
static void	qsort_insertion_sort (char *base, size_t nmemb, size_t size, qsort_compare_fn compar)
static size_t	qsort_partition (char *base, size_t nmemb, size_t size, qsort_compare_fn compar)
template<typename T>
constexpr T	radians (T deg) FL_NOEXCEPT
FASTLED_FORCE_INLINE fl::u32	radiansToA24_fp (fl::i32 angle_s16x16_raw)
u32	rand ()
int	read ()
FASTLED_FORCE_INLINE i32	read_sin32_lut (const i32 *addr) FL_NOEXCEPT
fl::optional< fl::string >	readLine (char delimiter, char skipChar, fl::optional< u32 > timeoutMs)
template<typename SerialIn>
fl::optional< fl::string >	readSerialLine (SerialIn &serial, char delimiter='\n', fl::optional< u32 > timeoutMs=fl::nullopt)
	Read a line from a serial-like input source (blocking with optional timeout)
fl::optional< fl::string >	readSerialLine (SerialReader &serial, char delimiter='\n', fl::optional< u32 > timeoutMs=fl::nullopt)
	Optimized readSerialLine for fl:: serial input.
template<typename SerialIn>
fl::optional< fl::string >	readSerialStringUntil (SerialIn &serial, char delimiter, char skipChar, fl::optional< u32 > timeoutMs)
bool	readStringUntil (sstream &out, char delimiter, char skipChar, fl::optional< u32 > timeoutMs)
void *	realloc (void *ptr, size_t new_size)
void	register_asset (fl::string_view path, const fl::url &u) FL_NOEXCEPT
	Public helper: plug an asset mapping at runtime.
template<typename To, typename From>
To	reinterpret_cast_ (const From &from) FL_NOEXCEPT
template<typename T, typename Y>
shared_ptr< T >	reinterpret_pointer_cast (const shared_ptr< Y > &other) FL_NOEXCEPT
template<typename Iterator, typename T>
Iterator	remove (Iterator first, Iterator last, const T &value) FL_NOEXCEPT
template<typename Iterator, typename UnaryPredicate>
Iterator	remove_if (Iterator first, Iterator last, UnaryPredicate pred) FL_NOEXCEPT
void	render_polar_lookup_table (float cx, float cy, fl::vector< fl::vector< float > > &polar_theta, fl::vector< fl::vector< float > > &distance, int num_x, int num_y)
FASTLED_FORCE_INLINE float	render_value (render_parameters &animation)
FASTLED_FORCE_INLINE fl::i32	render_value_fp (const render_parameters_fp &p, const fl::i32 *fade_lut, const fl::u8 *perm)
FASTLED_FORCE_INLINE fl::i32	render_value_fp_from_float (const render_parameters &anim, const fl::i32 *fade_lut, const fl::u8 *perm)
template<typename Iterator, typename T>
void	replace (Iterator first, Iterator last, const T &old_value, const T &new_value) FL_NOEXCEPT
template<typename Iterator, typename UnaryPredicate, typename T>
void	replace_if (Iterator first, Iterator last, UnaryPredicate pred, const T &new_value) FL_NOEXCEPT
FASTLED_FORCE_INLINE u16	rescaleNoiseValue16 (u16 raw_value)
	Rescale raw inoise16() output to full 16-bit range [0, 65535] Curries in the global NOISE16_EXTENT_MIN/MAX extents for clean, reusable rescaling.
fl::string_view	resetCauseName (ResetCause c) FL_NOEXCEPT
	Return a static-lifetime name for c — zero-cost, no allocation.
fl::url	resolve_asset (const asset_ref &a) FL_NOEXCEPT
	Resolve an asset handle to a URL (or local file path) at runtime.
template<typename Iterator>
void	reverse (Iterator first, Iterator last) FL_NOEXCEPT
void	rgb565ToRgb888 (fl::u16 rgb565, fl::u8 &r, fl::u8 &g, fl::u8 &b)
fl::u16	rgb888ToRgb565 (fl::u8 r, fl::u8 g, fl::u8 b)
FASTLED_FORCE_INLINE void	rgb_2_rgbw (RGBW_MODE mode, u16 w_color_temperature, u8 r, u8 g, u8 b, u8 r_scale, u8 g_scale, u8 b_scale, u8 *out_r, u8 *out_g, u8 *out_b, u8 *out_w) FL_NOEXCEPT
	Converts RGB to RGBW using one of the functions.
template<RGBW_MODE MODE>
FASTLED_FORCE_INLINE void	rgb_2_rgbw (u16 w_color_temperature, u8 r, u8 g, u8 b, u8 r_scale, u8 g_scale, u8 b_scale, u8 *out_r, u8 *out_g, u8 *out_b, u8 *out_w) FL_NOEXCEPT
void	rgb_2_rgbw_colorimetric (u16 w_color_temperature, u8 r, u8 g, u8 b, u8 r_scale, u8 g_scale, u8 b_scale, u8 *out_r, u8 *out_g, u8 *out_b, u8 *out_w) FL_NOEXCEPT
void	rgb_2_rgbw_colorimetric_boosted (u16 w_color_temperature, u8 r, u8 g, u8 b, u8 r_scale, u8 g_scale, u8 b_scale, u8 *out_r, u8 *out_g, u8 *out_b, u8 *out_w) FL_NOEXCEPT
void	rgb_2_rgbw_exact (u16 w_color_temperature, u8 r, u8 g, u8 b, u8 r_scale, u8 g_scale, u8 b_scale, u8 *out_r, u8 *out_g, u8 *out_b, u8 *out_w) FL_NOEXCEPT
	Converts RGB to RGBW using a color transfer method from saturated color channels to white.
void	rgb_2_rgbw_max_brightness (u16 w_color_temperature, u8 r, u8 g, u8 b, u8 r_scale, u8 g_scale, u8 b_scale, u8 *out_r, u8 *out_g, u8 *out_b, u8 *out_w) FL_NOEXCEPT
	The minimum brigthness of the RGB channels is used to set the W channel.
void	rgb_2_rgbw_null_white_pixel (u16 w_color_temperature, u8 r, u8 g, u8 b, u8 r_scale, u8 g_scale, u8 b_scale, u8 *out_r, u8 *out_g, u8 *out_b, u8 *out_w) FL_NOEXCEPT
	Converts RGB to RGBW with the W channel set to black, always.
void	rgb_2_rgbw_user_function (u16 w_color_temperature, u8 r, u8 g, u8 b, u8 r_scale, u8 g_scale, u8 b_scale, u8 *out_r, u8 *out_g, u8 *out_b, u8 *out_w)
void	rgb_2_rgbw_white_boosted (u16 w_color_temperature, u8 r, u8 g, u8 b, u8 r_scale, u8 g_scale, u8 b_scale, u8 *out_r, u8 *out_g, u8 *out_b, u8 *out_w) FL_NOEXCEPT
	Converts RGB to RGBW with a boosted white channel.
FASTLED_FORCE_INLINE void	rgb_2_rgbww (const Rgbww &cfg, fl::u8 r, fl::u8 g, fl::u8 b, fl::u8 r_scale, fl::u8 g_scale, fl::u8 b_scale, fl::u8 *out_r, fl::u8 *out_g, fl::u8 *out_b, fl::u8 *out_ww, fl::u8 *out_wc) FL_NOEXCEPT
void	rgb_2_rgbww_colorimetric (const Rgbww &cfg, fl::u8 r, fl::u8 g, fl::u8 b, fl::u8 r_scale, fl::u8 g_scale, fl::u8 b_scale, fl::u8 *out_r, fl::u8 *out_g, fl::u8 *out_b, fl::u8 *out_ww, fl::u8 *out_wc) FL_NOEXCEPT
	Colorimetric strict sub-gamut solver for RGBWW (gist sec 5 + sec 11-12, using solve_rgbcct from rgbw_colorimetric.h).
void	rgb_2_rgbww_colorimetric_boosted (const Rgbww &cfg, fl::u8 r, fl::u8 g, fl::u8 b, fl::u8 r_scale, fl::u8 g_scale, fl::u8 b_scale, fl::u8 *out_r, fl::u8 *out_g, fl::u8 *out_b, fl::u8 *out_ww, fl::u8 *out_wc) FL_NOEXCEPT
	Colorimetric white-overdrive solver for RGBWW (wx_lp_legacy + RGBCCT layered blend).
void	rgb_2_rgbww_user_function (const Rgbww &cfg, fl::u8 r, fl::u8 g, fl::u8 b, fl::u8 r_scale, fl::u8 g_scale, fl::u8 b_scale, fl::u8 *out_r, fl::u8 *out_g, fl::u8 *out_b, fl::u8 *out_ww, fl::u8 *out_wc) FL_NOEXCEPT
	User-installable RGB->RGBWW function.
FASTLED_FORCE_INLINE rgb	rgb_sanity_check (rgb &pixel)
FASTLED_FORCE_INLINE void	rgb_sanity_check_fp (fl::i32 &r, fl::i32 &g, fl::i32 &b)
static HSV16	RGBtoHSV16 (const CRGB &rgb)
bool	rgbw_colorimetric_lut_enabled () FL_NOEXCEPT
constexpr unsigned long	rgbw_colorimetric_lut_memory_bytes (int grid_n, RgbwLutInterp interp) FL_NOEXCEPT
void	rgbw_partial_reorder (EOrderW w_placement, u8 b0, u8 b1, u8 b2, u8 w, u8 *out_b0, u8 *out_b1, u8 *out_b2, u8 *out_b3)
void	rgbww_partial_reorder (EOrderWW ww_placement, fl::u8 b0, fl::u8 b1, fl::u8 b2, fl::u8 ww, fl::u8 wc, fl::u8 *out_b0, fl::u8 *out_b1, fl::u8 *out_b2, fl::u8 *out_b3, fl::u8 *out_b4) FL_NOEXCEPT
	Dispatch RGB->RGBWW for a given mode.
template<typename T>
enable_if<!is_integral< T >::value, T >::type	round (T value) FL_NOEXCEPT
template<typename T>
enable_if< is_integral< T >::value, float >::type	round (T value) FL_NOEXCEPT
template<>
double	round< double > (double value) FL_NOEXCEPT
double	round_impl_double (double value)
float	round_impl_float (float value)
float	roundf (float value) FL_NOEXCEPT
template<typename T>
constexpr enable_if< is_fixed_point< T >::value, T >::type	rsqrt (T x) FL_NOEXCEPT
void	run_default_oscillators (oscillators &timings, modulators &move, fl::u32 current_time, float speed_factor, float master_speed=0.005)
SingleTestResult	runSingleValidationTest (const SingleTestConfig &config)
	Run a single stateless validation test.
template<>
fl::shared_ptr< RxDevice >	RxDevice::create< RxDeviceType::FLEXIO > (int pin) FL_NOEXCEPT
template<>
fl::shared_ptr< RxDevice >	RxDevice::create< RxDeviceType::FLEXPWM > (int pin) FL_NOEXCEPT
template<>
fl::shared_ptr< RxDevice >	RxDevice::create< RxDeviceType::FLEXPWM > (int pin) FL_NOEXCEPT
template<>
fl::shared_ptr< RxDevice >	RxDevice::create< RxDeviceType::ISR > (int pin) FL_NOEXCEPT
template<>
fl::shared_ptr< RxDevice >	RxDevice::create< RxDeviceType::ISR > (int pin) FL_NOEXCEPT
template<>
fl::shared_ptr< RxDevice >	RxDevice::create< RxDeviceType::LPC_SCT_CAPTURE > (int pin) FL_NOEXCEPT
template<>
fl::shared_ptr< RxDevice >	RxDevice::create< RxDeviceType::LPC_SCT_CAPTURE > (int pin) FL_NOEXCEPT
template<>
fl::shared_ptr< RxDevice >	RxDevice::create< RxDeviceType::PLATFORM_DEFAULT > (int pin) FL_NOEXCEPT
template<>
fl::shared_ptr< RxDevice >	RxDevice::create< RxDeviceType::PLATFORM_DEFAULT > (int pin) FL_NOEXCEPT
template<>
fl::shared_ptr< RxDevice >	RxDevice::create< RxDeviceType::RMT > (int pin) FL_NOEXCEPT
template<>
fl::shared_ptr< RxDevice >	RxDevice::create< RxDeviceType::RMT > (int pin) FL_NOEXCEPT
CRGB	sample (const CRGB *grid, const XYMap &xyMap, float x, float y, SampleMode mode=SampleMode::SAMPLE_BILINEAR)
	Sample a pixel from a 2D CRGB grid at floating-point coordinates.
CRGB	sampleBilinear (const CRGB *grid, const XYMap &xyMap, float x, float y)
	Bilinear interpolation sample from a 2D CRGB grid.
CRGB	sampleNearest (const CRGB *grid, const XYMap &xyMap, float x, float y)
	Nearest-neighbor sample from a 2D CRGB grid.
static u16	scale8_to_16_accurate (u8 x)
float	screen (float &a, float &b)
FASTLED_FORCE_INLINE fl::i32	screen_fp (fl::i32 a, fl::i32 b)
LIB8STATIC u16	seconds16 () FL_NOEXCEPT
	Return the current seconds since boot in a 16-bit value.
void	serial_begin (u32 baudRate)
bool	serial_ready ()
fl::string	serializeValue (const json_value &value)
void	set_errno (int value)
void	set_input_gamut (DiodeProfile *profile, InputGamut g) FL_NOEXCEPT
void	set_input_gamut (DiodeProfile *profile, InputGamut g, const float white_xy[2]) FL_NOEXCEPT
void	set_rgb_2_rgbw_function (rgb_2_rgbw_function func)
void	set_rgb_2_rgbww_function (rgb_2_rgbww_function func) FL_NOEXCEPT
void	set_rgbw_colorimetric_profile (const DiodeProfile *profile) FL_NOEXCEPT
void	set_rgbww_colorimetric_profile (const colorimetric_detail::RgbcctProfile *profile) FL_NOEXCEPT
void	setAdcRange (AdcRange range)
	Set ADC voltage range.
void	setLogLevel (u8 level) FL_NOEXCEPT
	Set the global log level.
void	SetPSRamAllocator (void *(*alloc)(fl::size), void(*free)(void *))
void	setPwm16 (int pin, u16 val)
	Set PWM duty cycle with 16-bit resolution.
int	setPwmFrequency (int pin, u32 frequency_hz)
	Set PWM frequency for a pin.
void	setTime (Context &ctx, fl::u32 t)
template<typename Iterator>
void	shuffle (Iterator first, Iterator last) FL_NOEXCEPT
template<typename Iterator>
void	shuffle (Iterator first, Iterator last, math::random &rng) FL_NOEXCEPT
template<typename Iterator, typename RandomGenerator>
void	shuffle (Iterator first, Iterator last, RandomGenerator &g) FL_NOEXCEPT
template<typename Iterator, typename Compare>
void	sift_down (Iterator first, Iterator last, Iterator start, Compare comp)
template<typename T>
constexpr enable_if< is_fixed_point< T >::value, int >::type	sign (T x) FL_NOEXCEPT
double	sin (double value) FL_NOEXCEPT
template<typename T>
enable_if< is_fixed_point< T >::value, T >::type	sin (T angle) FL_NOEXCEPT
template<typename T>
enable_if< is_integral< T >::value, float >::type	sin (T value) FL_NOEXCEPT
FASTLED_FORCE_INLINE i16	sin16lut (u16 angle) FL_NOEXCEPT
FASTLED_FORCE_INLINE i32	sin32 (u32 angle) FL_NOEXCEPT
FASTLED_FORCE_INLINE i32	sin32_interp (u8 qi, u8 qi_next, i32 dmask, u32 t, u8 offset=0) FL_NOEXCEPT
double	sin_impl_double (double value)
float	sin_impl_float (float value)
template<typename T>
enable_if< is_integral< T >::value >::type	sincos (T angle, float &out_sin, float &out_cos) FL_NOEXCEPT
template<typename T>
enable_if< is_fixed_point< T >::value, void >::type	sincos (T angle, T &out_sin, T &out_cos) FL_NOEXCEPT
template<typename T>
enable_if< is_floating_point< T >::value >::type	sincos (T angle, T &out_sin, T &out_cos) FL_NOEXCEPT
FASTLED_FORCE_INLINE SinCos32	sincos32 (u32 angle) FL_NOEXCEPT
FASTLED_FORCE_INLINE SinCos32_simd	sincos32_simd (simd::simd_u32x4 angles) FL_NOEXCEPT
	Process 4 angles simultaneously, returning vectorized sin/cos values SIMD-optimized: vectorized angle decomposition, vector LUT loads with 4x4 transpose (AoS→SoA), and vectorized quadratic interpolation.
float	sinf (float value) FL_NOEXCEPT
i32	smap16_to_32 (i16 x) FL_NOEXCEPT
	Use int_scale<int16_t, int32_t>() instead.
i8	smap16_to_8 (i16 x) FL_NOEXCEPT
	Use int_scale<int16_t, int8_t>() instead.
i16	smap32_to_16 (i32 x) FL_NOEXCEPT
	Use int_scale<int32_t, int16_t>() instead.
i8	smap32_to_8 (i32 x) FL_NOEXCEPT
	Use int_scale<int32_t, int8_t>() instead.
i16	smap8_to_16 (i8 x) FL_NOEXCEPT
	Use int_scale<int8_t, int16_t>() instead.
i32	smap8_to_32 (i8 x) FL_NOEXCEPT
	Use int_scale<int8_t, int32_t>() instead.
template<typename T>
enable_if< is_fixed_point< T >::value, T >::type	smoothstep (T edge0, T edge1, T x) FL_NOEXCEPT
template<typename... Args>
int	snprintf (char *buffer, fl::size size, const char *format, const Args &... args) FL_NOEXCEPT
	Snprintf-like formatting function that writes to a buffer.
template<typename Iterator>
void	sort (Iterator first, Iterator last) FL_NOEXCEPT
template<typename Iterator, typename Compare>
void	sort (Iterator first, Iterator last, Compare comp) FL_NOEXCEPT
template<typename Iterator>
void	sort_small (Iterator first, Iterator last) FL_NOEXCEPT
template<typename Iterator, typename Compare>
void	sort_small (Iterator first, Iterator last, Compare comp) FL_NOEXCEPT
Tile2x2_u8	splat (vec2f xy)
	"Splat" as in "splat pixel rendering" takes a pixel value in float x,y coordinates and "splats" it into a 2x2 tile of pixel values.
template<fl::size N, typename... Args>
int	sprintf (char(&buffer)[N], const char *format, const Args &... args) FL_NOEXCEPT
	Sprintf-like formatting function that writes to a buffer.
double	sqrt (double value) FL_NOEXCEPT
float	sqrt (float value) FL_NOEXCEPT
template<typename T>
enable_if< is_integral< T >::value, float >::type	sqrt (T value) FL_NOEXCEPT
template<typename T>
enable_if< sqrt_detail::has_static_sqrt< T >::value, decltype(T::sqrt(declval< T >()))>::type	sqrt (T value) FL_NOEXCEPT
template<typename T>
constexpr enable_if< is_fixed_point< T >::value, T >::type	sqrt (T x) FL_NOEXCEPT
double	sqrt_impl_double (double value)
float	sqrt_impl_float (float value)
float	sqrtf (float value) FL_NOEXCEPT
template<typename Iterator>
void	stable_sort (Iterator first, Iterator last) FL_NOEXCEPT
template<typename Iterator, typename Compare>
void	stable_sort (Iterator first, Iterator last, Compare comp) FL_NOEXCEPT
template<typename T, typename Y>
shared_ptr< T >	static_pointer_cast (const shared_ptr< Y > &other) FL_NOEXCEPT
template<typename T>
constexpr enable_if< is_fixed_point< T >::value, T >::type	step (T edge, T x) FL_NOEXCEPT
char *	strcat (char *dest, const char *src) FL_NOEXCEPT
char *	strchr (char *s, int c) FL_NOEXCEPT
const char *	strchr (const char *s, int c) FL_NOEXCEPT
int	strcmp (const char *s1, const char *s2) FL_NOEXCEPT
char *	strcpy (char *dest, const char *src) FL_NOEXCEPT
size_t	strcspn (const char *s1, const char *s2) FL_NOEXCEPT
char *	strerror (int errnum) FL_NOEXCEPT
static int	string_compare (const string &a, const string &b) FL_NOEXCEPT
size_t	strlen (const char *s) FL_NOEXCEPT
char *	strncat (char *dest, const char *src, size_t n) FL_NOEXCEPT
int	strncmp (const char *s1, const char *s2, size_t n) FL_NOEXCEPT
char *	strncpy (char *dest, const char *src, size_t n) FL_NOEXCEPT
char *	strpbrk (char *s1, const char *s2) FL_NOEXCEPT
const char *	strpbrk (const char *s1, const char *s2) FL_NOEXCEPT
char *	strrchr (char *s, int c) FL_NOEXCEPT
const char *	strrchr (const char *s, int c) FL_NOEXCEPT
size_t	strspn (const char *s1, const char *s2) FL_NOEXCEPT
const char *	strstr (const char *haystack, const char *needle) FL_NOEXCEPT
double	strtod (const char *str, char **endptr)
char *	strtok (char *s1, const char *s2) FL_NOEXCEPT
long	strtol (const char *str, char **endptr, int base)
unsigned long	strtoul (const char *str, char **endptr, int base)
float	subtract (float &a, float &b)
FASTLED_FORCE_INLINE fl::i32	subtract_fp (fl::i32 a, fl::i32 b)
template<typename T, fl::size N>
void	swap (array< T, N > &lhs, array< T, N > &rhs) FL_NOEXCEPT
template<typename Key, typename Value, typename Less>
void	swap (flat_map< Key, Value, Less > &lhs, flat_map< Key, Value, Less > &rhs) FL_NOEXCEPT
template<typename Key, typename Less>
void	swap (flat_set< Key, Less > &lhs, flat_set< Key, Less > &rhs) FL_NOEXCEPT
template<typename T>
void	swap (list< T > &lhs, list< T > &rhs)
template<typename T1, typename T2>
void	swap (pair< T1, T2 > &lhs, pair< T1, T2 > &rhs) FL_NOEXCEPT
template<typename T, typename Container>
void	swap (queue< T, Container > &lhs, queue< T, Container > &rhs)
	Swap two queues.
template<typename T>
void	swap (shared_ptr< T > &lhs, shared_ptr< T > &rhs) FL_NOEXCEPT
template<typename T>
void	swap (T &a, T &b) FL_NOEXCEPT
template<typename T, typename Deleter>
void	swap (unique_ptr< T, Deleter > &lhs, unique_ptr< T, Deleter > &rhs) FL_NOEXCEPT
template<typename Key, typename Value, typename Equal>
void	swap (unordered_map_small< Key, Value, Equal > &lhs, unordered_map_small< Key, Value, Equal > &rhs) FL_NOEXCEPT
template<typename T>
void	swap (weak_ptr< T > &lhs, weak_ptr< T > &rhs) FL_NOEXCEPT
template<typename T>
void	swap_by_copy (T &a, T &b) FL_NOEXCEPT
static void	sys_yield ()
double	tan (double value) FL_NOEXCEPT
template<typename T>
enable_if< is_integral< T >::value, float >::type	tan (T value) FL_NOEXCEPT
double	tan_impl_double (double value)
float	tan_impl_float (float value)
float	tanf (float value) FL_NOEXCEPT
fl::u64	time () FL_NOEXCEPT
	Alias for millis64() - returns 64-bit millisecond time.
u16	time_alpha16 (u32 now, u32 start, u32 end) FL_NOEXCEPT
u8	time_alpha8 (u32 now, u32 start, u32 end) FL_NOEXCEPT
float	time_alphaf (u32 now, u32 start, u32 end) FL_NOEXCEPT
template<fl::size N, typename T>
array< T, N >	to_array (fl::span< const T, fl::size(-1)> s) FL_NOEXCEPT
template<typename T, fl::size N>
array< T, N >	to_array (fl::span< const T, N > s) FL_NOEXCEPT
template<typename T>
fl::string	to_hex (T value, bool uppercase=false, bool pad_to_width=false) FL_NOEXCEPT
	Convert an integer value to hexadecimal string representation.
template<typename TIMING>
constexpr ChipsetTiming	to_runtime_timing () FL_NOEXCEPT
	Convert enum-based timing type to runtime ChipsetTiming struct.
string	to_string (float value, int precision) FL_NOEXCEPT
template<typename T>
string	to_string (T value) FL_NOEXCEPT
static u8	to_uint8 (float f)
char	tolower (char c) FL_NOEXCEPT
	Convert character to lowercase.
const char *	toString (RxBackend backend) FL_NOEXCEPT
const char *	toString (RxDeviceType type) FL_NOEXCEPT
	Convert RxDeviceType to human-readable string.
char	toupper (char c) FL_NOEXCEPT
	Convert character to uppercase.
template<int m, int n>
FASTLED_FORCE_INLINE void	transpose8 (unsigned char *A, unsigned char *B) FL_NOEXCEPT
	Templated 8x8 bit transpose with custom stride.
FASTLED_FORCE_INLINE void	transpose8x1 (unsigned char *A, unsigned char *B) FL_NOEXCEPT
	Simplified 8x1 bit transpose (inline version)
FASTLED_FORCE_INLINE void	transpose8x1_MSB (unsigned char *A, unsigned char *B) FL_NOEXCEPT
	Simplified 8x1 bit transpose with MSB-first output.
void	transpose8x1_noinline (unsigned char *A, unsigned char *B) FL_NOEXCEPT
	Simplified 8x1 bit transpose (non-inline version)
void	transpose_16lane_inline (const u8 *const lanes[16], u8 *output, size_t num_bytes) FL_NOEXCEPT
	Low-level bit-interleaving primitive for 16 lanes (ISR-safe)
void	transpose_2lane_inline (const u8 *lane0_byte, const u8 *lane1_byte, u8 *output, size_t num_bytes) FL_NOEXCEPT
	Low-level bit-interleaving primitive for 2 lanes (ISR-safe)
FASTLED_FORCE_INLINE void	transpose_2strips (const u8 *const input[2], u8 *output, u16 num_leds, u8 bytes_per_led) FL_NOEXCEPT
	Transpose 2 LED strips into parallel bit format.
void	transpose_4lane_inline (const u8 *const lanes[4], u8 *output, size_t num_bytes) FL_NOEXCEPT
	Low-level bit-interleaving primitive for 4 lanes (ISR-safe)
FASTLED_FORCE_INLINE void	transpose_4strips (const u8 *const input[4], u8 *output, u16 num_leds, u8 bytes_per_led) FL_NOEXCEPT
	Transpose 4 LED strips into parallel bit format.
void	transpose_8lane_inline (const u8 *const lanes[8], u8 *output, size_t num_bytes) FL_NOEXCEPT
	Low-level bit-interleaving primitive for 8 lanes (ISR-safe)
FASTLED_FORCE_INLINE void	transpose_8strips (const u8 *const input[8], u8 *output, u16 num_leds, u8 bytes_per_led) FL_NOEXCEPT
	Transpose 8 LED strips into parallel bit format.
template<typename TSource>
void	transpose_generic_inline (const TSource *const lanes[], size_t num_lanes, u8 *output, size_t num_items) FL_NOEXCEPT
	Generic bit-interleaving primitive for N lanes with M-bit source data (ISR-safe)
bool	transpose_strips (u8 num_strips, const u8 *const *input, u8 *output, u16 num_leds, u8 bytes_per_led) FL_NOEXCEPT
	Helper to transpose N strips with automatic dispatch.
FASTLED_FORCE_INLINE FL_IRAM size_t	transpose_wave8byte_parlio (const u8 *FL_RESTRICT_PARAM laneWaveforms, size_t data_width, u8 *FL_RESTRICT_PARAM outputBuffer) FL_NOEXCEPT
template<size_t DATA_WIDTH>
FASTLED_FORCE_INLINE FL_IRAM FL_OPTIMIZE_FUNCTION size_t	transpose_wave8byte_parlio_template (const u8 *FL_RESTRICT_PARAM laneWaveforms, u8 *FL_RESTRICT_PARAM outputBuffer) FL_NOEXCEPT
	Template specialization of transpose for compile-time data_width (optimization)
template<typename GridVisitor>
void	traverseGridSegment (const vec2f &start, const vec2f &end, GridVisitor &visitor)
	Traverse a grid segment by selecting the cells that are crossed.
template<typename GridVisitor>
void	traverseGridSegment16 (const vec2f &start, const vec2f &end, GridVisitor &visitor)
	Traverse a grid segment using fixed-point 8.8 arithmetic.
template<typename GridVisitor>
void	traverseGridSegment32 (const vec2f &start, const vec2f &end, GridVisitor &visitor)
template<typename GridVisitor>
void	traverseGridSegmentFloat (const vec2f &start, const vec2f &end, GridVisitor &visitor)
	Traverse a grid segment using floating point arithmetic.
void	upscale (const CRGB *input, CRGB *output, u16 inputWidth, u16 inputHeight, const fl::XYMap &xyMap)
void	upscaleArbitrary (const CRGB *input, CRGB *output, u16 inputWidth, u16 inputHeight, const fl::XYMap &xyMap)
	Performs bilinear interpolation for upscaling an image.
void	upscaleArbitraryFloat (const CRGB *input, CRGB *output, u16 inputWidth, u16 inputHeight, const XYMap &xyMap)
void	upscaleFloat (const CRGB *input, CRGB *output, u8 inputWidth, u8 inputHeight, const XYMap &xyMap)
u8	upscaleFloat (u8 v00, u8 v10, u8 v01, u8 v11, float dx, float dy)
void	UpscalePalette (const class CHSVPalette16 &srcpal16, class CHSVPalette256 &destpal256)
void	UpscalePalette (const class CHSVPalette16 &srcpal16, class CHSVPalette32 &destpal32)
void	UpscalePalette (const class CHSVPalette32 &srcpal32, class CHSVPalette256 &destpal256)
void	UpscalePalette (const class CRGBPalette16 &srcpal16, class CRGBPalette256 &destpal256)
void	UpscalePalette (const class CRGBPalette16 &srcpal16, class CRGBPalette32 &destpal32)
void	UpscalePalette (const class CRGBPalette32 &srcpal32, class CRGBPalette256 &destpal256)
void	upscalePowerOf2 (const CRGB *input, CRGB *output, u8 inputWidth, u8 inputHeight, const fl::XYMap &xyMap)
	Performs bilinear interpolation for upscaling an image.
void	upscaleRectangular (const CRGB *input, CRGB *output, u16 inputWidth, u16 inputHeight, u16 outputWidth, u16 outputHeight)
	Optimized upscale for rectangular/line-by-line XY maps.
void	upscaleRectangularPowerOf2 (const CRGB *input, CRGB *output, u8 inputWidth, u8 inputHeight, u8 outputWidth, u8 outputHeight)
	Optimized upscale for rectangular/line-by-line XY maps (power-of-2 version).
int	utoa32 (u32 value, char *buffer, int radix) FL_NOEXCEPT
	Convert unsigned 32-bit integer to string buffer in given radix.
int	utoa64 (u64 value, char *buffer, int radix) FL_NOEXCEPT
	Convert unsigned 64-bit integer to string buffer in given radix.
template<typename T>
const vector_element_ops *	vector_element_ops_for () FL_NOEXCEPT
	Generate a static ops table for type T.
FASTLED_FORCE_INLINE FL_IRAM FL_OPTIMIZE_FUNCTION void	wave3 (u8 lane, const Wave3BitExpansionLut &lut, u8(&FL_RESTRICT_PARAM output)[sizeof(Wave3Byte)])
	Convert byte to 3 wave3 bytes using nibble LUT.
FL_OPTIMIZE_FUNCTION u32	wave3ClockFrequencyHz (const ChipsetTiming &timing)
	Calculate the clock frequency for wave3 encoding.
FL_OPTIMIZE_FUNCTION FL_IRAM void	wave3Transpose_16 (const u8(&FL_RESTRICT_PARAM lanes)[16], const Wave3BitExpansionLut &lut, u8(&FL_RESTRICT_PARAM output)[16 *sizeof(Wave3Byte)])
FL_OPTIMIZE_FUNCTION FL_IRAM void	wave3Transpose_2 (const u8(&FL_RESTRICT_PARAM lanes)[2], const Wave3BitExpansionLut &lut, u8(&FL_RESTRICT_PARAM output)[2 *sizeof(Wave3Byte)])
FL_OPTIMIZE_FUNCTION FL_IRAM void	wave3Transpose_4 (const u8(&FL_RESTRICT_PARAM lanes)[4], const Wave3BitExpansionLut &lut, u8(&FL_RESTRICT_PARAM output)[4 *sizeof(Wave3Byte)])
FL_OPTIMIZE_FUNCTION FL_IRAM void	wave3Transpose_8 (const u8(&FL_RESTRICT_PARAM lanes)[8], const Wave3BitExpansionLut &lut, u8(&FL_RESTRICT_PARAM output)[8 *sizeof(Wave3Byte)])
FL_OPTIMIZE_FUNCTION void	wave3Untranspose_16 (const u8(&FL_RESTRICT_PARAM transposed)[16 *sizeof(Wave3Byte)], u8(&FL_RESTRICT_PARAM output)[16 *sizeof(Wave3Byte)])
FL_OPTIMIZE_FUNCTION void	wave3Untranspose_2 (const u8(&FL_RESTRICT_PARAM transposed)[2 *sizeof(Wave3Byte)], u8(&FL_RESTRICT_PARAM output)[2 *sizeof(Wave3Byte)])
FL_OPTIMIZE_FUNCTION void	wave3Untranspose_4 (const u8(&FL_RESTRICT_PARAM transposed)[4 *sizeof(Wave3Byte)], u8(&FL_RESTRICT_PARAM output)[4 *sizeof(Wave3Byte)])
FL_OPTIMIZE_FUNCTION void	wave3Untranspose_8 (const u8(&FL_RESTRICT_PARAM transposed)[8 *sizeof(Wave3Byte)], u8(&FL_RESTRICT_PARAM output)[8 *sizeof(Wave3Byte)])
FASTLED_FORCE_INLINE FL_IRAM FL_OPTIMIZE_FUNCTION void	wave8 (u8 lane, const Wave8BitExpansionLut &lut, u8(&FL_RESTRICT_PARAM output)[sizeof(Wave8Byte)])
	Convert byte to 8 Wave8Bit structures using nibble LUT.
FL_OPTIMIZE_FUNCTION FL_IRAM void	wave8Transpose_16 (const u8(&FL_RESTRICT_PARAM lanes)[16], const Wave8BitExpansionLut &lut, u8(&FL_RESTRICT_PARAM output)[16 *sizeof(Wave8Byte)])
FL_OPTIMIZE_FUNCTION FL_IRAM void	wave8Transpose_16 (const u8(&FL_RESTRICT_PARAM lanes)[16], const Wave8ByteExpansionLut &lut, u8(&FL_RESTRICT_PARAM output)[16 *sizeof(Wave8Byte)])
FL_OPTIMIZE_FUNCTION FL_IRAM void	wave8Transpose_16_bf1 (const u8(&FL_RESTRICT_PARAM lanes)[16], const Wave8ByteExpansionLut &lut, u8(&FL_RESTRICT_PARAM output)[16 *sizeof(Wave8Byte)])
	BF1: chipset-aware direct encode for 16-lane Wave8 (#2548 deep-dive).
FL_OPTIMIZE_FUNCTION FL_IRAM void	wave8Transpose_16x2_pipe2 (const u8(&FL_RESTRICT_PARAM lanes_a)[16], const u8(&FL_RESTRICT_PARAM lanes_b)[16], const Wave8ByteExpansionLut &lut, u8(&FL_RESTRICT_PARAM output_a)[16 *sizeof(Wave8Byte)], u8(&FL_RESTRICT_PARAM output_b)[16 *sizeof(Wave8Byte)])
	Pipe2: transpose 16-lane × 2-byte-positions (#2548).
FL_OPTIMIZE_FUNCTION FL_IRAM void	wave8Transpose_16x4_bf1_pipe4 (const u8(&FL_RESTRICT_PARAM lanes_a)[16], const u8(&FL_RESTRICT_PARAM lanes_b)[16], const u8(&FL_RESTRICT_PARAM lanes_c)[16], const u8(&FL_RESTRICT_PARAM lanes_d)[16], const Wave8ByteExpansionLut &lut, u8(&FL_RESTRICT_PARAM output_a)[16 *sizeof(Wave8Byte)], u8(&FL_RESTRICT_PARAM output_b)[16 *sizeof(Wave8Byte)], u8(&FL_RESTRICT_PARAM output_c)[16 *sizeof(Wave8Byte)], u8(&FL_RESTRICT_PARAM output_d)[16 *sizeof(Wave8Byte)])
	BF1 + pipe4: 4-position-pipelined direct encode (#2548 deep-dive).
FL_OPTIMIZE_FUNCTION FL_IRAM void	wave8Transpose_16x4_pipe4 (const u8(&FL_RESTRICT_PARAM lanes_a)[16], const u8(&FL_RESTRICT_PARAM lanes_b)[16], const u8(&FL_RESTRICT_PARAM lanes_c)[16], const u8(&FL_RESTRICT_PARAM lanes_d)[16], const Wave8ByteExpansionLut &lut, u8(&FL_RESTRICT_PARAM output_a)[16 *sizeof(Wave8Byte)], u8(&FL_RESTRICT_PARAM output_b)[16 *sizeof(Wave8Byte)], u8(&FL_RESTRICT_PARAM output_c)[16 *sizeof(Wave8Byte)], u8(&FL_RESTRICT_PARAM output_d)[16 *sizeof(Wave8Byte)])
	Pipe4: transpose 16-lane × 4-byte-positions (#2548).
FL_OPTIMIZE_FUNCTION FL_IRAM void	wave8Transpose_2 (const u8(&FL_RESTRICT_PARAM lanes)[2], const Wave8BitExpansionLut &lut, u8(&FL_RESTRICT_PARAM output)[2 *sizeof(Wave8Byte)])
FL_OPTIMIZE_FUNCTION FL_IRAM void	wave8Transpose_2 (const u8(&FL_RESTRICT_PARAM lanes)[2], const Wave8ByteExpansionLut &lut, u8(&FL_RESTRICT_PARAM output)[2 *sizeof(Wave8Byte)])
FL_OPTIMIZE_FUNCTION FL_IRAM void	wave8Transpose_2_bf1 (const u8(&FL_RESTRICT_PARAM lanes)[2], const Wave8ByteExpansionLut &lut, u8(&FL_RESTRICT_PARAM output)[2 *sizeof(Wave8Byte)])
	BF1 for 2-lane Wave8 (#2548 deep-dive followup).
FL_OPTIMIZE_FUNCTION FL_IRAM void	wave8Transpose_4 (const u8(&FL_RESTRICT_PARAM lanes)[4], const Wave8BitExpansionLut &lut, u8(&FL_RESTRICT_PARAM output)[4 *sizeof(Wave8Byte)])
FL_OPTIMIZE_FUNCTION FL_IRAM void	wave8Transpose_4 (const u8(&FL_RESTRICT_PARAM lanes)[4], const Wave8ByteExpansionLut &lut, u8(&FL_RESTRICT_PARAM output)[4 *sizeof(Wave8Byte)])
FL_OPTIMIZE_FUNCTION FL_IRAM void	wave8Transpose_4_bf1 (const u8(&FL_RESTRICT_PARAM lanes)[4], const Wave8ByteExpansionLut &lut, u8(&FL_RESTRICT_PARAM output)[4 *sizeof(Wave8Byte)])
	BF1 for 4-lane Wave8 (#2548 deep-dive followup).
FL_OPTIMIZE_FUNCTION FL_IRAM void	wave8Transpose_8 (const u8(&FL_RESTRICT_PARAM lanes)[8], const Wave8BitExpansionLut &lut, u8(&FL_RESTRICT_PARAM output)[8 *sizeof(Wave8Byte)])
FL_OPTIMIZE_FUNCTION FL_IRAM void	wave8Transpose_8 (const u8(&FL_RESTRICT_PARAM lanes)[8], const Wave8ByteExpansionLut &lut, u8(&FL_RESTRICT_PARAM output)[8 *sizeof(Wave8Byte)])
FL_OPTIMIZE_FUNCTION FL_IRAM void	wave8Transpose_8_bf1 (const u8(&FL_RESTRICT_PARAM lanes)[8], const Wave8ByteExpansionLut &lut, u8(&FL_RESTRICT_PARAM output)[8 *sizeof(Wave8Byte)])
	BF1 for 8-lane Wave8 (#2548 deep-dive followup).
FL_OPTIMIZE_FUNCTION void	wave8Untranspose_16 (const u8(&FL_RESTRICT_PARAM transposed)[16 *sizeof(Wave8Byte)], u8(&FL_RESTRICT_PARAM output)[16 *sizeof(Wave8Byte)])
FL_OPTIMIZE_FUNCTION void	wave8Untranspose_2 (const u8(&FL_RESTRICT_PARAM transposed)[2 *sizeof(Wave8Byte)], u8(&FL_RESTRICT_PARAM output)[2 *sizeof(Wave8Byte)])
FL_OPTIMIZE_FUNCTION void	wave8Untranspose_4 (const u8(&FL_RESTRICT_PARAM transposed)[4 *sizeof(Wave8Byte)], u8(&FL_RESTRICT_PARAM output)[4 *sizeof(Wave8Byte)])
FL_OPTIMIZE_FUNCTION void	wave8Untranspose_8 (const u8(&FL_RESTRICT_PARAM transposed)[8 *sizeof(Wave8Byte)], u8(&FL_RESTRICT_PARAM output)[8 *sizeof(Wave8Byte)])
i32	worley_noise_2d_q15 (i32 x, i32 y)
size_t	write_bytes (const u8 *buffer, size_t size)
template<typename SerialOut>
void	writeSerialLine (SerialOut &serial, const fl::string &str)
	Write a string with newline to a serial-like output.
FASTLED_FORCE_INLINE u16	x_linear (u16 x, u16 length)
FASTLED_FORCE_INLINE u16	x_reverse (u16 x, u16 length)
fl::u16	XY (fl::u16 x, fl::u16 y)
FASTLED_FORCE_INLINE u16	xy_line_by_line (u16 x, u16 y, u16 width, u16 height) FL_NOEXCEPT
FASTLED_FORCE_INLINE u16	xy_serpentine (u16 x, u16 y, u16 width, u16 height) FL_NOEXCEPT
u16	xyMapCallbackAdapter (u16 x, u16 y, void *userData)
void	yield ()
	Yield to the platform scheduler.
LIB8STATIC u8	squarewave8 (u8 in, u8 pulsewidth=128) FL_NOEXCEPT
	Square wave generator.

Variables
const TProgmemRGBPalette16 *	ActivePaletteList []
template<typename Allocator>
constexpr bool	allocator_traits< Allocator >::has_allocate_at_least_v
template<typename Allocator>
constexpr bool	allocator_traits< Allocator >::has_reallocate_v
static const AnimartrixEntry	ANIMATION_TABLE []
FL_DISABLE_WARNING_PUSH unsigned char *	B
const TProgmemRGBPalette16	BlueWhite_p
u8 u8 fract8	blur_amount
constexpr size_t	BYTES_PER_PIXEL_RGB = 3
	Number of bytes per RGB pixel (order-agnostic)
constexpr size_t	BYTES_PER_PIXEL_RGBW = 4
	Number of bytes per RGBW pixel (order-agnostic)
constexpr size_t	BYTES_PER_PIXEL_RGBWW = 5
	Number of bytes per RGBWW pixel (order-agnostic, issue #2558).
FL_DISABLE_WARNING_GLOBAL_CONSTRUCTORS istream	cin
static const unsigned char	console_font_4x6 []
static const unsigned char	console_font_5x12 []
static const unsigned char	console_font_5x8 []
static const unsigned char	console_font_6x8 []
static const unsigned char	console_font_7x9 []
ostream	cout
const dec_t	dec
constexpr fl::size	dynamic_extent = fl::size(-1)
const endl_t	endl
const TProgmemRGBPalette16	FairyLight_p
SerialPort	fl_serial
static constexpr i32	FP_255 = 255 * FP_ONE
static constexpr i32	FP_ONE = s16x16::SCALE
volatile size_t	g_json_max_stack_depth
volatile size_t	g_json_stack_base
const u16	GAMMA_2_8_LUT [256]
static u8	gLogLevel = static_cast<u8>(LogLevel::FL_LOG_LEVEL_DEBUG)
u8 u8	height
const hex_t	hex
const TProgmemRGBPalette16	Holly_p
const TProgmemRGBPalette16	Ice_p
const DiodeProfile	kRgbwDefaultProfile
const colorimetric_detail::RgbcctProfile	kRgbwwDefaultProfile
constexpr size_t	MAX_SPI_LANES = 32
	Maximum number of SPI lanes supported (hardware: 1-8, software: up to 32)
constexpr u16	NOISE16_EXTENT_MAX = 59500
constexpr u16	NOISE16_EXTENT_MIN = 9000
	Observed min/max extents for inoise16() output.
constexpr nullopt_t	nullopt {}
constexpr int	numeric_limits< char >::digits
constexpr int	numeric_limits< char >::digits10
constexpr bool	numeric_limits< char >::is_signed
constexpr int	numeric_limits< double >::max_digits10
constexpr int	numeric_limits< double >::max_exponent
constexpr int	numeric_limits< double >::max_exponent10
constexpr int	numeric_limits< double >::min_exponent
constexpr int	numeric_limits< double >::min_exponent10
constexpr int	numeric_limits< float >::max_digits10
constexpr int	numeric_limits< float >::max_exponent
constexpr int	numeric_limits< float >::max_exponent10
constexpr int	numeric_limits< float >::min_exponent
constexpr int	numeric_limits< float >::min_exponent10
constexpr int	numeric_limits< int >::digits
constexpr int	numeric_limits< int >::digits10
constexpr int	numeric_limits< long >::digits
constexpr int	numeric_limits< long >::digits10
constexpr int	numeric_limits< longlong >::digits
constexpr int	numeric_limits< longlong >::digits10
constexpr int	numeric_limits< short >::digits
constexpr int	numeric_limits< short >::digits10
constexpr int	numeric_limits< signedchar >::digits
constexpr int	numeric_limits< signedchar >::digits10
constexpr int	numeric_limits< unsignedchar >::digits
constexpr int	numeric_limits< unsignedchar >::digits10
constexpr int	numeric_limits< unsignedint >::digits
constexpr int	numeric_limits< unsignedint >::digits10
constexpr int	numeric_limits< unsignedlong >::digits
constexpr int	numeric_limits< unsignedlong >::digits10
constexpr int	numeric_limits< unsignedlonglong >::digits
constexpr int	numeric_limits< unsignedlonglong >::digits10
constexpr int	numeric_limits< unsignedshort >::digits
constexpr int	numeric_limits< unsignedshort >::digits10
const oct_t	oct
template<typename Fn, fl::size N>
const detail::LutArray< u8, N >	ProgmemLUT< Fn, N >::kData
const TProgmemRGBPalette16	RedGreenWhite_p
const TProgmemRGBPalette16	RedWhite_p
const TProgmemRGBPalette16	RetroC9_p
const fl::u8	rgb565_5to8_table [32]
const fl::u8	rgb565_6to8_table [64]
const i32	sinCosPairedLut []
const TProgmemRGBPalette16	Snow_p
	t = (x ^ (x >> 7)) & 0x00AA00AA
constexpr int	type_rank< bool >::value
constexpr int	type_rank< char >::value
constexpr int	type_rank< double >::value
constexpr int	type_rank< float >::value
constexpr int	type_rank< int >::value
constexpr int	type_rank< long >::value
constexpr int	type_rank< longdouble >::value
constexpr int	type_rank< longlong >::value
constexpr int	type_rank< short >::value
constexpr int	type_rank< signedchar >::value
template<typename T>
constexpr int	type_rank< T >::value
constexpr int	type_rank< unsignedchar >::value
constexpr int	type_rank< unsignedint >::value
constexpr int	type_rank< unsignedlong >::value
constexpr int	type_rank< unsignedlonglong >::value
constexpr int	type_rank< unsignedshort >::value
u8	width
	x = *(u32*)(A+4)
	y = *(u32*)(A)

Class Members
typedef T *	type T *