re_viewport - Rust视口管理库介绍与使用指南

概述

re_viewport是一个高效的Rust视口管理库，专门用于处理多窗口和屏幕布局。它提供了简单易用的API来管理多个视口(viewport)，支持窗口创建、布局管理和渲染目标控制等功能。

主要特性

• 多窗口管理
• 灵活的屏幕布局配置
• 高效的视口渲染
• 跨平台支持
• 与常见Rust图形库兼容

安装

在Cargo.toml中添加依赖：

[dependencies]
re_viewport = "0.1"  # 请使用最新版本

完整示例代码

下面是一个完整的示例，展示了如何使用re_viewport创建多窗口、管理视口布局并与wgpu集成进行渲染：

use re_viewport::ViewportManager;
use wgpu::{Instance, Surface, Adapter, Device, Queue, CommandEncoder, RenderPass};
use winit::event::{Event, WindowEvent};
use winit::event_loop::{EventLoop, ControlFlow};

async fn run() {
    // 1. 创建视口管理器
    let mut viewport_manager = ViewportManager::new();
    
    // 2. 创建主窗口
    let main_window = viewport_manager.add_window(
        "Main Window",
        800,
        600,
        false
    );
    
    // 3. 在主窗口中添加两个视口
    let left_view = viewport_manager.add_viewport(
        main_window,
        re_viewport::ViewportDescriptor {
            x: 0.0,
            y: 0.0,
            width: 0.5,
            height: 1.0,
        },
    );
    
    let right_view = viewport_manager.add_viewport(
        main_window,
        re_viewport::ViewportDescriptor {
            x: 0.5,
            y: 0.0,
            width: 0.5,
            height: 1.0,
        },
    );
    
    // 4. 创建第二个窗口
    let second_window = viewport_manager.add_window(
        "Second Window",
        400,
        300,
        false
    );
    
    // 5. 初始化wgpu
    let (surface, adapter, device, queue) = setup_wgpu(&viewport_manager, main_window).await;
    
    // 6. 事件循环
    let event_loop = EventLoop::new();
    event_loop.run(move |event, _, control_flow| {
        *control_flow = ControlFlow::Wait;
        
        match event {
            Event::WindowEvent { event: WindowEvent::CloseRequested, .. } => {
                *control_flow = ControlFlow::Exit;
            }
            Event::MainEventsCleared => {
                // 处理视口管理器事件
                for event in viewport_manager.poll_events() {
                    match event {
                        re_viewport::ViewportEvent::WindowResized { window_id, width, height } => {
                            println!("Window {} resized to {}x{}", window_id, width, height);
                        }
                        _ => {}
                    }
                }
                
                // 渲染逻辑
                render_frame(&device, &queue, &surface, &viewport_manager);
            }
            _ => {}
        }
    });
}

async fn setup_wgpu(viewport_manager: &ViewportManager, window_id: re_viewport::WindowId) -> (Surface, Adapter, Device, Queue) {
    let window = viewport_manager.get_window(window_id).unwrap();
    
    // 创建wgpu实例
    let instance = Instance::new(wgpu::InstanceDescriptor {
        backends: wgpu::Backends::all(),
        ..Default::default()
    });
    
    // 创建表面
    let surface = unsafe { instance.create_surface(&window) }.unwrap();
    
    // 选择适配器和创建设备
    let adapter = instance.request_adapter(
        &wgpu::RequestAdapterOptions {
            power_preference: wgpu::PowerPreference::HighPerformance,
            compatible_surface: Some(&surface),
            force_fallback_adapter: false,
        },
    ).await.unwrap();
    
    let (device, queue) = adapter.request_device(
        &wgpu::DeviceDescriptor {
            features: wgpu::Features::empty(),
            limits: wgpu::Limits::default(),
            label: None,
        },
        None,
    ).await.unwrap();
    
    (surface, adapter, device, queue)
}

fn render_frame(device: &Device, queue: &Queue, surface: &Surface, viewport_manager: &ViewportManager) {
    // 获取当前帧
    let frame = surface.get_current_texture().unwrap();
    let view = frame.texture.create_view(&wgpu::TextureViewDescriptor::default());
    
    // 创建命令编码器
    let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
        label: Some("Render Encoder"),
    });
    
    {
        // 开始渲染通道
        let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
            label: Some("Render Pass"),
            color_attachments: &[Some(wgpu::RenderPassColorAttachment {
                view: &view,
                resolve_target: None,
                ops: wgpu::Operations {
                    load: wgpu::LoadOp::Clear(wgpu::Color::GREEN),
                    store: true,
                },
            })],
            depth_stencil_attachment: None,
        });
        
        // 在这里添加实际的渲染命令
        // 可以根据视口信息设置不同的渲染区域
        
        render_pass.end();
    }
    
    // 提交命令
    queue.submit(std::iter::once(encoder.finish()));
    frame.present();
}

fn main() {
    // 启动异步运行时并运行应用
    pollster::block_on(run());
}

示例说明

1. 视口管理器初始化：首先创建ViewportManager实例，用于管理所有窗口和视口。

2. 窗口创建：示例中创建了两个窗口，一个主窗口和一个副窗口。

3. 视口布局：在主窗口中设置了左右两个视口，各占50%宽度。

4. 图形API集成：使用wgpu进行渲染初始化，创建了表面、适配器、设备和命令队列。

5. 事件处理：处理窗口事件和渲染循环，响应窗口大小变化等事件。

6. 渲染流程：展示了基本的渲染流程，包括帧获取、命令编码和渲染通道设置。

注意事项

1. 确保在主线程上调用窗口管理相关函数
2. 处理窗口事件时要注意性能影响
3. 在多线程环境中使用时需要适当的同步
4. 视口坐标和尺寸是相对于窗口的归一化值(0-1)

这个完整示例展示了re_viewport库的核心功能，包括多窗口管理、视口布局和图形API集成，可以作为开发复杂图形应用的起点。