horizon_lattice_render/

lib.rs

//! Graphics rendering backend for Horizon Lattice.
//!
//! This crate provides the GPU-accelerated rendering layer built on wgpu.
//! It handles surface management, rendering primitives, and GPU resource management.

#![warn(missing_docs)]
// Allow pre-existing clippy lints - these are intentional patterns
#![allow(clippy::too_many_arguments)]
#![allow(clippy::explicit_counter_loop)]
//!
//! # Getting Started
//!
//! Before any rendering can occur, you must initialize the [`GraphicsContext`]:
//!
//! ```no_run
//! use horizon_lattice_render::{GraphicsContext, GraphicsConfig};
//!
//! // Initialize with default configuration
//! let ctx = GraphicsContext::init(GraphicsConfig::default())
//!     .expect("Failed to initialize graphics");
//!
//! // Get adapter information
//! let info = ctx.adapter_info();
//! println!("Using GPU: {} ({:?})", info.name, info.backend);
//! ```
//!
//! # Creating Render Surfaces
//!
//! Each window needs a [`RenderSurface`] to render to:
//!
//! ```no_run
//! use std::sync::Arc;
//! use horizon_lattice_render::{GraphicsContext, GraphicsConfig, RenderSurface, SurfaceConfig};
//! use winit::event_loop::ActiveEventLoop;
//! use winit::window::Window;
//!
//! # fn example(event_loop: &ActiveEventLoop) -> horizon_lattice_render::RenderResult<()> {
//! // Initialize graphics first
//! GraphicsContext::init(GraphicsConfig::default())?;
//!
//! // Create a window (must be Arc for surface lifetime)
//! let window = Arc::new(event_loop.create_window(Window::default_attributes()).unwrap());
//!
//! // Create a render surface
//! let mut surface = RenderSurface::new(window, SurfaceConfig::default())?;
//! # Ok(())
//! # }
//! ```
//!
//! # Using the Renderer
//!
//! The [`GpuRenderer`] provides a high-level 2D drawing API:
//!
//! ```no_run
//! use horizon_lattice_render::{
//!     GraphicsContext, GraphicsConfig, RenderSurface, SurfaceConfig,
//!     GpuRenderer, Renderer, Color, Rect, Size,
//! };
//! use std::sync::Arc;
//! use winit::window::Window;
//!
//! # fn example(window: Arc<Window>) -> horizon_lattice_render::RenderResult<()> {
//! GraphicsContext::init(GraphicsConfig::default())?;
//! let mut surface = RenderSurface::new(window, SurfaceConfig::default())?;
//! let mut renderer = GpuRenderer::new(&surface)?;
//!
//! // Begin a frame
//! renderer.begin_frame(Color::WHITE, Size::new(800.0, 600.0));
//!
//! // Draw some shapes
//! renderer.fill_rect(Rect::new(10.0, 10.0, 100.0, 50.0), Color::RED);
//!
//! renderer.save();
//! renderer.translate(200.0, 100.0);
//! renderer.fill_rect(Rect::new(0.0, 0.0, 80.0, 80.0), Color::BLUE);
//! renderer.restore();
//!
//! // End frame and render to surface
//! renderer.end_frame();
//! renderer.render_to_surface(&mut surface)?;
//! # Ok(())
//! # }
//! ```
//!
//! # Handling Window Events
//!
//! The surface needs to be resized when the window is resized:
//!
//! ```no_run
//! # use horizon_lattice_render::RenderSurface;
//! # fn example(surface: &mut RenderSurface, width: u32, height: u32) {
//! // In your window event handler:
//! // WindowEvent::Resized(size) => {
//! surface.resize(width, height).ok();
//! // }
//! # }
//! ```

mod animated_image;
mod async_image;
mod atlas;
mod context;
pub mod damage;
mod disk_cache;
mod embedded_icon;
mod error;
mod gpu_renderer;
mod gradient;
mod icon;
mod image;
mod image_buffer;
mod image_cache;
pub mod image_data;
pub mod layer;
mod paint;
mod path;
mod renderer;
mod scalable_image;
pub mod stencil;
mod surface;
mod svg;
mod svg_cache;
pub mod text;
mod text_render_pass;
mod text_renderer;
mod transform;
mod types;

pub mod capture;
mod offscreen;

// Shader hot-reload support (optional)
#[cfg(feature = "shader-hot-reload")]
mod shader_watcher;

