main.cpp

#include <iostream>
#include <opencv2/opencv.hpp>

#include "OBJ_Loader.h"
#include "Shader.hpp"
#include "Texture.hpp"
#include "Triangle.hpp"
#include "global.hpp"
#include "rasterizer.hpp"

Eigen::Matrix4f get_view_matrix(Eigen::Vector3f eye_pos) {
  Eigen::Matrix4f view = Eigen::Matrix4f::Identity();

  Eigen::Matrix4f translate;
  translate << 1, 0, 0, -eye_pos[0], 0, 1, 0, -eye_pos[1], 0, 0, 1, -eye_pos[2],
      0, 0, 0, 1;

  view = translate * view;

  return view;
}

Eigen::Matrix4f get_model_matrix(float angle) {
  Eigen::Matrix4f rotation;
  angle = angle * MY_PI / 180.f;
  rotation << cos(angle), 0, sin(angle), 0, 0, 1, 0, 0, -sin(angle), 0,
      cos(angle), 0, 0, 0, 0, 1;

  Eigen::Matrix4f scale;
  scale << 2.5, 0, 0, 0, 0, 2.5, 0, 0, 0, 0, 2.5, 0, 0, 0, 0, 1;

  Eigen::Matrix4f translate;
  translate << 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1;

  return translate * rotation * scale;
}

// 这里的zNear和zFar表示的是距离, 而非坐标
// 参考: https://zhuanlan.zhihu.com/p/509902950
// 参考: https://zhuanlan.zhihu.com/p/464638515 => OpenGL NDS是左手系(x, y, -z)
// 引用3D图形学书上的公式, games101的推导在正投影中z没有取反
Eigen::Matrix4f get_projection_matrix(float eye_fov, float aspect_ratio,
                                      float zNear, float zFar) {
  // Students will implement this function

  Eigen::Matrix4f projection = Eigen::Matrix4f::Identity();

  // TODO: Implement this function
  // Create the projection matrix for the given parameters.
  // Then return it.

  assert(zNear > 0.0f);
  assert(zFar > 0.0f);

  // 修复中心对称问题
  // 见ppt4, 有标注

  // assert(zNear > zFar); // assert failed
  // 也就是说, 这里我们这里并不是看向-z

  float fovY = eye_fov / 180.0f * MY_PI;
  float t = std::tan(fovY) * zNear;
  float r = t * aspect_ratio;
  /*
  Eigen::Matrix4f trans;
  // fix, 因为near和far我们看作距离, 所以他们的坐标是-near和-far
  // 所以等于-1(-zNear + (-)(zFar)) / 2 = (zNear + zFar) / 2
  trans << 1, 0, 0, 0,              //
      0, 1, 0, 0,                   //
      0, 0, 1, -(zNear + zFar) / 2, //
      0, 0, 0, 1;                   //

  Eigen::Matrix4f scale;
  // 注意这里是zNear - zFar
  scale << 1 / r, 0, 0, 0,         //
      0, 1 / t, 0, 0,              //
      0, 0, 2 / (zNear - zFar), 0, //
      0, 0, 0, 1;                  //

  Eigen::Matrix4f PerspToOrtho;
  // 注意第四行的参数是-1, 我们可以带入 矩阵A*(x, y, z, 1) = (x, y, z, 1)
  // z=-n时, 第四行第三列只能是-1
  PerspToOrtho << zNear, 0, 0, 0,           //
      0, zNear, 0, 0,                       //
      0, 0, -(zNear + zFar), -zNear * zFar, //
      0, 0, -1, 0;                          //

  Eigen::Matrix4f mirror;
  mirror << 1, 0, 0, 0, //
      0, 1, 0, 0,       //
      0, 0, -1, 0,      //
      0, 0, 0, 1;       //

  projection = mirror * scale * trans * PerspToOrtho * projection;
  */

  Eigen::Matrix4f PerspToOrtho;
  Eigen::Matrix4f Ortho;
  PerspToOrtho << zNear / r, 0, 0, 0, //
      0, zNear / t, 0, 0,             //
      0, 0, -(zFar + zNear) / (zFar - zNear),
      -2 * zNear * zFar / (zFar - zNear),                         //
      0, 0, -1, 0;                                                //
  Ortho << 1, 0, 0, 0,                                            //
      0, 1, 0, 0,                                                 //
      0, 0, -2 / (zFar - zNear), -(zFar + zNear) / (zFar - zNear), //
      0, 0, 0, 1;

  Eigen::Matrix4f mirror;
  mirror << 1, 0, 0, 0, //
      0, 1, 0, 0,       //
      0, 0, -1, 0,      //
      0, 0, 0, 1;       //

  return mirror * Ortho * PerspToOrtho;
}

