refactor: encapsulate MeshOutput buffers

crates/urath-core/src/mesh_output.rs

@@ -5,18 +5,18 @@
 /// without deallocating.
 pub struct MeshOutput {
     /// Vertex positions — 3 floats (x, y, z) per vertex.
-    pub positions: Vec<f32>,
+    pub(crate) positions: Vec<f32>,
     /// Vertex normals — 3 floats (nx, ny, nz) per vertex.
-    pub normals: Vec<f32>,
+    pub(crate) normals: Vec<f32>,
     /// Ambient occlusion — 1 float per vertex, range [0.0, 1.0] where 1.0 = fully lit.
-    pub ao: Vec<f32>,
+    pub(crate) ao: Vec<f32>,
     /// Block ID per vertex — used for texture lookup.
-    pub block_ids: Vec<u16>,
+    pub(crate) block_ids: Vec<u16>,
     /// Texture coordinates — 2 floats (u, v) per vertex.
     /// For greedy-merged quads, UVs tile: a W×H quad gets UVs spanning [0,W]×[0,H].
-    pub uvs: Vec<f32>,
+    pub(crate) uvs: Vec<f32>,
     /// Triangle indices.
-    pub indices: Vec<u32>,
+    pub(crate) indices: Vec<u32>,
     /// Current number of vertices.
     vertex_count: u32,
 }
@@ -80,6 +80,42 @@ impl MeshOutput {
         self.vertex_count == 0
     }
 
+    /// Vertex positions as a slice — 3 floats (x, y, z) per vertex.
+    #[inline]
+    pub fn positions(&self) -> &[f32] {
+        &self.positions
+    }
+
+    /// Vertex normals as a slice — 3 floats (nx, ny, nz) per vertex.
+    #[inline]
+    pub fn normals(&self) -> &[f32] {
+        &self.normals
+    }
+
+    /// Ambient occlusion values as a slice — 1 float per vertex.
+    #[inline]
+    pub fn ao(&self) -> &[f32] {
+        &self.ao
+    }
+
+    /// Block IDs as a slice — 1 u16 per vertex.
+    #[inline]
+    pub fn block_ids(&self) -> &[u16] {
+        &self.block_ids
+    }
+
+    /// UV coordinates as a slice — 2 floats (u, v) per vertex.
+    #[inline]
+    pub fn uvs(&self) -> &[f32] {
+        &self.uvs
+    }
+
+    /// Triangle indices as a slice.
+    #[inline]
+    pub fn indices(&self) -> &[u32] {
+        &self.indices
+    }
+
     /// Append a quad (4 vertices, 6 indices / 2 triangles).
     ///
     /// Vertices are ordered: `[v0, v1, v2, v3]` forming a quad where

crates/urath-wasm/src/lib.rs

@@ -182,33 +182,38 @@ impl WasmMeshResult {
 
     /// Opaque positions (Float32Array, 3 floats per vertex).
     pub fn positions(&self) -> js_sys::Float32Array {
-        js_sys::Float32Array::from(&self.opaque.positions[..])
+        js_sys::Float32Array::from(self.opaque.positions())
     }
 
     /// Opaque normals (Float32Array, 3 floats per vertex).
     pub fn normals(&self) -> js_sys::Float32Array {
-        js_sys::Float32Array::from(&self.opaque.normals[..])
+        js_sys::Float32Array::from(self.opaque.normals())
     }
 
     /// Opaque AO values (Float32Array, 1 float per vertex).
     pub fn ao(&self) -> js_sys::Float32Array {
-        js_sys::Float32Array::from(&self.opaque.ao[..])
+        js_sys::Float32Array::from(self.opaque.ao())
     }
 
     /// Opaque block IDs (Float32Array, cast from u16).
     pub fn block_ids(&self) -> js_sys::Float32Array {
-        let f32_vec: Vec<f32> = self.opaque.block_ids.iter().map(|&id| id as f32).collect();
+        let f32_vec: Vec<f32> = self
+            .opaque
+            .block_ids()
+            .iter()
+            .map(|&id| id as f32)
+            .collect();
         js_sys::Float32Array::from(&f32_vec[..])
     }
 
     /// Opaque UV coordinates (Float32Array, 2 floats per vertex).
     pub fn uvs(&self) -> js_sys::Float32Array {
-        js_sys::Float32Array::from(&self.opaque.uvs[..])
+        js_sys::Float32Array::from(self.opaque.uvs())
     }
 
     /// Opaque indices (Uint32Array).
     pub fn indices(&self) -> js_sys::Uint32Array {
-        js_sys::Uint32Array::from(&self.opaque.indices[..])
+        js_sys::Uint32Array::from(self.opaque.indices())
     }
 
     // --- Transparent mesh accessors ---
@@ -230,24 +235,24 @@ impl WasmMeshResult {
 
     /// Transparent positions (Float32Array, 3 floats per vertex).
     pub fn transparent_positions(&self) -> js_sys::Float32Array {
-        js_sys::Float32Array::from(&self.transparent.positions[..])
+        js_sys::Float32Array::from(self.transparent.positions())
     }
 
     /// Transparent normals (Float32Array, 3 floats per vertex).
     pub fn transparent_normals(&self) -> js_sys::Float32Array {
-        js_sys::Float32Array::from(&self.transparent.normals[..])
+        js_sys::Float32Array::from(self.transparent.normals())
     }
 
     /// Transparent AO values (Float32Array, 1 float per vertex).
     pub fn transparent_ao(&self) -> js_sys::Float32Array {
-        js_sys::Float32Array::from(&self.transparent.ao[..])
+        js_sys::Float32Array::from(self.transparent.ao())
     }
 
     /// Transparent block IDs (Float32Array, cast from u16).
     pub fn transparent_block_ids(&self) -> js_sys::Float32Array {
         let f32_vec: Vec<f32> = self
             .transparent
-            .block_ids
+            .block_ids()
             .iter()
             .map(|&id| id as f32)
             .collect();
@@ -256,12 +261,12 @@ impl WasmMeshResult {
 
     /// Transparent UV coordinates (Float32Array, 2 floats per vertex).
     pub fn transparent_uvs(&self) -> js_sys::Float32Array {
-        js_sys::Float32Array::from(&self.transparent.uvs[..])
+        js_sys::Float32Array::from(self.transparent.uvs())
     }
 
     /// Transparent indices (Uint32Array).
     pub fn transparent_indices(&self) -> js_sys::Uint32Array {
-        js_sys::Uint32Array::from(&self.transparent.indices[..])
+        js_sys::Uint32Array::from(self.transparent.indices())
     }
 }