Why do we choose the "bounding box" method to fill a triangle? - c++

Question

I'm learning a short course "How OpenGL works: software rendering in 500 lines of code" on GitHub. In lesson 2, the author is teaching us how to fill a triangle with color. He comes up with two methods:
Enumerate all the horizontal segments within the triangle, and draw these segments. The author's code is as follows.
void triangle(Vec2i t0, Vec2i t1, Vec2i t2, TGAImage &image, TGAColor color) {
if (t0.y==t1.y && t0.y==t2.y) return; // I dont care about degenerate triangles
// sort the vertices, t0, t1, t2 lower−to−upper (bubblesort yay!)
if (t0.y>t1.y) std::swap(t0, t1);
if (t0.y>t2.y) std::swap(t0, t2);
if (t1.y>t2.y) std::swap(t1, t2);
int total_height = t2.y-t0.y;
for (int i=0; i<total_height; i++) {
bool second_half = i>t1.y-t0.y || t1.y==t0.y;
int segment_height = second_half ? t2.y-t1.y : t1.y-t0.y;
float alpha = (float)i/total_height;
float beta = (float)(i-(second_half ? t1.y-t0.y : 0))/segment_height; // be careful: with above conditions no division by zero here
Vec2i A = t0 + (t2-t0)*alpha;
Vec2i B = second_half ? t1 + (t2-t1)*beta : t0 + (t1-t0)*beta;
if (A.x>B.x) std::swap(A, B);
for (int j=A.x; j<=B.x; j++) {
image.set(j, t0.y+i, color); // attention, due to int casts t0.y+i != A.y
}
}
}
Find the bounding box of the triangle. Enumerate all the points in the bounding box, and use barycentric coordinates to check if the point is within the triangle. If the point is in the triangle, then fill the point with color. The author's code is as follows.
Vec3f barycentric(Vec2i *pts, Vec2i P) {
Vec3f u = cross(Vec3f(pts[2][0]-pts[0][0], pts[1][0]-pts[0][0], pts[0][0]-P[0]), Vec3f(pts[2][1]-pts[0][1], pts[1][1]-pts[0][1], pts[0][1]-P[1]));
if (std::abs(u[2])<1) return Vec3f(-1,1,1); // triangle is degenerate, in this case return smth with negative coordinates
return Vec3f(1.f-(u.x+u.y)/u.z, u.y/u.z, u.x/u.z);
}
void triangle(Vec2i *pts, TGAImage &image, TGAColor color) {
Vec2i bboxmin(image.get_width()-1, image.get_height()-1);
Vec2i bboxmax(0, 0);
Vec2i clamp(image.get_width()-1, image.get_height()-1);
for (int i=0; i<3; i++) {
for (int j=0; j<2; j++) {
bboxmin[j] = std::max(0, std::min(bboxmin[j], pts[i][j]));
bboxmax[j] = std::min(clamp[j], std::max(bboxmax[j], pts[i][j]));
}
}
Vec2i P;
for (P.x=bboxmin.x; P.x<=bboxmax.x; P.x++) {
for (P.y=bboxmin.y; P.y<=bboxmax.y; P.y++) {
Vec3f bc_screen = barycentric(pts, P);
if (bc_screen.x<0 || bc_screen.y<0 || bc_screen.z<0) continue;
image.set(P.x, P.y, color);
}
}
}
The author chooses the second method at the end of lesson 2, but I can't understand why. Is the reason something about efficiency, or it is just because the second method is easier to understand?

Answer 1

Barycentric coordinates are used to interpolate or "smear" values at each vertex of the triangle across the triangle. For example: if I define a triangle ABC, I can give each vertex a color, Red, Green, and Blue respectively. Then as I fill out the triangle, I can use the barycentric coordinates (alpha, beta, gamma) to get a linear combination P = alpha * Red + beta * Blue + gamma * Green to determine what the color at a point inside the triangle should be.
This process is highly optimized and built into GPU hardware. You can smear any values you'd like, including normal vectors (which is often used in per-pixel lighting computations), so it is a very useful operation.
Of course, I have no idea what your teacher is thinking, but I'd hazard to guess that in a future lesson they might talk about that so the second algorithm naturally leads into that discussion.
Source: https://www.scratchapixel.com/lessons/3d-basic-rendering/ray-tracing-rendering-a-triangle/barycentric-coordinates