Struct DebugState 

#[repr(C)]
pub struct DebugState {

    pub show_hit_test_areas: bool,
    pub profiler_dbg: bool,
    pub render_target_dbg: bool,
    pub texture_cache_dbg: bool,
    pub gpu_time_queries: bool,
    pub gpu_sample_queries: bool,
    pub disable_batching: bool,
    pub epochs: bool,
    pub echo_driver_messages: bool,
    pub show_overdraw: bool,
    pub gpu_cache_dbg: bool,
    pub texture_cache_dbg_clear_evicted: bool,
    pub picture_caching_dbg: bool,
    pub primitive_dbg: bool,
    pub zoom_dbg: bool,
    pub small_screen: bool,
    pub disable_opaque_pass: bool,
    pub disable_alpha_pass: bool,
    pub disable_clip_masks: bool,
    pub disable_text_prims: bool,
    pub disable_gradient_prims: bool,
    pub obscure_images: bool,
    pub glyph_flashing: bool,
    pub smart_profiler: bool,
    pub invalidation_dbg: bool,
    pub tile_cache_logging_dbg: bool,
    pub profiler_capture: bool,
    pub force_picture_invalidation: bool,
}

Toggles webrender debug flags (will make stuff appear on the screen that you might not want to - used for debugging purposes)

Every field here maps onto a webrender::DebugFlags bit except show_hit_test_areas, which is azul’s own overlay. Populate it from the environment with DebugState::from_az_overlay_env — see that function for the verb list and why the hit-test overlay is no longer debug_assertions-only.

Fields

show_hit_test_areas: bool

Paint a translucent red rectangle over every hit-test area.

azul’s own overlay, not a webrender flag: the compositor draws it while emitting DisplayListItem::HitTestArea, so it shows exactly the regions the hit tester will actually consider — which is the question you have when a click does nothing, or lands on the wrong node.

profiler_dbg: bool

render_target_dbg: bool

texture_cache_dbg: bool

gpu_time_queries: bool

gpu_sample_queries: bool

disable_batching: bool

epochs: bool

echo_driver_messages: bool

show_overdraw: bool

gpu_cache_dbg: bool

texture_cache_dbg_clear_evicted: bool

picture_caching_dbg: bool

primitive_dbg: bool

zoom_dbg: bool

small_screen: bool

disable_opaque_pass: bool

disable_alpha_pass: bool

disable_clip_masks: bool

disable_text_prims: bool

disable_gradient_prims: bool

obscure_images: bool

glyph_flashing: bool

smart_profiler: bool

invalidation_dbg: bool

tile_cache_logging_dbg: bool

profiler_capture: bool

force_picture_invalidation: bool

Implementations

impl DebugState

pub fn from_az_overlay_env() -> Self

Build a DebugState from the AZ_OVERLAY environment variable.

AZ_OVERLAY is a comma-separated list of verbs, e.g.

AZ_OVERLAY=hit-test
AZ_OVERLAY=hit-test,overdraw,profiler
AZ_OVERLAY=list          # print the verbs and exit-code nothing

WHY THIS EXISTS: the hit-test overlay used to be #[cfg(debug_assertions)] in the compositor, so a debug build painted every hit-test area red and a release build painted none, with no way to ask for either. That is a debug/release divergence in VISUAL OUTPUT — running hello-world showed a red window and the reasonable first guess was “this linked the wrong DLL”. It was not. An overlay you cannot turn on when you need it, and cannot turn off when you do not, is worse than no overlay.

Available in RELEASE builds too, deliberately: the moment you need to see hit-test regions or overdraw is usually on the build a user is running.

Unknown verbs are reported and ignored rather than fatal — a typo in a debugging aid must not stop the app you are trying to debug. Reading the environment needs std; on no_std there is no environment to read, so the overlay is simply off. from_overlay_spec stays available everywhere, so a no_std embedder can still enable overlays explicitly.

pub fn from_overlay_spec(spec: &str) -> Self

The parser behind DebugState::from_az_overlay_env, separated so it is testable without touching the process environment.

Trait Implementations

impl Clone for DebugState

fn clone(&self) -> DebugState

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for DebugState

impl Debug for DebugState

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for DebugState

fn default() -> DebugState

Returns the “default value” for a type.

impl Eq for DebugState

impl Hash for DebugState

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for DebugState

fn cmp(&self, other: &DebugState) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for DebugState

fn eq(&self, other: &DebugState) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl PartialOrd for DebugState

fn partial_cmp(&self, other: &DebugState) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for DebugState