Merge pull request #186 from CMU-Graphics/spring2025

Fixed uv and normal import from mesh in manager.cpp

Author: lmhurley2003

src/geometry/halfedge-local - old.cpp

@@ -730,7 +730,13 @@ struct hash< std::pair< A, B > > {
 };
 }
 
-Halfedge_Mesh Halfedge_Mesh::from_indexed_faces(std::vector< Vec3 > const &vertices_, std::vector< std::vector< Index > > const &faces_) {
+Halfedge_Mesh Halfedge_Mesh::from_indexed_faces(std::vector< Vec3 > const &vertices_, 
+		std::vector< std::vector< Index > > const &faces_,
+		std::vector< std::vector< Index > > const &corner_normal_idxs,
+		std::vector< std::vector< Index > > const &corner_uv_idxs,
+		std::vector<Vec3> const &corner_normals_,
+		std::vector<Vec2> const &corner_uvs_)
+{
 
 	Halfedge_Mesh mesh;
 
@@ -744,8 +750,13 @@ Halfedge_Mesh Halfedge_Mesh::from_indexed_faces(std::vector< Vec3 > const &verti
 
 	std::unordered_map< std::pair< Index, Index >, HalfedgeRef > halfedges; //for quick lookup of halfedges by from/to vertex index
 
+	uint32_t num_faces = static_cast<uint32_t>(faces_.size());
+	const bool add_corner_normals = corner_normal_idxs.size() >= num_faces;
+	const bool add_corner_uvs = corner_uv_idxs.size() >= num_faces;
 	//helper to add a face (and, later, boundary):
-	auto add_loop = [&](std::vector< Index > const &loop, bool boundary) {
+	auto add_loop = [&](std::vector< Index > const &loop, bool boundary,
+					    std::vector< Index> const &n_loop = std::vector<Index>{}, 
+						std::vector< Index> const &uv_loop = std::vector<Index>{}) {
 		assert(loop.size() >= 3);
 
 		for (uint32_t j = 0; j < loop.size(); ++j) {
@@ -791,13 +802,19 @@ Halfedge_Mesh Halfedge_Mesh::from_indexed_faces(std::vector< Vec3 > const &verti
 
 			if (i != 0) prev->next = halfedge; //set previous halfedge's next pointer
 			prev = halfedge;
+
+			if(add_corner_normals && i < n_loop.size()) halfedge->corner_normal = corner_normals_[n_loop[i]];
+			if(add_corner_uvs && i < uv_loop.size()) halfedge->corner_uv = corner_uvs_[uv_loop[i]];
 		}
+
 		prev->next = face->halfedge; //set next pointer for last halfedge to first edge
 	};
 
 	//add all faces:
-	for (auto const &loop : faces_) {
-		add_loop(loop, false);
+	for (uint32_t i = 0; i < num_faces; i++) {
+		if(add_corner_normals && add_corner_uvs) add_loop(faces_[i], false, corner_normal_idxs[i], corner_uv_idxs[i]);
+		else if(add_corner_normals) add_loop(faces_[i], false, corner_normal_idxs[i]);
+		else add_loop(faces_[i], false);
 	}
 
 	// All halfedges created so far have valid next pointers, but some may be missing twins because they are at a boundary.
@@ -849,6 +866,49 @@ Halfedge_Mesh Halfedge_Mesh::from_indexed_faces(std::vector< Vec3 > const &verti
 	return mesh;
 }
 
+Halfedge_Mesh Halfedge_Mesh::from_indexed_mesh_with_corner_data(
+		const Indexed_Mesh& indexed_mesh, 
+		std::vector<Index> const &corner_normal_idxs_,  
+		std::vector<Index> const &corner_uv_idxs_,  
+		std::vector<Vec3> const &normals_,  
+		std::vector<Vec2> const &uvs_)
+{ 
+
+	//extract vertex positions and face indices from indexed_mesh:
+	std::vector< Vec3 > indexed_vertices;
+	indexed_vertices.reserve(indexed_mesh.vertices().size());
+	for (auto const &v : indexed_mesh.vertices()) {
+		indexed_vertices.emplace_back(v.pos);
+	}
+
+	std::vector< std::vector< Index > > indexed_faces;
+	assert(indexed_mesh.indices().size() % 3 == 0);
+	indexed_faces.reserve(indexed_mesh.indices().size() / 3);
+	for (uint32_t i = 0; i < indexed_mesh.indices().size(); i += 3) {
+		indexed_faces.emplace_back(indexed_mesh.indices().begin() + i, indexed_mesh.indices().begin() + i + 3);
+	}
+
+	std::vector< std::vector < Index > > indexed_normals;
+	assert(corner_normal_idxs_.size() % 3 == 0);
+	indexed_normals.reserve(corner_normal_idxs_.size() / 3);
+	for (uint32_t i = 0; i < corner_normal_idxs_.size(); i += 3) {
+		indexed_normals.emplace_back(corner_normal_idxs_.begin() + i, corner_normal_idxs_.begin() + i + 3);
+	}
+
+	std::vector< std::vector < Index > > indexed_uvs;
+	assert(corner_uv_idxs_.size() % 3 == 0);
+	indexed_uvs.reserve(corner_uv_idxs_.size() / 3);
+	for (uint32_t i = 0; i < corner_uv_idxs_.size(); i += 3) {
+		indexed_uvs.emplace_back(corner_uv_idxs_.begin() + i, corner_uv_idxs_.begin() + i + 3);
+	}
+
+	//build halfedge mesh with the extracted vertex/face data:
+	Halfedge_Mesh mesh = Halfedge_Mesh::from_indexed_faces(indexed_vertices, 
+			indexed_faces, indexed_normals, indexed_uvs, normals_, uvs_);
+
+	return mesh;
+}
+
 Halfedge_Mesh Halfedge_Mesh::from_indexed_mesh(Indexed_Mesh const &indexed_mesh) {
 
 	//extract vertex positions and face indices from indexed_mesh:

src/geometry/halfedge-utility.cpp

@@ -424,7 +424,19 @@ class Halfedge_Mesh {
 	// - mesh must correspond to a valid halfedge mesh (see 'validate()')
 	// - vertices and faces will match the order they appear in vertices[] and faces[], respectively
 	// - halfedges will match the order they are mentioned in faces[]
-	static Halfedge_Mesh from_indexed_faces(std::vector< Vec3 > const &vertices, std::vector< std::vector< Index > > const &faces);
+	//static Halfedge_Mesh from_indexed_faces(std::vector< Vec3 > const &vertices, std::vector< std::vector< Index > > const &faces);
+	static Halfedge_Mesh from_indexed_faces(std::vector< Vec3 > const &vertices, 
+		std::vector< std::vector< Index > > const &faces, 
+		std::vector< std::vector< Index > > const &corner_normal_idxs = std::vector< std::vector<Index>>{}, 
+		std::vector< std::vector< Index > > const &corner_uv_idxs = std::vector< std::vector<Index>>{}, 
+		std::vector<Vec3> const &normals = std::vector<Vec3>{}, 
+		std::vector<Vec2> const &uvs = std::vector<Vec2>{});
+	static Halfedge_Mesh from_indexed_mesh_with_corner_data(
+		const Indexed_Mesh& mesh,
+		std::vector<Index> const &corner_normal_idxs = std::vector<Index>{}, 
+		std::vector<Index> const &corner_uv_idxs = std::vector<Index>{}, 
+		std::vector<Vec3> const &normals = std::vector<Vec3>{}, 
+		std::vector<Vec2> const &uvs = std::vector<Vec2>{});
 	static Halfedge_Mesh from_indexed_mesh(const Indexed_Mesh& mesh);
 
 	//generate a cube:

src/geometry/halfedge.h

@@ -280,7 +280,10 @@ void Manager::to_s3d() {
 
     std::vector<Indexed_Mesh::Vert> verts;
     std::vector<Indexed_Mesh::Index> idxs;
+	std::vector<Indexed_Mesh::Index> n_idxs;
+	std::vector<Indexed_Mesh::Index> uv_idxs;
     std::vector<Vec3> normals;
+	std::vector<Vec2> uvs = std::vector<Vec2>{};
 
     // read in lines from file, assign verts and idxs
 	char *old_model_path = nullptr;
@@ -307,9 +310,20 @@ void Manager::to_s3d() {
             data >> x >> y >> z;
             normals.emplace_back(Vec3(x, y, z));
         }
+		else if (type == "vt") {
+    		float u, v;
+    		data >> u >> v;
+    		uvs.emplace_back(Vec2 {u, v});
+    	}
         else if (type == "f") {
             std::string token;
+
 			std::vector<uint32_t> f_idxs;
+			std::vector<uint32_t> f_uv_idxs = std::vector<uint32_t>{};
+			std::vector<uint32_t> f_n_idxs;
+
+			bool contains_uvs = false;
+			bool warned_once = false;
             while (data >> token) { // v/vt/vn pair
 				std::vector<std::string> v_data;
 				std::stringstream v_data_ss(token);
@@ -319,27 +333,53 @@ void Manager::to_s3d() {
 					v_data.push_back(substr);
 				}
 				uint32_t vi = static_cast<uint32_t>(std::stoi(v_data[0]));
-				// int vt = 0;
-				// try { 
-				// 	vt = std::stoi(v_data[1]); 
-				// } catch (std::exception e) {
-				// 	vt = 0;
-				// }
+				uint32_t vt = 0;
+				try { 
+					vt = std::stoi(v_data[1]);
+					f_uv_idxs.emplace_back(vt - 1);
+					contains_uvs = true; 
+				} catch (std::exception e) {
+					if(!warned_once) {
+						warn("Error loading imported obj uvs : %s", e.what());
+					}
+					warned_once = true;
+				}
+
 				uint32_t vn = static_cast<uint32_t>(std::stoi(v_data[2]));
+				f_n_idxs.emplace_back(vn - 1);
 				verts[vi - 1].norm = normals[vn - 1];
+				if(contains_uvs && vt + 1 < uvs.size()) {
+					verts[vi - 1].uv = uvs[vt - 1];
+				}
+
 				f_idxs.emplace_back(vi - 1);
             }
+
 			for (size_t i = 1; i + 1 < f_idxs.size(); i++) {
 				idxs.emplace_back(static_cast<Indexed_Mesh::Index>(f_idxs[0]));
 				idxs.emplace_back(static_cast<Indexed_Mesh::Index>(f_idxs[i]));
 				idxs.emplace_back(static_cast<Indexed_Mesh::Index>(f_idxs[i + 1]));
+				n_idxs.emplace_back(static_cast<Indexed_Mesh::Index>(f_n_idxs[0]));
+				n_idxs.emplace_back(static_cast<Indexed_Mesh::Index>(f_n_idxs[i]));
+				n_idxs.emplace_back(static_cast<Indexed_Mesh::Index>(f_n_idxs[i + 1]));
+				if(contains_uvs) {
+					uv_idxs.emplace_back(static_cast<Indexed_Mesh::Index>(f_uv_idxs[0]));
+					uv_idxs.emplace_back(static_cast<Indexed_Mesh::Index>(f_uv_idxs[i]));
+					uv_idxs.emplace_back(static_cast<Indexed_Mesh::Index>(f_uv_idxs[i + 1]));
+				}
 			}
         }
     }
 
     // verts and idxs -> index mesh -> halfedge mesh
     Indexed_Mesh idx_mesh(std::move(verts), std::move(idxs));
-    Halfedge_Mesh he_mesh = Halfedge_Mesh::from_indexed_mesh(idx_mesh);
+	//if(uv_idxs.size() >= idxs.size()) {
+	Halfedge_Mesh he_mesh = Halfedge_Mesh::from_indexed_mesh_with_corner_data(idx_mesh, 
+								std::move(n_idxs), std::move(uv_idxs), std::move(normals),
+								std::move(uvs));
+	//} else {
+	//	he_mesh = Halfedge_Mesh::from_indexed_mesh(idx_mesh);
+	//}
 	Halfedge_Mesh skinned_mesh_data = Halfedge_Mesh::from_indexed_mesh(idx_mesh);
 	Skinned_Mesh skinned_mesh;
 	skinned_mesh.mesh = std::move(skinned_mesh_data);

src/gui/manager.cpp

@@ -0,0 +1,60 @@
+#include "framebuffer.h"
+#include "../util/hdr_image.h"
+#include "sample_pattern.h"
+
+Framebuffer::Framebuffer(uint32_t width_, uint32_t height_, SamplePattern const& sample_pattern_)
+	: width(width_), height(height_), sample_pattern(sample_pattern_) {
+
+	// check that framebuffer isn't larger than allowed:
+	if (width > MaxWidth || height > MaxHeight) {
+		throw std::runtime_error("Framebuffer size (" + std::to_string(width) + "x" +
+		                         std::to_string(height) + ") exceeds maximum allowed (" +
+		                         std::to_string(MaxWidth) + "x" + std::to_string(MaxHeight) + ").");
+	}
+	// check that framebuffer size is even:
+	if (width % 2 != 0 || height % 2 != 0) {
+		throw std::runtime_error("Framebuffer size (" + std::to_string(width) + "x" +
+		                         std::to_string(height) + ") is not even.");
+	}
+
+	uint32_t samples =
+		width * height * static_cast<uint32_t>(sample_pattern.centers_and_weights.size());
+
+	// allocate storage for color and depth samples:
+	colors.assign(samples, Spectrum{0.0f, 0.0f, 0.0f});
+	depths.assign(samples, 1.0f);
+}
+
+HDR_Image Framebuffer::resolve_colors() const {
+#ifdef STUDENT_CODE_A1T7
+	// A1T7: resolve_colors
+	// TODO: update to support sample patterns with more than one sample.
+
+	HDR_Image image(width, height);
+
+	for (uint32_t y = 0; y < height; ++y) {
+		for (uint32_t x = 0; x < width; ++x) {
+			image.at(x, y) = color_at(x, y, 0);
+		}
+	}
+
+	return image;
+#else
+	// A1T7: resolve_colors -- reference code!
+
+	HDR_Image image(width, height);
+	std::vector<Vec3> const& cw = sample_pattern.centers_and_weights;
+
+	for (uint32_t y = 0; y < height; ++y) {
+		for (uint32_t x = 0; x < width; ++x) {
+			Spectrum acc = cw[0].z * color_at(x, y, 0);
+			for (uint32_t s = 1; s < cw.size(); ++s) {
+				acc += cw[s].z * color_at(x, y, s);
+			}
+			image.at(x, y) = acc;
+		}
+	}
+
+	return image;
+#endif
+}

src/rasterizer/framebufferBase.cpp

@@ -0,0 +1,59 @@
+#pragma once
+
+#include <vector>
+
+#include "../lib/spectrum.h"
+
+class HDR_Image;
+struct SamplePattern;
+
+struct Framebuffer {
+	static constexpr uint32_t MaxWidth = 4096;
+	static constexpr uint32_t MaxHeight = 4096;
+
+	// Construct a new framebuffer:
+	//  width must be <= MaxWidth
+	//  height must be <= MaxHeight
+	//  both width and height must be even
+	// these restrictions exist because:
+	//  - having a limited size makes it easier to write rasterization functions with fixed-point
+	//    math (if you want)
+	//  - having an even size avoids some corner cases if you choose to rasterize with quadfrags
+	Framebuffer(uint32_t width, uint32_t height, SamplePattern const& sample_pattern);
+
+	const uint32_t width, height;
+	SamplePattern const& sample_pattern;
+
+	// storage for color and depth samples:
+	std::vector<Spectrum> colors;
+	std::vector<float> depths;
+
+	// return storage index for sample s of pixel (x,y):
+	uint32_t index(uint32_t x, uint32_t y, uint32_t s) const {
+#ifdef STUDENT_CODE_A1T7
+		// A1T7: index
+		// TODO: update to provide different storage locations for different samples
+		return y * width + x;
+#else
+		// A1T7: index -- reference code
+		return (s * height + y) * width + x;
+#endif
+	}
+
+	// helpers that look up colors and depths for sample s of pixel (x,y):
+	Spectrum& color_at(uint32_t x, uint32_t y, uint32_t s) {
+		return colors[index(x, y, s)];
+	}
+	Spectrum const& color_at(uint32_t x, uint32_t y, uint32_t s) const {
+		return colors[index(x, y, s)];
+	}
+	float& depth_at(uint32_t x, uint32_t y, uint32_t s) {
+		return depths[index(x, y, s)];
+	}
+	float const& depth_at(uint32_t x, uint32_t y, uint32_t s) const {
+		return depths[index(x, y, s)];
+	}
+
+	// resolve_colors creates a weighted average of the color samples:
+	HDR_Image resolve_colors() const;
+};