Jérôme Bousquié
d81743481b
- Wrap in backticks every bare type in rustdoc comments (vertex.rs, frame.rs, pipeline_cache.rs, material.rs, mesh.rs, scene.rs, error.rs) so rustdoc no longer misreads them as intra-doc links or HTML tags. - Add a missing doc comment on the public Frame struct. - Add #![warn(missing_docs)] to the crate root so unevidenced public items are surfaced going forward. cargo doc --no-deps now generates with zero warnings.
62 lines
3.1 KiB
Rust
62 lines
3.1 KiB
Rust
//! # Mesh Module — Persistent GPU Geometry Container
|
|
//!
|
|
//! Defines `Mesh`, a persistent GPU geometry container. Mesh data is uploaded to the GPU once at creation time
|
|
//! and remains valid across all frames until dropped. It holds no rendering knowledge—only raw geometric data.
|
|
//!
|
|
//! ## Architecture Notes (per ARCHI_APP.md)
|
|
//! - **Identifiants**: Each Mesh is registered in Scene by string identifier, enabling dynamic access
|
|
//! during the render loop without borrow checker issues. The identifier serves as the `Handle<T>` key.
|
|
//! - **Phase de Déclaration**: Meshes are instantiated once in the declarative phase before the render loop begins.
|
|
//! - **Performance**: Multiple entities can reference the same Mesh, reducing memory footprint for repeated geometry.
|
|
|
|
use crate::resources::vertex::Vertex;
|
|
use wgpu::util::DeviceExt;
|
|
|
|
/// Persistent GPU geometry: vertex positions, optional indices, and draw call counters.
|
|
/// Created once via `Mesh::new()` during scene setup; referenced by Renderer for every frame.
|
|
pub struct Mesh {
|
|
/// GPU buffer containing vertex attribute data (position, UV, color).
|
|
pub vertex_buffer: wgpu::Buffer,
|
|
/// Optional GPU buffer for indexed drawing. Present when the mesh uses index-based rendering instead of simple vertex iteration.
|
|
pub index_buffer: Option<wgpu::Buffer>,
|
|
/// Number of vertices in the mesh. Used as `0..num_vertices` for non-indexed draws.
|
|
pub num_vertices: u32,
|
|
/// Number of indices in the index buffer. Used as `0..num_indices` for indexed draws.
|
|
pub num_indices: u32,
|
|
}
|
|
|
|
impl Mesh {
|
|
/// Creates a new Mesh by uploading vertex and optional index data to GPU buffers.
|
|
/// Inputs: device (GPU command source for buffer creation), vertices (CPU-side vertex array to upload),
|
|
/// indices (optional CPU-side index array for indexed drawing).
|
|
/// Returns a Mesh with two GPU buffers ready for rendering. Called at scene initialization time only.
|
|
/// Internal steps: 1) create_buffer_init for vertex data →
|
|
/// 2) if indices provided: create_buffer_init for index data and set num_indices = len →
|
|
/// else: set index_buffer = None and num_indices = 0.
|
|
pub fn new(device: &wgpu::Device, vertices: &[Vertex], indices: Option<&[u16]>) -> Self {
|
|
let vertex_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
|
|
label: Some("Mesh Vertex Buffer"),
|
|
contents: bytemuck::cast_slice(vertices),
|
|
usage: wgpu::BufferUsages::VERTEX,
|
|
});
|
|
|
|
// Create optional index buffer and count indices if provided
|
|
let (index_buffer, num_indices) = if let Some(data) = indices {
|
|
let buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
|
|
label: Some("Mesh Index Buffer"),
|
|
usage: wgpu::BufferUsages::INDEX,
|
|
contents: bytemuck::cast_slice(data),
|
|
});
|
|
(Some(buffer), data.len() as u32)
|
|
} else {
|
|
(None, 0)
|
|
};
|
|
Self {
|
|
vertex_buffer,
|
|
index_buffer,
|
|
num_vertices: vertices.len() as u32,
|
|
num_indices,
|
|
}
|
|
}
|
|
}
|