// Core infrastructure
pub use context::{GpuResources, GraphicsConfig, GraphicsContext};
pub use error::{RenderError, RenderResult};
pub use offscreen::{OffscreenConfig, OffscreenSurface};
pub use surface::{PresentMode, RenderSurface, SurfaceConfig, SurfaceFrame};

// Renderer API
pub use gpu_renderer::GpuRenderer;
pub use renderer::{FrameStats, RenderState, RenderStateStack, Renderer};

// Drawing types
pub use paint::{
    BlendMode, BoxShadow, BoxShadowParams, DashPattern, FillRule, GradientStop, LineCap, LineJoin,
    LinearGradient, Paint, RadialGradient, Stroke,
};
pub use path::{DEFAULT_TOLERANCE, TessellatedPath, tessellate_fill, tessellate_stroke};
pub use transform::{Transform2D, TransformStack};
pub use types::{Color, CornerRadii, Path, PathCommand, Point, Rect, RoundedRect, Size};

// Image types
pub use animated_image::{
    AnimatedImage, AnimationController, AnimationFrame, LoopCount, PlaybackState,
};
pub use async_image::{AsyncImageHandle, AsyncImageLoader, AsyncImageLoaderConfig, LoadingState};
pub use atlas::{ImageManager, TextureAtlas};
pub use disk_cache::{DiskCacheConfig, DiskCacheStats, DiskImageCache};
pub use image::{Image, ImageLoader, ImageScaleMode, NinePatch};
pub use image_buffer::{ImageBlendMode, ImageBuffer, OutputFormat, ResizeFilter};
pub use image_cache::{CacheKey, ImageCache, ImageCacheConfig, ImageCacheStats};
pub use scalable_image::ScalableImage;
pub use svg::SvgImage;
pub use svg_cache::{SvgCache, SvgCacheConfig, SvgCacheKey, SvgCacheStats, SvgSource};

// Icon types
pub use icon::{
    Icon, IconMode, IconPosition, IconSize, IconSource, IconState, IconThemeMode, SizedIconSet,
    StatefulIconSet, ThemedIconSet, icon_tint_for_state, icon_tint_for_state_full,
    icon_tint_for_state_with_hover,
};

// Embedded icon support
pub use embedded_icon::{EmbeddedIconData, EmbeddedIconSet, ImageFormat};

// Image metadata
pub use image_data::{
    ColorType, ExifData, ImageMetadata, Orientation, read_dimensions, read_dimensions_from_bytes,
    read_metadata, read_metadata_from_bytes,
};

// Damage tracking
pub use damage::DamageTracker;

// Layer compositing
pub use layer::{Compositor, Layer, LayerConfig, LayerId};

// Stencil clipping
pub use stencil::{ClipShape, ClipStack};

// Text rendering
pub use text::{
    // Text layout
    BackgroundRect,
    DecorationLine,
    Font,
    FontBuilder,
    FontFaceId,
    FontFaceInfo,
    FontFamily,
    FontFeature,
    FontLoadError,
    FontMetrics,
    FontQuery,
    FontStretch,
    FontStyle,
    FontSystem,
    FontSystemConfig,
    FontWeight,
    // Glyph rendering
    GlyphAllocation,
    GlyphAtlas,
    GlyphAtlasStats,
    GlyphCache,
    // Text shaping
    GlyphCacheKey,
    GlyphCacheStats,
    GlyphId,
    GlyphPixelFormat,
    GlyphRenderMode,
    HorizontalAlign,
    LayoutGlyph,
    LayoutLine,
    RasterizedGlyph,
    // Rich text
    RichText,
    RichTextSpan,
    ShapedGlyph,
    ShapedText,
    ShapingOptions,
    // Text decoration
    TextDecoration,
    TextDecorationStyle,
    TextDecorationType,
    TextLayout,
    TextLayoutOptions,
    TextShaper,
    TextSpan,
    VerticalAlign,
    WrapMode,
};

// Text renderer
pub use text_render_pass::TextRenderPass;
pub use text_renderer::{PreparedGlyph, TextRenderer, TextRendererConfig, TextRendererStats};

// Shader hot-reload support
#[cfg(feature = "shader-hot-reload")]
pub use shader_watcher::{ShaderKind, ShaderReloadResult, ShaderWatcher, load_shader_source};

// Re-export wgpu types that users commonly need
pub use wgpu;