GAMES101 Lecture Notes

uniform sampler2D myTexture;
uniform vec3 lightDir; 
varying vec2 uv; 
varying vec3 norm;

void diffuseShader() { 
  vec3 kd; 
  kd = texture2d(myTexture, uv); 
  kd *= clamp(dot(–lightDir, norm), 0.0, 1.0); 
  gl_FragColor = vec4(kd, 1.0); 
}

#include<cmath>
#include<Eigen/Core>
#include<Eigen/Dense>
#include<iostream>


int main(){

    float pi = std::acos(-1);
    float alpha = 45.0f / 180.0 * pi;

    Eigen::Vector3f p(2.0f, 1.0f, 1.0f);
    Eigen::Matrix3f R;
    R << std::cos(alpha), -std::sin(alpha), 0.0, 
         std::sin(alpha), std::cos(alpha), 0.0, 
         0.0, 0.0, 1.0;
    Eigen::Matrix3f T;
    T << 1.0f, 0.0f, 1.0f,
         0.0f, 1.0f, 2.0f,
         0.0f, 0.0f, 1.0f;
    Eigen::Vector3f res = T * R * p;
    std::cout << res << std::endl;

    // result is 1.70711, 4.12132, 1
    return 0;
}

/* main.cpp */
Eigen::Matrix4f get_model_matrix(float rotation_angle)
{
    Eigen::Matrix4f model = Eigen::Matrix4f::Identity();

    // Create the model matrix for rotating the triangle around the Z axis.
    // Then return it.

    model(0, 0) = cos(rotation_angle * 180 / MY_PI);
    model(0, 1) = -sin(rotation_angle * 180 / MY_PI);
    model(1, 0) = sin(rotation_angle * 180 / MY_PI);
    model(1, 1) = cos(rotation_angle * 180 / MY_PI);

    return model;
}

Eigen::Matrix4f get_projection_matrix(float eye_fov, float aspect_ratio,
                                      float zNear, float zFar)
{
    Eigen::Matrix4f projection = Eigen::Matrix4f::Identity();

    // Create the projection matrix for the given parameters.
    // Then return it.
    float top = tanf(eye_fov / 2.0f) * zNear;
    float bottom = -top;
    float right = top * aspect_ratio;
    float left = -right;

    projection(0, 0) = zNear / right;
    projection(1, 1) = zNear / top;
    projection(2, 2) = (zNear + zFar) / (zNear - zFar);
    projection(2, 3) = (2 * zNear * zFar) / (zNear - zFar);
    projection(3, 2) = -1.0f;
    return projection;
}

//Screen space rasterization
void rst::rasterizer::rasterize_triangle(const Triangle& t) {
    auto v = t.toVector4();

    // Find out the bounding box of current triangle.
    float x_min, y_min, x_max, y_max;
    x_min = y_min = std::max(width, height) + 1;
    x_max = y_max = -1;
    for (int i = 0; i < 3; i++) {
        Vector4f vertice = v[i];
        x_min = std::min(x_min, vertice.x());
        y_min = std::min(y_min, vertice.y());
        x_max = std::max(x_max, vertice.x());
        y_max = std::max(y_max, vertice.y());
    }
    // iterate through the pixel and find if the current pixel is inside the triangle
    for (int i = (int) x_min; i <= (int) x_max; i++) {
        for (int j = (int) y_min; j <= (int) y_max; j++) {
            if (insideTriangle(i, j, t.v)) {
                int idx = get_index(i, j);
                // get the interpolated z value
                auto[alpha, beta, gamma] = computeBarycentric2D(i + 0.5, j + 0.5, t.v);
                float w_reciprocal = 1.0/(alpha / v[0].w() + beta / v[1].w() + gamma / v[2].w());
                float z_interpolated = alpha * v[0].z() / v[0].w() + beta * v[1].z() / v[1].w() + gamma * v[2].z() / v[2].w();
                z_interpolated *= w_reciprocal;

                if (z_interpolated < depth_buf[idx]) {
                    depth_buf[idx] = z_interpolated;
                    // set the current pixel to the color of the triangle if it should be painted.
                    set_pixel(Vector3f(i, j, 0.0), t.getColor());
                }
            }
        }
    }
}