Eigen::Vector3f vertex_shader(const vertex_shader_payload &payload) {
  return payload.position;
}

Eigen::Vector3f normal_fragment_shader(const fragment_shader_payload &payload) {
  Eigen::Vector3f return_color = (payload.normal.head<3>().normalized() +
                                  Eigen::Vector3f(1.0f, 1.0f, 1.0f)) /
                                 2.f;
  Eigen::Vector3f result;
  result << return_color.x() * 255, return_color.y() * 255,
      return_color.z() * 255;
  return result;
}

static Eigen::Vector3f reflect(const Eigen::Vector3f &vec,
                               const Eigen::Vector3f &axis) {
  auto costheta = vec.dot(axis);
  return (2 * costheta * axis - vec).normalized();
}

struct light {
  Eigen::Vector3f position;
  Eigen::Vector3f intensity;
};

Eigen::Vector3f
texture_fragment_shader(const fragment_shader_payload &payload) {
  Eigen::Vector3f return_color = {0, 0, 0};
  if (payload.texture) {
    // TODO: Get the texture value at the texture coordinates of the current
    // fragment
    float u = payload.tex_coords[0], v = payload.tex_coords[1];
    //return_color = payload.texture->getColor(u, v);
    return_color = payload.texture->getBilinearColor(u, v);
    std::cout << "return_color:" << return_color.x() << '\t' << return_color.y() << '\t'
              << return_color.z() << '\n';
  }
  Eigen::Vector3f texture_color;
  texture_color << return_color.x(), return_color.y(), return_color.z();

  Eigen::Vector3f ka = Eigen::Vector3f(0.005, 0.005, 0.005);
  Eigen::Vector3f kd = texture_color / 255.f;
  Eigen::Vector3f ks = Eigen::Vector3f(0.7937, 0.7937, 0.7937);

  auto l1 = light{{20, 20, 20}, {500, 500, 500}};
  auto l2 = light{{-20, 20, 0}, {500, 500, 500}};

  std::vector<light> lights = {l1, l2};
  Eigen::Vector3f amb_light_intensity{10, 10, 10};
  Eigen::Vector3f eye_pos{0, 0, 10};

  float p = 150;

  // 而不是直接使用payload中的color
  Eigen::Vector3f color = texture_color;
  Eigen::Vector3f point = payload.view_pos;
  Eigen::Vector3f normal = payload.normal;

  Eigen::Vector3f result_color = {0, 0, 0};

  for (auto &light : lights) {
    // TODO: For each light source in the code, calculate what the *ambient*,
    // *diffuse*, and *specular* components are. Then, accumulate that result on
    // the *result_color* object.

    // 模型是一样的, 只是输入不一样

    Eigen::Vector3f light_dir = (light.position - point).normalized();
    float r2 = (light.position - point).dot(light.position - point);
    Eigen::Vector3f lightIntensity = light.intensity / r2;
    // 注意符号

    // 漫反射
    Eigen::Vector3f diffuse = kd.cwiseProduct(lightIntensity);
    diffuse *= std::max(0.0f, normal.dot(light_dir));

    Eigen::Vector3f view = (eye_pos - point).normalized();
    Eigen::Vector3f half_vector = (view + light_dir).normalized();

    // 高光
    Eigen::Vector3f specular = ks.cwiseProduct(lightIntensity);
    specular *= std::pow(std::max(0.0f, normal.dot(half_vector)), p);

    // 环境光
    Eigen::Vector3f ambient = ka.cwiseProduct(amb_light_intensity);

    // std::cout << diffuse.x() << '\t' << diffuse.y() << '\t' << diffuse.z()
    //           << '\n';
    // std::cout << specular.x() << '\t' << specular.y() << '\t' << specular.z()
    //           << '\n';
    // std::cout << ambient.x() << '\t' << ambient.y() << '\t' << ambient.z()
    //           << '\n';

    result_color += (diffuse + specular + ambient);
  }

  return result_color * 255.f;
}

