render-zig

load_obj.zig (6325B)

---

 const std = @import("std");
 const gpu = @import("mach_gpu");
 
 const Mesh = @import("mesh.zig");
 
 const f32x2 = @Vector(2, f32);
 const f32x3 = @Vector(3, f32);
 const f32x4 = @Vector(4, f32);
 
 fn parsePosition(line: []u8) !f32x4 {
     var iter = std.mem.tokenize(u8, line[2..], " ");
     var position = f32x4{ 0, 0, 0, 1 };
     var idx: u32 = 0;
     while (iter.next()) |part| : (idx += 1) {
         if (idx >= 4) {
             return error.InvalidFormat;
         }
         position[idx] = try std.fmt.parseFloat(f32, part);
     }
     if (idx < 3) {
         return error.InvalidFormat;
     }
     return position;
 }
 
 fn parseNormal(line: []u8) !f32x3 {
     var iter = std.mem.tokenize(u8, line[3..], " ");
     var normal = f32x3{ 0, 0, 0 };
     var idx: u32 = 0;
     while (iter.next()) |part| : (idx += 1) {
         if (idx >= 3) {
             return error.InvalidFormat;
         }
         normal[idx] = try std.fmt.parseFloat(f32, part);
     }
     if (idx < 3) {
         return error.InvalidFormat;
     }
     return normal;
 }
 
 fn parseTexCoord(line: []u8) !f32x3 {
     var iter = std.mem.tokenize(u8, line[3..], " ");
     var tex_coord = f32x3{ 0, 0, 0 };
     var idx: u32 = 0;
     while (iter.next()) |part| : (idx += 1) {
         if (idx >= 3) {
             return error.InvalidFormat;
         }
         tex_coord[idx] = try std.fmt.parseFloat(f32, part);
     }
     if (idx < 1) {
         return error.InvalidFormat;
     }
     return tex_coord;
 }
 
 const Vertex = struct {
     position: u32 = 0,
     tex_coord: ?u32 = null,
     normal: ?u32 = null,
 };
 
 fn parseFace(line: []u8) ![3]Vertex {
     var iter = std.mem.tokenize(u8, line[2..], " ");
     var vertices = [3]Vertex{ .{}, .{}, .{} };
     var idx: u32 = 0;
 
     while (iter.next()) |part| : (idx += 1) {
         if (idx >= 3) {
             return error.InvalidFormat;
         }
         const vertex = try parseVertex(part);
         vertices[idx] = vertex;
     }
     if (idx < 3) {
         return error.InvalidFormat;
     }
     return vertices;
 }
 
 fn parseVertex(line: []const u8) !Vertex {
     var iter = std.mem.split(u8, line, "/");
     var vertex = Vertex{
         .position = 0,
         .tex_coord = null,
         .normal = null,
     };
     var idx: u32 = 0;
     while (iter.next()) |part| : (idx += 1) {
         switch (idx) {
             0 => vertex.position = (try std.fmt.parseInt(u32, part, 10)) - 1,
             1 => vertex.tex_coord = if (!std.mem.eql(u8, part, "")) (try std.fmt.parseInt(u32, part, 10)) - 1 else null,
             2 => vertex.normal = if (!std.mem.eql(u8, part, "")) (try std.fmt.parseInt(u32, part, 10)) - 1 else null,
             else => return error.InvalidFormat,
         }
     }
     return vertex;
 }
 
 pub const LoadFileOptions = struct {
     allocator: std.mem.Allocator,
     path: []const u8,
 };
 
 pub fn loadFile(options: LoadFileOptions) !Mesh {
     const allocator = options.allocator;
     const path = options.path;
 
     var file = try std.fs.cwd().openFile(path, .{ .mode = .read_only });
     defer file.close();
 
     var reader = std.io.bufferedReader(file.reader());
     var stream = reader.reader();
 
     var positions = std.ArrayList(f32x4).init(allocator);
     defer positions.deinit();
     var normals = std.ArrayList(f32x3).init(allocator);
     defer normals.deinit();
     var tex_coords = std.ArrayList(f32x3).init(allocator);
     defer tex_coords.deinit();
     var vertices = std.AutoArrayHashMap(Vertex, u32).init(allocator);
     var indices = std.ArrayList(u32).init(allocator);
 
     var buf: [256]u8 = undefined;
     var vtx_idx: u32 = 0;
     while (try stream.readUntilDelimiterOrEof(&buf, '\n')) |line| {
         if (std.mem.startsWith(u8, line, "v ")) {
             try positions.append(try parsePosition(line));
         } else if (std.mem.startsWith(u8, line, "vt ")) {
             try tex_coords.append(try parseTexCoord(line));
         } else if (std.mem.startsWith(u8, line, "vn ")) {
             try normals.append(try parseNormal(line));
         } else if (std.mem.startsWith(u8, line, "f ")) {
             const face = try parseFace(line);
             for (face) |vertex| {
                 const entry = try vertices.getOrPutValue(vertex, vtx_idx);
                 try indices.append(entry.value_ptr.*);
                 if (!entry.found_existing) {
                     vtx_idx += 1;
                 }
             }
         } else {
             std.log.info("UNRECOGNIZED: {s}", .{line});
         }
     }
 
     std.log.info("NUM POSITIONS: {}", .{positions.items.len});
     std.log.info("NUM NORMALS: {}", .{normals.items.len});
     std.log.info("NUM TEXCOORDS: {}", .{tex_coords.items.len});
     std.log.info("NUM VERTICES: {}", .{vertices.count()});
 
     var positions_indexed = std.ArrayList(f32x4).init(allocator);
     defer positions_indexed.deinit();
     var normals_indexed = std.ArrayList(f32x3).init(allocator);
     defer normals_indexed.deinit();
     var tex_coords_indexed = std.ArrayList(f32x3).init(allocator);
     defer tex_coords_indexed.deinit();
 
     var vtx_iter = vertices.iterator();
     while (vtx_iter.next()) |entry| {
         const vtx = entry.key_ptr;
 
         const position = positions.items[vtx.position];
         try positions_indexed.append(position);
 
         if (vtx.normal != null) {
             const normal = normals.items[vtx.normal.?];
             try normals_indexed.append(normal);
         }
 
         if (vtx.tex_coord != null) {
             const tex_coord = tex_coords.items[vtx.tex_coord.?];
             try tex_coords_indexed.append(tex_coord);
         }
     }
 
     std.log.info("NUM POSITIONS: {}", .{positions_indexed.items.len});
     std.log.info("NUM NORMALS: {}", .{normals_indexed.items.len});
     std.log.info("NUM TEXCOORDS: {}", .{tex_coords_indexed.items.len});
 
     const pslice = try positions_indexed.toOwnedSlice();
     const nslice = try normals_indexed.toOwnedSlice();
     const tslice = try tex_coords_indexed.toOwnedSlice();
     const islice = try indices.toOwnedSlice();
     var mesh = Mesh{
         .positions = pslice,
         .normals = nslice,
         .tex_coords = tslice,
         .indices = islice,
         .tangents = try allocator.alloc(f32x3, pslice.len),
         .bitangents = try allocator.alloc(f32x3, pslice.len),
     };
     mesh.bbox = mesh.axisAlignedBoundingBox();
     try mesh.tangentsAndBitangents(allocator);
 
     return mesh;
 }