Crate grafo 

Grafo

Grafo is a GPU-accelerated rendering library for Rust. It is a one-stop solution in case you need a quick and simple way to render shapes (with optional texture layers) in your application. It supports features such as masking, clipping, and font loading and rendering.

The library is designed for flexibility and ease of use, making it suitable for a wide range of applications, from simple graphical interfaces to complex rendering engines.

Features

• Shape Rendering: Create and render complex vector shapes.
• Shape Texturing: Apply up to two texture layers per shape with hierarchical clipping.
• Stencil Operations: Advanced stencil operations for clipping and masking.
• Shape Hierarchy: Attach shapes to parent nodes and choose whether each parent clips children.

Grafo available on crates.io, and API Documentation is available on docs.rs.

Getting Started

Add the following to your Cargo.toml:

[dependencies]
grafo = "0.1.0"
winit = "0.27"   # For window creation and event handling
image = "0.24"   # For image processing
env_logger = "0.10" # For logging
log = "0.4"      # For logging

Basic Usage

Below is a simple example demonstrating how to initialize the Renderer, add shapes and text, and render a frame using winit. For a more comprehensive example, refer to the examples folder in the repository.

use futures::executor::block_on;
use grafo::{BorderRadii, Shape};
use grafo::{Color, ShapeDrawCommandOptions, Stroke};
use std::sync::Arc;
use winit::application::ApplicationHandler;
use winit::event::WindowEvent;
use winit::event_loop::{ActiveEventLoop, EventLoop};
use winit::window::{Window, WindowId};

#[derive(Default)]
struct App<'a> {
    window: Option<Arc<Window>>,
    renderer: Option<grafo::Renderer<'a>>,
}

impl<'a> ApplicationHandler for App<'a> {
    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
        let window = Arc::new(
            event_loop
                .create_window(Window::default_attributes())
                .unwrap(),
        );

        let window_size = window.inner_size();
        let scale_factor = window.scale_factor();
        let physical_size = (window_size.width, window_size.height);

        // Initialize the renderer
        let mut renderer = block_on(grafo::Renderer::new(
            window.clone(),
            physical_size,
            scale_factor,
            true,  // vsync
            false, // transparent
            1,     // msaa_samples (1 = off)
        ));

        // Define a simple rectangle shape
        let rect = Shape::rect(
            [(0.0, 0.0), (200.0, 100.0)],
            Stroke::new(2.0, Color::BLACK), // Black stroke with width 2.0
        );
        renderer
            .add_shape(
                rect,
                None,
                None,
                ShapeDrawCommandOptions::new()
                    .color(Color::rgb(0, 128, 255))
                    .transform(grafo::TransformInstance::identity())
                    .clips_children(true),
            )
            .expect("to add shape to the renderer");

        self.window = Some(window);
        self.renderer = Some(renderer);
    }

    fn window_event(
        &mut self,
        event_loop: &ActiveEventLoop,
        window_id: WindowId,
        event: WindowEvent,
    ) {
        if let Some(ref mut renderer) = self.renderer {
            match event {
                WindowEvent::CloseRequested => event_loop.exit(),
                WindowEvent::Resized(physical_size) => {
                    let new_size = (physical_size.width, physical_size.height);
                    renderer.resize(new_size);
                    if let Some(window) = &self.window {
                        window.request_redraw();
                    }
                }
                WindowEvent::RedrawRequested => {
                    match renderer.render() {
                        Ok(_) => {
                            renderer.clear_draw_queue();
                        }
                        Err(wgpu::SurfaceError::Lost) => renderer.resize(renderer.size()),
                        Err(wgpu::SurfaceError::OutOfMemory) => event_loop.exit(),
                        Err(e) => eprintln!("{:?}", e),
                    }
                }
                _ => {}
            }
        }
    }
}

    env_logger::init();
    let event_loop = EventLoop::new().expect("to start an event loop");
    let mut app = App::default();
    event_loop.run_app(&mut app).unwrap();

Examples

For a detailed example showcasing advanced features like hierarchical clipping, multi-layer texturing, please refer to the examples directory in the repository.

Re-exports

pub use gradient::errors::GradientError;

pub use gradient::types::ColorInterpolation;

pub use gradient::types::ConicGradientDesc;

pub use gradient::types::Fill;

pub use gradient::types::Gradient;

pub use gradient::types::GradientColor;

pub use gradient::types::GradientCommonDesc;

pub use gradient::types::GradientDesc;

pub use gradient::types::GradientStop;

pub use gradient::types::GradientStopOffset;

pub use gradient::types::GradientStopPositions;

pub use gradient::types::GradientSupport;

pub use gradient::types::GradientUnits;

pub use gradient::types::HueComponent;

pub use gradient::types::HueInterpolationMethod;

pub use gradient::types::LinearGradientDesc;

pub use gradient::types::LinearGradientLine;

pub use gradient::types::RadialGradientDesc;

pub use gradient::types::RadialGradientShape;

pub use gradient::types::RadialGradientSize;

pub use gradient::types::SpreadMode;

pub use lyon;

pub use wgpu;

Modules

gradient

Structs

BackdropEffectConfig

Per-node configuration for backdrop capture before the effect shader runs.

BorderRadii

A set of border radii for a rounded rectangle

CachedShapeHandle

Color

Represents a color in RGBA format.

PathShape

Represents a custom path shape with stroke.

RectShape

Represents a simple rectangular shape with a fill color and stroke.

Renderer

The renderer for the Grafo library. This is the main struct used to render shapes and images.

ShapeBuilder

A builder for creating complex shapes using a fluent interface.

ShapeDrawCommandOptions

ShapeTextureOptions

Stroke

Represents the stroke properties of a shape.

TextureManager

A manager for textures providing granular control over texture handling.

TransformInstance

Enums

BackdropCaptureArea

Defines which already-rendered region a backdrop effect captures before processing it.

DrawCommandError

EffectError

Errors that can occur when working with the effect system.

RendererCreationError

Errors that can occur when creating a Renderer via Renderer::try_new_headless.

Shape

Represents a graphical shape, which can be either a custom path or a simple rectangle.

ShapeOverflow

Controls whether a shape clips descendants attached to it in the draw tree.

ShapeTextureFitMode

Controls how bound textures are fit into a shape’s local texture-coordinate space.

TextureLayer

Semantic texture layers for a shape. Background is layer 0, Foreground is layer 1.

Functions

premultiply_rgba8_srgb_inplace

Type Aliases

MathRect