// 默认shader
Eigen::Vector3f phong_fragment_shader(const fragment_shader_payload &payload) {
  Eigen::Vector3f ka = Eigen::Vector3f(0.005, 0.005, 0.005);
  Eigen::Vector3f kd = payload.color;
  Eigen::Vector3f ks = Eigen::Vector3f(0.7937, 0.7937, 0.7937);

  auto l1 = light{{20, 20, 20}, {500, 500, 500}};
  auto l2 = light{{-20, 20, 0}, {500, 500, 500}};

  std::vector<light> lights = {l1, l2};
  Eigen::Vector3f amb_light_intensity{10, 10, 10};
  Eigen::Vector3f eye_pos{0, 0, 10};

  float p = 150;

  Eigen::Vector3f color = payload.color;
  Eigen::Vector3f point = payload.view_pos;
  Eigen::Vector3f normal = payload.normal;

  Eigen::Vector3f result_color = {0, 0, 0};
  for (auto &light : lights) {
    // TODO: For each light source in the code, calculate what the *ambient*,
    // *diffuse*, and *specular* components are. Then, accumulate that result on
    // the *result_color* object.

    Eigen::Vector3f light_dir = (light.position - point).normalized();
    float r2 = (light.position - point).dot(light.position - point);
    Eigen::Vector3f lightIntensity = light.intensity / r2;
    // 注意符号

    // 漫反射
    Eigen::Vector3f diffuse = kd.cwiseProduct(lightIntensity);
    diffuse *= std::max(0.0f, normal.dot(light_dir));

    Eigen::Vector3f view = (eye_pos - point).normalized();
    Eigen::Vector3f half_vector = (view + light_dir).normalized();

    // 高光
    Eigen::Vector3f specular = ks.cwiseProduct(lightIntensity);
    specular *= std::pow(std::max(0.0f, normal.dot(half_vector)), p);

    // 环境光
    Eigen::Vector3f ambient = ka.cwiseProduct(amb_light_intensity);

    // std::cout << diffuse.x() << '\t' << diffuse.y() << '\t' << diffuse.z()
    //           << '\n';
    // std::cout << specular.x() << '\t' << specular.y() << '\t' << specular.z()
    //           << '\n';
    // std::cout << ambient.x() << '\t' << ambient.y() << '\t' << ambient.z()
    //           << '\n';

    result_color += (diffuse + specular + ambient);
  }

  return result_color * 255.f;
}

Eigen::Vector3f
displacement_fragment_shader(const fragment_shader_payload &payload) {

  Eigen::Vector3f ka = Eigen::Vector3f(0.005, 0.005, 0.005);
  Eigen::Vector3f kd = payload.color;
  Eigen::Vector3f ks = Eigen::Vector3f(0.7937, 0.7937, 0.7937);

  auto l1 = light{{20, 20, 20}, {500, 500, 500}};
  auto l2 = light{{-20, 20, 0}, {500, 500, 500}};

  std::vector<light> lights = {l1, l2};
  Eigen::Vector3f amb_light_intensity{10, 10, 10};
  Eigen::Vector3f eye_pos{0, 0, 10};

  float p = 150;

  Eigen::Vector3f color = payload.color;
  Eigen::Vector3f point = payload.view_pos;
  Eigen::Vector3f normal = payload.normal;

  float kh = 0.2, kn = 0.1;

  // TODO: Implement displacement mapping here
  // Let n = normal = (x, y, z)
  // Vector t = (x*y/sqrt(x*x+z*z),sqrt(x*x+z*z),z*y/sqrt(x*x+z*z))
  // Vector b = n cross product t
  // Matrix TBN = [t b n]
  // dU = kh * kn * (h(u+1/w,v)-h(u,v))
  // dV = kh * kn * (h(u,v+1/h)-h(u,v))
  // Vector ln = (-dU, -dV, 1)
  // Position p = p + kn * n * h(u,v)
  // Normal n = normalize(TBN * ln)

  Eigen::Vector3f result_color = {0, 0, 0};

  for (auto &light : lights) {
    // TODO: For each light source in the code, calculate what the *ambient*,
    // *diffuse*, and *specular* components are. Then, accumulate that result on
    // the *result_color* object.
  }

  return result_color * 255.f;
}

Eigen::Vector3f bump_fragment_shader(const fragment_shader_payload &payload) {

  Eigen::Vector3f ka = Eigen::Vector3f(0.005, 0.005, 0.005);
  Eigen::Vector3f kd = payload.color;
  Eigen::Vector3f ks = Eigen::Vector3f(0.7937, 0.7937, 0.7937);

  auto l1 = light{{20, 20, 20}, {500, 500, 500}};
  auto l2 = light{{-20, 20, 0}, {500, 500, 500}};

  std::vector<light> lights = {l1, l2};
  Eigen::Vector3f amb_light_intensity{10, 10, 10};
  Eigen::Vector3f eye_pos{0, 0, 10};

  float p = 150;

  Eigen::Vector3f color = payload.color;
  Eigen::Vector3f point = payload.view_pos;
  Eigen::Vector3f normal = payload.normal;

  float kh = 0.2, kn = 0.1;

  // TODO: Implement bump mapping here
  // Let n = normal = (x, y, z)
  // Vector t = (x*y/sqrt(x*x+z*z),sqrt(x*x+z*z),z*y/sqrt(x*x+z*z))
  // Vector b = n cross product t
  // Matrix TBN = [t b n]
  // dU = kh * kn * (h(u+1/w,v)-h(u,v))
  // dV = kh * kn * (h(u,v+1/h)-h(u,v))
  // Vector ln = (-dU, -dV, 1)
  // Normal n = normalize(TBN * ln)

  Eigen::Vector3f result_color = {0, 0, 0};
  result_color = normal;

  return result_color * 255.f;
}

