Some super minor tweaks to loading

- Since Rust 1.76, use offset_of! macro from std lib
- Update comments and control-flow formatting in 'lines_escaped'
- Make 'trim_line_comment' a general-purpose function in preparation for
  parsing different types of model files

Author: matthew-e-brown

gloog/src/loader/mod.rs

@@ -26,38 +26,35 @@ fn lines_escaped<R: BufRead>(reader: R) -> impl Iterator<Item = io::Result<(Line
         let mut processed: Option<String> = None;
 
         let escaped_line = loop {
-            raw_line_num += 1; // Fine to increment first; line numbers start at 1.
+            raw_line_num += 1; // Fine to increment before grabbing from `raw_lines` iterator; line numbers start at 1.
 
             let raw_line = match raw_lines.next() {
+                // Next line in file is just regular text.
                 Some(Ok(text)) => text,
-                // If we hit an error, short-circuit this function. Can be caught by the consumer.
+                // Failed to read next line; throw the error up to the consumer.
                 Some(Err(err)) => return Some(Err(err)),
-                None => {
-                    // If the last line of the file has a backslash on it, we might run out of lines while we're
-                    // currently holding onto processed line(s). We
-                    match processed {
-                        Some(text) => break text,
-                        None => return None,
-                    };
-                },
+                // There are no more lines in the file. If `processed` is still Some, that means that the previous line
+                // ended with a backslash, and so we _should_ have found another line here. Otherwise, we can just
+                // return `None` and stop iteration.
+                None if processed.is_some() => return Some(Err(io::ErrorKind::UnexpectedEof.into())),
+                None => return None,
             };
 
-            // If we have any processed text currently pending, append this line. Otherwise, our new pending text is
-            // just the freshly read value on its own.
+            // If we have any processed text currently pending, append this line to it. Otherwise, our new pending text
+            // is just the freshly read value on its own.
             let mut pending = match processed {
                 Some(prev) => prev + &raw_line,
                 None => raw_line,
             };
 
-            // Then, check if the newly appended-to
+            // If our collection of lines still ends with a backslash, trim it off and keep looping.
             if pending.ends_with('\\') {
-                // If our escaped text still ends with a backslash, trim off that backslash and keep looping. We are
-                // safe to truncate by -1 because we now the last character is a plain ASCII backslash.
+                // Safe to truncate by 1 byte since we know the last character is a plain ASCII backslash
                 pending.truncate(pending.len() - 1);
                 processed = Some(pending);
                 num_escaped += 1;
             } else {
-                // Otherwise, what we've got is the current line.
+                // Otherwise, what we've got is the final line.
                 break pending;
             }
         };
@@ -70,6 +67,15 @@ fn lines_escaped<R: BufRead>(reader: R) -> impl Iterator<Item = io::Result<(Line
 }
 
 
+/// Grab everything in a line up to the first line-comment character(s). Also trims the start and end of the string.
+fn trim_line_comment<'a>(line: &'a str, comment: &str) -> &'a str {
+    match line.find(comment) {
+        Some(i) => line[0..i].trim(),
+        None => line[0..].trim(),
+    }
+}
+
+
 /// Formats a range of line numbers as either `line N` or `lines N to M` if the range is longer than one line.
 fn fmt_line_range(range: &LineRange) -> String {
     // Range is exclusive, hence - 1

gloog/src/loader/obj/mod.rs

@@ -30,7 +30,7 @@ use log::{debug, info, log, trace};
 
 use self::error::{ObjLoadError, ObjResult};
 use crate::loader::obj::mtl::parse_mtl_file;
-use crate::loader::{lines_escaped, LineRange};
+use crate::loader::{lines_escaped, trim_line_comment, LineRange};
 
 
 // cspell:words curv interp stech ctech scrv cstype bmat newmtl usemtl mtllib maplib usemap
@@ -125,22 +125,11 @@ pub struct ObjVertex {
     tex_coord: Vec2,
 }
 
-macro_rules! vertex_offset {
-    ($field:ident) => {{
-        // We don't really need to care if the memory we're getting pointers to has been initialized properly, so we
-        // just allocate some zeroes.
-        let vert = unsafe { std::mem::MaybeUninit::<ObjVertex>::zeroed().assume_init() };
-        let base = std::ptr::addr_of!(vert) as *const u8;
-        let field = std::ptr::addr_of!(vert.$field) as *const u8;
-        unsafe { field.offset_from(base) as usize }
-    }};
-}
-
 impl ObjVertex {
     pub const STRIDE: isize = std::mem::size_of::<ObjVertex>() as isize;
-    pub const OFFSET_POSITION: usize = vertex_offset!(position);
-    pub const OFFSET_TEX_COORD: usize = vertex_offset!(tex_coord);
-    pub const OFFSET_NORMAL: usize = vertex_offset!(normal);
+    pub const OFFSET_POSITION: usize = std::mem::offset_of!(ObjVertex, position);
+    pub const OFFSET_TEX_COORD: usize = std::mem::offset_of!(ObjVertex, tex_coord);
+    pub const OFFSET_NORMAL: usize = std::mem::offset_of!(ObjVertex, normal);
 }
 
 /// Used to configure uniforms before executing draw call.
@@ -195,14 +184,6 @@ impl Debug for ObjMaterial {
 }
 
 
-/// Grab everything in a line up to the first `#` (and also trim the starts and ends).
-fn trim_comment(line: &str) -> &str {
-    match line.find('#') {
-        Some(i) => line[0..i].trim(),
-        None => line[0..].trim(),
-    }
-}
-
 impl ObjModel {
     pub fn from_file(
         path: impl AsRef<Path>,
@@ -239,7 +220,7 @@ impl ObjModel {
 
         for line_result in lines_escaped(file) {
             let (line_nums, line) = line_result?;
-            let line = trim_comment(&line);
+            let line = trim_line_comment(&line, "#");
 
             // If our line is empty after removing the comment, we can ignore it
             if line.len() == 0 {

gloog/src/loader/obj/mtl.rs

@@ -10,8 +10,8 @@ use image::ImageResult;
 use log::{debug, info, warn};
 
 use super::error::{MtlLoadError, MtlResult};
-use super::{read_ws_verts, trim_comment, CachedImage, ObjMaterial};
-use crate::loader::{lines_escaped, LineRange};
+use super::{read_ws_verts, CachedImage, ObjMaterial};
+use crate::loader::{lines_escaped, trim_line_comment, LineRange};
 
 // cspell:words newmtl usemtl
 
@@ -49,7 +49,7 @@ pub fn parse_mtl_file(
                 Err(err) => return Err(MtlLoadError::IOReadError(err)),
             };
 
-            let line = trim_comment(&line);
+            let line = trim_line_comment(&line, "#");
             if line.len() == 0 {
                 continue;
             }