static bool insideTriangle(int x, int y, const Vector3f* _v)
{   
    float x_pos = x + 0.5f;
    float y_pos = y + 0.5f;
    Vector3f QP0 = Vector3f(_v[0].x() - x_pos, _v[0].y() - y_pos, 0.0);
    Vector3f QP1 = Vector3f(_v[1].x() - x_pos, _v[1].y() - y_pos, 0.0);
    Vector3f QP2 = Vector3f(_v[2].x() - x_pos, _v[2].y() - y_pos, 0.0);
    Vector3f P0P1 = Vector3f(_v[1].x() - _v[0].x(), _v[1].y() - _v[0].y(), 0.0);
    Vector3f P1P2 = Vector3f(_v[2].x() - _v[1].x(), _v[2].y() - _v[1].y(), 0.0);
    Vector3f P2P0 = Vector3f(_v[0].x() - _v[2].x(), _v[0].y() - _v[2].y(), 0.0);
    float res1 = QP0.cross(P0P1).z();
    float res2 = QP1.cross(P1P2).z();
    float res3 = QP2.cross(P2P0).z();
    return (res1 >= 0.0 && res2 >= 0.0 && res3 >= 0.0) || (res1 <= 0.0 && res2 <= 0.0 && res3 <= 0.0);
}

//Screen space rasterization
void rst::rasterizer::rasterize_triangle(const Triangle& t, const std::array<Eigen::Vector3f, 3>& view_pos) 
{
    auto v = t.toVector4();

    // Find out the bounding box of current triangle.
    float x_min, y_min, x_max, y_max;
    x_min = y_min = std::max(width, height) + 1;
    x_max = y_max = -1;
    for (int i = 0; i < 3; i++) {
        Vector4f vertice = v[i];
        x_min = std::min(x_min, vertice.x());
        y_min = std::min(y_min, vertice.y());
        x_max = std::max(x_max, vertice.x());
        y_max = std::max(y_max, vertice.y());
    }
    // iterate through the pixel and find if the current pixel is inside the triangle
    for (int i = (int) x_min; i <= (int) x_max; i++) {
        for (int j = (int) y_min; j <= (int) y_max; j++) {
            if (insideTriangle(i, j, t.v)) {
                int idx = get_index(i, j);
                // get the interpolated z value
                auto[alpha, beta, gamma] = computeBarycentric2D(i + 0.5, j + 0.5, t.v);
                //   * v[i].w() is the vertex view space depth value z.
                //   * Z is interpolated view space depth for the current pixel
                //   * zp is depth between zNear and zFar, used for z-buffer

                // projection interpolation adjust
                float Z = 1.0 / (alpha / v[0].w() + beta / v[1].w() + gamma / v[2].w());
                float zp = alpha * v[0].z() / v[0].w() + beta * v[1].z() / v[1].w() + gamma * v[2].z() / v[2].w();
                zp *= Z;

                if (zp < depth_buf[idx]) {
                    depth_buf[idx] = zp;
                    // interpolate the attributes for shader
                    Vector3f interpolated_color = interpolate(alpha, beta, gamma, t.color[0], t.color[1], t.color[2], 1.0);
                    Vector3f interpolated_normal = interpolate(alpha, beta, gamma, t.normal[0], t.normal[1], t.normal[2], 1.0);
                    Vector2f interpolated_texcoords = interpolate(alpha, beta, gamma, t.tex_coords[0], t.tex_coords[1], t.tex_coords[2], 1.0);
                    // shading coords is to find the corresponding position of the shading point in the real world space in order to be used in the blinn-phong model
                    Vector3f interpolated_shadingcoords = interpolate(alpha, beta, gamma, view_pos[0], view_pos[1], view_pos[2], 1.0);

                    // generate a shader payload
                    auto payload = fragment_shader_payload(interpolated_color, interpolated_normal.normalized(), interpolated_texcoords, texture ? &*texture : nullptr);
                    payload.view_pos = interpolated_shadingcoords;
                    auto pixel_color = fragment_shader(payload);
                    set_pixel(Vector2i(i, j), pixel_color);
                }   
            }
        }
    }
}

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)
    {
        // parameters to use
        Vector3f l = (light.position - point).normalized();
        Vector3f v = (eye_pos - point).normalized();
        Vector3f h = (v + l).normalized();
        float r_square = (light.position - point).dot(light.position - point);

        // ambient light
        Vector3f ambient = ka.cwiseProduct(amb_light_intensity);
        
        // diffusion light
        Vector3f diffusion = kd.cwiseProduct(light.intensity / r_square) * std::max(0.0f, normal.normalized().dot(l.normalized()));
        
        // specular light
        Vector3f specular = ks.cwiseProduct(light.intensity / r_square) * pow((std::max(0.0f, normal.normalized().dot(h))), p);
        
        result_color += (ambient + diffusion + specular);
    }

    return result_color * 255.f;
}