int main(int argc, const char **argv) {
  std::vector<Triangle *> TriangleList;

  float angle = 140.0;
  bool command_line = false;

  std::string filename = "output.png";
  objl::Loader Loader;
  //std::string obj_path = "../models/spot/";
  // 避免bug使用绝对路径
  std::string obj_path = "/home/er1c/code/games101_homework/Homework3/Assignment3/models/spot/";

  // Load .obj File
  bool loadout = Loader.LoadFile(obj_path + "spot_triangulated_good.obj");
  for (auto mesh : Loader.LoadedMeshes) {
    for (int i = 0; i < mesh.Vertices.size(); i += 3) {
      Triangle *t = new Triangle();
      for (int j = 0; j < 3; j++) {
        t->setVertex(j, Vector4f(mesh.Vertices[i + j].Position.X,
                                 mesh.Vertices[i + j].Position.Y,
                                 mesh.Vertices[i + j].Position.Z, 1.0));
        t->setNormal(j, Vector3f(mesh.Vertices[i + j].Normal.X,
                                 mesh.Vertices[i + j].Normal.Y,
                                 mesh.Vertices[i + j].Normal.Z));
        t->setTexCoord(j, Vector2f(mesh.Vertices[i + j].TextureCoordinate.X,
                                   mesh.Vertices[i + j].TextureCoordinate.Y));
      }
      TriangleList.push_back(t);
    }
  }

  rst::rasterizer r(700, 700);

  auto texture_path = "hmap.jpg";
  r.set_texture(Texture(obj_path + texture_path));

  // fragment_shader_payload是一个结构体(包括view pos、颜色、法线、texture
  // coordinate、和texture信息)
  std::function<Eigen::Vector3f(fragment_shader_payload)> active_shader =
      phong_fragment_shader;

  if (argc >= 2) {
    command_line = true;
    filename = std::string(argv[1]);

    if (argc == 3 && std::string(argv[2]) == "texture") {
      std::cout << "Rasterizing using the texture shader\n";
      active_shader = texture_fragment_shader;
      texture_path = "spot_texture.png";
      r.set_texture(Texture(obj_path + texture_path));
    } else if (argc == 3 && std::string(argv[2]) == "normal") {
      std::cout << "Rasterizing using the normal shader\n";
      active_shader = normal_fragment_shader;
    } else if (argc == 3 && std::string(argv[2]) == "phong") {
      std::cout << "Rasterizing using the phong shader\n";
      active_shader = phong_fragment_shader;
    } else if (argc == 3 && std::string(argv[2]) == "bump") {
      std::cout << "Rasterizing using the bump shader\n";
      active_shader = bump_fragment_shader;
    } else if (argc == 3 && std::string(argv[2]) == "displacement") {
      std::cout << "Rasterizing using the bump shader\n";
      active_shader = displacement_fragment_shader;
    }
  }

  Eigen::Vector3f eye_pos = {0, 0, 10};

  r.set_vertex_shader(vertex_shader);
  // 其实就是一个shader function.
  r.set_fragment_shader(active_shader);

  int key = 0;
  int frame_count = 0;

  if (command_line) {
    r.clear(rst::Buffers::Color | rst::Buffers::Depth);
    r.set_model(get_model_matrix(angle));
    r.set_view(get_view_matrix(eye_pos));
    r.set_projection(get_projection_matrix(45.0, 1, 0.1, 50));

    r.draw(TriangleList);
    cv::Mat image(700, 700, CV_32FC3, r.frame_buffer().data());
    image.convertTo(image, CV_8UC3, 1.0f);
    cv::cvtColor(image, image, cv::COLOR_RGB2BGR);

    cv::imwrite(filename, image);

    return 0;
  }

  while (key != 27) {
    r.clear(rst::Buffers::Color | rst::Buffers::Depth);

    r.set_model(get_model_matrix(angle));
    r.set_view(get_view_matrix(eye_pos));
    r.set_projection(get_projection_matrix(45.0, 1, 0.1, 50));

    // r.draw(pos_id, ind_id, col_id, rst::Primitive::Triangle);
    r.draw(TriangleList);
    cv::Mat image(700, 700, CV_32FC3, r.frame_buffer().data());
    image.convertTo(image, CV_8UC3, 1.0f);
    cv::cvtColor(image, image, cv::COLOR_RGB2BGR);

    cv::imshow("image", image);
    cv::imwrite(filename, image);
    key = cv::waitKey(10);

    if (key == 'a') {
      angle -= 0.1;
    } else if (key == 'd') {
      angle += 0.1;
    }
  }
  return 0;
}