working z-buffer

Author: ssloy

main.cpp

@@ -2,86 +2,91 @@
 #include <cmath>
 #include <limits>
 #include "tgaimage.h"
+#include "model.h"
 #include "geometry.h"
 
-const TGAColor white = TGAColor(255, 255, 255, 255);
-const TGAColor red   = TGAColor(255, 0,   0,   255);
-const TGAColor green = TGAColor(0,   255, 0,   255);
-const TGAColor blue  = TGAColor(0,   0,   255, 255);
 const int width  = 800;
-const int height = 500;
+const int height = 800;
+const int depth  = 255;
 
-void line(Vec2i p0, Vec2i p1, TGAImage &image, TGAColor color) {
-    bool steep = false;
-    if (std::abs(p0.x-p1.x)<std::abs(p0.y-p1.y)) {
-        std::swap(p0.x, p0.y);
-        std::swap(p1.x, p1.y);
-        steep = true;
-    }
-    if (p0.x>p1.x) {
-        std::swap(p0, p1);
-    }
-
-    for (int x=p0.x; x<=p1.x; x++) {
-        float t = (x-p0.x)/(float)(p1.x-p0.x);
-        int y = p0.y*(1.-t) + p1.y*t + .5;
-        if (steep) {
-            image.set(y, x, color);
-        } else {
-            image.set(x, y, color);
-        }
-    }
-}
+Model *model = NULL;
+int *zbuffer = NULL;
+Vec3f light_dir(0,0,-1);
 
-void rasterize(Vec2i p0, Vec2i p1, TGAImage &image, TGAColor color, int ybuffer[]) {
-    if (p0.x>p1.x) {
-        std::swap(p0, p1);
-    }
-    for (int x=p0.x; x<=p1.x; x++) {
-        float t = (x-p0.x)/(float)(p1.x-p0.x);
-        int y = p0.y*(1.-t) + p1.y*t + .5;
-        if (ybuffer[x]<y) {
-            ybuffer[x] = y;
-            image.set(x, 0, color);
+void triangle(Vec3i t0, Vec3i t1, Vec3i t2, TGAImage &image, TGAColor color, int *zbuffer) {
+    if (t0.y==t1.y && t0.y==t2.y) return; // i dont care about degenerate triangles
+    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
+        Vec3i A =               t0 + (t2-t0)*alpha;
+        Vec3i 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++) {
+            float phi = B.x==A.x ? 1. : (float)(j-A.x)/(float)(B.x-A.x);
+            Vec3i P = A + (B-A)*phi;
+            P.x = j; P.y = t0.y+i; // a hack to fill holes (due to int cast precision problems)
+            int idx = j+(t0.y+i)*width;
+            if (zbuffer[idx]<P.z) {
+                zbuffer[idx] = P.z;
+                image.set(P.x, P.y, color); // attention, due to int casts t0.y+i != A.y
+            }
         }
     }
 }
 
 int main(int argc, char** argv) {
-    { // just dumping the 2d scene (yay we have enough dimensions!)
-        TGAImage scene(width, height, TGAImage::RGB);
-
-        // scene "2d mesh"
-        line(Vec2i(20, 34),   Vec2i(744, 400), scene, red);
-        line(Vec2i(120, 434), Vec2i(444, 400), scene, green);
-        line(Vec2i(330, 463), Vec2i(594, 200), scene, blue);
-
-        // screen line
-        line(Vec2i(10, 10), Vec2i(790, 10), scene, white);
+    if (2==argc) {
+        model = new Model(argv[1]);
+    } else {
+        model = new Model("obj/african_head.obj");
+    }
 
-        scene.flip_vertically(); // i want to have the origin at the left bottom corner of the image
-        scene.write_tga_file("scene.tga");
+    zbuffer = new int[width*height];
+    for (int i=0; i<width*height; i++) {
+        zbuffer[i] = std::numeric_limits<int>::min();
     }
 
-    {
-        TGAImage render(width, 16, TGAImage::RGB);
-        int ybuffer[width];
-        for (int i=0; i<width; i++) {
-            ybuffer[i] = std::numeric_limits<int>::min();
+    { // draw the model
+        TGAImage image(width, height, TGAImage::RGB);
+        for (int i=0; i<model->nfaces(); i++) {
+            std::vector<int> face = model->face(i);
+            Vec3i screen_coords[3];
+            Vec3f world_coords[3];
+            for (int j=0; j<3; j++) {
+                Vec3f v = model->vert(face[j]);
+                screen_coords[j] = Vec3i((v.x+1.)*width/2., (v.y+1.)*height/2., (v.z+1.)*depth/2.);
+                world_coords[j]  = v;
+            }
+            Vec3f n = (world_coords[2]-world_coords[0])^(world_coords[1]-world_coords[0]);
+            n.normalize();
+            float intensity = n*light_dir;
+            if (intensity>0) {
+                triangle(screen_coords[0], screen_coords[1], screen_coords[2], image, TGAColor(intensity*255, intensity*255, intensity*255, 255), zbuffer);
+            }
         }
-        rasterize(Vec2i(20, 34),   Vec2i(744, 400), render, red,   ybuffer);
-        rasterize(Vec2i(120, 434), Vec2i(444, 400), render, green, ybuffer);
-        rasterize(Vec2i(330, 463), Vec2i(594, 200), render, blue,  ybuffer);
 
-        // 1-pixel wide image is bad for eyes, lets widen it
+        image.flip_vertically(); // i want to have the origin at the left bottom corner of the image
+        image.write_tga_file("output.tga");
+    }
+
+    { // dump z-buffer (debugging purposes only)
+        TGAImage zbimage(width, height, TGAImage::GRAYSCALE);
         for (int i=0; i<width; i++) {
-            for (int j=1; j<16; j++) {
-                render.set(i, j, render.get(i, 0));
+            for (int j=0; j<height; j++) {
+                zbimage.set(i, j, TGAColor(zbuffer[i+j*width], 1));
             }
         }
-        render.flip_vertically(); // i want to have the origin at the left bottom corner of the image
-        render.write_tga_file("render.tga");
+        zbimage.flip_vertically(); // i want to have the origin at the left bottom corner of the image
+        zbimage.write_tga_file("zbuffer.tga");
     }
+    delete model;
+    delete [] zbuffer;
     return 0;
 }