Struct Renderer 

pub struct Renderer<F: Fn()> { /* private fields */ }

Renderer

The main renderer struct that manages the application lifecycle and rendering.

The Renderer is the core component of the Tessera UI framework, responsible for:

• Managing the application window and WGPU context
• Handling input events (mouse, touch, keyboard, IME)
• Coordinating the component tree building and rendering process
• Managing rendering pipelines and resources

Type Parameters

• F: The entry point function type that defines your UI. Must implement Fn().

Lifecycle

The renderer follows this lifecycle:

1. Initialization: Create window, initialize WGPU context, register pipelines
2. Event Loop: Handle window events, input events, and render requests
3. Frame Rendering: Build component tree → Compute draw commands → Render to surface
4. Cleanup: Automatic cleanup when the application exits

Thread Safety

The renderer runs on the main thread and coordinates with other threads for:

• Component tree building (potentially parallelized)
• Resource management
• Event processing

Usage

Basic Usage

It’s suggested to use cargo-tessera to create your project from templates which include all necessary setup. However, here’s a minimal example of how to use the renderer through the Renderer::run method:

use tessera_ui::{PipelineContext, RenderModule, Renderer};

#[derive(Debug)]
struct DemoModule;

impl RenderModule for DemoModule {
    fn register_pipelines(&self, _context: &mut PipelineContext<'_>) {}
}

// Define your UI entry point
fn my_app() {
    // Your UI components go here
}

// Run the application
Renderer::run(my_app, vec![Box::new(DemoModule)]).unwrap();

Android Usage

On android, Renderer::run requires an additional AndroidApp parameter from app context or android_main function.

Configuration

You can customize the renderer behavior by passing TesseraConfig when using Renderer::run_with_config. instead of Renderer::run.

use tessera_ui::{PipelineContext, RenderModule, Renderer, renderer::TesseraConfig};

#[derive(Debug)]
struct DemoModule;

impl RenderModule for DemoModule {
    fn register_pipelines(&self, _context: &mut PipelineContext<'_>) {}
}

let config = TesseraConfig {
    sample_count: 8,                            // 8x MSAA
    window_title: "My Tessera App".to_string(), // Custom window title
    ..Default::default()
};

Renderer::run_with_config(|| { /* my_app */ }, vec![Box::new(DemoModule)], config)?;

Performance Monitoring

The renderer includes built-in performance monitoring that logs frame statistics when performance drops below 60 FPS.

Implementations

impl<F: Fn()> Renderer<F>

pub fn run( entry_point: F, modules: Vec<Box<dyn RenderModule>>, ) -> Result<(), EventLoopError>

Runs the Tessera application with default configuration on desktop platforms.

This is the most convenient way to start a Tessera application on Windows, Linux, or macOS. It uses the default TesseraConfig settings (4x MSAA).

Parameters

• entry_point: A function that defines your UI. This function will be called every frame to build the component tree. It should contain your root UI components.
• modules: Render modules that register pipelines.

Returns

Returns Ok(()) when the application exits normally, or an EventLoopError if the event loop fails to start or encounters a critical error.

Examples

use tessera_ui::{PipelineContext, RenderModule, Renderer};

#[derive(Debug)]
struct DemoModule;

impl RenderModule for DemoModule {
    fn register_pipelines(&self, _context: &mut PipelineContext<'_>) {}
}

fn my_ui() {
    // Your UI components go here
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    Renderer::run(my_ui, vec![Box::new(DemoModule)])?;
    Ok(())
}

pub fn run_with_config( entry_point: F, modules: Vec<Box<dyn RenderModule>>, config: TesseraConfig, ) -> Result<(), EventLoopError>

Runs the Tessera application with custom configuration on desktop platforms.

This method allows you to customize the renderer behavior through TesseraConfig. Use this when you need to adjust settings like MSAA sample count or other rendering parameters.

Parameters

• entry_point: A function that defines your UI
• modules: Render modules that register pipelines
• config: Custom configuration for the renderer

Returns

Returns Ok(()) when the application exits normally, or an EventLoopError if the event loop fails to start.

Examples

use tessera_ui::{PipelineContext, RenderModule, Renderer, renderer::TesseraConfig};

#[derive(Debug)]
struct DemoModule;

impl RenderModule for DemoModule {
    fn register_pipelines(&self, _context: &mut PipelineContext<'_>) {}
}

let config = TesseraConfig {
    sample_count: 8, // 8x MSAA for higher quality
    ..Default::default()
};

Renderer::run_with_config(|| { /* my_ui */ }, vec![Box::new(DemoModule)], config)?;