main.cpp

Go to the documentation of this file.

/**
 *\file         main.cpp
 *
 *\brief        
 *
 *\author       Xianming Chen
 *
 */

#include "Canvas.h"
#include "color.h"
#include "xmath.h"
#include "TriangleMesh.h"
#include "Sphere.h"

#include <iostream>
#include <sstream>
#include <iomanip>


using namespace columbia;

/* 
 * Given the material color, light color, and the normal and lighting direction, return the diffuse color.
 * If the normal == 0, then no light computation is done, and the material_col is simply returned.
 */
inline RGB compute_lighting(RGB const& material_col, RGB const& light_col, Vector const& light_dir, Vector* normal=0)
{
  if(normal)
  {
    float pro = normal->x * light_dir.x + normal->y * light_dir.y + normal->z * light_dir.z;
    if(pro < 0)
      return Black;

    return 
      (material_col * light_col) * 
      ( (pro / (sqrt(normal->x * normal->x + normal->y * normal->y + normal->z * normal->z) *
                sqrt(light_dir.x * light_dir.x + light_dir.y * light_dir.y + light_dir.z * light_dir.z) )) );
  }
  return material_col;
}


int main1(int argc, char** argv) 
{
  bool draw_wireframe = false;
  if(argc > 2)
    draw_wireframe = (argv[2][0]=='w');
  float scale_factor = 0.15;
  if(argc > 3)
    scale_factor *= argv[3][0] - '0';
  
  try 
  {
    Canvas teximage;
    teximage.Checkerboard();
    teximage.WritePPM("c.ppm");
    teximage.ReadPPM("c.ppm");
    teximage.WritePPM("c2.ppm");
    
    teximage.ReadPPM("o.ppm");
    teximage.WritePPM("o2.ppm");
    //    exit(0);
    
    
    Canvas canvas;
    //    canvas.Clear(Green);
    
    canvas.SetTextureImage(&teximage);
    canvas.filename = "t.ppm";

    //     TriangleMesh msh;
    //     ParametrizeSphere(msh, 32, 64);
    //     cout << msh ;
    //     exit(0);
    
    TriangleMesh msh(argc > 1? argv[1] : "hellskull.obj");

    Vector translate = - msh.bbox.center;
    
    float scale_x = canvas.hReso / (msh.bbox.max.x - msh.bbox.min.x) ;
    float scale_y = canvas.vReso / (msh.bbox.max.y - msh.bbox.min.y) ;
    float scale = std :: min (scale_x, scale_y) * scale_factor;
    float z_range = msh.bbox.max.z - msh.bbox.min.z;
    
    RGB material_col = Firebrick;   //White;//
    RGB light_col1 = White;
    RGB light_col2 = White * .0;
    
    Vector light_dir1(.0, 0, 1); //cos(pi/6), 0,sin(pi/6));
    //    Vector light_dir2(-1, 0, -.3); //cos(pi/6), 0,sin(pi/6));

    for(int f = 0; f < msh.total_triangles; ++f)
    {
      int i = msh.F[f].i, j = msh.F[f].j, k = msh.F[f].k;
      int ni = msh.F[f].ni, nj = msh.F[f].nj, nk = msh.F[f].nk;
      int ti = msh.F[f].ti, tj = msh.F[f].tj, tk = msh.F[f].tk;

      static Point texI, texJ, texK;
      static RGB colI, colJ, colK;
      Point *texi = 0, *texj = 0, *texk = 0;
      RGB *coli = 0, *colj = 0, *colk = 0;
      
      if(! msh.has_normal  && (! (msh.has_texture=0) || draw_wireframe) )
      {
        colI = material_col * ( (msh.V[i].z - msh.bbox.min.z) / z_range );
        colJ = material_col * ( (msh.V[j].z - msh.bbox.min.z) / z_range );
        colK = material_col * ( (msh.V[k].z - msh.bbox.min.z) / z_range );
        coli = &colI, colj = &colJ, colk = &colK;
      }
      else 
      {
        if(msh.has_normal)
        {
          colI = compute_lighting(material_col, light_col1, light_dir1, &msh.N[ni]);
          colJ = compute_lighting(material_col, light_col1, light_dir1, &msh.N[nj]);
          colK = compute_lighting(material_col, light_col1, light_dir1, &msh.N[nk]);
          coli = &colI, colj = &colJ, colk = &colK;
        }
        if(! draw_wireframe && msh.has_texture)
        {
          texI = msh.T[ti], texJ = msh.T[tj], texK = msh.T[tk];
          texi = &texI, texj = &texJ, texk = &texK;
        }
      }
      
      if(draw_wireframe)
        canvas.WireTriangle( (msh.V[i] + translate) * scale, *coli, 
                             (msh.V[j] + translate) * scale, *colj, 
                             (msh.V[k] + translate) * scale, *colk);
      else
      {
        canvas.SolidTriangle( (msh.V[i] + translate) * scale, texi, coli, 
                              (msh.V[j] + translate) * scale, texj, colj, 
                              (msh.V[k] + translate) * scale, texk, colk);
      }
    }
    
    canvas.WritePPM();
  }
    
  catch(char const* msg) 
  { 
    std :: cerr << msg << std :: endl; 
  }
  
  
  return 0;
}
  

---