Eigen::Vector3f texture_fragment_shader(const fragment_shader_payload& payload)
{
    Eigen::Vector3f return_color = {0, 0, 0};
    if (payload.texture)
    {
        // Get the texture value at the texture coordinates of the current fragment
        return_color = payload.texture->getColor(payload.tex_coords.x(), payload.tex_coords.y());
    }
    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;

    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)
    {
        // parameters to use
        Vector3f l = (light.position - point).normalized();
        Vector3f v = (eye_pos - point).normalized();
        Vector3f h = (v + l).normalized();
        float r_square = (light.position - point).dot(light.position - point);

        // ambient light
        Vector3f ambient = ka.cwiseProduct(amb_light_intensity);
        
        // diffusion light
        Vector3f diffusion = kd.cwiseProduct(light.intensity / r_square) * std::max(0.0f, normal.normalized().dot(l.normalized()));
        
        // specular light
        Vector3f specular = ks.cwiseProduct(light.intensity / r_square) * pow((std::max(0.0f, normal.normalized().dot(h))), p);
        
        result_color += (ambient + diffusion + specular);
    }

    return result_color * 255.f;
}

Eigen::Vector3f getColor(float u, float v)
    {
  			// add this line
        if (u <= 0 || u >= 1 || v <= 0 || v >= 1) {
            return Eigen::Vector3f(0, 0, 0);
        }
        auto u_img = u * width;
        auto v_img = (1 - v) * height;
        auto color = image_data.at<cv::Vec3b>(v_img, u_img);
        return Eigen::Vector3f(color[0], color[1], color[2]);
    }

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;

    // Implement bump mapping
    // Let n = normal = (x, y, z)
    Vector3f n = normal;
    Vector3f t = Vector3f(n.x() * n.y() / std::sqrt(n.x() * n.x() + n.z() * n.z()), std::sqrt(n.x() * n.x() + n.z() * n.z()), n.z() * n.y() / std::sqrt(n.x() * n.x() + n.z() * n.z()));
    Vector3f b = n.cross(t);
    Matrix3f TBN;
    TBN << t.x(), b.x(), normal.x(),
           t.y(), b.y(), normal.y(),
           t.z(), b.z(), normal.z();

    float u = payload.tex_coords.x();
    float v = payload.tex_coords.y();
    float w = payload.texture->width;
    float h = payload.texture->height;
    float dU = kh * kn * (payload.texture->getColor(u + 1.0 / w, v) .norm() - payload.texture->getColor(u, v).norm());
    float dV = kh * kn * (payload.texture->getColor(u, v + 1.0 / h).norm() - payload.texture->getColor(u, v).norm());
    Vector3f ln = Vector3f(-dU, -dV, 1.0f);
    n = (TBN * ln).normalized();

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

    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
    Vector3f n = normal;
    Vector3f t = Vector3f(n.x() * n.y() / std::sqrt(n.x() * n.x() + n.z() * n.z()), std::sqrt(n.x() * n.x() + n.z() * n.z()), n.z() * n.y() / std::sqrt(n.x() * n.x() + n.z() * n.z()));
    Vector3f b = n.cross(t);
    Matrix3f TBN;
    TBN << t.x(), b.x(), normal.x(),
           t.y(), b.y(), normal.y(),
           t.z(), b.z(), normal.z();

    float u = payload.tex_coords.x();
    float v = payload.tex_coords.y();
    float w = payload.texture->width;
    float h = payload.texture->height;
    float dU = kh * kn * (payload.texture->getColor(u + 1.0 / w, v) .norm() - payload.texture->getColor(u, v).norm());
    float dV = kh * kn * (payload.texture->getColor(u, v + 1.0 / h).norm() - payload.texture->getColor(u, v).norm());
    Vector3f ln = Vector3f(-dU, -dV, 1.0f);
    n = (TBN * ln).normalized();
  	// change position of point according to the displacement map
    point += kn * n * payload.texture->getColor(u, v).norm();

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

    for (auto& light : lights)
    {
        // parameters to use
        Vector3f l = (light.position - point).normalized();
        Vector3f v = (eye_pos - point).normalized();
        Vector3f h = (v + l).normalized();
        float r_square = (light.position - point).dot(light.position - point);

        // ambient light
        Vector3f ambient = ka.cwiseProduct(amb_light_intensity);
        
        // diffusion light
        Vector3f diffusion = kd.cwiseProduct(light.intensity / r_square) * std::max(0.0f, normal.normalized().dot(l.normalized()));
        
        // specular light
        Vector3f specular = ks.cwiseProduct(light.intensity / r_square) * pow((std::max(0.0f, normal.normalized().dot(h))), p);
        
        result_color += (ambient + diffusion + specular);
    }

    return result_color * 255.f;
}